refactor(simulator): Combine work and deadline to duration

This change removes the work and deadline properties from the
SimResourceCommand.Consume class and introduces a new property duration.
This property is now used in conjunction with the limit to compute the amount
of work processed by a resource provider.

Previously, we used both work and deadline to compute the duration and
the amount of remaining work at the end of a consumption. However, with
this change, we ensure that a resource consumption always runs at the
same speed once establishing, drastically simplifying the computation
for the amount of work processed during the consumption.

8 files changed, 60 insertions, 130 deletions

diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
index 2f01a8c4..a9390553 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
@@ -38,7 +38,6 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 /**
  * Test suite for the [SimResourceAggregatorMaxMin] class.
  */
-@OptIn(ExperimentalCoroutinesApi::class)
 internal class SimResourceAggregatorMaxMinTest {
     @Test
     fun testSingleCapacity() = runBlockingSimulation {
@@ -102,15 +101,15 @@ internal class SimResourceAggregatorMaxMinTest {
         sources.forEach(aggregator::addInput)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(4.0, 4.0, 1000))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(4.0, 1000))
             .andThen(SimResourceCommand.Exit)
 
         aggregator.consume(consumer)
         yield()
         assertEquals(1000, clock.millis())
 
-        verify(exactly = 2) { consumer.onNext(any()) }
+        verify(exactly = 2) { consumer.onNext(any(), any(), any()) }
     }
 
     @Test
@@ -125,8 +124,8 @@ internal class SimResourceAggregatorMaxMinTest {
         sources.forEach(aggregator::addInput)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1.0, 1.0))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(1.0, duration = 1000))
             .andThenThrows(IllegalStateException("Test Exception"))
 
         assertThrows<IllegalStateException> { aggregator.consume(consumer) }
@@ -152,7 +151,7 @@ internal class SimResourceAggregatorMaxMinTest {
             sources[0].capacity = 0.5
         }
         yield()
-        assertEquals(2334, clock.millis())
+        assertEquals(2333, clock.millis())
     }
 
     @Test
@@ -173,7 +172,7 @@ internal class SimResourceAggregatorMaxMinTest {
             sources[0].capacity = 0.5
         }
         yield()
-        assertEquals(1000, clock.millis())
+        assertEquals(1167, clock.millis())
     }
 
     @Test
@@ -188,8 +187,8 @@ internal class SimResourceAggregatorMaxMinTest {
         sources.forEach(aggregator::addInput)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(4.0, 4.0, 1000))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(4.0, 1000))
             .andThen(SimResourceCommand.Exit)
 
         aggregator.consume(consumer)
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceCommandTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceCommandTest.kt
index 02d456ff..9a52dc63 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceCommandTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceCommandTest.kt
@@ -31,44 +31,23 @@ import org.junit.jupiter.api.assertThrows
  */
 class SimResourceCommandTest {
     @Test
-    fun testZeroWork() {
-        assertThrows<IllegalArgumentException> {
-            SimResourceCommand.Consume(0.0, 1.0)
-        }
-    }
-
-    @Test
-    fun testNegativeWork() {
-        assertThrows<IllegalArgumentException> {
-            SimResourceCommand.Consume(-1.0, 1.0)
-        }
-    }
-
-    @Test
-    fun testZeroLimit() {
+    fun testNegativeLimit() {
         assertThrows<IllegalArgumentException> {
-            SimResourceCommand.Consume(1.0, 0.0)
+            SimResourceCommand.Consume(-1.0, 1)
         }
     }
 
     @Test
-    fun testNegativeLimit() {
+    fun testNegativeDuration() {
         assertThrows<IllegalArgumentException> {
-            SimResourceCommand.Consume(1.0, -1.0, 1)
+            SimResourceCommand.Consume(1.0, -1)
         }
     }
 
     @Test
     fun testConsumeCorrect() {
         assertDoesNotThrow {
-            SimResourceCommand.Consume(1.0, 1.0)
-        }
-    }
-
-    @Test
-    fun testIdleCorrect() {
-        assertDoesNotThrow {
-            SimResourceCommand.Idle(1)
+            SimResourceCommand.Consume(1.0)
         }
     }
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
index 6cb507ce..0cb95abb 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
@@ -32,19 +32,14 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 /**
  * A test suite for the [SimResourceContextImpl] class.
  */
-@OptIn(ExperimentalCoroutinesApi::class)
 class SimResourceContextTest {
     @Test
     fun testFlushWithoutCommand() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Consume(10.0, 1.0) andThen SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
 
-        val logic = object : SimResourceProviderLogic {
-            override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long = deadline
-            override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long = deadline
-            override fun onFinish(ctx: SimResourceControllableContext) {}
-        }
+        val logic = object : SimResourceProviderLogic {}
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
 
         context.doUpdate(interpreter.clock.millis())
@@ -54,12 +49,11 @@ class SimResourceContextTest {
     fun testIntermediateFlush() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Consume(10.0, 1.0) andThen SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
 
         val logic = spyk(object : SimResourceProviderLogic {
-            override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long = deadline
             override fun onFinish(ctx: SimResourceControllableContext) {}
-            override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long = deadline
+            override fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long = duration
         })
         val context = spyk(SimResourceContextImpl(null, interpreter, consumer, logic))
 
@@ -74,13 +68,9 @@ class SimResourceContextTest {
     fun testIntermediateFlushIdle() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Idle(10) andThen SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10) andThen SimResourceCommand.Exit
 
-        val logic = spyk(object : SimResourceProviderLogic {
-            override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long = deadline
-            override fun onFinish(ctx: SimResourceControllableContext) {}
-            override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long = deadline
-        })
+        val logic = spyk(object : SimResourceProviderLogic {})
         val context = spyk(SimResourceContextImpl(null, interpreter, consumer, logic))
 
         context.start()
@@ -90,7 +80,7 @@ class SimResourceContextTest {
         context.invalidate()
 
         assertAll(
-            { verify(exactly = 2) { logic.onIdle(any(), any()) } },
+            { verify(exactly = 2) { logic.onConsume(any(), any(), 0.0, any()) } },
             { verify(exactly = 1) { logic.onFinish(any()) } }
         )
     }
@@ -99,13 +89,9 @@ class SimResourceContextTest {
     fun testDoubleStart() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Idle(10) andThen SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10) andThen SimResourceCommand.Exit
 
-        val logic = object : SimResourceProviderLogic {
-            override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long = deadline
-            override fun onFinish(ctx: SimResourceControllableContext) {}
-            override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long = deadline
-        }
+        val logic = object : SimResourceProviderLogic {}
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
 
         context.start()
@@ -116,16 +102,12 @@ class SimResourceContextTest {
     }
 
     @Test
-    fun testIdempodentCapacityChange() = runBlockingSimulation {
+    fun testIdempotentCapacityChange() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Consume(10.0, 1.0) andThen SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
 
-        val logic = object : SimResourceProviderLogic {
-            override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long = deadline
-            override fun onFinish(ctx: SimResourceControllableContext) {}
-            override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long = deadline
-        }
+        val logic = object : SimResourceProviderLogic {}
 
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
         context.capacity = 4200.0
@@ -139,15 +121,11 @@ class SimResourceContextTest {
     fun testFailureNoInfiniteLoop() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Exit
         every { consumer.onEvent(any(), SimResourceEvent.Exit) } throws IllegalStateException("onEvent")
         every { consumer.onFailure(any(), any()) } throws IllegalStateException("onFailure")
 
-        val logic = spyk(object : SimResourceProviderLogic {
-            override fun onIdle(ctx: SimResourceControllableContext, deadline: Long): Long = deadline
-            override fun onFinish(ctx: SimResourceControllableContext) {}
-            override fun onConsume(ctx: SimResourceControllableContext, work: Double, limit: Double, deadline: Long): Long = deadline
-        })
+        val logic = spyk(object : SimResourceProviderLogic {})
 
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
 
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
index 4895544d..c310fad6 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
@@ -37,8 +37,7 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 /**
  * A test suite for the [SimResourceSource] class.
  */
-@OptIn(ExperimentalCoroutinesApi::class)
-class SimResourceSourceTest {
+internal class SimResourceSourceTest {
     @Test
     fun testSpeed() = runBlockingSimulation {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
@@ -46,8 +45,8 @@ class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1000 * capacity, capacity))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(capacity, duration = 1000))
             .andThen(SimResourceCommand.Exit)
 
         val res = mutableListOf<Double>()
@@ -81,8 +80,8 @@ class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1000 * capacity, 2 * capacity))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(2 * capacity, duration = 1000))
             .andThen(SimResourceCommand.Exit)
 
         val res = mutableListOf<Double>()
@@ -104,7 +103,7 @@ class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
                 return SimResourceCommand.Exit
             }
 
@@ -133,11 +132,10 @@ class SimResourceSourceTest {
                 }
             }
 
-            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
-                assertEquals(0.0, ctx.remainingWork)
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
                 return if (isFirst) {
                     isFirst = false
-                    SimResourceCommand.Consume(4.0, 1.0)
+                    SimResourceCommand.Consume(1.0, duration = 4000)
                 } else {
                     SimResourceCommand.Exit
                 }
@@ -175,8 +173,8 @@ class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1.0, 1.0))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(1.0, duration = 1000))
             .andThenThrows(IllegalStateException())
 
         assertThrows<IllegalStateException> {
@@ -191,8 +189,8 @@ class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1.0, 1.0))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(1.0))
             .andThenThrows(IllegalStateException())
 
         assertThrows<IllegalStateException> {
@@ -210,8 +208,8 @@ class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1.0, 1.0))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(1.0))
             .andThenThrows(IllegalStateException())
 
         launch { provider.consume(consumer) }
@@ -228,8 +226,8 @@ class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Idle(clock.millis() + 500))
+        every { consumer.onNext(any(), any(), any()) }
+            .returns(SimResourceCommand.Consume(0.0, 500))
             .andThen(SimResourceCommand.Exit)
 
         provider.consume(consumer)
@@ -246,28 +244,12 @@ class SimResourceSourceTest {
                 val provider = SimResourceSource(capacity, scheduler)
 
                 val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-                every { consumer.onNext(any()) }
-                    .returns(SimResourceCommand.Idle())
+                every { consumer.onNext(any(), any(), any()) }
+                    .returns(SimResourceCommand.Consume(0.0))
                     .andThenThrows(IllegalStateException())
 
                 provider.consume(consumer)
             }
         }
     }
-
-    @Test
-    fun testIncorrectDeadline() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Idle(2))
-            .andThen(SimResourceCommand.Exit)
-
-        delay(10)
-
-        assertThrows<IllegalArgumentException> { provider.consume(consumer) }
-    }
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
index ad8d82e3..ad3b0f9f 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
@@ -24,7 +24,6 @@ package org.opendc.simulator.resources
 
 import io.mockk.every
 import io.mockk.mockk
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.yield
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
@@ -38,7 +37,6 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 /**
  * Test suite for the [SimResourceSwitchExclusive] class.
  */
-@OptIn(ExperimentalCoroutinesApi::class)
 internal class SimResourceSwitchExclusiveTest {
     /**
      * Test a trace workload.
@@ -91,7 +89,7 @@ internal class SimResourceSwitchExclusiveTest {
 
         val duration = 5 * 60L * 1000
         val workload = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { workload.onNext(any()) } returns SimResourceCommand.Consume(duration / 1000.0, 1.0) andThen SimResourceCommand.Exit
+        every { workload.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0, duration = duration) andThen SimResourceCommand.Exit
 
         val switch = SimResourceSwitchExclusive()
         val source = SimResourceSource(3200.0, scheduler)
@@ -127,10 +125,10 @@ internal class SimResourceSwitchExclusiveTest {
                 }
             }
 
-            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
                 return if (isFirst) {
                     isFirst = false
-                    SimResourceCommand.Consume(duration / 1000.0, 1.0)
+                    SimResourceCommand.Consume(1.0, duration = duration)
                 } else {
                     SimResourceCommand.Exit
                 }
@@ -161,9 +159,8 @@ internal class SimResourceSwitchExclusiveTest {
     fun testConcurrentWorkloadFails() = runBlockingSimulation {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
 
-        val duration = 5 * 60L * 1000
         val workload = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { workload.onNext(any()) } returns SimResourceCommand.Consume(duration / 1000.0, 1.0) andThen SimResourceCommand.Exit
+        every { workload.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
 
         val switch = SimResourceSwitchExclusive()
         val source = SimResourceSource(3200.0, scheduler)
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
index e4292ec0..d8f18e65 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
@@ -24,7 +24,6 @@ package org.opendc.simulator.resources
 
 import io.mockk.every
 import io.mockk.mockk
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.yield
@@ -37,7 +36,6 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 /**
  * Test suite for the [SimResourceSwitch] implementations
  */
-@OptIn(ExperimentalCoroutinesApi::class)
 internal class SimResourceSwitchMaxMinTest {
     @Test
     fun testSmoke() = runBlockingSimulation {
@@ -50,7 +48,7 @@ internal class SimResourceSwitchMaxMinTest {
         val provider = switch.newOutput()
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Consume(1.0, 1.0) andThen SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0, duration = 1000) andThen SimResourceCommand.Exit
 
         try {
             provider.consume(consumer)
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
index cf69b7b5..3780fd60 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
@@ -37,7 +37,6 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 /**
  * A test suite for the [SimResourceTransformer] class.
  */
-@OptIn(ExperimentalCoroutinesApi::class)
 internal class SimResourceTransformerTest {
     @Test
     fun testCancelImmediately() = runBlockingSimulation {
@@ -48,7 +47,7 @@ internal class SimResourceTransformerTest {
         launch { source.consume(forwarder) }
 
         forwarder.consume(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
                 return SimResourceCommand.Exit
             }
         })
@@ -68,10 +67,10 @@ internal class SimResourceTransformerTest {
         forwarder.consume(object : SimResourceConsumer {
             var isFirst = true
 
-            override fun onNext(ctx: SimResourceContext): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
                 return if (isFirst) {
                     isFirst = false
-                    SimResourceCommand.Consume(10.0, 1.0)
+                    SimResourceCommand.Consume(1.0, duration = 10 * 1000L)
                 } else {
                     SimResourceCommand.Exit
                 }
@@ -86,7 +85,7 @@ internal class SimResourceTransformerTest {
     fun testState() = runBlockingSimulation {
         val forwarder = SimResourceForwarder()
         val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext): SimResourceCommand = SimResourceCommand.Exit
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand = SimResourceCommand.Exit
         }
 
         assertFalse(forwarder.isActive)
@@ -108,7 +107,7 @@ internal class SimResourceTransformerTest {
         val forwarder = SimResourceForwarder()
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Exit
 
         forwarder.startConsumer(consumer)
         forwarder.cancel()
@@ -123,7 +122,7 @@ internal class SimResourceTransformerTest {
         val source = SimResourceSource(2000.0, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Idle(10)
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10)
 
         source.startConsumer(forwarder)
         yield()
@@ -142,7 +141,7 @@ internal class SimResourceTransformerTest {
         val source = SimResourceSource(2000.0, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Idle(10)
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10)
 
         source.startConsumer(forwarder)
         yield()
@@ -161,7 +160,7 @@ internal class SimResourceTransformerTest {
         val source = SimResourceSource(2000.0, scheduler)
 
         val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) } returns SimResourceCommand.Exit
+        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Exit
 
         source.startConsumer(forwarder)
         forwarder.consume(consumer)
@@ -200,7 +199,7 @@ internal class SimResourceTransformerTest {
         forwarder.consume(consumer)
 
         assertEquals(0, clock.millis())
-        verify(exactly = 1) { consumer.onNext(any()) }
+        verify(exactly = 1) { consumer.onNext(any(), any(), any()) }
     }
 
     @Test
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
index 42648cf1..830f16d3 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
@@ -22,7 +22,6 @@
 
 package org.opendc.simulator.resources
 
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 import org.opendc.simulator.core.runBlockingSimulation
@@ -32,7 +31,6 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 /**
  * A test suite for the [SimWorkConsumer] class.
  */
-@OptIn(ExperimentalCoroutinesApi::class)
 internal class SimWorkConsumerTest {
     @Test
     fun testSmoke() = runBlockingSimulation {