From d575bed5418be222e1d3ad39af862e2390596d61 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Sun, 26 Sep 2021 13:11:10 +0200
Subject: 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.
---
 .../resources/SimResourceAggregatorMaxMinTest.kt   | 19 ++++----
 .../simulator/resources/SimResourceCommandTest.kt  | 31 ++-----------
 .../simulator/resources/SimResourceContextTest.kt  | 50 ++++++--------------
 .../simulator/resources/SimResourceSourceTest.kt   | 54 ++++++++--------------
 .../resources/SimResourceSwitchExclusiveTest.kt    | 11 ++---
 .../resources/SimResourceSwitchMaxMinTest.kt       |  4 +-
 .../resources/SimResourceTransformerTest.kt        | 19 ++++----
 .../simulator/resources/SimWorkConsumerTest.kt     |  2 -
 8 files changed, 60 insertions(+), 130 deletions(-)

(limited to 'opendc-simulator/opendc-simulator-resources/src/test')

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 {
-- 
cgit v1.2.3


From 02fa44c0b116ff51c4cbe2876d8b2a225ed68553 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Tue, 28 Sep 2021 11:58:19 +0200
Subject: refactor(simulator): Add support for pushing flow from context

This change adds a new method to `SimResourceContext` called `push`
which allows users to change the requested flow rate directly without
having to interrupt the consumer.
---
 .../resources/SimResourceAggregatorMaxMinTest.kt   | 55 ++++++-------
 .../simulator/resources/SimResourceCommandTest.kt  | 53 -------------
 .../simulator/resources/SimResourceContextTest.kt  | 90 ++++++++++++++++++----
 .../simulator/resources/SimResourceSourceTest.kt   | 73 +++++++-----------
 .../resources/SimResourceSwitchExclusiveTest.kt    | 17 ++--
 .../resources/SimResourceSwitchMaxMinTest.kt       |  7 +-
 .../resources/SimResourceTransformerTest.kt        | 44 +++++++----
 7 files changed, 161 insertions(+), 178 deletions(-)
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceCommandTest.kt

(limited to 'opendc-simulator/opendc-simulator-resources/src/test')

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 a9390553..f4ea5fe8 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
@@ -22,14 +22,12 @@
 
 package org.opendc.simulator.resources
 
-import io.mockk.every
-import io.mockk.mockk
+import io.mockk.spyk
 import io.mockk.verify
 import kotlinx.coroutines.*
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertAll
-import org.junit.jupiter.api.assertThrows
 import org.opendc.simulator.core.runBlockingSimulation
 import org.opendc.simulator.resources.consumer.SimSpeedConsumerAdapter
 import org.opendc.simulator.resources.consumer.SimWorkConsumer
@@ -100,10 +98,17 @@ internal class SimResourceAggregatorMaxMinTest {
         )
         sources.forEach(aggregator::addInput)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(4.0, 1000))
-            .andThen(SimResourceCommand.Exit)
+        val consumer = spyk(object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (now == 0L) {
+                    ctx.push(4.0)
+                    1000
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        })
 
         aggregator.consume(consumer)
         yield()
@@ -112,27 +117,6 @@ internal class SimResourceAggregatorMaxMinTest {
         verify(exactly = 2) { consumer.onNext(any(), any(), any()) }
     }
 
-    @Test
-    fun testException() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val aggregator = SimResourceAggregatorMaxMin(scheduler)
-        val sources = listOf(
-            SimResourceSource(1.0, scheduler),
-            SimResourceSource(1.0, scheduler)
-        )
-        sources.forEach(aggregator::addInput)
-
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(1.0, duration = 1000))
-            .andThenThrows(IllegalStateException("Test Exception"))
-
-        assertThrows<IllegalStateException> { aggregator.consume(consumer) }
-        yield()
-        assertFalse(sources[0].isActive)
-    }
-
     @Test
     fun testAdjustCapacity() = runBlockingSimulation {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
@@ -186,10 +170,17 @@ internal class SimResourceAggregatorMaxMinTest {
         )
         sources.forEach(aggregator::addInput)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(4.0, 1000))
-            .andThen(SimResourceCommand.Exit)
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (now == 0L) {
+                    ctx.push(4.0)
+                    1000
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        }
 
         aggregator.consume(consumer)
         yield()
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
deleted file mode 100644
index 9a52dc63..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceCommandTest.kt
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertDoesNotThrow
-import org.junit.jupiter.api.assertThrows
-
-/**
- * Test suite for [SimResourceCommand].
- */
-class SimResourceCommandTest {
-    @Test
-    fun testNegativeLimit() {
-        assertThrows<IllegalArgumentException> {
-            SimResourceCommand.Consume(-1.0, 1)
-        }
-    }
-
-    @Test
-    fun testNegativeDuration() {
-        assertThrows<IllegalArgumentException> {
-            SimResourceCommand.Consume(1.0, -1)
-        }
-    }
-
-    @Test
-    fun testConsumeCorrect() {
-        assertDoesNotThrow {
-            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 0cb95abb..4e57f598 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
@@ -36,8 +36,17 @@ class SimResourceContextTest {
     @Test
     fun testFlushWithoutCommand() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (now == 0L) {
+                    ctx.push(1.0)
+                    1000
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        }
 
         val logic = object : SimResourceProviderLogic {}
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
@@ -48,14 +57,23 @@ class SimResourceContextTest {
     @Test
     fun testIntermediateFlush() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (now == 0L) {
+                    ctx.push(4.0)
+                    1000
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        }
 
         val logic = spyk(object : SimResourceProviderLogic {
             override fun onFinish(ctx: SimResourceControllableContext) {}
             override fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long = duration
         })
-        val context = spyk(SimResourceContextImpl(null, interpreter, consumer, logic))
+        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
 
         context.start()
         delay(1) // Delay 1 ms to prevent hitting the fast path
@@ -67,11 +85,20 @@ class SimResourceContextTest {
     @Test
     fun testIntermediateFlushIdle() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10) andThen SimResourceCommand.Exit
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (now == 0L) {
+                    ctx.push(0.0)
+                    10
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        }
 
         val logic = spyk(object : SimResourceProviderLogic {})
-        val context = spyk(SimResourceContextImpl(null, interpreter, consumer, logic))
+        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
 
         context.start()
         delay(5)
@@ -88,8 +115,17 @@ class SimResourceContextTest {
     @Test
     fun testDoubleStart() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10) andThen SimResourceCommand.Exit
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (now == 0L) {
+                    ctx.push(0.0)
+                    1000
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        }
 
         val logic = object : SimResourceProviderLogic {}
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
@@ -104,8 +140,17 @@ class SimResourceContextTest {
     @Test
     fun testIdempotentCapacityChange() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0) andThen SimResourceCommand.Exit
+        val consumer = spyk(object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (now == 0L) {
+                    ctx.push(1.0)
+                    1000
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        })
 
         val logic = object : SimResourceProviderLogic {}
 
@@ -120,12 +165,23 @@ class SimResourceContextTest {
     @Test
     fun testFailureNoInfiniteLoop() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        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 {})
+        val consumer = spyk(object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
+
+            override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
+                if (event == SimResourceEvent.Exit) throw IllegalStateException("onEvent")
+            }
+
+            override fun onFailure(ctx: SimResourceContext, cause: Throwable) {
+                throw IllegalStateException("onFailure")
+            }
+        })
+
+        val logic = 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 c310fad6..e055daf7 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
@@ -44,10 +44,7 @@ internal class SimResourceSourceTest {
         val capacity = 4200.0
         val provider = SimResourceSource(capacity, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(capacity, duration = 1000))
-            .andThen(SimResourceCommand.Exit)
+        val consumer = SimWorkConsumer(4200.0, 1.0)
 
         val res = mutableListOf<Double>()
         val adapter = SimSpeedConsumerAdapter(consumer, res::add)
@@ -79,10 +76,7 @@ internal class SimResourceSourceTest {
         val capacity = 4200.0
         val provider = SimResourceSource(capacity, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(2 * capacity, duration = 1000))
-            .andThen(SimResourceCommand.Exit)
+        val consumer = SimWorkConsumer(capacity, 2.0)
 
         val res = mutableListOf<Double>()
         val adapter = SimSpeedConsumerAdapter(consumer, res::add)
@@ -103,8 +97,9 @@ internal class SimResourceSourceTest {
         val provider = SimResourceSource(capacity, scheduler)
 
         val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
-                return SimResourceCommand.Exit
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
             }
 
             override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
@@ -132,12 +127,14 @@ internal class SimResourceSourceTest {
                 }
             }
 
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
                 return if (isFirst) {
                     isFirst = false
-                    SimResourceCommand.Consume(1.0, duration = 4000)
+                    ctx.push(1.0)
+                    4000
                 } else {
-                    SimResourceCommand.Exit
+                    ctx.close()
+                    Long.MAX_VALUE
                 }
             }
         }
@@ -172,10 +169,19 @@ internal class SimResourceSourceTest {
         val capacity = 4200.0
         val provider = SimResourceSource(capacity, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(1.0, duration = 1000))
-            .andThenThrows(IllegalStateException())
+        val consumer = object : SimResourceConsumer {
+            var isFirst = true
+
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (isFirst) {
+                    isFirst = false
+                    ctx.push(1.0)
+                    1000
+                } else {
+                    throw IllegalStateException()
+                }
+            }
+        }
 
         assertThrows<IllegalStateException> {
             provider.consume(consumer)
@@ -188,10 +194,7 @@ internal class SimResourceSourceTest {
         val capacity = 4200.0
         val provider = SimResourceSource(capacity, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(1.0))
-            .andThenThrows(IllegalStateException())
+        val consumer = SimWorkConsumer(capacity, 1.0)
 
         assertThrows<IllegalStateException> {
             coroutineScope {
@@ -207,30 +210,13 @@ internal class SimResourceSourceTest {
         val capacity = 4200.0
         val provider = SimResourceSource(capacity, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) }
-            .returns(SimResourceCommand.Consume(1.0))
-            .andThenThrows(IllegalStateException())
+        val consumer = SimWorkConsumer(capacity, 1.0)
 
         launch { provider.consume(consumer) }
         delay(500)
         provider.cancel()
 
-        assertEquals(500, clock.millis())
-    }
-
-    @Test
-    fun testIdle() = 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(), any(), any()) }
-            .returns(SimResourceCommand.Consume(0.0, 500))
-            .andThen(SimResourceCommand.Exit)
-
-        provider.consume(consumer)
+        yield()
 
         assertEquals(500, clock.millis())
     }
@@ -243,10 +229,9 @@ internal class SimResourceSourceTest {
                 val capacity = 4200.0
                 val provider = SimResourceSource(capacity, scheduler)
 
-                val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-                every { consumer.onNext(any(), any(), any()) }
-                    .returns(SimResourceCommand.Consume(0.0))
-                    .andThenThrows(IllegalStateException())
+                val consumer = object : SimResourceConsumer {
+                    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long = Long.MAX_VALUE
+                }
 
                 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 ad3b0f9f..9f86dc0d 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
@@ -22,8 +22,6 @@
 
 package org.opendc.simulator.resources
 
-import io.mockk.every
-import io.mockk.mockk
 import kotlinx.coroutines.yield
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
@@ -32,6 +30,7 @@ import org.junit.jupiter.api.assertThrows
 import org.opendc.simulator.core.runBlockingSimulation
 import org.opendc.simulator.resources.consumer.SimSpeedConsumerAdapter
 import org.opendc.simulator.resources.consumer.SimTraceConsumer
+import org.opendc.simulator.resources.consumer.SimWorkConsumer
 import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 
 /**
@@ -88,8 +87,7 @@ internal class SimResourceSwitchExclusiveTest {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
 
         val duration = 5 * 60L * 1000
-        val workload = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { workload.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0, duration = duration) andThen SimResourceCommand.Exit
+        val workload = SimWorkConsumer(duration * 3.2, 1.0)
 
         val switch = SimResourceSwitchExclusive()
         val source = SimResourceSource(3200.0, scheduler)
@@ -125,12 +123,14 @@ internal class SimResourceSwitchExclusiveTest {
                 }
             }
 
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
                 return if (isFirst) {
                     isFirst = false
-                    SimResourceCommand.Consume(1.0, duration = duration)
+                    ctx.push(1.0)
+                    duration
                 } else {
-                    SimResourceCommand.Exit
+                    ctx.close()
+                    Long.MAX_VALUE
                 }
             }
         }
@@ -159,9 +159,6 @@ internal class SimResourceSwitchExclusiveTest {
     fun testConcurrentWorkloadFails() = runBlockingSimulation {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
 
-        val workload = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        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 d8f18e65..ba0d66ff 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
@@ -22,8 +22,6 @@
 
 package org.opendc.simulator.resources
 
-import io.mockk.every
-import io.mockk.mockk
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.yield
@@ -31,6 +29,7 @@ import org.junit.jupiter.api.*
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.opendc.simulator.core.runBlockingSimulation
 import org.opendc.simulator.resources.consumer.SimTraceConsumer
+import org.opendc.simulator.resources.consumer.SimWorkConsumer
 import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 
 /**
@@ -46,9 +45,7 @@ internal class SimResourceSwitchMaxMinTest {
         sources.forEach { switch.addInput(it) }
 
         val provider = switch.newOutput()
-
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(1.0, duration = 1000) andThen SimResourceCommand.Exit
+        val consumer = SimWorkConsumer(2000.0, 1.0)
 
         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 3780fd60..fc43c3da 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
@@ -22,8 +22,6 @@
 
 package org.opendc.simulator.resources
 
-import io.mockk.every
-import io.mockk.mockk
 import io.mockk.spyk
 import io.mockk.verify
 import kotlinx.coroutines.*
@@ -47,8 +45,9 @@ internal class SimResourceTransformerTest {
         launch { source.consume(forwarder) }
 
         forwarder.consume(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
-                return SimResourceCommand.Exit
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
             }
         })
 
@@ -67,12 +66,14 @@ internal class SimResourceTransformerTest {
         forwarder.consume(object : SimResourceConsumer {
             var isFirst = true
 
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
                 return if (isFirst) {
                     isFirst = false
-                    SimResourceCommand.Consume(1.0, duration = 10 * 1000L)
+                    ctx.push(1.0)
+                    10 * 1000
                 } else {
-                    SimResourceCommand.Exit
+                    ctx.close()
+                    Long.MAX_VALUE
                 }
             }
         })
@@ -85,7 +86,10 @@ internal class SimResourceTransformerTest {
     fun testState() = runBlockingSimulation {
         val forwarder = SimResourceForwarder()
         val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): SimResourceCommand = SimResourceCommand.Exit
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
         }
 
         assertFalse(forwarder.isActive)
@@ -106,8 +110,12 @@ internal class SimResourceTransformerTest {
     fun testCancelPendingDelegate() = runBlockingSimulation {
         val forwarder = SimResourceForwarder()
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Exit
+        val consumer = spyk(object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
+        })
 
         forwarder.startConsumer(consumer)
         forwarder.cancel()
@@ -121,8 +129,7 @@ internal class SimResourceTransformerTest {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
         val source = SimResourceSource(2000.0, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10)
+        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
 
         source.startConsumer(forwarder)
         yield()
@@ -140,8 +147,7 @@ internal class SimResourceTransformerTest {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
         val source = SimResourceSource(2000.0, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Consume(0.0, 10)
+        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
 
         source.startConsumer(forwarder)
         yield()
@@ -159,8 +165,12 @@ internal class SimResourceTransformerTest {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
         val source = SimResourceSource(2000.0, scheduler)
 
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any(), any(), any()) } returns SimResourceCommand.Exit
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
+        }
 
         source.startConsumer(forwarder)
         forwarder.consume(consumer)
@@ -190,7 +200,7 @@ internal class SimResourceTransformerTest {
 
     @Test
     fun testTransformExit() = runBlockingSimulation {
-        val forwarder = SimResourceTransformer { _, _ -> SimResourceCommand.Exit }
+        val forwarder = SimResourceTransformer { ctx, _ -> ctx.close(); Long.MAX_VALUE }
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
         val source = SimResourceSource(1.0, scheduler)
 
-- 
cgit v1.2.3


From 657deac134f7b9ee30ed7e2b7667e30f3b17f79f Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Wed, 29 Sep 2021 16:52:30 +0200
Subject: perf(simulator): Reduce memory allocations in SimResourceInterpreter

This change removes unnecessary allocations in the SimResourceInterpreter
caused by the way timers were allocated for the resource context.
---
 .../kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'opendc-simulator/opendc-simulator-resources/src/test')

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 4e57f598..e95e9e42 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
@@ -51,7 +51,7 @@ class SimResourceContextTest {
         val logic = object : SimResourceProviderLogic {}
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
 
-        context.doUpdate(interpreter.clock.millis())
+        interpreter.scheduleSync(interpreter.clock.millis(), context)
     }
 
     @Test
@@ -77,7 +77,7 @@ class SimResourceContextTest {
 
         context.start()
         delay(1) // Delay 1 ms to prevent hitting the fast path
-        context.doUpdate(interpreter.clock.millis())
+        interpreter.scheduleSync(interpreter.clock.millis(), context)
 
         verify(exactly = 2) { logic.onConsume(any(), any(), any(), any()) }
     }
-- 
cgit v1.2.3


From d031a70f8bea02a86df7840c5ce731185df86883 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Tue, 28 Sep 2021 22:10:12 +0200
Subject: refactor(simulator): Invoke consumer callback on every invalidation

This change updates the simulator implementation to always invoke the
`SimResourceConsumer.onNext` callback when the resource context is
invalidated. This allows users to update the resource counter or do some
other work if the context has changed.
---
 .../simulator/resources/SimResourceContextTest.kt  | 33 ++++++----------------
 1 file changed, 8 insertions(+), 25 deletions(-)

(limited to 'opendc-simulator/opendc-simulator-resources/src/test')

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 e95e9e42..c7230a0e 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
@@ -26,6 +26,7 @@ import io.mockk.*
 import kotlinx.coroutines.*
 import org.junit.jupiter.api.*
 import org.opendc.simulator.core.runBlockingSimulation
+import org.opendc.simulator.resources.consumer.SimWorkConsumer
 import org.opendc.simulator.resources.impl.SimResourceContextImpl
 import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 
@@ -57,23 +58,14 @@ class SimResourceContextTest {
     @Test
     fun testIntermediateFlush() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (now == 0L) {
-                    ctx.push(4.0)
-                    1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        }
+        val consumer = SimWorkConsumer(1.0, 1.0)
 
         val logic = spyk(object : SimResourceProviderLogic {
             override fun onFinish(ctx: SimResourceControllableContext) {}
             override fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long = duration
         })
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        context.capacity = 1.0
 
         context.start()
         delay(1) // Delay 1 ms to prevent hitting the fast path
@@ -85,29 +77,20 @@ class SimResourceContextTest {
     @Test
     fun testIntermediateFlushIdle() = runBlockingSimulation {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (now == 0L) {
-                    ctx.push(0.0)
-                    10
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        }
+        val consumer = SimWorkConsumer(1.0, 1.0)
 
         val logic = spyk(object : SimResourceProviderLogic {})
         val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        context.capacity = 1.0
 
         context.start()
-        delay(5)
+        delay(500)
         context.invalidate()
-        delay(5)
+        delay(500)
         context.invalidate()
 
         assertAll(
-            { verify(exactly = 2) { logic.onConsume(any(), any(), 0.0, any()) } },
+            { verify(exactly = 2) { logic.onConsume(any(), any(), any(), any()) } },
             { verify(exactly = 1) { logic.onFinish(any()) } }
         )
     }
-- 
cgit v1.2.3


From e07a5357013b92377a840b4d0d394d0ef6605b26 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Mon, 27 Sep 2021 14:22:02 +0200
Subject: refactor(simulator): Remove onUpdate callback

This change removes the `onUpdate` callback from the
`SimResourceProviderLogic` interface. Instead, users should now update
counters using either `onConsume` or `onConverge`.
---
 .../simulator/resources/SimResourceContextTest.kt  | 24 +++++++++-------------
 .../resources/SimResourceTransformerTest.kt        |  3 +++
 2 files changed, 13 insertions(+), 14 deletions(-)

(limited to 'opendc-simulator/opendc-simulator-resources/src/test')

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 c7230a0e..1428ce42 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
@@ -50,7 +50,7 @@ class SimResourceContextTest {
         }
 
         val logic = object : SimResourceProviderLogic {}
-        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        val context = SimResourceContextImpl(interpreter, consumer, logic)
 
         interpreter.scheduleSync(interpreter.clock.millis(), context)
     }
@@ -60,18 +60,15 @@ class SimResourceContextTest {
         val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
         val consumer = SimWorkConsumer(1.0, 1.0)
 
-        val logic = spyk(object : SimResourceProviderLogic {
-            override fun onFinish(ctx: SimResourceControllableContext) {}
-            override fun onConsume(ctx: SimResourceControllableContext, now: Long, limit: Double, duration: Long): Long = duration
-        })
-        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        val logic = spyk(object : SimResourceProviderLogic {})
+        val context = SimResourceContextImpl(interpreter, consumer, logic)
         context.capacity = 1.0
 
         context.start()
         delay(1) // Delay 1 ms to prevent hitting the fast path
         interpreter.scheduleSync(interpreter.clock.millis(), context)
 
-        verify(exactly = 2) { logic.onConsume(any(), any(), any(), any()) }
+        verify(exactly = 2) { logic.onConsume(any(), any(), any(), any(), any()) }
     }
 
     @Test
@@ -80,7 +77,7 @@ class SimResourceContextTest {
         val consumer = SimWorkConsumer(1.0, 1.0)
 
         val logic = spyk(object : SimResourceProviderLogic {})
-        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        val context = SimResourceContextImpl(interpreter, consumer, logic)
         context.capacity = 1.0
 
         context.start()
@@ -90,8 +87,8 @@ class SimResourceContextTest {
         context.invalidate()
 
         assertAll(
-            { verify(exactly = 2) { logic.onConsume(any(), any(), any(), any()) } },
-            { verify(exactly = 1) { logic.onFinish(any()) } }
+            { verify(exactly = 2) { logic.onConsume(any(), any(), any(), any(), any()) } },
+            { verify(exactly = 1) { logic.onFinish(any(), any(), any()) } }
         )
     }
 
@@ -111,7 +108,7 @@ class SimResourceContextTest {
         }
 
         val logic = object : SimResourceProviderLogic {}
-        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        val context = SimResourceContextImpl(interpreter, consumer, logic)
 
         context.start()
 
@@ -136,8 +133,7 @@ class SimResourceContextTest {
         })
 
         val logic = object : SimResourceProviderLogic {}
-
-        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        val context = SimResourceContextImpl(interpreter, consumer, logic)
         context.capacity = 4200.0
         context.start()
         context.capacity = 4200.0
@@ -166,7 +162,7 @@ class SimResourceContextTest {
 
         val logic = object : SimResourceProviderLogic {}
 
-        val context = SimResourceContextImpl(null, interpreter, consumer, logic)
+        val context = SimResourceContextImpl(interpreter, consumer, logic)
 
         context.start()
 
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 fc43c3da..d7d0924f 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
@@ -223,6 +223,9 @@ internal class SimResourceTransformerTest {
 
         forwarder.consume(consumer)
 
+        yield()
+
+        assertEquals(2.0, source.counters.actual)
         assertEquals(source.counters.actual, forwarder.counters.actual) { "Actual work" }
         assertEquals(source.counters.demand, forwarder.counters.demand) { "Work demand" }
         assertEquals(source.counters.overcommit, forwarder.counters.overcommit) { "Overcommitted work" }
-- 
cgit v1.2.3


From d2f15fd7fd16922c11b0dcaa8807e8a321859773 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Wed, 29 Sep 2021 22:05:03 +0200
Subject: refactor(simulator): Merge distributor and aggregator into switch

This change removes the distributor and aggregator interfaces in favour
of a single switch interface. Since the switch interface is as powerful
as both the distributor and aggregator, we don't need the latter two.
---
 .../resources/SimResourceAggregatorMaxMinTest.kt   | 190 ---------------------
 .../resources/SimResourceSwitchExclusiveTest.kt    |  28 +--
 .../resources/SimResourceSwitchMaxMinTest.kt       |   6 +-
 3 files changed, 10 insertions(+), 214 deletions(-)
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt

(limited to 'opendc-simulator/opendc-simulator-resources/src/test')

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
deleted file mode 100644
index f4ea5fe8..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import io.mockk.spyk
-import io.mockk.verify
-import kotlinx.coroutines.*
-import org.junit.jupiter.api.Assertions.*
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertAll
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimSpeedConsumerAdapter
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * Test suite for the [SimResourceAggregatorMaxMin] class.
- */
-internal class SimResourceAggregatorMaxMinTest {
-    @Test
-    fun testSingleCapacity() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val aggregator = SimResourceAggregatorMaxMin(scheduler)
-        val forwarder = SimResourceForwarder()
-        val sources = listOf(
-            forwarder,
-            SimResourceSource(1.0, scheduler)
-        )
-        sources.forEach(aggregator::addInput)
-
-        val consumer = SimWorkConsumer(1.0, 0.5)
-        val usage = mutableListOf<Double>()
-        val source = SimResourceSource(1.0, scheduler)
-        val adapter = SimSpeedConsumerAdapter(forwarder, usage::add)
-        source.startConsumer(adapter)
-
-        aggregator.consume(consumer)
-        yield()
-
-        assertAll(
-            { assertEquals(1000, clock.millis()) },
-            { assertEquals(listOf(0.0, 0.5, 0.0), usage) }
-        )
-    }
-
-    @Test
-    fun testDoubleCapacity() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val aggregator = SimResourceAggregatorMaxMin(scheduler)
-        val sources = listOf(
-            SimResourceSource(1.0, scheduler),
-            SimResourceSource(1.0, scheduler)
-        )
-        sources.forEach(aggregator::addInput)
-
-        val consumer = SimWorkConsumer(2.0, 1.0)
-        val usage = mutableListOf<Double>()
-        val adapter = SimSpeedConsumerAdapter(consumer, usage::add)
-
-        aggregator.consume(adapter)
-        yield()
-        assertAll(
-            { assertEquals(1000, clock.millis()) },
-            { assertEquals(listOf(0.0, 2.0, 0.0), usage) }
-        )
-    }
-
-    @Test
-    fun testOvercommit() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val aggregator = SimResourceAggregatorMaxMin(scheduler)
-        val sources = listOf(
-            SimResourceSource(1.0, scheduler),
-            SimResourceSource(1.0, scheduler)
-        )
-        sources.forEach(aggregator::addInput)
-
-        val consumer = spyk(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (now == 0L) {
-                    ctx.push(4.0)
-                    1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        })
-
-        aggregator.consume(consumer)
-        yield()
-        assertEquals(1000, clock.millis())
-
-        verify(exactly = 2) { consumer.onNext(any(), any(), any()) }
-    }
-
-    @Test
-    fun testAdjustCapacity() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val aggregator = SimResourceAggregatorMaxMin(scheduler)
-        val sources = listOf(
-            SimResourceSource(1.0, scheduler),
-            SimResourceSource(1.0, scheduler)
-        )
-        sources.forEach(aggregator::addInput)
-
-        val consumer = SimWorkConsumer(4.0, 1.0)
-        coroutineScope {
-            launch { aggregator.consume(consumer) }
-            delay(1000)
-            sources[0].capacity = 0.5
-        }
-        yield()
-        assertEquals(2333, clock.millis())
-    }
-
-    @Test
-    fun testFailOverCapacity() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val aggregator = SimResourceAggregatorMaxMin(scheduler)
-        val sources = listOf(
-            SimResourceSource(1.0, scheduler),
-            SimResourceSource(1.0, scheduler)
-        )
-        sources.forEach(aggregator::addInput)
-
-        val consumer = SimWorkConsumer(1.0, 0.5)
-        coroutineScope {
-            launch { aggregator.consume(consumer) }
-            delay(500)
-            sources[0].capacity = 0.5
-        }
-        yield()
-        assertEquals(1167, clock.millis())
-    }
-
-    @Test
-    fun testCounters() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val aggregator = SimResourceAggregatorMaxMin(scheduler)
-        val sources = listOf(
-            SimResourceSource(1.0, scheduler),
-            SimResourceSource(1.0, scheduler)
-        )
-        sources.forEach(aggregator::addInput)
-
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (now == 0L) {
-                    ctx.push(4.0)
-                    1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        }
-
-        aggregator.consume(consumer)
-        yield()
-        assertEquals(1000, clock.millis())
-        assertEquals(2.0, aggregator.counters.actual) { "Actual work mismatch" }
-    }
-}
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 9f86dc0d..49f2da5f 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
@@ -65,13 +65,8 @@ internal class SimResourceSwitchExclusiveTest {
         switch.addInput(forwarder)
 
         val provider = switch.newOutput()
-
-        try {
-            provider.consume(workload)
-            yield()
-        } finally {
-            provider.close()
-        }
+        provider.consume(workload)
+        yield()
 
         assertAll(
             { assertEquals(listOf(0.0, 28.0, 3200.0, 0.0, 183.0, 0.0), speed) { "Correct speed" } },
@@ -95,13 +90,9 @@ internal class SimResourceSwitchExclusiveTest {
         switch.addInput(source)
 
         val provider = switch.newOutput()
+        provider.consume(workload)
+        yield()
 
-        try {
-            provider.consume(workload)
-            yield()
-        } finally {
-            provider.close()
-        }
         assertEquals(duration, clock.millis()) { "Took enough time" }
     }
 
@@ -141,14 +132,9 @@ internal class SimResourceSwitchExclusiveTest {
         switch.addInput(source)
 
         val provider = switch.newOutput()
-
-        try {
-            provider.consume(workload)
-            yield()
-            provider.consume(workload)
-        } finally {
-            provider.close()
-        }
+        provider.consume(workload)
+        yield()
+        provider.consume(workload)
         assertEquals(duration * 2, clock.millis()) { "Took enough time" }
     }
 
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 ba0d66ff..03f90e21 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
@@ -51,7 +51,7 @@ internal class SimResourceSwitchMaxMinTest {
             provider.consume(consumer)
             yield()
         } finally {
-            switch.close()
+            switch.clear()
         }
     }
 
@@ -81,7 +81,7 @@ internal class SimResourceSwitchMaxMinTest {
             provider.consume(workload)
             yield()
         } finally {
-            switch.close()
+            switch.clear()
         }
 
         assertAll(
@@ -133,7 +133,7 @@ internal class SimResourceSwitchMaxMinTest {
 
             yield()
         } finally {
-            switch.close()
+            switch.clear()
         }
         assertAll(
             { assertEquals(2073600.0, switch.counters.demand, "Requested work does not match") },
-- 
cgit v1.2.3


From dd605ab1f70fef1fbbed848e8ebbd6b231622273 Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Wed, 29 Sep 2021 22:20:48 +0200
Subject: refactor(simulator): Remove transform from SimResourceForwarder

This change removes the ability to transform the duration of a pull from
the SimResourceForwarder class. This ability is not used anymore, since
pushes are now done using a method instead of a command.
---
 .../resources/SimResourceForwarderTest.kt          | 220 +++++++++++++++++++
 .../resources/SimResourceTransformerTest.kt        | 234 ---------------------
 2 files changed, 220 insertions(+), 234 deletions(-)
 create mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt

(limited to 'opendc-simulator/opendc-simulator-resources/src/test')

diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
new file mode 100644
index 00000000..49e60f68
--- /dev/null
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2021 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.simulator.resources
+
+import io.mockk.spyk
+import io.mockk.verify
+import kotlinx.coroutines.*
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.opendc.simulator.core.runBlockingSimulation
+import org.opendc.simulator.resources.consumer.SimWorkConsumer
+import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
+
+/**
+ * A test suite for the [SimResourceForwarder] class.
+ */
+internal class SimResourceForwarderTest {
+    @Test
+    fun testCancelImmediately() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
+        val source = SimResourceSource(2000.0, scheduler)
+
+        launch { source.consume(forwarder) }
+
+        forwarder.consume(object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
+        })
+
+        forwarder.close()
+        source.cancel()
+    }
+
+    @Test
+    fun testCancel() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
+        val source = SimResourceSource(2000.0, scheduler)
+
+        launch { source.consume(forwarder) }
+
+        forwarder.consume(object : SimResourceConsumer {
+            var isFirst = true
+
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                return if (isFirst) {
+                    isFirst = false
+                    ctx.push(1.0)
+                    10 * 1000
+                } else {
+                    ctx.close()
+                    Long.MAX_VALUE
+                }
+            }
+        })
+
+        forwarder.close()
+        source.cancel()
+    }
+
+    @Test
+    fun testState() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
+        }
+
+        assertFalse(forwarder.isActive)
+
+        forwarder.startConsumer(consumer)
+        assertTrue(forwarder.isActive)
+
+        assertThrows<IllegalStateException> { forwarder.startConsumer(consumer) }
+
+        forwarder.cancel()
+        assertFalse(forwarder.isActive)
+
+        forwarder.close()
+        assertFalse(forwarder.isActive)
+    }
+
+    @Test
+    fun testCancelPendingDelegate() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+
+        val consumer = spyk(object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
+        })
+
+        forwarder.startConsumer(consumer)
+        forwarder.cancel()
+
+        verify(exactly = 0) { consumer.onEvent(any(), SimResourceEvent.Exit) }
+    }
+
+    @Test
+    fun testCancelStartedDelegate() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
+        val source = SimResourceSource(2000.0, scheduler)
+
+        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
+
+        source.startConsumer(forwarder)
+        yield()
+        forwarder.startConsumer(consumer)
+        yield()
+        forwarder.cancel()
+
+        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Start) }
+        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Exit) }
+    }
+
+    @Test
+    fun testCancelPropagation() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
+        val source = SimResourceSource(2000.0, scheduler)
+
+        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
+
+        source.startConsumer(forwarder)
+        yield()
+        forwarder.startConsumer(consumer)
+        yield()
+        source.cancel()
+
+        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Start) }
+        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Exit) }
+    }
+
+    @Test
+    fun testExitPropagation() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder(isCoupled = true)
+        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
+        val source = SimResourceSource(2000.0, scheduler)
+
+        val consumer = object : SimResourceConsumer {
+            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
+                ctx.close()
+                return Long.MAX_VALUE
+            }
+        }
+
+        source.startConsumer(forwarder)
+        forwarder.consume(consumer)
+        yield()
+
+        assertFalse(forwarder.isActive)
+    }
+
+    @Test
+    fun testAdjustCapacity() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
+        val source = SimResourceSource(1.0, scheduler)
+
+        val consumer = spyk(SimWorkConsumer(2.0, 1.0))
+        source.startConsumer(forwarder)
+
+        coroutineScope {
+            launch { forwarder.consume(consumer) }
+            delay(1000)
+            source.capacity = 0.5
+        }
+
+        assertEquals(3000, clock.millis())
+        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Capacity) }
+    }
+
+    @Test
+    fun testCounters() = runBlockingSimulation {
+        val forwarder = SimResourceForwarder()
+        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
+        val source = SimResourceSource(1.0, scheduler)
+
+        val consumer = SimWorkConsumer(2.0, 1.0)
+        source.startConsumer(forwarder)
+
+        forwarder.consume(consumer)
+
+        yield()
+
+        assertEquals(2.0, source.counters.actual)
+        assertEquals(source.counters.actual, forwarder.counters.actual) { "Actual work" }
+        assertEquals(source.counters.demand, forwarder.counters.demand) { "Work demand" }
+        assertEquals(source.counters.overcommit, forwarder.counters.overcommit) { "Overcommitted work" }
+        assertEquals(2000, clock.millis())
+    }
+}
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
deleted file mode 100644
index d7d0924f..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
+++ /dev/null
@@ -1,234 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import io.mockk.spyk
-import io.mockk.verify
-import kotlinx.coroutines.*
-import org.junit.jupiter.api.Assertions.*
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertThrows
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * A test suite for the [SimResourceTransformer] class.
- */
-internal class SimResourceTransformerTest {
-    @Test
-    fun testCancelImmediately() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        launch { source.consume(forwarder) }
-
-        forwarder.consume(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        })
-
-        forwarder.close()
-        source.cancel()
-    }
-
-    @Test
-    fun testCancel() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        launch { source.consume(forwarder) }
-
-        forwarder.consume(object : SimResourceConsumer {
-            var isFirst = true
-
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (isFirst) {
-                    isFirst = false
-                    ctx.push(1.0)
-                    10 * 1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        })
-
-        forwarder.close()
-        source.cancel()
-    }
-
-    @Test
-    fun testState() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        }
-
-        assertFalse(forwarder.isActive)
-
-        forwarder.startConsumer(consumer)
-        assertTrue(forwarder.isActive)
-
-        assertThrows<IllegalStateException> { forwarder.startConsumer(consumer) }
-
-        forwarder.cancel()
-        assertFalse(forwarder.isActive)
-
-        forwarder.close()
-        assertFalse(forwarder.isActive)
-    }
-
-    @Test
-    fun testCancelPendingDelegate() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-
-        val consumer = spyk(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        })
-
-        forwarder.startConsumer(consumer)
-        forwarder.cancel()
-
-        verify(exactly = 0) { consumer.onEvent(any(), SimResourceEvent.Exit) }
-    }
-
-    @Test
-    fun testCancelStartedDelegate() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
-
-        source.startConsumer(forwarder)
-        yield()
-        forwarder.startConsumer(consumer)
-        yield()
-        forwarder.cancel()
-
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Start) }
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Exit) }
-    }
-
-    @Test
-    fun testCancelPropagation() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
-
-        source.startConsumer(forwarder)
-        yield()
-        forwarder.startConsumer(consumer)
-        yield()
-        source.cancel()
-
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Start) }
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Exit) }
-    }
-
-    @Test
-    fun testExitPropagation() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder(isCoupled = true)
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        }
-
-        source.startConsumer(forwarder)
-        forwarder.consume(consumer)
-        yield()
-
-        assertFalse(forwarder.isActive)
-    }
-
-    @Test
-    fun testAdjustCapacity() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(1.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2.0, 1.0))
-        source.startConsumer(forwarder)
-
-        coroutineScope {
-            launch { forwarder.consume(consumer) }
-            delay(1000)
-            source.capacity = 0.5
-        }
-
-        assertEquals(3000, clock.millis())
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Capacity) }
-    }
-
-    @Test
-    fun testTransformExit() = runBlockingSimulation {
-        val forwarder = SimResourceTransformer { ctx, _ -> ctx.close(); Long.MAX_VALUE }
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(1.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2.0, 1.0))
-        source.startConsumer(forwarder)
-        forwarder.consume(consumer)
-
-        assertEquals(0, clock.millis())
-        verify(exactly = 1) { consumer.onNext(any(), any(), any()) }
-    }
-
-    @Test
-    fun testCounters() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(1.0, scheduler)
-
-        val consumer = SimWorkConsumer(2.0, 1.0)
-        source.startConsumer(forwarder)
-
-        forwarder.consume(consumer)
-
-        yield()
-
-        assertEquals(2.0, source.counters.actual)
-        assertEquals(source.counters.actual, forwarder.counters.actual) { "Actual work" }
-        assertEquals(source.counters.demand, forwarder.counters.demand) { "Work demand" }
-        assertEquals(source.counters.overcommit, forwarder.counters.overcommit) { "Overcommitted work" }
-        assertEquals(2000, clock.millis())
-    }
-}
-- 
cgit v1.2.3


From 4cc1d40d421c8736f8b21b360b61d6b065158b7a Mon Sep 17 00:00:00 2001
From: Fabian Mastenbroek <mail.fabianm@gmail.com>
Date: Wed, 29 Sep 2021 23:56:16 +0200
Subject: refactor(simulator): Migrate to flow-based simulation

This change renames the `opendc-simulator-resources` module into the
`opendc-simulator-flow` module to indicate that the core simulation
model of OpenDC is based around modelling and simulating flows.

Previously, the distinction between resource consumer and provider, and
input and output caused some confusion. By switching to a flow-based
model, this distinction is now clear (as in, the water flows from source
to consumer/sink).
---
 .../simulator/resources/SimResourceContextTest.kt  | 173 ---------------
 .../resources/SimResourceForwarderTest.kt          | 220 -------------------
 .../simulator/resources/SimResourceSourceTest.kt   | 240 ---------------------
 .../resources/SimResourceSwitchExclusiveTest.kt    | 156 --------------
 .../resources/SimResourceSwitchMaxMinTest.kt       | 145 -------------
 .../simulator/resources/SimWorkConsumerTest.kt     |  56 -----
 6 files changed, 990 deletions(-)
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
 delete mode 100644 opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt

(limited to 'opendc-simulator/opendc-simulator-resources/src/test')

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
deleted file mode 100644
index 1428ce42..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceContextTest.kt
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import io.mockk.*
-import kotlinx.coroutines.*
-import org.junit.jupiter.api.*
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceContextImpl
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * A test suite for the [SimResourceContextImpl] class.
- */
-class SimResourceContextTest {
-    @Test
-    fun testFlushWithoutCommand() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (now == 0L) {
-                    ctx.push(1.0)
-                    1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        }
-
-        val logic = object : SimResourceProviderLogic {}
-        val context = SimResourceContextImpl(interpreter, consumer, logic)
-
-        interpreter.scheduleSync(interpreter.clock.millis(), context)
-    }
-
-    @Test
-    fun testIntermediateFlush() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = SimWorkConsumer(1.0, 1.0)
-
-        val logic = spyk(object : SimResourceProviderLogic {})
-        val context = SimResourceContextImpl(interpreter, consumer, logic)
-        context.capacity = 1.0
-
-        context.start()
-        delay(1) // Delay 1 ms to prevent hitting the fast path
-        interpreter.scheduleSync(interpreter.clock.millis(), context)
-
-        verify(exactly = 2) { logic.onConsume(any(), any(), any(), any(), any()) }
-    }
-
-    @Test
-    fun testIntermediateFlushIdle() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = SimWorkConsumer(1.0, 1.0)
-
-        val logic = spyk(object : SimResourceProviderLogic {})
-        val context = SimResourceContextImpl(interpreter, consumer, logic)
-        context.capacity = 1.0
-
-        context.start()
-        delay(500)
-        context.invalidate()
-        delay(500)
-        context.invalidate()
-
-        assertAll(
-            { verify(exactly = 2) { logic.onConsume(any(), any(), any(), any(), any()) } },
-            { verify(exactly = 1) { logic.onFinish(any(), any(), any()) } }
-        )
-    }
-
-    @Test
-    fun testDoubleStart() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (now == 0L) {
-                    ctx.push(0.0)
-                    1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        }
-
-        val logic = object : SimResourceProviderLogic {}
-        val context = SimResourceContextImpl(interpreter, consumer, logic)
-
-        context.start()
-
-        assertThrows<IllegalStateException> {
-            context.start()
-        }
-    }
-
-    @Test
-    fun testIdempotentCapacityChange() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-        val consumer = spyk(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (now == 0L) {
-                    ctx.push(1.0)
-                    1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        })
-
-        val logic = object : SimResourceProviderLogic {}
-        val context = SimResourceContextImpl(interpreter, consumer, logic)
-        context.capacity = 4200.0
-        context.start()
-        context.capacity = 4200.0
-
-        verify(exactly = 0) { consumer.onEvent(any(), SimResourceEvent.Capacity) }
-    }
-
-    @Test
-    fun testFailureNoInfiniteLoop() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val consumer = spyk(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-
-            override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-                if (event == SimResourceEvent.Exit) throw IllegalStateException("onEvent")
-            }
-
-            override fun onFailure(ctx: SimResourceContext, cause: Throwable) {
-                throw IllegalStateException("onFailure")
-            }
-        })
-
-        val logic = object : SimResourceProviderLogic {}
-
-        val context = SimResourceContextImpl(interpreter, consumer, logic)
-
-        context.start()
-
-        delay(1)
-
-        verify(exactly = 1) { consumer.onFailure(any(), any()) }
-    }
-}
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
deleted file mode 100644
index 49e60f68..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceForwarderTest.kt
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import io.mockk.spyk
-import io.mockk.verify
-import kotlinx.coroutines.*
-import org.junit.jupiter.api.Assertions.*
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertThrows
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * A test suite for the [SimResourceForwarder] class.
- */
-internal class SimResourceForwarderTest {
-    @Test
-    fun testCancelImmediately() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        launch { source.consume(forwarder) }
-
-        forwarder.consume(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        })
-
-        forwarder.close()
-        source.cancel()
-    }
-
-    @Test
-    fun testCancel() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        launch { source.consume(forwarder) }
-
-        forwarder.consume(object : SimResourceConsumer {
-            var isFirst = true
-
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (isFirst) {
-                    isFirst = false
-                    ctx.push(1.0)
-                    10 * 1000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        })
-
-        forwarder.close()
-        source.cancel()
-    }
-
-    @Test
-    fun testState() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        }
-
-        assertFalse(forwarder.isActive)
-
-        forwarder.startConsumer(consumer)
-        assertTrue(forwarder.isActive)
-
-        assertThrows<IllegalStateException> { forwarder.startConsumer(consumer) }
-
-        forwarder.cancel()
-        assertFalse(forwarder.isActive)
-
-        forwarder.close()
-        assertFalse(forwarder.isActive)
-    }
-
-    @Test
-    fun testCancelPendingDelegate() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-
-        val consumer = spyk(object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        })
-
-        forwarder.startConsumer(consumer)
-        forwarder.cancel()
-
-        verify(exactly = 0) { consumer.onEvent(any(), SimResourceEvent.Exit) }
-    }
-
-    @Test
-    fun testCancelStartedDelegate() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
-
-        source.startConsumer(forwarder)
-        yield()
-        forwarder.startConsumer(consumer)
-        yield()
-        forwarder.cancel()
-
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Start) }
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Exit) }
-    }
-
-    @Test
-    fun testCancelPropagation() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2000.0, 1.0))
-
-        source.startConsumer(forwarder)
-        yield()
-        forwarder.startConsumer(consumer)
-        yield()
-        source.cancel()
-
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Start) }
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Exit) }
-    }
-
-    @Test
-    fun testExitPropagation() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder(isCoupled = true)
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(2000.0, scheduler)
-
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-        }
-
-        source.startConsumer(forwarder)
-        forwarder.consume(consumer)
-        yield()
-
-        assertFalse(forwarder.isActive)
-    }
-
-    @Test
-    fun testAdjustCapacity() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(1.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2.0, 1.0))
-        source.startConsumer(forwarder)
-
-        coroutineScope {
-            launch { forwarder.consume(consumer) }
-            delay(1000)
-            source.capacity = 0.5
-        }
-
-        assertEquals(3000, clock.millis())
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Capacity) }
-    }
-
-    @Test
-    fun testCounters() = runBlockingSimulation {
-        val forwarder = SimResourceForwarder()
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val source = SimResourceSource(1.0, scheduler)
-
-        val consumer = SimWorkConsumer(2.0, 1.0)
-        source.startConsumer(forwarder)
-
-        forwarder.consume(consumer)
-
-        yield()
-
-        assertEquals(2.0, source.counters.actual)
-        assertEquals(source.counters.actual, forwarder.counters.actual) { "Actual work" }
-        assertEquals(source.counters.demand, forwarder.counters.demand) { "Work demand" }
-        assertEquals(source.counters.overcommit, forwarder.counters.overcommit) { "Overcommitted work" }
-        assertEquals(2000, clock.millis())
-    }
-}
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
deleted file mode 100644
index e055daf7..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
+++ /dev/null
@@ -1,240 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import io.mockk.every
-import io.mockk.mockk
-import io.mockk.spyk
-import io.mockk.verify
-import kotlinx.coroutines.*
-import org.junit.jupiter.api.*
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimSpeedConsumerAdapter
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * A test suite for the [SimResourceSource] class.
- */
-internal class SimResourceSourceTest {
-    @Test
-    fun testSpeed() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = SimWorkConsumer(4200.0, 1.0)
-
-        val res = mutableListOf<Double>()
-        val adapter = SimSpeedConsumerAdapter(consumer, res::add)
-
-        provider.consume(adapter)
-
-        assertEquals(listOf(0.0, capacity, 0.0), res) { "Speed is reported correctly" }
-    }
-
-    @Test
-    fun testAdjustCapacity() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val provider = SimResourceSource(1.0, scheduler)
-
-        val consumer = spyk(SimWorkConsumer(2.0, 1.0))
-
-        coroutineScope {
-            launch { provider.consume(consumer) }
-            delay(1000)
-            provider.capacity = 0.5
-        }
-        assertEquals(3000, clock.millis())
-        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Capacity) }
-    }
-
-    @Test
-    fun testSpeedLimit() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = SimWorkConsumer(capacity, 2.0)
-
-        val res = mutableListOf<Double>()
-        val adapter = SimSpeedConsumerAdapter(consumer, res::add)
-
-        provider.consume(adapter)
-
-        assertEquals(listOf(0.0, capacity, 0.0), res) { "Speed is reported correctly" }
-    }
-
-    /**
-     * Test to see whether no infinite recursion occurs when interrupting during [SimResourceConsumer.onStart] or
-     * [SimResourceConsumer.onNext].
-     */
-    @Test
-    fun testIntermediateInterrupt() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = object : SimResourceConsumer {
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                ctx.close()
-                return Long.MAX_VALUE
-            }
-
-            override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-                ctx.interrupt()
-            }
-        }
-
-        provider.consume(consumer)
-    }
-
-    @Test
-    fun testInterrupt() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-        lateinit var resCtx: SimResourceContext
-
-        val consumer = object : SimResourceConsumer {
-            var isFirst = true
-
-            override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-                when (event) {
-                    SimResourceEvent.Start -> resCtx = ctx
-                    else -> {}
-                }
-            }
-
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (isFirst) {
-                    isFirst = false
-                    ctx.push(1.0)
-                    4000
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        }
-
-        launch {
-            yield()
-            resCtx.interrupt()
-        }
-        provider.consume(consumer)
-
-        assertEquals(0, clock.millis())
-    }
-
-    @Test
-    fun testFailure() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onEvent(any(), eq(SimResourceEvent.Start)) }
-            .throws(IllegalStateException())
-
-        assertThrows<IllegalStateException> {
-            provider.consume(consumer)
-        }
-    }
-
-    @Test
-    fun testExceptionPropagationOnNext() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = object : SimResourceConsumer {
-            var isFirst = true
-
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (isFirst) {
-                    isFirst = false
-                    ctx.push(1.0)
-                    1000
-                } else {
-                    throw IllegalStateException()
-                }
-            }
-        }
-
-        assertThrows<IllegalStateException> {
-            provider.consume(consumer)
-        }
-    }
-
-    @Test
-    fun testConcurrentConsumption() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = SimWorkConsumer(capacity, 1.0)
-
-        assertThrows<IllegalStateException> {
-            coroutineScope {
-                launch { provider.consume(consumer) }
-                provider.consume(consumer)
-            }
-        }
-    }
-
-    @Test
-    fun testCancelDuringConsumption() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = SimWorkConsumer(capacity, 1.0)
-
-        launch { provider.consume(consumer) }
-        delay(500)
-        provider.cancel()
-
-        yield()
-
-        assertEquals(500, clock.millis())
-    }
-
-    @Test
-    fun testInfiniteSleep() {
-        assertThrows<IllegalStateException> {
-            runBlockingSimulation {
-                val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-                val capacity = 4200.0
-                val provider = SimResourceSource(capacity, scheduler)
-
-                val consumer = object : SimResourceConsumer {
-                    override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long = Long.MAX_VALUE
-                }
-
-                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
deleted file mode 100644
index 49f2da5f..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchExclusiveTest.kt
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import kotlinx.coroutines.yield
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertAll
-import org.junit.jupiter.api.assertThrows
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimSpeedConsumerAdapter
-import org.opendc.simulator.resources.consumer.SimTraceConsumer
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * Test suite for the [SimResourceSwitchExclusive] class.
- */
-internal class SimResourceSwitchExclusiveTest {
-    /**
-     * Test a trace workload.
-     */
-    @Test
-    fun testTrace() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val speed = mutableListOf<Double>()
-
-        val duration = 5 * 60L
-        val workload =
-            SimTraceConsumer(
-                sequenceOf(
-                    SimTraceConsumer.Fragment(duration * 1000, 28.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 3500.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 0.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 183.0)
-                ),
-            )
-
-        val switch = SimResourceSwitchExclusive()
-        val source = SimResourceSource(3200.0, scheduler)
-        val forwarder = SimResourceForwarder()
-        val adapter = SimSpeedConsumerAdapter(forwarder, speed::add)
-        source.startConsumer(adapter)
-        switch.addInput(forwarder)
-
-        val provider = switch.newOutput()
-        provider.consume(workload)
-        yield()
-
-        assertAll(
-            { assertEquals(listOf(0.0, 28.0, 3200.0, 0.0, 183.0, 0.0), speed) { "Correct speed" } },
-            { assertEquals(5 * 60L * 4000, clock.millis()) { "Took enough time" } }
-        )
-    }
-
-    /**
-     * Test runtime workload on hypervisor.
-     */
-    @Test
-    fun testRuntimeWorkload() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val duration = 5 * 60L * 1000
-        val workload = SimWorkConsumer(duration * 3.2, 1.0)
-
-        val switch = SimResourceSwitchExclusive()
-        val source = SimResourceSource(3200.0, scheduler)
-
-        switch.addInput(source)
-
-        val provider = switch.newOutput()
-        provider.consume(workload)
-        yield()
-
-        assertEquals(duration, clock.millis()) { "Took enough time" }
-    }
-
-    /**
-     * Test two workloads running sequentially.
-     */
-    @Test
-    fun testTwoWorkloads() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val duration = 5 * 60L * 1000
-        val workload = object : SimResourceConsumer {
-            var isFirst = true
-
-            override fun onEvent(ctx: SimResourceContext, event: SimResourceEvent) {
-                when (event) {
-                    SimResourceEvent.Start -> isFirst = true
-                    else -> {}
-                }
-            }
-
-            override fun onNext(ctx: SimResourceContext, now: Long, delta: Long): Long {
-                return if (isFirst) {
-                    isFirst = false
-                    ctx.push(1.0)
-                    duration
-                } else {
-                    ctx.close()
-                    Long.MAX_VALUE
-                }
-            }
-        }
-
-        val switch = SimResourceSwitchExclusive()
-        val source = SimResourceSource(3200.0, scheduler)
-
-        switch.addInput(source)
-
-        val provider = switch.newOutput()
-        provider.consume(workload)
-        yield()
-        provider.consume(workload)
-        assertEquals(duration * 2, clock.millis()) { "Took enough time" }
-    }
-
-    /**
-     * Test concurrent workloads on the machine.
-     */
-    @Test
-    fun testConcurrentWorkloadFails() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val switch = SimResourceSwitchExclusive()
-        val source = SimResourceSource(3200.0, scheduler)
-
-        switch.addInput(source)
-
-        switch.newOutput()
-        assertThrows<IllegalStateException> { switch.newOutput() }
-    }
-}
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
deleted file mode 100644
index 03f90e21..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSwitchMaxMinTest.kt
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.yield
-import org.junit.jupiter.api.*
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimTraceConsumer
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * Test suite for the [SimResourceSwitch] implementations
- */
-internal class SimResourceSwitchMaxMinTest {
-    @Test
-    fun testSmoke() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val switch = SimResourceSwitchMaxMin(scheduler)
-
-        val sources = List(2) { SimResourceSource(2000.0, scheduler) }
-        sources.forEach { switch.addInput(it) }
-
-        val provider = switch.newOutput()
-        val consumer = SimWorkConsumer(2000.0, 1.0)
-
-        try {
-            provider.consume(consumer)
-            yield()
-        } finally {
-            switch.clear()
-        }
-    }
-
-    /**
-     * Test overcommitting of resources via the hypervisor with a single VM.
-     */
-    @Test
-    fun testOvercommittedSingle() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val duration = 5 * 60L
-        val workload =
-            SimTraceConsumer(
-                sequenceOf(
-                    SimTraceConsumer.Fragment(duration * 1000, 28.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 3500.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 0.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 183.0)
-                ),
-            )
-
-        val switch = SimResourceSwitchMaxMin(scheduler)
-        val provider = switch.newOutput()
-
-        try {
-            switch.addInput(SimResourceSource(3200.0, scheduler))
-            provider.consume(workload)
-            yield()
-        } finally {
-            switch.clear()
-        }
-
-        assertAll(
-            { assertEquals(1113300.0, switch.counters.demand, "Requested work does not match") },
-            { assertEquals(1023300.0, switch.counters.actual, "Actual work does not match") },
-            { assertEquals(90000.0, switch.counters.overcommit, "Overcommitted work does not match") },
-            { assertEquals(1200000, clock.millis()) }
-        )
-    }
-
-    /**
-     * Test overcommitting of resources via the hypervisor with two VMs.
-     */
-    @Test
-    fun testOvercommittedDual() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-
-        val duration = 5 * 60L
-        val workloadA =
-            SimTraceConsumer(
-                sequenceOf(
-                    SimTraceConsumer.Fragment(duration * 1000, 28.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 3500.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 0.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 183.0)
-                ),
-            )
-        val workloadB =
-            SimTraceConsumer(
-                sequenceOf(
-                    SimTraceConsumer.Fragment(duration * 1000, 28.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 3100.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 0.0),
-                    SimTraceConsumer.Fragment(duration * 1000, 73.0)
-                )
-            )
-
-        val switch = SimResourceSwitchMaxMin(scheduler)
-        val providerA = switch.newOutput()
-        val providerB = switch.newOutput()
-
-        try {
-            switch.addInput(SimResourceSource(3200.0, scheduler))
-
-            coroutineScope {
-                launch { providerA.consume(workloadA) }
-                providerB.consume(workloadB)
-            }
-
-            yield()
-        } finally {
-            switch.clear()
-        }
-        assertAll(
-            { assertEquals(2073600.0, switch.counters.demand, "Requested work does not match") },
-            { assertEquals(1053600.0, switch.counters.actual, "Granted work does not match") },
-            { assertEquals(1020000.0, switch.counters.overcommit, "Overcommitted work does not match") },
-            { assertEquals(1200000, clock.millis()) }
-        )
-    }
-}
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
deleted file mode 100644
index 830f16d3..00000000
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2021 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.simulator.resources
-
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Test
-import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
-import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
-
-/**
- * A test suite for the [SimWorkConsumer] class.
- */
-internal class SimWorkConsumerTest {
-    @Test
-    fun testSmoke() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val provider = SimResourceSource(1.0, scheduler)
-
-        val consumer = SimWorkConsumer(1.0, 1.0)
-
-        provider.consume(consumer)
-        assertEquals(1000, clock.millis())
-    }
-
-    @Test
-    fun testUtilization() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val provider = SimResourceSource(1.0, scheduler)
-
-        val consumer = SimWorkConsumer(1.0, 0.5)
-
-        provider.consume(consumer)
-        assertEquals(2000, clock.millis())
-    }
-}
-- 
cgit v1.2.3