Тестирование произвольного кода

Lincheck предоставляет функцию runConcurrentTest() для тестирования произвольного конкурентного кода.

Функция runConcurrentTest() выполняет блок конкурентного кода несколько раз и использует проверку модели для исследования возможных расписаний выполнения.

Чтобы протестировать конкурентный код с помощью Lincheck:

1. Создайте тестовый класс:

   class CounterTestWithInvocations {
   }

2. Создайте тестовую функцию как функцию-член, используя runConcurrentTest():

       @Test
       fun test() = Lincheck.runConcurrentTest(100_000) {
           var counter = 0
   
           // Increments the counter concurrently
           val t1 = thread { counter++ }
           val t2 = thread { counter++ }
   
           // Waits for the threads to finish
           t1.join()
           t2.join()
   
           // Checks that both increments have been applied
           assertEquals(2, counter)
       }
   

3. Запустите тест. Если он завершится неудачно, Lincheck создаст отчёт с расписанием выполнения, приводящим к неправильному поведению.

   | ------------------------------------------------------------------------------- |
   |                   Main Thread                   |   Thread 1    |   Thread 2    |
   | ------------------------------------------------------------------------------- |
   | thread(block = Lambda#2): Thread#1              |               |               |
   | thread(block = Lambda#3): Thread#2              |               |               |
   | switch (reason: waiting for Thread 1 to finish) |               |               |
   |                                                 |               | run()         |
   |                                                 |               |   counter ➜ 0 |
   |                                                 |               |   switch      |
   |                                                 | run()         |               |
   |                                                 |   counter ➜ 0 |               |
   |                                                 |   counter = 1 |               |
   |                                                 |               |   counter = 1 |
   | Thread#1.join()                                 |               |               |
   | Thread#2.join()                                 |               |               |
   | counter.element ➜ 1                             |               |               |
   | assertEquals(2, 1): threw AssertionFailedError  |               |               |
   | ------------------------------------------------------------------------------- |
   

package org.lincheck.docs

import org.jetbrains.lincheck.*
import kotlin.test.Test
import java.util.concurrent.*
import kotlin.concurrent.*

// This test demonstrates a deadlock caused by two threads
// performing nested `computeIfAbsent` calls in opposite order.
class ConcurrentHashMapDeadlockTest {
    @Test
    fun test() = Lincheck.runConcurrentTest {
        val map = ConcurrentHashMap<String, String>()

        // Updates `key2` while locking `key1`.
        val thread1 = thread {
            map.computeIfAbsent("key1") {
                map.computeIfAbsent("key2") { "value2" }
                "value1"
            }
        }
        
        // Updates `key1` while locking `key2`.
        val thread2 = thread {
            map.computeIfAbsent("key2") {
                map.computeIfAbsent("key1") { "value1" }
                "value2"
            }
        }

        // Wait until both threads complete.
        thread1.join()
        thread2.join()
    }
}