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 ()
}