diff --git a/tests/AbstractLoopTest.php b/tests/AbstractLoopTest.php
index f07f6877..296bdc7e 100644
--- a/tests/AbstractLoopTest.php
+++ b/tests/AbstractLoopTest.php
@@ -262,6 +262,8 @@ public function testRemoveInvalid()
         // remove a valid stream from the event loop that was never added in the first place
         $this->loop->removeReadStream($stream);
         $this->loop->removeWriteStream($stream);
+
+        $this->assertTrue(true);
     }
 
     /** @test */
diff --git a/tests/Timer/AbstractTimerTest.php b/tests/Timer/AbstractTimerTest.php
index 28c7a421..15202e41 100644
--- a/tests/Timer/AbstractTimerTest.php
+++ b/tests/Timer/AbstractTimerTest.php
@@ -8,69 +8,103 @@ abstract class AbstractTimerTest extends TestCase
 {
     abstract public function createLoop();
 
-    public function testAddTimer()
+    public function testAddTimerReturnsNonPeriodicTimerInstance()
     {
-        // usleep is intentionally high
+        $loop = $this->createLoop();
+
+        $timer = $loop->addTimer(0.001, $this->expectCallableNever());
+
+        $this->assertInstanceOf('React\EventLoop\TimerInterface', $timer);
+        $this->assertFalse($timer->isPeriodic());
+    }
 
+    public function testAddTimerWillBeInvokedOnceAndBlocksLoopWhenRunning()
+    {
         $loop = $this->createLoop();
 
         $loop->addTimer(0.001, $this->expectCallableOnce());
-        usleep(1000);
-        $this->tickLoop($loop);
+
+        $start = microtime(true);
+        $loop->run();
+        $end = microtime(true);
+
+        // make no strict assumptions about actual time interval.
+        // must be at least 0.001s (1ms) and should not take longer than 0.1s
+        $this->assertGreaterThanOrEqual(0.001, $end - $start);
+        $this->assertLessThan(0.1, $end - $start);
     }
 
-    public function testAddPeriodicTimer()
+    public function testAddPeriodicTimerReturnsPeriodicTimerInstance()
     {
         $loop = $this->createLoop();
 
-        $loop->addPeriodicTimer(0.001, $this->expectCallableExactly(3));
-        usleep(1000);
-        $this->tickLoop($loop);
-        usleep(1000);
-        $this->tickLoop($loop);
-        usleep(1000);
-        $this->tickLoop($loop);
+        $periodic = $loop->addPeriodicTimer(0.1, $this->expectCallableNever());
+
+        $this->assertInstanceOf('React\EventLoop\TimerInterface', $periodic);
+        $this->assertTrue($periodic->isPeriodic());
     }
 
-    public function testAddPeriodicTimerWithCancel()
+    public function testAddPeriodicTimerWillBeInvokedUntilItIsCancelled()
     {
         $loop = $this->createLoop();
 
-        $timer = $loop->addPeriodicTimer(0.001, $this->expectCallableExactly(2));
-
-        usleep(1000);
-        $this->tickLoop($loop);
-        usleep(1000);
-        $this->tickLoop($loop);
+        $periodic = $loop->addPeriodicTimer(0.1, $this->expectCallableExactly(3));
 
-        $loop->cancelTimer($timer);
+        // make no strict assumptions about actual time interval.
+        // leave some room to ensure this ticks exactly 3 times.
+        $loop->addTimer(0.399, function () use ($loop, $periodic) {
+            $loop->cancelTimer($periodic);
+        });
 
-        usleep(1000);
-        $this->tickLoop($loop);
+        $loop->run();
     }
 
-    public function testAddPeriodicTimerCancelsItself()
+    public function testAddPeriodicTimerWillBeInvokedWithMaximumAccuracyUntilItIsCancelled()
     {
+        $loop = $this->createLoop();
+
         $i = 0;
+        $periodic = $loop->addPeriodicTimer(0.001, function () use (&$i) {
+            ++$i;
+        });
+
+        $loop->addTimer(0.02, function () use ($loop, $periodic) {
+            $loop->cancelTimer($periodic);
+        });
+
+        $loop->run();
 
+        // make no strict assumptions about number of invocations.
+        // we know it must be no more than 20 times and should at least be
+        // invoked twice for really slow loops
+        $this->assertLessThanOrEqual(20, $i);
+        $this->assertGreaterThan(2, $i);
+    }
+
+    public function testAddPeriodicTimerCancelsItself()
+    {
         $loop = $this->createLoop();
 
+        $i = 0;
         $loop->addPeriodicTimer(0.001, function ($timer) use (&$i, $loop) {
             $i++;
 
-            if ($i == 2) {
+            if ($i === 5) {
                 $loop->cancelTimer($timer);
             }
         });
 
-        usleep(1000);
-        $this->tickLoop($loop);
-        usleep(1000);
-        $this->tickLoop($loop);
-        usleep(1000);
-        $this->tickLoop($loop);
+        $start = microtime(true);
+        $loop->run();
+        $end = microtime(true);
+
+        $this->assertEquals(5, $i);
 
-        $this->assertSame(2, $i);
+        // make no strict assumptions about time interval.
+        // 5 invocations must take at least 0.005s (5ms) and should not take
+        // longer than 0.1s for slower loops.
+        $this->assertGreaterThanOrEqual(0.005, $end - $start);
+        $this->assertLessThan(0.1, $end - $start);
     }
 
     public function testMinimumIntervalOneMicrosecond()
diff --git a/tests/Timer/TimersTest.php b/tests/Timer/TimersTest.php
index c70a39cd..a2cb134b 100644
--- a/tests/Timer/TimersTest.php
+++ b/tests/Timer/TimersTest.php
@@ -25,5 +25,7 @@ public function testBlockedTimer()
         }));
 
         $timers->tick();
+
+        $this->assertTrue(true);
     }
 }