Update lincheck

Author: qwwdfsad

core/kotlinx-coroutines-core/build.gradle

@@ -3,7 +3,7 @@
  */
 
 dependencies {
-    testCompile "com.devexperts.lincheck:core:$lincheck_version"
+    testCompile "com.devexperts.lincheck:lincheck:$lincheck_version"
     testCompile "com.esotericsoftware:kryo:4.0.0"
 }
 

core/kotlinx-coroutines-core/test/internal/LockFreeTaskQueueLinearizabilityTest.kt

@@ -3,26 +3,22 @@
  */
 @file:Suppress("unused")
 
-package kotlinx.coroutines.channels
+package kotlinx.coroutines.linearizability
 
 import com.devexperts.dxlab.lincheck.*
 import com.devexperts.dxlab.lincheck.annotations.*
 import com.devexperts.dxlab.lincheck.paramgen.*
-import com.devexperts.dxlab.lincheck.stress.*
+import com.devexperts.dxlab.lincheck.strategy.stress.*
 import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.*
 import org.junit.*
 import java.io.*
 
 @Param(name = "value", gen = IntGen::class, conf = "1:3")
 class ChannelIsClosedLinearizabilityTest : TestBase() {
 
     private val lt = LinTesting()
-    private lateinit var channel: Channel<Int>
-
-    @Reset
-    fun resetChannel() {
-        channel = Channel()
-    }
+    private val channel = Channel<Int>()
 
     @Operation(runOnce = true)
     fun send1(@Param(name = "value") value: Int) = lt.run("send1") { channel.send(value) }
@@ -50,20 +46,8 @@ class ChannelIsClosedLinearizabilityTest : TestBase() {
         val options = StressOptions()
             .iterations(100)
             .invocationsPerIteration(1000 * stressTestMultiplier)
-            .addThread(1, 3)
-            .addThread(1, 3)
-            .addThread(1, 3)
+            .threads(3)
             .verifier(LinVerifier::class.java)
-            .injectExecution { actors, methods ->
-                actors[0].add(actorMethod(methods, "receive1"))
-                actors[0].add(actorMethod(methods, "receive2"))
-                actors[0].add(actorMethod(methods, "close1"))
-
-                actors[1].add(actorMethod(methods, "send2"))
-                actors[1].add(actorMethod(methods, "send1"))
-
-                actors[2].add(actorMethod(methods, "isClosedForSend"))
-            }
 
         LinChecker.check(ChannelIsClosedLinearizabilityTest::class.java, options)
     }

core/kotlinx-coroutines-core/test/channels/ChannelIsClosedLinearizabilityTest.kt renamed to core/kotlinx-coroutines-core/test/linearizability/ChannelIsClosedLinearizabilityTest.kt

@@ -3,27 +3,28 @@
  */
 @file:Suppress("unused")
 
-package kotlinx.coroutines.channels
+package kotlinx.coroutines.linearizability
 
 import com.devexperts.dxlab.lincheck.*
 import com.devexperts.dxlab.lincheck.annotations.*
 import com.devexperts.dxlab.lincheck.paramgen.*
-import com.devexperts.dxlab.lincheck.stress.*
+import com.devexperts.dxlab.lincheck.strategy.stress.*
 import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.*
 import org.junit.*
 import java.io.*
 
 @Param(name = "value", gen = IntGen::class, conf = "1:3")
 class ChannelLinearizabilityTest : TestBase() {
 
+    private companion object {
+        // Emulating ctor argument for lincheck
+        var capacity = 0
+    }
+
     private val lt = LinTesting()
-    private var capacity = 0
-    private lateinit var channel: Channel<Int>
+    private var channel: Channel<Int> = Channel(capacity)
 
-    @Reset
-    fun resetChannel() {
-        channel = Channel(capacity)
-    }
 
     @Operation(runOnce = true)
     fun send1(@Param(name = "value") value: Int) = lt.run("send1") { channel.send(value) }
@@ -68,13 +69,11 @@ class ChannelLinearizabilityTest : TestBase() {
     fun testUnlimitedChannelLinearizability() = runTest(Channel.UNLIMITED)
 
     private fun runTest(capacity: Int) {
-        this.capacity = capacity
+        ChannelLinearizabilityTest.capacity = capacity
         val options = StressOptions()
             .iterations(100)
             .invocationsPerIteration(1000 * stressTestMultiplier)
-            .addThread(1, 3)
-            .addThread(1, 3)
-            .addThread(1, 3)
+            .threads(3)
             .verifier(LinVerifier::class.java)
         LinChecker.check(ChannelLinearizabilityTest::class.java, options)
     }

core/kotlinx-coroutines-core/test/channels/ChannelLinearizabilityTest.kt renamed to core/kotlinx-coroutines-core/test/linearizability/ChannelLinearizabilityTest.kt

@@ -6,6 +6,8 @@ package kotlinx.coroutines
 
 import com.devexperts.dxlab.lincheck.Actor
 import com.devexperts.dxlab.lincheck.Result
+import com.devexperts.dxlab.lincheck.Utils.*
+import com.devexperts.dxlab.lincheck.execution.*
 import com.devexperts.dxlab.lincheck.verifier.Verifier
 import java.lang.reflect.Method
 import java.util.*
@@ -57,29 +59,30 @@ class LinTesting {
     }
 }
 
-class LinVerifier(
-    actorsPerThread: List<List<Actor>>, testInstance: Any, resetMethod: Method?
-) : Verifier(actorsPerThread, testInstance, resetMethod) {
+class LinVerifier(scenario: ExecutionScenario,
+                  testClass: Class<*>) : Verifier {
     private val possibleResultsSet: Set<List<List<Result>>> =
-        generateAllLinearizableExecutions(actorsPerThread)
+        generateAllLinearizableExecutions(scenario.parallelExecution)
             .asSequence()
             .map { linEx: List<Actor> ->
-                val res: List<Result> = executeActors(testInstance, linEx)
+                val res: List<Result> = executeActors(testClass.newInstance(), linEx)
                 val actorIds = linEx.asSequence().withIndex().associateBy({ it.value}, { it.index })
-                actorsPerThread.map { actors -> actors.map { actor -> res[actorIds[actor]!!] } }
+                scenario.parallelExecution.map { actors -> actors.map { actor -> res[actorIds[actor]!!] } }
             }.toSet()
 
-    override fun verifyResults(results: List<List<Result>>) {
-        if (!valid(results)) {
+    override fun verifyResults(results: ExecutionResult): Boolean {
+        if (!valid(results.parallelResults)) {
             println("\nNon-linearizable execution:")
-            printResults(results)
+            printResults(results.parallelResults)
             println("\nPossible linearizable executions:")
             possibleResultsSet.forEach { possibleResults ->
                 printResults(possibleResults)
                 println()
             }
             throw AssertionError("Non-linearizable execution detected, see log for details")
         }
+
+        return true
     }
 
     private fun printResults(results: List<List<Result>>) {
@@ -103,7 +106,7 @@ class LinVerifier(
     private fun generateAllLinearizableExecutions(actorsPerThread: List<List<Actor>>): List<List<Actor>> {
         val executions = ArrayList<List<Actor>>()
         generateLinearizableExecutions0(
-            executions, actorsPerThread, ArrayList<Actor>(), IntArray(actorsPerThread.size),
+            executions, actorsPerThread, ArrayList(), IntArray(actorsPerThread.size),
             actorsPerThread.sumBy { it.size })
         return executions
     }

core/kotlinx-coroutines-core/test/linearizability/FixedBehaviourExecutionGenerator.kt

@@ -3,25 +3,21 @@
  */
 @file:Suppress("unused")
 
-package kotlinx.coroutines.internal
+package kotlinx.coroutines.linearizability
 
 import com.devexperts.dxlab.lincheck.*
 import com.devexperts.dxlab.lincheck.annotations.*
 import com.devexperts.dxlab.lincheck.paramgen.*
-import com.devexperts.dxlab.lincheck.stress.*
+import com.devexperts.dxlab.lincheck.strategy.stress.*
 import kotlinx.coroutines.*
+import kotlinx.coroutines.internal.*
 import kotlin.test.*
 
 @Param(name = "value", gen = IntGen::class, conf = "1:3")
 class LockFreeListLinearizabilityTest : TestBase() {
     class Node(val value: Int): LockFreeLinkedListNode()
 
-    private lateinit var q: LockFreeLinkedListHead
-
-    @Reset
-    fun resetList() {
-        q = LockFreeLinkedListHead()
-    }
+    private val q: LockFreeLinkedListHead = LockFreeLinkedListHead()
 
     @Operation
     fun addLast(@Param(name = "value") value: Int) {
@@ -52,10 +48,7 @@ class LockFreeListLinearizabilityTest : TestBase() {
         val options = StressOptions()
             .iterations(100)
             .invocationsPerIteration(1000 * stressTestMultiplier)
-            .addThread(1, 2)
-            .addThread(1, 2)
-            .addThread(1, 2)
-            .addThread(1, 2)
+            .threads(4)
         LinChecker.check(LockFreeListLinearizabilityTest::class.java, options)
     }
 }