Split up test cases into individual files

Author: clue

tests/BlockerTest.php

@@ -0,0 +1,49 @@
+<?php
+
+class FunctionAwaitAllTest extends TestCase
+{
+    public function testAwaitAllEmpty()
+    {
+        $this->assertEquals(array(), $this->block->awaitAll(array()));
+    }
+
+    public function testAwaitAllAllResolved()
+    {
+        $all = array(
+            'first' => $this->createPromiseResolved(1),
+            'second' => $this->createPromiseResolved(2)
+        );
+
+        $this->assertEquals(array('first' => 1, 'second' => 2), $this->block->awaitAll($all));
+    }
+
+    public function testAwaitAllRejected()
+    {
+        $all = array(
+            $this->createPromiseResolved(1),
+            $this->createPromiseRejected(new Exception('test'))
+        );
+
+        $this->setExpectedException('Exception', 'test');
+        $this->block->awaitAll($all);
+    }
+
+    public function testAwaitAllOnlyRejected()
+    {
+        $all = array(
+            $this->createPromiseRejected(new Exception('first')),
+            $this->createPromiseRejected(new Exception('second'))
+        );
+
+        $this->setExpectedException('Exception', 'first');
+        $this->block->awaitAll($all);
+    }
+
+    public function testAwaitAllInterrupted()
+    {
+        $promise = $this->createPromiseResolved(2, 0.02);
+        $this->createTimerInterrupt(0.01);
+
+        $this->assertEquals(array(2), $this->block->awaitAll(array($promise)));
+    }
+}

tests/FunctionAwaitAllTest.php

@@ -0,0 +1,65 @@
+<?php
+
+use React\Promise\Deferred;
+
+class FunctionAwaitAnyTest extends TestCase
+{
+    /**
+     * @expectedException UnderflowException
+     */
+    public function testAwaitAnyEmpty()
+    {
+        $this->block->awaitAny(array());
+    }
+
+    public function testAwaitAnyFirstResolved()
+    {
+        $all = array(
+            $this->createPromiseRejected(1),
+            $this->createPromiseResolved(2, 0.01),
+            $this->createPromiseResolved(3, 0.02)
+        );
+
+        $this->assertEquals(2, $this->block->awaitAny($all));
+    }
+
+    public function testAwaitAnyFirstResolvedConcurrently()
+    {
+        $d1 = new Deferred();
+        $d2 = new Deferred();
+        $d3 = new Deferred();
+
+        $this->loop->addTimer(0.01, function() use ($d1, $d2, $d3) {
+            $d1->reject(1);
+            $d2->resolve(2);
+            $d3->resolve(3);
+        });
+
+        $all = array(
+            $d1->promise(),
+            $d2->promise(),
+            $d3->promise()
+        );
+
+        $this->assertEquals(2, $this->block->awaitAny($all));
+    }
+
+    public function testAwaitAnyAllRejected()
+    {
+        $all = array(
+            $this->createPromiseRejected(1),
+            $this->createPromiseRejected(2)
+        );
+
+        $this->setExpectedException('UnderflowException');
+        $this->block->awaitAny($all);
+    }
+
+    public function testAwaitAnyInterrupted()
+    {
+        $promise = $this->createPromiseResolved(2, 0.02);
+        $this->createTimerInterrupt(0.01);
+
+        $this->assertEquals(2, $this->block->awaitAny(array($promise)));
+    }
+}

tests/FunctionAwaitAnyTest.php

@@ -0,0 +1 @@
+<?php

tests/FunctionAwaitRaceTest_.php

@@ -0,0 +1,27 @@
+<?php
+
+class FunctionAwaitTest extends TestCase
+{
+    public function testAwaitOneRejected()
+    {
+        $promise = $this->createPromiseRejected(new Exception('test'));
+
+        $this->setExpectedException('Exception', 'test');
+        $this->block->await($promise);
+    }
+
+    public function testAwaitOneResolved()
+    {
+        $promise = $this->createPromiseResolved(2);
+
+        $this->assertEquals(2, $this->block->await($promise));
+    }
+
+    public function testAwaitOneInterrupted()
+    {
+        $promise = $this->createPromiseResolved(2, 0.02);
+        $this->createTimerInterrupt(0.01);
+
+        $this->assertEquals(2, $this->block->await($promise));
+    }
+}

tests/FunctionAwaitTest.php

@@ -0,0 +1,13 @@
+<?php
+
+class FunctionSleepTest extends TestCase
+{
+    public function testSleep()
+    {
+        $time = microtime(true);
+        $this->block->sleep(0.2);
+        $time = microtime(true) - $time;
+
+        $this->assertEquals(0.2, $time, '', 0.1);
+    }
+}

tests/FunctionSleepTest.php

@@ -1,9 +1,50 @@
 <?php
 
+use Clue\React\Block\Blocker;
+use React\Promise\Deferred;
+
 require_once __DIR__ . '/../vendor/autoload.php';
 
 error_reporting(-1);
 
 class TestCase extends PHPUnit_Framework_TestCase
 {
+    protected $loop;
+    protected $block;
+
+    public function setUp()
+    {
+        $this->loop = React\EventLoop\Factory::create();
+        $this->block = new Blocker($this->loop);
+    }
+
+    protected function createPromiseResolved($value = null, $delay = 0.01)
+    {
+        $deferred = new Deferred();
+
+        $this->loop->addTimer($delay, function () use ($deferred, $value) {
+            $deferred->resolve($value);
+        });
+
+            return $deferred->promise();
+    }
+
+    protected function createPromiseRejected($value = null, $delay = 0.01)
+    {
+        $deferred = new Deferred();
+
+        $this->loop->addTimer($delay, function () use ($deferred, $value) {
+            $deferred->reject($value);
+        });
+
+            return $deferred->promise();
+    }
+
+    protected function createTimerInterrupt($delay = 0.01)
+    {
+        $loop = $this->loop;
+        $loop->addTimer($delay, function () use ($loop) {
+            $loop->stop();
+        });
+    }
 }