Task tests

Author: Avanatiker

common/build.gradle.kts

@@ -23,6 +23,8 @@ val kotlinxCoroutinesVersion: String by project
 val discordIPCVersion: String by project
 val fuelVersion: String by project
 val resultVersion: String by project
+val mockitoKotlin: String by project
+val mockitoInline: String by project
 
 base.archivesName = "${base.archivesName.get()}-api"
 
@@ -58,6 +60,8 @@ dependencies {
     // Baritone
     modImplementation("baritone-api:baritone-unoptimized-fabric:1.10.2") { isTransitive = false }
     testImplementation(kotlin("test"))
+    testImplementation("org.mockito.kotlin:mockito-kotlin:$mockitoKotlin")
+    testImplementation("org.mockito:mockito-inline:$mockitoInline")
 }
 
 tasks {

common/src/main/kotlin/com/lambda/module/modules/network/PacketLimiter.kt

@@ -35,7 +35,7 @@ object PacketLimiter : Module(
 ) {
     private var packetQueue = LimitedDecayQueue<PacketEvent.Send.Pre>(99, 1000)
     private val limit by setting("Limit", 99, 1..100, 1, "The maximum amount of packets to send per given time interval", unit = " packets")
-        .onValueChange { _, to -> packetQueue.setMaxSize(to) }
+        .onValueChange { _, to -> packetQueue.setSizeLimit(to) }
 
     private val interval by setting("Duration", 1000L, 1L..1000L, 50L, "The interval / duration in milliseconds to limit packets for", unit = " ms")
         .onValueChange { _, to -> packetQueue.setDecayTime(to) }

common/src/main/kotlin/com/lambda/task/Task.kt

@@ -38,8 +38,8 @@ typealias TaskGeneratorUnit<R> = SafeContext.(R) -> Unit
 
 abstract class Task<Result> : Nameable, Muteable {
     private var parent: Task<*>? = null
-    private val subTasks = mutableListOf<Task<*>>()
-    private var state = State.INIT
+    val subTasks = mutableListOf<Task<*>>()
+    var state = State.INIT
     override val isMuted: Boolean get() = state == State.PAUSED || state == State.INIT
     var age = 0
     private val depth: Int get() = parent?.depth?.plus(1) ?: 0

common/src/main/kotlin/com/lambda/task/tasks/OpenContainer.kt

@@ -39,10 +39,10 @@ class OpenContainer @Ta5kBuilder constructor(
     private val interact: InteractionConfig = TaskFlowModule.interact,
     private val sides: Set<Direction> = Direction.entries.toSet(),
 ) : Task<ScreenHandler>() {
-    override val name get() = "${state.description(inScope)} at ${blockPos.toShortString()}"
+    override val name get() = "${containerState.description(inScope)} at ${blockPos.toShortString()}"
 
     private var screenHandler: ScreenHandler? = null
-    private var state = State.SCOPING
+    private var containerState = State.SCOPING
     private var inScope = 0
 
     enum class State {
@@ -57,39 +57,39 @@ class OpenContainer @Ta5kBuilder constructor(
 
     init {
         listen<InventoryEvent.Open> {
-            if (state != State.OPENING) return@listen
+            if (containerState != State.OPENING) return@listen
 
             screenHandler = it.screenHandler
-            state = State.SLOT_LOADING
+            containerState = State.SLOT_LOADING
 
             if (!waitForSlotLoad) success(it.screenHandler)
         }
 
         listen<InventoryEvent.Close> {
             if (screenHandler != it.screenHandler) return@listen
 
-            state = State.SCOPING
+            containerState = State.SCOPING
             screenHandler = null
         }
 
         listen<InventoryEvent.FullUpdate> {
-            if (state != State.SLOT_LOADING) return@listen
+            if (containerState != State.SLOT_LOADING) return@listen
 
             screenHandler?.let {
                 success(it)
             }
         }
 
         listen<TickEvent.Pre> {
-            if (state != State.SCOPING) return@listen
+            if (containerState != State.SCOPING) return@listen
 
             val target = lookAtBlock(blockPos, sides, config = interact)
             if (rotate && !target.requestBy(rotation).done) return@listen
 
             val hitResult = target.hit?.hitIfValid()?.blockResult ?: return@listen
             interaction.interactBlock(player, Hand.MAIN_HAND, hitResult)
 
-            state = State.OPENING
+            containerState = State.OPENING
         }
     }
 }

common/src/main/kotlin/com/lambda/util/collections/LimitedDecayQueue.kt

@@ -110,7 +110,7 @@ class LimitedDecayQueue<E>(
      *
      * @param newSize The new maximum size for the queue. Must be a non-negative integer.
      */
-    fun setMaxSize(newSize: Int) {
+    fun setSizeLimit(newSize: Int) {
         sizeLimit = newSize
         cleanUp()
 

common/src/test/kotlin/LimitedDecayQueueTest.kt

@@ -135,7 +135,7 @@ class LimitedDecayQueueTest {
         queue.add("Element2")
         queue.add("Element3")
 
-        queue.setMaxSize(2) // Reduce size limit to 2
+        queue.setSizeLimit(2) // Reduce size limit to 2
 
         assertEquals(2, queue.size)
     }

common/src/test/kotlin/TaskTest.kt

@@ -0,0 +1,80 @@
+import com.lambda.context.ClientContext
+import com.lambda.context.SafeContext
+import com.lambda.task.RootTask
+import com.lambda.task.RootTask.run
+import com.lambda.task.Task
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.mockito.Mock
+import org.mockito.MockedConstruction
+import org.mockito.Mockito
+import org.mockito.Mockito.`when`
+import org.mockito.MockitoAnnotations
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+class TaskTest {
+
+    @Mock
+    private lateinit var mockSafeContext: SafeContext
+
+    private lateinit var clientContextMock: MockedConstruction<ClientContext>
+
+    class TestTask(private val i: Int = 0) : Task<Int>() {
+        override val name get() = "TestTask of $i"
+
+        override fun SafeContext.onStart() {
+            success(i + 1)
+        }
+
+        override fun SafeContext.onCancel() {
+            success(i)
+        }
+    }
+
+    @BeforeEach
+    fun setUp() {
+        MockitoAnnotations.openMocks(this)
+        clientContextMock = Mockito.mockConstruction(ClientContext::class.java) { mock, _ ->
+            `when`(mock.toSafe()).thenReturn(mockSafeContext)
+        }
+    }
+
+    @AfterEach
+    fun tearDown() {
+        clientContextMock.close()
+        RootTask.clear()
+    }
+
+    @Test
+    fun `test task`() {
+        val task = TestTask(5)
+
+        assertEquals(task.name, "TestTask of 5")
+
+        task.finally { result ->
+            assertEquals(result, 6)
+            assertEquals(task.state, Task.State.COMPLETED)
+            assertTrue(task.isCompleted)
+        }.run()
+    }
+}

common/src/test/kotlin/Vec3Test.kt common/src/test/kotlin/Vec3dTest.ktcommon/src/test/kotlin/Vec3Test.kt renamed to common/src/test/kotlin/Vec3dTest.kt

@@ -32,7 +32,7 @@ import kotlin.test.assertEquals
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-class Vec3Test {
+class Vec3dTest {
 
     @Test
     fun `test dist with another Vec3d`() {

gradle.properties

@@ -34,6 +34,8 @@ baritoneVersion=1.10.2
 discordIPCVersion=8edf2dbeda
 fuelVersion=2.3.1
 resultVersion=5.6.0
+mockitoKotlin=5.4.0
+mockitoInline=5.2.0
 
 # Fabric https://fabricmc.net/develop/
 fabricLoaderVersion=0.16.9