LockFreeLinkedList

mirai-core/src/jvmTest/kotlin/net/mamoe/mirai/utils/LockFreeLinkedListTest.kt

@@ -4,17 +4,18 @@ package net.mamoe.mirai.utils
 
 import kotlinx.coroutines.*
 import net.mamoe.mirai.test.shouldBeEqualTo
-import net.mamoe.mirai.test.shouldBeFalse
 import net.mamoe.mirai.test.shouldBeTrue
 import org.junit.Test
 import kotlin.system.exitProcess
-import kotlin.test.*
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 
 @MiraiExperimentalAPI
 internal class LockFreeLinkedListTest {
     init {
         GlobalScope.launch {
-            delay(5000)
+            delay(30 * 1000)
             exitProcess(-100)
         }
     }
@@ -27,26 +28,41 @@ internal class LockFreeLinkedListTest {
         list.add(3)
         list.add(4)
 
-        assertEquals(list[0], 1, "Failed on list[0]")
-        assertEquals(list[1], 2, "Failed on list[1]")
-        assertEquals(list[2], 3, "Failed on list[2]")
-        assertEquals(list[3], 4, "Failed on list[3]")
+        list.size shouldBeEqualTo 4
     }
 
     @Test
-    fun addAndGetSingleConcurrent() {
+    fun addAndGetConcurrent() = runBlocking {
+        //withContext(Dispatchers.Default){
         val list = LockFreeLinkedList<Int>()
-        val add = GlobalScope.async { list.concurrentAdd(1000, 10, 1) }
-        val remove = GlobalScope.async {
-            add.join()
-            list.concurrentDo(100, 10) {
-                remove(1)
-            }
+
+        list.concurrentAdd(1000, 10, 1)
+        list.size shouldBeEqualTo 1000 * 10
+
+        list.concurrentDo(100, 10) {
+            remove(1).shouldBeTrue()
         }
-        runBlocking {
-            joinAll(add, remove)
+
+        list.size shouldBeEqualTo 1000 * 10 - 100 * 10
+        //}
+    }
+
+    @Test
+    fun addAndGetMassConcurrentAccess() = runBlocking {
+        val list = LockFreeLinkedList<Int>()
+
+        val addJob = async { list.concurrentAdd(5000, 10, 1) }
+
+        delay(10) // let addJob fly
+        if (addJob.isCompleted) {
+            error("Number of elements are not enough")
+        }
+        list.concurrentDo(1000, 10) {
+            remove(1).shouldBeTrue()
         }
-        assertEquals(1000 * 10 - 100 * 10, list.size)
+        addJob.join()
+
+        list.size shouldBeEqualTo 5000 * 10 - 1000 * 10
     }
 
     @Test
@@ -66,178 +82,112 @@ internal class LockFreeLinkedListTest {
     }
 
     @Test
-    fun getSize() {
-        val list = lockFreeLinkedListOf(1, 2, 3, 4, 5)
-        assertEquals(5, list.size)
-
-        val list2 = lockFreeLinkedListOf<Unit>()
-        assertEquals(0, list2.size)
+    fun addAll() {
+        val list = LockFreeLinkedList<Int>()
+        list.addAll(listOf(1, 2, 3, 4, 5))
+        list.size shouldBeEqualTo 5
     }
 
     @Test
-    fun contains() {
-        val list = lockFreeLinkedListOf<Int>()
-        assertFalse { list.contains(0) }
-
-        list.add(0)
-        assertTrue { list.contains(0) }
+    fun clear() {
+        val list = LockFreeLinkedList<Int>()
+        list.addAll(listOf(1, 2, 3, 4, 5))
+        list.size shouldBeEqualTo 5
+        list.clear()
+        list.size shouldBeEqualTo 0
     }
 
+    @UseExperimental(ExperimentalUnsignedTypes::class)
     @Test
-    fun containsAll() {
-        var list = lockFreeLinkedListOf(1, 2, 3)
-        assertTrue { list.containsAll(listOf(1, 2, 3)) }
-        assertTrue { list.containsAll(listOf()) }
-
-        list = lockFreeLinkedListOf(1, 2)
-        assertFalse { list.containsAll(listOf(1, 2, 3)) }
+    fun withInlineClassElements() {
+        val list = LockFreeLinkedList<UInt>()
+        list.addAll(listOf(1u, 2u, 3u, 4u, 5u))
+        list.size shouldBeEqualTo 5
 
-        list = lockFreeLinkedListOf()
-        assertTrue { list.containsAll(listOf()) }
-        assertFalse { list.containsAll(listOf(1)) }
+        list.toString() shouldBeEqualTo "[1, 2, 3, 4, 5]"
     }
 
+    /*
     @Test
     fun indexOf() {
-        val list: LockFreeLinkedList<Int> = lockFreeLinkedListOf(1, 2, 3, 3)
-        assertEquals(0, list.indexOf(1))
-        assertEquals(2, list.indexOf(3))
+    val list: LockFreeLinkedList<Int> = lockFreeLinkedListOf(1, 2, 3, 3)
+    assertEquals(0, list.indexOf(1))
+    assertEquals(2, list.indexOf(3))
 
-        assertEquals(-1, list.indexOf(4))
-    }
-
-    @Test
-    fun isEmpty() {
-        val list: LockFreeLinkedList<Int> = lockFreeLinkedListOf()
-        list.isEmpty().shouldBeTrue()
-
-        list.add(1)
-        list.isEmpty().shouldBeFalse()
+    assertEquals(-1, list.indexOf(4))
     }
 
     @Test
     fun iterator() {
-        var list: LockFreeLinkedList<Int> = lockFreeLinkedListOf(2)
-        list.forEach {
-            it shouldBeEqualTo 2
-        }
+    var list: LockFreeLinkedList<Int> = lockFreeLinkedListOf(2)
+    list.forEach {
+    it shouldBeEqualTo 2
+    }
 
-        list = lockFreeLinkedListOf(1, 2)
-        list.joinToString { it.toString() } shouldBeEqualTo "1, 2"
+    list = lockFreeLinkedListOf(1, 2)
+    list.joinToString { it.toString() } shouldBeEqualTo "1, 2"
 
 
-        list = lockFreeLinkedListOf(1, 2)
-        val iterator = list.iterator()
-        iterator.remove()
-        var reached = false
-        for (i in iterator) {
-            i shouldBeEqualTo 2
-            reached = true
-        }
-        reached shouldBeEqualTo true
+    list = lockFreeLinkedListOf(1, 2)
+    val iterator = list.iterator()
+    iterator.remove()
+    var reached = false
+    for (i in iterator) {
+    i shouldBeEqualTo 2
+    reached = true
+    }
+    reached shouldBeEqualTo true
 
-        list.joinToString { it.toString() } shouldBeEqualTo "2"
-        iterator.remove()
-        assertFailsWith<NoSuchElementException> { iterator.remove() }
+    list.joinToString { it.toString() } shouldBeEqualTo "2"
+    iterator.remove()
+    assertFailsWith<NoSuchElementException> { iterator.remove() }
     }
 
     @Test
     fun `lastIndexOf of exact 1 match at first`() {
-        val list: LockFreeLinkedList<Int> = lockFreeLinkedListOf(2, 1)
-        list.lastIndexOf(2) shouldBeEqualTo 0
+    val list: LockFreeLinkedList<Int> = lockFreeLinkedListOf(2, 1)
+    list.lastIndexOf(2) shouldBeEqualTo 0
     }
 
     @Test
     fun `lastIndexOf of exact 1 match`() {
-        val list: LockFreeLinkedList<Int> = lockFreeLinkedListOf(1, 2)
-        list.lastIndexOf(2) shouldBeEqualTo 1
+    val list: LockFreeLinkedList<Int> = lockFreeLinkedListOf(1, 2)
+    list.lastIndexOf(2) shouldBeEqualTo 1
     }
 
     @Test
     fun `lastIndexOf of multiply matches`() {
-        val list: LockFreeLinkedList<Int> = lockFreeLinkedListOf(1, 2, 2)
-        list.lastIndexOf(2) shouldBeEqualTo 2
+    val list: LockFreeLinkedList<Int> = lockFreeLinkedListOf(1, 2, 2)
+    list.lastIndexOf(2) shouldBeEqualTo 2
     }
 
     @Test
     fun `lastIndexOf of no match`() {
-        val list: LockFreeLinkedList<Int> = lockFreeLinkedListOf(2)
-        list.lastIndexOf(3) shouldBeEqualTo -1
+    val list: LockFreeLinkedList<Int> = lockFreeLinkedListOf(2)
+    list.lastIndexOf(3) shouldBeEqualTo -1
     }
 
     @Test
     fun `lastIndexOf of many elements`() {
-        val list: LockFreeLinkedList<Int> = lockFreeLinkedListOf(1, 4, 2, 3, 4, 5)
-        list.lastIndexOf(4) shouldBeEqualTo 4
-    }
-
-
-/*
-    companion object{
-        @JvmStatic
-        fun main(vararg args: String) {
-            LockFreeLinkedListTest().`lastIndexOf of many elements`()
-        }
-    }*/
-
-    @Test
-    fun listIterator() {
+    val list: LockFreeLinkedList<Int> = lockFreeLinkedListOf(1, 4, 2, 3, 4, 5)
+    list.lastIndexOf(4) shouldBeEqualTo 4
     }
 
-    @Test
-    fun testListIterator() {
-    }
-
-    @Test
-    fun subList() {
-    }
-
-    @Test
-    fun testAdd() {
-    }
-
-    @Test
-    fun addAll() {
-    }
-
-    @Test
-    fun testAddAll() {
-    }
-
-    @Test
-    fun clear() {
-    }
-
-    @Test
-    fun removeAll() {
-    }
-
-    @Test
-    fun removeAt() {
-    }
-
-    @Test
-    fun retainAll() {
-    }
-
-    @Test
-    fun set() {
-    }
+     */
 }
 
-internal fun withTimeoutBlocking(timeout: Long = 500L, block: suspend () -> Unit) = runBlocking { withTimeout(timeout) { block() } }
-
 @MiraiExperimentalAPI
-internal suspend fun <E> LockFreeLinkedList<E>.concurrentAdd(numberOfCoroutines: Int, timesOfAdd: Int, element: E) =
+internal suspend inline fun <E> LockFreeLinkedList<E>.concurrentAdd(numberOfCoroutines: Int, timesOfAdd: Int, element: E) =
     concurrentDo(numberOfCoroutines, timesOfAdd) { add(element) }
 
 @MiraiExperimentalAPI
-internal suspend fun <E : LockFreeLinkedList<*>> E.concurrentDo(numberOfCoroutines: Int, timesOfAdd: Int, todo: E.() -> Unit) = coroutineScope {
-    repeat(numberOfCoroutines) {
-        launch {
-            repeat(timesOfAdd) {
-                todo()
+internal suspend inline fun <E : LockFreeLinkedList<*>> E.concurrentDo(numberOfCoroutines: Int, timesOfAdd: Int, crossinline todo: E.() -> Unit) =
+    coroutineScope {
+        repeat(numberOfCoroutines) {
+            launch {
+                repeat(timesOfAdd) {
+                    todo()
+                }
             }
         }
-    }
-}
+    }
\ No newline at end of file
\ No newline at end of file