TestControl

 val program = for {
   first <- IO.realTime   // IO.monotonic also works
   _ <- IO.println("it is currently " + first)

   _ <- IO.sleep(100.milis)
   second <- IO.realTime
   _ <- IO.println("we slept and now it is " + second)

   _ <- IO.sleep(1.hour).timeout(1.minute)
   third <- IO.realTime
   _ <- IO.println("we slept a second time and now it is " + third)
 } yield ()

 TestControl.execute(program) flatMap { control =>
   for {
     first <- control.results
     _ <- IO(assert(first == None))   // we haven't finished yet

     _ <- control.tick
     // at this point, the "it is currently ..." line will have printed

     next1 <- control.nextInterval
     _ <- IO(assert(next1 == 100.millis))

     _ <- control.advance(100.millis)
     // nothing has happened yet!
     _ <- control.tick
     // now the "we slept and now it is ..." line will have printed

     second <- control.results
     _ <- IO(assert(second == None))  // we're still not done yet

     next2 <- control.nextInterval
     _ <- IO(assert(next2 == 1.minute))   // we need to wait one minute for our next task, since we will hit the timeout

     _ <- control.advance(15.seconds)
     _ <- control.tick
     // nothing happens!

     next3 <- control.nextInterval
     _ <- IO(assert(next3 == 45.seconds))   // haven't gone far enough to hit the timeout

     _ <- control.advanceAndTick(45.seconds)
     // at this point, nothing will print because we hit the timeout exception!

     third <- control.results

     _ <- IO {
       assert(third.isDefined)
       assert(third.get.isError)   // an exception, not a value!
       assert(third.get.fold(false, _.isInstanceOf[TimeoutException], _ => false))
     }
   } yield ()
 }