clean test code

src/test/java/com/alibaba/Utils.kt

@@ -6,7 +6,6 @@ import com.alibaba.ttl.TransmittableThreadLocal
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull
 import java.lang.Thread.sleep
-import java.util.*
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ConcurrentMap
 import java.util.concurrent.ExecutorService
@@ -107,7 +106,7 @@ fun <T> printTtlInstances(ttlInstances: TtlInstances<T>, title: String = "") {
     val headList =
             if (title.isBlank()) emptyList()
             else listOf("## $title [${Thread.currentThread().name}] ##")
-    val valueString = ttlInstances.filter { (_, v) -> v.get() != null }
+    val valueString = ttlInstances.filterValues { it.get() != null }
             .map { (k, v) -> "$k: ${v.get()}" }
             .joinToString()
     val output = (headList + valueString + "^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^")
@@ -124,51 +123,39 @@ fun <T> printTtlInstances(ttlInstances: TtlInstances<T>, title: String = "") {
 typealias  TtlValues<T> = Map<String, T>
 
 fun <T> copyTtlValues(ttlInstances: TtlInstances<T>): TtlValues<T> =
-        ttlInstances.filter { (_, v) -> v.get() != null }.map { (k, v) -> Pair(k, v.get()) }.toMap()
+        ttlInstances.filterValues { it.get() != null }
+                .mapValues { (_, v) -> v.get() }
 
-
-fun <T> assertTtlValues(copied: TtlValues<T>, vararg asserts: String?) {
-    val message = "Assert Fail:\ncopyTtlValues: $copied\n asserts: ${Arrays.toString(asserts)}"
-
-    if (asserts.size % 2 != 0) {
-        throw IllegalStateException("should even count! $message")
-    }
-
-    assertEquals("assertTtlValues size not equals! $message", (asserts.size / 2).toLong(), copied.size.toLong())
-
-    var i = 0
-    while (i < asserts.size) {
-        val expectedValue = asserts[i]
-
-        val ttlKey = asserts[i + 1]
-        val actual = copied[ttlKey]
-
-        assertEquals(message, expectedValue, actual)
-        i += 2
-    }
+fun <T> assertTtlValues(expected: TtlValues<T>, copied: TtlValues<T>) {
+    val message = "Assert Fail:\nexpected: $expected\ncopyTtlValues: $copied"
+    assertEquals("size not equals! $message", expected.size, copied.size)
+    assertEquals(message, expected, copied)
 }
 
 fun <T> assertChildTtlValues(tag: String, values: TtlValues<T>) {
-    assertTtlValues(values,
-            PARENT_CREATE_MODIFIED_IN_CHILD + tag, PARENT_CREATE_MODIFIED_IN_CHILD,
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            CHILD_CREATE + tag, CHILD_CREATE + tag
+    assertTtlValues(
+            mapOf(PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD + tag,
+                    PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    CHILD_CREATE + tag to CHILD_CREATE + tag),
+            values
     )
 }
 
 fun <T> assertChildTtlValuesWithParentCreateAfterCreateChild(tag: String, values: TtlValues<T>) {
-    assertTtlValues(values,
-            PARENT_CREATE_MODIFIED_IN_CHILD + tag, PARENT_CREATE_MODIFIED_IN_CHILD,
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            CHILD_CREATE + tag, CHILD_CREATE + tag,
-            PARENT_CREATE_AFTER_CREATE_CHILD, PARENT_CREATE_AFTER_CREATE_CHILD
+    assertTtlValues(
+            mapOf(PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD + tag,
+                    PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    CHILD_CREATE + tag to CHILD_CREATE + tag,
+                    PARENT_CREATE_AFTER_CREATE_CHILD to PARENT_CREATE_AFTER_CREATE_CHILD),
+            values
     )
 }
 
 fun <T> assertParentTtlValues(values: TtlValues<T>) {
-    assertTtlValues(values,
-            PARENT_CREATE_MODIFIED_IN_CHILD, PARENT_CREATE_MODIFIED_IN_CHILD, // restored after call!
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            PARENT_CREATE_AFTER_CREATE_CHILD, PARENT_CREATE_AFTER_CREATE_CHILD
+    assertTtlValues(
+            mapOf(PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD, // restored after call!
+                    PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    PARENT_CREATE_AFTER_CREATE_CHILD to PARENT_CREATE_AFTER_CREATE_CHILD),
+            values
     )
 }

src/test/java/com/alibaba/demo/agent/AgentDemo.kt

@@ -3,6 +3,7 @@
 package com.alibaba.demo.agent
 
 import com.alibaba.ttl.TransmittableThreadLocal
+import java.lang.IllegalStateException
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 import java.util.concurrent.TimeUnit
@@ -33,7 +34,7 @@ fun main(args: Array<String>) {
 
     executorService.shutdown()
     if (!executorService.awaitTermination(3, TimeUnit.SECONDS)) {
-        System.exit(1)
+        throw IllegalStateException("Fail to shutdown executorService!")
     }
 }
 

src/test/java/com/alibaba/demo/distributed_tracer/weakref/DistributedTracerUseDemo_WeakReferenceInsteadOfRefCounter.kt

@@ -5,16 +5,19 @@ import com.alibaba.ttl.TransmittableThreadLocal
 import com.alibaba.ttl.threadpool.TtlExecutors
 import java.lang.Thread.sleep
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.atomic.AtomicLong
 import kotlin.concurrent.thread
 
-private val executorService = TtlExecutors.getTtlExecutorService(
-        Executors.newFixedThreadPool(1) { r: Runnable ->
-            Thread(r, "Executors").apply { isDaemon = true }
-        }
-)
+private val executorService: ExecutorService = Executors.newFixedThreadPool(1) { r: Runnable ->
+    Thread(r, "Executors").apply { isDaemon = true }
+}.let {
+    // ensure threads in pool is pre-created.
+    expandThreadPool(it)
+    TtlExecutors.getTtlExecutorService(it)
+}
 
 /**
  * DistributedTracer(DT) use demo.
@@ -22,9 +25,6 @@ private val executorService = TtlExecutors.getTtlExecutorService(
  * @author Jerry Lee (oldratlee at gmail dot com)
  */
 fun main(args: Array<String>) {
-    // ensure threads in pool is pre-created.
-    expandThreadPool(executorService)
-
     for (i in 0..42) {
         rpcInvokeIn()
     }

src/test/java/com/alibaba/demo/forkjoinpool/Demo.kt

@@ -22,7 +22,7 @@ fun main(args: Array<String>) {
 }
 
 internal class SumTask(private val numbers: LongRange) : RecursiveTask<Long>() {
-    override fun compute(): Long? =
+    override fun compute(): Long =
             if (numbers.count() <= 16) {
                 // compute directly
                 numbers.asSequence().sum()

src/test/java/com/alibaba/third_part_lib_test/ForkJoinPoolTest.kt

@@ -43,7 +43,7 @@ class ForkJoinPoolTest {
 internal class SumTask(private val numbers: LongRange) : RecursiveTask<Long>() {
     val execCounter = AtomicInteger(0)
 
-    override fun compute(): Long? {
+    override fun compute(): Long {
         execCounter.incrementAndGet()
 
         return if (numbers.count() <= 16) {

src/test/java/com/alibaba/ttl/TtlCallableTest.kt

@@ -151,11 +151,7 @@ class TtlCallableTest {
     }
 
     companion object {
-        private val executorService = Executors.newFixedThreadPool(3)
-
-        init {
-            expandThreadPool(executorService)
-        }
+        private val executorService = Executors.newFixedThreadPool(3).also { expandThreadPool(it) }
 
         @AfterClass
         @Suppress("unused")

src/test/java/com/alibaba/ttl/TtlRunnableTest.kt

@@ -241,11 +241,7 @@ class TtlRunnableTest {
     }
 
     companion object {
-        private val executorService = Executors.newFixedThreadPool(3)
-
-        init {
-            expandThreadPool(executorService)
-        }
+        private val executorService = Executors.newFixedThreadPool(3).also { expandThreadPool(it) }
 
         @AfterClass
         @Suppress("unused")

src/test/java/com/alibaba/ttl/forkjoin/recursive_action/TtlRecursiveActionTest.kt

@@ -69,29 +69,32 @@ private fun run_test_with_pool(forkJoinPool: ForkJoinPool) {
 
 
     // child Inheritable
-    assertTtlValues(printAction.copied,
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            PARENT_CREATE_MODIFIED_IN_CHILD /* Not change*/, PARENT_CREATE_MODIFIED_IN_CHILD
+    assertTtlValues(
+            mapOf(PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD /* Not change*/),
+            printAction.copied
     )
 
     // left grand Task Inheritable, changed value
-    assertTtlValues(printAction.leftSubAction.copied,
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            PARENT_CREATE_MODIFIED_IN_CHILD + PrintAction.CHANGE_POSTFIX /* CHANGED */, PARENT_CREATE_MODIFIED_IN_CHILD
+    assertTtlValues(
+            mapOf(PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD + PrintAction.CHANGE_POSTFIX /* CHANGED */),
+            printAction.leftSubAction.copied
     )
 
     // right grand Task Inheritable, not change value
-    assertTtlValues(printAction.rightSubAction.copied,
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            PARENT_CREATE_MODIFIED_IN_CHILD /* Not change*/, PARENT_CREATE_MODIFIED_IN_CHILD
+    assertTtlValues(
+            mapOf(PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD /* Not change*/),
+            printAction.rightSubAction.copied
     )
 
     // child do not effect parent
-    assertTtlValues(copyTtlValues(ttlInstances),
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            PARENT_CREATE_MODIFIED_IN_CHILD, PARENT_CREATE_MODIFIED_IN_CHILD,
-            PARENT_CREATE_AFTER_CREATE_CHILD, PARENT_CREATE_AFTER_CREATE_CHILD
-    )
+    assertTtlValues(
+            mapOf(PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD,
+                    PARENT_CREATE_AFTER_CREATE_CHILD to PARENT_CREATE_AFTER_CREATE_CHILD),
+            copyTtlValues(ttlInstances))
 }
 
 

src/test/java/com/alibaba/ttl/forkjoin/recursive_task/TtlRecursiveTaskTest.kt

@@ -68,28 +68,32 @@ private fun run_test_with_pool(forkJoinPool: ForkJoinPool) {
 
 
     // child Inheritable
-    assertTtlValues(sumTask.copied,
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            PARENT_CREATE_MODIFIED_IN_CHILD /* Not change*/, PARENT_CREATE_MODIFIED_IN_CHILD
+    assertTtlValues(
+            mapOf(PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD /* Not change*/),
+            sumTask.copied
     )
 
     // left grand Task Inheritable, changed value
-    assertTtlValues(sumTask.leftSubTask.copied,
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            PARENT_CREATE_MODIFIED_IN_CHILD + SumTask.CHANGE_POSTFIX /* CHANGED */, PARENT_CREATE_MODIFIED_IN_CHILD
+    assertTtlValues(
+            mapOf(PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD + SumTask.CHANGE_POSTFIX /* CHANGED */),
+            sumTask.leftSubTask.copied
     )
 
     // right grand Task Inheritable, not change value
-    assertTtlValues(sumTask.rightSubTask.copied,
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            PARENT_CREATE_MODIFIED_IN_CHILD /* Not change*/, PARENT_CREATE_MODIFIED_IN_CHILD
+    assertTtlValues(
+            mapOf(PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD /* Not change*/),
+            sumTask.rightSubTask.copied
     )
 
     // child do not effect parent
-    assertTtlValues(copyTtlValues(ttlInstances),
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            PARENT_CREATE_MODIFIED_IN_CHILD, PARENT_CREATE_MODIFIED_IN_CHILD,
-            PARENT_CREATE_AFTER_CREATE_CHILD, PARENT_CREATE_AFTER_CREATE_CHILD
+    assertTtlValues(
+            mapOf(PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD,
+                    PARENT_CREATE_AFTER_CREATE_CHILD to PARENT_CREATE_AFTER_CREATE_CHILD),
+            copyTtlValues(ttlInstances)
     )
 }
 
@@ -107,7 +111,7 @@ private class SumTask(private val numbers: IntRange,
     lateinit var leftSubTask: SumTask
     lateinit var rightSubTask: SumTask
 
-    override fun compute(): Int? {
+    override fun compute(): Int {
         if (changeTtlValue) {
             modifyParentTtlInstances(CHANGE_POSTFIX, ttlMap)
         }

src/test/java/com/alibaba/ttl/testmodel/DeepCopyFooTransmittableThreadLocal.kt

@@ -6,7 +6,5 @@ import com.alibaba.ttl.TransmittableThreadLocal
  * @author Jerry Lee (oldratlee at gmail dot com)
  */
 class DeepCopyFooTransmittableThreadLocal : TransmittableThreadLocal<FooPojo>() {
-    override fun copy(parentValue: FooPojo?): FooPojo? =
-            if (parentValue == null) null else FooPojo(parentValue.name, parentValue.age)
-
+    override fun copy(parentValue: FooPojo?): FooPojo? = parentValue?.copy()
 }

src/test/java/com/alibaba/ttl/threadpool/ScheduledExecutorServiceTtlWrapperTest.kt

@@ -38,7 +38,7 @@ class ScheduledExecutorServiceTtlWrapperTest {
         createParentTtlInstancesAfterCreateChild(ttlInstances)
 
 
-        executorService!!.execute(task)
+        executorService.execute(task)
         Thread.sleep(100)
 
         // child Inheritable
@@ -53,7 +53,7 @@ class ScheduledExecutorServiceTtlWrapperTest {
         createParentTtlInstancesAfterCreateChild(ttlInstances)
 
 
-        val future = executorService!!.submit(call)
+        val future = executorService.submit(call)
         assertEquals("ok", future.get())
 
         // child Inheritable
@@ -68,7 +68,7 @@ class ScheduledExecutorServiceTtlWrapperTest {
         createParentTtlInstancesAfterCreateChild(ttlInstances)
 
 
-        val future = executorService!!.submit(task, "ok")
+        val future = executorService.submit(task, "ok")
         assertEquals("ok", future.get())
 
         // child Inheritable
@@ -83,7 +83,7 @@ class ScheduledExecutorServiceTtlWrapperTest {
         createParentTtlInstancesAfterCreateChild(ttlInstances)
 
 
-        val future = executorService!!.submit(task)
+        val future = executorService.submit(task)
         assertNull(future.get())
 
         // child Inheritable
@@ -99,7 +99,7 @@ class ScheduledExecutorServiceTtlWrapperTest {
         createParentTtlInstancesAfterCreateChild(ttlInstances)
 
 
-        val futures = executorService!!.invokeAll(Arrays.asList(call1, call2))
+        val futures = executorService.invokeAll(Arrays.asList(call1, call2))
         for (future in futures) {
             assertEquals("ok", future.get())
         }
@@ -118,7 +118,7 @@ class ScheduledExecutorServiceTtlWrapperTest {
         createParentTtlInstancesAfterCreateChild(ttlInstances)
 
 
-        val futures = executorService!!.invokeAll(Arrays.asList(call1, call2), 10, TimeUnit.SECONDS)
+        val futures = executorService.invokeAll(Arrays.asList(call1, call2), 10, TimeUnit.SECONDS)
         for (future in futures) {
             assertEquals("ok", future.get())
         }
@@ -137,7 +137,7 @@ class ScheduledExecutorServiceTtlWrapperTest {
         createParentTtlInstancesAfterCreateChild(ttlInstances)
 
 
-        val s = executorService!!.invokeAny(Arrays.asList(call1, call2))
+        val s = executorService.invokeAny(Arrays.asList(call1, call2))
         assertEquals("ok", s)
 
         assertTrue(call1.isCopied || call2.isCopied)
@@ -157,7 +157,7 @@ class ScheduledExecutorServiceTtlWrapperTest {
         createParentTtlInstancesAfterCreateChild(ttlInstances)
 
 
-        val s = executorService!!.invokeAny(Arrays.asList(call1, call2), 10, TimeUnit.SECONDS)
+        val s = executorService.invokeAny(Arrays.asList(call1, call2), 10, TimeUnit.SECONDS)
         assertEquals("ok", s)
 
         assertTrue(call1.isCopied || call2.isCopied)
@@ -177,7 +177,7 @@ class ScheduledExecutorServiceTtlWrapperTest {
         createParentTtlInstancesAfterCreateChild(ttlInstances)
 
 
-        val future = executorService!!.schedule(task, 1, TimeUnit.SECONDS)
+        val future = executorService.schedule(task, 1, TimeUnit.SECONDS)
         assertNull(future.get())
 
         // child Inheritable
@@ -191,7 +191,7 @@ class ScheduledExecutorServiceTtlWrapperTest {
         // create after new Task, won't see parent value in in task!
         createParentTtlInstancesAfterCreateChild(ttlInstances)
 
-        val future = executorService!!.schedule(call, 1, TimeUnit.SECONDS)
+        val future = executorService.schedule(call, 1, TimeUnit.SECONDS)
         assertEquals("ok", future.get())
 
         // child Inheritable
@@ -205,7 +205,7 @@ class ScheduledExecutorServiceTtlWrapperTest {
         // create after new Task, won't see parent value in in task!
         createParentTtlInstancesAfterCreateChild(ttlInstances)
 
-        val future = executorService!!.scheduleAtFixedRate(task, 0, 100, TimeUnit.SECONDS)
+        val future = executorService.scheduleAtFixedRate(task, 0, 100, TimeUnit.SECONDS)
         Thread.sleep(100)
         future.cancel(true)
 
@@ -221,7 +221,7 @@ class ScheduledExecutorServiceTtlWrapperTest {
         createParentTtlInstancesAfterCreateChild(ttlInstances)
 
 
-        val future = executorService!!.scheduleWithFixedDelay(task, 0, 50, TimeUnit.SECONDS)
+        val future = executorService.scheduleWithFixedDelay(task, 0, 50, TimeUnit.SECONDS)
 
         Thread.sleep(100)
         future.cancel(true)
@@ -231,21 +231,18 @@ class ScheduledExecutorServiceTtlWrapperTest {
     }
 
     companion object {
-        private var executorService: ScheduledExecutorService? = null
-
-        init {
-            val scheduledThreadPoolExecutor = ScheduledThreadPoolExecutor(3)
-            scheduledThreadPoolExecutor.setKeepAliveTime(1024, TimeUnit.DAYS)
-            executorService = TtlExecutors.getTtlScheduledExecutorService(scheduledThreadPoolExecutor)
-            expandThreadPool(executorService!!)
+        private val executorService: ScheduledExecutorService = ScheduledThreadPoolExecutor(3).let {
+            it.setKeepAliveTime(10, TimeUnit.SECONDS)
+            expandThreadPool(it)
+            TtlExecutors.getTtlScheduledExecutorService(it)
         }
 
         @AfterClass
         @Suppress("unused")
         fun afterClass() {
-            executorService!!.shutdown()
-            executorService!!.awaitTermination(100, TimeUnit.MILLISECONDS)
-            if (!executorService!!.isTerminated) fail("Fail to shutdown thread pool")
+            executorService.shutdown()
+            executorService.awaitTermination(100, TimeUnit.MILLISECONDS)
+            if (!executorService.isTerminated) fail("Fail to shutdown thread pool")
         }
     }
 }

src/test/java/com/alibaba/ttl/threadpool/agent/check/AgentCheckMain.kt

@@ -5,15 +5,8 @@ package com.alibaba.ttl.threadpool.agent.check
 import com.alibaba.support.junit.conditional.BelowJava7
 
 fun main(args: Array<String>) {
-    try {
-        com.alibaba.ttl.threadpool.agent.check.executor.main(args)
+    com.alibaba.ttl.threadpool.agent.check.executor.main(args)
 
-        if (!BelowJava7().isSatisfied)
-            com.alibaba.ttl.threadpool.agent.check.forkjoin.main(args)
-
-    } catch (e: Throwable) {
-        println("Exception when run AgentCheck: ")
-        e.printStackTrace(System.out)
-        System.exit(2)
-    }
+    if (!BelowJava7().isSatisfied)
+        com.alibaba.ttl.threadpool.agent.check.forkjoin.main(args)
 }

src/test/java/com/alibaba/ttl/threadpool/agent/check/forkjoin/ForkJoinTaskClassAgentCheck.kt

@@ -63,28 +63,34 @@ private fun run_test_with_pool(forkJoinPool: ForkJoinPool) {
 
 
     // child Inheritable
-    assertTtlValues(sumTask.copied,
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            PARENT_CREATE_MODIFIED_IN_CHILD /* Not change*/, PARENT_CREATE_MODIFIED_IN_CHILD
+    assertTtlValues(
+            mapOf(PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD /* Not change*/
+            ),
+            sumTask.copied
     )
 
     // left grand Task Inheritable, changed value
-    assertTtlValues(sumTask.leftSubTask.copied,
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            PARENT_CREATE_MODIFIED_IN_CHILD + SumTask.CHANGE_POSTFIX /* CHANGED */, PARENT_CREATE_MODIFIED_IN_CHILD
+    assertTtlValues(
+            mapOf(PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD + SumTask.CHANGE_POSTFIX /* CHANGED */
+            ),
+            sumTask.leftSubTask.copied
     )
 
     // right grand Task Inheritable, not change value
-    assertTtlValues(sumTask.rightSubTask.copied,
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            PARENT_CREATE_MODIFIED_IN_CHILD /* Not change*/, PARENT_CREATE_MODIFIED_IN_CHILD
+    assertTtlValues(
+            mapOf(PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD /* Not change*/),
+            sumTask.rightSubTask.copied
     )
 
     // child do not effect parent
-    assertTtlValues(copyTtlValues(ttlInstances),
-            PARENT_CREATE_UNMODIFIED_IN_CHILD, PARENT_CREATE_UNMODIFIED_IN_CHILD,
-            PARENT_CREATE_MODIFIED_IN_CHILD, PARENT_CREATE_MODIFIED_IN_CHILD,
-            PARENT_CREATE_AFTER_CREATE_CHILD, PARENT_CREATE_AFTER_CREATE_CHILD
+    assertTtlValues(
+            mapOf(PARENT_CREATE_UNMODIFIED_IN_CHILD to PARENT_CREATE_UNMODIFIED_IN_CHILD,
+                    PARENT_CREATE_MODIFIED_IN_CHILD to PARENT_CREATE_MODIFIED_IN_CHILD,
+                    PARENT_CREATE_AFTER_CREATE_CHILD to PARENT_CREATE_AFTER_CREATE_CHILD),
+            copyTtlValues(ttlInstances)
     )
 }
 
@@ -103,7 +109,7 @@ private class SumTask(private val numbers: IntRange,
     lateinit var leftSubTask: SumTask
     lateinit var rightSubTask: SumTask
 
-    override fun compute(): Int? {
+    override fun compute(): Int {
         if (changeTtlValue) {
             modifyParentTtlInstances(CHANGE_POSTFIX, ttlMap)
         }

src/test/java/com/alibaba/ttl/user_api_test/TransmittableThreadLocal_Transmitter_UserTest.kt

@@ -11,6 +11,7 @@ import org.junit.Assert.fail
 import org.junit.Rule
 import org.junit.Test
 import java.util.*
+import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 import java.util.concurrent.TimeUnit
 
@@ -101,11 +102,7 @@ class TransmittableThreadLocal_Transmitter_UserTest {
         private val PARENT = "parent: " + Date()
         private val CHILD = "child: " + Date()
 
-        private val executorService = Executors.newFixedThreadPool(3)
-
-        init {
-            expandThreadPool(executorService)
-        }
+        private val executorService: ExecutorService = Executors.newFixedThreadPool(3).also { expandThreadPool(it) }
 
         @AfterClass
         @Suppress("unused")