From 0ded0278b5771d5b1a08d0060eb750345822d8f5 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Tue, 23 Jul 2024 13:22:51 +0200 Subject: [PATCH 01/34] First approach with random selection --- .../ga/metaheuristics/mosa/DynaMOSA.java | 66 +-- .../org/evosuite/kex/KexTestGenerator.kt | 201 +++++--- .../evosuite/kex/observers/KexTestObserver.kt | 448 ++++++++++++++++++ 3 files changed, 618 insertions(+), 97 deletions(-) create mode 100644 client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt diff --git a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java index a093ae6ff4..0db15a1eca 100644 --- a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java +++ b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java @@ -27,15 +27,11 @@ import org.evosuite.ga.metaheuristics.mosa.structural.MultiCriteriaManager; import org.evosuite.ga.operators.ranking.CrowdingDistance; import org.evosuite.kex.KexTestGenerator; -import org.evosuite.testcase.TestCase; -import org.evosuite.testcase.TestChromosome; +import org.evosuite.testcase.*; import org.evosuite.utils.LoggingUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; +import java.util.*; /** * Implementation of the DynaMOSA (Many Objective Sorting Algorithm) described in the paper @@ -73,58 +69,46 @@ public DynaMOSA(ChromosomeFactory factory) { super(factory); } + private List generateTests(long time) { + List res = new ArrayList<>(); + logger.info("Start generation"); + int i = 0; + while (maxGenerateTests == -1 || i < maxGenerateTests) { + TestCase testCase = kexTestGenerator.generateTest(); + if (testCase != null) { + TestChromosome test = new TestChromosome(); + test.setTestCase(testCase); + res.add(test); + calculateFitness(test); + logger.debug("Covered goals: {}", testCase.getCoveredGoals().size()); + } + i++; + } + return res; + } + /** {@inheritDoc} */ @Override protected void evolve() { List additional = Collections.emptyList(); - if (stallLen > maxStallLen) { + if (true) { logger.info("Run test generation using kex"); - stallLen = 0; wasTargeted = true; - - additional = new ArrayList<>(); - - logger.info("Constraints collection"); long startTime = System.currentTimeMillis(); List solutions = getSolutions(); statLogger.debug("Current solutions: {}", solutions.size()); -// statLogger.debug("-----------------------"); -// for (TestChromosome solution : solutions) { -// statLogger.debug(solution.toString()); -// statLogger.debug("-----------------------"); -// } kexTestGenerator.collectTraces( solutions, - () -> System.currentTimeMillis() - startTime > kexExecutionTimeout + () -> false ); long endExecutionTime = System.currentTimeMillis(); - logger.info("Start generation"); - Function0 stoppingCondition = - () -> System.currentTimeMillis() - endExecutionTime > kexGenerationTimeout; - int i = 0; - while (maxGenerateTests == -1 || i < maxGenerateTests) { - TestCase testCase = kexTestGenerator.generateTest(stoppingCondition); - if (testCase == null) { - break; - } - TestChromosome test = new TestChromosome(); - test.setTestCase(testCase); - additional.add(test); - calculateFitness(test); - logger.debug("Covered goals: {}", testCase.getCoveredGoals().size()); - i++; - } + logger.info("Start generating tests"); + additional = generateTests(endExecutionTime); + long endTime = System.currentTimeMillis(); statLogger.debug("Test cases generated: {}", additional.size()); -// statLogger.debug("---------------------"); -// for (TestChromosome test: additional) { -// statLogger.debug(test.toString()); -// statLogger.debug("----------------------"); -// } - statLogger.debug("Kex generation time: {}", endTime - endExecutionTime); - statLogger.debug("Kex execution time: {}", endExecutionTime - startTime); statLogger.debug("Kex iteration time: {}", endTime - startTime); if (additional.isEmpty()) { diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index d600a36aa6..d783628d36 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -1,32 +1,50 @@ package org.evosuite.kex +import kotlinx.collections.immutable.PersistentList +import kotlinx.collections.immutable.PersistentMap +import kotlinx.collections.immutable.toPersistentList +import kotlinx.collections.immutable.toPersistentMap import kotlinx.coroutines.DelicateCoroutinesApi import kotlinx.coroutines.runBlocking import kotlinx.coroutines.withTimeoutOrNull +import kotlinx.serialization.Contextual import kotlinx.serialization.ExperimentalSerializationApi import kotlinx.serialization.InternalSerializationApi import org.evosuite.Properties -import org.evosuite.kex.observers.KexStatementObserver +import org.evosuite.kex.observers.KexTestObserver import org.evosuite.testcase.DefaultTestCase import org.evosuite.testcase.TestCase import org.evosuite.testcase.TestChromosome +import org.evosuite.testcase.statements.PrimitiveStatement import org.slf4j.LoggerFactory +import org.vorpal.research.kex.asm.analysis.concolic.bfs.BfsPathSelectorImpl import org.vorpal.research.kex.asm.analysis.concolic.coverage.CoverageGuidedSelector import org.vorpal.research.kex.asm.analysis.concolic.coverage.CoverageGuidedSelectorManager import org.vorpal.research.kex.asm.state.PredicateStateAnalysis import org.vorpal.research.kex.config.kexConfig import org.vorpal.research.kex.descriptor.Descriptor +import org.vorpal.research.kex.ktype.KexType +import org.vorpal.research.kex.mocking.performMocking import org.vorpal.research.kex.parameters.Parameters +import org.vorpal.research.kex.parameters.concreteParameters +import org.vorpal.research.kex.parameters.filterIgnoredStatic +import org.vorpal.research.kex.parameters.filterStaticFinals import org.vorpal.research.kex.reanimator.actionsequence.ActionSequence import org.vorpal.research.kex.reanimator.actionsequence.generator.ConcolicSequenceGenerator import org.vorpal.research.kex.reanimator.rtUnmapped -import org.vorpal.research.kex.trace.symbolic.SymbolicState -import org.vorpal.research.kex.trace.symbolic.persistentSymbolicState +import org.vorpal.research.kex.smt.AsyncChecker +import org.vorpal.research.kex.smt.Checker +import org.vorpal.research.kex.smt.SMTModel +import org.vorpal.research.kex.state.PredicateState +import org.vorpal.research.kex.state.term.* +import org.vorpal.research.kex.state.transformer.generateInitialDescriptors +import org.vorpal.research.kex.trace.symbolic.* import org.vorpal.research.kex.trace.symbolic.protocol.SuccessResult import org.vorpal.research.kex.util.asmString -import org.vorpal.research.kex.util.javaString -import org.vorpal.research.kfg.ir.Method +import org.vorpal.research.kfg.Package +import org.vorpal.research.kfg.ir.* import org.vorpal.research.kfg.ir.value.instruction.Instruction +import org.vorpal.research.kthelper.assert.unreachable import java.util.* import kotlin.time.Duration.Companion.seconds import kotlin.time.ExperimentalTime @@ -48,10 +66,7 @@ class KexTestGenerator { ) ) private val asGenerator = ConcolicSequenceGenerator(ctx, PredicateStateAnalysis(ctx.cm)) - private val cache = WeakHashMap() - - private val Method.isTargetMethod: Boolean - get() = klass.fullName.javaString == Properties.TARGET_CLASS + private val cache = WeakHashMap() fun collectTraces(testChromosomes: List, stoppingCondition: () -> Boolean) { runBlocking { @@ -61,19 +76,11 @@ class KexTestGenerator { if (test in cache) continue try { - val observer = KexStatementObserver(ctx) + val observer = KexTestObserver(ctx) val testCaseClone = test.testCase.clone() as DefaultTestCase - KexService.execute(testCaseClone, observer)?.let { - observer.results.forEach { (key, value) -> - val (state, trace) = value - if (state.isNotEmpty() - && trace.first().parent.method.isTargetMethod - ) { - updateWithTrace(trace, state, key.method) - } - } - } - cache[test] = true + KexService.execute(testCaseClone, observer) + + cache[test] = observer.trace } catch (e: Throwable) { logger.error("Error occurred while running test:\n{}", test, e) } @@ -85,56 +92,138 @@ class KexTestGenerator { pathSelector.addExecutionTrace(method, persistentSymbolicState(), SuccessResult(trace, state)) } - fun generateTest(stoppingCondition: () -> Boolean): TestCase? = runBlocking { + fun generateTest(): TestCase? = runBlocking { logger.info("Generating test with kex") - while (pathSelector.hasNext() && !stoppingCondition()) { - val (method, state) = pathSelector.next() - val timeout = 4 * kexConfig.getIntValue("smt", "timeout", 3) - try { - val test = withTimeoutOrNull(timeout.seconds) { - val parameters = state.checkAndGetParameters(ctx, method) - parameters?.let { generateTest(it, method) } - } ?: continue - logger.info("Test is generated successfully") - return@runBlocking test - } catch (e: Throwable) { - logger.error("Error occurred while generating test for state:\n{}", state, e) + val mth = buildMethod() + var chosenTest: TestChromosome + var chosenPathClauseIndex: Pair + do { + chosenTest = chooseTestCase() + chosenPathClauseIndex = choosePathClause(chosenTest) + } while(chosenPathClauseIndex.first == -1) + + val prevState = cache[chosenTest]!! + val clauseList = prevState.clauses.take(chosenPathClauseIndex.first).toMutableList() + val pathList = prevState.path.take(chosenPathClauseIndex.second).toMutableList() + val reversed = BfsPathSelectorImpl(ctx, mth).reverse(pathList.last())!! + clauseList[clauseList.size - 1] = reversed + pathList[pathList.size - 1] = reversed + + val state = PersistentSymbolicState( + PersistentClauseList(clauseList.toPersistentList()), + PersistentPathCondition(pathList.toPersistentList()), + prevState.concreteTypes.toPersistentMap(), + prevState.concreteValues.toPersistentMap(), + prevState.termMap.toPersistentMap() + ) + + val result = state.check(ctx) ?: return@runBlocking null + return@runBlocking generateTest(chosenTest.testCase, result) + }.also { + logger.debug("Kex produce new test:\n{}", it) + } + + private fun findNext(assignments: Map, previous: String? = null): Term? { + var flag = previous == null + for ((key, _) in assignments) { + if (!key.name.contains("primitive")) { continue } + if (key.name == previous) { + flag = true + continue + } + if (flag) { + return key + } } - logger.info("Unsuccessful in the test generation") - null - }.also { - logger.debug("Kex produce new test:\n{}", it) + return null } + private fun generateTest(oldTest: TestCase, result: SMTModel): TestCase? { + var isTestChanged = false + val newTest = DefaultTestCase() + var curPrimitiveName = findNext(result.assignments) + for (s in oldTest) { + if (curPrimitiveName == null) { + return null + } + if (s is PrimitiveStatement<*>) { + isTestChanged = true + when (result.assignments[curPrimitiveName]) { + is ConstIntTerm -> { + s.value = (result.assignments[curPrimitiveName] as ConstIntTerm).value + } - private val Descriptor.actionSequence: ActionSequence - get() = asGenerator.generate(this) + is ConstLongTerm -> { + s.value = (result.assignments[curPrimitiveName] as ConstLongTerm).value + } - private val Parameters.actionSequences: Parameters - get() { - val thisSequence = instance?.actionSequence - val argSequences = arguments.map { it.actionSequence } - val staticFields = statics.mapTo(mutableSetOf()) { it.actionSequence } - return Parameters(thisSequence, argSequences, staticFields) - } + is ConstFloatTerm -> { + s.value = (result.assignments[curPrimitiveName] as ConstFloatTerm).value + } - private fun generateTest(parameters: Parameters, method: Method): TestCase { - logger.debug("Start test generation for {} with {}", method.toString(), parameters.toString()) + is ConstDoubleTerm -> { + s.value = (result.assignments[curPrimitiveName] as ConstDoubleTerm).value + } + + is ConstStringTerm -> { + s.value = (result.assignments[curPrimitiveName] as ConstStringTerm).value + } + + is ConstShortTerm -> { + s.value = (result.assignments[curPrimitiveName] as ConstShortTerm).value + } - val actionParameters = parameters.actionSequences.rtUnmapped - val testCase = DefaultTestCase() - val generator = ActionSequence2EvosuiteStatements(testCase) + is ConstByteTerm -> { + s.value = (result.assignments[curPrimitiveName] as ConstByteTerm).value + } + + is ConstCharTerm -> { + s.value = (result.assignments[curPrimitiveName] as ConstCharTerm).value + } + + is ConstBoolTerm -> { + s.value = (result.assignments[curPrimitiveName] as ConstBoolTerm).value + } - for (seq in actionParameters.asList) { - generator.generateStatements(seq) + else -> unreachable {} + } + curPrimitiveName = findNext(result.assignments, curPrimitiveName?.name) + } + newTest.addStatement(s) } - generator.generateTestCall(method, actionParameters) + if (isTestChanged) + return newTest + return null + } - return testCase + private fun chooseTestCase(): TestChromosome { + return cache.keys.random() } + private fun choosePathClause(chosenTest: TestChromosome): Pair { + if (cache[chosenTest]!!.path.path.isEmpty()) + return -1 to -1 + val number = (0 until cache[chosenTest]!!.path.path.size).random() + var counter = 0 + for (i in 0 until cache[chosenTest]!!.clauses.state.size) { + if (cache[chosenTest]!!.clauses.state[i] is PathClause) { + if (counter == number) { + return i + 1 to number + 1 + } + counter += 1 + } + } + return -1 to -1 + } + + private fun buildMethod(): Method { + val cm = KexService.ctx.cm + val klass: Class = OuterClass(cm, Package(""), "TestClass", Modifiers(0)) + val testDescriptor = MethodDescriptor(emptyList(), cm.type.voidType) + return Method(cm, klass, "name", testDescriptor) + } } \ No newline at end of file diff --git a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt new file mode 100644 index 0000000000..7de5cd0c39 --- /dev/null +++ b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt @@ -0,0 +1,448 @@ +package org.evosuite.kex.observers + +import org.evosuite.testcase.execution.ExecutionResult +import org.evosuite.testcase.execution.Scope +import org.evosuite.testcase.statements.* +import org.evosuite.testcase.statements.environment.EnvironmentDataStatement +import org.evosuite.testcase.variable.* +import org.vorpal.research.kex.ExecutionContext +import org.vorpal.research.kex.ktype.KexType +import org.vorpal.research.kex.ktype.kexType +import org.vorpal.research.kex.parameters.Parameters +import org.vorpal.research.kex.state.predicate.Predicate +import org.vorpal.research.kex.state.predicate.state +import org.vorpal.research.kex.state.term.Term +import org.vorpal.research.kex.state.term.TermBuilder.Terms.const +import org.vorpal.research.kex.state.term.TermBuilder.Terms.field +import org.vorpal.research.kex.state.term.TermBuilder.Terms.load +import org.vorpal.research.kex.state.term.TermBuilder.Terms.staticRef +import org.vorpal.research.kex.state.term.term +import org.vorpal.research.kex.trace.symbolic.InstructionTraceCollector +import org.vorpal.research.kex.trace.symbolic.StateClause +import org.vorpal.research.kex.trace.symbolic.SymbolicTraceBuilder +import org.vorpal.research.kex.trace.symbolic.TraceCollectorProxy.disableCollector +import org.vorpal.research.kex.trace.symbolic.TraceCollectorProxy.enableCollector +import org.vorpal.research.kex.trace.symbolic.TraceCollectorProxy.initializeEmptyCollector +import org.vorpal.research.kex.trace.symbolic.TraceCollectorProxy.setCurrentCollector +import org.vorpal.research.kex.util.toKfgType +import org.vorpal.research.kfg.ClassManager +import org.vorpal.research.kfg.ir.Field +import org.vorpal.research.kfg.ir.value.EmptyUsageContext +import org.vorpal.research.kfg.ir.value.NameMapperContext +import org.vorpal.research.kfg.ir.value.UsageContext +import org.vorpal.research.kfg.ir.value.Value +import org.vorpal.research.kfg.ir.value.instruction.BinaryOpcode +import org.vorpal.research.kfg.ir.value.instruction.CmpOpcode +import org.vorpal.research.kfg.ir.value.instruction.Instruction +import org.vorpal.research.kfg.ir.value.instruction.InstructionBuilder +import org.vorpal.research.kthelper.assert.unreachable +import ru.spbstu.wheels.runIf +import java.lang.reflect.Method + +private typealias KFGMethod = org.vorpal.research.kfg.ir.Method + +// TODO: refactor KexObserver and SymbolicTraceBuilder +class KexTestObserver(executionContext: ExecutionContext, private val id: Int = 0) : KexObserver(executionContext), + InstructionBuilder { + sealed interface WrappedValue { + val value: Value + + val type: KexType get() = value.type.kexType + val name: String get() = value.name.toString() + } + + private data class KexValue(override val value: Value) : WrappedValue + + private data class EvoVar(val refName: String, override val value: Value) : WrappedValue + + private fun Value.wrap() = KexValue(this) + private fun VariableReference.wrap(value: Value) = EvoVar(name, value) + + override val cm: ClassManager + get() = executionContext.cm + override val ctx: UsageContext = EmptyUsageContext + + private var collector: SymbolicTraceBuilder + private val emptyCollector: InstructionTraceCollector + + private val stateBuilder get() = collector.stateBuilder + + val valueCache = mutableMapOf() + val termCache = mutableMapOf() + val nameCache = mutableMapOf() + + val trace get() = collector.symbolicState + + val result get() = collector.stateBuilder + + init { + collector = enableCollector(executionContext, NameMapperContext()) as SymbolicTraceBuilder + emptyCollector = initializeEmptyCollector() + } + + override fun beforeStatement(statement: Statement, scope: Scope) { + super.beforeStatement(statement, scope) + setCurrentCollector(collector) + } + + private fun buildField(field: Field, source: WrappedValue?, name: String): Pair { + val instruction = if (field.isStatic) { + field.load(name) + } else { + source!!.value.load(name, field) + } + + val ownerTerm = source?.let { mkTerm(it) } + val actualOwner = ownerTerm ?: staticRef(field.klass) + val term = actualOwner.field(field.type.kexType, field.name).load() + + return instruction to term + } + + override fun beforeField(statement: FieldStatement, scope: Scope) { + val field = statement.field.kfgField + val source = statement.source?.let { mkValue(it) } + + val (instruction, loadTerm) = buildField(field, source, statement.returnValue.name) + val valueTerm = register(statement.returnValue, instruction) + val predicate = state { valueTerm equality loadTerm } + + postProcess(instruction, predicate) + } + + override fun beforeArray(statement: ArrayStatement, scope: Scope) { + // TODO: probably make dims symbolic + val componentType = types.get(statement.arrayReference.componentClass) + val dims = statement.lengths.map { it.asValue } + val instruction = componentType.asArray.newArray(statement.arrayReference.name, dims) + + val valueTerm = register(statement.returnValue, instruction) + val dimsTerm = statement.lengths.map { const(it) } + val predicate = state { + valueTerm.new(dimsTerm) + } + + postProcess(instruction, predicate) + } + + override fun beforeConstructor(statement: ConstructorStatement, scope: Scope) { + val constructor = statement.constructor.constructor.kfgMethod + val args = statement.parameterReferences.map { mkValue(it) } + + val newInst = constructor.klass.new(statement.returnValue.name) + val newTerm = register(statement.returnValue, newInst) + val predicate = state { + newTerm.new() + } + postProcess(newInst, predicate) + + collector.lastCall = buildCall(constructor, null, mkValue(statement.returnValue), args, scope) + } + + override fun beforeMethod(statement: MethodStatement, scope: Scope) { + val method = statement.method.method.kfgMethod + val callee = statement.callee?.let { mkValue(it) } + val args = statement.parameterReferences.map { mkValue(it) } + + collector.lastCall = buildCall(method, statement.returnValue, callee, args, scope) + } + + private fun buildCall( + method: KFGMethod, + returnValue: VariableReference?, + callee: WrappedValue?, + args: List, + scope: Scope + ): SymbolicTraceBuilder.Call { + val unwrappedArgs = args.map { it.value } + val name = returnValue?.name + val isVoid = returnValue?.type?.let { it == Void.TYPE } ?: true + val instruction = when { + method.isStatic && isVoid -> method.staticCall(method.klass, unwrappedArgs) + method.isStatic -> method.staticCall(method.klass, name!!, unwrappedArgs) + + method.isConstructor -> method.specialCall(method.klass, callee!!.value, unwrappedArgs) + + method.klass.isInterface && isVoid -> method.interfaceCall(method.klass, callee!!.value, unwrappedArgs) + method.klass.isInterface -> method.interfaceCall(method.klass, name!!, callee!!.value, unwrappedArgs) + + isVoid -> method.virtualCall(method.klass, callee!!.value, unwrappedArgs) + else -> method.virtualCall(method.klass, name!!, callee!!.value, unwrappedArgs) + } + + val valueTerm = runIf(!isVoid) { register(returnValue!!, instruction) } + val calleeTerm = callee?.let { mkTerm(it) } + val argsTerm = args.map { mkTerm(it) } + + val predicate = state { + val actualCallee = calleeTerm ?: staticRef(method.klass) + val callTerm = actualCallee.call(method, argsTerm) + valueTerm?.call(callTerm) ?: call(callTerm) + } + + return SymbolicTraceBuilder.Call( + instruction, method, + valueTerm?.let { instruction to it }, + Parameters(calleeTerm, argsTerm), predicate + ) + } + + override fun beforeMock(statement: FunctionalMockStatement, scope: Scope) { + TODO("Not supported in Kex") + } + + override fun beforeExpression(statement: PrimitiveExpression, scope: Scope) { + val lhv = mkValue(statement.leftOperand) + val rhv = mkValue(statement.rightOperand) + + val binOpcode = statement.operator.getBinOpcode() + val cmpOpcode = statement.operator.getCmpOpcode() + + val name = statement.returnValue.name + val instruction = if (binOpcode != null) { + binary(name, binOpcode, lhv.value, rhv.value) + } else if (cmpOpcode != null) { + cmp(name, statement.returnClass.toKfgType(types), cmpOpcode, lhv.value, rhv.value) + } else { + unreachable { } + } + + val valueTerm = register(statement.returnValue, instruction) + val lhvTerm = mkTerm(lhv) + val rhvTerm = mkTerm(rhv) + + val predicate = state { + if (binOpcode != null) { + valueTerm equality lhvTerm.apply(types, binOpcode, rhvTerm) + } else if (cmpOpcode != null) { + valueTerm equality lhvTerm.apply(cmpOpcode, rhvTerm) + } else { + unreachable { } + } + } + + postProcess(instruction, predicate) + } + + private fun PrimitiveExpression.Operator.getCmpOpcode(): CmpOpcode? = when (this) { + PrimitiveExpression.Operator.LESS -> CmpOpcode.LT + PrimitiveExpression.Operator.GREATER -> CmpOpcode.GT + PrimitiveExpression.Operator.LESS_EQUALS -> CmpOpcode.LE + PrimitiveExpression.Operator.GREATER_EQUALS -> CmpOpcode.GE + PrimitiveExpression.Operator.EQUALS -> CmpOpcode.EQ + PrimitiveExpression.Operator.NOT_EQUALS -> CmpOpcode.NEQ + else -> null + } + + private fun PrimitiveExpression.Operator.getBinOpcode(): BinaryOpcode? = when (this) { + PrimitiveExpression.Operator.TIMES -> BinaryOpcode.MUL + PrimitiveExpression.Operator.DIVIDE -> BinaryOpcode.DIV + PrimitiveExpression.Operator.REMAINDER -> BinaryOpcode.REM + PrimitiveExpression.Operator.PLUS -> BinaryOpcode.ADD + PrimitiveExpression.Operator.MINUS -> BinaryOpcode.SUB + PrimitiveExpression.Operator.LEFT_SHIFT -> BinaryOpcode.SHL + PrimitiveExpression.Operator.RIGHT_SHIFT_SIGNED -> BinaryOpcode.SHR + PrimitiveExpression.Operator.RIGHT_SHIFT_UNSIGNED -> BinaryOpcode.USHR + PrimitiveExpression.Operator.XOR -> BinaryOpcode.XOR + PrimitiveExpression.Operator.AND, PrimitiveExpression.Operator.CONDITIONAL_AND -> BinaryOpcode.AND + PrimitiveExpression.Operator.OR, PrimitiveExpression.Operator.CONDITIONAL_OR -> BinaryOpcode.OR + else -> null + } + + override fun beforeAssignment(statement: AssignmentStatement, scope: Scope) { + val value = mkValue(statement.value) + val termValue = mkTerm(value) + + val clause = when (val retval = statement.returnValue) { + is ArrayIndex -> { + // TODO: probably make index symbolic + val array = mkValue(retval.array) + val instruction = array.value.store(retval.arrayIndex, value.value) + + val arrayTerm = mkTerm(array) + val predicate = state { arrayTerm[retval.arrayIndex].store(termValue) } + + StateClause(instruction, predicate) + } + + is FieldReference -> { + val field = retval.field.kfgField + val owner = retval.source?.let { mkValue(it) } + + val instruction = if (retval.field.isStatic) { + field.store(value.value) + } else { + owner!!.value.store(field, value.value) + } + + val termOwner = owner?.let { mkTerm(it) } + + val predicate = state { + val actualOwner = termOwner ?: staticRef(field.klass) + actualOwner.field(field.type.kexType, field.name).store(termValue) + } + + StateClause(instruction, predicate) + } + + else -> unreachable { } + } + + postProcess(clause) + } + + override fun beforePrimitive(statement: PrimitiveStatement<*>, scope: Scope) { + when (statement) { + is EnumPrimitiveStatement<*> -> TODO() + is EnvironmentDataStatement<*> -> TODO("need more research here") + else -> { + val value = buildValue(statement.value, statement.returnClass) + modifyName(statement.returnValue.name, "primitive%" + value.name + "%" + statement.returnValue.name) + register(statement.returnValue, value) + } + } + } + + private fun postProcess(instruction: Instruction, predicate: Predicate) { + postProcess(StateClause(instruction, predicate)) + } + + private fun postProcess(clause: StateClause) { + stateBuilder += clause + } + + private fun modifyName(old: String, new: String) { + nameCache[old] = new + } + + private fun getName(refName: String) = nameCache.getOrElse(refName) {refName} + + private fun register(ref: VariableReference, value: Value): Term { + val wrapped = ref.wrap(value) + valueCache[getName(ref.name)] = wrapped + return mkNewTerm(wrapped, getName(ref.name)) + } + + private fun mkValue(ref: VariableReference): WrappedValue = + valueCache.getOrElse(getName(ref.name)) { mkNewValue(ref) } + + private fun mkNewValue(ref: VariableReference): WrappedValue { + var needCaching = true + + val value = when (ref) { + is NullReference -> ref.wrap(values.nullConstant) + is ConstantValue -> ref.wrap(buildValue(ref.value, ref.variableClass)) + is ArrayIndex -> { + // TODO: probably make index symbolic + needCaching = false + + val array = mkValue(ref.array) + val instruction = array.value.load(TMP_NAME, ref.arrayIndex) + val wrappedInstruction = instruction.wrap() + + val arrayTerm = mkTerm(array) + val valueTerm = mkNewTerm(wrappedInstruction) + val predicate = state { valueTerm equality arrayTerm[ref.arrayIndex].load() } + postProcess(instruction, predicate) + + wrappedInstruction + } + + is FieldReference -> { + needCaching = false + + val field = ref.field.kfgField + val source = ref.source?.let { mkValue(it) } + + val (instruction, loadTerm) = buildField(field, source, TMP_NAME) + val wrappedInstruction = instruction.wrap() + val valueTerm = mkNewTerm(wrappedInstruction) + val predicate = state { valueTerm equality loadTerm } + postProcess(instruction, predicate) + + wrappedInstruction + } + + else -> unreachable { } + } + + if (needCaching) { + valueCache[getName(ref.name)] = value + } + return value + } + + private fun buildValue(value: Any?, clazz: Class<*>): Value = when (clazz) { + Boolean::class.java -> { + values.getBool(value as Boolean) + } + Byte::class.java -> { + values.getByte(value as Byte) + } + Char::class.java -> { + values.getChar(value as Char) + } + Short::class.java -> { + values.getShort(value as Short) + } + Int::class.java -> { + values.getInt(value as Int) + } + Long::class.java -> { + values.getLong(value as Long) + } + Float::class.java -> { + values.getFloat(value as Float) + } + Double::class.java -> { + values.getDouble(value as Double) + } + String::class.java -> { + values.getString(value as String) + } + Class::class.java -> { + values.getClass(types.get(value as Class<*>)) + } + Method::class.java -> { + values.getMethod((value as Method).kfgMethod) + } + else -> unreachable { } + } + + private fun mkTerm(value: WrappedValue): Term = termCache.getOrElse(value) { mkNewTerm(value) } + + private fun mkNewTerm(value: WrappedValue, name: String? = null): Term = term { + termFactory.getValue( + value.type, + collector.nameGenerator.nextName("$evoPrefix${name ?: value.name}") + ) + }.also { termCache[value] = it } + + override fun afterStatement(statement: Statement, scope: Scope, exception: Throwable?) { + setCurrentCollector(emptyCollector) + + collector.lastCall?.let { + postProcess(it.call, it.predicate) + } + collector.lastCall = null + } + + override fun testExecutionFinished(r: ExecutionResult, s: Scope) { + disableCollector() + } + + override fun clear() { + collector = SymbolicTraceBuilder(executionContext, NameMapperContext()) + valueCache.clear() + termCache.clear() + setCurrentCollector(emptyCollector) + } + + private val evoPrefix = "$EVO_NAME$id%" + + companion object { + private const val TMP_NAME = "tmp" + const val EVO_NAME = "%evo%" + } + +} \ No newline at end of file From 581b36a7520782303a651ba5278c31969c02ead3 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Tue, 23 Jul 2024 13:39:16 +0200 Subject: [PATCH 02/34] fix --- client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt | 1 + 1 file changed, 1 insertion(+) diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index d783628d36..aa26610a23 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -205,6 +205,7 @@ class KexTestGenerator { } private fun choosePathClause(chosenTest: TestChromosome): Pair { + if (cache[chosenTest] == null) return -1 to -1 if (cache[chosenTest]!!.path.path.isEmpty()) return -1 to -1 val number = (0 until cache[chosenTest]!!.path.path.size).random() From f91ecc9121ce074b8cbdee4f274644b3681ba33a Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Thu, 25 Jul 2024 18:02:11 +0200 Subject: [PATCH 03/34] basic idea of state splitting --- .../org/evosuite/kex/KexTestGenerator.kt | 201 +++++++++++------- .../evosuite/kex/observers/KexTestObserver.kt | 4 +- 2 files changed, 125 insertions(+), 80 deletions(-) diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index aa26610a23..daba4bc6d1 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -1,13 +1,9 @@ package org.evosuite.kex -import kotlinx.collections.immutable.PersistentList -import kotlinx.collections.immutable.PersistentMap import kotlinx.collections.immutable.toPersistentList import kotlinx.collections.immutable.toPersistentMap import kotlinx.coroutines.DelicateCoroutinesApi import kotlinx.coroutines.runBlocking -import kotlinx.coroutines.withTimeoutOrNull -import kotlinx.serialization.Contextual import kotlinx.serialization.ExperimentalSerializationApi import kotlinx.serialization.InternalSerializationApi import org.evosuite.Properties @@ -16,37 +12,33 @@ import org.evosuite.testcase.DefaultTestCase import org.evosuite.testcase.TestCase import org.evosuite.testcase.TestChromosome import org.evosuite.testcase.statements.PrimitiveStatement +import org.evosuite.testcase.statements.StringPrimitiveStatement +import org.evosuite.testcase.statements.numeric.BooleanPrimitiveStatement +import org.evosuite.testcase.statements.numeric.BytePrimitiveStatement +import org.evosuite.testcase.statements.numeric.CharPrimitiveStatement +import org.evosuite.testcase.statements.numeric.DoublePrimitiveStatement +import org.evosuite.testcase.statements.numeric.FloatPrimitiveStatement +import org.evosuite.testcase.statements.numeric.IntPrimitiveStatement +import org.evosuite.testcase.statements.numeric.LongPrimitiveStatement +import org.evosuite.testcase.statements.numeric.ShortPrimitiveStatement import org.slf4j.LoggerFactory import org.vorpal.research.kex.asm.analysis.concolic.bfs.BfsPathSelectorImpl -import org.vorpal.research.kex.asm.analysis.concolic.coverage.CoverageGuidedSelector -import org.vorpal.research.kex.asm.analysis.concolic.coverage.CoverageGuidedSelectorManager -import org.vorpal.research.kex.asm.state.PredicateStateAnalysis -import org.vorpal.research.kex.config.kexConfig -import org.vorpal.research.kex.descriptor.Descriptor -import org.vorpal.research.kex.ktype.KexType -import org.vorpal.research.kex.mocking.performMocking -import org.vorpal.research.kex.parameters.Parameters -import org.vorpal.research.kex.parameters.concreteParameters -import org.vorpal.research.kex.parameters.filterIgnoredStatic -import org.vorpal.research.kex.parameters.filterStaticFinals -import org.vorpal.research.kex.reanimator.actionsequence.ActionSequence -import org.vorpal.research.kex.reanimator.actionsequence.generator.ConcolicSequenceGenerator -import org.vorpal.research.kex.reanimator.rtUnmapped -import org.vorpal.research.kex.smt.AsyncChecker -import org.vorpal.research.kex.smt.Checker +import org.vorpal.research.kex.descriptor.* +import org.vorpal.research.kex.ktype.KexChar +import org.vorpal.research.kex.ktype.asArray +import org.vorpal.research.kex.smt.InitialDescriptorReanimator import org.vorpal.research.kex.smt.SMTModel -import org.vorpal.research.kex.state.PredicateState -import org.vorpal.research.kex.state.term.* -import org.vorpal.research.kex.state.transformer.generateInitialDescriptors +import org.vorpal.research.kex.state.transformer.DescriptorGenerator import org.vorpal.research.kex.trace.symbolic.* -import org.vorpal.research.kex.trace.symbolic.protocol.SuccessResult -import org.vorpal.research.kex.util.asmString +import org.vorpal.research.kex.util.javaString import org.vorpal.research.kfg.Package import org.vorpal.research.kfg.ir.* +import org.vorpal.research.kfg.ir.value.instruction.CallInst import org.vorpal.research.kfg.ir.value.instruction.Instruction +import org.vorpal.research.kfg.ir.value.instruction.ReturnInst import org.vorpal.research.kthelper.assert.unreachable +import org.vorpal.research.kthelper.logging.log import java.util.* -import kotlin.time.Duration.Companion.seconds import kotlin.time.ExperimentalTime @ExperimentalTime @@ -60,14 +52,11 @@ class KexTestGenerator { } private val ctx get() = KexService.ctx - private val pathSelector = CoverageGuidedSelector( - CoverageGuidedSelectorManager( - ctx, ctx.cm[Properties.TARGET_CLASS.asmString].allMethods - ) - ) - private val asGenerator = ConcolicSequenceGenerator(ctx, PredicateStateAnalysis(ctx.cm)) private val cache = WeakHashMap() + private val Method.isTargetMethod: Boolean + get() = klass.fullName.javaString == Properties.TARGET_CLASS + fun collectTraces(testChromosomes: List, stoppingCondition: () -> Boolean) { runBlocking { logger.info("Trace collection") @@ -79,8 +68,8 @@ class KexTestGenerator { val observer = KexTestObserver(ctx) val testCaseClone = test.testCase.clone() as DefaultTestCase KexService.execute(testCaseClone, observer) - - cache[test] = observer.trace + updateWithTrace(observer.trace, observer.state) + cache[test] = observer.state } catch (e: Throwable) { logger.error("Error occurred while running test:\n{}", test, e) } @@ -88,8 +77,46 @@ class KexTestGenerator { } } - private suspend fun updateWithTrace(trace: List, state: SymbolicState, method: Method) { - pathSelector.addExecutionTrace(method, persistentSymbolicState(), SuccessResult(trace, state)) + + // TODO: handle throws + // TODO: get rid of assumption that every call has return (System.out.println or Object. as example) (or look at if(y.getX() - it generates two calls for getX and only one has return) + // TODO: get rid of nested call states and border clauses (compare to version from master) + private fun splitState(state: SymbolicState): List> { + val stateStarts = mutableListOf() + val res = mutableListOf>() + val clauses = state.clauses.toList() + for (i in clauses.indices) { + if (clauses[i] is PathClause) continue // Assuming that all necessary calls are already made (I believe it's true but need to ask) + + val instruction = clauses[i].instruction + if (instruction is CallInst) { + stateStarts.add(i + 1) + } else if (instruction is ReturnInst) { + if (!(clauses[stateStarts.last() - 1].instruction as CallInst).method.isTargetMethod) { + stateStarts.removeLast() + continue + } + + val subsegment = clauses.subList(stateStarts.last(), i + 1) + res.add((clauses[stateStarts.last() - 1].instruction as CallInst).method to + PersistentSymbolicState( + PersistentClauseList(subsegment.toPersistentList()), + PersistentPathCondition(subsegment.filterIsInstance().toPersistentList()), + state.concreteTypes.toPersistentMap(), + state.concreteValues.toPersistentMap(), + state.termMap.toPersistentMap() + )) + stateStarts.removeLast() + } + } + return res + } + + private suspend fun updateWithTrace(trace: List, state: SymbolicState) { + val statesForMethod = splitState(state) + for ((method, methodState) in statesForMethod) { + // clauseSelector.addExecutionTrace(method, persistentSymbolicState(), SuccessResult(trace, methodState)) + } } fun generateTest(): TestCase? = runBlocking { @@ -124,73 +151,74 @@ class KexTestGenerator { logger.debug("Kex produce new test:\n{}", it) } - private fun findNext(assignments: Map, previous: String? = null): Term? { - var flag = previous == null - for ((key, _) in assignments) { - if (!key.name.contains("primitive")) { - continue - } - if (key.name == previous) { - flag = true - continue - } - if (flag) { - return key - } - } - return null - } + private fun buildPrimitiveTermList(result: SMTModel) = + result.assignments.keys.filter { term -> term.name.contains("primitive") }.sortedBy { term -> term.name } private fun generateTest(oldTest: TestCase, result: SMTModel): TestCase? { + val primitiveTerms = buildPrimitiveTermList(result) + if (primitiveTerms.isEmpty()) return null + var isTestChanged = false val newTest = DefaultTestCase() - var curPrimitiveName = findNext(result.assignments) + var indexOfCurrentPrimitiveTerm = 0 + + val descriptorGenerator = DescriptorGenerator(buildMethod(), ctx, result, InitialDescriptorReanimator(result, ctx)) + descriptorGenerator.generateAll() + for (s in oldTest) { - if (curPrimitiveName == null) { - return null - } if (s is PrimitiveStatement<*>) { + if (indexOfCurrentPrimitiveTerm == primitiveTerms.size) { + return null + } isTestChanged = true - when (result.assignments[curPrimitiveName]) { - is ConstIntTerm -> { - s.value = (result.assignments[curPrimitiveName] as ConstIntTerm).value + when (s) { + is IntPrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Int).value } - is ConstLongTerm -> { - s.value = (result.assignments[curPrimitiveName] as ConstLongTerm).value + is LongPrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Long).value } - is ConstFloatTerm -> { - s.value = (result.assignments[curPrimitiveName] as ConstFloatTerm).value + is FloatPrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Float).value } - is ConstDoubleTerm -> { - s.value = (result.assignments[curPrimitiveName] as ConstDoubleTerm).value + is DoublePrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Double).value } - is ConstStringTerm -> { - s.value = (result.assignments[curPrimitiveName] as ConstStringTerm).value + is StringPrimitiveStatement -> { + s.value = descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]]!!.asStringValue } - is ConstShortTerm -> { - s.value = (result.assignments[curPrimitiveName] as ConstShortTerm).value + is ShortPrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Short).value } - is ConstByteTerm -> { - s.value = (result.assignments[curPrimitiveName] as ConstByteTerm).value + is BytePrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Byte).value } - is ConstCharTerm -> { - s.value = (result.assignments[curPrimitiveName] as ConstCharTerm).value + is CharPrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Char).value } - is ConstBoolTerm -> { - s.value = (result.assignments[curPrimitiveName] as ConstBoolTerm).value + is BooleanPrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Bool).value } else -> unreachable {} } - curPrimitiveName = findNext(result.assignments, curPrimitiveName?.name) + indexOfCurrentPrimitiveTerm++ } newTest.addStatement(s) } @@ -201,11 +229,14 @@ class KexTestGenerator { } private fun chooseTestCase(): TestChromosome { - return cache.keys.random() + var chosenTest: TestChromosome + do { + chosenTest = cache.keys.random() + } while (cache[chosenTest] == null) + return chosenTest } private fun choosePathClause(chosenTest: TestChromosome): Pair { - if (cache[chosenTest] == null) return -1 to -1 if (cache[chosenTest]!!.path.path.isEmpty()) return -1 to -1 val number = (0 until cache[chosenTest]!!.path.path.size).random() @@ -227,4 +258,18 @@ class KexTestGenerator { val testDescriptor = MethodDescriptor(emptyList(), cm.type.voidType) return Method(cm, klass, "name", testDescriptor) } + + val Descriptor.asStringValue: String? + get() = (this as? ObjectDescriptor)?.let { obj -> + val valueDescriptor = obj["value", KexChar.asArray()] as? ArrayDescriptor + valueDescriptor?.let { array -> + (0 until array.length).map { + when (val value = array.elements.getOrDefault(it, descriptor { const(' ') })) { + is ConstantDescriptor.Char -> value.value + is ConstantDescriptor.Byte -> value.value.toInt().toChar() + else -> unreachable { log.error("Unexpected element type in string: $value") } + } + }.joinToString("") + } + } } \ No newline at end of file diff --git a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt index 7de5cd0c39..d425bd4acf 100644 --- a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt +++ b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt @@ -71,9 +71,9 @@ class KexTestObserver(executionContext: ExecutionContext, private val id: Int = val termCache = mutableMapOf() val nameCache = mutableMapOf() - val trace get() = collector.symbolicState + val state get() = collector.symbolicState - val result get() = collector.stateBuilder + val trace get() = collector.instructionTrace init { collector = enableCollector(executionContext, NameMapperContext()) as SymbolicTraceBuilder From 747be241ae61672781ac6d027218a0c79c261ba2 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Fri, 26 Jul 2024 12:47:00 +0200 Subject: [PATCH 04/34] basic clause selector version --- .../kotlin/org/evosuite/kex/ClauseSelector.kt | 18 +++++ .../org/evosuite/kex/KexTestGenerator.kt | 81 +++---------------- .../evosuite/kex/ScoreGuidedClauseSelector.kt | 68 ++++++++++++++++ .../evosuite/kex/observers/KexTestObserver.kt | 12 +++ 4 files changed, 111 insertions(+), 68 deletions(-) create mode 100644 client/src/main/kotlin/org/evosuite/kex/ClauseSelector.kt create mode 100644 client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt diff --git a/client/src/main/kotlin/org/evosuite/kex/ClauseSelector.kt b/client/src/main/kotlin/org/evosuite/kex/ClauseSelector.kt new file mode 100644 index 0000000000..1a12d0ba07 --- /dev/null +++ b/client/src/main/kotlin/org/evosuite/kex/ClauseSelector.kt @@ -0,0 +1,18 @@ +package org.evosuite.kex + +import org.vorpal.research.kex.asm.analysis.util.SuspendableIterator +import org.vorpal.research.kex.trace.symbolic.Clause +import org.vorpal.research.kex.trace.symbolic.PathClause +import org.vorpal.research.kfg.ir.Method +import org.vorpal.research.kfg.ir.value.instruction.Instruction + +interface ClauseSelector : SuspendableIterator, List>> { + val targets: Set + + suspend fun isEmpty(): Boolean + suspend fun addExecutionTrace( + trace: List + ) + + fun reverse(pathClause: PathClause): PathClause? +} diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index daba4bc6d1..4e60651428 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -30,6 +30,7 @@ import org.vorpal.research.kex.smt.InitialDescriptorReanimator import org.vorpal.research.kex.smt.SMTModel import org.vorpal.research.kex.state.transformer.DescriptorGenerator import org.vorpal.research.kex.trace.symbolic.* +import org.vorpal.research.kex.util.asmString import org.vorpal.research.kex.util.javaString import org.vorpal.research.kfg.Package import org.vorpal.research.kfg.ir.* @@ -53,6 +54,7 @@ class KexTestGenerator { private val ctx get() = KexService.ctx private val cache = WeakHashMap() + private val clauseSelector = ScoreGuidedClauseSelector(ctx.cm[Properties.TARGET_CLASS.asmString].allMethods, ctx) private val Method.isTargetMethod: Boolean get() = klass.fullName.javaString == Properties.TARGET_CLASS @@ -68,7 +70,7 @@ class KexTestGenerator { val observer = KexTestObserver(ctx) val testCaseClone = test.testCase.clone() as DefaultTestCase KexService.execute(testCaseClone, observer) - updateWithTrace(observer.trace, observer.state) + updateWithTrace(observer.callTraces) cache[test] = observer.state } catch (e: Throwable) { logger.error("Error occurred while running test:\n{}", test, e) @@ -77,63 +79,22 @@ class KexTestGenerator { } } - - // TODO: handle throws - // TODO: get rid of assumption that every call has return (System.out.println or Object. as example) (or look at if(y.getX() - it generates two calls for getX and only one has return) - // TODO: get rid of nested call states and border clauses (compare to version from master) - private fun splitState(state: SymbolicState): List> { - val stateStarts = mutableListOf() - val res = mutableListOf>() - val clauses = state.clauses.toList() - for (i in clauses.indices) { - if (clauses[i] is PathClause) continue // Assuming that all necessary calls are already made (I believe it's true but need to ask) - - val instruction = clauses[i].instruction - if (instruction is CallInst) { - stateStarts.add(i + 1) - } else if (instruction is ReturnInst) { - if (!(clauses[stateStarts.last() - 1].instruction as CallInst).method.isTargetMethod) { - stateStarts.removeLast() - continue - } - - val subsegment = clauses.subList(stateStarts.last(), i + 1) - res.add((clauses[stateStarts.last() - 1].instruction as CallInst).method to - PersistentSymbolicState( - PersistentClauseList(subsegment.toPersistentList()), - PersistentPathCondition(subsegment.filterIsInstance().toPersistentList()), - state.concreteTypes.toPersistentMap(), - state.concreteValues.toPersistentMap(), - state.termMap.toPersistentMap() - )) - stateStarts.removeLast() - } - } - return res - } - - private suspend fun updateWithTrace(trace: List, state: SymbolicState) { - val statesForMethod = splitState(state) - for ((method, methodState) in statesForMethod) { - // clauseSelector.addExecutionTrace(method, persistentSymbolicState(), SuccessResult(trace, methodState)) + private suspend fun updateWithTrace(callTraces: List>) { + for (trace in callTraces) { + if (!trace.first().parent.method.isTargetMethod) continue + clauseSelector.addExecutionTrace(trace) } } fun generateTest(): TestCase? = runBlocking { logger.info("Generating test with kex") - val mth = buildMethod() - var chosenTest: TestChromosome - var chosenPathClauseIndex: Pair - do { - chosenTest = chooseTestCase() - chosenPathClauseIndex = choosePathClause(chosenTest) - } while(chosenPathClauseIndex.first == -1) - + val chosenTest = chooseTestCase() val prevState = cache[chosenTest]!! - val clauseList = prevState.clauses.take(chosenPathClauseIndex.first).toMutableList() - val pathList = prevState.path.take(chosenPathClauseIndex.second).toMutableList() - val reversed = BfsPathSelectorImpl(ctx, mth).reverse(pathList.last())!! + clauseSelector.setState(prevState.clauses.state, prevState.path.path) + val (clauseList, pathList) = clauseSelector.next() + + val reversed = clauseSelector.reverse(pathList.last())!! clauseList[clauseList.size - 1] = reversed pathList[pathList.size - 1] = reversed @@ -232,26 +193,10 @@ class KexTestGenerator { var chosenTest: TestChromosome do { chosenTest = cache.keys.random() - } while (cache[chosenTest] == null) + } while (cache[chosenTest] == null || cache[chosenTest]!!.path.path.isEmpty()) return chosenTest } - private fun choosePathClause(chosenTest: TestChromosome): Pair { - if (cache[chosenTest]!!.path.path.isEmpty()) - return -1 to -1 - val number = (0 until cache[chosenTest]!!.path.path.size).random() - var counter = 0 - for (i in 0 until cache[chosenTest]!!.clauses.state.size) { - if (cache[chosenTest]!!.clauses.state[i] is PathClause) { - if (counter == number) { - return i + 1 to number + 1 - } - counter += 1 - } - } - return -1 to -1 - } - private fun buildMethod(): Method { val cm = KexService.ctx.cm val klass: Class = OuterClass(cm, Package(""), "TestClass", Modifiers(0)) diff --git a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt new file mode 100644 index 0000000000..35e8d7d37d --- /dev/null +++ b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt @@ -0,0 +1,68 @@ +package org.evosuite.kex + +import kotlinx.collections.immutable.toPersistentList +import org.vorpal.research.kex.ExecutionContext +import org.vorpal.research.kex.asm.analysis.concolic.bfs.BfsPathSelectorImpl +import org.vorpal.research.kex.asm.analysis.concolic.coverage.InstructionGraph +import org.vorpal.research.kex.trace.symbolic.Clause +import org.vorpal.research.kex.trace.symbolic.PathClause +import org.vorpal.research.kfg.Package +import org.vorpal.research.kfg.ir.Method +import org.vorpal.research.kfg.ir.MethodDescriptor +import org.vorpal.research.kfg.ir.Modifiers +import org.vorpal.research.kfg.ir.OuterClass +import org.vorpal.research.kfg.ir.value.instruction.Instruction + +class ScoreGuidedClauseSelector( + override val targets: Set, + private val ctx: ExecutionContext +) : ClauseSelector { + private val instructionGraph = InstructionGraph(targets) + private val instructionsGraph get() = instructionGraph + private val clauses = mutableListOf() + private val path = mutableListOf() + private val candidates = mutableListOf>() + private val targetInstructions = targets.flatMapTo(mutableSetOf()) { it.body.flatten() } + private val coveredInstructions = mutableSetOf() + + override suspend fun isEmpty(): Boolean = coveredInstructions.containsAll(targetInstructions) || + candidates.isEmpty() + + override suspend fun hasNext(): Boolean = !isEmpty() + + override suspend fun next(): Pair, MutableList> { + val candidate = candidates.random() + candidates.remove(candidate) + return clauses.take(candidate.first + 1).toMutableList() to path.take(candidate.second + 1).toMutableList() + } + + override suspend fun addExecutionTrace(trace: List) { + instructionsGraph.addTrace(trace) + coveredInstructions += trace + } + + suspend fun setState(newClauses: List, newPath: List) { + clauses.clear() + path.clear() + clauses.addAll(newClauses) + path.addAll(newPath) + + candidates.clear() + var pathIndex = 0 + for (i in clauses.indices) { + if (clauses[i] is PathClause) { + assert(clauses[i] == path[pathIndex]) + candidates.add(i to pathIndex) + pathIndex++ + } + } + assert(pathIndex == path.size) + } + + // TODO: rewrite? + override fun reverse(pathClause: PathClause): PathClause? = BfsPathSelectorImpl(ctx, Method( + ctx.cm, OuterClass(ctx.cm, Package(""), "TestClass", Modifiers(0)),"name", + MethodDescriptor(emptyList(), ctx.cm.type.voidType) + )).reverse(pathClause) + +} diff --git a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt index d425bd4acf..aef609bc04 100644 --- a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt +++ b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt @@ -75,6 +75,9 @@ class KexTestObserver(executionContext: ExecutionContext, private val id: Int = val trace get() = collector.instructionTrace + val callTraces = mutableListOf>() + private var index = -1 + init { collector = enableCollector(executionContext, NameMapperContext()) as SymbolicTraceBuilder emptyCollector = initializeEmptyCollector() @@ -137,6 +140,8 @@ class KexTestObserver(executionContext: ExecutionContext, private val id: Int = postProcess(newInst, predicate) collector.lastCall = buildCall(constructor, null, mkValue(statement.returnValue), args, scope) + + index = trace.size } override fun beforeMethod(statement: MethodStatement, scope: Scope) { @@ -145,6 +150,8 @@ class KexTestObserver(executionContext: ExecutionContext, private val id: Int = val args = statement.parameterReferences.map { mkValue(it) } collector.lastCall = buildCall(method, statement.returnValue, callee, args, scope) + + index = trace.size } private fun buildCall( @@ -419,6 +426,11 @@ class KexTestObserver(executionContext: ExecutionContext, private val id: Int = }.also { termCache[value] = it } override fun afterStatement(statement: Statement, scope: Scope, exception: Throwable?) { + if (statement is MethodStatement || statement is ConstructorStatement) { + callTraces.add(trace.takeLast(trace.size - index)) + index = -1 + } + setCurrentCollector(emptyCollector) collector.lastCall?.let { From 07e827e3b8b9b1babbe249be03c30a1df75f8a26 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Mon, 29 Jul 2024 12:31:33 +0200 Subject: [PATCH 05/34] clause selection based on min uncovered distance --- .../org/evosuite/kex/KexTestGenerator.kt | 3 - .../evosuite/kex/ScoreGuidedClauseSelector.kt | 57 +++++++++++++++++-- 2 files changed, 51 insertions(+), 9 deletions(-) diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index 4e60651428..a4e33aa6dd 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -22,7 +22,6 @@ import org.evosuite.testcase.statements.numeric.IntPrimitiveStatement import org.evosuite.testcase.statements.numeric.LongPrimitiveStatement import org.evosuite.testcase.statements.numeric.ShortPrimitiveStatement import org.slf4j.LoggerFactory -import org.vorpal.research.kex.asm.analysis.concolic.bfs.BfsPathSelectorImpl import org.vorpal.research.kex.descriptor.* import org.vorpal.research.kex.ktype.KexChar import org.vorpal.research.kex.ktype.asArray @@ -34,9 +33,7 @@ import org.vorpal.research.kex.util.asmString import org.vorpal.research.kex.util.javaString import org.vorpal.research.kfg.Package import org.vorpal.research.kfg.ir.* -import org.vorpal.research.kfg.ir.value.instruction.CallInst import org.vorpal.research.kfg.ir.value.instruction.Instruction -import org.vorpal.research.kfg.ir.value.instruction.ReturnInst import org.vorpal.research.kthelper.assert.unreachable import org.vorpal.research.kthelper.logging.log import java.util.* diff --git a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt index 35e8d7d37d..94b57e0857 100644 --- a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt +++ b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt @@ -3,6 +3,8 @@ package org.evosuite.kex import kotlinx.collections.immutable.toPersistentList import org.vorpal.research.kex.ExecutionContext import org.vorpal.research.kex.asm.analysis.concolic.bfs.BfsPathSelectorImpl +import org.vorpal.research.kex.asm.analysis.concolic.coverage.ExecutionGraph.Companion.DEFAULT_SCORE +import org.vorpal.research.kex.asm.analysis.concolic.coverage.ExecutionGraph.Companion.SIGMA import org.vorpal.research.kex.asm.analysis.concolic.coverage.InstructionGraph import org.vorpal.research.kex.trace.symbolic.Clause import org.vorpal.research.kex.trace.symbolic.PathClause @@ -11,14 +13,18 @@ import org.vorpal.research.kfg.ir.Method import org.vorpal.research.kfg.ir.MethodDescriptor import org.vorpal.research.kfg.ir.Modifiers import org.vorpal.research.kfg.ir.OuterClass +import org.vorpal.research.kfg.ir.value.instruction.CallInst +import org.vorpal.research.kfg.ir.value.instruction.CatchInst import org.vorpal.research.kfg.ir.value.instruction.Instruction +import org.vorpal.research.kfg.ir.value.instruction.ReturnInst +import kotlin.math.exp +import kotlin.math.pow class ScoreGuidedClauseSelector( override val targets: Set, private val ctx: ExecutionContext ) : ClauseSelector { private val instructionGraph = InstructionGraph(targets) - private val instructionsGraph get() = instructionGraph private val clauses = mutableListOf() private val path = mutableListOf() private val candidates = mutableListOf>() @@ -31,17 +37,17 @@ class ScoreGuidedClauseSelector( override suspend fun hasNext(): Boolean = !isEmpty() override suspend fun next(): Pair, MutableList> { - val candidate = candidates.random() + val candidate = candidates.first() candidates.remove(candidate) return clauses.take(candidate.first + 1).toMutableList() to path.take(candidate.second + 1).toMutableList() } override suspend fun addExecutionTrace(trace: List) { - instructionsGraph.addTrace(trace) + instructionGraph.addTrace(trace) coveredInstructions += trace } - suspend fun setState(newClauses: List, newPath: List) { + fun setState(newClauses: List, newPath: List) { clauses.clear() path.clear() clauses.addAll(newClauses) @@ -49,14 +55,53 @@ class ScoreGuidedClauseSelector( candidates.clear() var pathIndex = 0 + val stackTraces = mutableListOf>>() + val currentStackTrace = mutableListOf>() + var previousInstruction: Instruction? = null for (i in clauses.indices) { - if (clauses[i] is PathClause) { - assert(clauses[i] == path[pathIndex]) + val clause = clauses[i] + val currentInstruction = clause.instruction + try { + val currentMethod = currentInstruction.parent.method + when (currentInstruction) { + currentMethod.body.entry.first() -> { + currentStackTrace += previousInstruction to currentMethod + } + + is CallInst -> { + previousInstruction = currentInstruction + } + + is ReturnInst -> { + currentStackTrace.removeLast() + } + + is CatchInst -> { + while (stackTraces[stackTraces.size - 1].last().second != currentMethod) { + currentStackTrace.removeLast() + } + } + } + } catch (_: Exception) {} + + if (clause is PathClause) { + stackTraces += currentStackTrace.toList() + assert(clause == path[pathIndex]) candidates.add(i to pathIndex) pathIndex++ } } assert(pathIndex == path.size) + + candidates.sortBy { (_, pathIndex) -> + val scaleDistance = { distance: Int -> + val normalizedDistance = exp(-0.5 * (distance.toDouble() / SIGMA).pow(2)) + (normalizedDistance * DEFAULT_SCORE).toLong() + } + + scaleDistance(instructionGraph.getVertex(path[pathIndex].instruction). + distanceToUncovered(targets, stackTraces[pathIndex].toPersistentList()).second) + } } // TODO: rewrite? From 8b56a6e28c990891902879a6e67857d6a98a7ff7 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Mon, 29 Jul 2024 12:42:50 +0200 Subject: [PATCH 06/34] collecting all tests --- .../org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java index 0db15a1eca..85a40bc7e5 100644 --- a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java +++ b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java @@ -60,6 +60,8 @@ public class DynaMOSA extends AbstractMOSA { private final long kexGenerationTimeout = 5000; private KexTestGenerator kexTestGenerator; + private final List allTests = new ArrayList<>(); + /** * Constructor based on the abstract class {@link AbstractMOSA}. * @@ -96,9 +98,9 @@ protected void evolve() { wasTargeted = true; long startTime = System.currentTimeMillis(); List solutions = getSolutions(); - statLogger.debug("Current solutions: {}", solutions.size()); + statLogger.debug("Tests generated up to this moment: {}", allTests.size()); kexTestGenerator.collectTraces( - solutions, + allTests, () -> false ); long endExecutionTime = System.currentTimeMillis(); @@ -122,6 +124,8 @@ protected void evolve() { // Generate offspring, compute their fitness, update the archive and coverage goals. List offspringPopulation = this.breedNextGeneration(); + allTests.addAll(offspringPopulation); + allTests.addAll(additional); // Create the union of parents and offspring List union = new ArrayList<>(additional.size() + this.population.size() + offspringPopulation.size()); From 607890a01b4614a9e35942efbf492c41bd6e2732 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Mon, 29 Jul 2024 17:56:31 +0200 Subject: [PATCH 07/34] minor fixes --- .../ga/metaheuristics/mosa/DynaMOSA.java | 4 +++- .../kotlin/org/evosuite/kex/ClauseSelector.kt | 2 +- .../org/evosuite/kex/KexTestGenerator.kt | 6 ++++++ .../evosuite/kex/ScoreGuidedClauseSelector.kt | 19 +++++++------------ 4 files changed, 17 insertions(+), 14 deletions(-) diff --git a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java index 85a40bc7e5..fd9d18ddc3 100644 --- a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java +++ b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java @@ -97,8 +97,10 @@ protected void evolve() { logger.info("Run test generation using kex"); wasTargeted = true; long startTime = System.currentTimeMillis(); - List solutions = getSolutions(); statLogger.debug("Tests generated up to this moment: {}", allTests.size()); + if (allTests.isEmpty()) { + allTests.addAll(getSolutions()); + } kexTestGenerator.collectTraces( allTests, () -> false diff --git a/client/src/main/kotlin/org/evosuite/kex/ClauseSelector.kt b/client/src/main/kotlin/org/evosuite/kex/ClauseSelector.kt index 1a12d0ba07..4ebe565d16 100644 --- a/client/src/main/kotlin/org/evosuite/kex/ClauseSelector.kt +++ b/client/src/main/kotlin/org/evosuite/kex/ClauseSelector.kt @@ -6,7 +6,7 @@ import org.vorpal.research.kex.trace.symbolic.PathClause import org.vorpal.research.kfg.ir.Method import org.vorpal.research.kfg.ir.value.instruction.Instruction -interface ClauseSelector : SuspendableIterator, List>> { +interface ClauseSelector : SuspendableIterator?, List?>> { val targets: Set suspend fun isEmpty(): Boolean diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index a4e33aa6dd..d2373ddef3 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -78,6 +78,9 @@ class KexTestGenerator { private suspend fun updateWithTrace(callTraces: List>) { for (trace in callTraces) { + if(trace.isEmpty()) { + continue + } if (!trace.first().parent.method.isTargetMethod) continue clauseSelector.addExecutionTrace(trace) } @@ -90,6 +93,9 @@ class KexTestGenerator { val prevState = cache[chosenTest]!! clauseSelector.setState(prevState.clauses.state, prevState.path.path) val (clauseList, pathList) = clauseSelector.next() + if (clauseList == null || pathList == null) { + return@runBlocking null + } val reversed = clauseSelector.reverse(pathList.last())!! clauseList[clauseList.size - 1] = reversed diff --git a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt index 94b57e0857..e624c5484e 100644 --- a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt +++ b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt @@ -3,8 +3,6 @@ package org.evosuite.kex import kotlinx.collections.immutable.toPersistentList import org.vorpal.research.kex.ExecutionContext import org.vorpal.research.kex.asm.analysis.concolic.bfs.BfsPathSelectorImpl -import org.vorpal.research.kex.asm.analysis.concolic.coverage.ExecutionGraph.Companion.DEFAULT_SCORE -import org.vorpal.research.kex.asm.analysis.concolic.coverage.ExecutionGraph.Companion.SIGMA import org.vorpal.research.kex.asm.analysis.concolic.coverage.InstructionGraph import org.vorpal.research.kex.trace.symbolic.Clause import org.vorpal.research.kex.trace.symbolic.PathClause @@ -17,8 +15,6 @@ import org.vorpal.research.kfg.ir.value.instruction.CallInst import org.vorpal.research.kfg.ir.value.instruction.CatchInst import org.vorpal.research.kfg.ir.value.instruction.Instruction import org.vorpal.research.kfg.ir.value.instruction.ReturnInst -import kotlin.math.exp -import kotlin.math.pow class ScoreGuidedClauseSelector( override val targets: Set, @@ -36,7 +32,8 @@ class ScoreGuidedClauseSelector( override suspend fun hasNext(): Boolean = !isEmpty() - override suspend fun next(): Pair, MutableList> { + override suspend fun next(): Pair?, MutableList?> { + if (isEmpty()) return null to null val candidate = candidates.first() candidates.remove(candidate) return clauses.take(candidate.first + 1).toMutableList() to path.take(candidate.second + 1).toMutableList() @@ -93,14 +90,12 @@ class ScoreGuidedClauseSelector( } assert(pathIndex == path.size) - candidates.sortBy { (_, pathIndex) -> - val scaleDistance = { distance: Int -> - val normalizedDistance = exp(-0.5 * (distance.toDouble() / SIGMA).pow(2)) - (normalizedDistance * DEFAULT_SCORE).toLong() - } + candidates.sortBy /*TODO: or by descending?*/ { (_, pathIndex) -> + + val distance = instructionGraph.getVertex(path[pathIndex].instruction). + distanceToUncovered(targets, stackTraces[pathIndex].toPersistentList()).second - scaleDistance(instructionGraph.getVertex(path[pathIndex].instruction). - distanceToUncovered(targets, stackTraces[pathIndex].toPersistentList()).second) + distance } } From cf7757d76b32ae4d68f04356837b82c1e1c97f88 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Mon, 29 Jul 2024 18:01:50 +0200 Subject: [PATCH 08/34] added timeout for test generation --- .../ga/metaheuristics/mosa/DynaMOSA.java | 4 +- .../org/evosuite/kex/KexTestGenerator.kt | 45 ++++++++++--------- 2 files changed, 27 insertions(+), 22 deletions(-) diff --git a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java index fd9d18ddc3..b0be35a172 100644 --- a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java +++ b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java @@ -75,8 +75,10 @@ private List generateTests(long time) { List res = new ArrayList<>(); logger.info("Start generation"); int i = 0; + Function0 stoppingCondition = + () -> System.currentTimeMillis() - time > kexGenerationTimeout && false; while (maxGenerateTests == -1 || i < maxGenerateTests) { - TestCase testCase = kexTestGenerator.generateTest(); + TestCase testCase = kexTestGenerator.generateTest(stoppingCondition); if (testCase != null) { TestChromosome test = new TestChromosome(); test.setTestCase(testCase); diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index d2373ddef3..6d6519a7ed 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -86,31 +86,34 @@ class KexTestGenerator { } } - fun generateTest(): TestCase? = runBlocking { + fun generateTest(stoppingCondition: () -> Boolean): TestCase? = runBlocking { logger.info("Generating test with kex") + while (!stoppingCondition()) { + val chosenTest = chooseTestCase() + val prevState = cache[chosenTest]!! + clauseSelector.setState(prevState.clauses.state, prevState.path.path) + val (clauseList, pathList) = clauseSelector.next() + if (clauseList == null || pathList == null) { + continue + } - val chosenTest = chooseTestCase() - val prevState = cache[chosenTest]!! - clauseSelector.setState(prevState.clauses.state, prevState.path.path) - val (clauseList, pathList) = clauseSelector.next() - if (clauseList == null || pathList == null) { - return@runBlocking null - } - - val reversed = clauseSelector.reverse(pathList.last())!! - clauseList[clauseList.size - 1] = reversed - pathList[pathList.size - 1] = reversed + val reversed = clauseSelector.reverse(pathList.last()) ?: continue + clauseList[clauseList.size - 1] = reversed + pathList[pathList.size - 1] = reversed - val state = PersistentSymbolicState( - PersistentClauseList(clauseList.toPersistentList()), - PersistentPathCondition(pathList.toPersistentList()), - prevState.concreteTypes.toPersistentMap(), - prevState.concreteValues.toPersistentMap(), - prevState.termMap.toPersistentMap() - ) + val state = PersistentSymbolicState( + PersistentClauseList(clauseList.toPersistentList()), + PersistentPathCondition(pathList.toPersistentList()), + prevState.concreteTypes.toPersistentMap(), + prevState.concreteValues.toPersistentMap(), + prevState.termMap.toPersistentMap() + ) - val result = state.check(ctx) ?: return@runBlocking null - return@runBlocking generateTest(chosenTest.testCase, result) + val result = state.check(ctx) ?: continue + return@runBlocking generateTest(chosenTest.testCase, result) + } + logger.info("Unsuccessful in the test generation") + null }.also { logger.debug("Kex produce new test:\n{}", it) } From f655da49ef4388141a485d05090847a4a4c7a791 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Tue, 30 Jul 2024 11:00:11 +0200 Subject: [PATCH 09/34] fixed loop condition --- client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index 6d6519a7ed..360ed916bb 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -88,7 +88,7 @@ class KexTestGenerator { fun generateTest(stoppingCondition: () -> Boolean): TestCase? = runBlocking { logger.info("Generating test with kex") - while (!stoppingCondition()) { + while (clauseSelector.hasNext() && !stoppingCondition()) { val chosenTest = chooseTestCase() val prevState = cache[chosenTest]!! clauseSelector.setState(prevState.clauses.state, prevState.path.path) From b9b3ea76cfadeb7f9aef41cf09d646145232b71b Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Wed, 31 Jul 2024 06:47:36 +0200 Subject: [PATCH 10/34] changed to a mutation --- .../main/java/org/evosuite/Properties.java | 3 +- .../ga/metaheuristics/mosa/DynaMOSA.java | 66 +--- .../org/evosuite/testcase/TestChromosome.java | 34 +- .../org/evosuite/kex/KexTestGenerator.kt | 296 +++++++++--------- 4 files changed, 160 insertions(+), 239 deletions(-) diff --git a/client/src/main/java/org/evosuite/Properties.java b/client/src/main/java/org/evosuite/Properties.java index 7f5c6ee263..65313b8f44 100644 --- a/client/src/main/java/org/evosuite/Properties.java +++ b/client/src/main/java/org/evosuite/Properties.java @@ -1279,8 +1279,7 @@ public enum ArchiveType { @Parameter(key = "concolic_mutation", description = "Deprecated. Probability of using concolic mutation operator") @DoubleValue(min = 0.0, max = 1.0) - @Deprecated - public static double CONCOLIC_MUTATION = 0.0; + public static double CONCOLIC_MUTATION = 1.0; @Parameter(key = "constraint_solution_attempts", description = "Number of attempts to solve constraints related to one code branch") public static int CONSTRAINT_SOLUTION_ATTEMPTS = 3; diff --git a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java index b0be35a172..ba33877478 100644 --- a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java +++ b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java @@ -58,9 +58,6 @@ public class DynaMOSA extends AbstractMOSA { private final int maxGenerateTests = 5; private final long kexExecutionTimeout = 5000; private final long kexGenerationTimeout = 5000; - private KexTestGenerator kexTestGenerator; - - private final List allTests = new ArrayList<>(); /** * Constructor based on the abstract class {@link AbstractMOSA}. @@ -71,69 +68,19 @@ public DynaMOSA(ChromosomeFactory factory) { super(factory); } - private List generateTests(long time) { - List res = new ArrayList<>(); - logger.info("Start generation"); - int i = 0; - Function0 stoppingCondition = - () -> System.currentTimeMillis() - time > kexGenerationTimeout && false; - while (maxGenerateTests == -1 || i < maxGenerateTests) { - TestCase testCase = kexTestGenerator.generateTest(stoppingCondition); - if (testCase != null) { - TestChromosome test = new TestChromosome(); - test.setTestCase(testCase); - res.add(test); - calculateFitness(test); - logger.debug("Covered goals: {}", testCase.getCoveredGoals().size()); - } - i++; - } - return res; - } - /** {@inheritDoc} */ @Override protected void evolve() { - List additional = Collections.emptyList(); - if (true) { - logger.info("Run test generation using kex"); - wasTargeted = true; - long startTime = System.currentTimeMillis(); - statLogger.debug("Tests generated up to this moment: {}", allTests.size()); - if (allTests.isEmpty()) { - allTests.addAll(getSolutions()); - } - kexTestGenerator.collectTraces( - allTests, - () -> false - ); - long endExecutionTime = System.currentTimeMillis(); - - logger.info("Start generating tests"); - additional = generateTests(endExecutionTime); - - long endTime = System.currentTimeMillis(); - statLogger.debug("Test cases generated: {}", additional.size()); - statLogger.debug("Kex generation time: {}", endTime - endExecutionTime); - statLogger.debug("Kex iteration time: {}", endTime - startTime); - - if (additional.isEmpty()) { - return; - } - - List temp = additional; - additional = this.population; - this.population = temp; - } - // Generate offspring, compute their fitness, update the archive and coverage goals. List offspringPopulation = this.breedNextGeneration(); - allTests.addAll(offspringPopulation); - allTests.addAll(additional); + long currentTime = System.currentTimeMillis(); + KexTestGenerator.Companion.collectTraces( + offspringPopulation, + () -> System.currentTimeMillis() - currentTime > kexExecutionTimeout || false + ); // Create the union of parents and offspring - List union = new ArrayList<>(additional.size() + this.population.size() + offspringPopulation.size()); - union.addAll(additional); + List union = new ArrayList<>(this.population.size() + offspringPopulation.size()); union.addAll(this.population); union.addAll(offspringPopulation); @@ -239,7 +186,6 @@ public void generateSolution() { int iterations = 0; int kexIterations = 0; int kexImproveIterations = 0; - kexTestGenerator = new KexTestGenerator(); while (!isFinished() && getNumberOfUncoveredGoals() > 0) { wasTargeted = false; long oldCoverage = getLineCoverage(); diff --git a/client/src/main/java/org/evosuite/testcase/TestChromosome.java b/client/src/main/java/org/evosuite/testcase/TestChromosome.java index d815251bd4..143b489e5d 100755 --- a/client/src/main/java/org/evosuite/testcase/TestChromosome.java +++ b/client/src/main/java/org/evosuite/testcase/TestChromosome.java @@ -19,6 +19,7 @@ */ package org.evosuite.testcase; +import kotlin.jvm.functions.Function0; import org.evosuite.Properties; import org.evosuite.coverage.mutation.Mutation; import org.evosuite.coverage.mutation.MutationExecutionResult; @@ -26,6 +27,7 @@ import org.evosuite.ga.SecondaryObjective; import org.evosuite.ga.localsearch.LocalSearchObjective; import org.evosuite.ga.operators.mutation.MutationHistory; +import org.evosuite.kex.KexTestGenerator; import org.evosuite.runtime.util.AtMostOnceLogger; import org.evosuite.setup.TestCluster; import org.evosuite.symbolic.BranchCondition; @@ -548,32 +550,12 @@ public boolean mutationInsert() { */ private boolean mutationConcolic() { logger.info("Applying DSE mutation"); - // concolicExecution = new ConcolicExecution(); + long currentTime = System.currentTimeMillis(); + long kexGenerationTimeout = 5000; + Function0 stoppingCondition = () -> System.currentTimeMillis() - currentTime > kexGenerationTimeout; + // TODO: do we need it? Evosuite didn't use it - // Apply DSE to gather constraints - List branches = ConcolicExecution.getSymbolicPath(this); - logger.debug("Conditions: " + branches); - if (branches.isEmpty()) - return false; - - boolean mutated = false; - - List targetBranches = branches.stream() - .filter(b -> TestCluster.isTargetClassName(b.getClassName())) - .collect(toCollection(ArrayList::new)); - - // Select random branch - List bs = targetBranches.isEmpty() ? branches : targetBranches; - BranchCondition branch = Randomness.choice(bs); - - logger.debug("Trying to negate branch " + branch.getInstructionIndex() - + " - have " + targetBranches.size() + "/" + branches.size() - + " target branches"); - - // Try to solve negated constraint - TestCase newTest = ConcolicMutation.negateCondition(branches, branch, test); - - // If successful, add resulting test to test suite + TestCase newTest = KexTestGenerator.Companion.generateTest(this, stoppingCondition); if (newTest != null) { logger.debug("CONCOLIC: Created new test"); // logger.info(newTest.toCode()); @@ -586,7 +568,7 @@ private boolean mutationConcolic() { logger.debug("CONCOLIC: Did not create new test"); } - return mutated; + return newTest != null; } /** diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index 360ed916bb..a02c3def05 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -47,180 +47,174 @@ class KexTestGenerator { companion object { private val logger = LoggerFactory.getLogger(KexTestGenerator::class.java) - } - private val ctx get() = KexService.ctx - private val cache = WeakHashMap() - private val clauseSelector = ScoreGuidedClauseSelector(ctx.cm[Properties.TARGET_CLASS.asmString].allMethods, ctx) - - private val Method.isTargetMethod: Boolean - get() = klass.fullName.javaString == Properties.TARGET_CLASS - - fun collectTraces(testChromosomes: List, stoppingCondition: () -> Boolean) { - runBlocking { - logger.info("Trace collection") - for (test in testChromosomes) { - if (stoppingCondition()) break - if (test in cache) continue - - try { - val observer = KexTestObserver(ctx) - val testCaseClone = test.testCase.clone() as DefaultTestCase - KexService.execute(testCaseClone, observer) - updateWithTrace(observer.callTraces) - cache[test] = observer.state - } catch (e: Throwable) { - logger.error("Error occurred while running test:\n{}", test, e) + private val ctx get() = KexService.ctx + private val cache = WeakHashMap() + private val clauseSelector = + ScoreGuidedClauseSelector(ctx.cm[Properties.TARGET_CLASS.asmString].allMethods, ctx) + + private val Method.isTargetMethod: Boolean + get() = klass.fullName.javaString == Properties.TARGET_CLASS + + fun collectTraces(testChromosomes: List, stoppingCondition: () -> Boolean) { + runBlocking { + logger.info("Trace collection") + for (test in testChromosomes) { + if (stoppingCondition()) break + if (test in cache) continue + + try { + val observer = KexTestObserver(ctx) + val testCaseClone = test.testCase.clone() as DefaultTestCase + KexService.execute(testCaseClone, observer) + updateWithTrace(observer.callTraces) + cache[test] = observer.state + } catch (e: Throwable) { + logger.error("Error occurred while running test:\n{}", test, e) + } } } } - } - private suspend fun updateWithTrace(callTraces: List>) { - for (trace in callTraces) { - if(trace.isEmpty()) { - continue + private suspend fun updateWithTrace(callTraces: List>) { + for (trace in callTraces) { + if (trace.isEmpty()) { + continue + } + if (!trace.first().parent.method.isTargetMethod) continue + clauseSelector.addExecutionTrace(trace) } - if (!trace.first().parent.method.isTargetMethod) continue - clauseSelector.addExecutionTrace(trace) } - } - fun generateTest(stoppingCondition: () -> Boolean): TestCase? = runBlocking { - logger.info("Generating test with kex") - while (clauseSelector.hasNext() && !stoppingCondition()) { - val chosenTest = chooseTestCase() - val prevState = cache[chosenTest]!! - clauseSelector.setState(prevState.clauses.state, prevState.path.path) - val (clauseList, pathList) = clauseSelector.next() - if (clauseList == null || pathList == null) { - continue - } + fun generateTest(chosenTest: TestChromosome, stoppingCondition: () -> Boolean): TestCase? = runBlocking { + logger.info("Generating test with kex") + while (clauseSelector.hasNext() && !stoppingCondition()) { + val prevState = cache[chosenTest]!! + clauseSelector.setState(prevState.clauses.state, prevState.path.path) + val (clauseList, pathList) = clauseSelector.next() + if (clauseList == null || pathList == null) { + continue + } - val reversed = clauseSelector.reverse(pathList.last()) ?: continue - clauseList[clauseList.size - 1] = reversed - pathList[pathList.size - 1] = reversed + val reversed = clauseSelector.reverse(pathList.last()) ?: continue + clauseList[clauseList.size - 1] = reversed + pathList[pathList.size - 1] = reversed - val state = PersistentSymbolicState( - PersistentClauseList(clauseList.toPersistentList()), - PersistentPathCondition(pathList.toPersistentList()), - prevState.concreteTypes.toPersistentMap(), - prevState.concreteValues.toPersistentMap(), - prevState.termMap.toPersistentMap() - ) + val state = PersistentSymbolicState( + PersistentClauseList(clauseList.toPersistentList()), + PersistentPathCondition(pathList.toPersistentList()), + prevState.concreteTypes.toPersistentMap(), + prevState.concreteValues.toPersistentMap(), + prevState.termMap.toPersistentMap() + ) - val result = state.check(ctx) ?: continue - return@runBlocking generateTest(chosenTest.testCase, result) + val result = state.check(ctx) ?: continue + return@runBlocking generateTest(chosenTest.testCase, result) + } + logger.info("Unsuccessful in the test generation") + null + }.also { + logger.debug("Kex produce new test:\n{}", it) } - logger.info("Unsuccessful in the test generation") - null - }.also { - logger.debug("Kex produce new test:\n{}", it) - } - private fun buildPrimitiveTermList(result: SMTModel) = - result.assignments.keys.filter { term -> term.name.contains("primitive") }.sortedBy { term -> term.name } + private fun buildPrimitiveTermList(result: SMTModel) = + result.assignments.keys.filter { term -> term.name.contains("primitive") }.sortedBy { term -> term.name } - private fun generateTest(oldTest: TestCase, result: SMTModel): TestCase? { - val primitiveTerms = buildPrimitiveTermList(result) - if (primitiveTerms.isEmpty()) return null + private fun generateTest(oldTest: TestCase, result: SMTModel): TestCase? { + val primitiveTerms = buildPrimitiveTermList(result) + if (primitiveTerms.isEmpty()) return null - var isTestChanged = false - val newTest = DefaultTestCase() - var indexOfCurrentPrimitiveTerm = 0 + var isTestChanged = false + val newTest = DefaultTestCase() + var indexOfCurrentPrimitiveTerm = 0 - val descriptorGenerator = DescriptorGenerator(buildMethod(), ctx, result, InitialDescriptorReanimator(result, ctx)) - descriptorGenerator.generateAll() + val descriptorGenerator = + DescriptorGenerator(buildMethod(), ctx, result, InitialDescriptorReanimator(result, ctx)) + descriptorGenerator.generateAll() - for (s in oldTest) { - if (s is PrimitiveStatement<*>) { - if (indexOfCurrentPrimitiveTerm == primitiveTerms.size) { - return null - } - isTestChanged = true - when (s) { - is IntPrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Int).value + for (s in oldTest) { + if (s is PrimitiveStatement<*>) { + if (indexOfCurrentPrimitiveTerm == primitiveTerms.size) { + return null } - - is LongPrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Long).value - } - - is FloatPrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Float).value - } - - is DoublePrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Double).value - } - - is StringPrimitiveStatement -> { - s.value = descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]]!!.asStringValue - } - - is ShortPrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Short).value + isTestChanged = true + when (s) { + is IntPrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Int).value + } + + is LongPrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Long).value + } + + is FloatPrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Float).value + } + + is DoublePrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Double).value + } + + is StringPrimitiveStatement -> { + s.value = + descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]]!!.asStringValue + } + + is ShortPrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Short).value + } + + is BytePrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Byte).value + } + + is CharPrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Char).value + } + + is BooleanPrimitiveStatement -> { + s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Bool).value + } + + else -> unreachable {} } - - is BytePrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Byte).value - } - - is CharPrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Char).value - } - - is BooleanPrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Bool).value - } - - else -> unreachable {} + indexOfCurrentPrimitiveTerm++ } - indexOfCurrentPrimitiveTerm++ + newTest.addStatement(s) } - newTest.addStatement(s) - } - - if (isTestChanged) - return newTest - return null - } - private fun chooseTestCase(): TestChromosome { - var chosenTest: TestChromosome - do { - chosenTest = cache.keys.random() - } while (cache[chosenTest] == null || cache[chosenTest]!!.path.path.isEmpty()) - return chosenTest - } + if (isTestChanged) + return newTest + return null + } - private fun buildMethod(): Method { - val cm = KexService.ctx.cm - val klass: Class = OuterClass(cm, Package(""), "TestClass", Modifiers(0)) - val testDescriptor = MethodDescriptor(emptyList(), cm.type.voidType) - return Method(cm, klass, "name", testDescriptor) - } + private fun buildMethod(): Method { + val cm = KexService.ctx.cm + val klass: Class = OuterClass(cm, Package(""), "TestClass", Modifiers(0)) + val testDescriptor = MethodDescriptor(emptyList(), cm.type.voidType) + return Method(cm, klass, "name", testDescriptor) + } - val Descriptor.asStringValue: String? - get() = (this as? ObjectDescriptor)?.let { obj -> - val valueDescriptor = obj["value", KexChar.asArray()] as? ArrayDescriptor - valueDescriptor?.let { array -> - (0 until array.length).map { - when (val value = array.elements.getOrDefault(it, descriptor { const(' ') })) { - is ConstantDescriptor.Char -> value.value - is ConstantDescriptor.Byte -> value.value.toInt().toChar() - else -> unreachable { log.error("Unexpected element type in string: $value") } - } - }.joinToString("") + private val Descriptor.asStringValue: String? + get() = (this as? ObjectDescriptor)?.let { obj -> + val valueDescriptor = obj["value", KexChar.asArray()] as? ArrayDescriptor + valueDescriptor?.let { array -> + (0 until array.length).map { + when (val value = array.elements.getOrDefault(it, descriptor { const(' ') })) { + is ConstantDescriptor.Char -> value.value + is ConstantDescriptor.Byte -> value.value.toInt().toChar() + else -> unreachable { log.error("Unexpected element type in string: $value") } + } + }.joinToString("") + } } - } + } } \ No newline at end of file From b68945dd880b5a38ad67d8ffc3bbdbdb06cd2c82 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Fri, 2 Aug 2024 14:58:29 +0200 Subject: [PATCH 11/34] fixed --- .../main/java/org/evosuite/Properties.java | 2 +- .../ga/metaheuristics/mosa/DynaMOSA.java | 27 +- .../org/evosuite/testcase/TestChromosome.java | 7 +- .../org/evosuite/kex/KexTestGenerator.kt | 327 +++++++++--------- .../evosuite/kex/ScoreGuidedClauseSelector.kt | 4 +- 5 files changed, 181 insertions(+), 186 deletions(-) diff --git a/client/src/main/java/org/evosuite/Properties.java b/client/src/main/java/org/evosuite/Properties.java index 65313b8f44..0933aab48a 100644 --- a/client/src/main/java/org/evosuite/Properties.java +++ b/client/src/main/java/org/evosuite/Properties.java @@ -1277,7 +1277,7 @@ public enum ArchiveType { @Parameter(key = "seed_dir", group = "Output", description = "Directory name where the best chromosomes are saved") public static String SEED_DIR = "evosuite-seeds"; - @Parameter(key = "concolic_mutation", description = "Deprecated. Probability of using concolic mutation operator") + @Parameter(key = "concolic_mutation", description = "Probability of using concolic mutation operator") @DoubleValue(min = 0.0, max = 1.0) public static double CONCOLIC_MUTATION = 1.0; diff --git a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java index ba33877478..518681363d 100644 --- a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java +++ b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java @@ -19,7 +19,6 @@ */ package org.evosuite.ga.metaheuristics.mosa; -import kotlin.jvm.functions.Function0; import org.evosuite.Properties; import org.evosuite.coverage.line.LineCoverageTestFitness; import org.evosuite.ga.ChromosomeFactory; @@ -52,12 +51,7 @@ public class DynaMOSA extends AbstractMOSA { protected CrowdingDistance distance = new CrowdingDistance<>(); - private int stallLen; - private int maxStallLen = 32; private boolean wasTargeted; - private final int maxGenerateTests = 5; - private final long kexExecutionTimeout = 5000; - private final long kexGenerationTimeout = 5000; /** * Constructor based on the abstract class {@link AbstractMOSA}. @@ -74,9 +68,9 @@ protected void evolve() { // Generate offspring, compute their fitness, update the archive and coverage goals. List offspringPopulation = this.breedNextGeneration(); long currentTime = System.currentTimeMillis(); - KexTestGenerator.Companion.collectTraces( + KexTestGenerator.INSTANCE.collectTraces( offspringPopulation, - () -> System.currentTimeMillis() - currentTime > kexExecutionTimeout || false + () -> System.currentTimeMillis() - currentTime > KexTestGenerator.KEX_EXECUTION_TIMEOUT ); // Create the union of parents and offspring @@ -166,6 +160,11 @@ public void generateSolution() { // Initialize the population by creating solutions at random. this.initializePopulation(); } + long currentTime = System.currentTimeMillis(); + KexTestGenerator.INSTANCE.collectTraces( + this.population, + () -> System.currentTimeMillis() - currentTime > KexTestGenerator.KEX_EXECUTION_TIMEOUT + ); // Compute the fitness for each population member, update the coverage information and the // set of goals to cover. Finally, update the archive. @@ -181,7 +180,6 @@ public void generateSolution() { // Evolve the population generation by generation until all gaols have been covered or the // search budget has been consumed. - stallLen = 0; long startTime = System.currentTimeMillis(); int iterations = 0; int kexIterations = 0; @@ -210,17 +208,6 @@ public void generateSolution() { } } - if (oldCoverage == newCoverage) { - if (wasTargeted) { -// maxGenerateTests *= 2; - maxStallLen *= 2; - } else { - stallLen++; - } - } else { - stallLen = 0; - } - iterations++; this.notifyIteration(); } diff --git a/client/src/main/java/org/evosuite/testcase/TestChromosome.java b/client/src/main/java/org/evosuite/testcase/TestChromosome.java index 143b489e5d..ef3e38b2c8 100755 --- a/client/src/main/java/org/evosuite/testcase/TestChromosome.java +++ b/client/src/main/java/org/evosuite/testcase/TestChromosome.java @@ -551,11 +551,10 @@ public boolean mutationInsert() { private boolean mutationConcolic() { logger.info("Applying DSE mutation"); long currentTime = System.currentTimeMillis(); - long kexGenerationTimeout = 5000; - Function0 stoppingCondition = () -> System.currentTimeMillis() - currentTime > kexGenerationTimeout; - // TODO: do we need it? Evosuite didn't use it + Function0 stoppingCondition = () -> System.currentTimeMillis() - currentTime > + KexTestGenerator.KEX_GENERATION_TIMEOUT; - TestCase newTest = KexTestGenerator.Companion.generateTest(this, stoppingCondition); + TestCase newTest = KexTestGenerator.INSTANCE.generateTest(this, stoppingCondition); if (newTest != null) { logger.debug("CONCOLIC: Created new test"); // logger.info(newTest.toCode()); diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index a02c3def05..a449d382d5 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -13,14 +13,7 @@ import org.evosuite.testcase.TestCase import org.evosuite.testcase.TestChromosome import org.evosuite.testcase.statements.PrimitiveStatement import org.evosuite.testcase.statements.StringPrimitiveStatement -import org.evosuite.testcase.statements.numeric.BooleanPrimitiveStatement -import org.evosuite.testcase.statements.numeric.BytePrimitiveStatement -import org.evosuite.testcase.statements.numeric.CharPrimitiveStatement -import org.evosuite.testcase.statements.numeric.DoublePrimitiveStatement -import org.evosuite.testcase.statements.numeric.FloatPrimitiveStatement -import org.evosuite.testcase.statements.numeric.IntPrimitiveStatement -import org.evosuite.testcase.statements.numeric.LongPrimitiveStatement -import org.evosuite.testcase.statements.numeric.ShortPrimitiveStatement +import org.evosuite.testcase.statements.numeric.* import org.slf4j.LoggerFactory import org.vorpal.research.kex.descriptor.* import org.vorpal.research.kex.ktype.KexChar @@ -28,7 +21,10 @@ import org.vorpal.research.kex.ktype.asArray import org.vorpal.research.kex.smt.InitialDescriptorReanimator import org.vorpal.research.kex.smt.SMTModel import org.vorpal.research.kex.state.transformer.DescriptorGenerator -import org.vorpal.research.kex.trace.symbolic.* +import org.vorpal.research.kex.trace.symbolic.PersistentClauseList +import org.vorpal.research.kex.trace.symbolic.PersistentPathCondition +import org.vorpal.research.kex.trace.symbolic.PersistentSymbolicState +import org.vorpal.research.kex.trace.symbolic.SymbolicState import org.vorpal.research.kex.util.asmString import org.vorpal.research.kex.util.javaString import org.vorpal.research.kfg.Package @@ -43,178 +39,191 @@ import kotlin.time.ExperimentalTime @InternalSerializationApi @ExperimentalSerializationApi @DelicateCoroutinesApi -class KexTestGenerator { - - companion object { - private val logger = LoggerFactory.getLogger(KexTestGenerator::class.java) - - private val ctx get() = KexService.ctx - private val cache = WeakHashMap() - private val clauseSelector = - ScoreGuidedClauseSelector(ctx.cm[Properties.TARGET_CLASS.asmString].allMethods, ctx) - - private val Method.isTargetMethod: Boolean - get() = klass.fullName.javaString == Properties.TARGET_CLASS - - fun collectTraces(testChromosomes: List, stoppingCondition: () -> Boolean) { - runBlocking { - logger.info("Trace collection") - for (test in testChromosomes) { - if (stoppingCondition()) break - if (test in cache) continue - - try { - val observer = KexTestObserver(ctx) - val testCaseClone = test.testCase.clone() as DefaultTestCase - KexService.execute(testCaseClone, observer) - updateWithTrace(observer.callTraces) - cache[test] = observer.state - } catch (e: Throwable) { - logger.error("Error occurred while running test:\n{}", test, e) - } +object KexTestGenerator { + private val logger = LoggerFactory.getLogger(KexTestGenerator::class.java) + + private val ctx get() = KexService.ctx + private val cache = WeakHashMap() + private val clauseSelector = + ScoreGuidedClauseSelector(ctx.cm[Properties.TARGET_CLASS.asmString].allMethods, ctx) + + private val Method.isTargetMethod: Boolean + get() = klass.fullName.javaString == Properties.TARGET_CLASS + + const val KEX_GENERATION_TIMEOUT = 5000 + const val KEX_EXECUTION_TIMEOUT = 5000 + + fun collectTraces(testChromosomes: List, stoppingCondition: () -> Boolean) { + runBlocking { + logger.info("Trace collection") + for (test in testChromosomes) { + if (stoppingCondition()) break + if (test.testCase.toCode() in cache) continue + + try { + val observer = KexTestObserver(ctx) + val testCaseClone = test.testCase.clone() as DefaultTestCase + KexService.execute(testCaseClone, observer) + updateWithTrace(observer.callTraces) + cache[test.testCase.toCode()] = observer.state + } catch (e: Throwable) { + logger.error("Error occurred while running test:\n{}", test, e) } } } + } - private suspend fun updateWithTrace(callTraces: List>) { - for (trace in callTraces) { - if (trace.isEmpty()) { - continue - } - if (!trace.first().parent.method.isTargetMethod) continue - clauseSelector.addExecutionTrace(trace) + private suspend fun updateWithTrace(callTraces: List>) { + for (trace in callTraces) { + if (trace.isEmpty()) { + continue } + if (!trace.first().parent.method.isTargetMethod) continue + clauseSelector.addExecutionTrace(trace) } + } - fun generateTest(chosenTest: TestChromosome, stoppingCondition: () -> Boolean): TestCase? = runBlocking { - logger.info("Generating test with kex") - while (clauseSelector.hasNext() && !stoppingCondition()) { - val prevState = cache[chosenTest]!! - clauseSelector.setState(prevState.clauses.state, prevState.path.path) - val (clauseList, pathList) = clauseSelector.next() - if (clauseList == null || pathList == null) { - continue - } + fun generateTest(chosenTest: TestChromosome, stoppingCondition: () -> Boolean): TestCase? = runBlocking { + logger.info("Generating test with kex") + var prevState = cache[chosenTest.testCase.toCode()] + if (prevState == null) { + collectTraces(listOf(chosenTest), stoppingCondition) + prevState = cache[chosenTest.testCase.toCode()]!! + } + clauseSelector.setState(prevState.clauses.state, prevState.path.path) + while (clauseSelector.hasNext() && !stoppingCondition()) { + val (clauseList, pathList) = clauseSelector.next() + if (clauseList == null || pathList == null) { + continue + } - val reversed = clauseSelector.reverse(pathList.last()) ?: continue - clauseList[clauseList.size - 1] = reversed - pathList[pathList.size - 1] = reversed + val reversed = clauseSelector.reverse(pathList.last()) ?: continue + clauseList[clauseList.size - 1] = reversed + pathList[pathList.size - 1] = reversed - val state = PersistentSymbolicState( - PersistentClauseList(clauseList.toPersistentList()), - PersistentPathCondition(pathList.toPersistentList()), - prevState.concreteTypes.toPersistentMap(), - prevState.concreteValues.toPersistentMap(), - prevState.termMap.toPersistentMap() - ) + val state = PersistentSymbolicState( + PersistentClauseList(clauseList.toPersistentList()), + PersistentPathCondition(pathList.toPersistentList()), + prevState.concreteTypes.toPersistentMap(), + prevState.concreteValues.toPersistentMap(), + prevState.termMap.toPersistentMap() + ) - val result = state.check(ctx) ?: continue - return@runBlocking generateTest(chosenTest.testCase, result) - } - logger.info("Unsuccessful in the test generation") - null - }.also { - logger.debug("Kex produce new test:\n{}", it) + val result = state.check(ctx) ?: continue + return@runBlocking generateTest(chosenTest.testCase.clone(), result) } + logger.info("Unsuccessful in the test generation") + null + }.also { + logger.debug("Kex produce new test:\n{}", it) + } - private fun buildPrimitiveTermList(result: SMTModel) = - result.assignments.keys.filter { term -> term.name.contains("primitive") }.sortedBy { term -> term.name } + private fun buildPrimitiveTermList(result: SMTModel) = + result.assignments.keys.filter { term -> term.name.contains("primitive") } + + private fun generateTest(oldTest: TestCase, result: SMTModel): TestCase? { + val primitiveTerms = buildPrimitiveTermList(result) + + var isTestChanged = false + val newTest = DefaultTestCase() + var indexOfCurrentPrimitiveTerm = 0 + var primitivesLeft = primitiveTerms.isNotEmpty() + + val descriptorGenerator = + DescriptorGenerator(buildMethod(), ctx, result, InitialDescriptorReanimator(result, ctx)) + descriptorGenerator.generateAll() + + for (s in oldTest) { + newTest.addStatement(s.clone(newTest)) + if (s is PrimitiveStatement<*> && primitivesLeft) { + isTestChanged = true + when (s) { + is IntPrimitiveStatement -> { + (newTest.getStatement(newTest.size() - 1) as IntPrimitiveStatement) + .value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Int).value + } - private fun generateTest(oldTest: TestCase, result: SMTModel): TestCase? { - val primitiveTerms = buildPrimitiveTermList(result) - if (primitiveTerms.isEmpty()) return null + is LongPrimitiveStatement -> { + (newTest.getStatement(newTest.size() - 1) as LongPrimitiveStatement) + .value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Long).value + } - var isTestChanged = false - val newTest = DefaultTestCase() - var indexOfCurrentPrimitiveTerm = 0 + is FloatPrimitiveStatement -> { + (newTest.getStatement(newTest.size() - 1) as FloatPrimitiveStatement) + .value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Float).value + } - val descriptorGenerator = - DescriptorGenerator(buildMethod(), ctx, result, InitialDescriptorReanimator(result, ctx)) - descriptorGenerator.generateAll() + is DoublePrimitiveStatement -> { + (newTest.getStatement(newTest.size() - 1) as DoublePrimitiveStatement) + .value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Double).value + } - for (s in oldTest) { - if (s is PrimitiveStatement<*>) { - if (indexOfCurrentPrimitiveTerm == primitiveTerms.size) { - return null + is StringPrimitiveStatement -> { + (newTest.getStatement(newTest.size() - 1) as StringPrimitiveStatement) + .value = descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]]!! + .asStringValue } - isTestChanged = true - when (s) { - is IntPrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Int).value - } - - is LongPrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Long).value - } - - is FloatPrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Float).value - } - - is DoublePrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Double).value - } - - is StringPrimitiveStatement -> { - s.value = - descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]]!!.asStringValue - } - - is ShortPrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Short).value - } - - is BytePrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Byte).value - } - - is CharPrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Char).value - } - - is BooleanPrimitiveStatement -> { - s.value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] - as ConstantDescriptor.Bool).value - } - - else -> unreachable {} + + is ShortPrimitiveStatement -> { + (newTest.getStatement(newTest.size() - 1) as ShortPrimitiveStatement) + .value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Short).value } - indexOfCurrentPrimitiveTerm++ - } - newTest.addStatement(s) - } - if (isTestChanged) - return newTest - return null - } + is BytePrimitiveStatement -> { + (newTest.getStatement(newTest.size() - 1) as BytePrimitiveStatement) + .value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Byte).value + } - private fun buildMethod(): Method { - val cm = KexService.ctx.cm - val klass: Class = OuterClass(cm, Package(""), "TestClass", Modifiers(0)) - val testDescriptor = MethodDescriptor(emptyList(), cm.type.voidType) - return Method(cm, klass, "name", testDescriptor) - } + is CharPrimitiveStatement -> { + (newTest.getStatement(newTest.size() - 1) as CharPrimitiveStatement) + .value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Char).value + } - private val Descriptor.asStringValue: String? - get() = (this as? ObjectDescriptor)?.let { obj -> - val valueDescriptor = obj["value", KexChar.asArray()] as? ArrayDescriptor - valueDescriptor?.let { array -> - (0 until array.length).map { - when (val value = array.elements.getOrDefault(it, descriptor { const(' ') })) { - is ConstantDescriptor.Char -> value.value - is ConstantDescriptor.Byte -> value.value.toInt().toChar() - else -> unreachable { log.error("Unexpected element type in string: $value") } - } - }.joinToString("") + is BooleanPrimitiveStatement -> { + (newTest.getStatement(newTest.size() - 1) as BooleanPrimitiveStatement) + .value = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] + as ConstantDescriptor.Bool).value + } + + else -> unreachable {} + } + indexOfCurrentPrimitiveTerm++ + if (indexOfCurrentPrimitiveTerm == primitiveTerms.size) { + primitivesLeft = false } } + } + + if (isTestChanged) + return newTest + return null + } + + private fun buildMethod(): Method { + val cm = KexService.ctx.cm + val klass: Class = OuterClass(cm, Package(""), "TestClass", Modifiers(0)) + val testDescriptor = MethodDescriptor(emptyList(), cm.type.voidType) + return Method(cm, klass, "name", testDescriptor) } + + private val Descriptor.asStringValue: String? + get() = (this as? ObjectDescriptor)?.let { obj -> + val valueDescriptor = obj["value", KexChar.asArray()] as? ArrayDescriptor + valueDescriptor?.let { array -> + (0 until array.length).map { + when (val value = array.elements.getOrDefault(it, descriptor { const(' ') })) { + is ConstantDescriptor.Char -> value.value + is ConstantDescriptor.Byte -> value.value.toInt().toChar() + else -> unreachable { log.error("Unexpected element type in string: $value") } + } + }.joinToString("") + } + } } \ No newline at end of file diff --git a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt index e624c5484e..01e01c6e1c 100644 --- a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt +++ b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt @@ -90,10 +90,10 @@ class ScoreGuidedClauseSelector( } assert(pathIndex == path.size) - candidates.sortBy /*TODO: or by descending?*/ { (_, pathIndex) -> + candidates.sortBy { (_, pathIndex) -> val distance = instructionGraph.getVertex(path[pathIndex].instruction). - distanceToUncovered(targets, stackTraces[pathIndex].toPersistentList()).second + distanceToUncovered(targets, stackTraces[pathIndex].toPersistentList()).first distance } From 00dbbd14ff8dcf7dd4506f38deebe26331592421 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Mon, 5 Aug 2024 13:38:37 +0200 Subject: [PATCH 12/34] adjustments --- client/src/main/java/org/evosuite/Properties.java | 2 +- .../main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/client/src/main/java/org/evosuite/Properties.java b/client/src/main/java/org/evosuite/Properties.java index 0933aab48a..cb849a6055 100644 --- a/client/src/main/java/org/evosuite/Properties.java +++ b/client/src/main/java/org/evosuite/Properties.java @@ -1279,7 +1279,7 @@ public enum ArchiveType { @Parameter(key = "concolic_mutation", description = "Probability of using concolic mutation operator") @DoubleValue(min = 0.0, max = 1.0) - public static double CONCOLIC_MUTATION = 1.0; + public static double CONCOLIC_MUTATION =0.5; @Parameter(key = "constraint_solution_attempts", description = "Number of attempts to solve constraints related to one code branch") public static int CONSTRAINT_SOLUTION_ATTEMPTS = 3; diff --git a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt index aef609bc04..433aa14af6 100644 --- a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt +++ b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt @@ -300,7 +300,7 @@ class KexTestObserver(executionContext: ExecutionContext, private val id: Int = override fun beforePrimitive(statement: PrimitiveStatement<*>, scope: Scope) { when (statement) { - is EnumPrimitiveStatement<*> -> TODO() + is EnumPrimitiveStatement<*> -> super.beforePrimitive(statement, scope) // TODO is EnvironmentDataStatement<*> -> TODO("need more research here") else -> { val value = buildValue(statement.value, statement.returnClass) From daf40bb14ac0eb0d7d357f3d7e3f928ca6bfd606 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Wed, 7 Aug 2024 17:35:42 +0200 Subject: [PATCH 13/34] new logs? --- .../ga/metaheuristics/mosa/DynaMOSA.java | 8 ++++++ .../org/evosuite/testcase/TestChromosome.java | 25 +++++++++++++++++++ .../org/evosuite/kex/KexTestGenerator.kt | 2 ++ 3 files changed, 35 insertions(+) diff --git a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java index 518681363d..03b12361f8 100644 --- a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java +++ b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java @@ -66,7 +66,15 @@ public DynaMOSA(ChromosomeFactory factory) { @Override protected void evolve() { // Generate offspring, compute their fitness, update the archive and coverage goals. + TestChromosome.reset(); List offspringPopulation = this.breedNextGeneration(); + statLogger.debug("Concolic mutation: ================== {} ==================", this.getAge()); + statLogger.debug("Concolic mutation: Number of total mutations: {}", TestChromosome.numberOfMutations); + statLogger.debug("Concolic mutation: Number of unchanged tests before concolic mutations: {}", TestChromosome.numberOfUnchanged); + statLogger.debug("Concolic mutation: Number of concolic mutations: {}", TestChromosome.numberOfConcolic); + statLogger.debug("Concolic mutation: Number of success concolic mutations: {}", TestChromosome.numberOfSuccessConcolic); + statLogger.debug("Concolic mutation: Number of timeout for concolic mutation: {}", TestChromosome.numberOfTimeouts); + statLogger.debug("Concolic mutation: Total time for concolic mutation: {}", TestChromosome.totalAmountOfTimeConcolic); long currentTime = System.currentTimeMillis(); KexTestGenerator.INSTANCE.collectTraces( offspringPopulation, diff --git a/client/src/main/java/org/evosuite/testcase/TestChromosome.java b/client/src/main/java/org/evosuite/testcase/TestChromosome.java index ef3e38b2c8..4fc4c73e9e 100755 --- a/client/src/main/java/org/evosuite/testcase/TestChromosome.java +++ b/client/src/main/java/org/evosuite/testcase/TestChromosome.java @@ -67,6 +67,21 @@ */ public final class TestChromosome extends AbstractTestChromosome { + public static int numberOfMutations = 0; + public static int numberOfUnchanged = 0; + public static int numberOfTimeouts = 0; + public static int numberOfConcolic = 0; + public static int numberOfSuccessConcolic = 0; + public static int totalAmountOfTimeConcolic = 0; + public static void reset() { + numberOfUnchanged = 0; + numberOfTimeouts = 0; + numberOfMutations = 0; + numberOfConcolic = 0; + numberOfSuccessConcolic = 0; + totalAmountOfTimeConcolic = 0; + } + private static final long serialVersionUID = 7532366007973252782L; private static final Logger logger = LoggerFactory.getLogger(TestChromosome.class); @@ -286,6 +301,8 @@ public boolean localSearch(LocalSearchObjective objective) { */ @Override public void mutate() { + numberOfMutations += 1; + boolean changed = false; mutationHistory.clear(); @@ -465,12 +482,17 @@ private boolean mutationChange() { TestFactory testFactory = TestFactory.getInstance(); if (Randomness.nextDouble() < Properties.CONCOLIC_MUTATION) { + numberOfConcolic += 1; + numberOfUnchanged += KexTestGenerator.INSTANCE.isCollected(this) ? 1 : 0; + long time = System.currentTimeMillis(); try { changed = mutationConcolic(); } catch (Exception exc) { logger.warn("Encountered exception when trying to use concolic mutation: {}", exc.getMessage()); logger.debug("Detailed exception trace: ", exc); } + totalAmountOfTimeConcolic += System.currentTimeMillis() - time; + numberOfSuccessConcolic += changed ? 1 : 0; } if (!changed) { @@ -564,6 +586,9 @@ private boolean mutationConcolic() { this.setChanged(true); this.lastExecutionResult = null; } else { + if (stoppingCondition.invoke()) { + numberOfTimeouts += 1; + } logger.debug("CONCOLIC: Did not create new test"); } diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index a449d382d5..209026c363 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -53,6 +53,8 @@ object KexTestGenerator { const val KEX_GENERATION_TIMEOUT = 5000 const val KEX_EXECUTION_TIMEOUT = 5000 + fun isCollected(testChromosome: TestChromosome) = testChromosome.testCase.toCode() in cache + fun collectTraces(testChromosomes: List, stoppingCondition: () -> Boolean) { runBlocking { logger.info("Trace collection") From bfa74bfee7c37d1992067e0e8747bb655f93fa0e Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Fri, 9 Aug 2024 09:10:11 +0200 Subject: [PATCH 14/34] small fixes --- client/src/main/java/org/evosuite/Properties.java | 2 +- .../main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/client/src/main/java/org/evosuite/Properties.java b/client/src/main/java/org/evosuite/Properties.java index cb849a6055..737628ae57 100644 --- a/client/src/main/java/org/evosuite/Properties.java +++ b/client/src/main/java/org/evosuite/Properties.java @@ -1279,7 +1279,7 @@ public enum ArchiveType { @Parameter(key = "concolic_mutation", description = "Probability of using concolic mutation operator") @DoubleValue(min = 0.0, max = 1.0) - public static double CONCOLIC_MUTATION =0.5; + public static double CONCOLIC_MUTATION = 0.5; @Parameter(key = "constraint_solution_attempts", description = "Number of attempts to solve constraints related to one code branch") public static int CONSTRAINT_SOLUTION_ATTEMPTS = 3; diff --git a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt index 433aa14af6..d86386ae5c 100644 --- a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt +++ b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt @@ -301,7 +301,7 @@ class KexTestObserver(executionContext: ExecutionContext, private val id: Int = override fun beforePrimitive(statement: PrimitiveStatement<*>, scope: Scope) { when (statement) { is EnumPrimitiveStatement<*> -> super.beforePrimitive(statement, scope) // TODO - is EnvironmentDataStatement<*> -> TODO("need more research here") + is EnvironmentDataStatement<*> -> super.beforePrimitive(statement, scope) // TODO("need more research here") else -> { val value = buildValue(statement.value, statement.returnClass) modifyName(statement.returnValue.name, "primitive%" + value.name + "%" + statement.returnValue.name) From 0da1f09dc40feb6346042f1128e5e5abdda9fcc0 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Mon, 12 Aug 2024 23:32:29 +0200 Subject: [PATCH 15/34] counting irreversible --- .../org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java | 1 + .../java/org/evosuite/testcase/TestChromosome.java | 10 +++------- .../main/kotlin/org/evosuite/kex/KexTestGenerator.kt | 8 +++++++- .../org/evosuite/kex/ScoreGuidedClauseSelector.kt | 10 +++++++--- 4 files changed, 18 insertions(+), 11 deletions(-) diff --git a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java index 03b12361f8..744d355368 100644 --- a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java +++ b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java @@ -75,6 +75,7 @@ protected void evolve() { statLogger.debug("Concolic mutation: Number of success concolic mutations: {}", TestChromosome.numberOfSuccessConcolic); statLogger.debug("Concolic mutation: Number of timeout for concolic mutation: {}", TestChromosome.numberOfTimeouts); statLogger.debug("Concolic mutation: Total time for concolic mutation: {}", TestChromosome.totalAmountOfTimeConcolic); + statLogger.debug("Concolic mutation: Number of irreversible for concolic mutation: {}", TestChromosome.numberOfIrreversibleConcolic); long currentTime = System.currentTimeMillis(); KexTestGenerator.INSTANCE.collectTraces( offspringPopulation, diff --git a/client/src/main/java/org/evosuite/testcase/TestChromosome.java b/client/src/main/java/org/evosuite/testcase/TestChromosome.java index 4fc4c73e9e..4d5edf64a0 100755 --- a/client/src/main/java/org/evosuite/testcase/TestChromosome.java +++ b/client/src/main/java/org/evosuite/testcase/TestChromosome.java @@ -29,10 +29,6 @@ import org.evosuite.ga.operators.mutation.MutationHistory; import org.evosuite.kex.KexTestGenerator; import org.evosuite.runtime.util.AtMostOnceLogger; -import org.evosuite.setup.TestCluster; -import org.evosuite.symbolic.BranchCondition; -import org.evosuite.symbolic.ConcolicExecution; -import org.evosuite.symbolic.ConcolicMutation; import org.evosuite.testcase.execution.ExecutionResult; import org.evosuite.testcase.localsearch.TestCaseLocalSearch; import org.evosuite.testcase.statements.FunctionalMockStatement; @@ -43,7 +39,6 @@ import org.evosuite.testsuite.TestSuiteChromosome; import org.evosuite.testsuite.TestSuiteFitnessFunction; import org.evosuite.utils.Randomness; -import org.evosuite.utils.generic.GenericAccessibleObject; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -57,8 +52,6 @@ import java.util.stream.IntStream; import java.util.stream.Stream; -import static java.util.stream.Collectors.toCollection; - /** * Chromosome representation of test cases * @@ -73,6 +66,7 @@ public final class TestChromosome extends AbstractTestChromosome public static int numberOfConcolic = 0; public static int numberOfSuccessConcolic = 0; public static int totalAmountOfTimeConcolic = 0; + public static int numberOfIrreversibleConcolic = 0; public static void reset() { numberOfUnchanged = 0; numberOfTimeouts = 0; @@ -80,6 +74,7 @@ public static void reset() { numberOfConcolic = 0; numberOfSuccessConcolic = 0; totalAmountOfTimeConcolic = 0; + numberOfIrreversibleConcolic = 0; } private static final long serialVersionUID = 7532366007973252782L; @@ -493,6 +488,7 @@ private boolean mutationChange() { } totalAmountOfTimeConcolic += System.currentTimeMillis() - time; numberOfSuccessConcolic += changed ? 1 : 0; + numberOfIrreversibleConcolic += KexTestGenerator.INSTANCE.isReversible() ? 1 : 0; } if (!changed) { diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index 209026c363..82e59bc269 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -53,6 +53,8 @@ object KexTestGenerator { const val KEX_GENERATION_TIMEOUT = 5000 const val KEX_EXECUTION_TIMEOUT = 5000 + fun isReversible() = clauseSelector.size() != 0 + fun isCollected(testChromosome: TestChromosome) = testChromosome.testCase.toCode() in cache fun collectTraces(testChromosomes: List, stoppingCondition: () -> Boolean) { @@ -88,6 +90,9 @@ object KexTestGenerator { fun generateTest(chosenTest: TestChromosome, stoppingCondition: () -> Boolean): TestCase? = runBlocking { logger.info("Generating test with kex") var prevState = cache[chosenTest.testCase.toCode()] + if (chosenTest.testCase.toCode().count { a -> a == '\n' } >= 2 && chosenTest.testCase.toCode().count { a -> a == '\n' } <= 5) { + println(0) + } if (prevState == null) { collectTraces(listOf(chosenTest), stoppingCondition) prevState = cache[chosenTest.testCase.toCode()]!! @@ -112,7 +117,8 @@ object KexTestGenerator { ) val result = state.check(ctx) ?: continue - return@runBlocking generateTest(chosenTest.testCase.clone(), result) + val test = generateTest(chosenTest.testCase.clone(), result) ?: continue + return@runBlocking test } logger.info("Unsuccessful in the test generation") null diff --git a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt index 01e01c6e1c..80a8ddf547 100644 --- a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt +++ b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt @@ -6,6 +6,7 @@ import org.vorpal.research.kex.asm.analysis.concolic.bfs.BfsPathSelectorImpl import org.vorpal.research.kex.asm.analysis.concolic.coverage.InstructionGraph import org.vorpal.research.kex.trace.symbolic.Clause import org.vorpal.research.kex.trace.symbolic.PathClause +import org.vorpal.research.kex.trace.symbolic.PathClauseType import org.vorpal.research.kfg.Package import org.vorpal.research.kfg.ir.Method import org.vorpal.research.kfg.ir.MethodDescriptor @@ -26,16 +27,19 @@ class ScoreGuidedClauseSelector( private val candidates = mutableListOf>() private val targetInstructions = targets.flatMapTo(mutableSetOf()) { it.body.flatten() } private val coveredInstructions = mutableSetOf() + private var index = 0 override suspend fun isEmpty(): Boolean = coveredInstructions.containsAll(targetInstructions) || candidates.isEmpty() override suspend fun hasNext(): Boolean = !isEmpty() + fun size() = candidates.size + override suspend fun next(): Pair?, MutableList?> { if (isEmpty()) return null to null - val candidate = candidates.first() - candidates.remove(candidate) + val candidate = candidates[index] + index += 1 return clauses.take(candidate.first + 1).toMutableList() to path.take(candidate.second + 1).toMutableList() } @@ -81,7 +85,7 @@ class ScoreGuidedClauseSelector( } } catch (_: Exception) {} - if (clause is PathClause) { + if (clause is PathClause && clause.type == PathClauseType.CONDITION_CHECK) { stackTraces += currentStackTrace.toList() assert(clause == path[pathIndex]) candidates.add(i to pathIndex) From ba3d469221d2eb24efa532db445b0d63fddb8642 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Wed, 21 Aug 2024 21:51:57 +0200 Subject: [PATCH 16/34] fixes + new logs --- .../ga/metaheuristics/mosa/DynaMOSA.java | 5 +++- .../org/evosuite/testcase/TestChromosome.java | 16 ++++++++--- .../org/evosuite/kex/KexTestGenerator.kt | 27 +++++++++++++++---- .../evosuite/kex/ScoreGuidedClauseSelector.kt | 13 ++++++--- .../evosuite/kex/observers/KexTestObserver.kt | 1 + 5 files changed, 49 insertions(+), 13 deletions(-) diff --git a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java index 744d355368..0615788d3d 100644 --- a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java +++ b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java @@ -70,12 +70,15 @@ protected void evolve() { List offspringPopulation = this.breedNextGeneration(); statLogger.debug("Concolic mutation: ================== {} ==================", this.getAge()); statLogger.debug("Concolic mutation: Number of total mutations: {}", TestChromosome.numberOfMutations); - statLogger.debug("Concolic mutation: Number of unchanged tests before concolic mutations: {}", TestChromosome.numberOfUnchanged); + statLogger.debug("Concolic mutation: Number of collected tests before concolic mutations: {}", TestChromosome.numberOfCollected); statLogger.debug("Concolic mutation: Number of concolic mutations: {}", TestChromosome.numberOfConcolic); statLogger.debug("Concolic mutation: Number of success concolic mutations: {}", TestChromosome.numberOfSuccessConcolic); statLogger.debug("Concolic mutation: Number of timeout for concolic mutation: {}", TestChromosome.numberOfTimeouts); statLogger.debug("Concolic mutation: Total time for concolic mutation: {}", TestChromosome.totalAmountOfTimeConcolic); statLogger.debug("Concolic mutation: Number of irreversible for concolic mutation: {}", TestChromosome.numberOfIrreversibleConcolic); + statLogger.debug("Concolic mutation: Number of tests with mocks for concolic mutation: {}", TestChromosome.numberOfMock); + statLogger.debug("Concolic mutation: Number of covered tests before concolic mutation: {}", TestChromosome.numberOfCovered); + long currentTime = System.currentTimeMillis(); KexTestGenerator.INSTANCE.collectTraces( offspringPopulation, diff --git a/client/src/main/java/org/evosuite/testcase/TestChromosome.java b/client/src/main/java/org/evosuite/testcase/TestChromosome.java index 4d5edf64a0..b7d522376a 100755 --- a/client/src/main/java/org/evosuite/testcase/TestChromosome.java +++ b/client/src/main/java/org/evosuite/testcase/TestChromosome.java @@ -61,20 +61,24 @@ public final class TestChromosome extends AbstractTestChromosome { public static int numberOfMutations = 0; - public static int numberOfUnchanged = 0; + public static int numberOfCollected = 0; public static int numberOfTimeouts = 0; public static int numberOfConcolic = 0; public static int numberOfSuccessConcolic = 0; public static int totalAmountOfTimeConcolic = 0; public static int numberOfIrreversibleConcolic = 0; + public static int numberOfCovered = 0; + public static int numberOfMock = 0; public static void reset() { - numberOfUnchanged = 0; + numberOfCovered = 0; + numberOfCollected = 0; numberOfTimeouts = 0; numberOfMutations = 0; numberOfConcolic = 0; numberOfSuccessConcolic = 0; totalAmountOfTimeConcolic = 0; numberOfIrreversibleConcolic = 0; + numberOfMock = 0; } private static final long serialVersionUID = 7532366007973252782L; @@ -478,7 +482,8 @@ private boolean mutationChange() { if (Randomness.nextDouble() < Properties.CONCOLIC_MUTATION) { numberOfConcolic += 1; - numberOfUnchanged += KexTestGenerator.INSTANCE.isCollected(this) ? 1 : 0; + numberOfMock += KexTestGenerator.INSTANCE.hasMock(getTestCase()) ? 1 : 0; + numberOfCollected += KexTestGenerator.INSTANCE.isCollected(this) ? 1 : 0; long time = System.currentTimeMillis(); try { changed = mutationConcolic(); @@ -574,6 +579,11 @@ private boolean mutationConcolic() { TestCase newTest = KexTestGenerator.INSTANCE.generateTest(this, stoppingCondition); if (newTest != null) { + if (newTest == this.test) { + logger.debug("CONCOLIC: Did not create new test because it was covered"); + numberOfCovered += 1; + return false; + } logger.debug("CONCOLIC: Created new test"); // logger.info(newTest.toCode()); // logger.info("Old test"); diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index 82e59bc269..957d53ab45 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -7,10 +7,12 @@ import kotlinx.coroutines.runBlocking import kotlinx.serialization.ExperimentalSerializationApi import kotlinx.serialization.InternalSerializationApi import org.evosuite.Properties +import org.evosuite.kex.observers.KexStatementObserver import org.evosuite.kex.observers.KexTestObserver import org.evosuite.testcase.DefaultTestCase import org.evosuite.testcase.TestCase import org.evosuite.testcase.TestChromosome +import org.evosuite.testcase.statements.FunctionalMockStatement import org.evosuite.testcase.statements.PrimitiveStatement import org.evosuite.testcase.statements.StringPrimitiveStatement import org.evosuite.testcase.statements.numeric.* @@ -25,6 +27,7 @@ import org.vorpal.research.kex.trace.symbolic.PersistentClauseList import org.vorpal.research.kex.trace.symbolic.PersistentPathCondition import org.vorpal.research.kex.trace.symbolic.PersistentSymbolicState import org.vorpal.research.kex.trace.symbolic.SymbolicState +import org.vorpal.research.kex.trace.symbolic.protocol.SuccessResult import org.vorpal.research.kex.util.asmString import org.vorpal.research.kex.util.javaString import org.vorpal.research.kfg.Package @@ -55,14 +58,26 @@ object KexTestGenerator { fun isReversible() = clauseSelector.size() != 0 + fun isCovered() = clauseSelector.allCovered() + fun isCollected(testChromosome: TestChromosome) = testChromosome.testCase.toCode() in cache + fun hasMock(testCase: TestCase): Boolean { + for (statement in testCase.toList()) { + if (statement is FunctionalMockStatement) { + return true + } + } + return false + } + fun collectTraces(testChromosomes: List, stoppingCondition: () -> Boolean) { runBlocking { logger.info("Trace collection") for (test in testChromosomes) { if (stoppingCondition()) break if (test.testCase.toCode() in cache) continue + if (hasMock(test.testCase)) continue try { val observer = KexTestObserver(ctx) @@ -90,18 +105,20 @@ object KexTestGenerator { fun generateTest(chosenTest: TestChromosome, stoppingCondition: () -> Boolean): TestCase? = runBlocking { logger.info("Generating test with kex") var prevState = cache[chosenTest.testCase.toCode()] - if (chosenTest.testCase.toCode().count { a -> a == '\n' } >= 2 && chosenTest.testCase.toCode().count { a -> a == '\n' } <= 5) { - println(0) - } if (prevState == null) { collectTraces(listOf(chosenTest), stoppingCondition) - prevState = cache[chosenTest.testCase.toCode()]!! + prevState = cache[chosenTest.testCase.toCode()] ?: return@runBlocking null } clauseSelector.setState(prevState.clauses.state, prevState.path.path) + + if(!clauseSelector.hasNext()) { + return@runBlocking chosenTest.testCase + } + while (clauseSelector.hasNext() && !stoppingCondition()) { val (clauseList, pathList) = clauseSelector.next() if (clauseList == null || pathList == null) { - continue + break } val reversed = clauseSelector.reverse(pathList.last()) ?: continue diff --git a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt index 80a8ddf547..e4f0d39e85 100644 --- a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt +++ b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt @@ -29,8 +29,10 @@ class ScoreGuidedClauseSelector( private val coveredInstructions = mutableSetOf() private var index = 0 - override suspend fun isEmpty(): Boolean = coveredInstructions.containsAll(targetInstructions) || - candidates.isEmpty() + fun allCovered() = coveredInstructions.containsAll(targetInstructions) + + override suspend fun isEmpty(): Boolean = allCovered() || + candidates.size == index override suspend fun hasNext(): Boolean = !isEmpty() @@ -85,13 +87,16 @@ class ScoreGuidedClauseSelector( } } catch (_: Exception) {} - if (clause is PathClause && clause.type == PathClauseType.CONDITION_CHECK) { + if (clause is PathClause) { stackTraces += currentStackTrace.toList() assert(clause == path[pathIndex]) - candidates.add(i to pathIndex) + if (clause.type == PathClauseType.CONDITION_CHECK) + candidates.add(i to pathIndex) pathIndex++ } } + + index = 0 assert(pathIndex == path.size) candidates.sortBy { (_, pathIndex) -> diff --git a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt index d86386ae5c..d2b0b18ad4 100644 --- a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt +++ b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt @@ -302,6 +302,7 @@ class KexTestObserver(executionContext: ExecutionContext, private val id: Int = when (statement) { is EnumPrimitiveStatement<*> -> super.beforePrimitive(statement, scope) // TODO is EnvironmentDataStatement<*> -> super.beforePrimitive(statement, scope) // TODO("need more research here") + is NullStatement -> super.beforePrimitive(statement, scope) else -> { val value = buildValue(statement.value, statement.returnClass) modifyName(statement.returnValue.name, "primitive%" + value.name + "%" + statement.returnValue.name) From acdaff7fc2795be10e437ba2b140af422985aef4 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Fri, 23 Aug 2024 21:02:22 +0200 Subject: [PATCH 17/34] new logs --- .../ga/metaheuristics/mosa/DynaMOSA.java | 3 +- .../org/evosuite/testcase/TestChromosome.java | 17 ++------ .../org/evosuite/kex/KexTestGenerator.kt | 42 ++++++++++++------- 3 files changed, 34 insertions(+), 28 deletions(-) diff --git a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java index 0615788d3d..e4b42d9c8c 100644 --- a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java +++ b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java @@ -76,8 +76,9 @@ protected void evolve() { statLogger.debug("Concolic mutation: Number of timeout for concolic mutation: {}", TestChromosome.numberOfTimeouts); statLogger.debug("Concolic mutation: Total time for concolic mutation: {}", TestChromosome.totalAmountOfTimeConcolic); statLogger.debug("Concolic mutation: Number of irreversible for concolic mutation: {}", TestChromosome.numberOfIrreversibleConcolic); - statLogger.debug("Concolic mutation: Number of tests with mocks for concolic mutation: {}", TestChromosome.numberOfMock); + statLogger.debug("Concolic mutation: Number of tests with mocks for concolic mutation: {}", TestChromosome.numberOfUnsupported); statLogger.debug("Concolic mutation: Number of covered tests before concolic mutation: {}", TestChromosome.numberOfCovered); + statLogger.debug("Concolic mutation: Number of unsats concolic mutation: {}", TestChromosome.numberOfUnsat); long currentTime = System.currentTimeMillis(); KexTestGenerator.INSTANCE.collectTraces( diff --git a/client/src/main/java/org/evosuite/testcase/TestChromosome.java b/client/src/main/java/org/evosuite/testcase/TestChromosome.java index b7d522376a..d4a500b798 100755 --- a/client/src/main/java/org/evosuite/testcase/TestChromosome.java +++ b/client/src/main/java/org/evosuite/testcase/TestChromosome.java @@ -68,7 +68,8 @@ public final class TestChromosome extends AbstractTestChromosome public static int totalAmountOfTimeConcolic = 0; public static int numberOfIrreversibleConcolic = 0; public static int numberOfCovered = 0; - public static int numberOfMock = 0; + public static int numberOfUnsupported = 0; + public static int numberOfUnsat = 0; public static void reset() { numberOfCovered = 0; numberOfCollected = 0; @@ -78,7 +79,8 @@ public static void reset() { numberOfSuccessConcolic = 0; totalAmountOfTimeConcolic = 0; numberOfIrreversibleConcolic = 0; - numberOfMock = 0; + numberOfUnsupported = 0; + numberOfUnsat = 0; } private static final long serialVersionUID = 7532366007973252782L; @@ -482,8 +484,6 @@ private boolean mutationChange() { if (Randomness.nextDouble() < Properties.CONCOLIC_MUTATION) { numberOfConcolic += 1; - numberOfMock += KexTestGenerator.INSTANCE.hasMock(getTestCase()) ? 1 : 0; - numberOfCollected += KexTestGenerator.INSTANCE.isCollected(this) ? 1 : 0; long time = System.currentTimeMillis(); try { changed = mutationConcolic(); @@ -493,7 +493,6 @@ private boolean mutationChange() { } totalAmountOfTimeConcolic += System.currentTimeMillis() - time; numberOfSuccessConcolic += changed ? 1 : 0; - numberOfIrreversibleConcolic += KexTestGenerator.INSTANCE.isReversible() ? 1 : 0; } if (!changed) { @@ -579,11 +578,6 @@ private boolean mutationConcolic() { TestCase newTest = KexTestGenerator.INSTANCE.generateTest(this, stoppingCondition); if (newTest != null) { - if (newTest == this.test) { - logger.debug("CONCOLIC: Did not create new test because it was covered"); - numberOfCovered += 1; - return false; - } logger.debug("CONCOLIC: Created new test"); // logger.info(newTest.toCode()); // logger.info("Old test"); @@ -592,9 +586,6 @@ private boolean mutationConcolic() { this.setChanged(true); this.lastExecutionResult = null; } else { - if (stoppingCondition.invoke()) { - numberOfTimeouts += 1; - } logger.debug("CONCOLIC: Did not create new test"); } diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index 957d53ab45..a57bb33ecc 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -15,7 +15,9 @@ import org.evosuite.testcase.TestChromosome import org.evosuite.testcase.statements.FunctionalMockStatement import org.evosuite.testcase.statements.PrimitiveStatement import org.evosuite.testcase.statements.StringPrimitiveStatement +import org.evosuite.testcase.statements.environment.EnvironmentDataStatement import org.evosuite.testcase.statements.numeric.* +import org.junit.Test import org.slf4j.LoggerFactory import org.vorpal.research.kex.descriptor.* import org.vorpal.research.kex.ktype.KexChar @@ -56,19 +58,14 @@ object KexTestGenerator { const val KEX_GENERATION_TIMEOUT = 5000 const val KEX_EXECUTION_TIMEOUT = 5000 - fun isReversible() = clauseSelector.size() != 0 - - fun isCovered() = clauseSelector.allCovered() - - fun isCollected(testChromosome: TestChromosome) = testChromosome.testCase.toCode() in cache - - fun hasMock(testCase: TestCase): Boolean { + private fun isSupported(testCase: TestCase): Boolean { for (statement in testCase.toList()) { - if (statement is FunctionalMockStatement) { - return true + if (statement is FunctionalMockStatement || + statement is EnvironmentDataStatement<*>) { + return false } } - return false + return true } fun collectTraces(testChromosomes: List, stoppingCondition: () -> Boolean) { @@ -77,7 +74,7 @@ object KexTestGenerator { for (test in testChromosomes) { if (stoppingCondition()) break if (test.testCase.toCode() in cache) continue - if (hasMock(test.testCase)) continue + if (!isSupported(test.testCase)) continue try { val observer = KexTestObserver(ctx) @@ -104,15 +101,25 @@ object KexTestGenerator { fun generateTest(chosenTest: TestChromosome, stoppingCondition: () -> Boolean): TestCase? = runBlocking { logger.info("Generating test with kex") + + if (!isSupported(chosenTest.testCase)) { + TestChromosome.numberOfUnsupported += 1 + return@runBlocking null + } + var prevState = cache[chosenTest.testCase.toCode()] if (prevState == null) { collectTraces(listOf(chosenTest), stoppingCondition) prevState = cache[chosenTest.testCase.toCode()] ?: return@runBlocking null + } else { + TestChromosome.numberOfCollected += 1 } clauseSelector.setState(prevState.clauses.state, prevState.path.path) - if(!clauseSelector.hasNext()) { - return@runBlocking chosenTest.testCase + if (clauseSelector.size() == 0) { + TestChromosome.numberOfIrreversibleConcolic += 1 + } else if (!clauseSelector.hasNext()){ + TestChromosome.numberOfCovered += 1 } while (clauseSelector.hasNext() && !stoppingCondition()) { @@ -133,10 +140,17 @@ object KexTestGenerator { prevState.termMap.toPersistentMap() ) - val result = state.check(ctx) ?: continue + val result = state.check(ctx) + if (result == null) { + TestChromosome.numberOfUnsat += 1 + continue + } val test = generateTest(chosenTest.testCase.clone(), result) ?: continue return@runBlocking test } + if (stoppingCondition()) { + TestChromosome.numberOfTimeouts += 1 + } logger.info("Unsuccessful in the test generation") null }.also { From 4e05f61cbc49086cf3a97ea890a7a82b58bd66a2 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Fri, 23 Aug 2024 23:06:41 +0200 Subject: [PATCH 18/34] added null handling --- .../src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt | 4 +++- .../kotlin/org/evosuite/kex/observers/KexTestObserver.kt | 8 +++++--- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index a57bb33ecc..c76fc04072 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -12,6 +12,7 @@ import org.evosuite.kex.observers.KexTestObserver import org.evosuite.testcase.DefaultTestCase import org.evosuite.testcase.TestCase import org.evosuite.testcase.TestChromosome +import org.evosuite.testcase.statements.EnumPrimitiveStatement import org.evosuite.testcase.statements.FunctionalMockStatement import org.evosuite.testcase.statements.PrimitiveStatement import org.evosuite.testcase.statements.StringPrimitiveStatement @@ -61,7 +62,8 @@ object KexTestGenerator { private fun isSupported(testCase: TestCase): Boolean { for (statement in testCase.toList()) { if (statement is FunctionalMockStatement || - statement is EnvironmentDataStatement<*>) { + statement is EnvironmentDataStatement<*> || + statement is EnumPrimitiveStatement<*>) { return false } } diff --git a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt index d2b0b18ad4..1eae015844 100644 --- a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt +++ b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt @@ -300,9 +300,11 @@ class KexTestObserver(executionContext: ExecutionContext, private val id: Int = override fun beforePrimitive(statement: PrimitiveStatement<*>, scope: Scope) { when (statement) { - is EnumPrimitiveStatement<*> -> super.beforePrimitive(statement, scope) // TODO - is EnvironmentDataStatement<*> -> super.beforePrimitive(statement, scope) // TODO("need more research here") - is NullStatement -> super.beforePrimitive(statement, scope) + is EnumPrimitiveStatement<*> -> TODO() + is EnvironmentDataStatement<*> -> TODO("need more research here") + is NullStatement -> { + register(statement.returnValue, values.nullConstant) // TODO: Discuss? + } else -> { val value = buildValue(statement.value, statement.returnClass) modifyName(statement.returnValue.name, "primitive%" + value.name + "%" + statement.returnValue.name) From 6e6dba8757c454aef11ae7f84d61673159a4bcf1 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Thu, 29 Aug 2024 12:58:23 +0200 Subject: [PATCH 19/34] fixed null handling and added enum handling --- .../org/evosuite/kex/KexTestGenerator.kt | 7 +++-- .../evosuite/kex/observers/KexTestObserver.kt | 27 +++++++++++++------ 2 files changed, 24 insertions(+), 10 deletions(-) diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index c76fc04072..46d4b70e38 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -62,8 +62,7 @@ object KexTestGenerator { private fun isSupported(testCase: TestCase): Boolean { for (statement in testCase.toList()) { if (statement is FunctionalMockStatement || - statement is EnvironmentDataStatement<*> || - statement is EnumPrimitiveStatement<*>) { + statement is EnvironmentDataStatement<*>) { return false } } @@ -233,6 +232,10 @@ object KexTestGenerator { as ConstantDescriptor.Bool).value } + is EnumPrimitiveStatement<*> -> { + TODO() + } + else -> unreachable {} } indexOfCurrentPrimitiveTerm++ diff --git a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt index 1eae015844..9b6e038a0c 100644 --- a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt +++ b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt @@ -6,11 +6,13 @@ import org.evosuite.testcase.statements.* import org.evosuite.testcase.statements.environment.EnvironmentDataStatement import org.evosuite.testcase.variable.* import org.vorpal.research.kex.ExecutionContext +import org.vorpal.research.kex.ktype.KexNull import org.vorpal.research.kex.ktype.KexType import org.vorpal.research.kex.ktype.kexType import org.vorpal.research.kex.parameters.Parameters import org.vorpal.research.kex.state.predicate.Predicate import org.vorpal.research.kex.state.predicate.state +import org.vorpal.research.kex.state.term.NullTerm import org.vorpal.research.kex.state.term.Term import org.vorpal.research.kex.state.term.TermBuilder.Terms.const import org.vorpal.research.kex.state.term.TermBuilder.Terms.field @@ -31,10 +33,9 @@ import org.vorpal.research.kfg.ir.value.EmptyUsageContext import org.vorpal.research.kfg.ir.value.NameMapperContext import org.vorpal.research.kfg.ir.value.UsageContext import org.vorpal.research.kfg.ir.value.Value -import org.vorpal.research.kfg.ir.value.instruction.BinaryOpcode -import org.vorpal.research.kfg.ir.value.instruction.CmpOpcode -import org.vorpal.research.kfg.ir.value.instruction.Instruction -import org.vorpal.research.kfg.ir.value.instruction.InstructionBuilder +import org.vorpal.research.kfg.ir.value.instruction.* +import org.vorpal.research.kfg.type.NullType +import org.vorpal.research.kfg.type.Reference import org.vorpal.research.kthelper.assert.unreachable import ru.spbstu.wheels.runIf import java.lang.reflect.Method @@ -300,10 +301,20 @@ class KexTestObserver(executionContext: ExecutionContext, private val id: Int = override fun beforePrimitive(statement: PrimitiveStatement<*>, scope: Scope) { when (statement) { - is EnumPrimitiveStatement<*> -> TODO() + is EnumPrimitiveStatement<*> -> { + val inst = instructions.getPhi(ctx, "name", types.get(statement.enumClass), emptyMap()) + modifyName(statement.returnValue.name, "primitive%" + statement.value.name + "%" + statement.returnValue.name) + register(statement.returnValue, inst) + } is EnvironmentDataStatement<*> -> TODO("need more research here") is NullStatement -> { - register(statement.returnValue, values.nullConstant) // TODO: Discuss? + val name = collector.nameGenerator.nextName("$evoPrefix${getName(statement.returnValue.name)}") + val inst = instructions.getPhi(ctx, "$name = null", types.nullType, emptyMap()) + val term = register(statement.returnValue, inst, name) // term { termFactory.getValue(KexNull(), name) } + val pred = state { + term equality NullTerm() + } + postProcess(inst, pred) } else -> { val value = buildValue(statement.value, statement.returnClass) @@ -327,10 +338,10 @@ class KexTestObserver(executionContext: ExecutionContext, private val id: Int = private fun getName(refName: String) = nameCache.getOrElse(refName) {refName} - private fun register(ref: VariableReference, value: Value): Term { + private fun register(ref: VariableReference, value: Value, name: String? = null): Term { val wrapped = ref.wrap(value) valueCache[getName(ref.name)] = wrapped - return mkNewTerm(wrapped, getName(ref.name)) + return mkNewTerm(wrapped, name ?: getName(ref.name)) } private fun mkValue(ref: VariableReference): WrappedValue = From 3757185c0173c121ad107943f5a2a16e157e9820 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Fri, 30 Aug 2024 08:47:08 +0200 Subject: [PATCH 20/34] finished enum handling --- .../kotlin/org/evosuite/kex/KexTestGenerator.kt | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index 46d4b70e38..51632897d5 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -1,5 +1,6 @@ package org.evosuite.kex +import com.jetbrains.rd.util.first import kotlinx.collections.immutable.toPersistentList import kotlinx.collections.immutable.toPersistentMap import kotlinx.coroutines.DelicateCoroutinesApi @@ -25,6 +26,8 @@ import org.vorpal.research.kex.ktype.KexChar import org.vorpal.research.kex.ktype.asArray import org.vorpal.research.kex.smt.InitialDescriptorReanimator import org.vorpal.research.kex.smt.SMTModel +import org.vorpal.research.kex.state.term.StaticClassRefTerm +import org.vorpal.research.kex.state.term.ValueTerm import org.vorpal.research.kex.state.transformer.DescriptorGenerator import org.vorpal.research.kex.trace.symbolic.PersistentClauseList import org.vorpal.research.kex.trace.symbolic.PersistentPathCondition @@ -159,7 +162,7 @@ object KexTestGenerator { } private fun buildPrimitiveTermList(result: SMTModel) = - result.assignments.keys.filter { term -> term.name.contains("primitive") } + result.assignments.keys.filter { term -> term.name.contains("primitive") && term is ValueTerm } private fun generateTest(oldTest: TestCase, result: SMTModel): TestCase? { val primitiveTerms = buildPrimitiveTermList(result) @@ -233,7 +236,17 @@ object KexTestGenerator { } is EnumPrimitiveStatement<*> -> { - TODO() + val descriptor = (descriptorGenerator.memory[primitiveTerms[indexOfCurrentPrimitiveTerm]] as ObjectDescriptor) + val classTerm = descriptorGenerator.memory.filter { + entry -> entry.key is StaticClassRefTerm && entry.key.type == descriptor.klass + } + assert(classTerm.size == 1) + val value = (classTerm.first().value as ClassDescriptor).fields.filter { + entry -> entry.value.term == descriptor.term + } + assert(value.size == 1) + val enumValue = s.enumValues.find { v -> v.name == value.first().key.first } + (newTest.getStatement(newTest.size() - 1) as EnumPrimitiveStatement<*>).value = enumValue } else -> unreachable {} From 69c7d1ec6314b4e063f4fa1d8aefeabf8c04266d Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Tue, 3 Sep 2024 11:15:43 +0200 Subject: [PATCH 21/34] fixes + added arm support for running experiments --- .../evosuite/kex/ScoreGuidedClauseSelector.kt | 23 ++++++++------ .../evosuite/kex/observers/KexTestObserver.kt | 31 +++++++++++++++---- sbst_scripts/setup-and-run-docker.sh | 2 +- 3 files changed, 39 insertions(+), 17 deletions(-) diff --git a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt index e4f0d39e85..bab5247112 100644 --- a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt +++ b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt @@ -32,7 +32,7 @@ class ScoreGuidedClauseSelector( fun allCovered() = coveredInstructions.containsAll(targetInstructions) override suspend fun isEmpty(): Boolean = allCovered() || - candidates.size == index + candidates.size == index override suspend fun hasNext(): Boolean = !isEmpty() @@ -76,16 +76,17 @@ class ScoreGuidedClauseSelector( } is ReturnInst -> { - currentStackTrace.removeLast() + currentStackTrace.removeAt(currentStackTrace.size - 1) } is CatchInst -> { while (stackTraces[stackTraces.size - 1].last().second != currentMethod) { - currentStackTrace.removeLast() + currentStackTrace.removeAt(currentStackTrace.size - 1) } } } - } catch (_: Exception) {} + } catch (_: Exception) { + } if (clause is PathClause) { stackTraces += currentStackTrace.toList() @@ -101,17 +102,19 @@ class ScoreGuidedClauseSelector( candidates.sortBy { (_, pathIndex) -> - val distance = instructionGraph.getVertex(path[pathIndex].instruction). - distanceToUncovered(targets, stackTraces[pathIndex].toPersistentList()).first + val distance = instructionGraph.getVertex(path[pathIndex].instruction) + .distanceToUncovered(targets, stackTraces[pathIndex].toPersistentList()).first distance } } // TODO: rewrite? - override fun reverse(pathClause: PathClause): PathClause? = BfsPathSelectorImpl(ctx, Method( - ctx.cm, OuterClass(ctx.cm, Package(""), "TestClass", Modifiers(0)),"name", - MethodDescriptor(emptyList(), ctx.cm.type.voidType) - )).reverse(pathClause) + override fun reverse(pathClause: PathClause): PathClause? = BfsPathSelectorImpl( + ctx, Method( + ctx.cm, OuterClass(ctx.cm, Package(""), "TestClass", Modifiers(0)), "name", + MethodDescriptor(emptyList(), ctx.cm.type.voidType) + ) + ).reverse(pathClause) } diff --git a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt index 9b6e038a0c..94ac9f1b3a 100644 --- a/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt +++ b/client/src/main/kotlin/org/evosuite/kex/observers/KexTestObserver.kt @@ -302,20 +302,28 @@ class KexTestObserver(executionContext: ExecutionContext, private val id: Int = override fun beforePrimitive(statement: PrimitiveStatement<*>, scope: Scope) { when (statement) { is EnumPrimitiveStatement<*> -> { - val inst = instructions.getPhi(ctx, "name", types.get(statement.enumClass), emptyMap()) - modifyName(statement.returnValue.name, "primitive%" + statement.value.name + "%" + statement.returnValue.name) + val name = "primitive%" + statement.value.name + "%" + statement.returnValue.name + val inst = instructions.getPhi(ctx, name, types.get(statement.enumClass), emptyMap()) + modifyName(statement.returnValue.name, name) register(statement.returnValue, inst) } + is EnvironmentDataStatement<*> -> TODO("need more research here") is NullStatement -> { val name = collector.nameGenerator.nextName("$evoPrefix${getName(statement.returnValue.name)}") - val inst = instructions.getPhi(ctx, "$name = null", types.nullType, emptyMap()) - val term = register(statement.returnValue, inst, name) // term { termFactory.getValue(KexNull(), name) } + val inst = instructions.getPhi( + ctx, + "$name%EqNull", + types.get(statement.returnValue.type as Class<*>), + emptyMap() + ) + val term = register(statement.returnValue, inst, name) val pred = state { - term equality NullTerm() + term equality null } postProcess(inst, pred) } + else -> { val value = buildValue(statement.value, statement.returnClass) modifyName(statement.returnValue.name, "primitive%" + value.name + "%" + statement.returnValue.name) @@ -336,7 +344,7 @@ class KexTestObserver(executionContext: ExecutionContext, private val id: Int = nameCache[old] = new } - private fun getName(refName: String) = nameCache.getOrElse(refName) {refName} + private fun getName(refName: String) = nameCache.getOrElse(refName) { refName } private fun register(ref: VariableReference, value: Value, name: String? = null): Term { val wrapped = ref.wrap(value) @@ -397,36 +405,47 @@ class KexTestObserver(executionContext: ExecutionContext, private val id: Int = Boolean::class.java -> { values.getBool(value as Boolean) } + Byte::class.java -> { values.getByte(value as Byte) } + Char::class.java -> { values.getChar(value as Char) } + Short::class.java -> { values.getShort(value as Short) } + Int::class.java -> { values.getInt(value as Int) } + Long::class.java -> { values.getLong(value as Long) } + Float::class.java -> { values.getFloat(value as Float) } + Double::class.java -> { values.getDouble(value as Double) } + String::class.java -> { values.getString(value as String) } + Class::class.java -> { values.getClass(types.get(value as Class<*>)) } + Method::class.java -> { values.getMethod((value as Method).kfgMethod) } + else -> unreachable { } } diff --git a/sbst_scripts/setup-and-run-docker.sh b/sbst_scripts/setup-and-run-docker.sh index 81742a367e..5ce79c526a 100755 --- a/sbst_scripts/setup-and-run-docker.sh +++ b/sbst_scripts/setup-and-run-docker.sh @@ -15,7 +15,7 @@ TIME_BUDGET=$4 TOOL_NAME=$(basename "$TOOL_HOME") DOCKER_TOOL_HOME=/home/$TOOL_NAME -docker run --rm -d \ +docker run --platform linux/amd64 --rm -d \ -v "$TOOL_HOME":"$DOCKER_TOOL_HOME" \ -v "$BENCH_PATH":/var/benchmarks \ --name="$TOOL_NAME" \ From fdce016a4a01940abebf6d2035a6a51dfe4955fc Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Thu, 12 Sep 2024 16:28:02 +0200 Subject: [PATCH 22/34] fixes + new logs + new condition for clause selection --- .../ga/metaheuristics/mosa/DynaMOSA.java | 6 ++- .../org/evosuite/testcase/TestChromosome.java | 10 ++++- .../org/evosuite/kex/KexTestGenerator.kt | 34 +++++++++------ .../evosuite/kex/ScoreGuidedClauseSelector.kt | 43 ++++++++++++++++--- sbst_scripts/collect_files.py | 29 +++++++++++++ 5 files changed, 101 insertions(+), 21 deletions(-) create mode 100644 sbst_scripts/collect_files.py diff --git a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java index e4b42d9c8c..7c59e3d7c4 100644 --- a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java +++ b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java @@ -76,9 +76,13 @@ protected void evolve() { statLogger.debug("Concolic mutation: Number of timeout for concolic mutation: {}", TestChromosome.numberOfTimeouts); statLogger.debug("Concolic mutation: Total time for concolic mutation: {}", TestChromosome.totalAmountOfTimeConcolic); statLogger.debug("Concolic mutation: Number of irreversible for concolic mutation: {}", TestChromosome.numberOfIrreversibleConcolic); - statLogger.debug("Concolic mutation: Number of tests with mocks for concolic mutation: {}", TestChromosome.numberOfUnsupported); + statLogger.debug("Concolic mutation: Number of unsupported tests for concolic mutation (mocks): {}", TestChromosome.numberOfUnsupported[0]); + statLogger.debug("Concolic mutation: Number of unsupported tests for concolic mutation (EnviromentDataStatement): {}", TestChromosome.numberOfUnsupported[1]); statLogger.debug("Concolic mutation: Number of covered tests before concolic mutation: {}", TestChromosome.numberOfCovered); statLogger.debug("Concolic mutation: Number of unsats concolic mutation: {}", TestChromosome.numberOfUnsat); + statLogger.debug("Concolic mutation: Number of sats concolic mutation: {}", TestChromosome.numberOfSat); + statLogger.debug("Concolic mutation: Total time for of unsats concolic mutation: {}", TestChromosome.timeOfUnsat); + statLogger.debug("Concolic mutation: Total time for of sats concolic mutation: {}", TestChromosome.timeOfSat); long currentTime = System.currentTimeMillis(); KexTestGenerator.INSTANCE.collectTraces( diff --git a/client/src/main/java/org/evosuite/testcase/TestChromosome.java b/client/src/main/java/org/evosuite/testcase/TestChromosome.java index d4a500b798..1b30a73e0b 100755 --- a/client/src/main/java/org/evosuite/testcase/TestChromosome.java +++ b/client/src/main/java/org/evosuite/testcase/TestChromosome.java @@ -68,8 +68,11 @@ public final class TestChromosome extends AbstractTestChromosome public static int totalAmountOfTimeConcolic = 0; public static int numberOfIrreversibleConcolic = 0; public static int numberOfCovered = 0; - public static int numberOfUnsupported = 0; + public static int[] numberOfUnsupported = {0, 0}; public static int numberOfUnsat = 0; + public static int numberOfSat = 0; + public static int timeOfUnsat = 0; + public static int timeOfSat = 0; public static void reset() { numberOfCovered = 0; numberOfCollected = 0; @@ -79,8 +82,11 @@ public static void reset() { numberOfSuccessConcolic = 0; totalAmountOfTimeConcolic = 0; numberOfIrreversibleConcolic = 0; - numberOfUnsupported = 0; + numberOfUnsupported = new int[]{0, 0}; numberOfUnsat = 0; + numberOfSat = 0; + timeOfUnsat = 0; + timeOfSat = 0; } private static final long serialVersionUID = 7532366007973252782L; diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index 51632897d5..a20b31fcce 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -8,7 +8,6 @@ import kotlinx.coroutines.runBlocking import kotlinx.serialization.ExperimentalSerializationApi import kotlinx.serialization.InternalSerializationApi import org.evosuite.Properties -import org.evosuite.kex.observers.KexStatementObserver import org.evosuite.kex.observers.KexTestObserver import org.evosuite.testcase.DefaultTestCase import org.evosuite.testcase.TestCase @@ -19,7 +18,7 @@ import org.evosuite.testcase.statements.PrimitiveStatement import org.evosuite.testcase.statements.StringPrimitiveStatement import org.evosuite.testcase.statements.environment.EnvironmentDataStatement import org.evosuite.testcase.statements.numeric.* -import org.junit.Test +import org.slf4j.Logger import org.slf4j.LoggerFactory import org.vorpal.research.kex.descriptor.* import org.vorpal.research.kex.ktype.KexChar @@ -33,7 +32,6 @@ import org.vorpal.research.kex.trace.symbolic.PersistentClauseList import org.vorpal.research.kex.trace.symbolic.PersistentPathCondition import org.vorpal.research.kex.trace.symbolic.PersistentSymbolicState import org.vorpal.research.kex.trace.symbolic.SymbolicState -import org.vorpal.research.kex.trace.symbolic.protocol.SuccessResult import org.vorpal.research.kex.util.asmString import org.vorpal.research.kex.util.javaString import org.vorpal.research.kfg.Package @@ -50,9 +48,10 @@ import kotlin.time.ExperimentalTime @DelicateCoroutinesApi object KexTestGenerator { private val logger = LoggerFactory.getLogger(KexTestGenerator::class.java) + private val statLogger = LoggerFactory.getLogger("StatLogger") private val ctx get() = KexService.ctx - private val cache = WeakHashMap() + private val cache = HashMap() private val clauseSelector = ScoreGuidedClauseSelector(ctx.cm[Properties.TARGET_CLASS.asmString].allMethods, ctx) @@ -62,14 +61,16 @@ object KexTestGenerator { const val KEX_GENERATION_TIMEOUT = 5000 const val KEX_EXECUTION_TIMEOUT = 5000 - private fun isSupported(testCase: TestCase): Boolean { + private fun isSupported(testCase: TestCase): Int { for (statement in testCase.toList()) { - if (statement is FunctionalMockStatement || - statement is EnvironmentDataStatement<*>) { - return false + if (statement is FunctionalMockStatement) { + return 0 + } + if (statement is EnvironmentDataStatement<*>) { + return 1 } } - return true + return 2 } fun collectTraces(testChromosomes: List, stoppingCondition: () -> Boolean) { @@ -78,7 +79,7 @@ object KexTestGenerator { for (test in testChromosomes) { if (stoppingCondition()) break if (test.testCase.toCode() in cache) continue - if (!isSupported(test.testCase)) continue + if (isSupported(test.testCase) != 2) continue try { val observer = KexTestObserver(ctx) @@ -106,8 +107,9 @@ object KexTestGenerator { fun generateTest(chosenTest: TestChromosome, stoppingCondition: () -> Boolean): TestCase? = runBlocking { logger.info("Generating test with kex") - if (!isSupported(chosenTest.testCase)) { - TestChromosome.numberOfUnsupported += 1 + val supported = isSupported(chosenTest.testCase) + if (supported != 2) { + TestChromosome.numberOfUnsupported[supported] += 1 return@runBlocking null } @@ -144,10 +146,16 @@ object KexTestGenerator { prevState.termMap.toPersistentMap() ) + val t = System.currentTimeMillis() val result = state.check(ctx) + val duration = (System.currentTimeMillis() - t).toInt() if (result == null) { + TestChromosome.timeOfUnsat += duration TestChromosome.numberOfUnsat += 1 - continue + break + } else { + TestChromosome.timeOfSat += duration + TestChromosome.numberOfSat += 1 } val test = generateTest(chosenTest.testCase.clone(), result) ?: continue return@runBlocking test diff --git a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt index bab5247112..da4c3ebea6 100644 --- a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt +++ b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt @@ -4,18 +4,20 @@ import kotlinx.collections.immutable.toPersistentList import org.vorpal.research.kex.ExecutionContext import org.vorpal.research.kex.asm.analysis.concolic.bfs.BfsPathSelectorImpl import org.vorpal.research.kex.asm.analysis.concolic.coverage.InstructionGraph +import org.vorpal.research.kex.state.predicate.EqualityPredicate +import org.vorpal.research.kex.state.term.* import org.vorpal.research.kex.trace.symbolic.Clause import org.vorpal.research.kex.trace.symbolic.PathClause import org.vorpal.research.kex.trace.symbolic.PathClauseType +import org.vorpal.research.kex.trace.symbolic.SymbolicState import org.vorpal.research.kfg.Package import org.vorpal.research.kfg.ir.Method import org.vorpal.research.kfg.ir.MethodDescriptor import org.vorpal.research.kfg.ir.Modifiers import org.vorpal.research.kfg.ir.OuterClass -import org.vorpal.research.kfg.ir.value.instruction.CallInst -import org.vorpal.research.kfg.ir.value.instruction.CatchInst -import org.vorpal.research.kfg.ir.value.instruction.Instruction -import org.vorpal.research.kfg.ir.value.instruction.ReturnInst +import org.vorpal.research.kfg.ir.value.NullConstant +import org.vorpal.research.kfg.ir.value.instruction.* +import java.util.* class ScoreGuidedClauseSelector( override val targets: Set, @@ -56,6 +58,8 @@ class ScoreGuidedClauseSelector( clauses.addAll(newClauses) path.addAll(newPath) + val isPrimitiveDependent = WeakHashMap() + candidates.clear() var pathIndex = 0 val stackTraces = mutableListOf>>() @@ -91,9 +95,30 @@ class ScoreGuidedClauseSelector( if (clause is PathClause) { stackTraces += currentStackTrace.toList() assert(clause == path[pathIndex]) - if (clause.type == PathClauseType.CONDITION_CHECK) + if (isPathClauseReversible(clause, isPrimitiveDependent)) { candidates.add(i to pathIndex) + } pathIndex++ + } else { + if (clause.predicate is EqualityPredicate && (clause.predicate as EqualityPredicate).lhv !is ConstBoolTerm) { + when ((clause.predicate as EqualityPredicate).rhv) { + is CmpTerm -> { + if (((clause.predicate as EqualityPredicate).rhv as CmpTerm).rhv !is NullTerm) { + isPrimitiveDependent[(clause.predicate as EqualityPredicate).lhv] = + isPrimitiveDependent[((clause.predicate as EqualityPredicate).rhv as CmpTerm).lhv] ?: ((clause.predicate as EqualityPredicate).rhv as CmpTerm).lhv.check + || isPrimitiveDependent[((clause.predicate as EqualityPredicate).rhv as CmpTerm).rhv] ?: ((clause.predicate as EqualityPredicate).rhv as CmpTerm).rhv.check + + } + } + + is InstanceOfTerm -> isPrimitiveDependent[(clause.predicate as EqualityPredicate).lhv] = false + + else -> isPrimitiveDependent[(clause.predicate as EqualityPredicate).lhv] = + isPrimitiveDependent[(clause.predicate as EqualityPredicate).rhv] + ?: (clause.predicate as EqualityPredicate).rhv.check + + } + } } } @@ -109,6 +134,12 @@ class ScoreGuidedClauseSelector( } } + private fun isPathClauseReversible(clause: PathClause, isPrimitiveDependent: WeakHashMap): Boolean { + return clause.type == PathClauseType.CONDITION_CHECK && clause.predicate.operands.map { op -> + isPrimitiveDependent[op] ?: op.check + }.fold(false) { acc, cur -> acc || cur } + } + // TODO: rewrite? override fun reverse(pathClause: PathClause): PathClause? = BfsPathSelectorImpl( ctx, Method( @@ -117,4 +148,6 @@ class ScoreGuidedClauseSelector( ) ).reverse(pathClause) + private val Term.check: Boolean get() = this.name.contains("%primitive%") && this is ValueTerm + } diff --git a/sbst_scripts/collect_files.py b/sbst_scripts/collect_files.py new file mode 100644 index 0000000000..54da79ec6d --- /dev/null +++ b/sbst_scripts/collect_files.py @@ -0,0 +1,29 @@ +import os +import shutil +from pathlib import Path +import sys + +def copy_files_with_specific_name(src_dir, dest_dir, file_name): + # Ensure the destination directory exists + os.makedirs(dest_dir, exist_ok=True) + + # Walk through the source directory + for root, dirs, files in os.walk(src_dir): + for file in files: + if file == file_name: + # Calculate the relative path of the file + rel_path = os.path.relpath(root, src_dir) + # Construct the destination path + dest_path = os.path.join(dest_dir, rel_path) + os.makedirs(dest_path, exist_ok=True) + # Copy the file to the destination path + shutil.copy(os.path.join(root, file), os.path.join(dest_path, file)) + print(f"Copied: {os.path.join(root, file)} to {os.path.join(dest_path, file)}") + +# Example usage +src_directory = sys.argv[1] +dest_directory = sys.argv[2] +a = ['work-stat.log', 'coverage-info.log'] + +for f in a: + copy_files_with_specific_name(src_directory, dest_directory, f) From 349fec0aaa1a5b90fbd40e517333c286652ab15d Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Fri, 13 Sep 2024 12:27:06 +0200 Subject: [PATCH 23/34] logged kex calls --- .../java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java | 1 + .../src/main/java/org/evosuite/testcase/TestChromosome.java | 2 ++ client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt | 5 +++++ 3 files changed, 8 insertions(+) diff --git a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java index 7c59e3d7c4..520f09a902 100644 --- a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java +++ b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java @@ -83,6 +83,7 @@ protected void evolve() { statLogger.debug("Concolic mutation: Number of sats concolic mutation: {}", TestChromosome.numberOfSat); statLogger.debug("Concolic mutation: Total time for of unsats concolic mutation: {}", TestChromosome.timeOfUnsat); statLogger.debug("Concolic mutation: Total time for of sats concolic mutation: {}", TestChromosome.timeOfSat); + statLogger.debug("Concolic mutation: Number of Kex calls: {}", TestChromosome.numberOfKexCalls); long currentTime = System.currentTimeMillis(); KexTestGenerator.INSTANCE.collectTraces( diff --git a/client/src/main/java/org/evosuite/testcase/TestChromosome.java b/client/src/main/java/org/evosuite/testcase/TestChromosome.java index 1b30a73e0b..8fc272df9f 100755 --- a/client/src/main/java/org/evosuite/testcase/TestChromosome.java +++ b/client/src/main/java/org/evosuite/testcase/TestChromosome.java @@ -73,6 +73,7 @@ public final class TestChromosome extends AbstractTestChromosome public static int numberOfSat = 0; public static int timeOfUnsat = 0; public static int timeOfSat = 0; + public static int numberOfKexCalls = 0; public static void reset() { numberOfCovered = 0; numberOfCollected = 0; @@ -82,6 +83,7 @@ public static void reset() { numberOfSuccessConcolic = 0; totalAmountOfTimeConcolic = 0; numberOfIrreversibleConcolic = 0; + numberOfKexCalls = 0; numberOfUnsupported = new int[]{0, 0}; numberOfUnsat = 0; numberOfSat = 0; diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index a20b31fcce..e8f46c9614 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -128,7 +128,9 @@ object KexTestGenerator { TestChromosome.numberOfCovered += 1 } + var i = 0 while (clauseSelector.hasNext() && !stoppingCondition()) { + i += 1 val (clauseList, pathList) = clauseSelector.next() if (clauseList == null || pathList == null) { break @@ -146,6 +148,9 @@ object KexTestGenerator { prevState.termMap.toPersistentMap() ) + if (i == 1) + TestChromosome.numberOfKexCalls += 1; + val t = System.currentTimeMillis() val result = state.check(ctx) val duration = (System.currentTimeMillis() - t).toInt() From 88da7e326e08cf5261165c6035939c35d4bed04b Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Wed, 18 Sep 2024 04:45:42 +0200 Subject: [PATCH 24/34] rewrote data flow analysis --- .../evosuite/kex/ScoreGuidedClauseSelector.kt | 129 ++++++++++++++---- 1 file changed, 105 insertions(+), 24 deletions(-) diff --git a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt index da4c3ebea6..182b32274b 100644 --- a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt +++ b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt @@ -4,18 +4,16 @@ import kotlinx.collections.immutable.toPersistentList import org.vorpal.research.kex.ExecutionContext import org.vorpal.research.kex.asm.analysis.concolic.bfs.BfsPathSelectorImpl import org.vorpal.research.kex.asm.analysis.concolic.coverage.InstructionGraph -import org.vorpal.research.kex.state.predicate.EqualityPredicate +import org.vorpal.research.kex.state.predicate.* import org.vorpal.research.kex.state.term.* import org.vorpal.research.kex.trace.symbolic.Clause import org.vorpal.research.kex.trace.symbolic.PathClause import org.vorpal.research.kex.trace.symbolic.PathClauseType -import org.vorpal.research.kex.trace.symbolic.SymbolicState import org.vorpal.research.kfg.Package import org.vorpal.research.kfg.ir.Method import org.vorpal.research.kfg.ir.MethodDescriptor import org.vorpal.research.kfg.ir.Modifiers import org.vorpal.research.kfg.ir.OuterClass -import org.vorpal.research.kfg.ir.value.NullConstant import org.vorpal.research.kfg.ir.value.instruction.* import java.util.* @@ -27,6 +25,8 @@ class ScoreGuidedClauseSelector( private val clauses = mutableListOf() private val path = mutableListOf() private val candidates = mutableListOf>() + private val isPrimitiveDependent = WeakHashMap() + private val isCallPrimitiveDependent = mutableListOf(false) private val targetInstructions = targets.flatMapTo(mutableSetOf()) { it.body.flatten() } private val coveredInstructions = mutableSetOf() private var index = 0 @@ -58,8 +58,6 @@ class ScoreGuidedClauseSelector( clauses.addAll(newClauses) path.addAll(newPath) - val isPrimitiveDependent = WeakHashMap() - candidates.clear() var pathIndex = 0 val stackTraces = mutableListOf>>() @@ -73,6 +71,7 @@ class ScoreGuidedClauseSelector( when (currentInstruction) { currentMethod.body.entry.first() -> { currentStackTrace += previousInstruction to currentMethod + isCallPrimitiveDependent += false } is CallInst -> { @@ -81,11 +80,13 @@ class ScoreGuidedClauseSelector( is ReturnInst -> { currentStackTrace.removeAt(currentStackTrace.size - 1) + isCallPrimitiveDependent.removeAt(isCallPrimitiveDependent.size - 1) } is CatchInst -> { while (stackTraces[stackTraces.size - 1].last().second != currentMethod) { currentStackTrace.removeAt(currentStackTrace.size - 1) + isCallPrimitiveDependent.removeAt(isCallPrimitiveDependent.size - 1) } } } @@ -95,28 +96,76 @@ class ScoreGuidedClauseSelector( if (clause is PathClause) { stackTraces += currentStackTrace.toList() assert(clause == path[pathIndex]) - if (isPathClauseReversible(clause, isPrimitiveDependent)) { + if (isPathClauseReversible(clause)) { candidates.add(i to pathIndex) } pathIndex++ } else { - if (clause.predicate is EqualityPredicate && (clause.predicate as EqualityPredicate).lhv !is ConstBoolTerm) { - when ((clause.predicate as EqualityPredicate).rhv) { - is CmpTerm -> { - if (((clause.predicate as EqualityPredicate).rhv as CmpTerm).rhv !is NullTerm) { - isPrimitiveDependent[(clause.predicate as EqualityPredicate).lhv] = - isPrimitiveDependent[((clause.predicate as EqualityPredicate).rhv as CmpTerm).lhv] ?: ((clause.predicate as EqualityPredicate).rhv as CmpTerm).lhv.check - || isPrimitiveDependent[((clause.predicate as EqualityPredicate).rhv as CmpTerm).rhv] ?: ((clause.predicate as EqualityPredicate).rhv as CmpTerm).rhv.check + when (val predicate = clause.predicate) { + is FieldStorePredicate -> { + isPrimitiveDependent[predicate.field] = isPrimitive(predicate.value) + isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] = + isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] || isPrimitiveDependent[predicate.field]!! + } + is EqualityPredicate -> { + if (predicate.lhv !is ConstBoolTerm) { + isPrimitiveDependent[predicate.lhv] = isPrimitive(predicate.rhv) + if (predicate.lhv.isReturnValue) { + isPrimitiveDependent[predicate.lhv] = + isPrimitiveDependent[predicate.lhv]!! || isCallPrimitiveDependent.last() } + isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] = + isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] || isPrimitiveDependent[predicate.lhv]!! } + } + + + is InequalityPredicate -> { + isPrimitiveDependent[predicate.lhv] = isPrimitive(predicate.rhv) + isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] = + isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] || isPrimitiveDependent[predicate.lhv]!! + } + + is GenerateArrayPredicate -> { + isPrimitiveDependent[predicate.lhv] = + isPrimitive(predicate.length) || isPrimitive(predicate.generator) + isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] = + isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] || isPrimitiveDependent[predicate.lhv]!! + } + + is FieldInitializerPredicate -> { + isPrimitiveDependent[predicate.field] = isPrimitive(predicate.value) + isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] = + isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] || isPrimitiveDependent[predicate.field]!! + } - is InstanceOfTerm -> isPrimitiveDependent[(clause.predicate as EqualityPredicate).lhv] = false + is NewPredicate -> { + isPrimitiveDependent[predicate.lhv] = false + } - else -> isPrimitiveDependent[(clause.predicate as EqualityPredicate).lhv] = - isPrimitiveDependent[(clause.predicate as EqualityPredicate).rhv] - ?: (clause.predicate as EqualityPredicate).rhv.check + is NewInitializerPredicate -> { + isPrimitiveDependent[predicate.lhv] = false + } + + is NewArrayPredicate -> { + isPrimitiveDependent[predicate.lhv] = false + } + + is NewArrayInitializerPredicate -> { + isPrimitiveDependent[predicate.lhv] = false + } + + is ArrayStorePredicate -> { + isPrimitiveDependent[predicate.arrayRef] = isPrimitive(predicate.value) + isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] = + isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] || isPrimitiveDependent[predicate.arrayRef]!! + } + is ArrayInitializerPredicate -> { + isPrimitiveDependent[predicate.arrayRef] = isPrimitive(predicate.value) + isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] = + isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] || isPrimitiveDependent[predicate.arrayRef]!! } } } @@ -126,18 +175,16 @@ class ScoreGuidedClauseSelector( assert(pathIndex == path.size) candidates.sortBy { (_, pathIndex) -> - val distance = instructionGraph.getVertex(path[pathIndex].instruction) .distanceToUncovered(targets, stackTraces[pathIndex].toPersistentList()).first - distance } } - private fun isPathClauseReversible(clause: PathClause, isPrimitiveDependent: WeakHashMap): Boolean { - return clause.type == PathClauseType.CONDITION_CHECK && clause.predicate.operands.map { op -> - isPrimitiveDependent[op] ?: op.check - }.fold(false) { acc, cur -> acc || cur } + private fun isPathClauseReversible(clause: PathClause): Boolean { + return clause.type == PathClauseType.CONDITION_CHECK && clause.predicate.operands.fold(false) { acc, cur -> + acc || getOrUpdate(cur) + } } // TODO: rewrite? @@ -148,6 +195,40 @@ class ScoreGuidedClauseSelector( ) ).reverse(pathClause) - private val Term.check: Boolean get() = this.name.contains("%primitive%") && this is ValueTerm + private val Term.isPrimitiveValue: Boolean get() = this.name.contains("%primitive%") + private val Term.isReturnValue: Boolean get() = this.name.contains("retval") + + private fun isPrimitive(term: Term): Boolean { + when (term) { + is CmpTerm -> { + if (term.rhv !is NullTerm) { + return getOrUpdate(term.lhv) || getOrUpdate(term.rhv) + } + return false + } + + is InstanceOfTerm -> return false + + is ValueTerm -> { + if (term.isPrimitiveValue) + return true + if (term.isReturnValue) { + if (isCallPrimitiveDependent.isEmpty()) return getOrUpdate(term, false) + return getOrUpdate(term, isCallPrimitiveDependent.last()) + } + return isPrimitiveDependent[term] ?: false + } + + else -> return term.subTerms.fold(false) { acc, cur -> acc || getOrUpdate(cur) } + + } + } + + private fun getOrUpdate(term: Term, value: Boolean? = null): Boolean { + if (isPrimitiveDependent[term] == null) { + isPrimitiveDependent[term] = value ?: isPrimitive(term) + } + return isPrimitiveDependent[term]!! + } } From b482829291164ba4911566a856c7a264684b6738 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Fri, 20 Sep 2024 13:46:45 +0200 Subject: [PATCH 25/34] rewrote data flow analysis to transformer --- .../org/evosuite/kex/KexTestGenerator.kt | 9 +- .../kex/PrimitiveDependencyAnalysis.kt | 361 ++++++++++++++++++ .../evosuite/kex/ScoreGuidedClauseSelector.kt | 133 +------ 3 files changed, 378 insertions(+), 125 deletions(-) create mode 100644 client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt diff --git a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt index e8f46c9614..70ff14c176 100644 --- a/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt +++ b/client/src/main/kotlin/org/evosuite/kex/KexTestGenerator.kt @@ -14,11 +14,11 @@ import org.evosuite.testcase.TestCase import org.evosuite.testcase.TestChromosome import org.evosuite.testcase.statements.EnumPrimitiveStatement import org.evosuite.testcase.statements.FunctionalMockStatement +import org.evosuite.testcase.statements.NullStatement import org.evosuite.testcase.statements.PrimitiveStatement import org.evosuite.testcase.statements.StringPrimitiveStatement import org.evosuite.testcase.statements.environment.EnvironmentDataStatement import org.evosuite.testcase.statements.numeric.* -import org.slf4j.Logger import org.slf4j.LoggerFactory import org.vorpal.research.kex.descriptor.* import org.vorpal.research.kex.ktype.KexChar @@ -48,7 +48,6 @@ import kotlin.time.ExperimentalTime @DelicateCoroutinesApi object KexTestGenerator { private val logger = LoggerFactory.getLogger(KexTestGenerator::class.java) - private val statLogger = LoggerFactory.getLogger("StatLogger") private val ctx get() = KexService.ctx private val cache = HashMap() @@ -120,7 +119,7 @@ object KexTestGenerator { } else { TestChromosome.numberOfCollected += 1 } - clauseSelector.setState(prevState.clauses.state, prevState.path.path) + clauseSelector.setState(prevState) if (clauseSelector.size() == 0) { TestChromosome.numberOfIrreversibleConcolic += 1 @@ -149,7 +148,7 @@ object KexTestGenerator { ) if (i == 1) - TestChromosome.numberOfKexCalls += 1; + TestChromosome.numberOfKexCalls += 1 val t = System.currentTimeMillis() val result = state.check(ctx) @@ -191,7 +190,7 @@ object KexTestGenerator { for (s in oldTest) { newTest.addStatement(s.clone(newTest)) - if (s is PrimitiveStatement<*> && primitivesLeft) { + if (s is PrimitiveStatement<*> && s !is NullStatement && primitivesLeft) { isTestChanged = true when (s) { is IntPrimitiveStatement -> { diff --git a/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt b/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt new file mode 100644 index 0000000000..b0e517cfa6 --- /dev/null +++ b/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt @@ -0,0 +1,361 @@ +package org.evosuite.kex + +import org.vorpal.research.kex.state.predicate.* +import org.vorpal.research.kex.state.term.* +import org.vorpal.research.kex.state.transformer.Transformer +import org.vorpal.research.kthelper.assert.unreachable +import java.util.* + +class PrimitiveDependencyAnalysis : Transformer { + private val isPrimitiveDependent = WeakHashMap() + + init { + isPrimitiveDependent[ConstBoolTerm(true)] = false + isPrimitiveDependent[ConstBoolTerm(false)] = false + } + + fun isPrimitiveDependent(term: Term): Boolean { + return isPrimitiveDependent[term] ?: unreachable { } + } + + private val Term.isPrimitiveValue: Boolean get() = this.name.contains("%primitive%") + + //////////////////////////////////////////////////////////////////// + // Term + //////////////////////////////////////////////////////////////////// + + override fun transformArrayLoadTerm(term: ArrayLoadTerm): Term { + assert(term.arrayRef is ArrayIndexTerm) + isPrimitiveDependent[term] = + isPrimitiveDependent[term.arrayRef]!! || isPrimitiveDependent[(term.arrayRef as ArrayIndexTerm).arrayRef]!! + return term + } + + override fun transformArrayContainsTerm(term: ArrayContainsTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.value]!! || isPrimitiveDependent[term.array]!! + return term + } + + override fun transformArrayIndexTerm(term: ArrayIndexTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.index]!! || isPrimitiveDependent[term.arrayRef]!! + return term + } + + override fun transformArgumentTerm(term: ArgumentTerm): Term { + error("Should not transform ArgumentTerm") + } + + override fun transformArrayLengthTerm(term: ArrayLengthTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.arrayRef] + return term + } + + override fun transformCharAtTerm(term: CharAtTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.index]!! || isPrimitiveDependent[term.string]!! + return term + } + + override fun transformBinaryTerm(term: BinaryTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.lhv]!! || isPrimitiveDependent[term.rhv]!! + return term + } + + override fun transformBoundTerm(term: BoundTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformCallTerm(term: CallTerm): Term { + isPrimitiveDependent[term] = term.arguments.fold(false) { acc, cur -> + isPrimitiveDependent[cur]!! || acc + } || isPrimitiveDependent[term.owner]!! + return term + } + + override fun transformCastTerm(term: CastTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.operand] + return term + } + + override fun transformClassAccessTerm(term: ClassAccessTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.operand] + return term + } + + override fun transformCmpTerm(term: CmpTerm): Term { + if (term.rhv !is NullTerm) { + isPrimitiveDependent[term] = isPrimitiveDependent[term.lhv]!! || isPrimitiveDependent[term.rhv]!! + } else { + isPrimitiveDependent[term] = false + } + return term + } + + override fun transformConcatTerm(term: ConcatTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.lhv]!! || isPrimitiveDependent[term.rhv]!! + return term + } + + override fun transformConstBoolTerm(term: ConstBoolTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformConstByteTerm(term: ConstByteTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformConstCharTerm(term: ConstCharTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformConstDoubleTerm(term: ConstDoubleTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformConstIntTerm(term: ConstIntTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformConstLongTerm(term: ConstLongTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformConstFloatTerm(term: ConstFloatTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformConstClassTerm(term: ConstClassTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformConstStringTerm(term: ConstStringTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformConstShortTerm(term: ConstShortTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformEndsWithTerm(term: EndsWithTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.string]!! || isPrimitiveDependent[term.suffix]!! + return term + } + + override fun transformEqualsTerm(term: EqualsTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.lhv]!! || isPrimitiveDependent[term.rhv]!! + return term + } + + override fun transformExistsTerm(term: ExistsTerm): Term { + isPrimitiveDependent[term] = + isPrimitiveDependent[term.start]!! || isPrimitiveDependent[term.end]!! || isPrimitiveDependent[term.body]!! + return term + } + + override fun transformFieldLoadTerm(term: FieldLoadTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.field] + return term + } + + override fun transformFieldTerm(term: FieldTerm): Term { + return term + } + + override fun transformForAllTerm(term: ForAllTerm): Term { + isPrimitiveDependent[term] = + isPrimitiveDependent[term.start]!! || isPrimitiveDependent[term.end]!! || isPrimitiveDependent[term.body]!! + return term + } + + override fun transformIndexOfTerm(term: IndexOfTerm): Term { + isPrimitiveDependent[term] = + isPrimitiveDependent[term.string]!! || isPrimitiveDependent[term.substring]!! || isPrimitiveDependent[term.offset]!! + return term + } + + override fun transformInstanceOfTerm(term: InstanceOfTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformIteTerm(term: IteTerm): Term { + isPrimitiveDependent[term] = + isPrimitiveDependent[term.cond]!! || isPrimitiveDependent[term.trueValue]!! || isPrimitiveDependent[term.falseValue]!! + return term + } + + override fun transformLambdaTerm(term: LambdaTerm): Term { + isPrimitiveDependent[term] = term.parameters.fold(false) { acc, cur -> + isPrimitiveDependent[cur]!! || acc + } + return term + } + + override fun transformNegTerm(term: NegTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.operand] + return term + } + + override fun transformNullTerm(term: NullTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformReturnValueTerm(term: ReturnValueTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformStartsWithTerm(term: StartsWithTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.string]!! || isPrimitiveDependent[term.prefix]!! + return term + } + + override fun transformStaticClassRefTerm(term: StaticClassRefTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformStringContainsTerm(term: StringContainsTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.string]!! || isPrimitiveDependent[term.substring]!! + return term + } + + override fun transformStringLengthTerm(term: StringLengthTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.string] + return term + } + + override fun transformStringParseTerm(term: StringParseTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.string] + return term + } + + override fun transformSubstringTerm(term: SubstringTerm): Term { + isPrimitiveDependent[term] = + isPrimitiveDependent[term.string]!! || isPrimitiveDependent[term.offset]!! || isPrimitiveDependent[term.length]!! + return term + } + + override fun transformToStringTerm(term: ToStringTerm): Term { + isPrimitiveDependent[term] = isPrimitiveDependent[term.value] + return term + } + + override fun transformUndefTerm(term: UndefTerm): Term { + isPrimitiveDependent[term] = false + return term + } + + override fun transformValueTerm(term: ValueTerm): Term { + if (term.isPrimitiveValue) isPrimitiveDependent[term] = true + if (isPrimitiveDependent[term] == null) isPrimitiveDependent[term] = false + return term + } + + //////////////////////////////////////////////////////////////////// + // Predicate + //////////////////////////////////////////////////////////////////// + + override fun transformArrayInitializerPredicate(predicate: ArrayInitializerPredicate): Predicate { + assert(predicate.arrayRef is ArrayIndexTerm) + isPrimitiveDependent[(predicate.arrayRef as ArrayIndexTerm).arrayRef] = isPrimitiveDependent[predicate.value]!! + isPrimitiveDependent[predicate.arrayRef] = isPrimitiveDependent[predicate.value]!! + return predicate + } + + override fun transformArrayStorePredicate(predicate: ArrayStorePredicate): Predicate { + assert(predicate.arrayRef is ArrayIndexTerm) + isPrimitiveDependent[(predicate.arrayRef as ArrayIndexTerm).arrayRef] = isPrimitiveDependent[predicate.value]!! + isPrimitiveDependent[predicate.arrayRef] = isPrimitiveDependent[predicate.value]!! + return predicate + } + + override fun transformBoundStorePredicate(predicate: BoundStorePredicate): Predicate { + return predicate + } + + override fun transformCallPredicate(predicate: CallPredicate): Predicate { + if (predicate.hasLhv) isPrimitiveDependent[predicate.lhv] = isPrimitiveDependent[predicate.callTerm] + return predicate + } + + override fun transformCatchPredicate(predicate: CatchPredicate): Predicate { + return predicate + } + + override fun transformDefaultSwitchPredicate(predicate: DefaultSwitchPredicate): Predicate { + return predicate + } + + override fun transformEnterMonitorPredicate(predicate: EnterMonitorPredicate): Predicate { + return predicate + } + + override fun transformEqualityPredicate(predicate: EqualityPredicate): Predicate { + if (predicate.lhv !is ConstBoolTerm) { + isPrimitiveDependent[predicate.lhv] = isPrimitiveDependent[predicate.rhv] + } + return predicate + } + + override fun transformExitMonitorPredicate(predicate: ExitMonitorPredicate): Predicate { + return predicate + } + + override fun transformFieldInitializerPredicate(predicate: FieldInitializerPredicate): Predicate { + isPrimitiveDependent[predicate.field] = isPrimitiveDependent[predicate.value] + return predicate + } + + override fun transformFieldStorePredicate(predicate: FieldStorePredicate): Predicate { + isPrimitiveDependent[predicate.field] = isPrimitiveDependent[predicate.value] + return predicate + } + + override fun transformGenerateArrayPredicate(predicate: GenerateArrayPredicate): Predicate { + isPrimitiveDependent[predicate.lhv] = + isPrimitiveDependent[predicate.length]!! || isPrimitiveDependent[predicate.generator]!! + return predicate + } + + override fun transformInequalityPredicate(predicate: InequalityPredicate): Predicate { + return predicate + } + + override fun transformNewArrayInitializerPredicate(predicate: NewArrayInitializerPredicate): Predicate { + isPrimitiveDependent[predicate.lhv] = predicate.elements.fold(false) { acc, cur -> + isPrimitiveDependent[cur]!! || acc + } || isPrimitiveDependent[predicate.length]!! + return predicate + } + + override fun transformNewArrayPredicate(predicate: NewArrayPredicate): Predicate { + isPrimitiveDependent[predicate.lhv] = predicate.dimensions.fold(false) { acc, cur -> + isPrimitiveDependent[cur]!! || acc + } + return predicate + } + + override fun transformNewInitializerPredicate(predicate: NewInitializerPredicate): Predicate { + return predicate + } + + override fun transformNewPredicate(predicate: NewPredicate): Predicate { + return predicate + } + + override fun transformThrowPredicate(predicate: ThrowPredicate): Predicate { + return predicate + } +} \ No newline at end of file diff --git a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt index 182b32274b..defcb968b4 100644 --- a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt +++ b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt @@ -4,18 +4,13 @@ import kotlinx.collections.immutable.toPersistentList import org.vorpal.research.kex.ExecutionContext import org.vorpal.research.kex.asm.analysis.concolic.bfs.BfsPathSelectorImpl import org.vorpal.research.kex.asm.analysis.concolic.coverage.InstructionGraph -import org.vorpal.research.kex.state.predicate.* -import org.vorpal.research.kex.state.term.* -import org.vorpal.research.kex.trace.symbolic.Clause -import org.vorpal.research.kex.trace.symbolic.PathClause -import org.vorpal.research.kex.trace.symbolic.PathClauseType +import org.vorpal.research.kex.trace.symbolic.* import org.vorpal.research.kfg.Package import org.vorpal.research.kfg.ir.Method import org.vorpal.research.kfg.ir.MethodDescriptor import org.vorpal.research.kfg.ir.Modifiers import org.vorpal.research.kfg.ir.OuterClass import org.vorpal.research.kfg.ir.value.instruction.* -import java.util.* class ScoreGuidedClauseSelector( override val targets: Set, @@ -25,8 +20,6 @@ class ScoreGuidedClauseSelector( private val clauses = mutableListOf() private val path = mutableListOf() private val candidates = mutableListOf>() - private val isPrimitiveDependent = WeakHashMap() - private val isCallPrimitiveDependent = mutableListOf(false) private val targetInstructions = targets.flatMapTo(mutableSetOf()) { it.body.flatten() } private val coveredInstructions = mutableSetOf() private var index = 0 @@ -52,7 +45,15 @@ class ScoreGuidedClauseSelector( coveredInstructions += trace } - fun setState(newClauses: List, newPath: List) { + fun setState(state: SymbolicState) { + val newClauses = state.clauses.state + val newPath = state.path.path + + val analysis = PrimitiveDependencyAnalysis() + val clausesWithoutPath = newClauses.filterNot { it is PathClause } + + analysis.apply(clausesWithoutPath.toClauseState().asState()) + clauses.clear() path.clear() clauses.addAll(newClauses) @@ -71,7 +72,6 @@ class ScoreGuidedClauseSelector( when (currentInstruction) { currentMethod.body.entry.first() -> { currentStackTrace += previousInstruction to currentMethod - isCallPrimitiveDependent += false } is CallInst -> { @@ -80,13 +80,11 @@ class ScoreGuidedClauseSelector( is ReturnInst -> { currentStackTrace.removeAt(currentStackTrace.size - 1) - isCallPrimitiveDependent.removeAt(isCallPrimitiveDependent.size - 1) } is CatchInst -> { while (stackTraces[stackTraces.size - 1].last().second != currentMethod) { currentStackTrace.removeAt(currentStackTrace.size - 1) - isCallPrimitiveDependent.removeAt(isCallPrimitiveDependent.size - 1) } } } @@ -96,78 +94,10 @@ class ScoreGuidedClauseSelector( if (clause is PathClause) { stackTraces += currentStackTrace.toList() assert(clause == path[pathIndex]) - if (isPathClauseReversible(clause)) { + if (isPathClauseReversible(clause, analysis)) { candidates.add(i to pathIndex) } pathIndex++ - } else { - when (val predicate = clause.predicate) { - is FieldStorePredicate -> { - isPrimitiveDependent[predicate.field] = isPrimitive(predicate.value) - isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] = - isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] || isPrimitiveDependent[predicate.field]!! - } - - is EqualityPredicate -> { - if (predicate.lhv !is ConstBoolTerm) { - isPrimitiveDependent[predicate.lhv] = isPrimitive(predicate.rhv) - if (predicate.lhv.isReturnValue) { - isPrimitiveDependent[predicate.lhv] = - isPrimitiveDependent[predicate.lhv]!! || isCallPrimitiveDependent.last() - } - isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] = - isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] || isPrimitiveDependent[predicate.lhv]!! - } - } - - - is InequalityPredicate -> { - isPrimitiveDependent[predicate.lhv] = isPrimitive(predicate.rhv) - isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] = - isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] || isPrimitiveDependent[predicate.lhv]!! - } - - is GenerateArrayPredicate -> { - isPrimitiveDependent[predicate.lhv] = - isPrimitive(predicate.length) || isPrimitive(predicate.generator) - isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] = - isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] || isPrimitiveDependent[predicate.lhv]!! - } - - is FieldInitializerPredicate -> { - isPrimitiveDependent[predicate.field] = isPrimitive(predicate.value) - isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] = - isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] || isPrimitiveDependent[predicate.field]!! - } - - is NewPredicate -> { - isPrimitiveDependent[predicate.lhv] = false - } - - is NewInitializerPredicate -> { - isPrimitiveDependent[predicate.lhv] = false - } - - is NewArrayPredicate -> { - isPrimitiveDependent[predicate.lhv] = false - } - - is NewArrayInitializerPredicate -> { - isPrimitiveDependent[predicate.lhv] = false - } - - is ArrayStorePredicate -> { - isPrimitiveDependent[predicate.arrayRef] = isPrimitive(predicate.value) - isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] = - isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] || isPrimitiveDependent[predicate.arrayRef]!! - } - - is ArrayInitializerPredicate -> { - isPrimitiveDependent[predicate.arrayRef] = isPrimitive(predicate.value) - isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] = - isCallPrimitiveDependent[isCallPrimitiveDependent.size - 1] || isPrimitiveDependent[predicate.arrayRef]!! - } - } } } @@ -181,9 +111,9 @@ class ScoreGuidedClauseSelector( } } - private fun isPathClauseReversible(clause: PathClause): Boolean { + private fun isPathClauseReversible(clause: PathClause, analysis: PrimitiveDependencyAnalysis): Boolean { return clause.type == PathClauseType.CONDITION_CHECK && clause.predicate.operands.fold(false) { acc, cur -> - acc || getOrUpdate(cur) + acc || analysis.isPrimitiveDependent(cur) } } @@ -194,41 +124,4 @@ class ScoreGuidedClauseSelector( MethodDescriptor(emptyList(), ctx.cm.type.voidType) ) ).reverse(pathClause) - - private val Term.isPrimitiveValue: Boolean get() = this.name.contains("%primitive%") - private val Term.isReturnValue: Boolean get() = this.name.contains("retval") - - private fun isPrimitive(term: Term): Boolean { - when (term) { - is CmpTerm -> { - if (term.rhv !is NullTerm) { - return getOrUpdate(term.lhv) || getOrUpdate(term.rhv) - } - return false - } - - is InstanceOfTerm -> return false - - is ValueTerm -> { - if (term.isPrimitiveValue) - return true - if (term.isReturnValue) { - if (isCallPrimitiveDependent.isEmpty()) return getOrUpdate(term, false) - return getOrUpdate(term, isCallPrimitiveDependent.last()) - } - return isPrimitiveDependent[term] ?: false - } - - else -> return term.subTerms.fold(false) { acc, cur -> acc || getOrUpdate(cur) } - - } - } - - private fun getOrUpdate(term: Term, value: Boolean? = null): Boolean { - if (isPrimitiveDependent[term] == null) { - isPrimitiveDependent[term] = value ?: isPrimitive(term) - } - return isPrimitiveDependent[term]!! - } - } From 8f17fbf5856522b5e55e90c27fe12bc44d4a36f6 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Fri, 20 Sep 2024 16:23:25 +0200 Subject: [PATCH 26/34] changed ArrayLengthTerm analysis approach --- .../main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt b/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt index b0e517cfa6..6ddb6a02a3 100644 --- a/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt +++ b/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt @@ -46,7 +46,7 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformArrayLengthTerm(term: ArrayLengthTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.arrayRef] + isPrimitiveDependent[term] = false return term } From 195373eb20a9aebd7054196a3ffaf3ac499cf15c Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Sat, 21 Sep 2024 00:16:34 +0200 Subject: [PATCH 27/34] changed approach to the PathClauses --- .../kex/PrimitiveDependencyAnalysis.kt | 238 ++++++++++++------ .../evosuite/kex/ScoreGuidedClauseSelector.kt | 13 +- 2 files changed, 166 insertions(+), 85 deletions(-) diff --git a/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt b/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt index 6ddb6a02a3..e9ace91b09 100644 --- a/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt +++ b/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt @@ -3,19 +3,20 @@ package org.evosuite.kex import org.vorpal.research.kex.state.predicate.* import org.vorpal.research.kex.state.term.* import org.vorpal.research.kex.state.transformer.Transformer -import org.vorpal.research.kthelper.assert.unreachable import java.util.* class PrimitiveDependencyAnalysis : Transformer { - private val isPrimitiveDependent = WeakHashMap() + private val isPrimitiveDependentTerm = WeakHashMap() + private val isPrimitiveDependentPathPredicate = mutableListOf() init { - isPrimitiveDependent[ConstBoolTerm(true)] = false - isPrimitiveDependent[ConstBoolTerm(false)] = false + isPrimitiveDependentTerm[ConstBoolTerm(true)] = false + isPrimitiveDependentTerm[ConstBoolTerm(false)] = false } - fun isPrimitiveDependent(term: Term): Boolean { - return isPrimitiveDependent[term] ?: unreachable { } + fun isPrimitiveDependentPathPredicate(index: Int): Boolean { + assert(isPrimitiveDependentPathPredicate.size >= index) + return isPrimitiveDependentPathPredicate[index] } private val Term.isPrimitiveValue: Boolean get() = this.name.contains("%primitive%") @@ -26,18 +27,20 @@ class PrimitiveDependencyAnalysis : Transformer { override fun transformArrayLoadTerm(term: ArrayLoadTerm): Term { assert(term.arrayRef is ArrayIndexTerm) - isPrimitiveDependent[term] = - isPrimitiveDependent[term.arrayRef]!! || isPrimitiveDependent[(term.arrayRef as ArrayIndexTerm).arrayRef]!! + isPrimitiveDependentTerm[term] = + isPrimitiveDependentTerm[term.arrayRef]!! || isPrimitiveDependentTerm[(term.arrayRef as ArrayIndexTerm).arrayRef]!! return term } override fun transformArrayContainsTerm(term: ArrayContainsTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.value]!! || isPrimitiveDependent[term.array]!! + isPrimitiveDependentTerm[term] = + isPrimitiveDependentTerm[term.value]!! || isPrimitiveDependentTerm[term.array]!! return term } override fun transformArrayIndexTerm(term: ArrayIndexTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.index]!! || isPrimitiveDependent[term.arrayRef]!! + isPrimitiveDependentTerm[term] = + isPrimitiveDependentTerm[term.index]!! || isPrimitiveDependentTerm[term.arrayRef]!! return term } @@ -46,124 +49,127 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformArrayLengthTerm(term: ArrayLengthTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformCharAtTerm(term: CharAtTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.index]!! || isPrimitiveDependent[term.string]!! + isPrimitiveDependentTerm[term] = + isPrimitiveDependentTerm[term.index]!! || isPrimitiveDependentTerm[term.string]!! return term } override fun transformBinaryTerm(term: BinaryTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.lhv]!! || isPrimitiveDependent[term.rhv]!! + isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.lhv]!! || isPrimitiveDependentTerm[term.rhv]!! return term } override fun transformBoundTerm(term: BoundTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformCallTerm(term: CallTerm): Term { - isPrimitiveDependent[term] = term.arguments.fold(false) { acc, cur -> - isPrimitiveDependent[cur]!! || acc - } || isPrimitiveDependent[term.owner]!! + isPrimitiveDependentTerm[term] = term.arguments.fold(false) { acc, cur -> + isPrimitiveDependentTerm[cur]!! || acc + } || isPrimitiveDependentTerm[term.owner]!! return term } override fun transformCastTerm(term: CastTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.operand] + isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.operand] return term } override fun transformClassAccessTerm(term: ClassAccessTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.operand] + isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.operand] return term } override fun transformCmpTerm(term: CmpTerm): Term { if (term.rhv !is NullTerm) { - isPrimitiveDependent[term] = isPrimitiveDependent[term.lhv]!! || isPrimitiveDependent[term.rhv]!! + isPrimitiveDependentTerm[term] = + isPrimitiveDependentTerm[term.lhv]!! || isPrimitiveDependentTerm[term.rhv]!! } else { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false } return term } override fun transformConcatTerm(term: ConcatTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.lhv]!! || isPrimitiveDependent[term.rhv]!! + isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.lhv]!! || isPrimitiveDependentTerm[term.rhv]!! return term } override fun transformConstBoolTerm(term: ConstBoolTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformConstByteTerm(term: ConstByteTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformConstCharTerm(term: ConstCharTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformConstDoubleTerm(term: ConstDoubleTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformConstIntTerm(term: ConstIntTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformConstLongTerm(term: ConstLongTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformConstFloatTerm(term: ConstFloatTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformConstClassTerm(term: ConstClassTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformConstStringTerm(term: ConstStringTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformConstShortTerm(term: ConstShortTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformEndsWithTerm(term: EndsWithTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.string]!! || isPrimitiveDependent[term.suffix]!! + isPrimitiveDependentTerm[term] = + isPrimitiveDependentTerm[term.string]!! || isPrimitiveDependentTerm[term.suffix]!! return term } override fun transformEqualsTerm(term: EqualsTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.lhv]!! || isPrimitiveDependent[term.rhv]!! + isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.lhv]!! || isPrimitiveDependentTerm[term.rhv]!! return term } override fun transformExistsTerm(term: ExistsTerm): Term { - isPrimitiveDependent[term] = - isPrimitiveDependent[term.start]!! || isPrimitiveDependent[term.end]!! || isPrimitiveDependent[term.body]!! + isPrimitiveDependentTerm[term] = + isPrimitiveDependentTerm[term.start]!! || isPrimitiveDependentTerm[term.end]!! || isPrimitiveDependentTerm[term.body]!! return term } override fun transformFieldLoadTerm(term: FieldLoadTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.field] + isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.field] return term } @@ -172,94 +178,96 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformForAllTerm(term: ForAllTerm): Term { - isPrimitiveDependent[term] = - isPrimitiveDependent[term.start]!! || isPrimitiveDependent[term.end]!! || isPrimitiveDependent[term.body]!! + isPrimitiveDependentTerm[term] = + isPrimitiveDependentTerm[term.start]!! || isPrimitiveDependentTerm[term.end]!! || isPrimitiveDependentTerm[term.body]!! return term } override fun transformIndexOfTerm(term: IndexOfTerm): Term { - isPrimitiveDependent[term] = - isPrimitiveDependent[term.string]!! || isPrimitiveDependent[term.substring]!! || isPrimitiveDependent[term.offset]!! + isPrimitiveDependentTerm[term] = + isPrimitiveDependentTerm[term.string]!! || isPrimitiveDependentTerm[term.substring]!! || isPrimitiveDependentTerm[term.offset]!! return term } override fun transformInstanceOfTerm(term: InstanceOfTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformIteTerm(term: IteTerm): Term { - isPrimitiveDependent[term] = - isPrimitiveDependent[term.cond]!! || isPrimitiveDependent[term.trueValue]!! || isPrimitiveDependent[term.falseValue]!! + isPrimitiveDependentTerm[term] = + isPrimitiveDependentTerm[term.cond]!! || isPrimitiveDependentTerm[term.trueValue]!! || isPrimitiveDependentTerm[term.falseValue]!! return term } override fun transformLambdaTerm(term: LambdaTerm): Term { - isPrimitiveDependent[term] = term.parameters.fold(false) { acc, cur -> - isPrimitiveDependent[cur]!! || acc + isPrimitiveDependentTerm[term] = term.parameters.fold(false) { acc, cur -> + isPrimitiveDependentTerm[cur]!! || acc } return term } override fun transformNegTerm(term: NegTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.operand] + isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.operand] return term } override fun transformNullTerm(term: NullTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformReturnValueTerm(term: ReturnValueTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformStartsWithTerm(term: StartsWithTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.string]!! || isPrimitiveDependent[term.prefix]!! + isPrimitiveDependentTerm[term] = + isPrimitiveDependentTerm[term.string]!! || isPrimitiveDependentTerm[term.prefix]!! return term } override fun transformStaticClassRefTerm(term: StaticClassRefTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformStringContainsTerm(term: StringContainsTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.string]!! || isPrimitiveDependent[term.substring]!! + isPrimitiveDependentTerm[term] = + isPrimitiveDependentTerm[term.string]!! || isPrimitiveDependentTerm[term.substring]!! return term } override fun transformStringLengthTerm(term: StringLengthTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.string] + isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.string] return term } override fun transformStringParseTerm(term: StringParseTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.string] + isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.string] return term } override fun transformSubstringTerm(term: SubstringTerm): Term { - isPrimitiveDependent[term] = - isPrimitiveDependent[term.string]!! || isPrimitiveDependent[term.offset]!! || isPrimitiveDependent[term.length]!! + isPrimitiveDependentTerm[term] = + isPrimitiveDependentTerm[term.string]!! || isPrimitiveDependentTerm[term.offset]!! || isPrimitiveDependentTerm[term.length]!! return term } override fun transformToStringTerm(term: ToStringTerm): Term { - isPrimitiveDependent[term] = isPrimitiveDependent[term.value] + isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.value] return term } override fun transformUndefTerm(term: UndefTerm): Term { - isPrimitiveDependent[term] = false + isPrimitiveDependentTerm[term] = false return term } override fun transformValueTerm(term: ValueTerm): Term { - if (term.isPrimitiveValue) isPrimitiveDependent[term] = true - if (isPrimitiveDependent[term] == null) isPrimitiveDependent[term] = false + if (term.isPrimitiveValue) isPrimitiveDependentTerm[term] = true + if (isPrimitiveDependentTerm[term] == null) isPrimitiveDependentTerm[term] = false return term } @@ -268,94 +276,168 @@ class PrimitiveDependencyAnalysis : Transformer { //////////////////////////////////////////////////////////////////// override fun transformArrayInitializerPredicate(predicate: ArrayInitializerPredicate): Predicate { - assert(predicate.arrayRef is ArrayIndexTerm) - isPrimitiveDependent[(predicate.arrayRef as ArrayIndexTerm).arrayRef] = isPrimitiveDependent[predicate.value]!! - isPrimitiveDependent[predicate.arrayRef] = isPrimitiveDependent[predicate.value]!! + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.arrayRef]!! || isPrimitiveDependentTerm[predicate.value]!! + } else { + assert(predicate.arrayRef is ArrayIndexTerm) + isPrimitiveDependentTerm[(predicate.arrayRef as ArrayIndexTerm).arrayRef] = + isPrimitiveDependentTerm[predicate.value]!! + isPrimitiveDependentTerm[predicate.arrayRef] = isPrimitiveDependentTerm[predicate.value]!! + } return predicate } override fun transformArrayStorePredicate(predicate: ArrayStorePredicate): Predicate { - assert(predicate.arrayRef is ArrayIndexTerm) - isPrimitiveDependent[(predicate.arrayRef as ArrayIndexTerm).arrayRef] = isPrimitiveDependent[predicate.value]!! - isPrimitiveDependent[predicate.arrayRef] = isPrimitiveDependent[predicate.value]!! + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.arrayRef]!! || isPrimitiveDependentTerm[predicate.value]!! + } else { + assert(predicate.arrayRef is ArrayIndexTerm) + isPrimitiveDependentTerm[(predicate.arrayRef as ArrayIndexTerm).arrayRef] = + isPrimitiveDependentTerm[predicate.value]!! + isPrimitiveDependentTerm[predicate.arrayRef] = isPrimitiveDependentTerm[predicate.value]!! + } return predicate } override fun transformBoundStorePredicate(predicate: BoundStorePredicate): Predicate { + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += false + } return predicate } override fun transformCallPredicate(predicate: CallPredicate): Predicate { - if (predicate.hasLhv) isPrimitiveDependent[predicate.lhv] = isPrimitiveDependent[predicate.callTerm] + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.lhv]!! || isPrimitiveDependentTerm[predicate.callTerm]!! + } else { + if (predicate.hasLhv) + isPrimitiveDependentTerm[predicate.lhv] = isPrimitiveDependentTerm[predicate.callTerm] + } return predicate } override fun transformCatchPredicate(predicate: CatchPredicate): Predicate { + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += false + } return predicate } override fun transformDefaultSwitchPredicate(predicate: DefaultSwitchPredicate): Predicate { + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += false + } return predicate } override fun transformEnterMonitorPredicate(predicate: EnterMonitorPredicate): Predicate { + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += false + } return predicate } override fun transformEqualityPredicate(predicate: EqualityPredicate): Predicate { - if (predicate.lhv !is ConstBoolTerm) { - isPrimitiveDependent[predicate.lhv] = isPrimitiveDependent[predicate.rhv] + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.lhv]!! || isPrimitiveDependentTerm[predicate.rhv]!! + } else { + if (predicate.lhv !is ConstBoolTerm) { + isPrimitiveDependentTerm[predicate.lhv] = isPrimitiveDependentTerm[predicate.rhv] + } } return predicate } override fun transformExitMonitorPredicate(predicate: ExitMonitorPredicate): Predicate { + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += false + } return predicate } override fun transformFieldInitializerPredicate(predicate: FieldInitializerPredicate): Predicate { - isPrimitiveDependent[predicate.field] = isPrimitiveDependent[predicate.value] + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.field]!! || isPrimitiveDependentTerm[predicate.field]!! || isPrimitiveDependentTerm[predicate.value]!! + } else { + isPrimitiveDependentTerm[predicate.field] = isPrimitiveDependentTerm[predicate.value] + } return predicate } override fun transformFieldStorePredicate(predicate: FieldStorePredicate): Predicate { - isPrimitiveDependent[predicate.field] = isPrimitiveDependent[predicate.value] + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.field]!! || isPrimitiveDependentTerm[predicate.value]!! + } else { + isPrimitiveDependentTerm[predicate.field] = isPrimitiveDependentTerm[predicate.value] + } return predicate } override fun transformGenerateArrayPredicate(predicate: GenerateArrayPredicate): Predicate { - isPrimitiveDependent[predicate.lhv] = - isPrimitiveDependent[predicate.length]!! || isPrimitiveDependent[predicate.generator]!! + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.lhv]!! || isPrimitiveDependentTerm[predicate.length]!! || isPrimitiveDependentTerm[predicate.generator]!! + } else { + isPrimitiveDependentTerm[predicate.lhv] = + isPrimitiveDependentTerm[predicate.length]!! || isPrimitiveDependentTerm[predicate.generator]!! + } return predicate } override fun transformInequalityPredicate(predicate: InequalityPredicate): Predicate { + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += false + } return predicate } override fun transformNewArrayInitializerPredicate(predicate: NewArrayInitializerPredicate): Predicate { - isPrimitiveDependent[predicate.lhv] = predicate.elements.fold(false) { acc, cur -> - isPrimitiveDependent[cur]!! || acc - } || isPrimitiveDependent[predicate.length]!! + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.lhv]!! || predicate.elements.fold( + false + ) { acc, cur -> + isPrimitiveDependentTerm[cur]!! || acc + } || isPrimitiveDependentTerm[predicate.length]!! + } else { + isPrimitiveDependentTerm[predicate.lhv] = predicate.elements.fold(false) { acc, cur -> + isPrimitiveDependentTerm[cur]!! || acc + } || isPrimitiveDependentTerm[predicate.length]!! + } return predicate } override fun transformNewArrayPredicate(predicate: NewArrayPredicate): Predicate { - isPrimitiveDependent[predicate.lhv] = predicate.dimensions.fold(false) { acc, cur -> - isPrimitiveDependent[cur]!! || acc + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.lhv]!! || predicate.dimensions.fold( + false + ) { acc, cur -> + isPrimitiveDependentTerm[cur]!! || acc + } + } else { + isPrimitiveDependentTerm[predicate.lhv] = predicate.dimensions.fold(false) { acc, cur -> + isPrimitiveDependentTerm[cur]!! || acc + } } return predicate } override fun transformNewInitializerPredicate(predicate: NewInitializerPredicate): Predicate { + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += false + } return predicate } override fun transformNewPredicate(predicate: NewPredicate): Predicate { + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += false + } return predicate } override fun transformThrowPredicate(predicate: ThrowPredicate): Predicate { + if (predicate.type == PredicateType.Path()) { + isPrimitiveDependentPathPredicate += false + } return predicate } } \ No newline at end of file diff --git a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt index defcb968b4..56b5e71b68 100644 --- a/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt +++ b/client/src/main/kotlin/org/evosuite/kex/ScoreGuidedClauseSelector.kt @@ -50,9 +50,8 @@ class ScoreGuidedClauseSelector( val newPath = state.path.path val analysis = PrimitiveDependencyAnalysis() - val clausesWithoutPath = newClauses.filterNot { it is PathClause } - analysis.apply(clausesWithoutPath.toClauseState().asState()) + analysis.apply(newClauses.toClauseState().asState()) clauses.clear() path.clear() @@ -94,7 +93,7 @@ class ScoreGuidedClauseSelector( if (clause is PathClause) { stackTraces += currentStackTrace.toList() assert(clause == path[pathIndex]) - if (isPathClauseReversible(clause, analysis)) { + if (isPathClauseReversible(pathIndex, analysis)) { candidates.add(i to pathIndex) } pathIndex++ @@ -111,10 +110,10 @@ class ScoreGuidedClauseSelector( } } - private fun isPathClauseReversible(clause: PathClause, analysis: PrimitiveDependencyAnalysis): Boolean { - return clause.type == PathClauseType.CONDITION_CHECK && clause.predicate.operands.fold(false) { acc, cur -> - acc || analysis.isPrimitiveDependent(cur) - } + private fun isPathClauseReversible(pathIndex: Int, analysis: PrimitiveDependencyAnalysis): Boolean { + return path[pathIndex].type == PathClauseType.CONDITION_CHECK && analysis.isPrimitiveDependentPathPredicate( + pathIndex + ) } // TODO: rewrite? From 00356a65fb1277ddc179924d68c51073d3a56754 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Sat, 21 Sep 2024 14:31:16 +0200 Subject: [PATCH 28/34] added stesgaard --- .../kex/PrimitiveDependencyAnalysis.kt | 278 +++++++++++------- 1 file changed, 178 insertions(+), 100 deletions(-) diff --git a/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt b/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt index e9ace91b09..f399b6610a 100644 --- a/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt +++ b/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt @@ -2,17 +2,15 @@ package org.evosuite.kex import org.vorpal.research.kex.state.predicate.* import org.vorpal.research.kex.state.term.* +import org.vorpal.research.kex.state.transformer.StensgaardAA +import org.vorpal.research.kex.state.transformer.Token import org.vorpal.research.kex.state.transformer.Transformer import java.util.* class PrimitiveDependencyAnalysis : Transformer { - private val isPrimitiveDependentTerm = WeakHashMap() + private val isPrimitiveDependentTerm = WeakHashMap() private val isPrimitiveDependentPathPredicate = mutableListOf() - - init { - isPrimitiveDependentTerm[ConstBoolTerm(true)] = false - isPrimitiveDependentTerm[ConstBoolTerm(false)] = false - } + private val stensgaardAA = StensgaardAA() fun isPrimitiveDependentPathPredicate(index: Int): Boolean { assert(isPrimitiveDependentPathPredicate.size >= index) @@ -20,27 +18,48 @@ class PrimitiveDependencyAnalysis : Transformer { } private val Term.isPrimitiveValue: Boolean get() = this.name.contains("%primitive%") + private val Term.getToken: Token? get() = stensgaardAA.get(this) + private val Term.isPrimitiveDependent: Boolean + get() { + if (isPrimitiveDependentTerm[this.getToken] == null) { + assert( + this is ConstBoolTerm || + this is ConstIntTerm || + this is ConstFloatTerm || + this is ConstLongTerm || + this is ConstCharTerm || + this is ConstClassTerm || + this is ConstStringTerm || + this is ConstShortTerm || + this is ConstByteTerm || + this is ConstDoubleTerm + ) + return false + } + return isPrimitiveDependentTerm[this.getToken]!! + } //////////////////////////////////////////////////////////////////// // Term //////////////////////////////////////////////////////////////////// override fun transformArrayLoadTerm(term: ArrayLoadTerm): Term { + stensgaardAA.transformArrayLoadTerm(term) assert(term.arrayRef is ArrayIndexTerm) - isPrimitiveDependentTerm[term] = - isPrimitiveDependentTerm[term.arrayRef]!! || isPrimitiveDependentTerm[(term.arrayRef as ArrayIndexTerm).arrayRef]!! + isPrimitiveDependentTerm[term.getToken] = + term.arrayRef.isPrimitiveDependent || (term.arrayRef as ArrayIndexTerm).arrayRef.isPrimitiveDependent return term } override fun transformArrayContainsTerm(term: ArrayContainsTerm): Term { - isPrimitiveDependentTerm[term] = - isPrimitiveDependentTerm[term.value]!! || isPrimitiveDependentTerm[term.array]!! + stensgaardAA.transformArrayContainsTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.value.isPrimitiveDependent || term.array.isPrimitiveDependent return term } override fun transformArrayIndexTerm(term: ArrayIndexTerm): Term { - isPrimitiveDependentTerm[term] = - isPrimitiveDependentTerm[term.index]!! || isPrimitiveDependentTerm[term.arrayRef]!! + stensgaardAA.transformArrayIndexTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.index.isPrimitiveDependent || term.arrayRef.isPrimitiveDependent return term } @@ -49,225 +68,261 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformArrayLengthTerm(term: ArrayLengthTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformArrayLengthTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformCharAtTerm(term: CharAtTerm): Term { - isPrimitiveDependentTerm[term] = - isPrimitiveDependentTerm[term.index]!! || isPrimitiveDependentTerm[term.string]!! + stensgaardAA.transformCharAtTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.index.isPrimitiveDependent || term.string.isPrimitiveDependent return term } override fun transformBinaryTerm(term: BinaryTerm): Term { - isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.lhv]!! || isPrimitiveDependentTerm[term.rhv]!! + stensgaardAA.transformBinaryTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent return term } override fun transformBoundTerm(term: BoundTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformBoundTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformCallTerm(term: CallTerm): Term { - isPrimitiveDependentTerm[term] = term.arguments.fold(false) { acc, cur -> - isPrimitiveDependentTerm[cur]!! || acc - } || isPrimitiveDependentTerm[term.owner]!! + stensgaardAA.transformCallTerm(term) + isPrimitiveDependentTerm[term.getToken] = + term.arguments.fold(false) { acc, cur -> cur.isPrimitiveDependent || acc } || term.owner.isPrimitiveDependent return term } override fun transformCastTerm(term: CastTerm): Term { - isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.operand] + stensgaardAA.transformCastTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.operand.isPrimitiveDependent return term } override fun transformClassAccessTerm(term: ClassAccessTerm): Term { - isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.operand] + stensgaardAA.transformClassAccessTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.operand.isPrimitiveDependent return term } override fun transformCmpTerm(term: CmpTerm): Term { + stensgaardAA.transformCmpTerm(term) if (term.rhv !is NullTerm) { - isPrimitiveDependentTerm[term] = - isPrimitiveDependentTerm[term.lhv]!! || isPrimitiveDependentTerm[term.rhv]!! + isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent } else { - isPrimitiveDependentTerm[term] = false + isPrimitiveDependentTerm[term.getToken] = false } return term } override fun transformConcatTerm(term: ConcatTerm): Term { - isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.lhv]!! || isPrimitiveDependentTerm[term.rhv]!! + stensgaardAA.transformConcatTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent return term } override fun transformConstBoolTerm(term: ConstBoolTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformConstBoolTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstByteTerm(term: ConstByteTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformConstByteTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstCharTerm(term: ConstCharTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformConstCharTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstDoubleTerm(term: ConstDoubleTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformConstDoubleTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstIntTerm(term: ConstIntTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformConstIntTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstLongTerm(term: ConstLongTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformConstLongTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstFloatTerm(term: ConstFloatTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformConstFloatTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstClassTerm(term: ConstClassTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformConstClassTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstStringTerm(term: ConstStringTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformConstStringTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstShortTerm(term: ConstShortTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformConstShortTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformEndsWithTerm(term: EndsWithTerm): Term { - isPrimitiveDependentTerm[term] = - isPrimitiveDependentTerm[term.string]!! || isPrimitiveDependentTerm[term.suffix]!! + stensgaardAA.transformEndsWithTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.suffix.isPrimitiveDependent return term } override fun transformEqualsTerm(term: EqualsTerm): Term { - isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.lhv]!! || isPrimitiveDependentTerm[term.rhv]!! + stensgaardAA.transformEqualsTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent return term } override fun transformExistsTerm(term: ExistsTerm): Term { - isPrimitiveDependentTerm[term] = - isPrimitiveDependentTerm[term.start]!! || isPrimitiveDependentTerm[term.end]!! || isPrimitiveDependentTerm[term.body]!! + stensgaardAA.transformExistsTerm(term) + isPrimitiveDependentTerm[term.getToken] = + term.start.isPrimitiveDependent || term.end.isPrimitiveDependent || term.body.isPrimitiveDependent return term } override fun transformFieldLoadTerm(term: FieldLoadTerm): Term { - isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.field] + stensgaardAA.transformFieldLoadTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.field.isPrimitiveDependent return term } override fun transformFieldTerm(term: FieldTerm): Term { + stensgaardAA.transformFieldTerm(term) return term } override fun transformForAllTerm(term: ForAllTerm): Term { - isPrimitiveDependentTerm[term] = - isPrimitiveDependentTerm[term.start]!! || isPrimitiveDependentTerm[term.end]!! || isPrimitiveDependentTerm[term.body]!! + stensgaardAA.transformForAllTerm(term) + isPrimitiveDependentTerm[term.getToken] = + term.start.isPrimitiveDependent || term.end.isPrimitiveDependent || term.body.isPrimitiveDependent return term } override fun transformIndexOfTerm(term: IndexOfTerm): Term { - isPrimitiveDependentTerm[term] = - isPrimitiveDependentTerm[term.string]!! || isPrimitiveDependentTerm[term.substring]!! || isPrimitiveDependentTerm[term.offset]!! + stensgaardAA.transformIndexOfTerm(term) + isPrimitiveDependentTerm[term.getToken] = + term.string.isPrimitiveDependent || term.substring.isPrimitiveDependent || term.offset.isPrimitiveDependent return term } override fun transformInstanceOfTerm(term: InstanceOfTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformInstanceOfTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformIteTerm(term: IteTerm): Term { - isPrimitiveDependentTerm[term] = - isPrimitiveDependentTerm[term.cond]!! || isPrimitiveDependentTerm[term.trueValue]!! || isPrimitiveDependentTerm[term.falseValue]!! + stensgaardAA.transformIteTerm(term) + isPrimitiveDependentTerm[term.getToken] = + term.cond.isPrimitiveDependent || term.trueValue.isPrimitiveDependent || term.falseValue.isPrimitiveDependent return term } override fun transformLambdaTerm(term: LambdaTerm): Term { - isPrimitiveDependentTerm[term] = term.parameters.fold(false) { acc, cur -> - isPrimitiveDependentTerm[cur]!! || acc + stensgaardAA.transformLambdaTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.parameters.fold(false) { acc, cur -> + cur.isPrimitiveDependent || acc } return term } override fun transformNegTerm(term: NegTerm): Term { - isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.operand] + stensgaardAA.transformNegTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.operand.isPrimitiveDependent return term } override fun transformNullTerm(term: NullTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformNullTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformReturnValueTerm(term: ReturnValueTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformReturnValueTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformStartsWithTerm(term: StartsWithTerm): Term { - isPrimitiveDependentTerm[term] = - isPrimitiveDependentTerm[term.string]!! || isPrimitiveDependentTerm[term.prefix]!! + stensgaardAA.transformStartsWithTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.prefix.isPrimitiveDependent return term } override fun transformStaticClassRefTerm(term: StaticClassRefTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformStaticClassRefTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformStringContainsTerm(term: StringContainsTerm): Term { - isPrimitiveDependentTerm[term] = - isPrimitiveDependentTerm[term.string]!! || isPrimitiveDependentTerm[term.substring]!! + stensgaardAA.transformStringContainsTerm(term) + isPrimitiveDependentTerm[term.getToken] = + term.string.isPrimitiveDependent || term.substring.isPrimitiveDependent return term } override fun transformStringLengthTerm(term: StringLengthTerm): Term { - isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.string] + stensgaardAA.transformStringLengthTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent return term } override fun transformStringParseTerm(term: StringParseTerm): Term { - isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.string] + stensgaardAA.transformStringParseTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent return term } override fun transformSubstringTerm(term: SubstringTerm): Term { - isPrimitiveDependentTerm[term] = - isPrimitiveDependentTerm[term.string]!! || isPrimitiveDependentTerm[term.offset]!! || isPrimitiveDependentTerm[term.length]!! + stensgaardAA.transformSubstringTerm(term) + isPrimitiveDependentTerm[term.getToken] = + term.string.isPrimitiveDependent || term.offset.isPrimitiveDependent || term.length.isPrimitiveDependent return term } override fun transformToStringTerm(term: ToStringTerm): Term { - isPrimitiveDependentTerm[term] = isPrimitiveDependentTerm[term.value] + stensgaardAA.transformToStringTerm(term) + isPrimitiveDependentTerm[term.getToken] = term.value.isPrimitiveDependent return term } override fun transformUndefTerm(term: UndefTerm): Term { - isPrimitiveDependentTerm[term] = false + stensgaardAA.transformUndefTerm(term) + isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformValueTerm(term: ValueTerm): Term { - if (term.isPrimitiveValue) isPrimitiveDependentTerm[term] = true - if (isPrimitiveDependentTerm[term] == null) isPrimitiveDependentTerm[term] = false + stensgaardAA.transformValueTerm(term) + if (term.isPrimitiveValue) isPrimitiveDependentTerm[term.getToken] = true + if (isPrimitiveDependentTerm[term.getToken] == null) isPrimitiveDependentTerm[term.getToken] = false return term } @@ -277,24 +332,26 @@ class PrimitiveDependencyAnalysis : Transformer { override fun transformArrayInitializerPredicate(predicate: ArrayInitializerPredicate): Predicate { if (predicate.type == PredicateType.Path()) { - isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.arrayRef]!! || isPrimitiveDependentTerm[predicate.value]!! + isPrimitiveDependentPathPredicate += predicate.arrayRef.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { + stensgaardAA.transformArrayInitializerPredicate(predicate) assert(predicate.arrayRef is ArrayIndexTerm) - isPrimitiveDependentTerm[(predicate.arrayRef as ArrayIndexTerm).arrayRef] = - isPrimitiveDependentTerm[predicate.value]!! - isPrimitiveDependentTerm[predicate.arrayRef] = isPrimitiveDependentTerm[predicate.value]!! + isPrimitiveDependentTerm[(predicate.arrayRef as ArrayIndexTerm).arrayRef.getToken] = + predicate.value.isPrimitiveDependent + isPrimitiveDependentTerm[predicate.arrayRef.getToken] = predicate.value.isPrimitiveDependent } return predicate } override fun transformArrayStorePredicate(predicate: ArrayStorePredicate): Predicate { if (predicate.type == PredicateType.Path()) { - isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.arrayRef]!! || isPrimitiveDependentTerm[predicate.value]!! + isPrimitiveDependentPathPredicate += predicate.arrayRef.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { + stensgaardAA.transformArrayStorePredicate(predicate) assert(predicate.arrayRef is ArrayIndexTerm) - isPrimitiveDependentTerm[(predicate.arrayRef as ArrayIndexTerm).arrayRef] = - isPrimitiveDependentTerm[predicate.value]!! - isPrimitiveDependentTerm[predicate.arrayRef] = isPrimitiveDependentTerm[predicate.value]!! + isPrimitiveDependentTerm[(predicate.arrayRef as ArrayIndexTerm).arrayRef.getToken] = + predicate.value.isPrimitiveDependent + isPrimitiveDependentTerm[predicate.arrayRef.getToken] = predicate.value.isPrimitiveDependent } return predicate } @@ -302,16 +359,19 @@ class PrimitiveDependencyAnalysis : Transformer { override fun transformBoundStorePredicate(predicate: BoundStorePredicate): Predicate { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false + } else { + stensgaardAA.transformBoundStorePredicate(predicate) } return predicate } override fun transformCallPredicate(predicate: CallPredicate): Predicate { if (predicate.type == PredicateType.Path()) { - isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.lhv]!! || isPrimitiveDependentTerm[predicate.callTerm]!! + isPrimitiveDependentPathPredicate += (predicate.hasLhv && predicate.lhv.isPrimitiveDependent) || predicate.callTerm.isPrimitiveDependent } else { + stensgaardAA.transformCallPredicate(predicate) if (predicate.hasLhv) - isPrimitiveDependentTerm[predicate.lhv] = isPrimitiveDependentTerm[predicate.callTerm] + isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.callTerm.isPrimitiveDependent } return predicate } @@ -319,6 +379,8 @@ class PrimitiveDependencyAnalysis : Transformer { override fun transformCatchPredicate(predicate: CatchPredicate): Predicate { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false + } else { + stensgaardAA.transformCatchPredicate(predicate) } return predicate } @@ -326,6 +388,8 @@ class PrimitiveDependencyAnalysis : Transformer { override fun transformDefaultSwitchPredicate(predicate: DefaultSwitchPredicate): Predicate { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false + } else { + stensgaardAA.transformDefaultSwitchPredicate(predicate) } return predicate } @@ -333,16 +397,19 @@ class PrimitiveDependencyAnalysis : Transformer { override fun transformEnterMonitorPredicate(predicate: EnterMonitorPredicate): Predicate { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false + } else { + stensgaardAA.transformEnterMonitorPredicate(predicate) } return predicate } override fun transformEqualityPredicate(predicate: EqualityPredicate): Predicate { if (predicate.type == PredicateType.Path()) { - isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.lhv]!! || isPrimitiveDependentTerm[predicate.rhv]!! + isPrimitiveDependentPathPredicate += predicate.lhv.isPrimitiveDependent || predicate.rhv.isPrimitiveDependent } else { + stensgaardAA.transformEqualityPredicate(predicate) if (predicate.lhv !is ConstBoolTerm) { - isPrimitiveDependentTerm[predicate.lhv] = isPrimitiveDependentTerm[predicate.rhv] + isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.rhv.isPrimitiveDependent } } return predicate @@ -351,34 +418,39 @@ class PrimitiveDependencyAnalysis : Transformer { override fun transformExitMonitorPredicate(predicate: ExitMonitorPredicate): Predicate { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false + } else { + stensgaardAA.transformExitMonitorPredicate(predicate) } return predicate } override fun transformFieldInitializerPredicate(predicate: FieldInitializerPredicate): Predicate { if (predicate.type == PredicateType.Path()) { - isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.field]!! || isPrimitiveDependentTerm[predicate.field]!! || isPrimitiveDependentTerm[predicate.value]!! + isPrimitiveDependentPathPredicate += predicate.field.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { - isPrimitiveDependentTerm[predicate.field] = isPrimitiveDependentTerm[predicate.value] + stensgaardAA.transformFieldInitializerPredicate(predicate) + isPrimitiveDependentTerm[predicate.field.getToken] = predicate.value.isPrimitiveDependent } return predicate } override fun transformFieldStorePredicate(predicate: FieldStorePredicate): Predicate { if (predicate.type == PredicateType.Path()) { - isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.field]!! || isPrimitiveDependentTerm[predicate.value]!! + isPrimitiveDependentPathPredicate += predicate.field.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { - isPrimitiveDependentTerm[predicate.field] = isPrimitiveDependentTerm[predicate.value] + stensgaardAA.transformFieldStorePredicate(predicate) + isPrimitiveDependentTerm[predicate.field.getToken] = predicate.value.isPrimitiveDependent } return predicate } override fun transformGenerateArrayPredicate(predicate: GenerateArrayPredicate): Predicate { if (predicate.type == PredicateType.Path()) { - isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.lhv]!! || isPrimitiveDependentTerm[predicate.length]!! || isPrimitiveDependentTerm[predicate.generator]!! + isPrimitiveDependentPathPredicate += predicate.lhv.isPrimitiveDependent || predicate.length.isPrimitiveDependent || predicate.generator.isPrimitiveDependent } else { - isPrimitiveDependentTerm[predicate.lhv] = - isPrimitiveDependentTerm[predicate.length]!! || isPrimitiveDependentTerm[predicate.generator]!! + stensgaardAA.transformGenerateArrayPredicate(predicate) + isPrimitiveDependentTerm[predicate.lhv.getToken] = + predicate.length.isPrimitiveDependent || predicate.generator.isPrimitiveDependent } return predicate } @@ -386,35 +458,35 @@ class PrimitiveDependencyAnalysis : Transformer { override fun transformInequalityPredicate(predicate: InequalityPredicate): Predicate { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false + } else { + stensgaardAA.transformInequalityPredicate(predicate) } return predicate } override fun transformNewArrayInitializerPredicate(predicate: NewArrayInitializerPredicate): Predicate { if (predicate.type == PredicateType.Path()) { - isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.lhv]!! || predicate.elements.fold( - false - ) { acc, cur -> - isPrimitiveDependentTerm[cur]!! || acc - } || isPrimitiveDependentTerm[predicate.length]!! + isPrimitiveDependentPathPredicate += predicate.lhv.isPrimitiveDependent || predicate.elements.fold(false) { acc, cur -> + cur.isPrimitiveDependent || acc + } || predicate.length.isPrimitiveDependent } else { - isPrimitiveDependentTerm[predicate.lhv] = predicate.elements.fold(false) { acc, cur -> - isPrimitiveDependentTerm[cur]!! || acc - } || isPrimitiveDependentTerm[predicate.length]!! + stensgaardAA.transformNewArrayInitializerPredicate(predicate) + isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.elements.fold(false) { acc, cur -> + cur.isPrimitiveDependent || acc + } || predicate.length.isPrimitiveDependent } return predicate } override fun transformNewArrayPredicate(predicate: NewArrayPredicate): Predicate { if (predicate.type == PredicateType.Path()) { - isPrimitiveDependentPathPredicate += isPrimitiveDependentTerm[predicate.lhv]!! || predicate.dimensions.fold( - false - ) { acc, cur -> - isPrimitiveDependentTerm[cur]!! || acc + isPrimitiveDependentPathPredicate += predicate.lhv.isPrimitiveDependent || predicate.dimensions.fold(false) { acc, cur -> + cur.isPrimitiveDependent || acc } } else { - isPrimitiveDependentTerm[predicate.lhv] = predicate.dimensions.fold(false) { acc, cur -> - isPrimitiveDependentTerm[cur]!! || acc + stensgaardAA.transformNewArrayPredicate(predicate) + isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.dimensions.fold(false) { acc, cur -> + cur.isPrimitiveDependent || acc } } return predicate @@ -423,6 +495,8 @@ class PrimitiveDependencyAnalysis : Transformer { override fun transformNewInitializerPredicate(predicate: NewInitializerPredicate): Predicate { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false + } else { + stensgaardAA.transformNewInitializerPredicate(predicate) } return predicate } @@ -430,6 +504,8 @@ class PrimitiveDependencyAnalysis : Transformer { override fun transformNewPredicate(predicate: NewPredicate): Predicate { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false + } else { + stensgaardAA.transformNewPredicate(predicate) } return predicate } @@ -437,6 +513,8 @@ class PrimitiveDependencyAnalysis : Transformer { override fun transformThrowPredicate(predicate: ThrowPredicate): Predicate { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false + } else { + stensgaardAA.transformThrowPredicate(predicate) } return predicate } From c13a248d923e0e8877e10edc170303d6ead4fbae Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Sat, 21 Sep 2024 14:32:31 +0200 Subject: [PATCH 29/34] added pointer check to stensgaard --- kex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/kex b/kex index d47df5d38f..f5cb297155 160000 --- a/kex +++ b/kex @@ -1 +1 @@ -Subproject commit d47df5d38f4d5f59e62288e54e05f913135e47df +Subproject commit f5cb2971553ec48e6746800b293fe89340d0b1e5 From 09ccab992e60c7916a62506c3cc56d130784d9f5 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Sun, 22 Sep 2024 00:08:12 +0200 Subject: [PATCH 30/34] added must(?) alias analysis --- .../org/evosuite/kex/MustAliasAnalysis.kt | 376 ++++++++++++++++++ .../kex/PrimitiveDependencyAnalysis.kt | 129 +++--- 2 files changed, 440 insertions(+), 65 deletions(-) create mode 100644 client/src/main/kotlin/org/evosuite/kex/MustAliasAnalysis.kt diff --git a/client/src/main/kotlin/org/evosuite/kex/MustAliasAnalysis.kt b/client/src/main/kotlin/org/evosuite/kex/MustAliasAnalysis.kt new file mode 100644 index 0000000000..645ec7d18c --- /dev/null +++ b/client/src/main/kotlin/org/evosuite/kex/MustAliasAnalysis.kt @@ -0,0 +1,376 @@ +package org.evosuite.kex + +import org.vorpal.research.kex.ktype.KexPointer +import org.vorpal.research.kex.state.predicate.* +import org.vorpal.research.kex.state.term.* +import org.vorpal.research.kex.state.transformer.Token +import org.vorpal.research.kex.state.transformer.Transformer +import org.vorpal.research.kthelper.collection.DisjointSet + +class MustAliasAnalysis : Transformer { + private val relations = DisjointSet() + private val root = hashMapOf() + + private fun emplace(term: Term) { + if (term !in root) root[term] = relations.emplace(term) + } + + private fun join(term1: Term, term2: Term) { + relations.join(root[term1]!!, root[term2]!!) + root[term1] = root[term1]!!.getRoot() + root[term2] = root[term2]!!.getRoot() + } + + fun get(term: Term) = root[term] + + //////////////////////////////////////////////////////////////////// + // Term + //////////////////////////////////////////////////////////////////// + + override fun transformArrayLoadTerm(term: ArrayLoadTerm): Term { + emplace(term) + if (term.type is KexPointer) { + join(term, term.arrayRef) + join(term, (term.arrayRef as ArrayIndexTerm).arrayRef) + } + join(term.arrayRef, (term.arrayRef as ArrayIndexTerm).arrayRef) + return term + } + + override fun transformArrayContainsTerm(term: ArrayContainsTerm): Term { + emplace(term) + return term + } + + override fun transformArrayIndexTerm(term: ArrayIndexTerm): Term { + emplace(term) + join(term, term.arrayRef) + return term + } + + override fun transformArgumentTerm(term: ArgumentTerm): Term { + error("Should not transform ArgumentTerm") + } + + override fun transformArrayLengthTerm(term: ArrayLengthTerm): Term { + emplace(term) + return term + } + + override fun transformCharAtTerm(term: CharAtTerm): Term { + emplace(term) + return term + } + + override fun transformBinaryTerm(term: BinaryTerm): Term { + emplace(term) + return term + } + + override fun transformBoundTerm(term: BoundTerm): Term { + emplace(term) + return term + } + + override fun transformCallTerm(term: CallTerm): Term { + emplace(term) + return term + } + + override fun transformCastTerm(term: CastTerm): Term { + emplace(term) + if(term.type is KexPointer && term.operand.type is KexPointer) { + join(term, term.operand) + } + return term + } + + override fun transformClassAccessTerm(term: ClassAccessTerm): Term { + emplace(term) + return term + } + + override fun transformCmpTerm(term: CmpTerm): Term { + emplace(term) + return term + } + + override fun transformConcatTerm(term: ConcatTerm): Term { + emplace(term) + return term + } + + override fun transformConstBoolTerm(term: ConstBoolTerm): Term { + emplace(term) + return term + } + + override fun transformConstByteTerm(term: ConstByteTerm): Term { + emplace(term) + return term + } + + override fun transformConstCharTerm(term: ConstCharTerm): Term { + emplace(term) + return term + } + + override fun transformConstDoubleTerm(term: ConstDoubleTerm): Term { + emplace(term) + return term + } + + override fun transformConstIntTerm(term: ConstIntTerm): Term { + emplace(term) + return term + } + + override fun transformConstLongTerm(term: ConstLongTerm): Term { + emplace(term) + return term + } + + override fun transformConstFloatTerm(term: ConstFloatTerm): Term { + emplace(term) + return term + } + + override fun transformConstClassTerm(term: ConstClassTerm): Term { + emplace(term) + return term + } + + override fun transformConstStringTerm(term: ConstStringTerm): Term { + emplace(term) + return term + } + + override fun transformConstShortTerm(term: ConstShortTerm): Term { + emplace(term) + return term + } + + override fun transformEndsWithTerm(term: EndsWithTerm): Term { + emplace(term) + return term + } + + override fun transformEqualsTerm(term: EqualsTerm): Term { + emplace(term) + if(term.lhv.type is KexPointer && term.rhv.type is KexPointer) { + join(term.lhv, term.rhv) + } + return term + } + + override fun transformExistsTerm(term: ExistsTerm): Term { + emplace(term) + return term + } + + override fun transformFieldLoadTerm(term: FieldLoadTerm): Term { + emplace(term) + if(term.type is KexPointer && term.field.type is KexPointer) { + join(term, term.field) + } + return term + } + + override fun transformFieldTerm(term: FieldTerm): Term { + emplace(term) + return term + } + + override fun transformForAllTerm(term: ForAllTerm): Term { + emplace(term) + return term + } + + override fun transformIndexOfTerm(term: IndexOfTerm): Term { + emplace(term) + return term + } + + override fun transformInstanceOfTerm(term: InstanceOfTerm): Term { + emplace(term) + return term + } + + override fun transformIteTerm(term: IteTerm): Term { + emplace(term) + return term + } + + override fun transformLambdaTerm(term: LambdaTerm): Term { + emplace(term) + return term + } + + override fun transformNegTerm(term: NegTerm): Term { + emplace(term) + return term + } + + override fun transformNullTerm(term: NullTerm): Term { + emplace(term) + return term + } + + override fun transformReturnValueTerm(term: ReturnValueTerm): Term { + emplace(term) + return term + } + + override fun transformStartsWithTerm(term: StartsWithTerm): Term { + emplace(term) + return term + } + + override fun transformStaticClassRefTerm(term: StaticClassRefTerm): Term { + emplace(term) + return term + } + + override fun transformStringContainsTerm(term: StringContainsTerm): Term { + emplace(term) + return term + } + + override fun transformStringLengthTerm(term: StringLengthTerm): Term { + emplace(term) + return term + } + + override fun transformStringParseTerm(term: StringParseTerm): Term { + emplace(term) + return term + } + + override fun transformSubstringTerm(term: SubstringTerm): Term { + emplace(term) + return term + } + + override fun transformToStringTerm(term: ToStringTerm): Term { + emplace(term) + return term + } + + override fun transformUndefTerm(term: UndefTerm): Term { + emplace(term) + return term + } + + override fun transformValueTerm(term: ValueTerm): Term { + emplace(term) + return term + } + + //////////////////////////////////////////////////////////////////// + // Predicate + //////////////////////////////////////////////////////////////////// + + override fun transformArrayInitializerPredicate(predicate: ArrayInitializerPredicate): Predicate { + if (predicate.type == PredicateType.State() && predicate.arrayRef.type is KexPointer && predicate.value.type is KexPointer) { + join(predicate.arrayRef, predicate.value) + } + join(predicate.arrayRef, (predicate.arrayRef as ArrayIndexTerm).arrayRef) + return predicate + } + + override fun transformArrayStorePredicate(predicate: ArrayStorePredicate): Predicate { + if (predicate.type == PredicateType.State() && predicate.arrayRef.type is KexPointer && predicate.value.type is KexPointer) { + join(predicate.arrayRef, predicate.value) + } + join(predicate.arrayRef, (predicate.arrayRef as ArrayIndexTerm).arrayRef) + return predicate + } + + override fun transformBoundStorePredicate(predicate: BoundStorePredicate): Predicate { + return predicate + } + + override fun transformCallPredicate(predicate: CallPredicate): Predicate { + if (predicate.type == PredicateType.State() && predicate.hasLhv && predicate.lhv.type is KexPointer) { + join(predicate.lhv, predicate.call) + } + return predicate + } + + override fun transformCatchPredicate(predicate: CatchPredicate): Predicate { + return predicate + } + + override fun transformDefaultSwitchPredicate(predicate: DefaultSwitchPredicate): Predicate { + return predicate + } + + override fun transformEnterMonitorPredicate(predicate: EnterMonitorPredicate): Predicate { + return predicate + } + + override fun transformEqualityPredicate(predicate: EqualityPredicate): Predicate { + if (predicate.type == PredicateType.State() && predicate.lhv.type is KexPointer && predicate.rhv.type is KexPointer) { + join(predicate.lhv, predicate.rhv) + } + return predicate + } + + override fun transformExitMonitorPredicate(predicate: ExitMonitorPredicate): Predicate { + return predicate + } + + override fun transformFieldInitializerPredicate(predicate: FieldInitializerPredicate): Predicate { + if (predicate.type == PredicateType.State() && predicate.field.type is KexPointer && predicate.value.type is KexPointer) { + join(predicate.field, predicate.value) + } + return predicate + } + + override fun transformFieldStorePredicate(predicate: FieldStorePredicate): Predicate { + if (predicate.type == PredicateType.State() && predicate.field.type is KexPointer && predicate.value.type is KexPointer) { + join(predicate.field, predicate.value) + } + return predicate + } + + override fun transformGenerateArrayPredicate(predicate: GenerateArrayPredicate): Predicate { + if (predicate.type == PredicateType.State()) { + emplace(predicate.lhv) + } + return predicate + } + + override fun transformInequalityPredicate(predicate: InequalityPredicate): Predicate { + return predicate + } + + override fun transformNewArrayInitializerPredicate(predicate: NewArrayInitializerPredicate): Predicate { + if (predicate.type == PredicateType.State()) { + emplace(predicate.lhv) + for (el in predicate.elements) { + join(predicate.lhv, el) + } + } + return predicate + } + + override fun transformNewArrayPredicate(predicate: NewArrayPredicate): Predicate { + if (predicate.type == PredicateType.State()) { + emplace(predicate.lhv) + } + return predicate + } + + override fun transformNewInitializerPredicate(predicate: NewInitializerPredicate): Predicate { + return predicate + } + + override fun transformNewPredicate(predicate: NewPredicate): Predicate { + return predicate + } + + override fun transformThrowPredicate(predicate: ThrowPredicate): Predicate { + return predicate + } +} \ No newline at end of file diff --git a/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt b/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt index f399b6610a..b1c8b3feee 100644 --- a/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt +++ b/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt @@ -2,7 +2,6 @@ package org.evosuite.kex import org.vorpal.research.kex.state.predicate.* import org.vorpal.research.kex.state.term.* -import org.vorpal.research.kex.state.transformer.StensgaardAA import org.vorpal.research.kex.state.transformer.Token import org.vorpal.research.kex.state.transformer.Transformer import java.util.* @@ -10,7 +9,7 @@ import java.util.* class PrimitiveDependencyAnalysis : Transformer { private val isPrimitiveDependentTerm = WeakHashMap() private val isPrimitiveDependentPathPredicate = mutableListOf() - private val stensgaardAA = StensgaardAA() + private val mustAliasAnalysis = MustAliasAnalysis() fun isPrimitiveDependentPathPredicate(index: Int): Boolean { assert(isPrimitiveDependentPathPredicate.size >= index) @@ -18,7 +17,7 @@ class PrimitiveDependencyAnalysis : Transformer { } private val Term.isPrimitiveValue: Boolean get() = this.name.contains("%primitive%") - private val Term.getToken: Token? get() = stensgaardAA.get(this) + private val Term.getToken: Token? get() = mustAliasAnalysis.get(this) private val Term.isPrimitiveDependent: Boolean get() { if (isPrimitiveDependentTerm[this.getToken] == null) { @@ -44,7 +43,7 @@ class PrimitiveDependencyAnalysis : Transformer { //////////////////////////////////////////////////////////////////// override fun transformArrayLoadTerm(term: ArrayLoadTerm): Term { - stensgaardAA.transformArrayLoadTerm(term) + mustAliasAnalysis.transformArrayLoadTerm(term) assert(term.arrayRef is ArrayIndexTerm) isPrimitiveDependentTerm[term.getToken] = term.arrayRef.isPrimitiveDependent || (term.arrayRef as ArrayIndexTerm).arrayRef.isPrimitiveDependent @@ -52,13 +51,13 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformArrayContainsTerm(term: ArrayContainsTerm): Term { - stensgaardAA.transformArrayContainsTerm(term) + mustAliasAnalysis.transformArrayContainsTerm(term) isPrimitiveDependentTerm[term.getToken] = term.value.isPrimitiveDependent || term.array.isPrimitiveDependent return term } override fun transformArrayIndexTerm(term: ArrayIndexTerm): Term { - stensgaardAA.transformArrayIndexTerm(term) + mustAliasAnalysis.transformArrayIndexTerm(term) isPrimitiveDependentTerm[term.getToken] = term.index.isPrimitiveDependent || term.arrayRef.isPrimitiveDependent return term } @@ -68,50 +67,50 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformArrayLengthTerm(term: ArrayLengthTerm): Term { - stensgaardAA.transformArrayLengthTerm(term) + mustAliasAnalysis.transformArrayLengthTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformCharAtTerm(term: CharAtTerm): Term { - stensgaardAA.transformCharAtTerm(term) + mustAliasAnalysis.transformCharAtTerm(term) isPrimitiveDependentTerm[term.getToken] = term.index.isPrimitiveDependent || term.string.isPrimitiveDependent return term } override fun transformBinaryTerm(term: BinaryTerm): Term { - stensgaardAA.transformBinaryTerm(term) + mustAliasAnalysis.transformBinaryTerm(term) isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent return term } override fun transformBoundTerm(term: BoundTerm): Term { - stensgaardAA.transformBoundTerm(term) + mustAliasAnalysis.transformBoundTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformCallTerm(term: CallTerm): Term { - stensgaardAA.transformCallTerm(term) + mustAliasAnalysis.transformCallTerm(term) isPrimitiveDependentTerm[term.getToken] = term.arguments.fold(false) { acc, cur -> cur.isPrimitiveDependent || acc } || term.owner.isPrimitiveDependent return term } override fun transformCastTerm(term: CastTerm): Term { - stensgaardAA.transformCastTerm(term) + mustAliasAnalysis.transformCastTerm(term) isPrimitiveDependentTerm[term.getToken] = term.operand.isPrimitiveDependent return term } override fun transformClassAccessTerm(term: ClassAccessTerm): Term { - stensgaardAA.transformClassAccessTerm(term) + mustAliasAnalysis.transformClassAccessTerm(term) isPrimitiveDependentTerm[term.getToken] = term.operand.isPrimitiveDependent return term } override fun transformCmpTerm(term: CmpTerm): Term { - stensgaardAA.transformCmpTerm(term) + mustAliasAnalysis.transformCmpTerm(term) if (term.rhv !is NullTerm) { isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent } else { @@ -121,130 +120,130 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformConcatTerm(term: ConcatTerm): Term { - stensgaardAA.transformConcatTerm(term) + mustAliasAnalysis.transformConcatTerm(term) isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent return term } override fun transformConstBoolTerm(term: ConstBoolTerm): Term { - stensgaardAA.transformConstBoolTerm(term) + mustAliasAnalysis.transformConstBoolTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstByteTerm(term: ConstByteTerm): Term { - stensgaardAA.transformConstByteTerm(term) + mustAliasAnalysis.transformConstByteTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstCharTerm(term: ConstCharTerm): Term { - stensgaardAA.transformConstCharTerm(term) + mustAliasAnalysis.transformConstCharTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstDoubleTerm(term: ConstDoubleTerm): Term { - stensgaardAA.transformConstDoubleTerm(term) + mustAliasAnalysis.transformConstDoubleTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstIntTerm(term: ConstIntTerm): Term { - stensgaardAA.transformConstIntTerm(term) + mustAliasAnalysis.transformConstIntTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstLongTerm(term: ConstLongTerm): Term { - stensgaardAA.transformConstLongTerm(term) + mustAliasAnalysis.transformConstLongTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstFloatTerm(term: ConstFloatTerm): Term { - stensgaardAA.transformConstFloatTerm(term) + mustAliasAnalysis.transformConstFloatTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstClassTerm(term: ConstClassTerm): Term { - stensgaardAA.transformConstClassTerm(term) + mustAliasAnalysis.transformConstClassTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstStringTerm(term: ConstStringTerm): Term { - stensgaardAA.transformConstStringTerm(term) + mustAliasAnalysis.transformConstStringTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstShortTerm(term: ConstShortTerm): Term { - stensgaardAA.transformConstShortTerm(term) + mustAliasAnalysis.transformConstShortTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformEndsWithTerm(term: EndsWithTerm): Term { - stensgaardAA.transformEndsWithTerm(term) + mustAliasAnalysis.transformEndsWithTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.suffix.isPrimitiveDependent return term } override fun transformEqualsTerm(term: EqualsTerm): Term { - stensgaardAA.transformEqualsTerm(term) + mustAliasAnalysis.transformEqualsTerm(term) isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent return term } override fun transformExistsTerm(term: ExistsTerm): Term { - stensgaardAA.transformExistsTerm(term) + mustAliasAnalysis.transformExistsTerm(term) isPrimitiveDependentTerm[term.getToken] = term.start.isPrimitiveDependent || term.end.isPrimitiveDependent || term.body.isPrimitiveDependent return term } override fun transformFieldLoadTerm(term: FieldLoadTerm): Term { - stensgaardAA.transformFieldLoadTerm(term) + mustAliasAnalysis.transformFieldLoadTerm(term) isPrimitiveDependentTerm[term.getToken] = term.field.isPrimitiveDependent return term } override fun transformFieldTerm(term: FieldTerm): Term { - stensgaardAA.transformFieldTerm(term) + mustAliasAnalysis.transformFieldTerm(term) return term } override fun transformForAllTerm(term: ForAllTerm): Term { - stensgaardAA.transformForAllTerm(term) + mustAliasAnalysis.transformForAllTerm(term) isPrimitiveDependentTerm[term.getToken] = term.start.isPrimitiveDependent || term.end.isPrimitiveDependent || term.body.isPrimitiveDependent return term } override fun transformIndexOfTerm(term: IndexOfTerm): Term { - stensgaardAA.transformIndexOfTerm(term) + mustAliasAnalysis.transformIndexOfTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.substring.isPrimitiveDependent || term.offset.isPrimitiveDependent return term } override fun transformInstanceOfTerm(term: InstanceOfTerm): Term { - stensgaardAA.transformInstanceOfTerm(term) + mustAliasAnalysis.transformInstanceOfTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformIteTerm(term: IteTerm): Term { - stensgaardAA.transformIteTerm(term) + mustAliasAnalysis.transformIteTerm(term) isPrimitiveDependentTerm[term.getToken] = term.cond.isPrimitiveDependent || term.trueValue.isPrimitiveDependent || term.falseValue.isPrimitiveDependent return term } override fun transformLambdaTerm(term: LambdaTerm): Term { - stensgaardAA.transformLambdaTerm(term) + mustAliasAnalysis.transformLambdaTerm(term) isPrimitiveDependentTerm[term.getToken] = term.parameters.fold(false) { acc, cur -> cur.isPrimitiveDependent || acc } @@ -252,75 +251,75 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformNegTerm(term: NegTerm): Term { - stensgaardAA.transformNegTerm(term) + mustAliasAnalysis.transformNegTerm(term) isPrimitiveDependentTerm[term.getToken] = term.operand.isPrimitiveDependent return term } override fun transformNullTerm(term: NullTerm): Term { - stensgaardAA.transformNullTerm(term) + mustAliasAnalysis.transformNullTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformReturnValueTerm(term: ReturnValueTerm): Term { - stensgaardAA.transformReturnValueTerm(term) + mustAliasAnalysis.transformReturnValueTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformStartsWithTerm(term: StartsWithTerm): Term { - stensgaardAA.transformStartsWithTerm(term) + mustAliasAnalysis.transformStartsWithTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.prefix.isPrimitiveDependent return term } override fun transformStaticClassRefTerm(term: StaticClassRefTerm): Term { - stensgaardAA.transformStaticClassRefTerm(term) + mustAliasAnalysis.transformStaticClassRefTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformStringContainsTerm(term: StringContainsTerm): Term { - stensgaardAA.transformStringContainsTerm(term) + mustAliasAnalysis.transformStringContainsTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.substring.isPrimitiveDependent return term } override fun transformStringLengthTerm(term: StringLengthTerm): Term { - stensgaardAA.transformStringLengthTerm(term) + mustAliasAnalysis.transformStringLengthTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent return term } override fun transformStringParseTerm(term: StringParseTerm): Term { - stensgaardAA.transformStringParseTerm(term) + mustAliasAnalysis.transformStringParseTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent return term } override fun transformSubstringTerm(term: SubstringTerm): Term { - stensgaardAA.transformSubstringTerm(term) + mustAliasAnalysis.transformSubstringTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.offset.isPrimitiveDependent || term.length.isPrimitiveDependent return term } override fun transformToStringTerm(term: ToStringTerm): Term { - stensgaardAA.transformToStringTerm(term) + mustAliasAnalysis.transformToStringTerm(term) isPrimitiveDependentTerm[term.getToken] = term.value.isPrimitiveDependent return term } override fun transformUndefTerm(term: UndefTerm): Term { - stensgaardAA.transformUndefTerm(term) + mustAliasAnalysis.transformUndefTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformValueTerm(term: ValueTerm): Term { - stensgaardAA.transformValueTerm(term) + mustAliasAnalysis.transformValueTerm(term) if (term.isPrimitiveValue) isPrimitiveDependentTerm[term.getToken] = true if (isPrimitiveDependentTerm[term.getToken] == null) isPrimitiveDependentTerm[term.getToken] = false return term @@ -334,7 +333,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.arrayRef.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { - stensgaardAA.transformArrayInitializerPredicate(predicate) + mustAliasAnalysis.transformArrayInitializerPredicate(predicate) assert(predicate.arrayRef is ArrayIndexTerm) isPrimitiveDependentTerm[(predicate.arrayRef as ArrayIndexTerm).arrayRef.getToken] = predicate.value.isPrimitiveDependent @@ -347,7 +346,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.arrayRef.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { - stensgaardAA.transformArrayStorePredicate(predicate) + mustAliasAnalysis.transformArrayStorePredicate(predicate) assert(predicate.arrayRef is ArrayIndexTerm) isPrimitiveDependentTerm[(predicate.arrayRef as ArrayIndexTerm).arrayRef.getToken] = predicate.value.isPrimitiveDependent @@ -360,7 +359,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - stensgaardAA.transformBoundStorePredicate(predicate) + mustAliasAnalysis.transformBoundStorePredicate(predicate) } return predicate } @@ -369,7 +368,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += (predicate.hasLhv && predicate.lhv.isPrimitiveDependent) || predicate.callTerm.isPrimitiveDependent } else { - stensgaardAA.transformCallPredicate(predicate) + mustAliasAnalysis.transformCallPredicate(predicate) if (predicate.hasLhv) isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.callTerm.isPrimitiveDependent } @@ -380,7 +379,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - stensgaardAA.transformCatchPredicate(predicate) + mustAliasAnalysis.transformCatchPredicate(predicate) } return predicate } @@ -389,7 +388,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - stensgaardAA.transformDefaultSwitchPredicate(predicate) + mustAliasAnalysis.transformDefaultSwitchPredicate(predicate) } return predicate } @@ -398,7 +397,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - stensgaardAA.transformEnterMonitorPredicate(predicate) + mustAliasAnalysis.transformEnterMonitorPredicate(predicate) } return predicate } @@ -407,7 +406,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.lhv.isPrimitiveDependent || predicate.rhv.isPrimitiveDependent } else { - stensgaardAA.transformEqualityPredicate(predicate) + mustAliasAnalysis.transformEqualityPredicate(predicate) if (predicate.lhv !is ConstBoolTerm) { isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.rhv.isPrimitiveDependent } @@ -419,7 +418,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - stensgaardAA.transformExitMonitorPredicate(predicate) + mustAliasAnalysis.transformExitMonitorPredicate(predicate) } return predicate } @@ -428,7 +427,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.field.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { - stensgaardAA.transformFieldInitializerPredicate(predicate) + mustAliasAnalysis.transformFieldInitializerPredicate(predicate) isPrimitiveDependentTerm[predicate.field.getToken] = predicate.value.isPrimitiveDependent } return predicate @@ -438,7 +437,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.field.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { - stensgaardAA.transformFieldStorePredicate(predicate) + mustAliasAnalysis.transformFieldStorePredicate(predicate) isPrimitiveDependentTerm[predicate.field.getToken] = predicate.value.isPrimitiveDependent } return predicate @@ -448,7 +447,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.lhv.isPrimitiveDependent || predicate.length.isPrimitiveDependent || predicate.generator.isPrimitiveDependent } else { - stensgaardAA.transformGenerateArrayPredicate(predicate) + mustAliasAnalysis.transformGenerateArrayPredicate(predicate) isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.length.isPrimitiveDependent || predicate.generator.isPrimitiveDependent } @@ -459,7 +458,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - stensgaardAA.transformInequalityPredicate(predicate) + mustAliasAnalysis.transformInequalityPredicate(predicate) } return predicate } @@ -470,7 +469,7 @@ class PrimitiveDependencyAnalysis : Transformer { cur.isPrimitiveDependent || acc } || predicate.length.isPrimitiveDependent } else { - stensgaardAA.transformNewArrayInitializerPredicate(predicate) + mustAliasAnalysis.transformNewArrayInitializerPredicate(predicate) isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.elements.fold(false) { acc, cur -> cur.isPrimitiveDependent || acc } || predicate.length.isPrimitiveDependent @@ -484,7 +483,7 @@ class PrimitiveDependencyAnalysis : Transformer { cur.isPrimitiveDependent || acc } } else { - stensgaardAA.transformNewArrayPredicate(predicate) + mustAliasAnalysis.transformNewArrayPredicate(predicate) isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.dimensions.fold(false) { acc, cur -> cur.isPrimitiveDependent || acc } @@ -496,7 +495,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - stensgaardAA.transformNewInitializerPredicate(predicate) + mustAliasAnalysis.transformNewInitializerPredicate(predicate) } return predicate } @@ -505,7 +504,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - stensgaardAA.transformNewPredicate(predicate) + mustAliasAnalysis.transformNewPredicate(predicate) } return predicate } @@ -514,7 +513,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - stensgaardAA.transformThrowPredicate(predicate) + mustAliasAnalysis.transformThrowPredicate(predicate) } return predicate } From 44fc1d2675e7e66a255c977e51563a6030d042ed Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Tue, 24 Sep 2024 08:12:32 +0200 Subject: [PATCH 31/34] hided must(?) alias analysis --- .../kex/PrimitiveDependencyAnalysis.kt | 131 +++++++++--------- 1 file changed, 66 insertions(+), 65 deletions(-) diff --git a/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt b/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt index b1c8b3feee..36f461ece7 100644 --- a/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt +++ b/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt @@ -7,9 +7,9 @@ import org.vorpal.research.kex.state.transformer.Transformer import java.util.* class PrimitiveDependencyAnalysis : Transformer { - private val isPrimitiveDependentTerm = WeakHashMap() + private val isPrimitiveDependentTerm = WeakHashMap() private val isPrimitiveDependentPathPredicate = mutableListOf() - private val mustAliasAnalysis = MustAliasAnalysis() + // private val mustAliasAnalysis = MustAliasAnalysis() fun isPrimitiveDependentPathPredicate(index: Int): Boolean { assert(isPrimitiveDependentPathPredicate.size >= index) @@ -17,7 +17,8 @@ class PrimitiveDependencyAnalysis : Transformer { } private val Term.isPrimitiveValue: Boolean get() = this.name.contains("%primitive%") - private val Term.getToken: Token? get() = mustAliasAnalysis.get(this) + // private val Term.getToken: Token? get() = mustAliasAnalysis.get(this) + private val Term.getToken: Term get() = this private val Term.isPrimitiveDependent: Boolean get() { if (isPrimitiveDependentTerm[this.getToken] == null) { @@ -43,7 +44,7 @@ class PrimitiveDependencyAnalysis : Transformer { //////////////////////////////////////////////////////////////////// override fun transformArrayLoadTerm(term: ArrayLoadTerm): Term { - mustAliasAnalysis.transformArrayLoadTerm(term) + //mustAliasAnalysis.transformArrayLoadTerm(term) assert(term.arrayRef is ArrayIndexTerm) isPrimitiveDependentTerm[term.getToken] = term.arrayRef.isPrimitiveDependent || (term.arrayRef as ArrayIndexTerm).arrayRef.isPrimitiveDependent @@ -51,13 +52,13 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformArrayContainsTerm(term: ArrayContainsTerm): Term { - mustAliasAnalysis.transformArrayContainsTerm(term) + //mustAliasAnalysis.transformArrayContainsTerm(term) isPrimitiveDependentTerm[term.getToken] = term.value.isPrimitiveDependent || term.array.isPrimitiveDependent return term } override fun transformArrayIndexTerm(term: ArrayIndexTerm): Term { - mustAliasAnalysis.transformArrayIndexTerm(term) + //mustAliasAnalysis.transformArrayIndexTerm(term) isPrimitiveDependentTerm[term.getToken] = term.index.isPrimitiveDependent || term.arrayRef.isPrimitiveDependent return term } @@ -67,50 +68,50 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformArrayLengthTerm(term: ArrayLengthTerm): Term { - mustAliasAnalysis.transformArrayLengthTerm(term) + //mustAliasAnalysis.transformArrayLengthTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformCharAtTerm(term: CharAtTerm): Term { - mustAliasAnalysis.transformCharAtTerm(term) + //mustAliasAnalysis.transformCharAtTerm(term) isPrimitiveDependentTerm[term.getToken] = term.index.isPrimitiveDependent || term.string.isPrimitiveDependent return term } override fun transformBinaryTerm(term: BinaryTerm): Term { - mustAliasAnalysis.transformBinaryTerm(term) + //mustAliasAnalysis.transformBinaryTerm(term) isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent return term } override fun transformBoundTerm(term: BoundTerm): Term { - mustAliasAnalysis.transformBoundTerm(term) + //mustAliasAnalysis.transformBoundTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformCallTerm(term: CallTerm): Term { - mustAliasAnalysis.transformCallTerm(term) + //mustAliasAnalysis.transformCallTerm(term) isPrimitiveDependentTerm[term.getToken] = term.arguments.fold(false) { acc, cur -> cur.isPrimitiveDependent || acc } || term.owner.isPrimitiveDependent return term } override fun transformCastTerm(term: CastTerm): Term { - mustAliasAnalysis.transformCastTerm(term) + //mustAliasAnalysis.transformCastTerm(term) isPrimitiveDependentTerm[term.getToken] = term.operand.isPrimitiveDependent return term } override fun transformClassAccessTerm(term: ClassAccessTerm): Term { - mustAliasAnalysis.transformClassAccessTerm(term) + //mustAliasAnalysis.transformClassAccessTerm(term) isPrimitiveDependentTerm[term.getToken] = term.operand.isPrimitiveDependent return term } override fun transformCmpTerm(term: CmpTerm): Term { - mustAliasAnalysis.transformCmpTerm(term) + //mustAliasAnalysis.transformCmpTerm(term) if (term.rhv !is NullTerm) { isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent } else { @@ -120,130 +121,130 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformConcatTerm(term: ConcatTerm): Term { - mustAliasAnalysis.transformConcatTerm(term) + //mustAliasAnalysis.transformConcatTerm(term) isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent return term } override fun transformConstBoolTerm(term: ConstBoolTerm): Term { - mustAliasAnalysis.transformConstBoolTerm(term) + //mustAliasAnalysis.transformConstBoolTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstByteTerm(term: ConstByteTerm): Term { - mustAliasAnalysis.transformConstByteTerm(term) + //mustAliasAnalysis.transformConstByteTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstCharTerm(term: ConstCharTerm): Term { - mustAliasAnalysis.transformConstCharTerm(term) + //mustAliasAnalysis.transformConstCharTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstDoubleTerm(term: ConstDoubleTerm): Term { - mustAliasAnalysis.transformConstDoubleTerm(term) + //mustAliasAnalysis.transformConstDoubleTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstIntTerm(term: ConstIntTerm): Term { - mustAliasAnalysis.transformConstIntTerm(term) + //mustAliasAnalysis.transformConstIntTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstLongTerm(term: ConstLongTerm): Term { - mustAliasAnalysis.transformConstLongTerm(term) + //mustAliasAnalysis.transformConstLongTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstFloatTerm(term: ConstFloatTerm): Term { - mustAliasAnalysis.transformConstFloatTerm(term) + //mustAliasAnalysis.transformConstFloatTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstClassTerm(term: ConstClassTerm): Term { - mustAliasAnalysis.transformConstClassTerm(term) + //mustAliasAnalysis.transformConstClassTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstStringTerm(term: ConstStringTerm): Term { - mustAliasAnalysis.transformConstStringTerm(term) + //mustAliasAnalysis.transformConstStringTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstShortTerm(term: ConstShortTerm): Term { - mustAliasAnalysis.transformConstShortTerm(term) + //mustAliasAnalysis.transformConstShortTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformEndsWithTerm(term: EndsWithTerm): Term { - mustAliasAnalysis.transformEndsWithTerm(term) + //mustAliasAnalysis.transformEndsWithTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.suffix.isPrimitiveDependent return term } override fun transformEqualsTerm(term: EqualsTerm): Term { - mustAliasAnalysis.transformEqualsTerm(term) + //mustAliasAnalysis.transformEqualsTerm(term) isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent return term } override fun transformExistsTerm(term: ExistsTerm): Term { - mustAliasAnalysis.transformExistsTerm(term) + //mustAliasAnalysis.transformExistsTerm(term) isPrimitiveDependentTerm[term.getToken] = term.start.isPrimitiveDependent || term.end.isPrimitiveDependent || term.body.isPrimitiveDependent return term } override fun transformFieldLoadTerm(term: FieldLoadTerm): Term { - mustAliasAnalysis.transformFieldLoadTerm(term) + //mustAliasAnalysis.transformFieldLoadTerm(term) isPrimitiveDependentTerm[term.getToken] = term.field.isPrimitiveDependent return term } override fun transformFieldTerm(term: FieldTerm): Term { - mustAliasAnalysis.transformFieldTerm(term) + //mustAliasAnalysis.transformFieldTerm(term) return term } override fun transformForAllTerm(term: ForAllTerm): Term { - mustAliasAnalysis.transformForAllTerm(term) + //mustAliasAnalysis.transformForAllTerm(term) isPrimitiveDependentTerm[term.getToken] = term.start.isPrimitiveDependent || term.end.isPrimitiveDependent || term.body.isPrimitiveDependent return term } override fun transformIndexOfTerm(term: IndexOfTerm): Term { - mustAliasAnalysis.transformIndexOfTerm(term) + //mustAliasAnalysis.transformIndexOfTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.substring.isPrimitiveDependent || term.offset.isPrimitiveDependent return term } override fun transformInstanceOfTerm(term: InstanceOfTerm): Term { - mustAliasAnalysis.transformInstanceOfTerm(term) + //mustAliasAnalysis.transformInstanceOfTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformIteTerm(term: IteTerm): Term { - mustAliasAnalysis.transformIteTerm(term) + //mustAliasAnalysis.transformIteTerm(term) isPrimitiveDependentTerm[term.getToken] = term.cond.isPrimitiveDependent || term.trueValue.isPrimitiveDependent || term.falseValue.isPrimitiveDependent return term } override fun transformLambdaTerm(term: LambdaTerm): Term { - mustAliasAnalysis.transformLambdaTerm(term) + //mustAliasAnalysis.transformLambdaTerm(term) isPrimitiveDependentTerm[term.getToken] = term.parameters.fold(false) { acc, cur -> cur.isPrimitiveDependent || acc } @@ -251,75 +252,75 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformNegTerm(term: NegTerm): Term { - mustAliasAnalysis.transformNegTerm(term) + //mustAliasAnalysis.transformNegTerm(term) isPrimitiveDependentTerm[term.getToken] = term.operand.isPrimitiveDependent return term } override fun transformNullTerm(term: NullTerm): Term { - mustAliasAnalysis.transformNullTerm(term) + //mustAliasAnalysis.transformNullTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformReturnValueTerm(term: ReturnValueTerm): Term { - mustAliasAnalysis.transformReturnValueTerm(term) + //mustAliasAnalysis.transformReturnValueTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformStartsWithTerm(term: StartsWithTerm): Term { - mustAliasAnalysis.transformStartsWithTerm(term) + //mustAliasAnalysis.transformStartsWithTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.prefix.isPrimitiveDependent return term } override fun transformStaticClassRefTerm(term: StaticClassRefTerm): Term { - mustAliasAnalysis.transformStaticClassRefTerm(term) + //mustAliasAnalysis.transformStaticClassRefTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformStringContainsTerm(term: StringContainsTerm): Term { - mustAliasAnalysis.transformStringContainsTerm(term) + //mustAliasAnalysis.transformStringContainsTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.substring.isPrimitiveDependent return term } override fun transformStringLengthTerm(term: StringLengthTerm): Term { - mustAliasAnalysis.transformStringLengthTerm(term) + //mustAliasAnalysis.transformStringLengthTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent return term } override fun transformStringParseTerm(term: StringParseTerm): Term { - mustAliasAnalysis.transformStringParseTerm(term) + //mustAliasAnalysis.transformStringParseTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent return term } override fun transformSubstringTerm(term: SubstringTerm): Term { - mustAliasAnalysis.transformSubstringTerm(term) + //mustAliasAnalysis.transformSubstringTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.offset.isPrimitiveDependent || term.length.isPrimitiveDependent return term } override fun transformToStringTerm(term: ToStringTerm): Term { - mustAliasAnalysis.transformToStringTerm(term) + //mustAliasAnalysis.transformToStringTerm(term) isPrimitiveDependentTerm[term.getToken] = term.value.isPrimitiveDependent return term } override fun transformUndefTerm(term: UndefTerm): Term { - mustAliasAnalysis.transformUndefTerm(term) + //mustAliasAnalysis.transformUndefTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformValueTerm(term: ValueTerm): Term { - mustAliasAnalysis.transformValueTerm(term) + //mustAliasAnalysis.transformValueTerm(term) if (term.isPrimitiveValue) isPrimitiveDependentTerm[term.getToken] = true if (isPrimitiveDependentTerm[term.getToken] == null) isPrimitiveDependentTerm[term.getToken] = false return term @@ -333,7 +334,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.arrayRef.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { - mustAliasAnalysis.transformArrayInitializerPredicate(predicate) + //mustAliasAnalysis.transformArrayInitializerPredicate(predicate) assert(predicate.arrayRef is ArrayIndexTerm) isPrimitiveDependentTerm[(predicate.arrayRef as ArrayIndexTerm).arrayRef.getToken] = predicate.value.isPrimitiveDependent @@ -346,7 +347,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.arrayRef.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { - mustAliasAnalysis.transformArrayStorePredicate(predicate) + //mustAliasAnalysis.transformArrayStorePredicate(predicate) assert(predicate.arrayRef is ArrayIndexTerm) isPrimitiveDependentTerm[(predicate.arrayRef as ArrayIndexTerm).arrayRef.getToken] = predicate.value.isPrimitiveDependent @@ -359,7 +360,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - mustAliasAnalysis.transformBoundStorePredicate(predicate) + //mustAliasAnalysis.transformBoundStorePredicate(predicate) } return predicate } @@ -368,7 +369,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += (predicate.hasLhv && predicate.lhv.isPrimitiveDependent) || predicate.callTerm.isPrimitiveDependent } else { - mustAliasAnalysis.transformCallPredicate(predicate) + //mustAliasAnalysis.transformCallPredicate(predicate) if (predicate.hasLhv) isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.callTerm.isPrimitiveDependent } @@ -379,7 +380,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - mustAliasAnalysis.transformCatchPredicate(predicate) + //mustAliasAnalysis.transformCatchPredicate(predicate) } return predicate } @@ -388,7 +389,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - mustAliasAnalysis.transformDefaultSwitchPredicate(predicate) + //mustAliasAnalysis.transformDefaultSwitchPredicate(predicate) } return predicate } @@ -397,7 +398,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - mustAliasAnalysis.transformEnterMonitorPredicate(predicate) + //mustAliasAnalysis.transformEnterMonitorPredicate(predicate) } return predicate } @@ -406,7 +407,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.lhv.isPrimitiveDependent || predicate.rhv.isPrimitiveDependent } else { - mustAliasAnalysis.transformEqualityPredicate(predicate) + //mustAliasAnalysis.transformEqualityPredicate(predicate) if (predicate.lhv !is ConstBoolTerm) { isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.rhv.isPrimitiveDependent } @@ -418,7 +419,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - mustAliasAnalysis.transformExitMonitorPredicate(predicate) + //mustAliasAnalysis.transformExitMonitorPredicate(predicate) } return predicate } @@ -427,7 +428,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.field.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { - mustAliasAnalysis.transformFieldInitializerPredicate(predicate) + //mustAliasAnalysis.transformFieldInitializerPredicate(predicate) isPrimitiveDependentTerm[predicate.field.getToken] = predicate.value.isPrimitiveDependent } return predicate @@ -437,7 +438,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.field.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { - mustAliasAnalysis.transformFieldStorePredicate(predicate) + //mustAliasAnalysis.transformFieldStorePredicate(predicate) isPrimitiveDependentTerm[predicate.field.getToken] = predicate.value.isPrimitiveDependent } return predicate @@ -447,7 +448,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.lhv.isPrimitiveDependent || predicate.length.isPrimitiveDependent || predicate.generator.isPrimitiveDependent } else { - mustAliasAnalysis.transformGenerateArrayPredicate(predicate) + //mustAliasAnalysis.transformGenerateArrayPredicate(predicate) isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.length.isPrimitiveDependent || predicate.generator.isPrimitiveDependent } @@ -458,7 +459,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - mustAliasAnalysis.transformInequalityPredicate(predicate) + //mustAliasAnalysis.transformInequalityPredicate(predicate) } return predicate } @@ -469,7 +470,7 @@ class PrimitiveDependencyAnalysis : Transformer { cur.isPrimitiveDependent || acc } || predicate.length.isPrimitiveDependent } else { - mustAliasAnalysis.transformNewArrayInitializerPredicate(predicate) + //mustAliasAnalysis.transformNewArrayInitializerPredicate(predicate) isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.elements.fold(false) { acc, cur -> cur.isPrimitiveDependent || acc } || predicate.length.isPrimitiveDependent @@ -483,7 +484,7 @@ class PrimitiveDependencyAnalysis : Transformer { cur.isPrimitiveDependent || acc } } else { - mustAliasAnalysis.transformNewArrayPredicate(predicate) + //mustAliasAnalysis.transformNewArrayPredicate(predicate) isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.dimensions.fold(false) { acc, cur -> cur.isPrimitiveDependent || acc } @@ -495,7 +496,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - mustAliasAnalysis.transformNewInitializerPredicate(predicate) + //mustAliasAnalysis.transformNewInitializerPredicate(predicate) } return predicate } @@ -504,7 +505,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - mustAliasAnalysis.transformNewPredicate(predicate) + //mustAliasAnalysis.transformNewPredicate(predicate) } return predicate } @@ -513,7 +514,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - mustAliasAnalysis.transformThrowPredicate(predicate) + //mustAliasAnalysis.transformThrowPredicate(predicate) } return predicate } From 6d402da3501b91751de12dbdc616f2ff7961ee12 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Tue, 24 Sep 2024 17:06:11 +0200 Subject: [PATCH 32/34] restored alias analysis --- .../kex/PrimitiveDependencyAnalysis.kt | 131 +++++++++--------- 1 file changed, 65 insertions(+), 66 deletions(-) diff --git a/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt b/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt index 36f461ece7..e9ab70aec9 100644 --- a/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt +++ b/client/src/main/kotlin/org/evosuite/kex/PrimitiveDependencyAnalysis.kt @@ -7,9 +7,9 @@ import org.vorpal.research.kex.state.transformer.Transformer import java.util.* class PrimitiveDependencyAnalysis : Transformer { - private val isPrimitiveDependentTerm = WeakHashMap() + private val isPrimitiveDependentTerm = WeakHashMap() private val isPrimitiveDependentPathPredicate = mutableListOf() - // private val mustAliasAnalysis = MustAliasAnalysis() + private val mustAliasAnalysis = MustAliasAnalysis() fun isPrimitiveDependentPathPredicate(index: Int): Boolean { assert(isPrimitiveDependentPathPredicate.size >= index) @@ -17,8 +17,7 @@ class PrimitiveDependencyAnalysis : Transformer { } private val Term.isPrimitiveValue: Boolean get() = this.name.contains("%primitive%") - // private val Term.getToken: Token? get() = mustAliasAnalysis.get(this) - private val Term.getToken: Term get() = this + private val Term.getToken: Token? get() = mustAliasAnalysis.get(this) private val Term.isPrimitiveDependent: Boolean get() { if (isPrimitiveDependentTerm[this.getToken] == null) { @@ -44,7 +43,7 @@ class PrimitiveDependencyAnalysis : Transformer { //////////////////////////////////////////////////////////////////// override fun transformArrayLoadTerm(term: ArrayLoadTerm): Term { - //mustAliasAnalysis.transformArrayLoadTerm(term) + mustAliasAnalysis.transformArrayLoadTerm(term) assert(term.arrayRef is ArrayIndexTerm) isPrimitiveDependentTerm[term.getToken] = term.arrayRef.isPrimitiveDependent || (term.arrayRef as ArrayIndexTerm).arrayRef.isPrimitiveDependent @@ -52,13 +51,13 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformArrayContainsTerm(term: ArrayContainsTerm): Term { - //mustAliasAnalysis.transformArrayContainsTerm(term) + mustAliasAnalysis.transformArrayContainsTerm(term) isPrimitiveDependentTerm[term.getToken] = term.value.isPrimitiveDependent || term.array.isPrimitiveDependent return term } override fun transformArrayIndexTerm(term: ArrayIndexTerm): Term { - //mustAliasAnalysis.transformArrayIndexTerm(term) + mustAliasAnalysis.transformArrayIndexTerm(term) isPrimitiveDependentTerm[term.getToken] = term.index.isPrimitiveDependent || term.arrayRef.isPrimitiveDependent return term } @@ -68,50 +67,50 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformArrayLengthTerm(term: ArrayLengthTerm): Term { - //mustAliasAnalysis.transformArrayLengthTerm(term) + mustAliasAnalysis.transformArrayLengthTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformCharAtTerm(term: CharAtTerm): Term { - //mustAliasAnalysis.transformCharAtTerm(term) + mustAliasAnalysis.transformCharAtTerm(term) isPrimitiveDependentTerm[term.getToken] = term.index.isPrimitiveDependent || term.string.isPrimitiveDependent return term } override fun transformBinaryTerm(term: BinaryTerm): Term { - //mustAliasAnalysis.transformBinaryTerm(term) + mustAliasAnalysis.transformBinaryTerm(term) isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent return term } override fun transformBoundTerm(term: BoundTerm): Term { - //mustAliasAnalysis.transformBoundTerm(term) + mustAliasAnalysis.transformBoundTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformCallTerm(term: CallTerm): Term { - //mustAliasAnalysis.transformCallTerm(term) + mustAliasAnalysis.transformCallTerm(term) isPrimitiveDependentTerm[term.getToken] = term.arguments.fold(false) { acc, cur -> cur.isPrimitiveDependent || acc } || term.owner.isPrimitiveDependent return term } override fun transformCastTerm(term: CastTerm): Term { - //mustAliasAnalysis.transformCastTerm(term) + mustAliasAnalysis.transformCastTerm(term) isPrimitiveDependentTerm[term.getToken] = term.operand.isPrimitiveDependent return term } override fun transformClassAccessTerm(term: ClassAccessTerm): Term { - //mustAliasAnalysis.transformClassAccessTerm(term) + mustAliasAnalysis.transformClassAccessTerm(term) isPrimitiveDependentTerm[term.getToken] = term.operand.isPrimitiveDependent return term } override fun transformCmpTerm(term: CmpTerm): Term { - //mustAliasAnalysis.transformCmpTerm(term) + mustAliasAnalysis.transformCmpTerm(term) if (term.rhv !is NullTerm) { isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent } else { @@ -121,130 +120,130 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformConcatTerm(term: ConcatTerm): Term { - //mustAliasAnalysis.transformConcatTerm(term) + mustAliasAnalysis.transformConcatTerm(term) isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent return term } override fun transformConstBoolTerm(term: ConstBoolTerm): Term { - //mustAliasAnalysis.transformConstBoolTerm(term) + mustAliasAnalysis.transformConstBoolTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstByteTerm(term: ConstByteTerm): Term { - //mustAliasAnalysis.transformConstByteTerm(term) + mustAliasAnalysis.transformConstByteTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstCharTerm(term: ConstCharTerm): Term { - //mustAliasAnalysis.transformConstCharTerm(term) + mustAliasAnalysis.transformConstCharTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstDoubleTerm(term: ConstDoubleTerm): Term { - //mustAliasAnalysis.transformConstDoubleTerm(term) + mustAliasAnalysis.transformConstDoubleTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstIntTerm(term: ConstIntTerm): Term { - //mustAliasAnalysis.transformConstIntTerm(term) + mustAliasAnalysis.transformConstIntTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstLongTerm(term: ConstLongTerm): Term { - //mustAliasAnalysis.transformConstLongTerm(term) + mustAliasAnalysis.transformConstLongTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstFloatTerm(term: ConstFloatTerm): Term { - //mustAliasAnalysis.transformConstFloatTerm(term) + mustAliasAnalysis.transformConstFloatTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstClassTerm(term: ConstClassTerm): Term { - //mustAliasAnalysis.transformConstClassTerm(term) + mustAliasAnalysis.transformConstClassTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstStringTerm(term: ConstStringTerm): Term { - //mustAliasAnalysis.transformConstStringTerm(term) + mustAliasAnalysis.transformConstStringTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformConstShortTerm(term: ConstShortTerm): Term { - //mustAliasAnalysis.transformConstShortTerm(term) + mustAliasAnalysis.transformConstShortTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformEndsWithTerm(term: EndsWithTerm): Term { - //mustAliasAnalysis.transformEndsWithTerm(term) + mustAliasAnalysis.transformEndsWithTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.suffix.isPrimitiveDependent return term } override fun transformEqualsTerm(term: EqualsTerm): Term { - //mustAliasAnalysis.transformEqualsTerm(term) + mustAliasAnalysis.transformEqualsTerm(term) isPrimitiveDependentTerm[term.getToken] = term.lhv.isPrimitiveDependent || term.rhv.isPrimitiveDependent return term } override fun transformExistsTerm(term: ExistsTerm): Term { - //mustAliasAnalysis.transformExistsTerm(term) + mustAliasAnalysis.transformExistsTerm(term) isPrimitiveDependentTerm[term.getToken] = term.start.isPrimitiveDependent || term.end.isPrimitiveDependent || term.body.isPrimitiveDependent return term } override fun transformFieldLoadTerm(term: FieldLoadTerm): Term { - //mustAliasAnalysis.transformFieldLoadTerm(term) + mustAliasAnalysis.transformFieldLoadTerm(term) isPrimitiveDependentTerm[term.getToken] = term.field.isPrimitiveDependent return term } override fun transformFieldTerm(term: FieldTerm): Term { - //mustAliasAnalysis.transformFieldTerm(term) + mustAliasAnalysis.transformFieldTerm(term) return term } override fun transformForAllTerm(term: ForAllTerm): Term { - //mustAliasAnalysis.transformForAllTerm(term) + mustAliasAnalysis.transformForAllTerm(term) isPrimitiveDependentTerm[term.getToken] = term.start.isPrimitiveDependent || term.end.isPrimitiveDependent || term.body.isPrimitiveDependent return term } override fun transformIndexOfTerm(term: IndexOfTerm): Term { - //mustAliasAnalysis.transformIndexOfTerm(term) + mustAliasAnalysis.transformIndexOfTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.substring.isPrimitiveDependent || term.offset.isPrimitiveDependent return term } override fun transformInstanceOfTerm(term: InstanceOfTerm): Term { - //mustAliasAnalysis.transformInstanceOfTerm(term) + mustAliasAnalysis.transformInstanceOfTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformIteTerm(term: IteTerm): Term { - //mustAliasAnalysis.transformIteTerm(term) + mustAliasAnalysis.transformIteTerm(term) isPrimitiveDependentTerm[term.getToken] = term.cond.isPrimitiveDependent || term.trueValue.isPrimitiveDependent || term.falseValue.isPrimitiveDependent return term } override fun transformLambdaTerm(term: LambdaTerm): Term { - //mustAliasAnalysis.transformLambdaTerm(term) + mustAliasAnalysis.transformLambdaTerm(term) isPrimitiveDependentTerm[term.getToken] = term.parameters.fold(false) { acc, cur -> cur.isPrimitiveDependent || acc } @@ -252,75 +251,75 @@ class PrimitiveDependencyAnalysis : Transformer { } override fun transformNegTerm(term: NegTerm): Term { - //mustAliasAnalysis.transformNegTerm(term) + mustAliasAnalysis.transformNegTerm(term) isPrimitiveDependentTerm[term.getToken] = term.operand.isPrimitiveDependent return term } override fun transformNullTerm(term: NullTerm): Term { - //mustAliasAnalysis.transformNullTerm(term) + mustAliasAnalysis.transformNullTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformReturnValueTerm(term: ReturnValueTerm): Term { - //mustAliasAnalysis.transformReturnValueTerm(term) + mustAliasAnalysis.transformReturnValueTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformStartsWithTerm(term: StartsWithTerm): Term { - //mustAliasAnalysis.transformStartsWithTerm(term) + mustAliasAnalysis.transformStartsWithTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.prefix.isPrimitiveDependent return term } override fun transformStaticClassRefTerm(term: StaticClassRefTerm): Term { - //mustAliasAnalysis.transformStaticClassRefTerm(term) + mustAliasAnalysis.transformStaticClassRefTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformStringContainsTerm(term: StringContainsTerm): Term { - //mustAliasAnalysis.transformStringContainsTerm(term) + mustAliasAnalysis.transformStringContainsTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.substring.isPrimitiveDependent return term } override fun transformStringLengthTerm(term: StringLengthTerm): Term { - //mustAliasAnalysis.transformStringLengthTerm(term) + mustAliasAnalysis.transformStringLengthTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent return term } override fun transformStringParseTerm(term: StringParseTerm): Term { - //mustAliasAnalysis.transformStringParseTerm(term) + mustAliasAnalysis.transformStringParseTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent return term } override fun transformSubstringTerm(term: SubstringTerm): Term { - //mustAliasAnalysis.transformSubstringTerm(term) + mustAliasAnalysis.transformSubstringTerm(term) isPrimitiveDependentTerm[term.getToken] = term.string.isPrimitiveDependent || term.offset.isPrimitiveDependent || term.length.isPrimitiveDependent return term } override fun transformToStringTerm(term: ToStringTerm): Term { - //mustAliasAnalysis.transformToStringTerm(term) + mustAliasAnalysis.transformToStringTerm(term) isPrimitiveDependentTerm[term.getToken] = term.value.isPrimitiveDependent return term } override fun transformUndefTerm(term: UndefTerm): Term { - //mustAliasAnalysis.transformUndefTerm(term) + mustAliasAnalysis.transformUndefTerm(term) isPrimitiveDependentTerm[term.getToken] = false return term } override fun transformValueTerm(term: ValueTerm): Term { - //mustAliasAnalysis.transformValueTerm(term) + mustAliasAnalysis.transformValueTerm(term) if (term.isPrimitiveValue) isPrimitiveDependentTerm[term.getToken] = true if (isPrimitiveDependentTerm[term.getToken] == null) isPrimitiveDependentTerm[term.getToken] = false return term @@ -334,7 +333,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.arrayRef.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { - //mustAliasAnalysis.transformArrayInitializerPredicate(predicate) + mustAliasAnalysis.transformArrayInitializerPredicate(predicate) assert(predicate.arrayRef is ArrayIndexTerm) isPrimitiveDependentTerm[(predicate.arrayRef as ArrayIndexTerm).arrayRef.getToken] = predicate.value.isPrimitiveDependent @@ -347,7 +346,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.arrayRef.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { - //mustAliasAnalysis.transformArrayStorePredicate(predicate) + mustAliasAnalysis.transformArrayStorePredicate(predicate) assert(predicate.arrayRef is ArrayIndexTerm) isPrimitiveDependentTerm[(predicate.arrayRef as ArrayIndexTerm).arrayRef.getToken] = predicate.value.isPrimitiveDependent @@ -360,7 +359,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - //mustAliasAnalysis.transformBoundStorePredicate(predicate) + mustAliasAnalysis.transformBoundStorePredicate(predicate) } return predicate } @@ -369,7 +368,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += (predicate.hasLhv && predicate.lhv.isPrimitiveDependent) || predicate.callTerm.isPrimitiveDependent } else { - //mustAliasAnalysis.transformCallPredicate(predicate) + mustAliasAnalysis.transformCallPredicate(predicate) if (predicate.hasLhv) isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.callTerm.isPrimitiveDependent } @@ -380,7 +379,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - //mustAliasAnalysis.transformCatchPredicate(predicate) + mustAliasAnalysis.transformCatchPredicate(predicate) } return predicate } @@ -389,7 +388,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - //mustAliasAnalysis.transformDefaultSwitchPredicate(predicate) + mustAliasAnalysis.transformDefaultSwitchPredicate(predicate) } return predicate } @@ -398,7 +397,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - //mustAliasAnalysis.transformEnterMonitorPredicate(predicate) + mustAliasAnalysis.transformEnterMonitorPredicate(predicate) } return predicate } @@ -407,7 +406,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.lhv.isPrimitiveDependent || predicate.rhv.isPrimitiveDependent } else { - //mustAliasAnalysis.transformEqualityPredicate(predicate) + mustAliasAnalysis.transformEqualityPredicate(predicate) if (predicate.lhv !is ConstBoolTerm) { isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.rhv.isPrimitiveDependent } @@ -419,7 +418,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - //mustAliasAnalysis.transformExitMonitorPredicate(predicate) + mustAliasAnalysis.transformExitMonitorPredicate(predicate) } return predicate } @@ -428,7 +427,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.field.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { - //mustAliasAnalysis.transformFieldInitializerPredicate(predicate) + mustAliasAnalysis.transformFieldInitializerPredicate(predicate) isPrimitiveDependentTerm[predicate.field.getToken] = predicate.value.isPrimitiveDependent } return predicate @@ -438,7 +437,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.field.isPrimitiveDependent || predicate.value.isPrimitiveDependent } else { - //mustAliasAnalysis.transformFieldStorePredicate(predicate) + mustAliasAnalysis.transformFieldStorePredicate(predicate) isPrimitiveDependentTerm[predicate.field.getToken] = predicate.value.isPrimitiveDependent } return predicate @@ -448,7 +447,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += predicate.lhv.isPrimitiveDependent || predicate.length.isPrimitiveDependent || predicate.generator.isPrimitiveDependent } else { - //mustAliasAnalysis.transformGenerateArrayPredicate(predicate) + mustAliasAnalysis.transformGenerateArrayPredicate(predicate) isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.length.isPrimitiveDependent || predicate.generator.isPrimitiveDependent } @@ -459,7 +458,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - //mustAliasAnalysis.transformInequalityPredicate(predicate) + mustAliasAnalysis.transformInequalityPredicate(predicate) } return predicate } @@ -470,7 +469,7 @@ class PrimitiveDependencyAnalysis : Transformer { cur.isPrimitiveDependent || acc } || predicate.length.isPrimitiveDependent } else { - //mustAliasAnalysis.transformNewArrayInitializerPredicate(predicate) + mustAliasAnalysis.transformNewArrayInitializerPredicate(predicate) isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.elements.fold(false) { acc, cur -> cur.isPrimitiveDependent || acc } || predicate.length.isPrimitiveDependent @@ -484,7 +483,7 @@ class PrimitiveDependencyAnalysis : Transformer { cur.isPrimitiveDependent || acc } } else { - //mustAliasAnalysis.transformNewArrayPredicate(predicate) + mustAliasAnalysis.transformNewArrayPredicate(predicate) isPrimitiveDependentTerm[predicate.lhv.getToken] = predicate.dimensions.fold(false) { acc, cur -> cur.isPrimitiveDependent || acc } @@ -496,7 +495,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - //mustAliasAnalysis.transformNewInitializerPredicate(predicate) + mustAliasAnalysis.transformNewInitializerPredicate(predicate) } return predicate } @@ -505,7 +504,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - //mustAliasAnalysis.transformNewPredicate(predicate) + mustAliasAnalysis.transformNewPredicate(predicate) } return predicate } @@ -514,7 +513,7 @@ class PrimitiveDependencyAnalysis : Transformer { if (predicate.type == PredicateType.Path()) { isPrimitiveDependentPathPredicate += false } else { - //mustAliasAnalysis.transformThrowPredicate(predicate) + mustAliasAnalysis.transformThrowPredicate(predicate) } return predicate } From 2e629a311ad39a0816279adbdcd0addf389f700a Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Wed, 25 Sep 2024 17:36:11 +0200 Subject: [PATCH 33/34] concolic mutations on plateaus --- .../ga/metaheuristics/mosa/DynaMOSA.java | 21 +++++++++++++++++++ .../org/evosuite/testcase/TestChromosome.java | 3 ++- 2 files changed, 23 insertions(+), 1 deletion(-) diff --git a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java index 520f09a902..1563932476 100644 --- a/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java +++ b/client/src/main/java/org/evosuite/ga/metaheuristics/mosa/DynaMOSA.java @@ -52,6 +52,8 @@ public class DynaMOSA extends AbstractMOSA { protected CrowdingDistance distance = new CrowdingDistance<>(); private boolean wasTargeted; + private int stallLen; + private int maxStallLen = 32; /** * Constructor based on the abstract class {@link AbstractMOSA}. @@ -65,6 +67,14 @@ public DynaMOSA(ChromosomeFactory factory) { /** {@inheritDoc} */ @Override protected void evolve() { + if (stallLen > maxStallLen) { + stallLen = 0; + wasTargeted = true; + TestChromosome.enableConcolic = true; + } else { + TestChromosome.enableConcolic = false; + } + // Generate offspring, compute their fitness, update the archive and coverage goals. TestChromosome.reset(); List offspringPopulation = this.breedNextGeneration(); @@ -198,6 +208,7 @@ public void generateSolution() { // Evolve the population generation by generation until all gaols have been covered or the // search budget has been consumed. + stallLen = 0; long startTime = System.currentTimeMillis(); int iterations = 0; int kexIterations = 0; @@ -226,6 +237,16 @@ public void generateSolution() { } } + if (oldCoverage == newCoverage) { + if (wasTargeted) { + maxStallLen *= 2; + } else { + stallLen++; + } + } else { + stallLen = 0; + } + iterations++; this.notifyIteration(); } diff --git a/client/src/main/java/org/evosuite/testcase/TestChromosome.java b/client/src/main/java/org/evosuite/testcase/TestChromosome.java index 8fc272df9f..da20588556 100755 --- a/client/src/main/java/org/evosuite/testcase/TestChromosome.java +++ b/client/src/main/java/org/evosuite/testcase/TestChromosome.java @@ -74,6 +74,7 @@ public final class TestChromosome extends AbstractTestChromosome public static int timeOfUnsat = 0; public static int timeOfSat = 0; public static int numberOfKexCalls = 0; + public static boolean enableConcolic = false; public static void reset() { numberOfCovered = 0; numberOfCollected = 0; @@ -490,7 +491,7 @@ private boolean mutationChange() { double pl = 1d / (lastMutatableStatement + 1); TestFactory testFactory = TestFactory.getInstance(); - if (Randomness.nextDouble() < Properties.CONCOLIC_MUTATION) { + if (Randomness.nextDouble() < Properties.CONCOLIC_MUTATION && enableConcolic) { numberOfConcolic += 1; long time = System.currentTimeMillis(); try { From 91f4dd40d04c10d28ea75f028378de31814742c8 Mon Sep 17 00:00:00 2001 From: FerrumBrain Date: Mon, 30 Sep 2024 11:51:35 +0200 Subject: [PATCH 34/34] new statistics collection notebook --- sbst_scripts/gather_statistics.ipynb | 3605 +++++++++++++++++++------- 1 file changed, 2643 insertions(+), 962 deletions(-) diff --git a/sbst_scripts/gather_statistics.ipynb b/sbst_scripts/gather_statistics.ipynb index 1ccc4de731..5aa954cda4 100644 --- a/sbst_scripts/gather_statistics.ipynb +++ b/sbst_scripts/gather_statistics.ipynb @@ -1,966 +1,2647 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true, - "ExecuteTime": { - "end_time": "2024-03-01T16:11:15.226914504Z", - "start_time": "2024-03-01T16:11:13.958239776Z" - } - }, - "outputs": [], - "source": [ - "import os\n", - "import re\n", - "from collections import defaultdict\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "from statsmodels.stats.weightstats import DescrStatsW\n", - "\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "outputs": [], - "source": [ - "# read gathered statistics data\n", - "\n", - "output_paths = [\n", - " # 'evosuite.csv',\n", - " # '~/evosuite-stat.csv',\n", - " # '~/evokex-16-15.csv', \n", - " # \"~/evokex-32-5.csv\",\n", - " # \"~/evokex-32-15.csv\", \n", - " # \"~/evokex-16-15-u.csv\",\n", - " # \"~/evokex-32-5-u.csv\",\n", - " # \"~/evokex-32-5-g-1.csv\",\n", - " # \"~/evokex-32-5-g-2.csv\",\n", - " # \"~/evokex-32-5-g-3.csv\",\n", - " # \"~/evokex-32-5-g-4.csv\",\n", - " # \"~/evokex-32-5-g-5.csv\",\n", - " # \"~/evokex-32-5-g-6.csv\",\n", - " # \"~/evokex-32-5-l-1.csv\",\n", - " # \"~/evokex-32-5-l-2.csv\",\n", - " # \"~/evokex-32-5-l-3.csv\",\n", - " # \"~/evokex-32-5-l-4.csv\",\n", - "\n", - " # \"~/evosuite-gu.csv\",\n", - " \"~/evosuite-stat-gu.csv\",\n", - " # \"~/evokex-32-5-gu.csv\",\n", - " # \"~/evokex-32-5-l-1-gu.csv\",\n", - " # \"~/evokex-32-5-l-4-gu.csv\",\n", - " \"~/evokex-32-5-h-1-gu.csv\",\n", - " \"~/evokex-32-5-h-2-gu.csv\",\n", - "]\n", - "raw_data: pd.DataFrame = None\n", - "for output_path in output_paths:\n", - " tmp = pd.read_csv(output_path)\n", - " if \"stat\" in output_path:\n", - " tmp['tool'] = tmp['tool'].apply(lambda x: x + '-2')\n", - " if raw_data is None:\n", - " raw_data = tmp\n", - " else:\n", - " raw_data = pd.concat([raw_data, tmp])" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-03-01T16:32:45.606063906Z", - "start_time": "2024-03-01T16:32:45.593397049Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 29, - "outputs": [], - "source": [ - "raw_data['project'] = raw_data['benchmark'].apply(lambda x: x[:x.rindex('-')])" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-03-01T16:32:46.520076502Z", - "start_time": "2024-03-01T16:32:46.514876670Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 30, - "outputs": [], - "source": [ - "# some additional filters\n", - "\n", - "# raw_data = raw_data[raw_data['timeout'] == 120]" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-03-01T16:32:47.461125073Z", - "start_time": "2024-03-01T16:32:47.452069996Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 31, - "outputs": [ - { - "data": { - "text/plain": "450" - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(raw_data)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-03-01T16:32:47.745753432Z", - "start_time": "2024-03-01T16:32:47.734988358Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 32, - "outputs": [ - { - "data": { - "text/plain": "450" - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# filter out \"bad\" benchmarks\n", - "\n", - "tools = set(raw_data['tool'].unique())\n", - "timeouts = set(raw_data['timeout'].unique())\n", - "\n", - "grouped = raw_data.groupby('benchmark')\n", - "mask = grouped.apply(lambda x: len(x.drop_duplicates(subset=['tool', 'timeout'])) == len(tools) * len(timeouts))\n", - "raw_data = raw_data[raw_data['benchmark'].map(mask)]\n", - "\n", - "len(raw_data)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-03-01T16:32:48.175017733Z", - "start_time": "2024-03-01T16:32:48.154429048Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 19, - "outputs": [], - "source": [ - "print(\"Deleted benchmarks:\")\n", - "for bench in mask.index:\n", - " if not mask[bench]:\n", - " print(bench)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-03-01T16:12:09.353200624Z", - "start_time": "2024-03-01T16:12:09.350275078Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 20, - "outputs": [], - "source": [ - "data_indexed = raw_data.set_index(['tool', 'timeout', 'project'], drop=False).sort_index()" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-03-01T16:12:09.771778199Z", - "start_time": "2024-03-01T16:12:09.761793462Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 22, - "outputs": [], - "source": [ - "# calculate weighted statistics\n", - "\n", - "def get_weighted_stats(x, w=None, mn=None, mx=None, **kwargs):\n", - " stats = DescrStatsW(x, w, ddof=1)\n", - "\n", - " q1, q2, q3 = stats.quantile([0.25, 0.5, 0.75], return_pandas=False)\n", - " iqr = q3 - q1\n", - "\n", - " whishi = q3 + 1.5 * iqr\n", - " if mx is not None:\n", - " whishi = min(mx, whishi)\n", - "\n", - " whislo = q1 - 1.5 * iqr\n", - " if mn is not None:\n", - " whislo = max(mn, whislo)\n", - "\n", - " fliers = x.loc[(x > whishi) | (x < whislo)]\n", - "\n", - " return {\n", - " 'mean': stats.mean,\n", - " 'q1': q1,\n", - " 'med': q2,\n", - " 'q3': q3,\n", - " 'iqr': iqr,\n", - " 'whishi': whishi,\n", - " 'whislo': whislo,\n", - " 'fliers': list(fliers),\n", - " 'std': stats.std,\n", - " **kwargs\n", - " }\n" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-03-01T16:12:10.504107542Z", - "start_time": "2024-03-01T16:12:10.495076546Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 23, - "outputs": [], - "source": [ - "tools = list(data_indexed.index.unique(0))\n", - "timeouts = list(data_indexed.index.unique(1))\n", - "projects = list(data_indexed.index.unique(2))" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-03-01T16:12:11.053372548Z", - "start_time": "2024-03-01T16:12:11.033206893Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 24, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n", - "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", - " return np.sqrt(self.var)\n" - ] - } - ], - "source": [ - "# constructing the most interesting statistics\n", - "\n", - "def full_stats_dict():\n", - " return {\n", - " 'default': None,\n", - " 'weighted': None,\n", - " '1 / weighted': None,\n", - " }\n", - "\n", - "\n", - "def compute_stats_by(df: pd.DataFrame, name: str, mod: str, weighted: int) -> dict:\n", - " label = f'{name}_{mod}'\n", - " weights = None\n", - " if weighted == 1:\n", - " label += ' (w)'\n", - " weights = df[f'{name}_total']\n", - " elif weighted == 2:\n", - " label += ' (1/w)'\n", - " weights = 1. / (df[f'{name}_total'] + 1)\n", - " return get_weighted_stats(\n", - " df[f'{name}_{mod}_ratio'],\n", - " weights,\n", - " mn=0, mx=100,\n", - " label=label\n", - " )\n", - "\n", - "\n", - "def compute_stats(df: pd.DataFrame, weighted: int) -> dict:\n", - " return {\n", - " 'lines_coverage': compute_stats_by(df, 'lines', 'coverage', weighted),\n", - " 'branches_coverage': compute_stats_by(df, 'branches', 'coverage', weighted),\n", - " 'instructions_coverage': compute_stats_by(df, 'instructions', 'coverage', weighted),\n", - " 'complexity_coverage': compute_stats_by(df, 'complexity', 'coverage', weighted),\n", - " }\n", - "\n", - "\n", - "global_stats = defaultdict(\n", - " lambda: defaultdict(\n", - " lambda: {\n", - " 'projects': defaultdict(lambda: full_stats_dict()),\n", - " **full_stats_dict()\n", - " }\n", - " )\n", - ")\n", - "\n", - "for tool in tools:\n", - " for timeout in timeouts:\n", - " dt = data_indexed.loc[tool, timeout]\n", - " stats = global_stats[tool][timeout]\n", - " stats['default'] = compute_stats(dt, weighted=0)\n", - " stats['weighted'] = compute_stats(dt, weighted=1)\n", - " stats['1 / weighted'] = compute_stats(dt, weighted=2)\n", - "\n", - " stats = stats['projects']\n", - " for project in projects:\n", - " dt = data_indexed.loc[tool, timeout, project]\n", - " p_stats = stats[project]\n", - " p_stats['default'] = compute_stats(dt, weighted=0)\n", - " p_stats['weighted'] = compute_stats(dt, weighted=1)\n", - " p_stats['1 / weighted'] = compute_stats(dt, weighted=2)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-03-01T16:12:12.492936151Z", - "start_time": "2024-03-01T16:12:11.410651383Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 25, - "outputs": [ - { - "data": { - "text/plain": " lines lines (w) lines (1/w)\nproject timeout tool \nALL 120 evokex-16-15 60.418769 53.665019 67.356481\n evokex-16-15-u 56.137538 57.11247 58.73611\n evokex-32-15 60.648667 51.496716 67.741631\n evokex-32-5 62.405538 55.837221 66.003016\n evokex-32-5-g-1 57.460462 51.667707 63.664072\n... ... ... ...\nSPOON 120 evokex-32-5-l-2 47.353778 37.62918 49.666162\n evokex-32-5-l-3 38.6 26.749166 44.665612\n evokex-32-5-l-4 36.910222 26.555799 39.818599\n evokex-32-5-u 49.71 34.643456 56.918415\n evosuite-stat-2 45.914444 37.768948 50.945707\n\n[80 rows x 3 columns]", - "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
lineslines (w)lines (1/w)
projecttimeouttool
ALL120evokex-16-1560.41876953.66501967.356481
evokex-16-15-u56.13753857.1124758.73611
evokex-32-1560.64866751.49671667.741631
evokex-32-562.40553855.83722166.003016
evokex-32-5-g-157.46046251.66770763.664072
..................
SPOON120evokex-32-5-l-247.35377837.6291849.666162
evokex-32-5-l-338.626.74916644.665612
evokex-32-5-l-436.91022226.55579939.818599
evokex-32-5-u49.7134.64345656.918415
evosuite-stat-245.91444437.76894850.945707
\n

80 rows × 3 columns

\n
" - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# group statistics by tool, timeout and project\n", - "\n", - "table = pd.DataFrame(\n", - " index=pd.MultiIndex.from_product([['ALL'] + projects, timeouts, tools], names=['project', 'timeout', 'tool']),\n", - " columns=['lines', 'branches', 'instructions', 'complexity', 'lines (w)', 'branches (w)', 'instructions (w)', 'complexity (w)', 'lines (1/w)', 'branches (1/w)', 'instructions (1/w)', 'complexity (1/w)']\n", - ")\n", - "\n", - "metric = 'mean'\n", - "\n", - "def extract(x):\n", - " return [x['lines_coverage'][metric], x['branches_coverage'][metric], x['instructions_coverage'][metric],\n", - " x['complexity_coverage'][metric]]\n", - "\n", - "\n", - "for timeout in timeouts:\n", - " for tool in tools:\n", - " stats = global_stats[tool][timeout]\n", - " item = [*extract(stats['default']), *extract(stats['weighted']), *extract(stats['1 / weighted'])]\n", - " table.loc['ALL', timeout, tool] = item\n", - " for project in projects:\n", - " stats = global_stats[tool][timeout]['projects'][project]\n", - " item = [*extract(stats['default']), *extract(stats['weighted']), *extract(stats['1 / weighted'])]\n", - " table.loc[project, timeout, tool] = item\n", - "\n", - "table[[col for col in table if col.startswith('lines')]]" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-03-01T16:12:12.691551990Z", - "start_time": "2024-03-01T16:12:12.637517150Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 46, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tools: evokex-32-5\n", - "timeouts: 30, 120\n", - "projects: BYTEBUDDY, ERRORPRONE, JAVAPOET\n", - "metrics: lines_coverage, branches_coverage, instructions_coverage, complexity_coverage\n" - ] - } - ], - "source": [ - "metrics = [\n", - " 'lines_coverage',\n", - " 'branches_coverage',\n", - " 'instructions_coverage',\n", - " 'complexity_coverage',\n", - "]\n", - "\n", - "print('tools:', ', '.join(tools))\n", - "print('timeouts:', ', '.join([str(x) for x in timeouts]))\n", - "print('projects:', ', '.join(projects))\n", - "print('metrics:', ', '.join(metrics))" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-25T15:18:40.742973372Z", - "start_time": "2024-01-25T15:18:40.696415375Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 47, - "outputs": [], - "source": [ - "# stuff for boxplots\n", - "\n", - "def get_cmap(n, name='brg'):\n", - " return plt.colormaps.get_cmap(name).resampled(n)\n", - "\n", - "\n", - "def draw_boxplots(ax: plt.Axes, labels, mods, get_stats, width=0.07, gap=1):\n", - " colors = get_cmap(len(mods))\n", - " n = len(mods)\n", - " pos_diff = np.linspace(-n + 1, n - 1, n) * (width / 2)\n", - " x_tick_label = []\n", - " x_tick_position = []\n", - "\n", - " for i, label in enumerate(labels):\n", - " for j, mod in enumerate(mods):\n", - " x_tick_label.append(label)\n", - " x_tick_position.append(i * gap)\n", - " p = i * gap + pos_diff[j]\n", - "\n", - " stats = get_stats(label, mod)\n", - " bxp = ax.bxp([stats], widths=[width], patch_artist=True, positions=[p])\n", - " for box in bxp[\"boxes\"]:\n", - " box.update(dict(\n", - " facecolor=colors(j),\n", - " zorder=.9,\n", - " edgecolor='gray',\n", - " ))\n", - " if i == 0:\n", - " rect = plt.Rectangle((0, 0), 0, 0,\n", - " linewidth=0,\n", - " edgecolor='gray',\n", - " facecolor=colors(j),\n", - " label=mod)\n", - " ax.add_patch(rect)\n", - "\n", - " plt.xticks(x_tick_position, x_tick_label)\n" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-25T15:18:41.278816122Z", - "start_time": "2024-01-25T15:18:41.269215096Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 49, - "outputs": [], - "source": [ - "def draw_per_project(metric, weighted, tool):\n", - " fig, ax = plt.subplots(figsize=(9, 4))\n", - "\n", - " def get_stats(project, timeout):\n", - " stats = global_stats[tool][timeout]['projects'][project]\n", - " if weighted == 0:\n", - " stats = stats['default']\n", - " elif weighted == 1:\n", - " stats = stats['weighted']\n", - " else:\n", - " stats = stats['1 / weighted']\n", - " return stats[metric]\n", - "\n", - " draw_boxplots(ax, projects, timeouts, get_stats, 0.15)\n", - "\n", - " ax.legend(loc='upper left', title='timeouts (s)', bbox_to_anchor=(1, 1))\n", - " title = f'{tool}: {metric}'\n", - " if weighted == 1:\n", - " title += ' (w)'\n", - " elif weighted == 2:\n", - " title += ' (1/w)'\n", - " ax.set_title(title)\n" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-25T15:20:31.838805302Z", - "start_time": "2024-01-25T15:20:31.797906360Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 50, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# draw boxplots for each tool\n", - "\n", - "metric = 'lines_coverage'\n", - "for weighted in [0, 1, 2]:\n", - " for tool in tools:\n", - " draw_per_project(metric, weighted, tool)\n", - "plt.show()" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-01-25T15:20:32.763756589Z", - "start_time": "2024-01-25T15:20:32.299708304Z" - } - } - }, - { - "cell_type": "code", - "execution_count": 38, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "cHpndGNt1Rem" + }, + "source": [ + "### Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": { + "collapsed": true, + "id": "2RhGWcIVIZ88" + }, + "outputs": [], + "source": [ + "import os\n", + "import re\n", + "from collections import defaultdict\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from statsmodels.stats.weightstats import DescrStatsW\n", + "import random\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SQhFE5foMaeY", + "outputId": "fb977ecb-9e2c-4e3f-d4c2-7a5a88fe214e" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: dataclass-csv in /usr/local/lib/python3.10/dist-packages (1.4.0)\n" + ] + } + ], + "source": [ + "!pip install dataclass-csv" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "p53NEie8IkxV", + "outputId": "3742cf1a-bc65-4d26-dffa-cb44c5f39653" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n" + ] + } + ], + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6JRqTSLb1jtn" + }, + "source": [ + "### Define paths" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "metadata": { + "id": "4X_xVr2n-TQk" + }, + "outputs": [], + "source": [ + "output_paths = [\n", + " # \"/content/drive/MyDrive/master-guava-30\",\n", + " # \"/content/drive/MyDrive/full-no-mocks-guava-30\",\n", + " # \"/content/drive/MyDrive/full-with-mocks-guava-30\",\n", + " # \"/content/drive/MyDrive/simple-no-mocks-guava-30\",\n", + " # \"/content/drive/MyDrive/simple-with-mocks-guava-30\",\n", + " # \"/content/drive/MyDrive/noAA-benchmarks10-full\",\n", + " # \"/content/drive/MyDrive/noAA-transformer-seata-full\",\n", + " # \"/content/drive/MyDrive/stensgaardAA-benchmarks10-full\",\n", + " # \"/content/drive/MyDrive/mustAA-0_1-subset-full\",\n", + " # \"/content/drive/MyDrive/mustAA-0_25-subset-full\",\n", + " # \"/content/drive/MyDrive/mustAA-0_5-benchmarks10-full\",\n", + " # \"/content/drive/MyDrive/mustAA-plateau-subset-full\",\n", + " # \"/content/drive/MyDrive/master-benchmarks10-full\",\n", + " \"/content/drive/MyDrive/master-benchmarks11-full\",\n", + " # \"/content/drive/MyDrive/mustAA-0_1-benchmarks11-full\",\n", + " \"/content/drive/MyDrive/mustAA-plateau-benchmarks11-full\",\n", + " # \"/content/drive/MyDrive/mustAA-plateau-1-benchmarks11-full\",\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SG9NcLxd1L3l" + }, + "source": [ + "### Build csv" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "metadata": { + "id": "0K5Q4oEhL5C6" + }, + "outputs": [], + "source": [ + "import argparse\n", + "import re\n", + "import shutil\n", + "import subprocess\n", + "import tempfile\n", + "from dataclasses import dataclass\n", + "from pathlib import Path\n", + "from typing import List, Tuple, TextIO\n", + "from dataclass_csv import DataclassWriter\n", + "\n", + "@dataclass\n", + "class RawStatisticsItem:\n", + " tool: str\n", + " timeout: int\n", + " benchmark: str\n", + " run_number: int\n", + " cut: str\n", + "\n", + " tests: int\n", + " # uncompilable: int\n", + " # broken: int\n", + " failing: int\n", + "\n", + " instructions_total: int\n", + " instructions_covered: int\n", + " instructions_coverage_ratio: float\n", + "\n", + " lines_total: int\n", + " lines_covered: int\n", + " lines_coverage_ratio: float\n", + "\n", + " branches_total: int\n", + " branches_covered: int\n", + " branches_coverage_ratio: float\n", + "\n", + " complexity_total: int\n", + " complexity_covered: int\n", + " complexity_coverage_ratio: float\n", + "\n", + "\n", + "def parse_key_value(f: TextIO) -> Tuple[str, str]:\n", + " key, value = re.search(r'^([^:]+):\\s(.+)$', f.readline().strip()).groups()\n", + " return key, value\n", + "\n", + "\n", + "def parse_n_values(f: TextIO, n: int) -> List[str]:\n", + " return [parse_key_value(f)[1] for _ in range(n)]\n", + "\n", + "\n", + "def skip(f: TextIO, n: int):\n", + " for _ in range(n):\n", + " f.readline()\n", + "\n", + "\n", + "def parse_coverage_info(f: TextIO, name: str) -> tuple[str, str, str]:\n", + " try:\n", + " covered, total, ratio = re.search(fr'^(\\d+) of (\\d+) {name} covered = (\\d+\\.\\d+)%$', f.readline().strip()).groups()\n", + " return covered, total, ratio\n", + " except:\n", + " return '0', '0', '100.00'\n", + "\n", + "a = defaultdict(int)\n", + "\n", + "def parse_raw_statistics_items(arr: List[RawStatisticsItem], file: Path, tool):\n", + " tool, timeout = re.search(r'^(.+)-(\\d+)$', tool).groups()\n", + "\n", + " with open(file) as f:\n", + " line = f.readline()\n", + " while line:\n", + " if not line.startswith(\"Benchmark\"):\n", + " line = f.readline()\n", + " continue\n", + "\n", + " bench, run = re.search(r'^Benchmark (.+)_(\\d+)$', line.strip()).groups()\n", + " cut = re.search(r'Coverage of `(.+)` class:', f.readline().strip()).group(1)\n", + " cut = cut.replace('/', '.')\n", + "\n", + " instructions_covered, instructions_total, instructions_coverage_ratio = \\\n", + " parse_coverage_info(f, 'instructions')\n", + "\n", + " branches_covered, branches_total, branches_coverage_ratio = \\\n", + " parse_coverage_info(f, 'branches')\n", + "\n", + " lines_covered, lines_total, lines_coverage_ratio = \\\n", + " parse_coverage_info(f, 'lines')\n", + "\n", + " complexity_covered, complexity_total, complexity_coverage_ratio = \\\n", + " parse_coverage_info(f, 'complexity')\n", + "\n", + " tests, failing = re.search(r'^(\\d+) tests; (\\d+) failure$', f.readline().strip()).groups()\n", + "\n", + " a[timeout] += 1\n", + "\n", + " arr.append(RawStatisticsItem(\n", + " tool, int(timeout), bench, int(run), cut,\n", + " int(tests), int(failing),\n", + " int(instructions_total), int(instructions_covered), float(instructions_coverage_ratio),\n", + " int(lines_total), int(lines_covered), float(lines_coverage_ratio),\n", + " int(branches_total), int(branches_covered), float(branches_coverage_ratio),\n", + " int(complexity_total), int(complexity_covered), float(complexity_coverage_ratio),\n", + " ))\n", + "\n", + " line = f.readline()\n", + "\n", + "def find_files_with_name(directories, target_names):\n", + " matching_files = []\n", + "\n", + " print(directories, target_names)\n", + "\n", + " for directory in directories:\n", + " for root, dirs, files in os.walk(directory):\n", + " for file in files:\n", + " if file in target_names:\n", + " full_path = Path(os.path.join(root, file))\n", + " matching_files.append(full_path)\n", + "\n", + " return matching_files\n", + "\n", + "def build_csv(results_dir, output):\n", + " print('---- Run statistics collection', flush=True)\n", + "\n", + " arr: List[RawStatisticsItem] = []\n", + "\n", + " stats_files = find_files_with_name(results_dir, [\"30.log\", \"60.log\", \"120.log\"])\n", + " print(stats_files)\n", + " for i, file in enumerate(stats_files):\n", + " print(file)\n", + " timeout = file.name.split('.')[0]\n", + " tool = '-'.join(file.parent.name.split('-')[:-2])\n", + " parse_raw_statistics_items(arr, file, f\"{tool}-{timeout}\")\n", + "\n", + " with open(output, 'w', newline='') as f:\n", + " w = DataclassWriter(f, arr, RawStatisticsItem)\n", + " w.write()\n", + "\n", + " print('---- Statistics collection finished', flush=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nEujLzx7BJ3T", + "outputId": "7f234362-1045-40eb-890e-f6330d141e4f" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "---- Run statistics collection\n", + "['/content/drive/MyDrive/master-benchmarks11-full', '/content/drive/MyDrive/mustAA-plateau-benchmarks11-full'] ['30.log', '60.log', '120.log']\n", + "[PosixPath('/content/drive/MyDrive/master-benchmarks11-full/60.log'), PosixPath('/content/drive/MyDrive/master-benchmarks11-full/30.log'), PosixPath('/content/drive/MyDrive/master-benchmarks11-full/120.log'), PosixPath('/content/drive/MyDrive/mustAA-plateau-benchmarks11-full/120.log'), PosixPath('/content/drive/MyDrive/mustAA-plateau-benchmarks11-full/60.log'), PosixPath('/content/drive/MyDrive/mustAA-plateau-benchmarks11-full/30.log')]\n", + "/content/drive/MyDrive/master-benchmarks11-full/60.log\n", + "/content/drive/MyDrive/master-benchmarks11-full/30.log\n", + "/content/drive/MyDrive/master-benchmarks11-full/120.log\n", + "/content/drive/MyDrive/mustAA-plateau-benchmarks11-full/120.log\n", + "/content/drive/MyDrive/mustAA-plateau-benchmarks11-full/60.log\n", + "/content/drive/MyDrive/mustAA-plateau-benchmarks11-full/30.log\n", + "---- Statistics collection finished\n" + ] + } + ], + "source": [ + "build_csv(output_paths, \"evokex.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "metadata": { + "id": "FcFKi5kwH5I5", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ad98b75b-01ed-4096-a823-345a7af85709" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "defaultdict(, {'60': 600, '30': 600, '120': 600})\n" + ] + } + ], + "source": [ + "print(a)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "q9F_WOLj1oOZ" + }, + "source": [ + "### Build statistics" + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "metadata": { + "id": "re9mEhqqIZ89" + }, + "outputs": [], + "source": [ + "raw_data: pd.DataFrame = None\n", + "for output_path in output_paths:\n", + " tmp = pd.read_csv(\"evokex.csv\")\n", + " if \"stat\" in output_path:\n", + " tmp['tool'] = tmp['tool'].apply(lambda x: x + '-2')\n", + " if raw_data is None:\n", + " raw_data = tmp\n", + " else:\n", + " raw_data = pd.concat([raw_data, tmp])" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "metadata": { + "id": "LfSokGgIIZ8-" + }, + "outputs": [], + "source": [ + "raw_data['project'] = raw_data['benchmark'].apply(lambda x: x[:x.rindex('-')])" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7yQv1wD6IZ8_", + "outputId": "1c2bda1a-d464-4c8e-9167-92f5c032f472" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "3600\n" + ] + } + ], + "source": [ + "# filter out \"bad\" benchmarks\n", + "\n", + "tools = set(raw_data['tool'].unique())\n", + "timeouts = set(raw_data['timeout'].unique())\n", + "\n", + "grouped = raw_data.groupby('benchmark')\n", + "mask = grouped.apply(lambda x: len(x.drop_duplicates(subset=['tool', 'timeout'])) == len(tools) * len(timeouts))\n", + "raw_data = raw_data[raw_data['benchmark'].map(mask)]\n", + "\n", + "print(len(raw_data))" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "metadata": { + "id": "xlm0ODgcIZ9A", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "16eb5255-4ea9-48ae-def9-454989466ba9" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Deleted benchmarks:\n" + ] + } + ], + "source": [ + "print(\"Deleted benchmarks:\")\n", + "for bench in mask.index:\n", + " if not mask[bench]:\n", + " print(bench)" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": { + "id": "tVc98hq5IZ9A" + }, + "outputs": [], + "source": [ + "data_indexed = raw_data.set_index(['tool', 'timeout', 'project'], drop=False).sort_index()" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": { + "id": "n1hVu3bIIZ9B" + }, + "outputs": [], + "source": [ + "# calculate weighted statistics\n", + "\n", + "def get_weighted_stats(x, w=None, mn=None, mx=None, **kwargs):\n", + " stats = DescrStatsW(x, w, ddof=1)\n", + "\n", + " q1, q2, q3 = stats.quantile([0.25, 0.5, 0.75], return_pandas=False)\n", + " iqr = q3 - q1\n", + "\n", + " whishi = q3 + 1.5 * iqr\n", + " if mx is not None:\n", + " whishi = min(mx, whishi)\n", + "\n", + " whislo = q1 - 1.5 * iqr\n", + " if mn is not None:\n", + " whislo = max(mn, whislo)\n", + "\n", + " fliers = x.loc[(x > whishi) | (x < whislo)]\n", + "\n", + " return {\n", + " 'mean': stats.mean,\n", + " 'q1': q1,\n", + " 'med': q2,\n", + " 'q3': q3,\n", + " 'iqr': iqr,\n", + " 'whishi': whishi,\n", + " 'whislo': whislo,\n", + " 'fliers': list(fliers),\n", + " 'std': stats.std,\n", + " **kwargs\n", + " }\n" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": { + "id": "9OgBO4AEIZ9B" + }, + "outputs": [], + "source": [ + "tools = list(data_indexed.index.unique(0))\n", + "timeouts = list(data_indexed.index.unique(1))\n", + "projects = list(data_indexed.index.unique(2))" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "metadata": { + "collapsed": true, + "id": "guPMw5D3IZ9B", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "01609763-5a64-4d3e-f4a2-5cbc3e4ebdf2" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", + " return np.sqrt(self.var)\n", + "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", + " return np.sqrt(self.var)\n", + "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", + " return np.sqrt(self.var)\n", + "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", + " return np.sqrt(self.var)\n", + "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", + " return np.sqrt(self.var)\n", + "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", + " return np.sqrt(self.var)\n", + "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", + " return np.sqrt(self.var)\n", + "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", + " return np.sqrt(self.var)\n", + "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", + " return np.sqrt(self.var)\n", + "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", + " return np.sqrt(self.var)\n", + "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", + " return np.sqrt(self.var)\n", + "/usr/local/lib/python3.10/dist-packages/statsmodels/stats/weightstats.py:196: RuntimeWarning: invalid value encountered in sqrt\n", + " return np.sqrt(self.var)\n" + ] + } + ], + "source": [ + "# constructing the most interesting statistics\n", + "\n", + "def full_stats_dict():\n", + " return {\n", + " 'default': None,\n", + " 'weighted': None,\n", + " '1 / weighted': None,\n", + " }\n", + "\n", + "\n", + "def compute_stats_by(df: pd.DataFrame, name: str, mod: str, weighted: int) -> dict:\n", + " label = f'{name}_{mod}'\n", + " weights = None\n", + " if weighted == 1:\n", + " label += ' (w)'\n", + " weights = df[f'{name}_total']\n", + " elif weighted == 2:\n", + " label += ' (1/w)'\n", + " weights = 1. / (df[f'{name}_total'] + 1)\n", + " return get_weighted_stats(\n", + " df[f'{name}_{mod}_ratio'],\n", + " weights,\n", + " mn=0, mx=100,\n", + " label=label\n", + " )\n", + "\n", + "\n", + "def compute_stats(df: pd.DataFrame, weighted: int) -> dict:\n", + " return {\n", + " 'lines_coverage': compute_stats_by(df, 'lines', 'coverage', weighted),\n", + " 'branches_coverage': compute_stats_by(df, 'branches', 'coverage', weighted),\n", + " 'instructions_coverage': compute_stats_by(df, 'instructions', 'coverage', weighted),\n", + " 'complexity_coverage': compute_stats_by(df, 'complexity', 'coverage', weighted),\n", + " }\n", + "\n", + "\n", + "global_stats = defaultdict(\n", + " lambda: defaultdict(\n", + " lambda: {\n", + " 'projects': defaultdict(lambda: full_stats_dict()),\n", + " **full_stats_dict()\n", + " }\n", + " )\n", + ")\n", + "\n", + "for tool in tools:\n", + " for timeout in timeouts:\n", + " dt = data_indexed.loc[tool, timeout]\n", + " stats = global_stats[tool][timeout]\n", + " stats['default'] = compute_stats(dt, weighted=0)\n", + " stats['weighted'] = compute_stats(dt, weighted=1)\n", + " stats['1 / weighted'] = compute_stats(dt, weighted=2)\n", + "\n", + " stats = stats['projects']\n", + " for project in projects:\n", + " dt = data_indexed.loc[tool, timeout, project]\n", + " p_stats = stats[project]\n", + " p_stats['default'] = compute_stats(dt, weighted=0)\n", + " p_stats['weighted'] = compute_stats(dt, weighted=1)\n", + " p_stats['1 / weighted'] = compute_stats(dt, weighted=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "metadata": { + "id": "jXgUN3O8IZ9C", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "eebd18ba-cd34-4bc8-85fd-0365f58eca6d" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " lines lines (w) lines (1/w)\n", + "project timeout tool \n", + "ALL 30 master 85.9281 76.897803 90.696802\n", + " mustAA-plateau 83.931767 77.101606 89.487538\n", + " 60 master 87.027267 84.087588 88.022689\n", + " mustAA-plateau 85.335733 81.082321 87.957442\n", + " 120 master 87.169067 85.016083 87.622917\n", + " mustAA-plateau 85.911667 83.617974 87.628205\n", + "COLLECTIONS 30 master 79.093333 61.369776 83.197641\n", + " mustAA-plateau 76.185333 57.557135 81.623248\n", + " 60 master 85.576667 72.489333 85.162658\n", + " mustAA-plateau 86.218133 73.196247 85.578936\n", + " 120 master 86.736667 75.959466 85.292884\n", + " mustAA-plateau 87.434933 76.30176 85.844289\n", + "JSOUP 30 master 83.170952 76.754586 90.503209\n", + " mustAA-plateau 85.44 86.841998 90.34939\n", + " 60 master 87.695714 89.232168 91.419098\n", + " mustAA-plateau 86.852619 88.814335 90.95302\n", + " 120 master 89.352857 91.954558 91.815844\n", + " mustAA-plateau 89.045714 91.815768 91.678713\n", + "SPATIAL4J 30 master 91.915128 88.351818 95.749712\n", + " mustAA-plateau 74.876667 70.328819 83.126808\n", + " 60 master 88.607179 84.470009 93.742971\n", + " mustAA-plateau 80.554615 76.294293 84.70011\n", + " 120 master 89.780513 85.448242 94.737971\n", + " mustAA-plateau 84.509231 81.092153 89.466418\n", + "TA4J 30 master 91.223778 90.893414 92.017541\n", + " mustAA-plateau 90.417333 89.749496 91.214909\n", + " 60 master 84.204111 86.912423 83.30795\n", + " mustAA-plateau 86.987556 89.581199 85.480717\n", + " 120 master 84.522556 88.141156 82.353337\n", + " mustAA-plateau 84.143889 87.039564 83.402791\n", + "THREETEN-EXTRA 30 master 84.415185 76.757052 96.116309\n", + " mustAA-plateau 89.248148 83.163639 97.480171\n", + " 60 master 92.086296 87.897387 98.095235\n", + " mustAA-plateau 83.63037 76.92676 95.637868\n", + " 120 master 88.595926 82.511304 97.277111\n", + " mustAA-plateau 85.317593 79.364878 96.065844" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
lineslines (w)lines (1/w)
projecttimeouttool
ALL30master85.928176.89780390.696802
mustAA-plateau83.93176777.10160689.487538
60master87.02726784.08758888.022689
mustAA-plateau85.33573381.08232187.957442
120master87.16906785.01608387.622917
mustAA-plateau85.91166783.61797487.628205
COLLECTIONS30master79.09333361.36977683.197641
mustAA-plateau76.18533357.55713581.623248
60master85.57666772.48933385.162658
mustAA-plateau86.21813373.19624785.578936
120master86.73666775.95946685.292884
mustAA-plateau87.43493376.3017685.844289
JSOUP30master83.17095276.75458690.503209
mustAA-plateau85.4486.84199890.34939
60master87.69571489.23216891.419098
mustAA-plateau86.85261988.81433590.95302
120master89.35285791.95455891.815844
mustAA-plateau89.04571491.81576891.678713
SPATIAL4J30master91.91512888.35181895.749712
mustAA-plateau74.87666770.32881983.126808
60master88.60717984.47000993.742971
mustAA-plateau80.55461576.29429384.70011
120master89.78051385.44824294.737971
mustAA-plateau84.50923181.09215389.466418
TA4J30master91.22377890.89341492.017541
mustAA-plateau90.41733389.74949691.214909
60master84.20411186.91242383.30795
mustAA-plateau86.98755689.58119985.480717
120master84.52255688.14115682.353337
mustAA-plateau84.14388987.03956483.402791
THREETEN-EXTRA30master84.41518576.75705296.116309
mustAA-plateau89.24814883.16363997.480171
60master92.08629687.89738798.095235
mustAA-plateau83.6303776.9267695.637868
120master88.59592682.51130497.277111
mustAA-plateau85.31759379.36487896.065844
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"table[[col for col in table if col\",\n \"rows\": 36,\n \"fields\": [\n {\n \"column\": \"lines\",\n \"properties\": {\n \"dtype\": \"date\",\n \"min\": 74.87666666666665,\n \"max\": 92.0862962962963,\n \"num_unique_values\": 36,\n \"samples\": [\n 85.31759259259259,\n 85.44000000000003,\n 84.2041111111111\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"lines (w)\",\n \"properties\": {\n \"dtype\": \"date\",\n \"min\": 57.557134703196354,\n \"max\": 91.95455846422338,\n \"num_unique_values\": 36,\n \"samples\": [\n 79.36487811791383,\n 86.84199825479931,\n 86.91242270224481\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"lines (1/w)\",\n \"properties\": {\n \"dtype\": \"date\",\n \"min\": 81.62324803785259,\n \"max\": 98.09523520365704,\n \"num_unique_values\": 36,\n \"samples\": [\n 96.06584393022521,\n 90.34939008848494,\n 83.30795021391714\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 168 + } + ], + "source": [ + "# group statistics by tool, timeout and project\n", + "\n", + "table = pd.DataFrame(\n", + " index=pd.MultiIndex.from_product([['ALL'] + projects, timeouts, tools], names=['project', 'timeout', 'tool']),\n", + " columns=['lines', 'branches', 'instructions', 'complexity', 'lines (w)', 'branches (w)', 'instructions (w)', 'complexity (w)', 'lines (1/w)', 'branches (1/w)', 'instructions (1/w)', 'complexity (1/w)']\n", + ")\n", + "\n", + "metric = 'mean'\n", + "\n", + "def extract(x):\n", + " return [x['lines_coverage'][metric], x['branches_coverage'][metric], x['instructions_coverage'][metric],\n", + " x['complexity_coverage'][metric]]\n", + "\n", + "\n", + "for timeout in timeouts:\n", + " for tool in tools:\n", + " stats = global_stats[tool][timeout]\n", + " item = [*extract(stats['default']), *extract(stats['weighted']), *extract(stats['1 / weighted'])]\n", + " table.loc['ALL', timeout, tool] = item\n", + " for project in projects:\n", + " stats = global_stats[tool][timeout]['projects'][project]\n", + " item = [*extract(stats['default']), *extract(stats['weighted']), *extract(stats['1 / weighted'])]\n", + " table.loc[project, timeout, tool] = item\n", + "\n", + "table[[col for col in table if col.startswith('lines')]]" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "metadata": { + "id": "vuM2HKHDIZ9C", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "c00522c7-ed95-4880-f88c-9fd59ede1453" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tools: master, mustAA-plateau\n", + "timeouts: 30, 60, 120\n", + "projects: COLLECTIONS, JSOUP, SPATIAL4J, TA4J, THREETEN-EXTRA\n", + "metrics: lines_coverage, branches_coverage, instructions_coverage, complexity_coverage\n" + ] + } + ], + "source": [ + "metrics = [\n", + " 'lines_coverage',\n", + " 'branches_coverage',\n", + " 'instructions_coverage',\n", + " 'complexity_coverage',\n", + "]\n", + "\n", + "print('tools:', ', '.join(tools))\n", + "print('timeouts:', ', '.join([str(x) for x in timeouts]))\n", + "print('projects:', ', '.join(projects))\n", + "print('metrics:', ', '.join(metrics))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HVcw57dp2JoH" + }, + "source": [ + "### Draw coverage comparison plots" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": { + "id": "loiQL3OgIZ9C" + }, + "outputs": [], + "source": [ + "# stuff for boxplots\n", + "\n", + "def get_cmap(n, name='brg'):\n", + " return plt.colormaps.get_cmap(name).resampled(n)\n", + "\n", + "\n", + "def draw_boxplots(ax: plt.Axes, labels, mods, get_stats, width=0.07, gap=1):\n", + " colors = get_cmap(len(mods))\n", + " n = len(mods)\n", + " pos_diff = np.linspace(-n + 1, n - 1, n) * (width / 2)\n", + " x_tick_label = []\n", + " x_tick_position = []\n", + "\n", + " for i, label in enumerate(labels):\n", + " for j, mod in enumerate(mods):\n", + " x_tick_label.append(label)\n", + " x_tick_position.append(i * gap)\n", + " p = i * gap + pos_diff[j]\n", + "\n", + " stats = get_stats(label, mod)\n", + " bxp = ax.bxp([stats], widths=[width], patch_artist=True, positions=[p])\n", + " for box in bxp[\"boxes\"]:\n", + " box.update(dict(\n", + " facecolor=colors(j),\n", + " zorder=.9,\n", + " edgecolor='gray',\n", + " ))\n", + " if i == 0:\n", + " rect = plt.Rectangle((0, 0), 0, 0,\n", + " linewidth=0,\n", + " edgecolor='gray',\n", + " facecolor=colors(j),\n", + " label=mod)\n", + " ax.add_patch(rect)\n", + "\n", + " plt.xticks(x_tick_position, x_tick_label)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "metadata": { + "id": "OFnCZFG6IZ9D" + }, + "outputs": [], + "source": [ + "def draw_per_project(metric, weighted):\n", + " fig, ax = plt.subplots(figsize=(15, 10))\n", + "\n", + " def get_stats(project, tool_timeout):\n", + " tool, timeout = tool_timeout.split('-')\n", + " timeout = int(timeout)\n", + " tool = tool.replace('$', '-')\n", + " stats = global_stats[tool][timeout]['projects'][project]\n", + " if weighted == 0:\n", + " stats = stats['default']\n", + " elif weighted == 1:\n", + " stats = stats['weighted']\n", + " else:\n", + " stats = stats['1 / weighted']\n", + " return stats[metric]\n", + "\n", + " labels = [f'{tool.replace(\"-\", \"$\")}-{timeout}' for timeout in timeouts for tool in tools ]\n", + " draw_boxplots(ax, projects, labels, get_stats, 0.15)\n", + "\n", + " ax.legend(loc='upper left', title='timeouts (s)', bbox_to_anchor=(1, 1))\n", + " title = f'{metric}'\n", + " if weighted == 1:\n", + " title += ' (w)'\n", + " elif weighted == 2:\n", + " title += ' (1/w)'\n", + " ax.set_title(title)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "metadata": { + "id": "x0IDui5mKhx1", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "d71a03be-c40a-4948-c8d0-ff3c5634b71a" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "# for metric in metrics:\n", + "for weighted in [0, 1, 2]:\n", + " draw_per_project('lines_coverage', weighted)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ESokZysY2SlC" + }, + "source": [ + "### Build concolic mutation statistics" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": { + "id": "4Gc31knw8C_g" + }, + "outputs": [], + "source": [ + "statistics_items = ['Number of total mutations',\n", + " 'Number of collected tests before concolic mutations',\n", + " 'Number of concolic mutations',\n", + " 'Number of success concolic mutations',\n", + " 'Number of timeout for concolic mutation',\n", + " 'Total time for concolic mutation',\n", + " 'Number of irreversible for concolic mutation',\n", + " 'Number of unsupported tests for concolic mutation (mocks)',\n", + " 'Number of unsupported tests for concolic mutation (EnviromentDataStatement)',\n", + " 'Number of covered tests before concolic mutation',\n", + " 'Number of unsats concolic mutation',\n", + " 'Number of sats concolic mutation',\n", + " 'Total time for of unsats concolic mutation',\n", + " 'Total time for of sats concolic mutation',\n", + " 'Number of Kex calls'\n", + " ]" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": { + "collapsed": true, + "id": "OJjyEcAPUCdL" + }, + "outputs": [], + "source": [ + "raw_statistics = {\n", + " item: {\n", + " tool: {\n", + " timeout: {\n", + " project: []\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " }\n", + " for item in statistics_items\n", + "}\n", + "for path in output_paths:\n", + " tool = '-'.join(path.split('/')[-1].split('-')[:-2])\n", + " for root, dirs, files in os.walk(path):\n", + " for filename in files:\n", + " cur = {\n", + " key: []\n", + " for key in raw_statistics.keys()\n", + " }\n", + " if filename == 'work-stat.log':\n", + " with open(os.path.join(root, filename), \"r\") as f:\n", + " lines = filter(lambda l: l.startswith(\"Concolic mutation:\"), f.readlines())\n", + " for line in lines:\n", + " n = int(re.search(r'[\\d]+', line).group())\n", + " if line.startswith(\"Concolic mutation: ================== \"):\n", + " continue\n", + " else:\n", + " cur[line.split(': ')[1]].append(n)\n", + " for key in cur.keys():\n", + " ds = root.split('/')\n", + " timeout = int(list(filter(lambda d: d.startswith('evokex'), ds))[-1].split('-')[1])\n", + " if timeout not in timeouts:\n", + " continue\n", + " project = '-'.join(ds[-1].split('-')[:-1])\n", + " raw_statistics[key][tool][timeout][project].append(cur[key])" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": { + "id": "WQZW2ieii-Pg" + }, + "outputs": [], + "source": [ + "statistics = {\n", + " key: {\n", + " tool: {\n", + " timeout: {\n", + " project: []\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " } for key in raw_statistics.keys()\n", + "}\n", + "\n", + "statistics['Number of epochs'] = {\n", + " tool: {\n", + " timeout: {\n", + " project: []\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + "}\n", + "\n", + "for key in raw_statistics.keys():\n", + " for tool in tools:\n", + " for timeout in timeouts:\n", + " for project in projects:\n", + " for i in range(len(raw_statistics[key][tool][timeout][project])):\n", + " statistics[key][tool][timeout][project].append(sum(raw_statistics[key][tool][timeout][project][i]))\n", + " statistics['Number of epochs'][tool][timeout][project].append(len(raw_statistics[key][tool][timeout][project][i]))" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": { + "id": "eFdAPDA8z2ep" + }, + "outputs": [], + "source": [ + "ratios = {\n", + " \"Percentage of collected tests before concolic mutation\": {\n", + " tool: {\n", + " timeout: {\n", + " project: [number_collected / number_concolic if number_concolic != 0 else None\n", + " for number_concolic, number_collected in\n", + " zip(statistics['Number of concolic mutations'][tool][timeout][project],\n", + " statistics[\"Number of collected tests before concolic mutations\"][tool][timeout][project])]\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + " \"Percentage of tests with mocks for concolic mutation\": {\n", + " tool: {\n", + " timeout: {\n", + " project: [number_mock / number_concolic if number_concolic != 0 else None\n", + " for number_concolic, number_mock in\n", + " zip(statistics['Number of concolic mutations'][tool][timeout][project],\n", + " statistics['Number of unsupported tests for concolic mutation (mocks)'][tool][timeout][project])]\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + " \"Percentage of tests with EnviromentDataStatement for concolic mutation\": {\n", + " tool: {\n", + " timeout: {\n", + " project: [number_mock / number_concolic if number_concolic != 0 else None\n", + " for number_concolic, number_mock in\n", + " zip(statistics['Number of concolic mutations'][tool][timeout][project],\n", + " statistics['Number of unsupported tests for concolic mutation (EnviromentDataStatement)'][tool][timeout][project])]\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + " \"Percentage of already covered tests for concolic mutation\": {\n", + " tool: {\n", + " timeout: {\n", + " project: [number_covered / number_concolic if number_concolic != 0 else None\n", + " for number_concolic, number_covered in\n", + " zip(statistics['Number of concolic mutations'][tool][timeout][project],\n", + " statistics[\"Number of covered tests before concolic mutation\"][tool][timeout][project])]\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + " \"Percentage of succesful concolic mutations\": {\n", + " tool: {\n", + " timeout: {\n", + " project: [number_succesful / (number_concolic - number_mock - number_enviroment - number_irreversible - number_covered) if number_concolic != number_mock + number_enviroment + number_irreversible + number_covered else None\n", + " for number_succesful, number_irreversible, number_concolic, number_covered, number_mock, number_enviroment in\n", + " zip(statistics['Number of success concolic mutations'][tool][timeout][project],\n", + " statistics['Number of irreversible for concolic mutation'][tool][timeout][project],\n", + " statistics['Number of concolic mutations'][tool][timeout][project],\n", + " statistics['Number of covered tests before concolic mutation'][tool][timeout][project],\n", + " statistics['Number of unsupported tests for concolic mutation (mocks)'][tool][timeout][project],\n", + " statistics['Number of unsupported tests for concolic mutation (EnviromentDataStatement)'][tool][timeout][project])]\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + " \"Percentage of timeouted concolic mutations\": {\n", + " tool: {\n", + " timeout: {\n", + " project: [number_timeout / number_reversible if number_reversible != 0 else None\n", + " for number_reversible, number_timeout in\n", + " zip(statistics['Number of concolic mutations'][tool][timeout][project],\n", + " statistics['Number of timeout for concolic mutation'][tool][timeout][project])]\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + " \"Percentage of irreversible concolic mutations\": {\n", + " tool: {\n", + " timeout: {\n", + " project: [number_irreversible / number_concolic if number_concolic != 0 else None\n", + " for number_concolic, number_irreversible in\n", + " zip(statistics['Number of concolic mutations'][tool][timeout][project],\n", + " statistics['Number of irreversible for concolic mutation'][tool][timeout][project])]\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + " \"Average time for concolic mutation\": {\n", + " tool: {\n", + " timeout: {\n", + " project: [total_time / number_concolic if number_concolic != 0 else None\n", + " for number_concolic, total_time in\n", + " zip(statistics['Number of concolic mutations'][tool][timeout][project],\n", + " statistics['Total time for concolic mutation'][tool][timeout][project])]\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + " \"Percentage of unsats concolic mutations\": {\n", + " tool: {\n", + " timeout: {\n", + " project: [number_unsat / (number_concolic - number_mock - number_enviroment - number_irreversible - number_covered) if number_concolic != number_mock + number_enviroment + number_irreversible + number_covered else None\n", + " for number_unsat, number_irreversible, number_concolic, number_covered, number_mock, number_enviroment in\n", + " zip(statistics['Number of unsats concolic mutation'][tool][timeout][project],\n", + " statistics['Number of irreversible for concolic mutation'][tool][timeout][project],\n", + " statistics['Number of concolic mutations'][tool][timeout][project],\n", + " statistics['Number of covered tests before concolic mutation'][tool][timeout][project],\n", + " statistics['Number of unsupported tests for concolic mutation (mocks)'][tool][timeout][project],\n", + " statistics['Number of unsupported tests for concolic mutation (EnviromentDataStatement)'][tool][timeout][project])]\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + " \"Percentage of sats concolic mutations\": {\n", + " tool: {\n", + " timeout: {\n", + " project: [number_sat / (number_concolic - number_mock - number_enviroment - number_irreversible - number_covered) if number_concolic != number_mock + number_enviroment + number_irreversible + number_covered else None\n", + " for number_sat, number_irreversible, number_concolic, number_covered, number_mock, number_enviroment in\n", + " zip(statistics['Number of sats concolic mutation'][tool][timeout][project],\n", + " statistics['Number of irreversible for concolic mutation'][tool][timeout][project],\n", + " statistics['Number of concolic mutations'][tool][timeout][project],\n", + " statistics['Number of covered tests before concolic mutation'][tool][timeout][project],\n", + " statistics['Number of unsupported tests for concolic mutation (mocks)'][tool][timeout][project],\n", + " statistics['Number of unsupported tests for concolic mutation (EnviromentDataStatement)'][tool][timeout][project])]\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + " \"Average time for sat\": {\n", + " tool: {\n", + " timeout: {\n", + " project: [total_time / number_sat if number_sat != 0 else None\n", + " for number_sat, total_time in\n", + " zip(statistics['Number of sats concolic mutation'][tool][timeout][project],\n", + " statistics['Total time for of sats concolic mutation'][tool][timeout][project])]\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + "\n", + " \"Average time for unsat\": {\n", + " tool: {\n", + " timeout: {\n", + " project: [total_time / number_unsat if number_unsat != 0 else None\n", + " for number_unsat, total_time in\n", + " zip(statistics['Number of unsats concolic mutation'][tool][timeout][project],\n", + " statistics['Total time for of unsats concolic mutation'][tool][timeout][project])]\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + "\n", + " \"Percentage of Kex calls\": {\n", + " tool: {\n", + " timeout: {\n", + " project: [number_kex / number_concolic if number_concolic != 0 else None\n", + " for number_kex, number_concolic in\n", + " zip(statistics['Number of Kex calls'][tool][timeout][project],\n", + " statistics['Number of concolic mutations'][tool][timeout][project])]\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + "\n", + " \"Average number of epochs\": {\n", + " tool: {\n", + " timeout: {\n", + " project: [number_epochs for number_epochs in statistics['Number of epochs'][tool][timeout][project]]\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + "\n", + " \"Percentage of increases\": {\n", + " tool: {\n", + " timeout: {\n", + " project: []\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " },\n", + "\n", + "}\n", + "\n", + "\n", + "for path in output_paths:\n", + " for root, dirs, files in os.walk(path):\n", + " for filename in files:\n", + " if filename == 'work-stat.log':\n", + " data = []\n", + " positive = 0\n", + " all = 0\n", + " need_to_check = False\n", + " with open(os.path.join(root, filename)) as f:\n", + " for line in f:\n", + " result = re.search(r\"^Coverage: (\\d+)/(\\d+)\", line)\n", + " if result is not None:\n", + " a, b = result.groups()\n", + " data.append(int(a) / int(b))\n", + " if need_to_check:\n", + " if (len(data) >= 2) and (data[-1] > data[-2]):\n", + " positive += 1\n", + " all += 1\n", + " need_to_check = False\n", + " else:\n", + " result = re.search(r\"^Concolic mutation: Number of Kex calls: (\\w+)\", line)\n", + " if result is not None:\n", + " t = int(result.groups()[0])\n", + " if t != 0:\n", + " need_to_check = True\n", + "\n", + " tool = '-'.join(path.split('/')[-1].split('-')[:-2])\n", + " timeout = int(list(filter(lambda d: d.startswith('evokex'), root.split('/')))[-1].split('-')[1])\n", + " project = \"-\".join(root.split('/')[-1].split('-')[:-1])\n", + " ratios['Percentage of increases'][tool][timeout][project].append(positive / all if all != 0 else None)\n", + "\n", + "for key in ratios.keys():\n", + " for tool in tools:\n", + " for t in timeouts:\n", + " for p in projects:\n", + " ratios[key][tool][t][p] = list(filter(lambda x: x is not None, ratios[key][tool][t][p]))" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": { + "id": "p1wzIy4t251B" + }, + "outputs": [], + "source": [ + "ignore_keys = [\n", + " # 'Percentage of tests with EnviromentDataStatement for concolic mutation',\n", + " # 'Percentage of already covered tests for concolic mutation',\n", + " # 'Percentage of sats concolic mutations',\n", + " # 'Percentage of unsats concolic mutations',\n", + " # 'Average time for unsat',\n", + " # 'Average time for sat',\n", + "]\n", + "for key in ignore_keys:\n", + " ratios.pop(key, None)" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": { + "id": "y-DglikCMsgQ" + }, + "outputs": [], + "source": [ + "import json\n", + "for path in output_paths:\n", + " with open(os.path.join(path, \"ratios.json\"), \"w\") as f:\n", + " tool = '-'.join(path.split('/')[-1].split('-')[:-2])\n", + " a = {key: ratios[key][tool] for key in ratios.keys()}\n", + " json.dump(a, f)\n", + " with open(os.path.join(path, \"statistics.json\"), \"w\") as f:\n", + " tool = '-'.join(path.split('/')[-1].split('-')[:-2])\n", + " a = {key: statistics[key][tool] for key in statistics.keys()}\n", + " json.dump(a, f)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fUlxLozRMo5f" + }, + "source": [ + "### Load statistics for concolic mutation" + ] + }, + { + "cell_type": "code", + "execution_count": 173, + "metadata": { + "id": "e9vRu8BpMoRA" + }, + "outputs": [], + "source": [ + "statistics = {\n", + " item: {\n", + " tool: {\n", + " timeout: {\n", + " project: []\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " }\n", + " for item in statistics_items\n", + "}\n", + "\n", + "ratios_keys = [\n", + " \"Percentage of collected tests before concolic mutation\",\n", + " \"Percentage of tests with mocks for concolic mutation\",\n", + " \"Percentage of tests with EnviromentDataStatement for concolic mutation\",\n", + " \"Percentage of already covered tests for concolic mutation\",\n", + " \"Percentage of succesful concolic mutations\",\n", + " \"Percentage of timeouted concolic mutations\",\n", + " \"Percentage of irreversible concolic mutations\",\n", + " \"Average time for concolic mutation\",\n", + " \"Percentage of unsats concolic mutations\",\n", + " \"Percentage of sats concolic mutations\",\n", + " \"Average time for sat\",\n", + " \"Average time for unsat\",\n", + " \"Percentage of Kex calls\",\n", + " \"Average number of epochs\",\n", + " \"Percentage of increases\"\n", + "]\n", + "\n", + "ratios = {\n", + " item: {\n", + " tool: {\n", + " timeout: {\n", + " project: []\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + " }\n", + " for item in ratios_keys\n", + "}\n", + "\n", + "import json\n", + "for path in output_paths:\n", + " with open(os.path.join(path, \"ratios.json\")) as f:\n", + " tool = '-'.join(path.split('/')[-1].split('-')[:-2])\n", + " data = json.load(f)\n", + " for key in ratios.keys():\n", + " for timeout in timeouts:\n", + " ratios[key][tool][timeout] = data[key][str(timeout)]\n", + " with open(os.path.join(path, \"statistics.json\")) as f:\n", + " tool = '-'.join(path.split('/')[-1].split('-')[:-2])\n", + " data = json.load(f)\n", + " for key in statistics.keys():\n", + " for timeout in timeouts:\n", + " statistics[key][tool][timeout] = data[key][str(timeout)]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "p91gsozn2ZJq" + }, + "source": [ + "### Draw concolic mutation statistics plots" + ] + }, + { + "cell_type": "code", + "execution_count": 174, + "metadata": { + "id": "aOecZPovcuio" + }, + "outputs": [], + "source": [ + "# new_ratios = {\n", + "# key: {\n", + "# tool: {\n", + "# timeout: []\n", + "# for timeout in timeouts\n", + "# }\n", + "# for tool in tools\n", + "# } for key in ratios.keys()\n", + "# }\n", + "# for key in ratios.keys():\n", + "# for tool in tools:\n", + "# for timeout in timeouts:\n", + "# res = []\n", + "# for project in [\"GUAVA\", \"FASTJSON\"]:\n", + "# res += ratios[key][tool][timeout][project]\n", + "# new_ratios[key][tool][timeout] = res" + ] + }, + { + "cell_type": "code", + "execution_count": 175, + "metadata": { + "id": "ZBvH20Y3ByNw", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 292 + }, + "outputId": "ddb43509-1c55-4fb1-a4ed-76609f3bcca5" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "def generate_random_color():\n", + " return np.random.rand(3,)\n", + "\n", + "timeout_colors = {timeout: generate_random_color() for timeout in timeouts}\n", + "\n", + "for i, metric in enumerate(ratios.keys()):\n", + " fig, ax = plt.subplots(figsize=(15, 10))\n", + " box_data = []\n", + " box_labels = []\n", + " timeout_color_mapping = {}\n", + "\n", + " for tool in tools:\n", + " for project in projects:\n", + " for timeout in timeouts:\n", + " if tool == 'master':\n", + " continue\n", + "\n", + " box_data.append(ratios[metric][tool][timeout][project])\n", + " box_labels.append(f\"{tool}-{project}-{timeout}\")\n", + " if timeout not in timeout_color_mapping:\n", + " timeout_color_mapping[timeout] = timeout_colors[timeout]\n", + "\n", + " # Plotting with color for each timeout\n", + " bp = ax.boxplot(box_data, labels=box_labels, patch_artist=True, boxprops=dict(facecolor='lightgray', color='black'), medianprops=dict(color='black'))\n", + "\n", + " # Apply colors based on timeout\n", + " for i, box in enumerate(bp['boxes']):\n", + " timeout = timeouts[i % len(timeouts)]\n", + " box.set_facecolor(timeout_color_mapping[timeout])\n", + "\n", + " ax.set_title(metric)\n", + " ax.set_xticklabels(box_labels, rotation=90)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "metadata": { + "id": "SptV35IiIhCV", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "b32e82de-50a1-40ac-b2da-d984f81b3233" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'master': {30: {'COLLECTIONS': 0,\n", + " 'JSOUP': 0,\n", + " 'SPATIAL4J': 0,\n", + " 'TA4J': 0,\n", + " 'THREETEN-EXTRA': 0},\n", + " 60: {'COLLECTIONS': 0,\n", + " 'JSOUP': 0,\n", + " 'SPATIAL4J': 0,\n", + " 'TA4J': 0,\n", + " 'THREETEN-EXTRA': 0},\n", + " 120: {'COLLECTIONS': 0,\n", + " 'JSOUP': 0,\n", + " 'SPATIAL4J': 0,\n", + " 'TA4J': 0,\n", + " 'THREETEN-EXTRA': 0}},\n", + " 'mustAA-plateau': {30: {'COLLECTIONS': 10,\n", + " 'JSOUP': 22,\n", + " 'SPATIAL4J': 64,\n", + " 'TA4J': 12,\n", + " 'THREETEN-EXTRA': 122},\n", + " 60: {'COLLECTIONS': 22,\n", + " 'JSOUP': 68,\n", + " 'SPATIAL4J': 56,\n", + " 'TA4J': 6,\n", + " 'THREETEN-EXTRA': 122},\n", + " 120: {'COLLECTIONS': 26,\n", + " 'JSOUP': 78,\n", + " 'SPATIAL4J': 159,\n", + " 'TA4J': 11,\n", + " 'THREETEN-EXTRA': 260}}}" + ] + }, + "metadata": {}, + "execution_count": 176 + } + ], + "source": [ + "key = 'Number of Kex calls'\n", + "a = {\n", + " tool: {\n", + " timeout: {\n", + " project: sum(statistics[key][tool][timeout][project])\n", + " for project in projects\n", + " }\n", + " for timeout in timeouts\n", + " }\n", + " for tool in tools\n", + "}\n", + "a" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kQ6HtdiWNgJj" + }, + "source": [ + "### Plots for coverage improvement over time" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": { + "id": "a6XY7XYS-Al2" + }, + "outputs": [], + "source": [ + "def get_runs(n):\n", + " work_stats = []\n", + " for root, dirs, files in os.walk(output_paths[0]):\n", + " for file in files:\n", + " if file == \"work-stat.log\":\n", + " full_path = Path(os.path.join(root, file))\n", + " with open(full_path, \"r\") as f:\n", + " lines = f.readlines()\n", + " if len(lines) < 57:\n", + " continue\n", + " for line in lines:\n", + " result = re.search(r\"^Concolic mutation: Number of Kex calls: (\\w+)\", line)\n", + " if result is not None:\n", + " t = int(result.groups()[0])\n", + " if t != 0:\n", + " work_stats.append(full_path)\n", + " break\n", + " # return random.sample(work_stats, min(20, len(work_stats)))\n", + " grouped = {\n", + " t: {\n", + " p: []\n", + " for p in projects\n", + " }\n", + " for t in timeouts\n", + " }\n", + "\n", + " for path in work_stats:\n", + " for p in projects:\n", + " for t in timeouts:\n", + " if str(path).find(p) != -1:\n", + " if str(path).find(f\"evokex-{t}\") != -1:\n", + " grouped[t][p].append(path)\n", + " break\n", + "\n", + " result = []\n", + " for t in timeouts:\n", + " for p in projects:\n", + " result += random.sample(grouped[t][p], min(n, len(grouped[t][p])))\n", + "\n", + " return result" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": { + "id": "0rW3PLxOHU19" + }, + "outputs": [], + "source": [ + "runs = get_runs(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 581 + }, + "id": "ZEx-NKPINfjS", + "outputId": "25e09eb8-604b-4366-ed72-c9acd9585f4b" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":58: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.\n", + " fig, (ax1, ax2) = plt.subplots(ncols=2, sharex='col', sharey=True)\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAHNCAYAAAA9hyBTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABJt0lEQVR4nO3deXxU9b3/8ffs2QNKEhYDwQ0FQZQll8WKNYpiqdraUuAq0p9Yt1ah1oJst1rBai+lC4pdkP6uoNSK9v4KUhVF24KiQRSqF0XxggsBFMie2b6/P87MSCDATEgyZ2Zez8cjD8PMmcl3hBxefM6ZE4cxxggAAMDGnMleAAAAwPEQLAAAwPYIFgAAYHsECwAAsD2CBQAA2B7BAgAAbI9gAQAAtkewAAAA2yNYAACA7REsAADA9ggWoJ1s2bJF11xzjXr16qWsrCz16NFDl1xyiX7961/HtikrK5PD4Yh9FBcX64ILLtDTTz/d4nMOHTpUDodDDz/8cOy2devWNXuOY31I0tKlS+VwOPTGG2+0+DXuuusuORwOjRs3rsX7P/roIzkcDv385z+P+//FgQMHVFxcLIfDoT//+c/N7jveeo5m2bJlcjgcysvLO+Z2gUBAffv2TXjNUfPmzdO//du/qaioSFlZWTrjjDN0xx13aO/eve36XOFwWA888IB69+6trKwsDRgwQI8//njCXxNIF+5kLwBIR+vXr9dFF12knj17asqUKeratat27dqlV199Vb/85S/1/e9/P7btwIED9cMf/lCS9Omnn+qRRx7RN77xDT388MO66aabYtu9//77ev3111VWVqZly5bp5ptvliSdffbZ+q//+q9mX3/GjBnKy8vTzJkzE1q3MUaPP/64ysrK9P/+3/9TTU2N8vPzW/u/IWbOnDmqr68/4eeJqq2t1V133aXc3NzjbvvrX/9aO3fubPXXqqys1MCBA/Wd73xH+fn5evfdd/W73/1Oq1at0ubNm+NaQ2uea+bMmbr//vs1ZcoUDRkyRH/5y180YcIEORwOfec732n16wFSlgHQ5saMGWOKiorM/v37j7ivqqoq9nmvXr3MFVdc0ez+zz77zOTm5pozzzyz2e1z5swxxcXF5qmnnjIOh8Ps2LHjqF+/X79+5sILL2zxvkcffdRIMq+//voR97344otGknnxxReNx+MxS5cuPWKbHTt2GEnmwQcfPOrXP9SWLVuM2+0299xzj5FknnzyybjXczQ//vGPTZ8+fczEiRNNbm7uUberqqoyhYWFsa8d75qP589//rORZB5//PF2ea6PP/7YeDwec+utt8ZuC4fD5oILLjCnnHKKCQaDJ/x1gVTDISGgHXzwwQfq16+fOnXqdMR9xcXFx3xs165ddfbZZ2vHjh3Nbl++fLmuueYafe1rX1NhYaGWL1/elkuWZB1m6du3ry666CJVVFRo2bJlJ/yct99+u66++mpdcMEFbbBCa9L0i1/8QgsWLJDbfewh8fTp09WnTx/9+7//e5t87aiysjJJ1qGu9niuv/zlLwoEArrllltitzkcDt188836+OOPtWHDhhP+ukCqIViAdtCrVy9VVlZq69atCT82EAho165dOvnkk2O3vfbaa9q+fbvGjx8vr9erb3zjG20SE4dqamrSU089pfHjx0uSxo8frxdffFG7d+9u9XM++eSTWr9+vR544IG2WqbuuOMOXXTRRRozZswxt9u4caP++Mc/auHChbHzd1rLGKN9+/Zp9+7d+vvf/64f/OAHcrlcGjVqVLs815tvvqnc3FydffbZzR47dOjQ2P1ApiFYgHZw5513qr6+XgMHDtTw4cP14x//WM8995wCgcAR2wYCAe3bt0/79u3T22+/reuuu05VVVX61re+FdvmscceU2lpqUaMGCFJ+s53vqN33nlHmzdvbrM1//Wvf9WBAwdi50dcddVV8ng8euKJJ1r1fA0NDbrzzjs1derU2BThRK1atUrPPfecFixYcMztjDH6/ve/r3HjxmnYsGEn/HWrqqpUVFSkbt266Stf+Yp27typ5cuX66yzzmqX5/rss89UUlJyRGh169ZNknWuE5BpOOkWaAeXXHKJNmzYoPnz5+tvf/ubNmzYoAceeEBFRUX6/e9/r69//euxbZ977jkVFRXFfu1yuXTttdfqZz/7mSQpGAxqxYoVmjRpUuwvsK9+9asqLi7WsmXLNHDgwDZZ87JlyzR48GCdfvrpkqT8/HxdccUVWrZsme64446En+/+++9XIBDQ3Xff3Sbr8/v9mjp1qm666Sb17dv3mNsuXbpUW7ZsOeIdSa110kkn6fnnn1djY6PefPNNrVy5UrW1te32XA0NDfL5fEc8NisrK3Y/kGkIFqCdDBkyRCtXrpTf79dbb72lp59+Wr/4xS90zTXXaPPmzbG/dMvLy/XTn/5UDodDOTk5Ovvss5ud+/Lcc89p7969Gjp0qLZv3x67/aKLLtLjjz+un/3sZ3I6T2xYeuDAAa1evVq33XZbs68xYsQIPfXUU3rvvfd05plnxv18H330kR588EEtWrTouG87Ptzhh6AKCwuVnZ2tX/ziF9q3b59+8pOfHPPx1dXVmjFjhn70ox+ptLQ0oa99NF6vVxUVFZKkr33ta7r44os1YsQIFRcX62tf+1qbP1d2draampqOeGxjY2PsfiDTECxAO/N6vRoyZIiGDBmiM888U5MnT9aTTz6puXPnSpK6dOkS+wusJdFzVb797W+3eP/LL7+siy666ITW+OSTT6qpqUn/+Z//qf/8z/9scQ3HC4VDzZkzRz169NCoUaP00UcfSfoyRPbu3auPPvpIPXv2bDG0ooc9oh599FFdffXV+ulPf6pbbrlF1dXVqq6ulmS9vdkYo48++kg5OTkqLi7Wz3/+c/n9fo0bNy72tT/++GNJ0v79+/XRRx+pe/fu8nq9cb+eww0fPlzdunXTsmXLEg6WeJ6rW7dueumll2SMaXZY6LPPPpMkde/e/YS+JpCKCBagAw0ePFjSl3/xHE9dXZ3+8pe/aNy4cbrmmmuOuP8HP/iBli1bdsLBsmzZMp1zzjmxiDrUI488ouXLlycULDt37tT27dt16qmnHnFf9J0v+/fvb/FdVM8//3yzX/fr10/79+9XbW2tHnjggRZP4O3du7euvPJKPfPMM9q5c6f279+vfv36HbHdvHnzNG/ePL355psnfCitsbFRBw8ePKHnONpzDRw4UL///e/17rvvNjv89dprr8XuBzINwQK0g5deekmjRo064qTJ1atXS5L69OkT1/M8/fTTqqur06233tri24Kfe+45Pfnkk1q0aFGL5zzEY9euXXrllVf0k5/8pMUo8vv9mjhxol577TWVl5fH9Zw//elPtW/fvma3bd26VbNnz9Zdd92lYcOGHfWCay1Nm+rr61u8+u+vfvUrbdiwQY8//nhsMvODH/xAV111VbPt9uzZo+9973u6/vrrdeWVV6p3795xvY66urrYobpDPfXUU9q/f38sQNv6ua688kpNnTpVDz30kH7zm99Isk4kXrx4sXr06KHhw4fH/XWBdEGwAO3g+9//vurr63X11VfrrLPOkt/v1/r167VixQqVlZVp8uTJcT3PsmXLdPLJJx/1L6ivf/3rsSulfuMb32jVWpcvXy5jTLMTgQ81ZswYud1uLVu2rFmwrF27NnZOxaGuuuoqjRw58ojbo9OUIUOGHBEUx5OTk9PiY5555hlt3Lix2X3nn3++zj///GbbRQ8N9evXL6Gv/f7776uiokLjxo3TWWedJafTqTfeeEOPPfaYysrKdPvtt7fLc51yyim644479OCDDyoQCGjIkCF65pln9Pe//13Lli2Ty+WK++sC6YJgAdrBz3/+cz355JNavXq1fvvb38rv96tnz5665ZZbNGvWrBYPhRxuz549euGFFzR+/Pij/gV18cUXKycnR4899lirg2XZsmXq2bOnzj333Bbv79Spk0aOHKkVK1Y0ezvxmjVrtGbNmiO2Lysr0znnnBP31zfGSJIt/xI+5ZRT9M1vflMvvvii/vjHPyoQCKhXr1667bbbNHPmzGbXymnr57r//vvVuXNnPfLII1q6dKnOOOMMPfbYY5owYUJbv0wgJThMdG8BAEnwq1/9Srfffru2b9+u0047LdnLAWBTXDgOQFK9/vrrys3NVa9evZK9FAA2xiEhAEnx1FNPad26dVq2bJluuOGG4/5coLZ2vB85kJ2drcLCwg5/LgAt45AQgKTo3bu3ampqdPXVV2vhwoVHfddQeznezxeaNGmSli5d2uHPBaBlTFgAJMXhP426ox1+vZfDJXJxtrZ8LgAtY8ICAABsj5NuAQCA7REsAADA9ggWAABgewQLAACwPYIFAADYHsECAABsj2ABAAC2R7AAAADbI1gAAIDtESwAAMD2CBYAAGB7BAsAALA9ggUAANgewQIAAGyPYAEAALZHsAAAANsjWAAAgO0RLAAAwPYIFgAAYHsECwAAsD2CBQAA2B7BAgAAbI9gAQAAtkewAAAA2yNYAACA7REsAADA9ggWAABge+5kL6CthMNhffrpp8rPz5fD4Uj2coCMY4xRTU2NunfvLqczNf4txH4DSL549x1pEyyffvqpSktLk70MIOPt2rVLp5xySrKXERf2G4B9HG/fkTbBkp+fL8l6wQUFBUleDZB5qqurVVpaGvteTAXsN4Dki3ffkTbBEh3nFhQUsOMBkiiVDq2w3wDs43j7jtQ40AwAADIawQIAAGyPYAEAALZHsAAAANsjWAAAgO0RLAAAwPYIFgAAYHsECwAAsL20uXAcgHbg90sPPSR98IF02mnSLbdIXm+yVwXAztppv0GwAGjZXXdJCxZIodCXt915pzRtmvTAA8lbFwD7asf9BsEC4Eh33SU9+OCRt4dCX95OtAA4VDvvNziHBUBzfr/1L6RjWbDA2g421ijpq5I6Rz5OknShpFGSTo7c19iGX+tCSR5Z/w4ujPzXEbntK5GP6G2H3j4qsr7Cw+53tPBcLd3nOcrX8ESe+/DXGF3r4c95tO0Rlw7YbzBhSRGfbNip96c9LEdjQ7KXgnS3d48UGtHsJiOHRunlL28Ihaxj1Hfc0bFrQwLGaOsfqvT5ogGSOfR2I+kcSSFJ10g6vQ2+1vbIf4cfZ7sRLdxmJA1ogzW09DWMjnyN21vY7ljbIy4t7Dck6SR9rv76l/WLE9xvECwpYvv3HtSoLb9J9jKQoT5U7yNv/OCDjl8IEvCWXN8v1oUNryR7Ichgf9fI5jecwH6DYEkR7uovJEmVJ1Wo5qyhSV4N0tqnn0of7TjsRqNTddhtp53WYUtCa5yrnIA1TfjHaSMULGlpd18oa9pyorZKOtgGz9MeDn+Nx1trW/0/yTAt7jekYlU1v+EE9hsES4pwBazjqrWXXK1RT9yS5NUgrfn9Uk5O87P8D+dyWW9VhI2tlttYhzZOmtOgvtftkNRf1vkaWySdK2mFpKw2+FqNkkZLWi/rsEqupDpZh53ckoZFtlsfuU2H3O6U9Jak8CGPiXId9lxq4b76yK8P/xpuWYd9Dn+N0bX+87DnPNr2iEsH7DcIlhThDDZZ/83yJXklSHter/UWxJbO9o+aNo3rsdheltzG+svDlbVEVqC039fSoec42VoqrTWFdMB+g2BJEa5osGQTLOgA0bceHn49BZeL67CkELcJSJJcWZ4krwQZoZ33GwRLinATLOhoDzwg/fSnXOk2hXmM9RZSdzbBgg7SjvsNgiVFuEIEC5LA6+WtyynMI2vCQrCgQ7XTfoMLx6UITyRY3HmcDAYgPtFg4ZAQ0gHBkiLcYStYXDlMWAAcnwkbuSPvgmHCgnRAsKQITyRY3LkEC4DjC9QHYp97cggWpD6CJUUQLAAS0SxYcjlRGqmPYEkRXkOwAIhfsIEJC9ILwZIifMa60q0nj2ABcHwcEkK6IVhShE/WhMWbT7AAOL7ohCUolxxOR5JXA5w4giUFhINheRSUxIQFQHyiwRIQ0xWkh1YFy6JFi1RWVqasrCyVl5dr48aNx9x+4cKF6tOnj7Kzs1VaWqqpU6eqsbExdn9ZWZkcDscRH7feemtrlpd2mqqbYp8zYQEQj1AjwYL0kvCVblesWKFp06Zp8eLFKi8v18KFCzV69Ght27ZNxcXFR2y/fPlyTZ8+XUuWLNHw4cP13nvv6frrr5fD4dCCBQskSa+//rpCh/zcga1bt+qSSy7Rt771rRN4aenDX9Ok7MjnvgKCBcDxxQ4JOQgWpIeEJywLFizQlClTNHnyZPXt21eLFy9WTk6OlixZ0uL269ev14gRIzRhwgSVlZXp0ksv1fjx45tNZYqKitS1a9fYx1//+leddtppuvDCC1v/ytKIv+aQCUseb08EcHzRCQvBgnSRULD4/X5VVlaqoqLiyydwOlVRUaENGza0+Jjhw4ersrIyFigffvihVq9erTFjxhz1azz22GP67ne/K4fj6CeKNTU1qbq6utlHuooGS6N8nDwHnIBM2m8QLEg3CQXLvn37FAqFVFJS0uz2kpIS7d69u8XHTJgwQffcc49Gjhwpj8ej0047TaNGjdLdd9/d4vbPPPOMDhw4oOuvv/6Ya5k/f74KCwtjH6WlpYm8lJQSqLWCpUkcDgJORCbtN4L11k9qJliQLtr9XULr1q3TvHnz9NBDD2nTpk1auXKlVq1apXvvvbfF7f/whz/o8ssvV/fu3Y/5vDNmzNDBgwdjH7t27WqP5dtCNFj8DoIFOBGZtN8IN1kTlhDBgjSR0Em3Xbp0kcvlUlVVVbPbq6qq1LVr1xYfM3v2bF177bW64YYbJEn9+/dXXV2dbrzxRs2cOVNO55fN9L//+7964YUXtHLlyuOuxefzyefLjL/Ag3VWsAScmfF6gfaSSfuN2CEhJ8GC9JDQhMXr9WrQoEFau3Zt7LZwOKy1a9dq2LBhLT6mvr6+WZRIksvlkiQZY5rd/uijj6q4uFhXXHFFIstKe4Ea6y3gASYsAOIUm7AQLEgTCb+tedq0aZo0aZIGDx6soUOHauHChaqrq9PkyZMlSdddd5169Oih+fPnS5LGjh2rBQsW6LzzzlN5ebm2b9+u2bNna+zYsbFwkazwefTRRzVp0iS53QkvK62F6iMTFhfBAiA+BAvSTcJlMG7cOO3du1dz5szR7t27NXDgQK1ZsyZ2Iu7OnTubTVRmzZolh8OhWbNm6ZNPPlFRUZHGjh2r++67r9nzvvDCC9q5c6e++93vnuBLSj8cEgKQKIIF6aZVo4zbbrtNt912W4v3rVu3rvkXcLs1d+5czZ0795jPeemllx5xiAiWcIMVLEEmLADiFAsWF9duQnrgZwmlgOghoRDBAiBOxm8FS5gJC9IEwZICYhMWd1aSVwIgVUQnLGEXwYL0QLCkgHBjZMLiYcICID6xCQvBgjRBsKQAE5mwhN0EC4D4ECxINwRLCjBMWAAkKhAJFjfBgvRAsKSCJitYDMECIE7RCYthwoI0QbCkgkbrSrdhL8ECIE6RCYthwoI0QbCkguiEhWABEC+/9dOaCRakC4IlBTj8VrCIYAEQLyYsSDMESwqIBUuG/JRZAG0gGiweggXpgWBJAY4AwQIgMY6gFSxiwoI0QbCkAGd0wpLNlW4BxCkaLExYkCYIlhTgDFrB4shiwgIgPo4AwYL0QrCkAFfkkJCTYAEQJ0eIYEF6IVhSgCsyYXFmEywA4hM7h8XrTe5CgDZCsKQAd9C6cBzBAiBezkiwOLxMWJAeCJYU4AoxYQGQGGeIYEF6IVhSgCcSLK4cggVAfBwEC9IMwZIC3GErWNy5BAuA+DBhQbohWFKAJ8yEBUBiXAQL0gzBkgKiweLJ58JxAOLjDFvB4vQRLEgPBEsK8BoOCQFIjCtk/bRmggXpgmBJAdFg8eQRLADi42LCgjRDsKQAn6xg8eYTLADiQ7Ag3RAsNhcOhuWVteNhwgIgXm6CBWmGYLG5puqm2OdMWADEy2WsYHFlESxIDwSLzflrvgwWXwHBAiA+TFiQbggWmzs0WLx5/BAzAPFhwoJ0Q7DYXDRYmuSVw+lI8moApAo3wYI0Q7DYXKA2GiwcDgIQP0/kZH13DpNZpAeCxeZiweLgKrcA4hedsLizmbAgPRAsNhess4Il4GTCAiB+sQkLwYI0QbDYXCxYHAQLgPgRLEg3BIvNxYLFRbAAiE/IH5JTRhLBgvRBsNhcqJ5DQgASE6gPxD4nWJAuCBabC9U1SpKCTFgAxMlf64997skhWJAeCBabi05YQgQLgDgFG76csBAsSBcEi82FG6xgCboJFgDxOTRYXF5XElcCtB2CxebCjZEJC8ECIE7RYPHLwxWykTYIFpszkQlLmGABEKdosATE4SCkD4LF5kx0wuLlSrcA4hMNliDBgjRCsNhdkxUsxsOEBUB8Qo2RCYuDYEH6IFjsLhIsYS/BAiA+0WAJEixIIwSL3UUnLAQLgDgRLEhHBIvNOfxWsIhgARCnWLA4vUleCdB2CBabczRZV7qVj2ABEJ9wkxUsISYsSCMEi805ApEJC8ECIE5fTlgIFqQPgsXmnNFDQlkEC4D4xCYsBAvSCMFic86gFSwOJiwA4kSwIB0RLDbnihwScmYTLADiE260flpzmGBBGiFYbM4VmbA4c7jSLYD4xCYsLoIF6YNgsTlXiAkLgMQYvxUsTFiQTggWm3MHCRYAiYkFCxMWpBGCxebcYStYXDkEC4D4ECxIRwSLzXkih4TcuQQLgPjEgsVNsCB9ECw25wlbV7plwgIgXtFgMUxYkEYIFpvzhJmwAEhQgAkL0g/BYnNeYwWLJ49gARCnSLAYggVphGCxOYIFQMIIFqQhgsXmfLKCxVvAheMAxCkSLPJ4k7sOoA0RLDYWDobllbXjYcICIG5MWJCGCBYb89f6Y5978wkWAPFxBKMTFoIF6YNgsbGm6qbY574CggVAfAgWpCOCxcb8NV8GizePY9EA4uMIRKazBAvSCMFiY/5q66JxTfLK4XQkeTUAUgUTFqQjgsXGArXWhKVJHA4CED9HKBIsXoIF6YNgsbFosPgdBAuA+DkjExYHExakEYLFxoJ1VrAECBYACXBGJiwOJixII60KlkWLFqmsrExZWVkqLy/Xxo0bj7n9woUL1adPH2VnZ6u0tFRTp05VY2Njs20++eQT/fu//7tOPvlkZWdnq3///nrjjTdas7y0EQ0Wv5NgARA/ggXpyJ3oA1asWKFp06Zp8eLFKi8v18KFCzV69Ght27ZNxcXFR2y/fPlyTZ8+XUuWLNHw4cP13nvv6frrr5fD4dCCBQskSfv379eIESN00UUX6dlnn1VRUZHef/99de7c+cRfYQqLTVhcXOUWQPxiweIjWJA+Eg6WBQsWaMqUKZo8ebIkafHixVq1apWWLFmi6dOnH7H9+vXrNWLECE2YMEGSVFZWpvHjx+u1116LbfOzn/1MpaWlevTRR2O39e7dO+EXk25C9ZFgYcICIAHOsBUsTiYsSCMJHRLy+/2qrKxURUXFl0/gdKqiokIbNmxo8THDhw9XZWVl7LDRhx9+qNWrV2vMmDGxbf77v/9bgwcP1re+9S0VFxfrvPPO0+9+97tjrqWpqUnV1dXNPtJNNFiCLoIFaAuZsN+QJBcTFqShhIJl3759CoVCKikpaXZ7SUmJdu/e3eJjJkyYoHvuuUcjR46Ux+PRaaedplGjRunuu++ObfPhhx/q4Ycf1hlnnKG//e1vuvnmm/WDH/xAf/zjH4+6lvnz56uwsDD2UVpamshLSQmhBitYQgQL0CYyYb8hMWFBemr3dwmtW7dO8+bN00MPPaRNmzZp5cqVWrVqle69997YNuFwWOeff77mzZun8847TzfeeKOmTJmixYsXH/V5Z8yYoYMHD8Y+du3a1d4vpcOFI8ESdBMsQFvIhP2GJLmiwcKEBWkkoXNYunTpIpfLpaqqqma3V1VVqWvXri0+Zvbs2br22mt1ww03SJL69++vuro63XjjjZo5c6acTqe6deumvn37Nnvc2Wefraeeeuqoa/H5fPL50vsv8nC99U6qEMECtIlM2G9IkjsSLK5sfqQH0kdCExav16tBgwZp7dq1sdvC4bDWrl2rYcOGtfiY+vp6OZ3Nv4zL5ZIkGWMkSSNGjNC2bduabfPee++pV69eiSwv7ZjIhCVMsABIgMtEgiWLCQvSR8LvEpo2bZomTZqkwYMHa+jQoVq4cKHq6upi7xq67rrr1KNHD82fP1+SNHbsWC1YsEDnnXeeysvLtX37ds2ePVtjx46NhcvUqVM1fPhwzZs3T9/+9re1ceNG/fa3v9Vvf/vbNnypqcc0RoLFQ7AAiB+HhJCOEg6WcePGae/evZozZ452796tgQMHas2aNbETcXfu3NlsojJr1iw5HA7NmjVLn3zyiYqKijR27Fjdd999sW2GDBmip59+WjNmzNA999yj3r17a+HChZo4cWIbvMQU1kSwAEicx1g/rZkJC9KJw0SPy6S46upqFRYW6uDBgyooKEj2ctrEugvnatQr9+iVfjfrK1sfSvZygGNKxe/BVFxzPPa4uqo4XKVtKzarz7fPTfZygGOK9/uQnyVkZ9EJi48r3QKIn5tzWJCGCBYbc/itYJGXQ0IA4hcNFnc2wYL0QbDYWCxYMuBtmADajkcEC9IPwWJjBAuA1ogGC4eEkE4IFhtzBiLBkkWwAIiPCRu5FZLEhAXphWCxMWfAutKtgwkLgDgF6gOxzz05BAvSB8FiY67IhMWZTbAAiM+hwcKEBemEYLExV9AKFgfBAiBOwQYmLEhPBIuNuUJMWAAkhkNCSFcEi425IxMWF8ECIE7RCUtITjnd7OKRPvjTbGPucCRYcrnSLYD4RIPFL2+SVwK0LYLFxjyRQ0LuXCYsAOITarSCJSAOByG9ECw2Fpuw5BAsAOITqLN+UnPQQbAgvRAsNuYNM2EBkJjohIVgQbohWGzMY6xg8eQRLADiQ7AgXREsNuYz1pVuCRYA8SJYkK4IFhvziQkLgMSEmyJvayZYkGYIFpsKB8PyRn7iKsECIF6xCYuTYEF6IVhsyl/rj33uzSdYAMQnNmEhWJBmCBabaqpuin3uKyBYAMSHYEG6Ilhsyl9DsABIHMGCdEWw2FSg1gqWJnnlcDqSvBoAqSIaLGGCBWmGYLGpL4OF6QqA+Bl/ZMLiIliQXggWm4oGi99BsACIX2zCQrAgzRAsNhWosS4aFyBYACQgOmEhWJBuCBabCtZFJixOggVA/L4MFm+SVwK0LYLFpqLBEiRYACTA+K1rOIXdTFiQXggWmwrVW8EScBEsABIQmbAYDgkhzRAsNhUNFiYsABISiAQLExakGYLFpkINkWBxZyV5JQBSCsGCNEWw2FQ4FixMWAAkgGBBmiJYbMpEgiVEsABIRDRYPAQL0gvBYlPRCUuYYAGQAEfQChYxYUGaIVhsyjRFgsVDsABIQDRYmLAgzRAsdtVgXemWYAGQCEeAYEF6IljsKjJhMV6CBUD8HCGCBemJYLErggVAKzg4JIQ0RbDYlMNPsABInDMSLA4vwYL0QrDYVDRY5CNYAMTPGT0kRLAgzRAsNhULliyudAsgftFzWJiwIN0QLDblDESDhQkLgPi5gtZPa3b6vEleCdC2CBabigaLg0NCABLgDDNhQXoiWGzKGbSCxZlNsACInytySMjpI1iQXggWm3JFgsVBsABIQHTCQrAg3RAsNuUOWle6ZcICIBEuggVpimCxKXdkwuIiWAAkgGBBuiJYbModjgRLDsECIH5uggVpimCxKU+IYAGQOJexgsWVRbAgvRAsNhWdsLhzCRYA8WPCgnRFsNiUNxoseVzpFkD8mLAgXREsNuUxVrB48piwAIifm2BBmiJYbMpLsABoBY+sYHFnEyxILwSLTflEsABIHBMWpCuCxYZM2Mgn6weYESwAEsGEBemKYLGhpuqm2OfefIIFQHwO/ccOwYJ0Q7DY0KHB4isgWADEJ+QPxT735HqTuBKg7REsNuSvOWTCksdOB0B8AvWB2OdMWJBuCBYbCtRaweKXR043v0UA4nNosHhyCBakF/42tKFosDSJw0EA4hdsIFiQvggWG4oFi4Or3AKI36HB4vK6krgSoO0RLDYUDZaAgwkLgPhFg8UvjxxOR5JXA7QtgsWGgnWRc1icBAuQGholfVXSyZH/NrbRYxolXSjJI8ktqZOkzod9nBR5/AEFG26WJAXkkTQqznUAqcGd7AUk296tVfrXzb+Ro7Ym2UuJ8e79RJIUJFiAlBBsHKN/XBOS45NzJIUkXSPp9OM8antk22M9Znvkv8OP81whSd9QzsfV6ikpKLeklyWNkfRi3K8DsLOMD5Z/3fawRv3jp8leRotqs7okewkA4vD2r/wateqfyV5GzEF3oQpVLemtZC8FaDMZHyyO/V9Ikt7OH6Ev+l+Y5NUcwulUj2njkr0KAHFo+KibJGmnu1QfDj1VUqGsycmxbJV08JBft/SYw7c5FrekoCSpy+S9kdvOjfOxgP0RLH7rGO8XQ0Zr1NrZSV4NgFQUOniRpD/r06IeGvVPp6QVko73Lr9GWYds3pIVFi09plHSaEnrJRlJeZIOP5nWIWmgpD9LujKyrWSd+7K6Fa8GsKeMDxanP3JVWR/niwBonfDBeklSMOt0Sf8V56OydPzzS7JknYsSr0S2BVJLxr9LyBmwgsWRRbAAaKUa66T9cE5+khcCpK9WBcuiRYtUVlamrKwslZeXa+PGjcfcfuHCherTp4+ys7NVWlqqqVOnqrHxy7fb/cd//IccDkezj7POOqs1S0uYM0iwADhBdbWSpHAuwQK0l4QPCa1YsULTpk3T4sWLVV5eroULF2r06NHatm2biouLj9h++fLlmj59upYsWaLhw4frvffe0/XXXy+Hw6EFCxbEtuvXr59eeOGFLxfm7pijVS6CBcAJctZFLouQT7AA7SXhCcuCBQs0ZcoUTZ48WX379tXixYuVk5OjJUuWtLj9+vXrNWLECE2YMEFlZWW69NJLNX78+COmMm63W127do19dOnSMW/pjQaLM5tgAdA67norWBz5eUleCZC+EgoWv9+vyspKVVRUfPkETqcqKiq0YcOGFh8zfPhwVVZWxgLlww8/1OrVqzVmzJhm273//vvq3r27Tj31VE2cOFE7d+485lqamppUXV3d7KM13JFgceXyc3uAdNdW+43DuRutYHEWMmEB2ktCwbJv3z6FQiGVlJQ0u72kpES7d+9u8TETJkzQPffco5EjR8rj8ei0007TqFGjdPfdd8e2KS8v19KlS7VmzRo9/PDD2rFjhy644ALV1Bz96rPz589XYWFh7KO0tDSRlxLjDkWCJYcJC5Du2mq/cThvk3UOi6szwQK0l3Z/l9C6des0b948PfTQQ9q0aZNWrlypVatW6d57741tc/nll+tb3/qWBgwYoNGjR2v16tU6cOCA/vSnPx31eWfMmKGDBw/GPnbt2tWq9bnDBAuQKdpqv3E4n9/6x5WnE4eEgPaS0JmtXbp0kcvlUlVVVbPbq6qq1LVr1xYfM3v2bF177bW64YYbJEn9+/dXXV2dbrzxRs2cOVNO55HN1KlTJ5155pnavn37EfdF+Xw++drg2ikeJixAxmir/cbhsoJWsHhPZsICtJeEJixer1eDBg3S2rVrY7eFw2GtXbtWw4YNa/Ex9fX1R0SJy+WSJBljWnxMbW2tPvjgA3Xr1i2R5bWKJzJhcecSLABaJydkBUtWEcECtJeE3zs8bdo0TZo0SYMHD9bQoUO1cOFC1dXVafLkyZKk6667Tj169ND8+fMlSWPHjtWCBQt03nnnqby8XNu3b9fs2bM1duzYWLjceeedGjt2rHr16qVPP/1Uc+fOlcvl0vjx49vwpbbMa6zrwRAsAForJ2ydw0KwAO0n4WAZN26c9u7dqzlz5mj37t0aOHCg1qxZEzsRd+fOnc0mKrNmzZLD4dCsWbP0ySefqKioSGPHjtV9990X2+bjjz/W+PHj9fnnn6uoqEgjR47Uq6++qqKiojZ4icfmNdaExZNHsABIXDgYVr6sYMkp5hwWoL04zNGOy6SY6upqFRYW6uDBgyooKIj7cfWOHOWoQbte/lClX+ndjisE0ltrvweTqS3WXPNpjfJ7WI+t31unnC45bblEIO3F+32Y8T9LyCcmLABar263df5KSE5ln5Sd5NUA6SujgyXYGJRLYUmSN59gAZC4hr3W4aBa5cvhdCR5NUD6yuhgaapuin3uK+RKtwAS17jXmrDUOzl/BWhPGR0s/ppDgqWACQuAxDXtiwSLm3cIAe2JYJF17Nmd1TE/HRpAevF/YR0SavQQLEB7yuhgCdRawdIkpisAWie435qw+D0cEgLaU0YHS3TC4ncQLABaJxYsWUxYgPaU0cESqLGuckuwAGit8EErWIIEC9CuMjpYgnVMWACcoFrrHJZQDsECtCeCRVLASbAAaKUaa8ISzuEcFqA9ZXSwhOqtYAkSLABayVlnBYvymbAA7YlgkRRwESwAWsfVEAmWAoIFaE8Ei6QgwQKgldyN1jksrkKCBWhPGR0s4YZIsLi5LD+A1vE2WRMWVyHnsADtiWCRFHIzYQHQOj6/FSyek5iwAO2JYBHBAqD1soLWISHvyQQL0J4yOlhMoxUsYYIFQCtlB60Ji/ckDgkB7Smzg6XButJt2EOwAGid3LAVLNnFTFiA9pTRwaKmyITFS7AASJwJG+XJOiSUU0KwAO2JYJFkmLAAaIX6ffVyykiScrsSLEB7IlgkGSYsAFqhbnfksvxyKKdLTpJXA6S3jA4Wh98KFvkIFgCJq6+ygqVWeXI4HUleDZDeCBaJYAHQKg17rGCpc3I4CGhvGR0szgDBAqD1/F9YJ9w2uAkWoL0RLJIc2VyaH0Di/J9bE5ZGN9dgAdobwSLJkcWEBUDiAl9YwdLkZcICtLeMDhZXkGAB0HrBA1aw+H0EC9DeMjxYrCvdOrMJFgCJC1db57AEszgkBLS3jA4Wd2TC4swhWAC0QrU1YQllM2EB2ltmB0vIChYXExYArVETuXBcLsECtLfMDpZwJFiYsABoBWe9dUhI+QQL0N4yOlg8kQmLO5dgAZA4V701YVEe57AA7S2zg4UJC4AT4G60gsVZyIQFaG+ZHSzGChZPHsECIHHeSLC4OxMsQHvL6GDxRoMlnyvdAkicN2Cdw0KwAO2PYBETFgCtkxWwJizekziHBWhvGR0sPhEsAFovJ2gFi68LExagvWVssAQbg3IrJEny5hMsABKXE7aCJauIYAHaW8YGS1N1U+xzggVAokzYKE/WOSzZRRwSAtpbxgaLv+bLYPEVECwAEtPwRYNcCkuScrsyYQHaW8YHS1gOubPcSV4NgFRTt7sm9nlucW4SVwJkhowNlkCtFSxN8snhdCR5NQBSTf0e63BQjfLkdGfsrhToMBn7XRadsPjF4SAAiWvca01Y6p2cvwJ0hIwNlmBdJFgcBAuAxMWCxcX5K0BHIFicBAuAxPk/t4Kl0U2wAB2BYHFyWX4AiQscsM5hafISLEBHyPhgCTJhAdAKof3WhMXv4xwWoCNkbLCE6holSQEXwQIgceGDVrAEs5iwAB0hc4OlPjJhIVgAtIKpjgRLDsECdISMDZZwgxUsIYIFQGvUWuewhHM4JAR0hIwPlqCbYAGQOGdd5Eq3eUxYgI6Q8cESJlgAtIKzPhIs+QQL0BEyNlhMY+SQkIdgAZA4T4MVLM5CggXoCBkfLGGCBUAreJqsc1hchZzDAnSEjA0WNREsAFrP67cmLO7OTFiAjpDxwWK8BAuAxGUHrGDxnkywAB2BYPFyaX4AicsKWYeEfF0IFqAjZGywOJqsK93Kx4QFQOJyw9aEJasL57AAHSFzg8VvTVgIFgCJMmGjPGMFS3YxExagI2RssDgDBAuA1mk80Ci3QpKk3K4EC9ARMj5YHFkEC4DE1FXVxj7PLc5N4kqAzEGwECwAElRfZR0OqlOOXF5XklcDZIaMDRZXkGAB0DoNeyLB4uRwENBRMj5YnNkEC4DENO2zgqXeRbAAHSVzgyVEsABoHf8X1jksjW7e0gx0lIwNFnckWFw5BAuAxAS+sCYsTR4mLEBHIVhyudItgMQE91vB4vcRLEBHydhg8YasK926c5mwAEhMuNo6JBTIIliAjtKqYFm0aJHKysqUlZWl8vJybdy48ZjbL1y4UH369FF2drZKS0s1depUNTY2trjt/fffL4fDoTvuuKM1S4ubJ8whIQCtY6qtCUsom3NYgI6ScLCsWLFC06ZN09y5c7Vp0yade+65Gj16tPbs2dPi9suXL9f06dM1d+5cvfvuu/rDH/6gFStW6O677z5i29dff12PPPKIBgwYkPgrSZDHWMHiySNYACSoxgqWcC4TFqCjJBwsCxYs0JQpUzR58mT17dtXixcvVk5OjpYsWdLi9uvXr9eIESM0YcIElZWV6dJLL9X48eOPmMrU1tZq4sSJ+t3vfqfOnTu37tUkwBsJFg4JAUiUo84KFpNHsAAdJaFg8fv9qqysVEVFxZdP4HSqoqJCGzZsaPExw4cPV2VlZSxQPvzwQ61evVpjxoxptt2tt96qK664otlzH0tTU5Oqq6ubfSTCy4QFyDgnut+IctVHLs2fT7AAHcWdyMb79u1TKBRSSUlJs9tLSkr0P//zPy0+ZsKECdq3b59GjhwpY4yCwaBuuummZoeEnnjiCW3atEmvv/563GuZP3++fvKTnySy/GZ8IliATHOi+40od4M1YXEWcA4L0FHa/V1C69at07x58/TQQw9p06ZNWrlypVatWqV7771XkrRr1y7dfvvtWrZsmbKy4n+L8YwZM3Tw4MHYx65du+J+bMgfiv2kVW8+wQJkihPZbxzK02QFi6sTExagoyQ0YenSpYtcLpeqqqqa3V5VVaWuXbu2+JjZs2fr2muv1Q033CBJ6t+/v+rq6nTjjTdq5syZqqys1J49e3T++efHHhMKhfTKK6/oN7/5jZqamuRyHfnDxXw+n3y+1sVGU3WTciKfEyxA5jiR/Uaz54kEi7szwQJ0lIQmLF6vV4MGDdLatWtjt4XDYa1du1bDhg1r8TH19fVyOpt/mWiAGGN08cUXa8uWLdq8eXPsY/DgwZo4caI2b97cYqycKH9NU+xzXwHBAiAxvqB1DounM4eEgI6S0IRFkqZNm6ZJkyZp8ODBGjp0qBYuXKi6ujpNnjxZknTdddepR48emj9/viRp7NixWrBggc477zyVl5dr+/btmj17tsaOHSuXy6X8/Hydc845zb5Gbm6uTj755CNubyuHBosnx9MuXwNA+soOWhMWXxcmLEBHSThYxo0bp71792rOnDnavXu3Bg4cqDVr1sROxN25c2ezicqsWbPkcDg0a9YsffLJJyoqKtLYsWN13333td2rSJC/2rpoXYOylO10JG0dAFJTbtgKlqwiggXoKA5jjEn2ItpCdXW1CgsLdfDgQRUUFBxz2w+f3aZTx5ylgypUoTnQMQsE0lwi34N20Zo1m7BR0OWVR0F9tnGXug05pZ1XCaS3eL8PM/JnCQXrrENCfgfnrwBIjL/WL4+CkqScYs5hATpKZgeLk2ABkJjaz2pin+eWECxAR8noYAkQLAASVF9lBUu9suXOSvg0QACtRLAAQAIa9lpvaa5zcMIt0JEyMlhC9VawBAkWAAlq2heZsLg4HAR0pMwOFhfBAiAx0WBpdDNhATpSRgZLuCESLG6CBUBiAl9EgsVLsAAdKaODJcSEBUCCQgetc1j8Xg4JAR0pM4Ol3rrSbcgT/0+HBgBJCh2wJizBLCYsQEfKyGAxjZEJi4cJC4DEmOpIsGQTLEBHyuhgCRMsABJVYwVLOJdgATpSRgaLmggWAK3jqLPOYTG5nMMCdKSMDhbjJVgAJMZVH7k0fz4TFqAjESwAkAB3gxUsjkKCBehIGRksDr8VLCJYACTI3WQdEnJ1IliAjpTZweIjWAAkxtdkTVjchZzDAnSkzAyWAMECoHWyAlaweE9mwgJ0pIwMFmc0WLIIFgCJyQ4SLEAyZGSwuCLB4iBYACQoO2ydw5LVhUNCQEfK0GCxLs3vzObS/AASk2esCUt2MRMWoCNlZrAErQmLM5sJC4D4+Wv98skvScrtSrAAHSkzgyVEsABIXO1nNbHPc0s4JAR0pIwMFnckWFw5BAuA+NXvsc5faZRPnhxPklcDZBaCBQDi1LDHmrDUOjgcBHS0jAwWT5hgAZC4xr1WsNS7CBago2V0sLhzCRYA8fN/bgVLg5tgAToawQIAcQrst85hafJwwi3Q0TIyWLyGYAGQuOB+a8Li9zJhATpaRgeLJ49gARC/0AErWAJZBAvQ0TIyWLJkXenWm0+wAIifqbEOCQWzOSQEdLSMC5aQPyS3QpIkbwGX5geQgBprwhLOYcICdLSMC5am6qbY50xYACTCUWsFi8kjWICOlnHB4q/5Mlh8BQQLgPg56yOX5s8nWICOltHBwqW1ASTC3WCdw+LI5xwWoKNlbLA0yieH05Hk1QBIJZ5Ga8Li6sSEBehoGRcsgVorWJrE4SAAifH6rWBxdyZYgI6WscHidxAsABKTFbCCxXMSwQJ0tIwLlmCdFSwBJ8ECIDFZQescFu9JnMMCdLTMDRYmLAASlBOyJixZRUxYgI6WecFSa13lNuAiWAAkJs9YwZJdTLAAHS3jgiVUHz0kxFVuAcQvUB9Qlqz9R04xh4SAjpaxwRJkwgIgAXVVtbHP87oxYQE6WsYFS7ghEixuggVA/Op2W4eDmuSVN8+b5NUAmSdjgyXEhAVAAhr2WMFS62C6AiRD5gaLh2ABEL/GfdYhoQYn568AyZBxwWIarWAJc0gIQAL8n1sTlgY3ExYgGTI2WJiwAEhENFgaPQQLkAwZFyxqsoLFECwAEhDcHznp1kewAMmQscES9hIsAOIXqrbOYQn6OIcFSIbMC5ZG60q3hmABkABz0JqwBLOZsADJkHHB4vBbExYRLAASUWMFSyiHYAGSIXODJYtL8wOIn6PWChaTyyEhIBkyL1gCkWDxMWEBED9nfeTS/PlMWIBkyLhgcUaDJYtgARA/d4M1YXEUECxAMmRcsLgiweIgWAAkwN1oBYurE8ECJEPGBYszaAWLk2ABkACv3zok5CrkHBYgGTIuWFzRYMkmWADEL8tvTVg8JzFhAZIh44LFTbAAaIWsoBUsvi4EC5AMGRcsrhDBAiBxOSGCBUimjAsWT8i60q0rh2ABEL9cY53Dkl3EOSxAMmResIStCYs7l2ABEJ9gY1A5apAk5ZQwYQGSIWODhQkLgHjVVdXGPs/rRrAAyZCxweLJ59L8AOJTt9s6f8Uvj3wF/GMHSIaMCxav4ZAQgMQ07LUmLHUOzl8BkiVjg8WTR7AAiE/jXmvCUufkcBCQLBkXLD5ZweLNJ1gAxKdpnxUsDW6CBUiWjAqWcDAsj4KSmLAAiF9gv3VIqMnNISEgWTIqWJqqm2KfM2EBEK/gfmvC0uRjwgIkS6uCZdGiRSorK1NWVpbKy8u1cePGY26/cOFC9enTR9nZ2SotLdXUqVPV2NgYu//hhx/WgAEDVFBQoIKCAg0bNkzPPvtsa5Z2TP6aL4OFM/0BxCt0wAqWAMECJE3CwbJixQpNmzZNc+fO1aZNm3Tuuedq9OjR2rNnT4vbL1++XNOnT9fcuXP17rvv6g9/+INWrFihu+++O7bNKaecovvvv1+VlZV644039NWvflVXXnml/vWvf7X+lbWg6eCXkeTN87bpcwNIX+GDVrAEswkWIFkSDpYFCxZoypQpmjx5svr27avFixcrJydHS5YsaXH79evXa8SIEZowYYLKysp06aWXavz48c2mMmPHjtWYMWN0xhln6Mwzz9R9992nvLw8vfrqq61/ZS2ITlia5JXD6WjT5waQxmqtc1hCOZzDAiRLQsHi9/tVWVmpioqKL5/A6VRFRYU2bNjQ4mOGDx+uysrKWKB8+OGHWr16tcaMGdPi9qFQSE888YTq6uo0bNiwo66lqalJ1dXVzT6OJ1AbDRYOBwGZqDX7DalRjtpNkiSTu0tS47E3B9Au3IlsvG/fPoVCIZWUlDS7vaSkRP/zP//T4mMmTJigffv2aeTIkTLGKBgM6qabbmp2SEiStmzZomHDhqmxsVF5eXl6+umn1bdv36OuZf78+frJT36SyPK/DBYHV7kFMlFr9hvSGDnrAtan+dWSxkh6sY1XBuB42v1dQuvWrdO8efP00EMPadOmTVq5cqVWrVqle++9t9l2ffr00ebNm/Xaa6/p5ptv1qRJk/TOO+8c9XlnzJihgwcPxj527dp13LUE66xgCTiZsACZqDX7DektuRqsyyE4Coykt9p1jQBaltCEpUuXLnK5XKqqqmp2e1VVlbp27driY2bPnq1rr71WN9xwgySpf//+qqur04033qiZM2fK6bSayev16vTTT5ckDRo0SK+//rp++ctf6pFHHmnxeX0+n3y+xMKj89ldte6C2VJurron9EgA6aA1+w3pXOmbDVr36oU6efQ+69cAOlxCweL1ejVo0CCtXbtWV111lSQpHA5r7dq1uu2221p8TH19fSxKolwulyTJGHPUrxUOh9XU1HTU+1uj25BT1O2Ve9r0OQGku9Ua/osxsiYr50paneT1AJkpoWCRpGnTpmnSpEkaPHiwhg4dqoULF6qurk6TJ0+WJF133XXq0aOH5s+fL8l6B9CCBQt03nnnqby8XNu3b9fs2bM1duzYWLjMmDFDl19+uXr27KmamhotX75c69at09/+9rc2fKkA0BpZ4pwVIPkSDpZx48Zp7969mjNnjnbv3q2BAwdqzZo1sRNxd+7c2WyiMmvWLDkcDs2aNUuffPKJioqKNHbsWN13332xbfbs2aPrrrtOn332mQoLCzVgwAD97W9/0yWXXNIGLxEAAKQ6hznWcZkUUl1drcLCQh08eFAFBQXJXg6QcVLxezAV1wykm3i/DzPqZwkBAIDURLAAAADbI1gAAIDtESwAAMD2CBYAAGB7BAsAALA9ggUAANgewQIAAGyPYAEAALZHsAAAANtL+GcJ2VX0JwxUV1cneSVAZop+76XST/tgvwEkX7z7jrQJlpqaGklSaWlpklcCZLaamhoVFhYmexlxYb8B2Mfx9h1p88MPw+GwPv30U+Xn58vhcBx1u+rqapWWlmrXrl0p9cPOUnXdEmtPhmSs2xijmpoade/evdlPbLezQ/cbNTU1Kfl7LfHntKOx7rYV774jbSYsTqdTp5xyStzbFxQU2Oo3LF6pum6JtSdDR687VSYrUYfuN6L/0EnV32spddfOujuWHdcdz74jNf4ZBAAAMhrBAgAAbC/jgsXn82nu3Lny+XzJXkpCUnXdEmtPhlRddzKl8v+zVF076+5YqbruqLQ56RYAAKSvjJuwAACA1EOwAAAA2yNYAACA7REsAADA9jIqWBYtWqSysjJlZWWpvLxcGzduTPaSjvDKK69o7Nix6t69uxwOh5555plm9xtjNGfOHHXr1k3Z2dmqqKjQ+++/n5zFHmL+/PkaMmSI8vPzVVxcrKuuukrbtm1rtk1jY6NuvfVWnXzyycrLy9M3v/lNVVVVJWnFX3r44Yc1YMCA2MWUhg0bpmeffTZ2v13Xfbj7779fDodDd9xxR+y2VFm7HSRz//Af//EfcjgczT7OOuus2P3x/D7u3LlTV1xxhXJyclRcXKwf/ehHCgaDzbZZt26dzj//fPl8Pp1++ulaunRpQutsi/3TF198oYkTJ6qgoECdOnXS//k//0e1tbXNtnn77bd1wQUXKCsrS6WlpXrggQeOWMuTTz6ps846S1lZWerfv79Wr159Qmu//vrrj/g9uOyyy5K69rbar7bVn42k/x1qMsQTTzxhvF6vWbJkifnXv/5lpkyZYjp16mSqqqqSvbRmVq9ebWbOnGlWrlxpJJmnn3662f3333+/KSwsNM8884x56623zNe//nXTu3dv09DQkJwFR4wePdo8+uijZuvWrWbz5s1mzJgxpmfPnqa2tja2zU033WRKS0vN2rVrzRtvvGH+7d/+zQwfPjyJq7b893//t1m1apV57733zLZt28zdd99tPB6P2bp1qzHGvus+1MaNG01ZWZkZMGCAuf3222O3p8La7SDZ+4e5c+eafv36mc8++yz2sXfv3tj9x/t9DAaD5pxzzjEVFRXmzTffNKtXrzZdunQxM2bMiG3z4YcfmpycHDNt2jTzzjvvmF//+tfG5XKZNWvWxL3Ottg/XXbZZebcc881r776qvn73/9uTj/9dDN+/PjY/QcPHjQlJSVm4sSJZuvWrebxxx832dnZ5pFHHolt889//tO4XC7zwAMPmHfeecfMmjXLeDwes2XLllavfdKkSeayyy5r9nvwxRdfNNumo9feFvvVtvqzkezvEWOMyZhgGTp0qLn11ltjvw6FQqZ79+5m/vz5SVzVsR3+TRUOh03Xrl3Ngw8+GLvtwIEDxufzmccffzwJKzy6PXv2GEnm5ZdfNsZY6/R4PObJJ5+MbfPuu+8aSWbDhg3JWuZRde7c2fz+979PiXXX1NSYM844wzz//PPmwgsvjAVLKqzdLpK9f5g7d64599xzW7wvnt/H1atXG6fTaXbv3h3b5uGHHzYFBQWmqanJGGPMXXfdZfr169fsuceNG2dGjx7dqjW3Zv/0zjvvGEnm9ddfj23z7LPPGofDYT755BNjjDEPPfSQ6dy5c2zdxhjz4x//2PTp0yf2629/+9vmiiuuaLae8vJy873vfa9VazfGCpYrr7zyqI+xw9pbs19tqz8byf4eMcaYjDgk5Pf7VVlZqYqKithtTqdTFRUV2rBhQxJXlpgdO3Zo9+7dzV5HYWGhysvLbfc6Dh48KEk66aSTJEmVlZUKBALN1n7WWWepZ8+etlp7KBTSE088obq6Og0bNiwl1n3rrbfqiiuuaLZGKXX+nyebXfYP77//vrp3765TTz1VEydO1M6dOyXF9/u4YcMG9e/fXyUlJbFtRo8ererqav3rX/+KbXP4n5HRo0e32WuMZ/+0YcMGderUSYMHD45tU1FRIafTqddeey22zVe+8hV5vd5m69y2bZv279/frq9l3bp1Ki4uVp8+fXTzzTfr888/j91nh7W3Zr/aFn827PI9khHBsm/fPoVCoWa/YZJUUlKi3bt3J2lViYuu1e6vIxwO64477tCIESN0zjnnSLLW7vV61alTp2bb2mXtW7ZsUV5ennw+n2666SY9/fTT6tu3r+3X/cQTT2jTpk2aP3/+EffZfe12YYf9Q3l5uZYuXao1a9bo4Ycf1o4dO3TBBReopqYmrt/H3bt3t7j+6H3H2qa6uloNDQ0n/Bri2T/t3r1bxcXFze53u9066aST2uS1nMjv12WXXab/+3//r9auXauf/exnevnll3X55ZcrFArZYu2t3a+2xZ8NO3yPSGn005phH7feequ2bt2qf/zjH8leStz69OmjzZs36+DBg/rzn/+sSZMm6eWXX072so5p165duv322/X8888rKysr2cvBCbj88stjnw8YMEDl5eXq1auX/vSnPyk7OzuJK8sc3/nOd2Kf9+/fXwMGDNBpp52mdevW6eKLL07iyiypuF9taxkxYenSpYtcLtcRZ05XVVWpa9euSVpV4qJrtfPruO222/TXv/5VL730kk455ZTY7V27dpXf79eBAweabW+XtXu9Xp1++ukaNGiQ5s+fr3PPPVe//OUvbb3uyspK7dmzR+eff77cbrfcbrdefvll/epXv5Lb7VZJSYlt124ndtw/dOrUSWeeeaa2b98e15/Brl27trj+6H3H2qagoKBNoiie/VPXrl21Z8+eZvcHg0F98cUXbfJa2vL369RTT1WXLl20ffv2pK/9RParbfFnwy7fIxkRLF6vV4MGDdLatWtjt4XDYa1du1bDhg1L4soS07t3b3Xt2rXZ66iurtZrr72W9NdhjNFtt92mp59+Wi+++KJ69+7d7P5BgwbJ4/E0W/u2bdu0c+fOpK+9JeFwWE1NTbZe98UXX6wtW7Zo8+bNsY/Bgwdr4sSJsc/tunY7seP+oba2Vh988IG6desW15/BYcOGacuWLc3+Qn3++edVUFCgvn37xrY59Dmi27TVa4xn/zRs2DAdOHBAlZWVsW1efPFFhcNhlZeXx7Z55ZVXFAgEmq2zT58+6ty5c4e8Fkn6+OOP9fnnn6tbt25JW3tb7Ffb4s+Gbb5HOuz03iR74oknjM/nM0uXLjXvvPOOufHGG02nTp2anTltBzU1NebNN980b775ppFkFixYYN58803zv//7v8YY622DnTp1Mn/5y1/M22+/ba688kpbvK355ptvNoWFhWbdunXN3hZYX18f2+amm24yPXv2NC+++KJ54403zLBhw8ywYcOSuGrL9OnTzcsvv2x27Nhh3n77bTN9+nTjcDjMc889Z4yx77pbcui7hIxJrbUnU7L3Dz/84Q/NunXrzI4dO8w///lPU1FRYbp06WL27NljjDn+72P0rauXXnqp2bx5s1mzZo0pKipq8a2rP/rRj8y7775rFi1alPDbmtti/3TZZZeZ8847z7z22mvmH//4hznjjDOavTX4wIEDpqSkxFx77bVm69at5oknnjA5OTlHvDXY7Xabn//85+bdd981c+fOPe7bmo+19pqaGnPnnXeaDRs2mB07dpgXXnjBnH/++eaMM84wjY2NSVt7W+xX2+rPRrK/R4zJoLc1G2PMr3/9a9OzZ0/j9XrN0KFDzauvvprsJR3hpZdeMpKO+Jg0aZIxxnrr4OzZs01JSYnx+Xzm4osvNtu2bUvuoo1pcc2SzKOPPhrbpqGhwdxyyy2mc+fOJicnx1x99dXms88+S96iI7773e+aXr16Ga/Xa4qKiszFF18cixVj7LvulhweLKm09mRL5v5h3Lhxplu3bsbr9ZoePXqYcePGme3bt8fuj+f38aOPPjKXX365yc7ONl26dDE//OEPTSAQaLbNSy+9ZAYOHGi8Xq859dRTm31/xqMt9k+ff/65GT9+vMnLyzMFBQVm8uTJpqamptk2b731lhk5cqTx+XymR48e5v777z9iLX/605/MmWeeabxer+nXr59ZtWpVq9deX19vLr30UlNUVGQ8Ho/p1auXmTJlyhF/GXf02ttqv9pWfzaS/XeowxhjOmKSAwAA0FoZcQ4LAABIbQQLAACwPYIFAADYHsECAABsj2ABAAC2R7AAAADbI1gAAIDtESwAAMD2CBYAAGB7BAsAALA9ggUAANgewQIAAGzv/wPBGLEFh8GmHQAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAHNCAYAAAA9hyBTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAzk0lEQVR4nO3de1hVVf7H8c8B5QAi4BUk8ZKal1K8E9pFJ4ops2yy1J9TatOYE1ZKj6aTSdmFyu5qVmNlF0uz1Go0Gx+8ZT+yvFAymGaaOiYXUzmKispZvz/8caYjoBxEWcD79Tz7Sdb+7r3XOpyz+rjP3luHMcYIAADAYn6V3QEAAICzIbAAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKxHYAEAANYjsAAAAOsRWFAlORyOMi0rV67UL7/8IofDoeeee67EfT366KNyOBzat2+fp2348OFe+3E6nbrkkks0efJkHTt2zKf+jBo1qtT9/n4JDAyUJLVo0aJMY5s9e3a5jt2pUyeV9C9yOBwOjR49+qyv/cqVK894zLlz50qSMjMzFRAQoBEjRhTbx8GDB9WkSRPFxsbqrbfeKtN4W7Ro4fX7Klpq166tFi1a6P7779fBgwdL7ff48ePlcDg0aNCgs47x97Zs2aKxY8eqV69eCgwMlMPh0C+//FJq/WeffaauXbsqMDBQzZo1U3Jysk6ePFniazBy5Eg1atRIderUUd++fbVhwwaf+iZJCxcuVEJCgqKiouR0OtW0aVMNHDhQGRkZPu+ryLx58xQXF6c6deooPDxcvXr10vLly4vVvfnmm2rfvr0CAwPVpk0bTZs2rdzHBM6mVmV3ACiP9957z+vnd999V8uWLSvW3r59ex09erRcx3A6nZo1a5YkKS8vT59++qkef/xx/fzzz5ozZ06x+muvvVZ33nlnsfZLLrmk1P3+nr+/vyTppZde0uHDhz3tS5Ys0YcffqgXX3xRDRs29LT36tXL52NL0qZNm7RgwQLdeuutxdb54v7771ePHj2KtcfFxUmSOnTooHHjxumpp57S8OHDdfXVV3tqJkyYoNzcXH3xxRcKDQ0t9nu7++671bNnT40cOdLTFhIS4lUzc+ZMhYSEKD8/X6mpqZo2bZo2bNigNWvWFOuTMUYffvihWrRooc8//1yHDh1S3bp1yzTOtLQ0vfLKK+rQoYPat2+v9PT0Umu/+OILDRgwQH369NG0adO0adMmPfHEE8rJydHMmTM9dW63W/369dP333+vcePGqWHDhnr11VfVp08frV+/Xm3atClT36RTv8969erpgQceUMOGDZWVlaW33npLPXv2VFpammJiYsq8L+lUIJwyZYoGDhyo4cOH68SJE8rIyNCePXu86l5//XWNGjVKt956q5KSkvTVV1/p/vvv15EjR/TQQw/5dEygTAxQDSQmJprS3s47duwwkszUqVNLXJ+cnGwkmdzcXE/bsGHDTJ06dbzq3G63ufzyy43D4TBZWVle6ySZxMTEs/azpP2ezdSpU40ks2PHjhLX+3LsoKAgc8kll5hOnToZt9tdrv2sWLHCSDLz588/a+3Ro0dNq1atTNu2bU1BQYExxpj//d//NQ6HwyQlJZW6XZ06dcywYcNKXFfS78sYYwYNGmQkmbVr1xbbZvny5UaSWb58ualdu7aZPXv2Wfte5LfffjMul8sYc/bfRYcOHUxMTIw5ceKEp+3hhx82DofDbN682dM2b968Yq9hTk6OCQ8PN0OGDClz30qTlZVlatWqZe655x6ftktLSzMOh8O88MILZ6w7cuSIadCggenXr59X+9ChQ02dOnXM/v37fe4zcDZ8JQSUkcPh0BVXXCFjjLZv317Z3SkXPz8/TZo0ST/88IMWLlx43o8XGBiomTNnasuWLUpJSdGJEyc0cuRIRUdHa8qUKRV6rCuvvFKS9PPPPxdbN2fOHHXo0EF9+/ZVfHx8iWfISlO/fv0ynY3JzMxUZmamRo4cqVq1/nvy+t5775UxRh9//LGn7eOPP1ZERIT+9Kc/edoaNWqk22+/XZ9++qkKCgrK3L+SNG7cWMHBwWf8iqwkL730kiIjI/XAAw/IGON1pu/3VqxYod9++0333nuvV3tiYqLy8/O1ePHi8nYdKBWBBTXGkSNHtG/fvmLLkSNHyryPomsX6tWrV2zdsWPHStz/8ePHi9WWVOdyuco9Nl+O/T//8z9q06aNpkyZUuK1LGV16NChEo95+j6vvfZaDRkyRCkpKRo9erQyMjI0bdo01alTp9zHLklpv5uCggJ98sknGjJkiCRpyJAhWr58ubKysir0+Bs3bpQkde/e3as9KipKTZs29awvqu3atav8/Lyn4J49e+rIkSPaunWrz8c/ePCgcnNztWnTJt19991yuVy65pprfNpHamqqevTooVdeeUWNGjVS3bp11aRJE02fPt2rrrSxduvWTX5+fl5jBSpMpZ7fASpIWb4SOttS0ldCubm5Jjc312zbts0899xzxuFwmMsuu6zEr1NKWz788EOv/ZZWl5CQUGL/y/KVUFmPXfR11DvvvGMkmQULFnjtx5evhEpb9u7dW2ybrKwsU69ePSPJDBgw4KzHKMtXQlu2bDG5ubnml19+MW+99ZYJCgoyjRo1Mvn5+V71H3/8sZFkfvrpJ2OMMS6XywQGBpoXX3zxrP043Zl+F0Xrdu3aVWxdjx49zOWXX+41vrvuuqtY3eLFi40ks3TpUp/71rZtW8/vICQkxEyaNMkUFhaWefv9+/cbSaZBgwYmJCTETJ061cybN8/88Y9/NJLMa6+95qlNTEw0/v7+Je6nUaNGZvDgwT73HzgbLrpFjTFy5EjddtttxdrffffdYhd9SlJ+fr4aNWrk1XbFFVfonXfekcPhKFZ/8803l3iXTceOHb1+DgwM1Oeff16s7vcX1PqqrMcuMnToUD3xxBOaMmWKBgwYUOJ4zmby5Mmer2F+r379+sXagoODFRwcrAMHDui6667z+Vgladu2rdfPHTt21Ntvv63g4GCv9jlz5qh79+5q3bq1JKlu3brq16+f5syZozFjxlRIXyR5Lu52Op3F1gUGBnqdQTt69Gipdb/fly/efvttuVwubd++XW+//baOHj2qwsLCYmdxSlP09c9vv/2muXPneu6mGjhwoDp27KgnnnhC99xzj6d/AQEBJe4nMDCw3Be6A2dCYEGN0aZNG8XHxxdrL+muEsk7WPznP//Rs88+q5ycHAUFBZVY37Rp0xL3fzp/f/8y1fmirMf+fR8mTZqkYcOGadGiRbrllluK1Zz+lUlYWJjX2Dt27FjmYz788MPKyspS+/btlZycrMGDB5f4tZovPvnkE4WGhio3N1evvPKKduzYUex3c/DgQS1ZskSjR4/Wtm3bPO29e/fWJ598oq1bt+qSSy7R0aNHlZeX57VtZGSkT/0pOnZJ158cO3bMq29BQUGl1v1+X74oujtLkgYPHqz27dtLUqm385+u6Ji1a9fWwIEDPe1+fn4aNGiQkpOTtWvXLjVr1kxBQUElft1YNIby9B84G65hAUpRFCzi4+M1fPhwpaamKisry/O3zKpu6NChat26danXsjRp0sRrmTdvXrmOs27dOs2YMUP33Xef5s6dqwMHDlTIba9XXXWV4uPjNWTIEC1btkxBQUEaOnSo3G63p2b+/PkqKCjQ888/rzZt2niWpKQkSfJcfDtv3rxi4/VV0TZ79+4ttm7v3r2Kioryqi2tTpJXbXnUq1dPf/jDH3y+uDgwMFANGjTw3GJfpHHjxpKkAwcOSDrV/8LCQuXk5HjVHT9+XL/99ts59x8oCYEFKKMmTZpo7Nix+vzzz/XNN99UdnfOWdFZlvT0dH366afF1i9btsxrSUhI8PkYhYWFGjlypKKiojRlyhR16tRJDzzwgGbNmqW0tLSKGIakU89oSU5OVnp6uj766CNP+5w5c3TZZZdp/vz5xZb4+Hh98MEHkqSEhIRi4/VV586dJZ0KaL/366+/6j//+Y9nfVHthg0bvMKVJK1du1bBwcElPj/HVyWdNToTPz8/de7cWbm5ucXOnvz666+S5PmKtLSxrlu3Tm6322usQEUhsAA+uO+++xQcHKynn366srtSIf785z+rdevWeuyxx4qtKzq7VLSU56zDK6+8oo0bN+qVV17x3Br82GOPqWnTpho1alSJT4Atr6FDh6pp06Z65plnJEm7d+/W6tWrdfvtt2vgwIHFlhEjRmjbtm1au3atmjRpUmy8vrr00kvVrl07vfHGGyosLPS0z5w5Uw6Hw+trloEDByo7O1sLFizwtO3bt0/z589X//79S7y+pTSnn+WQTt0xlZqaWuwunrMZNGiQCgsL9c4773jajh075rktvOjMyR/+8AfVr1/f62F40qmxBgcHq1+/fj4dFygLrmEBfNCgQQONGDFCr776qjZv3uy5TkCStm7dqvfff7/YNhEREbr22ms9P588ebLEOkm65ZZbynW7b1mPfTp/f389/PDDJT4+/2y++uqrEv+Zgk6dOqlTp07avXu3Jk+erP79+3tdI1OnTh29/PLL+tOf/qSXX35ZDz74oM/HLknt2rX1wAMPaNy4cVq6dKm+//57GWN00003lVh/ww03qFatWpozZ45iY2NL3W9eXp7nkfNff/21JGn69OkKDw9XeHi418XOU6dO1U033aTrrrtOgwcPVkZGhqZPn667777b670ycOBAXX755RoxYoQyMzM9T7otLCwsMTyeSceOHXXNNdeoc+fOqlevnn766Se9+eabOnHihM/B+p577tGsWbOUmJiorVu3qlmzZnrvvfe0c+dOrwvFg4KC9PjjjysxMVG33XabEhIS9NVXX+n999/Xk08+WeKF18A5q+zblICKcCGedFvk559/Nv7+/l633eoMt/leffXVXvs9U+2Zbpctz23Npx+7pDGdOHHCtGrVqsJua05OTjbGGHPzzTebOnXqmJ07d5a4nxtvvNGEhISUeBtweZ50a4wxeXl5JiwszFx99dWmY8eOplmzZmccS58+fUzjxo29nkx7ujPdFt+8efNi9QsXLjSdO3c2TqfTNG3a1EyaNMkcP368WN3+/fvNX/7yF9OgQQMTHBxsrr76avPdd9+dsb8lSU5ONt27dzf16tUztWrVMlFRUWbw4MHmhx9+8HlfxhiTnZ1thg0bZurXr2+cTqeJjY0t9TbrN954w7Rt29YEBASYVq1amRdffLHYLf9ARXEYcw5PjgIAALgAuIYFAABYj2tYAMBC+/fvL/VZJ9Kp649Of7DhhdgXUFn4SggALNSnTx+tWrWq1PXNmzf3/PtJF3JfQGUhsACAhdavX+95UFtJgoKC1Lt37wu+L6CyEFgAAID1uOgWAABYj8ACAACsR2ABAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKxHYAEAANYjsAAAAOsRWAAAgPUILAAAwHoEFgAAYD0CCwAAsB6BBQAAWI/AAgAArEdgAQAA1iOwAAAA6xFYAACA9QgsAADAegQWAABgPQILAACwHoEFAABYj8ACAACsR2ABAADWq1XZHagobrdbv/76q+rWrSuHw1HZ3QFqHGOMDh06pKioKPn5VY2/CzFvAJWvrHNHtQksv/76q6Kjoyu7G0CNt3v3bjVt2rSyu1EmzBuAPc42d1SbwFK3bl1JpwYcGhpayb0Bah6Xy6Xo6GjPZ7EqYN4AKl9Z545qE1iKTueGhoYy8QCVqCp9tcK8AdjjbHNH1fiiGQAA1GgEFgAAYD0CCwAAsB6BBQAAWI/AAgAArEdgAQAA1iOwAAAA6xFYAACA9QgsAADAegQWAABgPQILAACwHoEFAABYj8ACAACsR2ABAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKxHYAEAANYjsAAAAOsRWAAAgPUILAAAwHoEFgAAYD0CCwAAsB6BBQAAWI/AAgAArEdgAQAA1iOwAAAA6xFYAACA9QgsAADAegQWAABgPQILAACwHoEFAABYj8ACAACsR2ABAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALCez4Fl9erV6t+/v6KiouRwOLRo0aKzbrNy5Up17dpVTqdTrVu31uzZs0utffrpp+VwODRmzBhfuwYAAKopnwNLfn6+YmJiNGPGjDLV79ixQ/369VPfvn2Vnp6uMWPG6O6779aXX35ZrPa7777T66+/rk6dOvnaLQAAUI3V8nWD66+/Xtdff32Z61977TW1bNlSzz//vCSpffv2WrNmjV588UUlJCR46g4fPqyhQ4fqH//4h5544glfuwUAAKqx834NS1pamuLj473aEhISlJaW5tWWmJiofv36FastTUFBgVwul9cCAGfCvAFUXec9sGRlZSkiIsKrLSIiQi6XS0ePHpUkzZ07Vxs2bFBKSkqZ95uSkqKwsDDPEh0dXaH9BlD9MG8AVVel3yW0e/duPfDAA5ozZ44CAwPLvN3EiROVl5fnWXbv3n0eewmgOmDeAKoun69h8VVkZKSys7O92rKzsxUaGqqgoCCtX79eOTk56tq1q2d9YWGhVq9erenTp6ugoED+/v7F9ut0OuV0Os939wFUI8wbQNV13gNLXFyclixZ4tW2bNkyxcXFSZKuueYabdq0yWv9iBEj1K5dOz300EMlhhUAAFCz+BxYDh8+rG3btnl+3rFjh9LT01W/fn01a9ZMEydO1J49e/Tuu+9KkkaNGqXp06dr/Pjxuuuuu7R8+XJ99NFHWrx4sSSpbt26uuyyy7yOUadOHTVo0KBYOwAAqJl8voZl3bp16tKli7p06SJJSkpKUpcuXTR58mRJ0t69e7Vr1y5PfcuWLbV48WItW7ZMMTExev755zVr1iyvW5oBAADOxGGMMZXdiYrgcrkUFhamvLw8hYaGVnZ3gBqnKn4Gq2KfgeqmrJ/DSr9LCAAA4GwILAAAwHoEFgAAYD0CCwAAsB6BBQAAWI/AAgAArEdgAQAA1iOwAAAA6xFYAACA9QgsAADAegQWAABgPQILAACwHoEFAABYj8ACAACsR2ABAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKxHYAEAANYjsAAAAOsRWAAAgPUILAAAwHoEFgAAYD0CCwAAsB6BBQAAWI/AAgAArEdgAQAA1iOwAAAA6xFYAACA9QgsAADAegQWAABgPQILAACwHoEFAABYj8ACAACsR2ABAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKxHYAEAANYjsAAAAOsRWAAAgPUILAAAwHoEFgAAYD0CCwAAsB6BBQAAWI/AAgAArEdgAQAA1iOwAAAA6/kcWFavXq3+/fsrKipKDodDixYtOus2K1euVNeuXeV0OtW6dWvNnj3ba31KSop69OihunXrqnHjxhowYIC2bNnia9cAAEA15XNgyc/PV0xMjGbMmFGm+h07dqhfv37q27ev0tPTNWbMGN1999368ssvPTWrVq1SYmKivvnmGy1btkwnTpzQddddp/z8fF+7BwAAqiGHMcaUe2OHQwsXLtSAAQNKrXnooYe0ePFiZWRkeNoGDx6sgwcPaunSpSVuk5ubq8aNG2vVqlW66qqrytQXl8ulsLAw5eXlKTQ01KdxADh3VfEzWBX7DFQ3Zf0c1jrfHUlLS1N8fLxXW0JCgsaMGVPqNnl5eZKk+vXrl1pTUFCggoICz88ul+vcOgqg2mPeAKqu837RbVZWliIiIrzaIiIi5HK5dPTo0WL1brdbY8aMUe/evXXZZZeVut+UlBSFhYV5lujo6ArvO4DqhXkDqLqsu0soMTFRGRkZmjt37hnrJk6cqLy8PM+ye/fuC9RDAFUV8wZQdZ33r4QiIyOVnZ3t1Zadna3Q0FAFBQV5tY8ePVr//Oc/tXr1ajVt2vSM+3U6nXI6nRXeXwDVF/MGUHWd9zMscXFxSk1N9WpbtmyZ4uLiPD8bYzR69GgtXLhQy5cvV8uWLc93twAAQBXic2A5fPiw0tPTlZ6eLunUbcvp6enatWuXpFOnXO+8805P/ahRo7R9+3aNHz9eP/74o1599VV99NFHGjt2rKcmMTFR77//vj744APVrVtXWVlZysrKKvEaFwAAUPP4HFjWrVunLl26qEuXLpKkpKQkdenSRZMnT5Yk7d271xNeJKlly5ZavHixli1bppiYGD3//POaNWuWEhISPDUzZ85UXl6e+vTpoyZNmniWefPmnev4AABANXBOz2GxCc9TACpXVfwMVsU+A9VNWT+H1t0lBAAAcDoCCwAAsB6BBQAAWI/AAgAArEdgAQAA1iOwAAAA6xFYAACA9QgsAADAegQWAABgPQILAACwHoEFAABYj8ACAACsR2ABAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKxHYAEAANYjsAAAAOsRWAAAgPUILAAAwHoEFgAAYD0CCwAAsB6BBQAAWI/AAgAArEdgAQAA1iOwAAAA6xFYAACA9QgsAADAegQWAABgPQILAACwHoEFAABYj8ACAACsR2ABAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKxHYAEAANYjsAAAAOsRWAAAgPUILAAAwHoEFgAAYD0CCwAAsB6BBQAAWI/AAgAArEdgAQAA1iOwAAAA6xFYAACA9WpVdgcq3fHj0quvSj//LLVqJd17rxQQcO61AOCLip5fmK9Q3RgfrVq1ytx4442mSZMmRpJZuHDhWbdZsWKF6dKliwkICDCtWrUyb7/9drGa6dOnm+bNmxun02l69uxp1q5d61O/8vLyjCSTl5dX9o3GjTPG398Y6b+Lv/+p9nOpBWqgcn0GK5k1fa7o+YX5ClVIWT+HPn8llJ+fr5iYGM2YMaNM9Tt27FC/fv3Ut29fpaena8yYMbr77rv15ZdfemrmzZunpKQkJScna8OGDYqJiVFCQoJycnJ87V7ZjR8vTZ0qFRZ6txcWnmofP758tQDgi4qeX5ivUE05jDGm3Bs7HFq4cKEGDBhQas1DDz2kxYsXKyMjw9M2ePBgHTx4UEuXLpUkxcbGqkePHpo+fbokye12Kzo6Wvfdd58mTJhQpr64XC6FhYUpLy9PoaGhZy4+flwKDi7+gf49f3/pyJFTfy5rLadbUYP59Bm0RNn6fExSgqQ1ktxl3HNdSbskhZ+57PS5KETSzv/fzHFa7ek/l+SkpJaS/iMpQNK/JF2hkq9WLMv+gAqxQlKfUteWde4479ewpKWlKT4+3qstISFBY8aMkSQdP35c69ev18SJEz3r/fz8FB8fr7S0tFL3W1BQoIKCAs/PLpfrrH35de1u/TTqeSk3RyrsfebiQkkXD///P5extlHjs/YBqIpMo8bq86+/V3Y3zll55g3pBq0ZeVKF313h49H+JKnTmUtOn4taSLrGx8P83mGdCiuSFC1pzDnsC6gA9f/2mzqO7Cup3OdGPM57YMnKylJERIRXW0REhFwul44ePaoDBw6osLCwxJoff/yx1P2mpKToscce86kvedtydXX6y2XfYI8PO9/jYz1QhWwPaCup6geW8swb0vfy+7Ktrti1uhxHXOFbecbZS8rs5wrcF1BOX319hTSyYvZVZe8SmjhxopKSkjw/u1wuRUdHn3Gbeu0jtbLX36Vff5V+2XH2g7Roeeq/Za2Nijp7HVAVNWqoiyu7DxWgPPOGFCMNOKqV66728Wi1JMWeueT0uainzm1WzpP07///86WSws5hX0AFaHxNdoXt67wHlsjISGVne3c4OztboaGhCgoKkr+/v/z9/UusiYyMLHW/TqdTTqfTt750jVLk10+W/RqWLf869eey1nINC2C18swb0hL1ejlB0lc679ewZKpirmHZI+kncQ0LLOHjmcZSnPcHx8XFxSk1NdWrbdmyZYqLi5MkBQQEqFu3bl41brdbqampnpoKFxAg/e5vWSVKSjpV50stgGooUNIqnbpYzZRxcemsYUUqPr8cltRAkr9Ozc5+kh4aJznKeNxaRhoy7tSPx3XqOsdav9uXr/tjYamQpY8qhK/3Sx86dMhs3LjRbNy40UgyL7zwgtm4caPZuXOnMcaYCRMmmDvuuMNTv337dhMcHGzGjRtnNm/ebGbMmGH8/f3N0qVLPTVz5841TqfTzJ4922RmZpqRI0ea8PBwk5WVVeZ+8RwWoHJZ80wTH1jTZ57DghqsrJ9Dn29rXrlypfr27VusfdiwYZo9e7aGDx+uX375RStXrvTaZuzYscrMzFTTpk31yCOPaPjw4V7bT58+XVOnTlVWVpY6d+6sV155RbGxZ/n+93fKfUslT7oFKkT1va35AuFJt6ihyvo5PKfnsNjEqokHqIGq4mewKvYZqG7K+jnkHz8EAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKxHYAEAANYjsAAAAOsRWAAAgPUILAAAwHoEFgAAYD0CCwAAsB6BBQAAWI/AAgAArEdgAQAA1iOwAAAA6xFYAACA9QgsAADAegQWAABgPQILAACwHoEFAABYj8ACAACsR2ABAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKxHYAEAANYjsAAAAOsRWAAAgPUILAAAwHoEFgAAYD0CCwAAsB6BBQAAWI/AAgAArEdgAQAA1iOwAAAA6xFYAACA9QgsAADAegQWAABgPQILAACwHoEFAABYj8ACAACsR2ABAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKxXrsAyY8YMtWjRQoGBgYqNjdW3335bau2JEyc0ZcoUtWrVSoGBgYqJidHSpUu9agoLC/XII4+oZcuWCgoKUqtWrfT444/LGFOe7gEAgGrG58Ayb948JSUlKTk5WRs2bFBMTIwSEhKUk5NTYv2kSZP0+uuva9q0acrMzNSoUaN0yy23aOPGjZ6aZ555RjNnztT06dO1efNmPfPMM3r22Wc1bdq08o8MAABUGw7j42mM2NhY9ejRQ9OnT5ckud1uRUdH67777tOECROK1UdFRenhhx9WYmKip+3WW29VUFCQ3n//fUnSjTfeqIiICL355pul1pyNy+VSWFiY8vLyFBoa6suQAFSAqvgZrIp9Bqqbsn4OfTrDcvz4ca1fv17x8fH/3YGfn+Lj45WWllbiNgUFBQoMDPRqCwoK0po1azw/9+rVS6mpqdq6dask6fvvv9eaNWt0/fXX+9I9AABQTdXypXjfvn0qLCxURESEV3tERIR+/PHHErdJSEjQCy+8oKuuukqtWrVSamqqFixYoMLCQk/NhAkT5HK51K5dO/n7+6uwsFBPPvmkhg4dWmpfCgoKVFBQ4PnZ5XL5MhQANRDzBlB1nfe7hF5++WW1adNG7dq1U0BAgEaPHq0RI0bIz++/h/7oo480Z84cffDBB9qwYYPeeecdPffcc3rnnXdK3W9KSorCwsI8S3R09PkeCoAqjnkDqLp8CiwNGzaUv7+/srOzvdqzs7MVGRlZ4jaNGjXSokWLlJ+fr507d+rHH39USEiILr74Yk/NuHHjNGHCBA0ePFgdO3bUHXfcobFjxyolJaXUvkycOFF5eXmeZffu3b4MBUANxLwBVF0+BZaAgAB169ZNqampnja3263U1FTFxcWdcdvAwEBddNFFOnnypD755BPdfPPNnnVHjhzxOuMiSf7+/nK73aXuz+l0KjQ01GsBgDNh3gCqLp+uYZGkpKQkDRs2TN27d1fPnj310ksvKT8/XyNGjJAk3Xnnnbrooos8Z0fWrl2rPXv2qHPnztqzZ48effRRud1ujR8/3rPP/v3768knn1SzZs106aWXauPGjXrhhRd01113VdAwAQBAVeZzYBk0aJByc3M1efJkZWVlqXPnzlq6dKnnQtxdu3Z5nS05duyYJk2apO3btyskJEQ33HCD3nvvPYWHh3tqpk2bpkceeUT33nuvcnJyFBUVpXvuuUeTJ08+9xECAIAqz+fnsNiK5ykAlasqfgarYp+B6ua8PIcFAACgMhBYAACA9QgsAADAegQWAABgPQILAACwHoEFAABYj8ACAACsR2ABAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKxHYAEAANYjsAAAAOsRWAAAgPUILAAAwHoEFgAAYD0CCwAAsB6BBQAAWI/AAgAArEdgAQAA1iOwAAAA6xFYAACA9QgsAADAegQWAABgPQILAACwHoEFAABYj8ACAACsR2ABAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKxHYAEAANYjsAAAAOsRWAAAgPUILAAAwHoEFgAAYD0CCwAAsB6BBQAAWI/AAgAArEdgAQAA1iOwAAAA6xFYAACA9QgsAADAegQWAABgPQILAACwHoEFAABYj8ACAACsR2ABAADWI7AAAADrlSuwzJgxQy1atFBgYKBiY2P17bffllp74sQJTZkyRa1atVJgYKBiYmK0dOnSYnV79uzRn//8ZzVo0EBBQUHq2LGj1q1bV57uAQCAasbnwDJv3jwlJSUpOTlZGzZsUExMjBISEpSTk1Ni/aRJk/T6669r2rRpyszM1KhRo3TLLbdo48aNnpoDBw6od+/eql27tr744gtlZmbq+eefV7169co/MgAAUG04jDHGlw1iY2PVo0cPTZ8+XZLkdrsVHR2t++67TxMmTChWHxUVpYcffliJiYmetltvvVVBQUF6//33JUkTJkzQ119/ra+++qrcA3G5XAoLC1NeXp5CQ0PLvR8A5VMVP4NVsc9AdVPWz6FPZ1iOHz+u9evXKz4+/r878PNTfHy80tLSStymoKBAgYGBXm1BQUFas2aN5+fPPvtM3bt312233abGjRurS5cu+sc//nHGvhQUFMjlcnktAHAmzBtA1eVTYNm3b58KCwsVERHh1R4REaGsrKwSt0lISNALL7ygn376SW63W8uWLdOCBQu0d+9eT8327ds1c+ZMtWnTRl9++aX+9re/6f7779c777xTal9SUlIUFhbmWaKjo30ZCoAaiHkDqLrO+11CL7/8stq0aaN27dopICBAo0eP1ogRI+Tn999Du91ude3aVU899ZS6dOmikSNH6q9//atee+21Uvc7ceJE5eXleZbdu3ef76EAqOKYN4Cqy6fA0rBhQ/n7+ys7O9urPTs7W5GRkSVu06hRIy1atEj5+fnauXOnfvzxR4WEhOjiiy/21DRp0kQdOnTw2q59+/batWtXqX1xOp0KDQ31WgDgTJg3gKrLp8ASEBCgbt26KTU11dPmdruVmpqquLi4M24bGBioiy66SCdPntQnn3yim2++2bOud+/e2rJli1f91q1b1bx5c1+6BwAAqqlavm6QlJSkYcOGqXv37urZs6deeukl5efna8SIEZKkO++8UxdddJFSUlIkSWvXrtWePXvUuXNn7dmzR48++qjcbrfGjx/v2efYsWPVq1cvPfXUU7r99tv17bff6o033tAbb7xRQcMEAABVmc+BZdCgQcrNzdXkyZOVlZWlzp07a+nSpZ4LcXft2uV1fcqxY8c0adIkbd++XSEhIbrhhhv03nvvKTw83FPTo0cPLVy4UBMnTtSUKVPUsmVLvfTSSxo6dOi5jxAAAFR5Pj+HxVY8TwGoXFXxM1gV+wxUN+flOSwAAACVgcACAACsR2ABAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKxHYAEAANYjsAAAAOsRWAAAgPUILAAAwHoEFgAAYD0CCwAAsB6BBQAAWI/AAgAArEdgAQAA1iOwAAAA6xFYAACA9QgsAADAegQWAABgPQILAACwHoEFAABYj8ACAACsR2ABAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKxHYAEAANYjsAAAAOsRWAAAgPUILAAAwHoEFgAAYD0CCwAAsB6BBQAAWI/AAgAArFersjtQUYwxkiSXy1XJPQFqpqLPXtFnsSpg3gAqX1nnjmoTWA4dOiRJio6OruSeADXboUOHFBYWVtndKBPmDcAeZ5s7HKYq/XXoDNxut3799VfVrVtXDoej1DqXy6Xo6Gjt3r1boaGhF7CHVR+vXfnVhNfOGKNDhw4pKipKfn5V49vmsswbNeF3JzHO6qYqjbOsc0e1OcPi5+enpk2blrk+NDTU+l+irXjtyq+6v3ZV5cxKEV/mjer+uyvCOKuXqjLOsswdVeOvQQAAoEYjsAAAAOvVuMDidDqVnJwsp9NZ2V2pcnjtyo/XruqqKb87xlm9VMdxVpuLbgEAQPVV486wAACAqofAAgAArEdgAQAA1iOwAAAA69WowDJjxgy1aNFCgYGBio2N1bffflvZXap0jz76qBwOh9fSrl07z/pjx44pMTFRDRo0UEhIiG699VZlZ2d77WPXrl3q16+fgoOD1bhxY40bN04nT5680EM571avXq3+/fsrKipKDodDixYt8lpvjNHkyZPVpEkTBQUFKT4+Xj/99JNXzf79+zV06FCFhoYqPDxcf/nLX3T48GGvmh9++EFXXnmlAgMDFR0drWefffZ8Dw2lsHnOsOn9OH/+fLVr106BgYHq2LGjlixZUmHjTElJUY8ePVS3bl01btxYAwYM0JYtW7xqKmqeWrlypbp27Sqn06nWrVtr9uzZxfpzvt4TM2fOVKdOnTwPeouLi9MXX3xRrcZ4zkwNMXfuXBMQEGDeeust8+9//9v89a9/NeHh4SY7O7uyu1apkpOTzaWXXmr27t3rWXJzcz3rR40aZaKjo01qaqpZt26dufzyy02vXr0860+ePGkuu+wyEx8fbzZu3GiWLFliGjZsaCZOnFgZwzmvlixZYh5++GGzYMECI8ksXLjQa/3TTz9twsLCzKJFi8z3339vbrrpJtOyZUtz9OhRT80f//hHExMTY7755hvz1VdfmdatW5shQ4Z41ufl5ZmIiAgzdOhQk5GRYT788EMTFBRkXn/99Qs1TPw/2+cMW96PX3/9tfH39zfPPvusyczMNJMmTTK1a9c2mzZtqpBxJiQkmLfffttkZGSY9PR0c8MNN5hmzZqZw4cPe2oqYp7avn27CQ4ONklJSSYzM9NMmzbN+Pv7m6VLl3pqzud74rPPPjOLFy82W7duNVu2bDF///vfTe3atU1GRka1GeO5qjGBpWfPniYxMdHzc2FhoYmKijIpKSmV2KvKl5ycbGJiYkpcd/DgQVO7dm0zf/58T9vmzZuNJJOWlmaMOTVp+vn5maysLE/NzJkzTWhoqCkoKDivfa9Mp/8Pwu12m8jISDN16lRP28GDB43T6TQffvihMcaYzMxMI8l89913npovvvjCOBwOs2fPHmOMMa+++qqpV6+e12v30EMPmbZt257nEeF0VWnOqMz34+2332769evn1Z/Y2Fhzzz33VOgYi+Tk5BhJZtWqVZ5xVcQ8NX78eHPppZd6HWvQoEEmISHB8/OFfk/Uq1fPzJo1q1qP0Rc14iuh48ePa/369YqPj/e0+fn5KT4+XmlpaZXYMzv89NNPioqK0sUXX6yhQ4dq165dkqT169frxIkTXq9bu3bt1KxZM8/rlpaWpo4dOyoiIsJTk5CQIJfLpX//+98XdiCVaMeOHcrKyvJ6rcLCwhQbG+v1WoWHh6t79+6emvj4ePn5+Wnt2rWemquuukoBAQGemoSEBG3ZskUHDhy4QKNBVZ8zLuT7MS0tzes4RTXn63XKy8uTJNWvX19Sxc1TZxvHhXxPFBYWau7cucrPz1dcXFy1HGN51IjAsm/fPhUWFnr9IiUpIiJCWVlZldQrO8TGxmr27NlaunSpZs6cqR07dujKK6/UoUOHlJWVpYCAAIWHh3tt8/vXLSsrq8TXtWhdTVE01jO9x7KystS4cWOv9bVq1VL9+vV5PS1T1eeMC/l+LK3mfLxObrdbY8aMUe/evXXZZZd5jl8R81RpNS6XS0ePHr0g74lNmzYpJCRETqdTo0aN0sKFC9WhQ4dqNcZzUW3+tWaUz/XXX+/5c6dOnRQbG6vmzZvro48+UlBQUCX2DAC8JSYmKiMjQ2vWrKnsrpwXbdu2VXp6uvLy8vTxxx9r2LBhWrVqVWV3yxo14gxLw4YN5e/vX+yK6uzsbEVGRlZSr+wUHh6uSy65RNu2bVNkZKSOHz+ugwcPetX8/nWLjIws8XUtWldTFI31TO+xyMhI5eTkeK0/efKk9u/fz+tpmao+Z1zI92NpNRX9Oo0ePVr//Oc/tWLFCjVt2tTTXlHzVGk1oaGhCgoKuiDviYCAALVu3VrdunVTSkqKYmJi9PLLL1erMZ6LGhFYAgIC1K1bN6Wmpnra3G63UlNTFRcXV4k9s8/hw4f1888/q0mTJurWrZtq167t9bpt2bJFu3bt8rxucXFx2rRpk9fEt2zZMoWGhqpDhw4XvP+VpWXLloqMjPR6rVwul9auXev1Wh08eFDr16/31Cxfvlxut1uxsbGemtWrV+vEiROemmXLlqlt27aqV6/eBRoNqvqccSHfj3FxcV7HKaqpqNfJGKPRo0dr4cKFWr58uVq2bOm1vqLmqbONozLeE263WwUFBdV6jD6p7Kt+L5S5c+cap9NpZs+ebTIzM83IkSNNeHi41xXVNdGDDz5oVq5caXbs2GG+/vprEx8fbxo2bGhycnKMMadupWvWrJlZvny5WbdunYmLizNxcXGe7YtupbvuuutMenq6Wbp0qWnUqFG1vK350KFDZuPGjWbjxo1GknnhhRfMxo0bzc6dO40xp24jDQ8PN59++qn54YcfzM0331zibaRdunQxa9euNWvWrDFt2rTxuo304MGDJiIiwtxxxx0mIyPDzJ071wQHB3NbcyWwfc6w5f349ddfm1q1apnnnnvObN682SQnJ1fobc1/+9vfTFhYmFm5cqXX4xeOHDniqamIearolt9x48aZzZs3mxkzZpR4y+/5ek9MmDDBrFq1yuzYscP88MMPZsKECcbhcJh//etf1WaM56rGBBZjjJk2bZpp1qyZCQgIMD179jTffPNNZXep0g0aNMg0adLEBAQEmIsuusgMGjTIbNu2zbP+6NGj5t577zX16tUzwcHB5pZbbjF79+712scvv/xirr/+ehMUFGQaNmxoHnzwQXPixIkLPZTzbsWKFUZSsWXYsGHGmFO3kj7yyCMmIiLCOJ1Oc80115gtW7Z47eO3334zQ4YMMSEhISY0NNSMGDHCHDp0yKvm+++/N1dccYVxOp3moosuMk8//fSFGiJOY/OcYdP78aOPPjKXXHKJCQgIMJdeeqlZvHhxhY2zpDFKMm+//banpqLmqRUrVpjOnTubgIAAc/HFF3sdo8j5ek/cddddpnnz5iYgIMA0atTIXHPNNZ6wUl3GeK4cxhhzoc/qAAAA+KJGXMMCAACqNgILAACwHoEFAABYj8ACAACsR2ABAADWI7AAAADrEVgAAID1CCwAAMB6BBYAAGA9AgsAALAegQUAAFiPwAIAAKz3fzRON1QnENMXAAAAAElFTkSuQmCC\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAHNCAYAAADMjHveAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABFhUlEQVR4nO3de3yT5f3/8XeStkkLtBWBFrBY8ITIcSC1nsDZr0wY6g4OFQXZxOngN7R+laEI6iY4D8zNLw7nRDdlA93w8J18cVhFpiIgCoqcRBQQaQGhLaeekuv3R5pA6IEmaXK3d17PxyMP0jt3cn/uluu6P/lc133fDmOMEQAAgEWcVgcAAAASG8kIAACwFMkIAACwFMkIAACwFMkIAACwFMkIAACwFMkIAACwFMkIAACwFMkIAACwFMkIAACwFMkIEGcOh6NJj6VLlwbf8+STT8rhcCgvL69J2/jiiy/k8XjkcDj04Ycfhrx23333yeFwaO/evY1+xo033thofDt37gxZv6qqSjNmzFDPnj3l8XiUlZWlESNG6Ouvv27aL0bSt99+q0ceeUQXX3yxOnbsqMzMTJ133nlasGBBkz/jWAsWLND111+vM844Qw6HQ0OHDq13vVWrVmnixIk655xz1KZNG3Xr1k0/+clPtHnz5nrX37Bhg773ve+pbdu2at++vW644Qbt2bMnohgBSElWBwAkmueffz7k57/+9a9asmRJneVnn3128Pm8efOUm5urlStXasuWLTr99NMb3cbtt9+upKQkVVZWRhznz3/+cxUUFIQsM8bolltuUW5urrp27RpcXl1drREjRuj999/X+PHj1bdvX+3fv18rVqxQWVmZTjnllCZtc/ny5brnnns0fPhwTZ06VUlJSfrnP/+pa665RuvXr9f9998f1j788Y9/1OrVq3Xuuefq22+/bXC93/72t3rvvfd09dVXq2/fviouLtb//M//6Dvf+Y4++OAD9e7dO7ju119/rYsvvlgZGRmaMWOGDh48qEcffVSffvqpVq5cqZSUlLBiBCDJALDUhAkTTGNNcevWrUaSWbhwoenYsaO57777Gv28xYsXm5SUFDN16lQjyaxatSrk9enTpxtJZs+ePWHH+p///MdIMg8++GDI8t/+9rcmOTnZrFixIuzPPNbWrVvNV199FbLM5/OZ7373u8btdpuDBw+G9Xnbt283Xq/XGGPMOeecY4YMGVLveu+9956prKwMWbZ582bjdrvN6NGjQ5bfeuutJjU11Wzbti24bMmSJUaSeeqpp8KKD4AfwzRACzdv3jyddNJJGjFihH784x9r3rx5Da5bXV2tSZMmadKkSTrttNOaPZa//e1vcjgcuu6664LLfD6ffv/73+sHP/iBBg8erJqaGh0+fDiiz+/evbtOPfXUkGUOh0NXXXWVKisrtXXr1rA+LycnR07nibu5888/v05F44wzztA555yjDRs2hCz/5z//qe9///vq1q1bcFlBQYHOPPNMvfjii2HFB8CPZARo4ebNm6cf/vCHSklJ0bXXXqvPP/9cq1atqnfdxx9/XPv379fUqVObPY7q6mq9+OKLOv/885Wbmxtcvn79en3zzTfq27evbr75ZrVp00Zt2rRR37599fbbbzfLtouLiyVJHTp0aJbPawpjjEpKSkK2uXPnTu3evVuDBg2qs/7gwYP18ccfxy0+wE5IRoAWbPXq1dq4caOuueYaSdKFF16oU045pd7qSHFxsX7961/r17/+tdLT05s9ljfeeEPffvutRo8eHbL8888/lyT97ne/09KlS/XUU0/p2WefVUVFhb73ve/pk08+iWq7+/bt05///GdddNFF6ty5c1SfFY558+Zp586dGjVqVHDZrl27JKneODp37qx9+/ZFNU8HSFQkI0ALNm/ePGVlZemSSy6R5B+yGDVqlObPny+v1xuy7uTJk9WjRw/ddNNNMYnlb3/7m5KTk/WTn/wkZPnBgwclSQcOHFBRUZFuvPFG3XjjjXrzzTdljNHDDz8c8TZ9Pp9Gjx6t0tJSPfHEE1HFH46NGzdqwoQJys/P19ixY4PLjxw5Iklyu9113uPxeELWAdB0nE0DtFBer1fz58/XJZdcoi+//DK4PC8vT4899piKiop02WWXSZI++OADPf/88yoqKmrSHIljt3H8Kant27evM3/i4MGDevXVVzVs2DCdfPLJIa+lpqZKki644ALl5OQEl3fr1k0XXnih3n///SbHc7z/9//+nxYvXqy//vWv6tevX8SfE47i4mKNGDFCGRkZ+sc//iGXyxV8LbCv9VU/KioqQtYB0HQkI0AL9dZbb2nXrl2aP3++5s+fX+f1efPmBZORu+66SxdddJG6d++ur776SpKC1xHZtWuXtm/fHjLhMmDHjh3q3r17yLK33367zvU4XnnlFR0+fLjOEI0kdenSRZKUlZVV57VOnTpFPI/i/vvv15NPPqmHHnpIN9xwQ0SfEa6ysjJdfvnlKi0t1X/+85/gvgUEhmcCwzXH2rVrl9q3b19v1QRA40hGgBZq3rx56tSpk2bPnl3ntYULF+rll1/WnDlzlJqaqu3bt2vbtm11EgtJuuKKK5SRkaHS0tI6r2VnZ2vJkiUhy+qrQMybN09t27bVFVdcUee1Pn36KDk5uc5F0CTpm2++UceOHRvbzXrNnj1b9913n2677TZNnjw57PdHoqKiQiNHjtTmzZv15ptvqlevXnXW6dq1qzp27FjnQnKStHLlSvXv3z8OkQL2QzICtEBHjhzRwoULdfXVV+vHP/5xnde7dOmiv//973rttdc0atQo/elPf6pzOu1bb72lJ554Qo8++qh69uxZ73Y8Hk+dC5sdb8+ePXrzzTd17bXXKi0trc7r7dq10/Dhw/Wvf/1LGzduDG5rw4YNev/99/Xzn/+8qbstyX/V1F/+8pcaPXq0Zs2aFdZ7I+X1ejVq1CgtX75cr776qvLz8xtc90c/+pH+8pe/aMeOHcFhqaKiIm3evFm33357XOIF7IZkBGiBXnvtNR04cKDeSoQknXfeeerYsaPmzZunUaNGBYdrjhWohAwZMqTeU1GbasGCBaqpqal3iCZgxowZKioq0ne/+1398pe/lCT94Q9/UPv27XX33Xc3eVsrV67UmDFjdPLJJ+vSSy+tc9bQ+eefrx49ejT585YtW6Zly5ZJ8idVhw4d0m9+8xtJ0sUXX6yLL75YknTHHXfotdde08iRI7Vv3z698MILIZ9z/fXXB5/ffffdeumll3TJJZdo0qRJOnjwoB555BH16dNH48aNa3JsAI5h9VXXgERX3xVYR44caTwejzl06FCD77vxxhtNcnKy2bt3b72vP/vss/VegXXatGlGktm3b1+T4jvvvPNMp06dTE1NTaPrrV692hQUFJg2bdqYdu3amSuvvNJs3ry5Sds4PuaGHs8++2xYnxe42mx9j+nTpwfXGzJkSKPbPd66devMZZddZtLS0kxmZqYZPXq0KS4uDis2AEc5jDEmjrkPAIsVFhbq97//vSoqKpScnGx1OADAdUaARLNq1SqdfvrpJCIAWgzmjAAJ4tlnn9Vbb72ld999Vw8++GBct13f9UyO17ZtW7Vt2zaunwWgZWCYBkgQTqdT2dnZuuGGGzRjxoyQi3nF2ldffVXvacfHmj59uu677764fhaAloHKCJAgfD6fZduu73omx2vqWTLN+VkAWgYqIwAAwFJMYAUAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJYiGQEAAJZKCvcNy5Yt0yOPPKLVq1dr165devnll3XVVVc1+p6lS5eqsLBQn332mXJycjR16lTdeOONTd6mz+fTN998o3bt2snhcIQbMoAoGWN04MABdenSRU5n6/gOQ78BWK+pfUfYycihQ4fUr18//fSnP9UPf/jDE67/5ZdfasSIEbrllls0b948FRUV6aabblLnzp01bNiwJm3zm2++UU5OTrihAmhmO3bs0CmnnGJ1GE1CvwG0HCfqOxzGGBPphzscjhNWRiZPnqzXX39d69atCy675pprVFpaqsWLFzdpO2VlZcrMzNSOHTuUnp4eabgAIlReXq6cnByVlpYqIyPD6nCahH4DsF5T+46wKyPhWr58uQoKCkKWDRs2TLfddluTPyNQYk1PT6dTASzUmoY76DeAluNEfUfMk5Hi4mJlZWWFLMvKylJ5ebmOHDmi1NTUOu+prKxUZWVl8Ofy8vJYhwmglaPfAFqvFjkTbebMmcrIyAg+GPcFcCL0G0DrFfNkJDs7WyUlJSHLSkpKlJ6eXm9VRJKmTJmisrKy4GPHjh2xDhNAK0e/AbReMR+myc/P16JFi0KWLVmyRPn5+Q2+x+12y+12xzo0ADZCvwG0XmFXRg4ePKg1a9ZozZo1kvyn7q5Zs0bbt2+X5P92MmbMmOD6t9xyi7Zu3aq77rpLGzdu1JNPPqkXX3xRt99+e/PsAQAAaNXCTkY+/PBDDRgwQAMGDJAkFRYWasCAAZo2bZokadeuXcHERJK6d++u119/XUuWLFG/fv302GOP6c9//nOTrzECAADsLarrjMRLeXm5MjIyVFZWxil6gAVaYxtsjTEDdtPUdtgiz6YBAACJI+YTWHGMqirpySelL76QTjtN+sUvpJQUq6MCYEf0N2hFSEbi5a67pFmzJK/36LL//m+psFB6+GHr4gJgP/Q3aGVIRuLhrrukRx6pu9zrPbqcDgJAc6C/QSvEBNZYq6qS0tJCv6Ecz+WSDh+mhIoWqzW2wZYT80ZJZ8fw8zdI6ul/emx/kyLp35IuVP2zA1vPbYbQoi2XdF6Drza1HVIZacTGv3+s4sdekKOxROJE9uyWvBc0vo5XUo8bpY6dIt8OECHjStLQDx+1Ogzb2rvhAq27eYgcB2P1ve/nkvyXWgjpb3Ik3RajTQKS0q48rHPvy5cU/f9tkpFGVNx6u4aWvROfje2sfQBxViG3JJKRWFk3sY+GvhvrfmRZ3UVfxHiTSHhL2wyR7muezyIZaUSbim8lSe+dep2qu+ZG9iHffCN99eWJ18vtLnXpEtk2gGgkJWmo1THYmGOf/1vjJ+36aF+f9jHaSm015Nj+5hxJGTHaHCCp3feb787YJCONSPZVSJLaTf6F+t56gqGWhjR1zsimfzNnBLAhR0V3Scu079z2GloUiwpJA3NGPhdzRhAHy5vlU7joWSNSapOR5PT67y7ctA9J8Z9O15jCQhIRwKacVT7/E88I+cfWm/vR8+jGju1vqiQNlf8rp/OYx+Q7JUcs4uCRmI+GJ6+Gg8pII9y+I5Kk5Hae6D4ocBrd8ef9u1yc9w/YnKvS34840qL4UhMO+hu0QiQjxyj/ulyHdx8M/tzO+DuRlPQokxHJ3wH85jdcERGwtWKVf32GDu9OCy5JOdJVkuRMWyDp+5JyYx8G/Q1aGZKRWmufWKazf1mgdFXXea1ZkhHJ3xHcdlvzfBaAFmfN48PV6/ZKpevol5ps7ZYkOdt4JfWQ5ItPMPQ3aEVIRmrtX7xCKbWJSPUxv5Z1mReqX99sq8IC0IqU/rtdvf3IblcnnTp6m/xj7ACOxwTWgAr/ZNVlZ/9cyaY6+Biw/205k/g1AWiCCn9fsezsi5RsaoKPrjXf6JQLvhGnsAD14ygbcMQ/P8S4m2lIBkDiqRgoSTLuhpKOrfGLBWhFSEYCKv2VEZIRABGr8g/DGHfgEtnHP3Ktigxo0UhGajlrkxF5SEYANNVX8g+9+B+OylX+xe4P5L9BHoCmSNgJrL4an5Z99z4l7/CXTU/9+gP/C6lxuhYAgFbP+LrrncuGKPkL/6TV3K+3+V/wSP479TJhFWiKhE1G1j+3UkP/8+s6y5NO4cwZAE3z+cun13uJd1fXGguiAVqvhE1GKkrKJEm7nF21aeQdkqSkTifr3EdHWRkWgFakYre/krrHcbI+u+IcSVJSR6/OfWSVlWEBrU7CJiPeg/6zZ/am5WjoK7dbHA2A1qjm4L2SfqL97vYa+sqy417dYEVIQKuUuMnIIf+E1Zok5ogAiIz3kP+y7zXODDE/BIhcwp5NE6iM1CRz9gyAyNTUfqmpTqIfAaKRkJWRqoNV8n7uP4vGm0xlBEC4KmR8F6ryg7aSpJqkQ5IGS1qm2lNpAIQhIZORjV0u0dAD70uSvFRGAIRtuN7Jb6uhK/1n0niTXJJWSRou6S0rAwNapYQcpulxYK0kaacrR8ljrrU4GgCtz1q1/eLonXlrrkkKLgcQvoSsjHjkH+d1rfxAg7/TxeJoALQ+/ZRUs0+StPz283T+rA+CywGEL+EqI9WHq5UkryTJcxLzRQBEYpGSanySJFcbb+2ycyUtsiwioDVLuGSkorQi+NydwXwRAJHwKNnrvzOvq82D8p/Wu1JMXgUik3DJSGXZ0WTEk0nHAeBEinXszfACjxRvuSQpqe2dtesAiJTt54y88+Mn1Gbp68Gfk2oq1EFShdzyOB3WBQagVdj/RW99dtkF8hzzRUaSzqn+TJKU3K5KUo6k6vgHB9iErZMR4zM6/5+FSlbdm1YVJ+coN/4hAWhl1j96li7c+l69r3nlVPs+30r19DEAms72yUggEXnn6v+RK7Nd8LVTr7/IqrAAtCK+Iy5J0sbUs7T3+pNDXjspf7/O+c4G2bwrBWLO1i3I+I7eK6LPg9eo/RknN7I2ANRlfD+W9B+VZWTowj+9X88aLkk74hwVYC8Jk4w4mB8CIBK+wET3zuJmeEBs2PpsGpIRAFEz/n7EOOhDgFghGQGAxphAP0IfAsRKwiQj4lsNgAgYn/9Kq8Zp6+4SsJStWxeVEQBR81EZAWLN1smIr/beERLJCIAIBYZpqK4CMWPrZOTYyogzyda7CiBWmMAKxJytj9AM0wCIGhNYgZgjGQGAxjCBFYg5W7cukhEA0TJURoCYiygZmT17tnJzc+XxeJSXl6eVK1c2uG51dbUeeOABnXbaafJ4POrXr58WL14cccDhIBkBEDUmsAIxF3YysmDBAhUWFmr69On66KOP1K9fPw0bNky7d++ud/2pU6fqqaee0hNPPKH169frlltu0Q9+8AN9/PHHUQd/QoZkBECUfExgBWIt7GRk1qxZGj9+vMaNG6devXppzpw5SktL09y5c+td//nnn9fdd9+t4cOHq0ePHrr11ls1fPhwPfbYY1EHfyJURgBErXbOiBy2HtUGLBXWjfKqqqq0evVqTZkyJbjM6XSqoKBAy5cvr/c9lZWV8ng8IctSU1P17rvvNridyspKVVZWBn8uLy8PJ8wgkhEgcTRXv1EHwzRAzIWV6u/du1der1dZWVkhy7OyslRcXFzve4YNG6ZZs2bp888/l8/n05IlS7Rw4ULt2rWrwe3MnDlTGRkZwUdOTk44YQaRjACJo7n6jTq4zggQczGvO/7+97/XGWecoZ49eyolJUUTJ07UuHHj5GzkNLkpU6aorKws+NixY0dE2yYZARJHc/UbdVAZAWIurGGaDh06yOVyqaSkJGR5SUmJsrOz631Px44d9corr6iiokLffvutunTpol/96lfq0aNHg9txu91yu93hhFYvkhEgcTRXv1EHc0aAmAurdaWkpGjgwIEqKioKLvP5fCoqKlJ+fn6j7/V4POratatqamr0z3/+U1deeWVkEYeBZARA1BimAWIurMqIJBUWFmrs2LEaNGiQBg8erMcff1yHDh3SuHHjJEljxoxR165dNXPmTEnSihUrtHPnTvXv3187d+7UfffdJ5/Pp7vuuqt596Q+x5zaCwARYZgGiLmwk5FRo0Zpz549mjZtmoqLi9W/f38tXrw4OKl1+/btIfNBKioqNHXqVG3dulVt27bV8OHD9fzzzyszM7PZdqIhgcqITw57X2oWQOxwBVYg5sJORiRp4sSJmjhxYr2vLV26NOTnIUOGaP369ZFsJmqBZMTQiQCIVGDOCPemAWLG1q2LZARA1BimAWKOZAQAGsMEViDmbJ2MBDsRkhEAkaIyAsScrZMRKiMAosZ1RoCYs3XrIhkBEDUqI0DMkYwAQGNIRoCYs3cy4vWXV3323k0AsUQyAsScrY/SVEYARC0wEZ7rjAAxY+vWRTICIGqBCaz0I0DM2DoZ4dReAFFjmAaIOVsnI1RGAESNZASIuYRIRiivAohcbT/CnBEgZmzduoKVEb7RAIiQI3jRM/oRIFZsnYwwZwRA1BimAWLO1skIc0YARI1kBIg5khEAaIxhzggQa/ZuXQzTAIiWYc4IEGu2TkaojACIGsM0QMwlRDLCqb0AIuUgGQFiztbJSHCYhk4EQKSYMwLEnK1bF8M0AKLGdUaAmLN1MsIEVgDRY5gGiDVbJyNURgBEjTkjQMwlRDLCBFYAkXIwZwSIOXu3LiawAogW1xkBYs7WyQjDNACixjANEHO2TkZ8VTWSSEYARKJUUppcVZv8PzoWSdpoYTyAfdk2GVnz+3fUe3x+7U8kIwDC1V0fdOmr87cv9//okKSzrQwIsC3bJiOlL78dfP5lj0stjARAa2R8pRq068Pgz+1H7LcwGsDekqwOIGYqKiRJy866SRdvfNriYAC0NtWHOyhFeyVJu9d2UN++n1ocEWBftq2MOCqOSJJ8J3eyOBIArdHhPUerIpk9SmufbbAkFsDubFsZcVT6KyPyeKwNBECrdOTbJGVKqlaSUtpWWx0OYGu2rYw4q2qTkdRUawMB0CpV7i+VJB1WmqTvSqqwMhzA1mybjLiq/MM0jlQqIwDCV7l/qiSpwumR9Lak4ZbGA9iZbZMRZ7X/W4wj1W1xJABao6r930gKJCOStNa6YACbs20y4qqpkiQ5PSQjAMJXXdZNklSZFOhD+lkXDGBztk1GnD7/hDOnO9niSAC0RtVl10iSqlxuSZdIWmRpPICd2fZsGpfXXxlxeFIsjgRAa+Qt9/chVSmdJBVZGwxgc7atjLi8/sqIi2QEQAS8Bw5LkmqS0yyOBLA/+yYjvto5IwzTAIiA7+ABSVKNe584tReILdsmI0m1c0ZcqVRGAITPHFomSfK6HeLUXiC2bJyMUBkBEIWKckmSSQl0k5zaC8SKfZMR409GqIwAiEh1G0mSSXLULuDUXiBW7JuMBIZpPFRGAESg6gxJkklOEqf2ArFl32SktjKSlEZlBED4HDVe/5PkwZLeksStJYBYiSgZmT17tnJzc+XxeJSXl6eVK1c2uv7jjz+us846S6mpqcrJydHtt9+uiorYzkxPlr8yQjICICI1tXfqTaa6CsRa2MnIggULVFhYqOnTp+ujjz5Sv379NGzYMO3evbve9f/2t7/pV7/6laZPn64NGzbomWee0YIFC3T33XdHHXxjkgOVkVQ6EgDhc1T7+xCl8IUGiLWwk5FZs2Zp/PjxGjdunHr16qU5c+YoLS1Nc+fOrXf9999/XxdccIGuu+465ebm6rLLLtO11157wmpKtKiMAIiGg8oIEDdhJSNVVVVavXq1CgoKjn6A06mCggItX7683vecf/75Wr16dTD52Lp1qxYtWqThwxs+Z7+yslLl5eUhj3AYn1FKIBmhMgIkhGj7jeM5A8lICn0IEGthJSN79+6V1+tVVlZWyPKsrCwVFxfX+57rrrtODzzwgC688EIlJyfrtNNO09ChQxsdppk5c6YyMjKCj5ycnHDCVPXh6uDzlLZURoBEEG2/cTxn7Z2/HQzTADEX87Npli5dqhkzZujJJ5/URx99pIULF+r111/Xr3/96wbfM2XKFJWVlQUfO3bsCGubxyYjVEaAxBBtv3E8R+39rRxURoCYC+uuvR06dJDL5VJJSUnI8pKSEmVnZ9f7nnvvvVc33HCDbrrpJklSnz59dOjQId18882655575HTWzYfcbrfcbnc4oYWoPlQVfE5lBEgM0fYbx3OSjABxE1ZlJCUlRQMHDlRR0dHbaft8PhUVFSk/P7/e9xw+fLhOwuFyuSRJxphw422SkMqIJ6x8CwAkVchVs1eS5PQsFjfJA2Ir7CN1YWGhxo4dq0GDBmnw4MF6/PHHdejQIY0bN06SNGbMGHXt2lUzZ86UJI0cOVKzZs3SgAEDlJeXpy1btujee+/VyJEjg0lJc6s57K+MVClZKU7HCdYGgOMNl9NXKUlypOyQ/yZ5b1kaEWBnYScjo0aN0p49ezRt2jQVFxerf//+Wrx4cXBS6/bt20MqIVOnTpXD4dDUqVO1c+dOdezYUSNHjtSDDz7YfHtxHG+V/8qJXsUm2QFgd2vl9J0iSXIkGXGTPCC2HCZWYyXNqLy8XBkZGSorK1N6evoJ1//63a90ykXddUhpamMOxSFCwN7CbYMtQXQxf1efpO9V3wOf6oM7B+u8h9uIyggQvqa2Q1vem8ZX4/P/a8/dAxBzi6TayqrDdaq4SR4QW7Y8WhuvPxkxYr4IgEh45DC1N8ZzXi9ukgfElj2TEZ9/5MnYc/cAxIHD+L/UOFz0I0Cs2bKVBYdpHLbcPQBx4AwkI5yRB8ScLY/WDNMAiFagMqJ6LswIoHnZspUFhmmYwAogcv5+hGEaIPZs2cqOVkZsuXsA4sDJnBEgbmzZyoLJiINhGgCRcYg5I0C82DMZYZgGQJQ4mwaIH1u2MoZpAESLYRogfmzZyhimARA9JrAC8WLLVsYwDYBoBSoj4ksNEHO2PFofrYzYcvcAxEFwAiuVESDmbNnKuOgZgGgxgRWIH1u2Mu5NAyBaDuaMAHFjy1YWqIxwbxoAkeLeNED82PJoHUhGxDANgAgxZwSIH1u2MiojAKLFdUaA+LFnKzO1c0ZIRgBEKFAZcSbRjwCxZstWxtk0AKLFBFYgfmzZyrjOCIBocdEzIH5sebTm1F4A0WKYBogfW7Yy7k0DIFpOzqYB4saWrYy79gKIFskIED/2bGWcTQMgSo7afoSLngGxZ8ujNdcZARAt5owA8WPLVsYVWAFEi2EaIH7s2coYpgEQJSeVESBubNnKuM4IgOhUBJMROX4pqcLSaAC7s+XR2vg4tRdANIYHr8DqTFolabi14QA2Z8tkRFRGAERlrVzySpIcLiNprbXhADZny6O1qfF3IsbhsjgSAK1TPyXVJiOuFK+kftaGA9icPZORwKm9TpIRAOEzvteDz53J50paZF0wQAKwaTISqIzYcvcAxJi3Kjn43Jn0vCSPdcEACcCeR+vAMA2VEQAR8FZ5g89dKfQjQKzZMhlhzgiAaPhqfMHnzmT6ESDW7J2MUBkBEAEqI0B82TIZkY9TewFE7thkhCuwArFny1ZGZQRANHzVVEaAeLJlMiIvyQiAyB07Z4RkBIg9WyYjhmQEQBSOrYwwTAPEnj1bWeBy8C6SEQDhC8wZqRF9CBAPNk1Gar/VMIEVQAQClRGfTbtIoKWxZ0tjmAZAFAJzRrxURoC4iCgZmT17tnJzc+XxeJSXl6eVK1c2uO7QoUPlcDjqPEaMGBFx0CcUSEYYpgEQgUBlhGQEiI+wk5EFCxaosLBQ06dP10cffaR+/fpp2LBh2r17d73rL1y4ULt27Qo+1q1bJ5fLpauvvjrq4BsUGKahMgIgAiQjQHyFnYzMmjVL48eP17hx49SrVy/NmTNHaWlpmjt3br3rt2/fXtnZ2cHHkiVLlJaWFttkxMcEVgCRC84Z4ZYSQFwkhbNyVVWVVq9erSlTpgSXOZ1OFRQUaPny5U36jGeeeUbXXHON2rRp0+A6lZWVqqysDP5cXl4eTphMYAUSUNT9xjECc0aYwArER1gtbe/evfJ6vcrKygpZnpWVpeLi4hO+f+XKlVq3bp1uuummRtebOXOmMjIygo+cnJxwwlTGZ+/5n1AZARJGtP3GURUqeeNeSZJPDkmZkkqbJ0gA9Ypr2v/MM8+oT58+Gjx4cKPrTZkyRWVlZcHHjh07wtrOgNKlkiTj5FsNkCii7TeOGq7T5vi/0Djlk1QmqXtzhQmgHmEN03To0EEul0slJSUhy0tKSpSdnd3oew8dOqT58+frgQceOOF23G633G53OKEFGZ+RkUNOGWXdPjqizwDQ+kTTb4RaK5dxSJLWXdlbQ7RMVEaA2AqrdJCSkqKBAweqqKgouMzn86moqEj5+fmNvvell15SZWWlrr/++sgibaLqw9VyykiSulzYI6bbAmBH/dTWHJIknXbHF7XLMi2LBkgEYY9jFBYW6umnn9Zf/vIXbdiwQbfeeqsOHTqkcePGSZLGjBkTMsE14JlnntFVV12lk08+OfqoG3Fk35Hgc89JqTHdFgD7qal4TamqkCSlZR2SlCHpS0tjAuwurGEaSRo1apT27NmjadOmqbi4WP3799fixYuDk1q3b98u53FzNTZt2qR3331X//73v5sn6kZUlVcEn6e0TYn59gDYy6GSGmXUPm/buUQS/QgQa2EnI5I0ceJETZw4sd7Xli5dWmfZWWedJWNMJJsKW2WZPxk5Io9SnY64bBOAXVTo8O7rlCGpSslKaXuZpMWSPBbHBdib7U43+WbxJ5KkCgdDNADCNVybZ/jnixx0tJX0jqThlkYEJALbJSOVO/yXpT/J7Lc4EgCtz1ppm/9Z+2AfstayaIBEYbtkxNReCn5F1kiLIwHQ+vST/F2Ilp4/5OgyADFlu2REvtq5KVwKHkDYFkmm9lYVToekIf5lAGLKfkfswE3yHExeBRAuj2Rqr0/kuEjSUjF5FYg9+yUjwbN2SEYARCDQh3A7CSBubNfaAqcQc18aAJFw1FZXRXUViBv7HbG9tR0JlREAkaAyAsSd/VoblREA0TBURoB4s98R20dlBEAUqIwAcWe/1hboSPhWAyACzBkB4s92yUhwAivXGQEQESojQLzZr7V5+VYDIHJURoD4s18ywgRWANFgzggQd/ZrbUxgBRANzqYB4s5+yQgTWAFEwRHoQ1z26x6Blsp+rY1hGgDRqK2MOPhCA8SN/Y7YDNMAiIKDOSNA3NmvtVEZARAN5owAcWe/Izan5QGIApURIP7s19oCHQnDNAAiEaiMOOlDgHixbzLCtxoAEQhURhz0IUDc2K+1MUwDIBrMGQHizn7JCBNYAUSB64wA8We/1sapvQCiwXVGgLizXzLCFVgBRIGzaYD4s19royMBEAUHc0aAuLPfEZsJrACiUns2DXNGgLixX2sLTGAlGQEQAQdfaIC4s20yIof9dg1APFAZAeLNfq2NbzUAosCcESD+7JeMiAmsACIXvAIrlREgbmzX2hjvBRANKiNA/NkuGeE6IwCiwxVYgXizX2vjOiMAouDgCqxA3NnviM0wDYAocG8aIP5s2NqojACIHJURIP5sd8RmAiuA6HA2DRBvtmttjsojtU9IRgCEx/j2q+eBVf4fHLMklVoZDpAwbJeMDNoy3/8kUCEBgCZ692c/UoqqJUmOpCOSulsbEJAgbJeM7PCcIUlydOpocSQAWhvvhqNfYnrevFFURoD4sF0y4vLVSJIyLuxjcSQAWhtHlb9LXHreEKWfclBSpqXxAInCdsmI0/iTEWdKksWRAGhtHFX+yqrckj8R+dK6YIAEYrtkxEUyAiBCjir/fBG5h0naLyojQHyQjABALWdVpf+Jx21tIECCiSgZmT17tnJzc+XxeJSXl6eVK1c2un5paakmTJigzp07y+1268wzz9SiRYsiCvhEkoz/m43LkxyTzwdgX84afzLiSPVYHAmQWMIuHyxYsECFhYWaM2eO8vLy9Pjjj2vYsGHatGmTOnXqVGf9qqoq/dd//Zc6deqkf/zjH+ratau2bdumzMzM5oi/jkBlxOWmMgIgPK5qfzLipDICxFXYR+xZs2Zp/PjxGjdunCRpzpw5ev311zV37lz96le/qrP+3LlztW/fPr3//vtKTvZXK3Jzc6OLuhFJYpgGQGRctZURZyrJCBBPYQ3TVFVVafXq1SooKDj6AU6nCgoKtHz58nrf89prryk/P18TJkxQVlaWevfurRkzZsjr9Ta4ncrKSpWXl4c8morKCJCYouk3AlxekhHACmElI3v37pXX61VWVlbI8qysLBUXF9f7nq1bt+of//iHvF6vFi1apHvvvVePPfaYfvOb3zS4nZkzZyojIyP4yMnJaXKMgcpIUipzRoBEEk2/EZBEZQSwRMzPpvH5fOrUqZP+9Kc/aeDAgRo1apTuuecezZkzp8H3TJkyRWVlZcHHjh07mry9QDJCZQRILNH0GwFJPn8y4kojGQHiKawjdocOHeRyuVRSUhKyvKSkRNnZ2fW+p3PnzkpOTpbL5QouO/vss1VcXKyqqiqlpKTUeY/b7ZbbHX5nYHxGySQjQEKKtN84qkLJ3oOSpKQ2T0saIomzaoB4CKsykpKSooEDB6qoqCi4zOfzqaioSPn5+fW+54ILLtCWLVvkO+bGdZs3b1bnzp3rTUSi4a06Og8lyUMyAiAcw4+pjGyUNNzacIAEEvYwTWFhoZ5++mn95S9/0YYNG3Trrbfq0KFDwbNrxowZoylTpgTXv/XWW7Vv3z5NmjRJmzdv1uuvv64ZM2ZowoQJzbcXtXw1RxMeZ5LtrucGIKbWymX8fYjL7ZO01tpwgAQSdvlg1KhR2rNnj6ZNm6bi4mL1799fixcvDk5q3b59u5zOo4lATk6O3njjDd1+++3q27evunbtqkmTJmny5MnNtxe1jM8c/cHhaPbPB2Bn/eTURkmSw2Uk9bM2HCCBOIwx5sSrWau8vFwZGRkqKytTenp6g+tVlFbIc1Kq/z07ypR+SsPrAmi6prbBliT8mCu0y9VdnX3F2jT/Bzpr1N/EnBEgOk1th7Yayzi2MsIwDYDweIIdosN1n0hEgPix1RH72DkjDifDNADC46ydM+Jw2aprBFo8W7W4YysjJCMAwuWU/4w8khEgvmzV4khGAETDKX9lxJnsOsGaAJoTyQgA1AoM0zDnDIgvW7U4JrACiIZDzBkBrGCrFme8TGAFEDlX7ZwRvswA8WWrFscwDYBoMGcEsAbJCADUCiYjVEaAuLJViyMZARANF6f2ApawVYsjGQEQDSojgDVs1eKYwAogUsZn5JT/Cw1zRoD4slcyUlsZ8YlEBEB4uDQAYB1btbhAZ2JIRgCEyVvlDT4nGQHiy1YtjmQEQKRCbrTJBFYgrmzV4o4O09hqtwDEwbHJiCuFOSNAPNnqqB2YwEplBEC4jk1GGKYB4stWLY5hGgCRYs4IYB1btTiSEQCROvbSACQjQHzZq8UZkhEAkWHOCGAdWyUjVEYARIo5I4B1bNXiAp0JZ9MACJev+uicEa7gDMSXvY7aDNMAiFDgy0yNGKIB4s1WyQjDNAAiRWUVsI6tWt3Re0uQjAAIT+BsGpIRIP5s1eqClREHyQiA8ATmjJCMAPFnr1ZnuBw8gMgEhmm8zBkB4s5WR+1AZ8KcEQDhYpgGsI69Wh1n0wCIUPDLjMNe3SLQGtiq1XE2DYBIMWcEsI6tWh1n0wCIVGCYhjkjQPzZKhkJTmClzAogTAzTANaxVasLfLNhmAZAuJjACljHVq2OOSMAIhWYM2Ls1S0CrYKtWh1zRgBEKjhnxMGcESDebJWMBE/t5QqsAMIUHOZlzggQd7ZqdYHKCGO+AMLFnBHAOrZqdYHOhGEaAOEKzhmhMgLEna1aHTfKAxCpYGWEOSNA3NkqGeFy8AAidfTSAPbqFoHWwFatjlN7AUSmQsb7B0mSz1EtaaikCisDAhKKrZKRfW+sqn1GMgIgHMOVNH2TpMAw7zuShlsaEZBIbJWMmCP+bzLZNTssjgRA67JWnupKSVJ5m/TgMgDxYatkRBX+ZGTF2eMsDgRA69JPbasPSJLa/P5gcBmA+IgoGZk9e7Zyc3Pl8XiUl5enlStXNrjuc889J4fDEfLweDwRB9yo2mTEuGP0+QBsapEyfOWSpLY5FZKGSFpkaURAIgk7GVmwYIEKCws1ffp0ffTRR+rXr5+GDRum3bt3N/ie9PR07dq1K/jYtm1bVEE3xFFxRJJkPKkx+XwA9nRkn1Ga/P1Heu5aSUsl8aUGiJewk5FZs2Zp/PjxGjdunHr16qU5c+YoLS1Nc+fObfA9DodD2dnZwUdWVlZUQTe4ncra2e+xqrwAsKWyr3ZJkmrkUvopV4kzaYD4CisZqaqq0urVq1VQUHD0A5xOFRQUaPny5Q2+7+DBgzr11FOVk5OjK6+8Up999lmj26msrFR5eXnIoykcVbUdSCqVESDRRNpvSNKBbXdIkkodmXI4l4ozaYD4CisZ2bt3r7xeb53KRlZWloqLi+t9z1lnnaW5c+fq1Vdf1QsvvCCfz6fzzz9fX3/9dYPbmTlzpjIyMoKPnJycJsXnrJ0N73CnNHGPANhFpP2GJB0p9ldGDrna1C7hTBognmJ+Nk1+fr7GjBmj/v37a8iQIVq4cKE6duyop556qsH3TJkyRWVlZcHHjh1NO1XX4au9N42LyzkDiSbSfkOSvIf9iUuVK/BFhjNpgHhKCmflDh06yOVyqaSkJGR5SUmJsrOzm/QZycnJGjBggLZs2dLgOm63W263O5zQJEkOU5uMcG8aIOFE2m9IUs2hGyT9QzXOZEmXiDNpgPgKqzKSkpKigQMHqqioKLjM5/OpqKhI+fn5TfoMr9erTz/9VJ07dw4v0qaovTeNXPa6fAqA2PJV+PuOGleGpLfEmTRAfIVVGZGkwsJCjR07VoMGDdLgwYP1+OOP69ChQxo3zn+hsTFjxqhr166aOXOmJOmBBx7Qeeedp9NPP12lpaV65JFHtG3bNt10003Nuyc6WhlxUBkBEAbvEf98M68rssoKgOiEnYyMGjVKe/bs0bRp01RcXKz+/ftr8eLFwUmt27dvl9N5tDKxf/9+jR8/XsXFxTrppJM0cOBAvf/+++rVq1fz7UVAYJjGSWUEQNP5gskIk98BK4SdjEjSxIkTNXHixHpfW7p0acjPv/vd7/S73/0uks2EzcEwDYAImIoqSZI3icoIYAV7HbUZpgEQAV9FbWUkmWQEsIKtkpFgZYRhGgDhqPRXRnxJDNMAVrDVUZtTewFEwtRWRnxURgBL2CoZkfyVEQdzRgCEo8pfGTFURgBL2OqoHbwCK5URAOGo9FdGTAqVEcAKtkpGqIwAiAjJCGApWx21mTMCIBKOav8wjVIYpgGsYLNkhMoIgPA5qvyVEUV4bxsA0bHVUZvKCIBIOGqojABWslUyEpgzwhVYAYTDGaiMeKiMAFaw1VGbG+UBiISztjLioDICWMJmyQiVEQDhc9b4KyPOVCojgBVsddSmMgIgEq7aZMRBMgJYwlbJCNcZARAJl9c/TON0M0wDWMFWR23OpgEQiaTayogrjcoIYAWbJSNURgCEz+WrrYx4qIwAVrDVUdshKiMAwpfspTICWMleyUhgAiuVEQBNVqEk32FJUlKbP0qqsDYcIAHZ6qjNMA2A8A1Xsq+2MpK6XtJwa8MBEpCtjtoM0wAI31olmRpJksvjlbTW2nCABGSvZITKCICw9ZPLeCUFkpF+1oYDJCBbHbUDlRGHk8oIgKZaJJf8yYgzubekRdaGAyQgeyUjVEYAhM0jV+3kd5f7EUkea8MBEpCtjtrMGQEQCZf8c0acyS6LIwESk72SESojACKQVJuMuNxJFkcCJCZbHbWZMwIgEoE5IyQjgDXslYxQGQEQgeRAZSSFYRrACrY6ajNnBEC4fDW+4HMqI4A17JWMUBkBEKaaiprgcyojgDVsddRmzgiAcIUkI1RGAEvYLBmhMgIgPN4qb/B5kodkBLCCrY7awbv2UhkB0ETeSoZpAKvZKxmhMgIgTMdWRkhGAGvY6qjtNJxNAyA8gcqITw45k2zVJQKths1anr8yQocCoKkClZEaMV8EsIqtjtpOrjMCIEyBygjJCGAdWyUjzBkBEK5AMuIV80UAq9jqqB04m4ZhGgBN5av2D9N4HVRGAKvY6qjNMA2AcFEZAaxnq2TEwQRWAGGiMgJYz1ZHbSojAMLlq6IyAljNVslI4EZ5VEYANFUwGaEyAljGVkdtbpQHIFwM0wDWs1kywqm9AMITqIz4HAzTAFax1VHbSWUEQJgClREflRHAMhElI7Nnz1Zubq48Ho/y8vK0cuXKJr1v/vz5cjgcuuqqqyLZ7AlRGQEQLiojgPXCPmovWLBAhYWFmj59uj766CP169dPw4YN0+7duxt931dffaX//u//1kUXXRRxsCdCZQRAuIITWJ1URgCrhJ2MzJo1S+PHj9e4cePUq1cvzZkzR2lpaZo7d26D7/F6vRo9erTuv/9+9ejRI6qAG8N1RgCEy9QwTANYLayjdlVVlVavXq2CgoKjH+B0qqCgQMuXL2/wfQ888IA6deqkn/3sZ03aTmVlpcrLy0MeTcF1RoDEFWm/wTANYL2wkpG9e/fK6/UqKysrZHlWVpaKi4vrfc+7776rZ555Rk8//XSTtzNz5kxlZGQEHzk5OU16H5URIHFF2m8EKyMM0wCWielR+8CBA7rhhhv09NNPq0OHDk1+35QpU1RWVhZ87Nixo0nvY84IkLgi7TdMdW1lxEllBLBKWF8FOnToIJfLpZKSkpDlJSUlys7OrrP+F198oa+++kojR44MLvP5/AlDUlKSNm3apNNOO63O+9xut9xudzihSZKcnE0DJKxI+w0qI4D1wjpqp6SkaODAgSoqKgou8/l8KioqUn5+fp31e/bsqU8//VRr1qwJPq644gpdcsklWrNmTZPLqE1hfCb4nMoIgKY6WhkhGQGsEnbrKyws1NixYzVo0CANHjxYjz/+uA4dOqRx48ZJksaMGaOuXbtq5syZ8ng86t27d8j7MzMzJanO8mgZn1EgBWHOCICmCiQjhmEawDJhJyOjRo3Snj17NG3aNBUXF6t///5avHhxcFLr9u3b5XTGPxnw1fiCZR4qIwCaimEawHoRtb6JEydq4sSJ9b62dOnSRt/73HPPRbLJEzp2mIbKCICmojICWM82R21fje/oD1xnBEATGa+/MmKojACWsWUyQmUEQJNRGQEsZ5ujNsM0ACJhamqTEReVEcAqtjlqH1sZYQIrgCarncBKMgJYxzbJCJURABGpYZgGsJptjtpURgBExEtlBLCabZIRGSojACJQU+X/17VZ0nclVVgZDZCQbHPUpjICICI1ayVJxuWT9Lak4ZaGAyQi2yQjzBkBEBHvIUmSCY7SrLUsFCBR2WaQ1J3h0dIL7pF8Pg2hMgKgidpdcZKWOoeozWUHa5f0szQeIBHZJhlp06mNhr77G6vDANDKDJzyvDRluKQvJV0iaZHFEQGJxzbJCABExiPpLauDABIakysAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAIClWsWN8owxkqTy8nKLIwESU6DtBdpia0C/AVivqX1Hq0hGDhw4IEnKycmxOBIgsR04cEAZGRlWh9Ek9BtAy3GivsNhWsFXHZ/Pp2+++Ubt2rWTw+FocL3y8nLl5ORox44dSk9Pj2OEscM+tXx22x+p7j4ZY3TgwAF16dJFTmfrGN1N5H6jPomyn1Li7Gtr2M+m9h2tojLidDp1yimnNHn99PT0FvuHiRT71PLZbX+k0H1qLRWRAPqN+iXKfkqJs68tfT+b0ne0jq84AADAtkhGAACApWyVjLjdbk2fPl1ut9vqUJoN+9Ty2W1/JHvuU0MSZV8TZT+lxNlXO+1nq5jACgAA7MtWlREAAND6kIwAAABLkYwAAABLkYwAAABL2SYZmT17tnJzc+XxeJSXl6eVK1daHVKDZs6cqXPPPVft2rVTp06ddNVVV2nTpk0h6wwdOlQOhyPkccstt4Sss337do0YMUJpaWnq1KmT7rzzTtXU1MRzV4Luu+++OvH27Nkz+HpFRYUmTJigk08+WW3bttWPfvQjlZSUhHxGS9qf3NzcOvvjcDg0YcIESa3j77Ns2TKNHDlSXbp0kcPh0CuvvBLyujFG06ZNU+fOnZWamqqCggJ9/vnnIevs27dPo0ePVnp6ujIzM/Wzn/1MBw8eDFnnk08+0UUXXSSPx6OcnBw9/PDDsd61ZtOS+42m9BPN1a6WLl2q73znO3K73Tr99NP13HPP1YknXr+rhx56SA6HQ7fddltwmZ32c+fOnbr++ut18sknKzU1VX369NGHH34YfD2e7fKll15Sz5495fF41KdPHy1atKhZ9zUsxgbmz59vUlJSzNy5c81nn31mxo8fbzIzM01JSYnVodVr2LBh5tlnnzXr1q0za9asMcOHDzfdunUzBw8eDK4zZMgQM378eLNr167go6ysLPh6TU2N6d27tykoKDAff/yxWbRokenQoYOZMmWKFbtkpk+fbs4555yQePfs2RN8/ZZbbjE5OTmmqKjIfPjhh+a8884z559/fvD1lrY/u3fvDtmXJUuWGEnm7bffNsa0jr/PokWLzD333GMWLlxoJJmXX3455PWHHnrIZGRkmFdeecWsXbvWXHHFFaZ79+7myJEjwXW+973vmX79+pkPPvjA/Oc//zGnn366ufbaa4Ovl5WVmaysLDN69Gizbt068/e//92kpqaap556Kl67GbGW3m80pZ9ojna1detWk5aWZgoLC8369evNE088YVwul1m8eHFwnXj9rlauXGlyc3NN3759zaRJk2y3n/v27TOnnnqqufHGG82KFSvM1q1bzRtvvGG2bNkSXCde7fK9994zLpfLPPzww2b9+vVm6tSpJjk52Xz66afNsq/hskUyMnjwYDNhwoTgz16v13Tp0sXMnDnTwqiabvfu3UaSeeedd4LLhgwZEtIYj7do0SLjdDpNcXFxcNkf//hHk56ebiorK2MZbr2mT59u+vXrV+9rpaWlJjk52bz00kvBZRs2bDCSzPLly40xLW9/jjdp0iRz2mmnGZ/PZ4xpfX+f45MRn89nsrOzzSOPPBJcVlpaatxut/n73/9ujDFm/fr1RpJZtWpVcJ3/+7//Mw6Hw+zcudMYY8yTTz5pTjrppJB9mjx5sjnrrLNivEfRa239xvH9RHO1q7vuusucc845IdsaNWqUGTZsWPDnePyuDhw4YM444wyzZMmSkPZlp/2cPHmyufDCCxt8PZ7t8ic/+YkZMWJEyPbz8vLMz3/+8+h2MkKtfpimqqpKq1evVkFBQXCZ0+lUQUGBli9fbmFkTVdWViZJat++fcjyefPmqUOHDurdu7emTJmiw4cPB19bvny5+vTpo6ysrOCyYcOGqby8XJ999ll8Aj/O559/ri5duqhHjx4aPXq0tm/fLklavXq1qqurQ/5GPXv2VLdu3YJ/o5a4PwFVVVV64YUX9NOf/jTkhmut7e9zrC+//FLFxcUhf5OMjAzl5eWF/E0yMzM1aNCg4DoFBQVyOp1asWJFcJ2LL75YKSkpwXWGDRumTZs2af/+/XHam/C1xn7j+H6iudrV8uXLQz4jsE7gM+L1u5owYYJGjBhRJxY77edrr72mQYMG6eqrr1anTp00YMAAPf3008HX49kuT/T7iLdWcaO8xuzdu1derzfkP6EkZWVlaePGjRZF1XQ+n0+33XabLrjgAvXu3Tu4/LrrrtOpp56qLl266JNPPtHkyZO1adMmLVy4UJJUXFxc7z4HXou3vLw8PffcczrrrLO0a9cu3X///brooou0bt06FRcXKyUlRZmZmXXiDcTa0vbnWK+88opKS0t14403Bpe1tr/P8QIx1BfjsX+TTp06hbyelJSk9u3bh6zTvXv3Op8ReO2kk06KSfzRam39Rn39RHO1q4bWKS8v15EjR7R///6Y/67mz5+vjz76SKtWrarzmp32c+vWrfrjH/+owsJC3X333Vq1apV++ctfKiUlRWPHjo1ru2zo92FV/9Tqk5HWbsKECVq3bp3efffdkOU333xz8HmfPn3UuXNnXXrppfriiy902mmnxTvME7r88suDz/v27au8vDydeuqpevHFF5WammphZNF75plndPnll6tLly7BZa3t74PWraF+wg527NihSZMmacmSJfJ4PFaHE1M+n0+DBg3SjBkzJEkDBgzQunXrNGfOHI0dO9bi6KzV6odpOnToIJfLVWdmdUlJibKzsy2KqmkmTpyof/3rX3r77bdPeKvzvLw8SdKWLVskSdnZ2fXuc+A1q2VmZurMM8/Uli1blJ2draqqKpWWloasc+zfqKXuz7Zt2/Tmm2/qpptuanS91vb3CcTQWLvJzs7W7t27Q16vqanRvn37Wvzf7URaU7/RUD/RXO2qoXXS09OVmpoa89/V6tWrtXv3bn3nO99RUlKSkpKS9M477+gPf/iDkpKSlJWVZYv9lKTOnTurV69eIcvOPvvs4JB2PNtlQ+tY9f+/1ScjKSkpGjhwoIqKioLLfD6fioqKlJ+fb2FkDTPGaOLEiXr55Zf11ltv1Smn1WfNmjWS/P+ZJSk/P1+ffvppyH/KJUuWKD09vc5/discPHhQX3zxhTp37qyBAwcqOTk55G+0adMmbd++Pfg3aqn78+yzz6pTp04aMWJEo+u1tr9P9+7dlZ2dHfI3KS8v14oVK0L+JqWlpVq9enVwnbfeeks+ny+YfOXn52vZsmWqrq4OrrNkyRKdddZZLXaIRmod/caJ+onmalf5+fkhnxFYJ/AZsf5dXXrppfr000+1Zs2a4GPQoEEaPXp08Lkd9lOSLrjggjqnZ2/evFmnnnqqpPi2yxP9PuLOkmmzzWz+/PnG7Xab5557zqxfv97cfPPNJjMzM2RmdUty6623moyMDLN06dKQU0MPHz5sjDFmy5Yt5oEHHjAffvih+fLLL82rr75qevToYS6++OLgZwROZbvsssvMmjVrzOLFi03Hjh0tOxX2jjvuMEuXLjVffvmlee+990xBQYHp0KGD2b17tzHGf2pet27dzFtvvWU+/PBDk5+fb/Lz81vs/hjjn0nfrVs3M3ny5JDlreXvc+DAAfPxxx+bjz/+2Egys2bNMh9//LHZtm2bMcZ/CmFmZqZ59dVXzSeffGKuvPLKek8hHDBggFmxYoV59913zRlnnBFyCmFpaanJysoyN9xwg1m3bp2ZP3++SUtLazWn9rbkfuNE/YQxzdOuAqe83nnnnWbDhg1m9uzZ9Z7yGs/f1fFnq9llP1euXGmSkpLMgw8+aD7//HMzb948k5aWZl544YXgOvFql++9955JSkoyjz76qNmwYYOZPn06p/Y2hyeeeMJ069bNpKSkmMGDB5sPPvjA6pAaJKnex7PPPmuMMWb79u3m4osvNu3btzdut9ucfvrp5s477wy5joUxxnz11Vfm8ssvN6mpqaZDhw7mjjvuMNXV1Rbskf8Uuc6dO5uUlBTTtWtXM2rUqJBz548cOWJ+8YtfmJNOOsmkpaWZH/zgB2bXrl0hn9GS9scYY9544w0jyWzatClkeWv5+7z99tv1/j8bO3asMcZ/GuG9995rsrKyjNvtNpdeemmdff3222/Ntddea9q2bWvS09PNuHHjzIEDB0LWWbt2rbnwwguN2+02Xbt2NQ899FC8djFqLbnfOFE/YUzztau3337b9O/f36SkpJgePXqEbCMgnr+r45MRO+3n//7v/5revXsbt9ttevbsaf70pz+FvB7Pdvniiy+aM88806SkpJhzzjnHvP766826r+FwGGNMnIsxAAAAQa1+zggAAGjdSEYAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAIClSEYAAICl/j/GsqQeHOOS2gAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHNCAYAAAD49brCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABRZ0lEQVR4nO3deXhU5d0+8Hv2yZ6wZINgAAFBCAhqTLFiaxBc6vLWGi2+Cm1BMSiKVeGHQLUILpW6lBKhBWmLAqKolQilQXADqYAohTeRfU0IhMk6me08vz+ezMCQSWYmhMycmftzXXM5OfPMmecM4Xjz/T4zRyOEECAiIiKKUNpQT4CIiIjoYmLYISIioojGsENEREQRjWGHiIiIIhrDDhEREUU0hh0iIiKKaAw7REREFNEYdoiIiCiiMewQERFRRGPYISIioojGsEOqpNFoArpt3LgRBw8ehEajwR/+8Aef+/rd734HjUaDU6dOebaNHTvWaz8mkwl9+/bFzJkz0djYGNR8HnrooRb3e+7NbDYDALKzswM6trfeeqtNr52TkwNfV4nRaDSYNGmS3/d+48aNrb7m8uXLAQC7d++G0WjEuHHjmu3DYrEgIyMDubm5WLx4cUDHm52d7fXn5b4ZDAZkZ2fj0UcfhcViaXHeTz31FDQaDQoKCvwe4/mWL1+OoUOHwmw2o2vXrvj1r3/t9fviVlFRgXHjxiE1NRUxMTEYOnQo3n333aBf7/jx47jvvvvQr18/JCQkIDk5GVdffTWWLl3q88/On+effx633XYb0tLSoNFo8Lvf/c7nuPfffx8FBQXo1asXYmNj0a9fPzzxxBMtvq8fffSR533p0aMHZs2aBafTGfT8iC42fagnQNQWf//7371+/tvf/ob169c3296/f39YrdY2vYbJZMJf/vIXAEB1dTU+/PBD/P73v8e+ffuwbNmyZuNHjhyJ+++/v9n2vn37trjfc+l0OgDAq6++irq6Os/24uJivPPOO/jjH/+ILl26eLb/6Ec/Cvq1AeD777/H+++/j5///OfNHgvGo48+iquuuqrZ9ry8PADAgAED8OSTT2LOnDkYO3YsRowY4RkzdepUVFZW4pNPPkFiYmKzP7ff/OY3uPrqqzFhwgTPtvj4eK8xCxYsQHx8POrr61FSUoI33ngD27dvxxdffNFsTkIIvPPOO8jOzsY///lP1NbWIiEhIaDjXLBgAR5++GHccMMNmDdvHo4ePYrXXnsN33zzDb7++mtPSK2pqcG1116LiooKTJ48Genp6Vi5ciXuvvtuLFu2DL/85S8Dej0AOHXqFI4ePYq77roLPXr0gMPhwPr16zF27FiUlpZizpw5Ae8LAJ555hmkp6fjiiuuwLp161ocN2HCBGRmZuK+++5Djx498P333+NPf/oTiouLsX37dsTExHjGfvLJJ7jjjjtw/fXX44033sD333+P2bNn4+TJk1iwYEFQ8yO66ARRBCgsLBQt/TofOHBAABAvv/yyz8dnzZolAIjKykrPtgceeEDExcV5jVMURVxzzTVCo9GI8vJyr8cAiMLCQr/z9LVff15++WUBQBw4cMDn48G8dkxMjOjbt6/IyckRiqK0aT+ffvqpACDeffddv2OtVqvo3bu36Nevn7DZbEIIIb766iuh0WjElClTWnxeXFyceOCBB3w+5uvPSwghCgoKBADx9ddfN3vOhg0bBACxYcMGYTAYxFtvveV37kIIYbPZRHJysrjuuuu83q9//vOfAoB4/fXXPdteeuklAUCUlJR4trlcLnHVVVeJ9PR0z/FfiFtvvVXExcUJp9MZ1PPcvzuVlZUCgJg1a5bPcZ9++mmzbUuXLhUAxKJFi7y2DxgwQAwePFg4HA7PtunTpwuNRiP27NkT1PyILja2sYgCpNFocO2110IIgf3794d6Om2i1WrxzDPP4LvvvsPq1asv+uuZzWYsWLAApaWlmDt3LhwOByZMmICsrCw899xz7fpaP/7xjwEA+/bta/bYsmXLMGDAAPzkJz9Bfn6+z8qcL7t27YLFYkFBQQE0Go1n+6233or4+HhPyw4APv/8c3Tt2hU//elPPdu0Wi3uvvtulJeXY9OmTW09NI/s7Gw0NDTAbrcH/bxAXH/99c223XnnnQCAPXv2eLbt3r0bu3fvxoQJE6DXn20QPPzwwxBCYNWqVUHNj+hiYxuLokZDQ4PPdRYNDQ0B7+PgwYMAgJSUlGaPNTY2+tx/YmIijEaj1zZf44xGIxITEwOeS1tf+5e//CV+//vf47nnnsOdd97p9T/xYNTW1vp8zc6dO3vtc+TIkbj33nsxd+5cHD9+HLt27cKHH36IuLi4Nr1uS1r6s7HZbHjvvffwxBNPAADuvfdejBs3DuXl5UhPT291nzabDQC82jduMTEx2LFjBxRFgVarhc1m8zkuNjYWALBt2zaMHDkyqGOyWq2or69HXV0dNm3ahCVLliAvL8/n61ws5eXlAODVQt2xYwcA4Morr/Qam5mZie7du3seJwoXrOxQ1Jg1axa6du3a7Pbyyy+3+JxTp07h1KlT2LdvH1555RW89957GDhwIPr169ds7F//+lef+3///fe9xtXX1/scd/fdd7f52AJ9bUCuDXrmmWewc+dOfPDBB21+zV/96lc+X7OioqLZ2D/+8Y+IjY3FwoULcccdd+C2225r8+u6VVVV4dSpUzh06BCWLFmC+fPno2vXrrjuuuu8xn388cewWCy45557AAB33HEHDAaDV1WmJX369IFGo8GXX37ptb20tBSVlZWwWq04c+YMAKBfv344evQoDh065DX2888/BwAcO3Ys6GN87bXX0LVrV/Ts2RNjx47FNddcE9C829OLL74InU6Hu+66y7PtxIkTAICMjIxm4zMyMnD8+PEOmx9RIFjZoagxYcIE/OIXv2i2/W9/+1uzBbLA2VByrmuvvRZLly71WQ25/fbbfX6aadCgQV4/m81m/POf/2w27tx/OQcr0Nd2GzNmDGbPno3nnnsOd9xxR5uqOzNnzvS0js7VqVOnZttiY2MRGxuLM2fO4MYbbwz6tXw5P3AOGjQIS5Ys8VRS3JYtW4Yrr7wSl156KQAgISEBt9xyC5YtW4bHHnus1dfo0qUL7r77bixduhT9+/fHnXfeiWPHjuGRRx6BwWCAw+HwLID/zW9+g6KiItx999344x//iLS0NKxcudLTLmzLQvl7770XV155JSorK/Hxxx+joqKizQvu2+Ltt9/GX//6Vzz11FPo06ePZ7t7DiaTqdlzzGYzampqOmyORIFg2KGo0adPH+Tn5zfb7uvTO4B3KDl69CheeuklnDx5ssUWQvfu3X3u/3w6nS6gccEI9LXPncMzzzyDBx54AB988IFnXca53O0Lt6SkJK9jHzRoUMCvOX36dJSXl6N///6YNWsW7rnnHp+twGC89957SExMRGVlJV5//XUcOHCg2Z+NxWJBcXExJk2ahL1793q2Dx8+HO+99x7KysrQt29fWK1WVFdXez3X3eJ68803YbVa8dvf/ha//e1vAQD33Xcfevfujffff9/zKbGcnBy8/fbbeOihhzB8+HDPPl599VVMnDix2afJAnHJJZfgkksuASCDz4QJE5Cfn4/S0tKL3sr6/PPP8etf/xqjRo3C888/7/WY+7Xdbb5zNTY2dmibjSgQbGMRtcAdSvLz8zF27FiUlJSgvLwcDz74YKin1i7GjBmDSy+9FM8995zP727JyMjwuq1YsaJNr/PNN99g/vz5eOSRR7B8+XKcOXMGTz/99IVOH9dddx3y8/Nx7733Yv369YiJicGYMWOgKIpnzLvvvgubzYZXXnkFffr08dymTJkCAJ6FyitWrGh2vG5JSUn48MMPcejQIWzatAkHDx7E3//+d5w4cQJdu3ZFcnKyZ+xdd92F48ePY+vWrdi8eTMOHTqEXr16AfD9NQDBuuuuu3DkyBF89tlnF7yv1uzcuRO33XYbBg4ciFWrVnktQgbOtq/c7axznThxApmZmRd1fkTBYmWHKEAZGRl4/PHH8eyzz2LLli245pprQj2lC+Ku7owdOxYffvhhs8fXr1/v9fPll18e9Gu4XC7Pd7c899xzSEhIwOTJkzFv3jyMGzfO8508Fyo+Ph6zZs3CuHHjsHLlSs/6nGXLlmHgwIGYNWtWs+e8+eabePvtt/Hss89i1KhRzY73fD169ECPHj0AyIrRtm3bfH5XkdFo9Pr+oX//+98A0C7VPHf76PwqVHvat28fRo8ejdTUVBQXF/usSA0ZMgSADLJXX321Z/vx48dx9OhRr+9HIgoHDDtEQXjkkUfw8ssv44UXXrigxb3h4r777sPs2bPx7LPPNnusPf7n/Prrr2PHjh14//33PV/i9+yzz2LlypV46KGHsG3btmZVg7YaM2YMZsyYgRdffBH33HOPpwLy7LPPei2udbPb7RgzZgy+/vpr5Obm+lxs25Jp06bB6XTi8ccfb3XcDz/8gKKiItx6661BVXYqKyubrRcD5EJ0jUaDoUOHBryvYJSXl+PGG2+EVqvFunXrfM4BkMH3sssuw8KFC/Hggw96vhBzwYIF0Gg0Pt9volBi2CEKQufOnTFu3Dj8+c9/xp49e9C/f3/PY2VlZfjHP/7R7DlpaWleHzl2Op0+xwHyO03a8pHsQF/7fDqdDtOnT/d5SQd/Pv/8c5+XzsjJyUFOTg6OHDmCmTNn4mc/+5nXmqC4uDi89tpr+J//+R+89tprno+EXyiDwYDJkyfjySefxNq1a7Fz504IIVr85NfNN98MvV6PZcuWITc3t8X9vvDCC9i1axdyc3Oh1+vxwQcf4F//+hdmz57d7BukBwwYgF/84hfo0aMHDhw4gAULFqBTp04oKioK6lief/55fPnllxg9ejR69OiBqqoqvPfee/jPf/6DRx55xLPYOlB///vfcejQIc/XLHz22WeYPXs2AOB///d/PeuCRo8ejf379+Opp57CF1984bWe7fzfpZdffhm33XYbbrzxRtxzzz3YtWsX/vSnP+E3v/mN198LorAQ2u80JGofHfENym779u0TOp3O6xt+AbR4GzFihNd+Wxvr61uSA/kG5UBf29cxORwO0bt376C/Qbmlm/vbeW+//XYRFxcnDh065HM/t956q4iPjxeHDx9u9lhbvkFZCCGqq6tFUlKSGDFihBg0aJDo0aNHq8dy/fXXi9TUVK9vAT7fxx9/LK6++mqRkJAgYmNjxTXXXCNWrlzpc+w999wjsrKyhNFoFJmZmeKhhx4SFRUVrc7Bl3/961/i1ltvFZmZmcJgMIiEhAQxfPhwsWTJkmbffB2IESNGtPjnde63Jgf6u+S2evVqMWTIEGEymUT37t3FM888I+x2e9DzI7rYNEK04apyRERERCrBT2MRERFRROOaHSKiDuLr+3zO16lTp2aX+LjY+yKKdAw7REQdZMWKFX4Xg3/66ac+L8h5MfdFFOm4ZoeIqIOcOHEC//3vf1sdM2zYsIC+Xbo990UU6Rh2iIiIKKJxgTIRERFFNIYdIiIiimgMO0RERBTRGHaIiIgoojHsEBERUURj2CEiIqKIxrBDREREEY1hh4iIiCIaww4RERFFNIYdIiIiimgMO0RERBTRGHaIiIgoojHsEBERUURj2CEiIqKIxrBDREREEY1hh4iIiCIaww4RERFFNIYdIiIiimgMO0RERBTRGHaIiIgoojHsEBERUURj2CEiIqKIxrBDREREEY1hh4iIiCIaww4RERFFNIYdIiIiimgMO0RERBTR9KGeQHtRFAXHjx9HQkICNBpNqKdDFHWEEKitrUVmZia0WnX8O4rnDaLQ64hzR8SEnePHjyMrKyvU0yCKekeOHEH37t1DPY2A8LxBFD4u5rkjYsJOQkICAPlmJSYmhng2RNGnpqYGWVlZnr+LasDzBlHodcS5I2LCjrsEnZiYyJMWUQipqR3E8wZR+LiY5w51NNaJiIiI2ohhh4iIiCIaww4RERFFNIYdIiIiimgMO0RERBTRGHaIiIgoojHsEBERUURj2CEiIqKIFjFfKkhEF8huB/78Z2DfPqB3b+DhhwGjMdSzIqJwppLzBsMOEQFPPQXMmwe4XGe3/fa3wJQpwEsvhW5eRBS+VHTeYNghinZPPQW8/HLz7S7X2e1hduIiohBT2XmDa3aIopndLv9l1pp58+Q4aoNGACMAGCD/bZnU9F/NObeWtrtvBgDXN+2rLa/bluefu5+fAujc9N/z9+F+PKXp1qnpZ0vT6597TOcfp/tnX3P09brBHFN7HX978vdeqoi/84YOQPLLgOL+fQj9sWqEECLUk2gPNTU1SEpKQnV1tSou6Lf5yfdg//fnoZ4GRbvKk8CxY36Hib6X4frSN1sdo7a/g8DFn7OtZiQ23+2ApqI9TrMJAC4NcOxeALUX8PyW9nP+Pny9DiD/b+fysd0f9/59vS58vFZLx9Rex9+e/L2XKuLvvJEGIEPe7TTxNAZNSAWwocXhHXHuYBsrBGqO1uDKP9wDA5yhngpRQPbvPR7qKajSjucduH7dplBPg6hjVTTdAHz+5bXAhJ0hnQ7AsBMSxzb+gP5wohqJ2PGjSaGeDkWz48eBgwf8jxswEL0u/mwijv1oV8/9jT8acYF7SwIwMMCxuwBUX8DzW9rP+fvw9TqA/F9LW/4x596/r9eFj9dq6Zja6/jbk7/3UkX8nTe6A+gh76beUAFgcEfMqlUMOyFw5usyAMDBxBxc/+XzIZ4NRTW7HYiN9f40xfl0OmDbvzpuThFEqbkKwCp80XM4rv/yCwBxAOrh3eLRtbDdTQ9gOIAVAMwBvnIjgFEAvmr6Odjnn7ufmwHshPwf1vn7cD++o+lnDYAhAFYBuB3Alzh7TOcfp/vnBh9z9PW6COKY2uv425O/91JF/J03TgCYCGBqCqAdAqC44+bWAoadELD/9wcAQE1anxDPhKKe0Sg/JurrUxVuU6aE5fdmqEKt/B+5EjMIwBcd+MJmAO3RPjOjtbUWrT9+Ia/f0n4D3Wd7HX978vdeqoi/84YLgOVJQBs+n8Zi2AkB/UEZdlw9GXYoDLg/Hnr+92XodGH5fRmqUlcHAFBi40M8EaJ2prLzBsNOCCSflGHHNJBhh8LESy8Bs2er4ptQ1UTbIMMOEhJaH0ikRio6bzDshEBmgww7nXIZdiiMGI3AY4+FehYRRdfQ9FHjBFZ2KEKp5LzBLxXsYFU/nEYnUQUA6H69Sr9jgYgCorfJyo6WYYcopBh2OtjxTbKqc0LbDXGpcSGeDRFdTIamsKNPYRuLKJQYdjqY5RsZdsoT2cIiinQmu2xj6ZNZ2SEKJYadDubcLcNObTrDDlGkMztkZceQwrBDFEoMOx3MeEiGHaUXww5RpDO7ZNgxdWEbiyiUGHY6WPIpGXZichh2iCJdnCLbWOYurOwQhRLDTgcSikD3BnmpiM55fUM8GyK6mIQiECdkZSemK8MOUSgx7HSgU7tPIhG1UKBB9+t4WUWiSGavs8PQdDHM2FSGHaJQYtjpQCc+ky2s47oeMCer9AJwRBSQ+oo6z/24NIYdolBi2OlA1U0fO69I4nodokjXUCHX61hhht7ML6snCiWGnQ7k+j8ZduozGHaIIp21UlZ26jWs6hCFGsNOBzIdlouTlUsZdogine20DDsNOn7snCjUGHY6UKfTsrITN4SfxCKKdLZTso3VqGdlhyjUGHY6iFAEujfuBQB0yWNlhyjSOc7Iyo6NYYco5Bh2Okj59uOIQwOc0KH7j3uGejpEdJE5q5vCjoltLKJQY9jpIBVfyBbWMX02DLGGEM+GiC42l0W2sZwmVnaIQo1hp4PUbJdh52QyW1hE0UDUyMqO08ywQxRqDDsdRNkjP4nVkMmwQxQV6mTYccWxjUUUagw7HSTmqKzsoC8/iUUUDTR1so0lYlnZIQo1hp0O0vmM+2PnrOwQRQNNQ9PlIuIZdohCjWGnAyhOBd1t+wAAqcMZdoiigd4qw44mkW0solBj2OkAx78+AjNssMOAzGt6hHo6RNQB9I2yjaVNZGWHKNQYdjrAyS9lC+uosRcvCEgUJYw2WdnRJTHsEIUaw04HqN0uP4lVmcLFyUTRwuiQYcfQiW0solBj2OkIZbKyY+3O9TpE0SLGIdtYxk6s7BCFGsNOB4g5JsOOti/DDlHkagTwUwApAJJgdlUDAIyd/tj0GBGFCsPOBfh83GJUa5Jg1cS0ervyZDEAIP4Khh2iyHUzPu/ngFXTCKvGjgylAgAQk7odwM2hnRpRlONq2QuQsPpvSEJNQGNPabqg993DLvKMiChUhPItcsvqYITDs+24LgPpV5UDqAvdxIiIYedCpNXK9tTWZz5C5uicVsd27p+KmE4xHTEtIgoBa9WViMV6AMDeD3vB3LkRXQdVwpToADA4tJMjinIMO21UV16HDOU4AKDvr65Fcs+UEM+IiEKp5nARYtEbLmjR+9ZKaLTWpkdGACgO5dSIoh7DThsd27QX/SDbU10YdIiiXv1xGwCgWpOMTtrTIZ4NEZ2LC5TbqOpr2cI6EcdFx0QENBy3AADqdEmhnQgRNdOmsDN//nxkZ2fDbDYjNzcXW7dubXW8xWJBYWEhMjIyYDKZ0LdvXxQXny3rulwuzJgxAz179kRMTAx69+6N3//+9xBCtGV6HcK2S4ad6lSGHSICbCflR83rDcmhnQgRNRN0G2vFihWYMmUKioqKkJubi1dffRWjRo1CaWkpUlNTm4232+0YOXIkUlNTsWrVKnTr1g2HDh1CcnKyZ8yLL76IBQsWYOnSpbj88svxzTffYNy4cUhKSsKjjz56QQd4segOyLDj7MmwQ0SA/aQFANBoYmWHKNwEHXbmzZuH8ePHY9y4cQCAoqIirFmzBosXL8bUqVObjV+8eDGqqqrw1VdfwWAwAACys7O9xnz11Ve4/fbbccstt3gef+edd/xWjEIpqUKGHePlDDtEBDhPWQAAtpjkkM6DiJoLqo1lt9uxbds25Ofnn92BVov8/Hxs3rzZ53M++ugj5OXlobCwEGlpaRg4cCDmzJkDl8vlGfOjH/0IJSUlKCuT15DauXMnvvjiC9x0000tzsVms6Gmpsbr1pEy6uRcO13D610RqcXFPG8oZ2QbyxGX3G77JKL2EVRl59SpU3C5XEhLS/PanpaWhv/7v//z+Zz9+/djw4YNGDNmDIqLi7F37148/PDDcDgcmDVrFgBg6tSpqKmpwWWXXQadTgeXy4Xnn38eY8aMaXEuc+fOxbPPPhvM9NtN9eFqdBWVAIBuIy4NyRyIKHgX9bxhsQAAlHi2sYjCzUX/NJaiKEhNTcXChQsxbNgwFBQUYPr06SgqKvKMWblyJZYtW4a3334b27dvx9KlS/GHP/wBS5cubXG/06ZNQ3V1ted25MiRi30oHsc2yhZWhTYdCZm8ojGRWlzM84a2xgIAEEnJ7bZPImofQVV2unTpAp1Oh4qKCq/tFRUVSE9P9/mcjIwMGAwG6HQ6z7b+/fujvLwcdrsdRqMRTz75JKZOnYp77rkHADBo0CAcOnQIc+fOxQMPPOBzvyaTCSaTKZjptxvLf2TYKY/vgzQ/Y4kofFzM84auXraxNCnJF2X/RNR2QVV2jEYjhg0bhpKSEs82RVFQUlKCvLw8n88ZPnw49u7dC0VRPNvKysqQkZEBo9EIAGhoaIBW6z0VnU7n9ZxwYv+vDDs1aVycTESSscECANCmsI1FFG6CbmNNmTIFixYtwtKlS7Fnzx5MnDgR9fX1nk9n3X///Zg2bZpn/MSJE1FVVYXJkyejrKwMa9aswZw5c1BYWOgZ87Of/QzPP/881qxZg4MHD2L16tWYN28e7rzzznY4xPZnOCAXJ7t6MewQkWS2WgAAhq7JIZ0HETUX9EfPCwoKUFlZiZkzZ6K8vBxDhgzB2rVrPYuWDx8+7FWlycrKwrp16/D4448jJycH3bp1w+TJk/H00097xrzxxhuYMWMGHn74YZw8eRKZmZl48MEHMXPmzHY4xPaXVCkrO+YcfhKLiKQYh2xjmdKSQzsRImpGI8L5a4qDUFNTg6SkJFRXVyMxMfGivtYZbSekiDMoW/Ud+v580EV9LSK16Mi/g+2lPed8QtcNGcpx7PnHNvQfM7SdZkgU+Tri3MFrYwWp6ofTSBFnAADdR/QO8WyIKFwkKhYAQFy35JDOg4iaY9gJ0vFNsoV1XNcdsV1iQzwbIgoHjgYH4tAAAEjISg7tZIioGYadIFm2ysXJFQlcnExEUs2Ras/9hG7qaOERRROGnSA598jKTm0GFycTkVR31AIAqEU89OagP/dBRBcZw06QjIdk2FF6s7JDRFLDCVnZqdPyO3aIwhHDTpBSTsmwE5PDsENEkvWEBQBQZ0gO6TyIyDeGnSAIRaCbVYadLnkMO0Qk2StlZcdqTA7tRIjIJ4adIFTuqkAiauGCFt2v6xXq6RBRmHBUWgAANjPbWEThiGEnCCc+k1WdY/pLYEoMzUVIiSj8uKosAAB7bHJI50FEvjHsBKFmmww7J5PYwiKic1hkG8uZkBzaeRCRTww7QXD9nww79ZkMO0R0lqbaAgAQCWxjEYUjhp0gmI7IsINLGXaI6CxdrUXeSU4O5TSIqAUMO0HodFqGndjBDDtEdJahQbaxtJ2SQzsRIvKJYSdAilNBVqMMO6nX8tuTiegsk9UCANB3ZhuLKBwx7ASoYsdxxMIKB/ToNjw71NMhojASY7MAAIypySGdBxH5xrAToPLPZVXnqKEnr31DRF5inbKNZU5PDu1EiMgnhp0A1W6XYedUMtfrENG5GpHgsgAAYjPmAmgM6WyIqDmGnQApZXsBAA2Zl4Z4JkQUToRyExKFrOzEZX4F4ObQToiImmHYCZDuTCUAQKRnhHgmRBROHA27oYUAAJhTbAB2hnZCRNQMw06AjLWnAQDa1M4hngkRhRN73WDPfUOcHcDglgcTUUgw7AQopqEKAGBMZ9ghorMc9W957hvj8wAUh2wuROQbP1YUoDibrOyYMzuFeCZEFE4c9fLfjAo00BlLAGhCOyEiaoaVnQAlOmTYic1iZYeIznJaHQAAO4zQaBl0iMIRw04AhCKQImQbK+ESVnaI6CxHvR2ADDtEFJ4YdgJQc7QGergAAMm9GHaI6Cxngww7Dg3DDlG4YtgJQM1BWdVpQAxiOsWEeDZEFE4YdojCH8NOAGoPyvU6Fh3X6xCRN5dVhh0nww5R2GLYCYD1mKzs1BoYdojIm6eyo2XYIQpXDDsBsB2XlZ0GM9frEJE3T2WHYYcobDHsBMBRLsNOYxwrO0TkjWGHKPwx7ARAnJZtLEcCKztE5E1plGHHxbBDFLYYdgKgqZKVHSWFlR0i8uZyhx2dIcQzIaKWMOwEQFcjKzvozLBDRN6EJ+ywskMUrhh2AmCqk5UdXVe2sYjIm8KwQxT2GHYCENMgw44xg5UdIvKm2GTYUfQMO0ThimEnAPF22caK6cbKDhF5c7exFFZ2iMIWw04AkpyyshPXg5UdIvIm7KzsEIU7hh0/XHYXkoQFAJCYzcoOEZ3H3cYyMOwQhSuGHT+qD1mghQDAK54TkQ9NlR3Byg5R2GLY8aN6v2xhVSMRhlh+jwYRnccddljZIQpbDDt+1B+Ri5Nr9KzqEJEP7rBjZNghClcMO35Yj8rKTq2Ri5OJqDmNQ4YdsLJDFLYYdvywlcvKjpVXPCciX9xhh5UdorDFsOOHq0JWdmzxrOwQUXMap0PeYdghClsMO36IUzLsOJIYdoioOS0rO0Rhj2HHD41FtrFEMttYRNScxinDjsbEsEMUrhh2/DBUy8qOpgsrO0TUnJZhhyjsMez4YaqXlR1dKis7RNQcww5R+GPY8SPWKis7Jl7xnIh80LnDjplhhyhcMez4Ee/gFc+JqGU6lww7WlZ2iMIWw44f7iuex1/Cyg4RNecJO6zsEIUthp1W2OvsSEQtACCpF8MOETWnU2TY0cUw7BCFK4adVlQfPAMAUKBBYlZSiGdDROFIz8oOUdhj2GmF+4rnFk0KdEZdiGdDROFI767smA0hngkRtYRhpxUNR3nFcyJqnZ5tLKKwx7DTCvcVz+t4xXMiaoFeMOwQhTuGnVbYT8iwY41l2CEi3wxNYUcfy7BDFK4YdlrhqpRtLFs821hE5BvDDlH4Y9hpzWlZ2XHxiudE1AKGHaLw16awM3/+fGRnZ8NsNiM3Nxdbt25tdbzFYkFhYSEyMjJgMpnQt29fFBcXe405duwY7rvvPnTu3BkxMTEYNGgQvvnmm7ZMr91o3Vc8T2Flh4h8M0KGHUMcww5RuNIH+4QVK1ZgypQpKCoqQm5uLl599VWMGjUKpaWlSE1NbTbebrdj5MiRSE1NxapVq9CtWzccOnQIycnJnjFnzpzB8OHD8ZOf/ASffPIJunbtih9++AEpKSkXdHAXylDLK54TUcuEImCEAwArO0ThLOiwM2/ePIwfPx7jxo0DABQVFWHNmjVYvHgxpk6d2mz84sWLUVVVha+++goGg/weiuzsbK8xL774IrKysrBkyRLPtp49ewY7tXZnrpdhx5DGyg4RNedocMAdcYzxDDtE4SqoNpbdbse2bduQn59/dgdaLfLz87F582afz/noo4+Ql5eHwsJCpKWlYeDAgZgzZw5cLpfXmCuvvBK/+MUvkJqaiiuuuAKLFi1qdS42mw01NTVet/YW2yjbWKZMVnaIIkF7nzfsdXbPfbaxiMJXUGHn1KlTcLlcSEtL89qelpaG8vJyn8/Zv38/Vq1aBZfLheLiYsyYMQOvvPIKZs+e7TVmwYIF6NOnD9atW4eJEyfi0UcfxdKlS1ucy9y5c5GUlOS5ZWVlBXMoAUm0y8pObBbDDlEkaO/zhtPq8NxnZYcofF30T2MpioLU1FQsXLgQw4YNQ0FBAaZPn46ioiKvMUOHDsWcOXNwxRVXYMKECRg/frzXmPNNmzYN1dXVntuRI0fafe5JiqzsxPdgG4soErT3ecNRLys7CjS8pAxRGAtqzU6XLl2g0+lQUVHhtb2iogLp6ek+n5ORkQGDwQCd7uyJoH///igvL4fdbofRaERGRgYGDBjg9bz+/fvjvffea3EuJpMJJpMpmOkHxVplRSysAHjFc6JI0d7nDXfYscMIs1bTbvslovYVVGXHaDRi2LBhKCkp8WxTFAUlJSXIy8vz+Zzhw4dj7969UBTFs62srAwZGRkwGo2eMaWlpV7PKysrwyWXXBLM9NqVZZ9sYTmgR0JmQsjmQUTh69ywQ0ThK+g21pQpU7Bo0SIsXboUe/bswcSJE1FfX+/5dNb999+PadOmecZPnDgRVVVVmDx5MsrKyrBmzRrMmTMHhYWFnjGPP/44tmzZgjlz5mDv3r14++23sXDhQq8xHa32kGxhWTSdoOG/2IjIB2eDDDsODcMOUTgL+qPnBQUFqKysxMyZM1FeXo4hQ4Zg7dq1nkXLhw8fhlZ7NkNlZWVh3bp1ePzxx5GTk4Nu3bph8uTJePrppz1jrrrqKqxevRrTpk3Dc889h549e+LVV1/FmDFj2uEQ26b+sKzs1Bg6oWvIZkFE4Yxhh0gdgg47ADBp0iRMmjTJ52MbN25sti0vLw9btmxpdZ+33norbr311rZM56JoPCErO/UmrtchIt9cVhl2nAw7RGGN18ZqgcN9xfM4hh0i8s1T2dEy7BCFM4adFiiVMuzYecVzImqBp7LDsEMU1hh2WlIl21i84jkRtYRhh0gdGHZaoKuWlR10YmWHiHxTGmXYcTHsEIU1hp0WGGtlZUfblZUdIvLN5Q47OkOIZ0JErWHYaYG5oemK5+kMO0Tkm/CEHVZ2iMIZw04L4myysmPOZBuLiHxTGHaIVIFhpwWJDl7xnIhap9iaLgSqZ9ghCmcMOz4IRSBFkWEn4RJWdojIN3cbS2FlhyisMez4UFdeBwOcAIDk3qzsEJFvws7KDpEaMOz4UL1fVnUaYUJMp5gQz4aIwpa7jWVg2CEKZww7PriveH5G25lXPCeiljVVdgQrO0RhjWHHh4YjsrJTa2QLi4ha4Q47rOwQhTWGHR9sx2XYaTBxcTIRtaQRsO8EAAjjAfkzEYUlhh0fHCdlG6sxlmGHiFpyMzSOanlXXwfg5pDOhohaxrDjg3Bf8TyRbSwiaslOaBqFvBsjfyai8MSw44PmjKzsKMkMO0TUksHQ2lzybpwAMDiksyGiljHs+OC54nlnhh0iakkx9I16AIA2IRVAcWinQ0QtYtjxwVQrw46uK9fsEFFLzNDZYwEA2vhbAZhDOx0iahHDjg9mq2xjGTNY2SGilhnt9QAAXWJciGdCRK1h2PEh3iYrO7ziORG1xuBsAADoE2NDPBMiag3Djg+JTlnZievByg4RtczklJUdQzIrO0ThjGHnPIpTQbI4AwBI7MmwQ0QtM7tk2DEms7JDFM4Yds5TfcgCHRQAQHIvtrGIqGVmRbaxjCms7BCFM4ad89QclC2sWsTDGM/r3RBRy2KFrOyYO7GyQxTOGHbOU3tQLk6u1rGqQ0QtU5wKYpquh2XuzMoOUThj2DmP9VhTZYdXPCeiVjScavDcj+nMyg5ROGPYOY/9hKzsWM2s7BBRy6ynzwk7nWJCOBMi8odh5zzOChl2GuNZ2SGiljWelut16hELrZ6nUqJwxr+h5xGnZRvLySueE1ErbGdkZceqYQuLKNwx7JxHc0ZWdpRktrGIqGW2KlnZadRycTJRuGPYOY++RlZ20IWVHSJqmf2MDDs2HSs7ROGOYec8pjpZ2dHziudE1ApnjWxj2fSs7BCFO4ad88RaZdjhFc+JqDWOalnZsRtY2SEKdww754m3yzZWTHeGHSJqmVIrKzsOIys7ROGOYec8SU5Z2YnLYhuLiFrmqpGVHaeRlR2icMewcw5HgwNJqAEAJPViZYeIWibqZWXHZWJlhyjcMeycw3LgjOd+0iXJoZsIEYW/elnZUWIYdojCHcPOOWoOyBaWRZMMvVkf4tkQUVhrkJUdxcw2FlG4Y9g5R/0RuTi5WscWFhG1TmOVlR3EsbJDFO4Yds5hPSorO3UmLk4motZpG5suBBrLyg5RuGPYOYejQlZ2GmJY2SGi1ukbZWVHE8/KDlG4Y9g5h/uK5/Y4VnaIqHV6mww72nhWdojCHcPOuaqarniexMoOEbVO75BtLF0iKztE4Y5h5xzapiuei04MO0TUOqNDVnb0iazsEIU7hp1zGGpk2NF0ZhuLiFpndMrKjiGZlR2icMewcw5Tg2xj6dNY2SGi1pldsrLDsEMU/hh2zhHXdMVzUwYrO0TUOrNLVnaMyWxjEYU7hp1zxDtkZSc2i5UdImpdjJCVHXNnVnaIwh3DzjmSXbziORH5JxSBWMjKjrkTKztE4Y5hp0mjpRFxTSev5N6s7BBRyxotjdBCAABiurCyQxTuGHaaWPY3fccOdEjMSgrxbIgonDVU1nvux3ZhZYco3DHsNDl7xfMUaLSaEM+GiMJZY5WsAjfCBJ1RF+LZEJE/DDtNGo7Kyk6NgS0sImpd42lZ2bFqWNUhUgOGnSaNx2Rlp97IxclE1Dq7RVZ2rFqu1yFSA4adJvZyGXassazsEFHr7GdkZcemZWWHSA0YdpoolbKNZU9g2CGi1jmqm9bs6FnZIVIDhh2307Ky40xiG4uIWueolpUdu4Fhh0gNGHaa6KplZQe84jkR+eGqlZUdh4FtLCI1aFPYmT9/PrKzs2E2m5Gbm4utW7e2Ot5isaCwsBAZGRkwmUzo27cviouLfY594YUXoNFo8Nhjj7Vlam1mqJWVHW0XVnaIqHVKjazsOI2s7BCpgT7YJ6xYsQJTpkxBUVERcnNz8eqrr2LUqFEoLS1Fampqs/F2ux0jR45EamoqVq1ahW7duuHQoUNITk5uNvY///kP3nzzTeTk5LTpYC5ETL0MO/p0VnaIqHVKvazsuEys7BCpQdCVnXnz5mH8+PEYN24cBgwYgKKiIsTGxmLx4sU+xy9evBhVVVX44IMPMHz4cGRnZ2PEiBEYPHiw17i6ujqMGTMGixYtQkpKStuO5gLE2mQby5zJsENEftTJyo7LzMoOkRoEFXbsdju2bduG/Pz8szvQapGfn4/Nmzf7fM5HH32EvLw8FBYWIi0tDQMHDsScOXPgcrm8xhUWFuKWW27x2ndrbDYbampqvG4XItEhKzux3dnGIopU7XbeqJdhR8SwskOkBkGFnVOnTsHlciEtLc1re1paGsrLy30+Z//+/Vi1ahVcLheKi4sxY8YMvPLKK5g9e7ZnzPLly7F9+3bMnTs34LnMnTsXSUlJnltWVlYwh+JFKALJiqzsJGSzskMUqdrrvKGxyjaWiGVlh0gNLvqnsRRFQWpqKhYuXIhhw4ahoKAA06dPR1FREQDgyJEjmDx5MpYtWwaz2RzwfqdNm4bq6mrP7ciRI22eY/3JephgBwAk9WRlhyhStdd5Q2ttuhBoLCs7RGoQ1ALlLl26QKfToaKiwmt7RUUF0tPTfT4nIyMDBoMBOt3Zi+X1798f5eXlnrbYyZMnMXToUM/jLpcLn332Gf70pz/BZrN5PdfNZDLBZDIFM/0WWfadRjwAG4yIS+W/1IgiVXudN3Q2WdnRxPN8QaQGQVV2jEYjhg0bhpKSEs82RVFQUlKCvLw8n88ZPnw49u7dC0VRPNvKysqQkZEBo9GIG264Ad9//z2+/fZbz+3KK6/EmDFj8O233/oMOu2t7rBsYZ3RduYVz4nIL51NVna0CQw7RGoQdBtrypQpWLRoEZYuXYo9e/Zg4sSJqK+vx7hx4wAA999/P6ZNm+YZP3HiRFRVVWHy5MkoKyvDmjVrMGfOHBQWFgIAEhISMHDgQK9bXFwcOnfujIEDB7bTYbau4YhcnFxrYAuLiPwz2GVlRxvPNhaRGgT9PTsFBQWorKzEzJkzUV5ejiFDhmDt2rWeRcuHDx+GVns2Q2VlZWHdunV4/PHHkZOTg27dumHy5Ml4+umn2+8oLlDjCVnZqTdzcTIR+WdwyMqOPomVHSI1CDrsAMCkSZMwadIkn49t3Lix2ba8vDxs2bIl4P372sfF5Gy64nljLCs7ROSf0SkrO/pEVnaI1IDXxgKgVMqw4+AVz4koAGanrOwYU1jZIVIDhh0AOCPbWK5khh0i8s+sNIWdZFZ2iNSAYQeA3iIrO+jENhYR+WdWZBvL1ImVHSI1YNgBYKyTlR1dKis7RNQ6oQjEQVZ2TCms7BCpAcMOgJgGWdkxpLGyQ0StczQ4oIe8tl9sV1Z2iNSAYQdAvE2GHXM3VnaIqHUNlfWe+zGdWdkhUgOGHQAJTtnG4hXPicgf62m5XscBPYzxxhDPhogCEfVhR3EqSBEy7CT2ZGWHiFrXeFpWdhrAFhaRWkR92Kk9VgMd5HW7knuxskNErbNbZGXHqmULi0gtoj7sWPbJ9Tr1iIU52Rzi2RBRuLNVycpOo46VHSK1iPqwU3dIhh2Lji0sIvLPUV0NALDptAB+CqAxpPMhIv+iPuxYj8n1OnW84jkRBcBZ/RYAwK43AvgUwM2hnA4RBSDqw479dA0AwGpKCvFMiEgNXHWnAABOvfs6yjtDNxkiCkjUhx2ltuljpAYuNiQi/5RG2fJ26nVNWwaHbjJEFBCGnXorAMBliAnxTIhIDRTbDfK/egOAnwAoDul8iMg/hp2GprBjZNghIv+E1QkAUPRZADYA4Kc4icJd1IcduMOOmW0sIvJP2O0AAEXPb08mUguGnQa5ZkeYWNkhogDYmsKOgWGHSC0YdhplZUeYGXaIKABNlR1hMIV4IkQUqKgPO9qmsINYtrGIKAA2GwBAsLJDpBoMO42yjYUYVnaIKACeyg7DDpFaRH3Y0dllZUcTy7BDRP5pHDLswMQ2FpFaMOw0hR1tPNtYROSfxi7bWDCyskOkFlEfdvQO2cbSxrGyQ0T+aZxNlR2GHSLViPqwY3DIyo4unmGHiPzTuttYZraxiNSCYcclw44+gWGHiPzTOmQbS8PKDpFqRH3YMTaFHUMS1+wQkX9al6zsaMwMO0RqEfVhx+SSa3YMiazsEJF/2qY1O1q2sYhUg2FHaarsMOwQUQD0TtnG0rKyQ6QaUR92zEKGHVMK21hE5J/O5a7sMOwQqUVUhx2hCMRCtrFMyazsEJF/OkWGHV0s21hEahHVYcdeZ4cWAgBgTmHYISL/9C62sYjUJqrDTuMZq+c+ww4RBULvruzEMOwQqQXDDgAXtDDG88RFRP65w44+jm0sIrWI7rBTJdfrWBEDjVYT4tkQkRoYFdnGYmWHSD2iOuzYq2Vlp1HDFhYRBUYvmio7sQw7RGoR1WHHUdMUdrT82DkRBcbIsEOkOlEdduwW2cay61jZIaLAGCHbWIZ4rtkhUouoDjvOWlnZYdghokAZISs7hjhWdojUgmEHgF3PNhYR+eeyu6CDAoBhh0hNojrsuGplG8upZ2WHiPyz1dg8940JbGMRqUVUhx2lXlZ2nAaGHSLyz1Fv99znd3MRqQfDDgCXkWGHiPyz150NO4ZYQwhnQkTBiOqwIxqawo6Ja3aIyD9ngww7Nhj5RaREKhLVYQcNcs2OYmJlh4j8s9fKNTt2sIVFpCbRHXassrKjmBl2iMg/d2XHoWHYIVKTqA47msamq57HsI1FRP65w45dw09iEalJVIcdbaNsYyGGlR0i8s9ZL9tYTlZ2iFQlusOOramyE8uwQ0T+uaxNbSwtww6RmkR12NHZZdjRxrGNRUT+ucOOU8s2FpGaRHfYcbjDDis7ROSfp43Fyg6RqkR12DE45JodbTzDDhH5pzQ2VXZ0DDtEahLdYccpKzt6hh0iCoA77Lh0bGMRqUlUhx2jO+wkcs0OEfmnWGUby8XKDpGqRHfYcck2liGRlR0i8s9T2dEz7BCpSVSHHZMiKzsMO0QUCGGTYUfRs41FpCZRHXbMQoYdYzLbWETkn2iUbSyFlR0iVYnqsBMjZBvLlMzKDhH5d7ayw7BDpCZRG3ZcdhdMkCcuhh0iCoi9KewY2cYiUpM2hZ358+cjOzsbZrMZubm52Lp1a6vjLRYLCgsLkZGRAZPJhL59+6K4uNjz+Ny5c3HVVVchISEBqampuOOOO1BaWtqWqQWs0dLouR/TmW0sIgqATbaxhIGVHSI1CTrsrFixAlOmTMGsWbOwfft2DB48GKNGjcLJkyd9jrfb7Rg5ciQOHjyIVatWobS0FIsWLUK3bt08YzZt2oTCwkJs2bIF69evh8PhwI033oj6+vq2H5kfjWesnvsxnVjZIaIANFV2GHaI1EUf7BPmzZuH8ePHY9y4cQCAoqIirFmzBosXL8bUqVObjV+8eDGqqqrw1VdfwWAwAACys7O9xqxdu9br57feegupqanYtm0brrvuumCnGJDGKrlexwYjTPqo7eYRUTAcMuyAYYdIVYL6v7zdbse2bduQn59/dgdaLfLz87F582afz/noo4+Ql5eHwsJCpKWlYeDAgZgzZw5cLleLr1NdXQ0A6NSpU4tjbDYbampqvG7BsFlkZacRrOoQRYsLPW9o7LKNBRPX7BCpSVBh59SpU3C5XEhLS/PanpaWhvLycp/P2b9/P1atWgWXy4Xi4mLMmDEDr7zyCmbPnu1zvKIoeOyxxzB8+HAMHDiwxbnMnTsXSUlJnltWVlYwhwJHjQw7Vi3X6xBFiws9b2jclR0jKztEanLR+zeKoiA1NRULFy7EsGHDUFBQgOnTp6OoqMjn+MLCQuzatQvLly9vdb/Tpk1DdXW153bkyJGg5mW3NLWxtKzsEEWLCz1vaBl2iFQpqDU7Xbp0gU6nQ0VFhdf2iooKpKen+3xORkYGDAYDdDqdZ1v//v1RXl4Ou90O4zknjUmTJuHjjz/GZ599hu7du7c6F5PJBNMFlJLdlR27jmGHKFpc6HlD65RhR2NmG4tITYKq7BiNRgwbNgwlJSWebYqioKSkBHl5eT6fM3z4cOzduxeKoni2lZWVISMjwxN0hBCYNGkSVq9ejQ0bNqBnz55tOZagOGubwo6ebSwiCozWIdfsaEys7BCpSdBtrClTpmDRokVYunQp9uzZg4kTJ6K+vt7z6az7778f06ZN84yfOHEiqqqqMHnyZJSVlWHNmjWYM2cOCgsLPWMKCwvxj3/8A2+//TYSEhJQXl6O8vJyWK3WZq/fXlx1ct8OPSs7RBQYraupssOwQ6QqQX/0vKCgAJWVlZg5cybKy8sxZMgQrF271rNo+fDhw9Bqz2aorKwsrFu3Do8//jhycnLQrVs3TJ48GU8//bRnzIIFCwAA119/vddrLVmyBGPHjm3DYfnnqpVrdpwMO0QUIF1TG0sbwzYWkZoEHXYAubZm0qRJPh/buHFjs215eXnYsmVLi/sTQrRlGhdEqZeVHaeRYYeIAqNzyTaW1szKDpGaRO236SkNMuy4jFyzQ0SB0TW1sRh2iNQlasMO6mUbSzGxskNEgdE3hR1dLNtYRGoSvWGnafEzww4RBUqvyDaWLoaVHSI1id6w0yjDjohhG4uIAqNXmio7DDtEqhK1YUdrlW0sxLCyQ0SBMTSFHX0c21hEahK9YcfW9B0+DDtEFCCDYBuLSI2iN+zYZdjRxLGNRUSBMYimyk4sww6RmkRt2NE1hR1tHCs7RBQYd9gxxLONRaQmURt2DHa5Zodhh4gCZYJsYxniWNkhUpOoDTt6p6zs6OIZdojIP6EIGOEAwDYWkdpEbdgxNIUdfSLX7BCRf44Gh+e+MYFtLCI1idqwY3LJNpY+gZUdIvLPVmPz3DfGs7JDpCZRG3aMLlnZMSQy7BCRf456u+c+ww6RukRt2DEpMuwYk9nGIiL/3GHHCR10Rl2IZ0NEwYjasBMjZBvLmMTKDhH556iTbSw7WNUhUpuoDDtCEYiBrOyYkhl2iMg/d2XHwbBDpDpRGXYcDQ7ooAAAYjqzjUVE/jkbZNixa/hJLCK1icqwY62yeu6bU1jZISL/nPWyjeXQsrJDpDZRGXYaq+R6HQUafqqCiALiruw4NDxnEKlNVIYdm0VWdqyIgUarCfFsiEgNXNamT2OxskOkOlEZduzVTWFHw/U6RBSYs2GHa3aI1CY6w45FtrFsWq7XIaLAuBrkmh2njpUdIrWJyrDjqJGVHTvDDhEFSGmUlR0X21hEqhPVYcemZxuLiALjDjtOPdtYRGoTlWHHVSfDjkPHyg4RBUaxyjaWi20sItWJyrDjrJFrdhwGhh0iCoxik5UdRc+wQ6Q2URl2lHpZ2XEy7BBRgESjO+ywjUWkNlEddlxGrtkhosAIm2xjsbJDpD5RGXZEvWxjuYys7BBRgNxtLAPDDpHaRGXYgVVWdhQTww4RBcguw44wsI1FpDbRHXZi2MYiogA1tbEEKztEqhOVYUdjlW0smFnZIaIAeSo7DDtEahOdYccmKzuIYdghosBoHDLswMQ2FpHaRGXY0bnDThzbWEQUGI1dtrFgZGWHSG2iM+zYZdjRxrKyQ0SB0TibKjsMO0SqE6VhR67Z0cYx7BBRYLTuNpaZbSwitYnKsGNwNFV2GHaIKEBah2xjaVjZIVKdqAw7eqcMO/pErtkhosBoXbKyozEz7BCpTVSGHZNTtrH0CazsEFFgtE1rdrRsYxGpTlSGHaOrqbLDsENEAdI7ZRtLy8oOkepEZ9hRZNgxJrONRUSB0bnclR2GHSK1icqwYxZNYSeJlR0iCoxOkWFHF8s2FpHaRGXYiRFyzQ7DDhEFSu9iG4tIraIu7ChOBWbIk5a5E9tYRBQYvbuyE8OwQ6Q2URd2Gi2NnvvmFFZ2iCgwDDtE6hV1Ycd6usFzP6YTww4RBcYgZNjRx3HNDpHaRF3YsVnk4mQ7DNAZdSGeDRGphUGR7W99LCs7RGoTtWHHCq7XIaLAGd2VHYYdItWJurBjt8g2VqOWLSwiCpwBMuwY4tnGIlKb6As71bKyY2PYIaIgmJo+xWmIY2WHSG2iLuw4a5vCjo5tLCIKjMvugg4KAIYdIjWK2rDj0LGyQ0SBsdfZPfeNCWxjEalN9IWdGrlmx6Fn2CGiwNhrbZ77xnhWdojUJurCjquuqbJjYBuLiAJzbmXHEGsI4UyIqC2iLuwo9TLsOI2s7BBRYJwNMuzYYIRGqwnxbIgoWFEYdmQby8WwQ0QBcrex7GALi0iNoi7soEFWdhSGHSIKkLuy49Aw7BCpUfSFHWtT2DFzzQ4RBcYdduwafhKLSI2iNuwIMys7RBQYZ71sYzlZ2SFSpTaFnfnz5yM7Oxtmsxm5ubnYunVrq+MtFgsKCwuRkZEBk8mEvn37ori4+IL22Vbaxqarnscw7BBRYFzWpjaWlmGHSI2CDjsrVqzAlClTMGvWLGzfvh2DBw/GqFGjcPLkSZ/j7XY7Ro4ciYMHD2LVqlUoLS3FokWL0K1btzbv80JobLKyg1i2sYgoMO6w49SyjUWkRkGHnXnz5mH8+PEYN24cBgwYgKKiIsTGxmLx4sU+xy9evBhVVVX44IMPMHz4cGRnZ2PEiBEYPHhwm/d5IXRNYUcTy8oOEQXG08ZiZYdIlYIKO3a7Hdu2bUN+fv7ZHWi1yM/Px+bNm30+56OPPkJeXh4KCwuRlpaGgQMHYs6cOXC5XG3eJwDYbDbU1NR43QKhs8s2liaOYYco2rT1vKE0NlV2dAw7RGoUVNg5deoUXC4X0tLSvLanpaWhvLzc53P279+PVatWweVyobi4GDNmzMArr7yC2bNnt3mfADB37lwkJSV5bllZWQEdg94hKzs6hh2iqNPW84Y77Lh0bGMRqdFF/zSWoihITU3FwoULMWzYMBQUFGD69OkoKiq6oP1OmzYN1dXVntuRI0cCep7BHXYSuGaHKNq09byhWGUby8XKDpEq6YMZ3KVLF+h0OlRUVHhtr6ioQHp6us/nZGRkwGAwQKfTebb1798f5eXlsNvtbdonAJhMJphMwf8ry+CUbSxdPCs7RNGmrecNT2VHz7BDpEZBVXaMRiOGDRuGkpISzzZFUVBSUoK8vDyfzxk+fDj27t0LRVE828rKypCRkQGj0dimfV4Io0tWdgyJDDtEFBhhk2FH0bONRaRGQbexpkyZgkWLFmHp0qXYs2cPJk6ciPr6eowbNw4AcP/992PatGme8RMnTkRVVRUmT56MsrIyrFmzBnPmzEFhYWHA+2xPJnfYSWIbi4gCIxplG0thZYdIlYJqYwFAQUEBKisrMXPmTJSXl2PIkCFYu3atZ4Hx4cOHodWezVBZWVlYt24dHn/8ceTk5KBbt26YPHkynn766YD32Z5MCis7RBScs5Udhh0iNQo67ADApEmTMGnSJJ+Pbdy4sdm2vLw8bNmypc37bE9mIdfsmJIZdogoQPamsGNkG4tIjaLu2lgxkJUdUwrbWEQUoKawIwys7BCpUVSFHUeDA3rILzM0p7CyQ0QBssk1Oww7ROoUVWGn4VSD5z7DDhEFzCErO2DYIVKlqAo7NotsYSnQwJTI3jsRBUbjDjtt+I4eIgq9qAw7VsRAo9WEeDZEpA6N0Nh/kHeN3wFoDOlsiCh4URl2GjVsYRFRoG6G1lEv7xqrANwc0tkQUfCiKuzYLXLNjk3LsENEgdoJrVN+A7zGLH8mInVp0/fsqFVyvzRs/PEMIC4OmaGeDBGpxGDgf6zYuHUEOo86JX8mIlWJqrCTmZuFzM+eC/U0iEhVivGjP94MWdEZDKA4xPMhomBFVdghIgqeGcCGUE+CiC5AVK3ZISIioujDsENEREQRjWGHiIiIIhrDDhEREUU0hh0iIiKKaAw7REREFNEYdoiIiCiiMewQERFRRGPYISIioojGsENEREQRjWGHiIiIIhrDDhEREUW0iLkQqBACAFBTUxPimRBFJ/ffPfffRTXgeYMo9Dri3BExYae2thYAkJWVFeKZEEW32tpaJCUlhXoaAeF5gyh8XMxzh0ao6Z9hrVAUBcePH0dCQgI0Gk2L42pqapCVlYUjR44gMTGxA2fYftR+DGqfP8Bj8EUIgdraWmRmZkKrVUeHvLXzRiT8GV8MfF9axvfGN3/vS0ecOyKmsqPVatG9e/eAxycmJqr+l1Htx6D2+QM8hvOppaLjFsh5IxL+jC8Gvi8t43vjW2vvy8U+d6jjn19EREREbcSwQ0RERBEt6sKOyWTCrFmzYDKZQj2VNlP7Mah9/gCPIRrw/fGN70vL+N74Fg7vS8QsUCYiIiLyJeoqO0RERBRdGHaIiIgoojHsEBERUURj2CEiIqKIFlVhZ/78+cjOzobZbEZubi62bt0a6im16LPPPsPPfvYzZGZmQqPR4IMPPvB6XAiBmTNnIiMjAzExMcjPz8cPP/wQmsm2YO7cubjqqquQkJCA1NRU3HHHHSgtLfUa09jYiMLCQnTu3Bnx8fH4+c9/joqKihDNuLkFCxYgJyfH82VYeXl5+OSTTzyPh/v8z/fCCy9Ao9Hgscce82xT2zF0FDWdL4L1u9/9DhqNxut22WWXeR4P5Hfi8OHDuOWWWxAbG4vU1FQ8+eSTcDqdXmM2btyIoUOHwmQy4dJLL8Vbb73VEYcXsPY4z1ZVVWHMmDFITExEcnIyfv3rX6Ours5rzHfffYcf//jHMJvNyMrKwksvvdRsLu+++y4uu+wymM1mDBo0CMXFxe1+vMHw996MHTu22e/Q6NGjvcaE1XsjosTy5cuF0WgUixcvFv/973/F+PHjRXJysqioqAj11HwqLi4W06dPF++//74AIFavXu31+AsvvCCSkpLEBx98IHbu3Cluu+020bNnT2G1WkMzYR9GjRollixZInbt2iW+/fZbcfPNN4sePXqIuro6z5iHHnpIZGVliZKSEvHNN9+Ia665RvzoRz8K4ay9ffTRR2LNmjWirKxMlJaWiv/3//6fMBgMYteuXUKI8J//ubZu3Sqys7NFTk6OmDx5sme7mo6ho6jtfBGsWbNmicsvv1ycOHHCc6usrPQ87u93wul0ioEDB4r8/HyxY8cOUVxcLLp06SKmTZvmGbN//34RGxsrpkyZInbv3i3eeOMNodPpxNq1azv0WFvTHufZ0aNHi8GDB4stW7aIzz//XFx66aXi3nvv9TxeXV0t0tLSxJgxY8SuXbvEO++8I2JiYsSbb77pGfPll18KnU4nXnrpJbF7927xzDPPCIPBIL7//vuL/h60xN9788ADD4jRo0d7/Q5VVVV5jQmn9yZqws7VV18tCgsLPT+7XC6RmZkp5s6dG8JZBeb8XzRFUUR6erp4+eWXPdssFoswmUzinXfeCcEMA3Py5EkBQGzatEkIIedsMBjEu+++6xmzZ88eAUBs3rw5VNP0KyUlRfzlL39R1fxra2tFnz59xPr168WIESM8YUdNx9CR1Hy+CMSsWbPE4MGDfT4WyO9EcXGx0Gq1ory83DNmwYIFIjExUdhsNiGEEE899ZS4/PLLvfZdUFAgRo0a1c5H0z7acp7dvXu3ACD+85//eMZ88sknQqPRiGPHjgkhhPjzn/8sUlJSPO+LEEI8/fTTol+/fp6f7777bnHLLbd4zSc3N1c8+OCD7XqMbdVS2Ln99ttbfE64vTdR0cay2+3Ytm0b8vPzPdu0Wi3y8/OxefPmEM6sbQ4cOIDy8nKv40lKSkJubm5YH091dTUAoFOnTgCAbdu2weFweB3HZZddhh49eoTlcbhcLixfvhz19fXIy8tT1fwLCwtxyy23eM0VUN+fQUeItPNFS3744QdkZmaiV69eGDNmDA4fPgwgsN+JzZs3Y9CgQUhLS/OMGTVqFGpqavDf//7XM+b837dRo0ap5j0M5Dy7efNmJCcn48orr/SMyc/Ph1arxddff+0Zc91118FoNHrGjBo1CqWlpThz5oxnjBrfq40bNyI1NRX9+vXDxIkTcfr0ac9j4fbeREXYOXXqFFwul9dfTABIS0tDeXl5iGbVdu45q+l4FEXBY489huHDh2PgwIEA5HEYjUYkJyd7jQ234/j+++8RHx8Pk8mEhx56CKtXr8aAAQNUM//ly5dj+/btmDt3brPH1HIMHSnSzhe+5Obm4q233sLatWuxYMECHDhwAD/+8Y9RW1sb0O9EeXm5z/fH/VhrY2pqamC1Wi/SkbWfQM6z5eXlSE1N9Xpcr9ejU6dO7fJehfPv2+jRo/G3v/0NJSUlePHFF7Fp0ybcdNNNcLlcAMLvvYmYq55TeCssLMSuXbvwxRdfhHoqQevXrx++/fZbVFdXY9WqVXjggQewadOmUE8rIEeOHMHkyZOxfv16mM3mUE+HwsRNN93kuZ+Tk4Pc3FxccsklWLlyJWJiYkI4M1KLe+65x3N/0KBByMnJQe/evbFx40bccMMNIZyZb1FR2enSpQt0Ol2zTxNUVFQgPT09RLNqO/ec1XI8kyZNwscff4xPP/0U3bt392xPT0+H3W6HxWLxGh9ux2E0GnHppZdi2LBhmDt3LgYPHozXXntNFfPftm0bTp48iaFDh0Kv10Ov12PTpk14/fXXodfrkZaWFvbH0NEi7XwRiOTkZPTt2xd79+4N6Pc6PT3d5/vjfqy1MYmJiaoIVIGcZ9PT03Hy5Emvx51OJ6qqqtrlvVLT71uvXr3QpUsX7N27F0D4vTdREXaMRiOGDRuGkpISzzZFUVBSUoK8vLwQzqxtevbsifT0dK/jqampwddffx1WxyOEwKRJk7B69Wps2LABPXv29Hp82LBhMBgMXsdRWlqKw4cPh9VxnE9RFNhsNlXM/4YbbsD333+Pb7/91nO78sorMWbMGM/9cD+GjhZp54tA1NXVYd++fcjIyAjo9zovLw/ff/+91//M1q9fj8TERAwYMMAz5tx9uMeo5T0M5Dybl5cHi8WCbdu2ecZs2LABiqIgNzfXM+azzz6Dw+HwjFm/fj369euHlJQUzxg1v1cAcPToUZw+fRoZGRkAwvC9CWo5s4otX75cmEwm8dZbb4ndu3eLCRMmiOTkZK9PE4ST2tpasWPHDrFjxw4BQMybN0/s2LFDHDp0SAghPxKZnJwsPvzwQ/Hdd9+J22+/Pew+ej5x4kSRlJQkNm7c6PXxxIaGBs+Yhx56SPTo0UNs2LBBfPPNNyIvL0/k5eWFcNbepk6dKjZt2iQOHDggvvvuOzF16lSh0WjEv/71LyFE+M/fl3M/jSWEOo/hYlPb+SJYTzzxhNi4caM4cOCA+PLLL0V+fr7o0qWLOHnypBDC/++E+6PnN954o/j222/F2rVrRdeuXX1+9PzJJ58Ue/bsEfPnzw+7j563x3l29OjR4oorrhBff/21+OKLL0SfPn28Pl5tsVhEWlqa+N///V+xa9cusXz5chEbG9vs49V6vV784Q9/EHv27BGzZs0K+UfPW3tvamtrxW9/+1uxefNmceDAAfHvf/9bDB06VPTp00c0NjZ69hFO703UhB0hhHjjjTdEjx49hNFoFFdffbXYsmVLqKfUok8//VQAaHZ74IEHhBDyY5EzZswQaWlpwmQyiRtuuEGUlpaGdtLn8TV/AGLJkiWeMVarVTz88MMiJSVFxMbGijvvvFOcOHEidJM+z69+9StxySWXCKPRKLp27SpuuOEGT9ARIvzn78v5YUeNx9AR1HS+CFZBQYHIyMgQRqNRdOvWTRQUFIi9e/d6Hg/kd+LgwYPipptuEjExMaJLly7iiSeeEA6Hw2vMp59+KoYMGSKMRqPo1auX19/9cNAe59nTp0+Le++9V8THx4vExEQxbtw4UVtb6zVm586d4tprrxUmk0l069ZNvPDCC83msnLlStG3b19hNBrF5ZdfLtasWXPRjjsQrb03DQ0N4sYbbxRdu3YVBoNBXHLJJWL8+PHN/jEQTu+NRgghgqsFEREREalHVKzZISIioujFsENEREQRjWGHiIiIIhrDDhEREUU0hh0iIiKKaAw7REREFNEYdoiIiCiiMewQERFRRGPYISIioojGsENEREQRjWGHiIiIIhrDDhEREUW0/w+hSeCTJ/J3HwAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + } + ], + "source": [ + "page = 0\n", + "sz = 1000\n", + "\n", + "i = 0\n", + "\n", + "def fill_plots(ax, bx, folder, file, main_color):\n", + " data = []\n", + " times = []\n", + " prev_is_target = False\n", + " need_to_check = False\n", + " with open(os.path.join(folder, file)) as f:\n", + " for line in f:\n", + " result = re.search(r\"^Coverage: (\\d+)/(\\d+)\", line)\n", + " if result is not None:\n", + " a, b = result.groups()\n", + " data.append(int(a) / int(b))\n", + " if need_to_check:\n", + " if len(data) < 2:\n", + " color = \"yellow\"\n", + " elif data[-1] > data[-2]:\n", + " color = 'green'\n", + " else:\n", + " color = 'red'\n", + " need_to_check = False\n", + " ax.scatter(len(data)-1, data[-1], color=color, marker='o')\n", + " else:\n", + " result = re.search(r\"^Concolic mutation: Number of Kex calls: (\\w+)\", line)\n", + " if result is not None:\n", + " t = int(result.groups()[0])\n", + " if t != 0:\n", + " prev_is_target = True\n", + " need_to_check = True\n", + " else:\n", + " result = re.search(r\"^Time: (\\d+)\", line)\n", + " if result is not None:\n", + " t = result.groups()[0]\n", + " times.append(int(t))\n", + " if prev_is_target:\n", + " bx.scatter(int(t), data[-1], color=color, marker='o')\n", + " prev_is_target = False\n", + " else:\n", + " bx.scatter(int(t), data[-1], color='yellow', marker='o', s=5)\n", + " x = list(range(len(data)))\n", + " ax.plot(x, data, color=main_color)\n", + " bx.plot(times, data, color=main_color)\n", + "\n", + "for run in runs:\n", + " name = str(run.parent.name)\n", + " folder = str(run.parent)\n", + " file = str(run.name)\n", + "\n", + " timeout = 0\n", + " for t in timeouts:\n", + " if str(run).find(f\"evokex-{t}\") != -1:\n", + " timeout = t\n", + " break\n", + "\n", + " fig, (ax1, ax2) = plt.subplots(ncols=2, sharex='col', sharey=True)\n", + " fig.suptitle(f\"{name}_{timeout}\")\n", + " fill_plots(ax1, ax2, folder, file, \"blue\")\n", + " fill_plots(ax1, ax2, folder.replace('mustAA-plateau-subset-full', 'master-benchmarks10-full'), file, \"red\")\n", + "plt.show()" + ] } - ], - "source": [ - "# draw plots for coverage saturation\n", - "\n", - "page = 0\n", - "sz = 1000\n", - "\n", - "i = 0\n", - "\n", - "def fill_plots(ax, bx, folder, file):\n", - " data = []\n", - " times = []\n", - " prev_is_target = False\n", - " with open(os.path.join(folder, file)) as f:\n", - " for line in f:\n", - " result = re.search(r\"^Coverage: (\\d+)/(\\d+)\", line)\n", - " if result is not None:\n", - " a, b = result.groups()\n", - " data.append(int(a) / int(b))\n", - " else:\n", - " result = re.search(r\"^Targeted: (\\w+)\", line)\n", - " if result is not None:\n", - " t = result.groups()[0]\n", - " if t == 'true':\n", - " prev_is_target = True\n", - " if data[-1] > data[-2]:\n", - " color = 'green'\n", - " else:\n", - " color = 'red'\n", - " ax.scatter(len(data)-1, data[-1], color=color, marker='o')\n", - " else:\n", - " result = re.search(r\"^Time: (\\d+)\", line)\n", - " if result is not None:\n", - " t = result.groups()[0]\n", - " times.append(int(t))\n", - " if prev_is_target:\n", - " bx.scatter(int(t), data[-1], color=color, marker='o')\n", - " prev_is_target = False\n", - " else:\n", - " bx.scatter(int(t), data[-1], color='yellow', marker='o', s=5)\n", - " x = list(range(len(data)))\n", - " ax.plot(x, data)\n", - " bx.plot(times, data)\n", - "\n", - "bench_name = sorted(raw_data['benchmark'].unique())[5]\n", - "\n", - "for folder, _, files in os.walk('/home/rustamsadykov/stats/evokex-32-5-h-2-120'):\n", - " name = os.path.basename(folder)\n", - " if (not name.startswith(bench_name)\n", - " # or not name.endswith(\"_1\")\n", - " ):\n", - " continue\n", - " if i >= (page + 1) * sz:\n", - " break\n", - " for file in files:\n", - " if i < page * sz or i >= (page + 1) * sz:\n", - " i += 1\n", - " continue\n", - " i += 1\n", - " if file != 'work-stat.log':\n", - " continue\n", - "\n", - " fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(ncols=2, nrows=2, sharex='col', sharey=True)\n", - " fig.suptitle(name)\n", - " fill_plots(ax1, ax2, folder, file)\n", - " fill_plots(ax3, ax4, folder.replace('evokex-32-5-h-2-120', 'evosuite-stat-120'), file)\n", - "plt.show()" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-03-01T16:40:23.506114478Z", - "start_time": "2024-03-01T16:40:00.445993268Z" + ], + "metadata": { + "colab": { + "collapsed_sections": [ + "cHpndGNt1Rem", + "6JRqTSLb1jtn", + "SG9NcLxd1L3l", + "q9F_WOLj1oOZ", + "HVcw57dp2JoH", + "ESokZysY2SlC", + "fUlxLozRMo5f", + "kQ6HtdiWNgJj" + ], + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" } - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file