From 2a7dd77570b468babc6a54f900c0ee63d818ffdf Mon Sep 17 00:00:00 2001 From: Evgeniy Moiseenko Date: Thu, 30 May 2024 14:28:29 +0200 Subject: [PATCH] fixes after rebase Signed-off-by: Evgeniy Moiseenko --- .../jetbrains/kotlinx/lincheck/LinChecker.kt | 19 ++++++++++++------- .../kotlinx/lincheck/strategy/Strategy.kt | 2 +- .../strategy/managed/ManagedStrategy.kt | 9 +++++++-- .../ModelCheckingCTestConfiguration.kt | 2 +- 4 files changed, 21 insertions(+), 11 deletions(-) diff --git a/src/jvm/main/org/jetbrains/kotlinx/lincheck/LinChecker.kt b/src/jvm/main/org/jetbrains/kotlinx/lincheck/LinChecker.kt index 1f527d3ab..c50bced39 100644 --- a/src/jvm/main/org/jetbrains/kotlinx/lincheck/LinChecker.kt +++ b/src/jvm/main/org/jetbrains/kotlinx/lincheck/LinChecker.kt @@ -86,17 +86,18 @@ class LinChecker(private val testClass: Class<*>, options: Options<*, *>?) { verifier = createVerifier() scenario.validate() reporter.logIteration(i + 1, scenariosSize, scenario) - var failure = scenario.run(i, this, verifier) + var failure = scenario.run(this, verifier) if (failure == null) return@forEachIndexed if (minimizeFailedScenario && !isCustomScenario) { var j = i + 1 reporter.logScenarioMinimization(scenario) failure = failure.minimize { minimizedScenario -> - minimizedScenario.run(j++, this, createVerifier()) + minimizedScenario.run(this, createVerifier()) } } reporter.logFailedIteration(failure) + runReplayForPlugin(failure, verifier) return failure } return null @@ -118,7 +119,6 @@ class LinChecker(private val testClass: Class<*>, options: Options<*, *>?) { } private fun ExecutionScenario.run( - iteration: Int, testCfg: CTestConfiguration, verifier: Verifier, ): LincheckFailure? { @@ -129,19 +129,24 @@ class LinChecker(private val testClass: Class<*>, options: Options<*, *>?) { stateRepresentationMethod = testStructure.stateRepresentation, ) return strategy.use { - it.runIteration(iteration, testCfg.invocationsPerIteration, verifier) + it.runIteration(testCfg.invocationsPerIteration, verifier) } } private fun CTestConfiguration.createVerifier() = verifierClass.getConstructor(Class::class.java).newInstance(sequentialSpecification) - private fun CTestConfiguration.createExecutionGenerator(randomProvider: RandomProvider) = - generatorClass.getConstructor( + private fun CTestConfiguration.createExecutionGenerator(randomProvider: RandomProvider): ExecutionGenerator { + if (iterations > 0) { + checkAtLeastOneMethodIsMarkedAsOperation(testClass) + } + val constructor = generatorClass.getConstructor( CTestConfiguration::class.java, CTestStructure::class.java, RandomProvider::class.java - ).newInstance(this, testStructure, randomProvider) + ) + return constructor.newInstance(this, testStructure, randomProvider) + } private val CTestConfiguration.invocationsPerIteration get() = when (this) { is ModelCheckingCTestConfiguration -> this.invocationsPerIteration diff --git a/src/jvm/main/org/jetbrains/kotlinx/lincheck/strategy/Strategy.kt b/src/jvm/main/org/jetbrains/kotlinx/lincheck/strategy/Strategy.kt index fca773ef0..972355f9e 100644 --- a/src/jvm/main/org/jetbrains/kotlinx/lincheck/strategy/Strategy.kt +++ b/src/jvm/main/org/jetbrains/kotlinx/lincheck/strategy/Strategy.kt @@ -101,7 +101,7 @@ abstract class Strategy protected constructor( * * @return the failure, if detected, null otherwise. */ -fun Strategy.runIteration(iteration: Int, invocationsBound: Int, verifier: Verifier): LincheckFailure? { +fun Strategy.runIteration(invocationsBound: Int, verifier: Verifier): LincheckFailure? { var spinning = false for (invocation in 0 until invocationsBound) { if (!(spinning || nextInvocation())) diff --git a/src/jvm/main/org/jetbrains/kotlinx/lincheck/strategy/managed/ManagedStrategy.kt b/src/jvm/main/org/jetbrains/kotlinx/lincheck/strategy/managed/ManagedStrategy.kt index df78e3c46..5f777dcf8 100644 --- a/src/jvm/main/org/jetbrains/kotlinx/lincheck/strategy/managed/ManagedStrategy.kt +++ b/src/jvm/main/org/jetbrains/kotlinx/lincheck/strategy/managed/ManagedStrategy.kt @@ -135,6 +135,8 @@ abstract class ManagedStrategy( override fun close() { runner.close() + // clear object numeration at the end to avoid memory leaks + cleanObjectNumeration() } private fun createRunner(): ManagedStrategyRunner = @@ -247,8 +249,11 @@ abstract class ManagedStrategy( // Therefore, if the runner detects deadlock, we don't even try to collect trace. if (loggedResults is RunnerTimeoutInvocationResult) return null val sameResultTypes = loggedResults.javaClass == result.javaClass - val sameResults = - loggedResults !is CompletedInvocationResult || result !is CompletedInvocationResult || loggedResults.results == failingResult.results + val sameResults = ( + loggedResults !is CompletedInvocationResult || + result !is CompletedInvocationResult || + loggedResults.results == result.results + ) check(sameResultTypes && sameResults) { StringBuilder().apply { appendln("Non-determinism found. Probably caused by non-deterministic code (WeakHashMap, Object.hashCode, etc).") diff --git a/src/jvm/main/org/jetbrains/kotlinx/lincheck/strategy/managed/modelchecking/ModelCheckingCTestConfiguration.kt b/src/jvm/main/org/jetbrains/kotlinx/lincheck/strategy/managed/modelchecking/ModelCheckingCTestConfiguration.kt index 88020c2cd..2fa92c3a2 100644 --- a/src/jvm/main/org/jetbrains/kotlinx/lincheck/strategy/managed/modelchecking/ModelCheckingCTestConfiguration.kt +++ b/src/jvm/main/org/jetbrains/kotlinx/lincheck/strategy/managed/modelchecking/ModelCheckingCTestConfiguration.kt @@ -59,5 +59,5 @@ class ModelCheckingCTestConfiguration(testClass: Class<*>, iterations: Int, thre scenario: ExecutionScenario, validationFunction: Actor?, stateRepresentationMethod: Method?, - ): Strategy = ModelCheckingStrategy(this, testClass, scenario, validationFunction, stateRepresentationMethod) + ): Strategy = ModelCheckingStrategy(this, testClass, scenario, validationFunction, stateRepresentationMethod, isReplayModeForIdeaPluginEnabled) }