From 6d4f05ccae03c80f63313cd785c8b872d74e3203 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Sun, 29 Oct 2023 01:31:25 +0300 Subject: [PATCH 01/30] Some awful attempts --- .../org/utbot/contest/usvm/ConverterUtils.kt | 13 ++ .../contest/usvm/JcToUtExecutionConverter.kt | 97 +++++++------ .../contest/usvm/JcToUtModelConverter.kt | 131 ++++++++++++++++++ 3 files changed, 192 insertions(+), 49 deletions(-) create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt new file mode 100644 index 0000000000..092d39e840 --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt @@ -0,0 +1,13 @@ +package org.utbot.contest.usvm + +import org.jacodb.api.JcType +import org.jacodb.api.TypeName +import org.utbot.framework.plugin.api.ClassId +import org.utbot.framework.plugin.api.util.id +import org.utbot.framework.plugin.api.util.objectClassId + +val JcType?.classId: ClassId + get() = this?.javaClass?.id ?: objectClassId + +val TypeName.classId: ClassId + get() = ClassId(this.typeName) \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt index dee5b56ae7..e677e54917 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -14,6 +14,7 @@ import org.usvm.instrumentation.util.enclosingClass import org.usvm.instrumentation.util.enclosingMethod import org.utbot.contest.usvm.executor.JcExecution import org.utbot.framework.plugin.api.Coverage +import org.utbot.framework.plugin.api.EnvironmentModels import org.utbot.framework.plugin.api.Instruction import org.utbot.framework.plugin.api.MissingState import org.utbot.framework.plugin.api.UtExecution @@ -29,51 +30,49 @@ import java.util.* class JcToUtExecutionConverter( private val instructionIdProvider: InstructionIdProvider ) { - private val valueConstructor = Descriptor2ValueConverter(utContext.classLoader) - private val utModelConstructor = UtModelConstructor( - objectToModelCache = IdentityHashMap(), - idGenerator = StateBeforeAwareIdGenerator(allPreExistingModels = emptySet()), - utModelWithCompositeOriginConstructorFinder = { classId -> - javaStdLibModelWithCompositeOriginConstructors[classId.jClass]?.invoke() - } - ) + private val modelConverter = JcToUtModelConverter() fun convert(jcExecution: JcExecution): UtExecution? { - // TODO usvm-sbft: convert everything other than coverage - return UtUsvmExecution( - stateBefore = MissingState, - stateAfter = MissingState, - result = UtExecutionSuccess(UtVoidModel), - coverage = convertCoverage(getTrace(jcExecution.uTestExecutionResult), jcExecution.method.enclosingType.jcClass), - instrumentation = emptyList() - ) -// val coverage = Coverage(convertCoverage()) -// return when (jcExecution.uTestExecutionResult) { -// is UTestExecutionSuccessResult -> { -// -// TODO("usvm-sbft") -// } -// is UTestExecutionExceptionResult -> TODO("usvm-sbft") -// is UTestExecutionInitFailedResult -> { -// val exception = -// valueConstructor.buildObjectFromDescriptor(jcExecution.uTestExecutionResult.cause) as Throwable -// logger.error(exception) { "Concrete executor failed" } -// null -// } -// is UTestExecutionFailedResult -> { -// val exception = -// valueConstructor.buildObjectFromDescriptor(jcExecution.uTestExecutionResult.cause) as Throwable -// if (!jcExecution.uTestExecutionResult.cause.raisedByUserCode) -// logger.error(exception) { "Concrete executor failed" } -// // TODO usvm-sbft -// null -// } -// is UTestExecutionTimedOutResult -> { -// // TODO usvm-sbft -// null -// } -// } + val coverage = convertCoverage(getTrace(jcExecution.uTestExecutionResult), jcExecution.method.enclosingType.jcClass) + + val executionResult = jcExecution.uTestExecutionResult + return when (executionResult) { + is UTestExecutionSuccessResult -> { + val result = UtExecutionSuccess(modelConverter.convert(executionResult.result)) + + UtUsvmExecution( + stateBefore = MissingState, + stateAfter = MissingState, + result = result, + coverage = coverage, + instrumentation = emptyList() + ) + } + + is UTestExecutionExceptionResult -> TODO("usvm-sbft") + is UTestExecutionInitFailedResult -> { + val exception = + valueConstructor.buildObjectFromDescriptor(jcExecution.uTestExecutionResult.cause) as Throwable + logger.error(exception) { "Concrete executor failed" } + null + } + + is UTestExecutionFailedResult -> { + val exception = + valueConstructor.buildObjectFromDescriptor(jcExecution.uTestExecutionResult.cause) as Throwable + if (!jcExecution.uTestExecutionResult.cause.raisedByUserCode) + logger.error(exception) { "Concrete executor failed" } + // TODO usvm-sbft + null + } + + is UTestExecutionTimedOutResult -> { + // TODO usvm-sbft + null + } + } + } private fun getTrace(executionResult: UTestExecutionResult): List? = when (executionResult) { @@ -86,13 +85,13 @@ class JcToUtExecutionConverter( private fun convertCoverage(jcCoverage: List?, jcClass: JcClassOrInterface) = Coverage( coveredInstructions = jcCoverage.orEmpty().map { - val methodSignature = it.enclosingMethod.jcdbSignature - Instruction( - internalName = it.enclosingClass.name.replace('.', '/'), - methodSignature = methodSignature, - lineNumber = it.lineNumber, - id = instructionIdProvider.provideInstructionId(methodSignature, it.location.index) - ) + val methodSignature = it.enclosingMethod.jcdbSignature + Instruction( + internalName = it.enclosingClass.name.replace('.', '/'), + methodSignature = methodSignature, + lineNumber = it.lineNumber, + id = instructionIdProvider.provideInstructionId(methodSignature, it.location.index) + ) }, // TODO usvm-sbft: maybe add cache here // TODO usvm-sbft: make sure static initializers are included into instructions count diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt new file mode 100644 index 0000000000..a8984ffb3c --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -0,0 +1,131 @@ +package org.utbot.contest.usvm + +import org.jacodb.analysis.library.analyzers.thisInstance +import org.usvm.instrumentation.classloader.WorkerClassLoader +import org.usvm.instrumentation.testcase.api.UTestExpression +import org.usvm.instrumentation.testcase.api.UTestMock +import org.usvm.instrumentation.testcase.api.UTestMockObject +import org.usvm.instrumentation.testcase.descriptor.Descriptor2ValueConverter +import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor +import org.usvm.instrumentation.testcase.descriptor.Value2DescriptorConverter +import org.usvm.instrumentation.testcase.executor.UTestExpressionExecutor +import org.usvm.instrumentation.util.toJavaClass +import org.usvm.instrumentation.util.toJavaField +import org.utbot.framework.plugin.api.ExecutableId +import org.utbot.framework.plugin.api.FieldId +import org.utbot.framework.plugin.api.MethodId +import org.utbot.framework.plugin.api.UtCompositeModel +import org.utbot.framework.plugin.api.UtModel +import org.utbot.framework.plugin.api.UtNullModel +import org.utbot.framework.plugin.api.util.fieldId +import org.utbot.framework.plugin.api.util.id +import org.utbot.framework.plugin.api.util.jClass +import org.utbot.framework.plugin.api.util.objectClassId +import org.utbot.framework.plugin.api.util.utContext +import org.utbot.instrumentation.instrumentation.execution.constructors.StateBeforeAwareIdGenerator +import org.utbot.instrumentation.instrumentation.execution.constructors.UtModelConstructor +import org.utbot.instrumentation.instrumentation.execution.constructors.javaStdLibModelWithCompositeOriginConstructors +import java.util.* + +class JcToUtModelConverter { + + private val classLoader = utContext.classLoader + private val toValueConverter = Descriptor2ValueConverter(classLoader) + + // TODO: properly deal with test executor and related features + private val testExecutor = UTestExpressionExecutor() + private val toDescriptorConverter = Value2DescriptorConverter(WorkerClassLoader(), null) + + + private val utModelConstructor = UtModelConstructor( + objectToModelCache = IdentityHashMap(), + idGenerator = StateBeforeAwareIdGenerator(allPreExistingModels = emptySet()), + utModelWithCompositeOriginConstructorFinder = { classId -> + javaStdLibModelWithCompositeOriginConstructors[classId.jClass]?.invoke() + } + ) + + private val exprToModelCache = mutableMapOf() + private val descrToModelCache = mutableMapOf() + + fun convert(valueDescriptor: UTestValueDescriptor?): UtModel { + //WTF, how can it happen? but null can be passed here + if (valueDescriptor == null) { + return UtNullModel(objectClassId) + } + + return descrToModelCache.getOrPut(valueDescriptor) { + val concreteValue = toValueConverter.buildObjectFromDescriptor(valueDescriptor) + val objectType = valueDescriptor.type.toJavaClass(classLoader).id + + val mocklessModel = utModelConstructor.construct(concreteValue, objectType) + + if (mocklessModel !is UtCompositeModel) { + return mocklessModel + } + + val instantiatingExpr: UTestMock = // TODO: valueDescriptor.instantiatingExpr + UTestMockObject(valueDescriptor.type, emptyMap(), emptyMap()) + + restoreMockInfo(instantiatingExpr, mocklessModel) + } + } + + + private fun restoreMockInfo( + mockExpr: UTestMock, + mocklessModel: UtCompositeModel, + ): UtModel { + + exprToModelCache[mockExpr]?.let { return it } + + val fields = mutableMapOf() + val mocks = mutableMapOf>() + + val finalModel = UtCompositeModel( + id = mocklessModel.id, + classId = mocklessModel.classId, + isMock = true, + fields = fields, + mocks = mocks, + ) + exprToModelCache[mockExpr] = finalModel + + fields += mockExpr.fields + .entries + .associate { (jcField, uTestExpr) -> + val fieldType = jcField.toJavaField(classLoader)!!.fieldId.type + val fieldId = FieldId(fieldType, jcField.name) + + val fieldModelDescr = exprToDescriptor(uTestExpr) + + val fieldModel = convert(fieldModelDescr) + fieldId to fieldModel + } + .toMutableMap() + + mocks += mockExpr.methods + .entries + .associate { (jcMethod, uTestExprs) -> + val type = jcMethod.thisInstance.type.classId + val returnType = jcMethod.returnType.classId + val parameters = jcMethod.parameters.map { it.type.classId } + val executableId: ExecutableId = MethodId(type, jcMethod.name, returnType, parameters) + + val models = uTestExprs + .map { expr -> exprToDescriptor(expr) } + .map { descr -> convert(descr) } + + executableId to models + } + .toMutableMap() + + return finalModel + } + + private fun exprToDescriptor(expr: UTestExpression): UTestValueDescriptor = + toDescriptorConverter + .buildDescriptorFromUTestExpr(expr, testExecutor) + ?.getOrNull()!! + .valueDescriptor!! +} \ No newline at end of file From 4aa8a109dbf1f0e9f86e3392d83647511a2ca935 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 31 Oct 2023 00:25:57 +0300 Subject: [PATCH 02/30] Initially implemented a converter of UTestInst to UtModel --- .../org/utbot/contest/usvm/ConverterUtils.kt | 24 +- .../contest/usvm/JcToUtExecutionConverter.kt | 25 ++ .../contest/usvm/JcToUtModelConverter.kt | 10 +- .../usvm/UTestInst2UtModelConverter.kt | 298 ++++++++++++++++++ 4 files changed, 348 insertions(+), 9 deletions(-) create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt index 092d39e840..5c7398ee21 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt @@ -1,13 +1,35 @@ package org.utbot.contest.usvm +import org.jacodb.analysis.library.analyzers.thisInstance +import org.jacodb.api.JcClassOrInterface +import org.jacodb.api.JcMethod import org.jacodb.api.JcType import org.jacodb.api.TypeName +import org.usvm.instrumentation.util.toJavaClass import org.utbot.framework.plugin.api.ClassId +import org.utbot.framework.plugin.api.ConstructorId +import org.utbot.framework.plugin.api.ExecutableId +import org.utbot.framework.plugin.api.MethodId import org.utbot.framework.plugin.api.util.id import org.utbot.framework.plugin.api.util.objectClassId +import org.utbot.framework.plugin.api.util.utContext + +fun JcMethod.toExecutableId(): ExecutableId { + val type = this.thisInstance.type.classId + val parameters = this.parameters.map { it.type.classId } + + if (isConstructor) { + return ConstructorId(type, parameters) + } + + return MethodId(type, this.name, this.returnType.classId, parameters) +} val JcType?.classId: ClassId - get() = this?.javaClass?.id ?: objectClassId + get() = this?.toJavaClass(utContext.classLoader)?.id ?: objectClassId + +val JcClassOrInterface.classId: ClassId + get() = this.toJavaClass(utContext.classLoader).id val TypeName.classId: ClassId get() = ClassId(this.typeName) \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt index e677e54917..600696375e 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -1,25 +1,33 @@ package org.utbot.contest.usvm import org.jacodb.api.JcClassOrInterface +import org.jacodb.api.JcMethod +import org.jacodb.api.JcTypedMethod import org.jacodb.api.cfg.JcInst import org.jacodb.api.ext.jcdbSignature import org.usvm.instrumentation.testcase.api.UTestExecutionExceptionResult import org.usvm.instrumentation.testcase.api.UTestExecutionFailedResult import org.usvm.instrumentation.testcase.api.UTestExecutionInitFailedResult import org.usvm.instrumentation.testcase.api.UTestExecutionResult +import org.usvm.instrumentation.testcase.api.UTestExecutionState import org.usvm.instrumentation.testcase.api.UTestExecutionSuccessResult import org.usvm.instrumentation.testcase.api.UTestExecutionTimedOutResult import org.usvm.instrumentation.testcase.descriptor.Descriptor2ValueConverter import org.usvm.instrumentation.util.enclosingClass import org.usvm.instrumentation.util.enclosingMethod +import org.usvm.instrumentation.util.toJavaField import org.utbot.contest.usvm.executor.JcExecution import org.utbot.framework.plugin.api.Coverage import org.utbot.framework.plugin.api.EnvironmentModels +import org.utbot.framework.plugin.api.ExecutableId +import org.utbot.framework.plugin.api.FieldId import org.utbot.framework.plugin.api.Instruction +import org.utbot.framework.plugin.api.MethodId import org.utbot.framework.plugin.api.MissingState import org.utbot.framework.plugin.api.UtExecution import org.utbot.framework.plugin.api.UtExecutionSuccess import org.utbot.framework.plugin.api.UtVoidModel +import org.utbot.framework.plugin.api.util.fieldId import org.utbot.framework.plugin.api.util.jClass import org.utbot.framework.plugin.api.util.utContext import org.utbot.instrumentation.instrumentation.execution.constructors.StateBeforeAwareIdGenerator @@ -41,6 +49,7 @@ class JcToUtExecutionConverter( is UTestExecutionSuccessResult -> { val result = UtExecutionSuccess(modelConverter.convert(executionResult.result)) + UtUsvmExecution( stateBefore = MissingState, stateAfter = MissingState, @@ -83,6 +92,22 @@ class JcToUtExecutionConverter( is UTestExecutionTimedOutResult -> emptyList() } + private fun convertState(state: UTestExecutionState, method: JcTypedMethod): EnvironmentModels { + val thisInstance = modelConverter.convert(state.instanceDescriptor?.valueDescriptor) + val parameters = state.argsDescriptors.map { modelConverter.convert(it!!.valueDescriptor) } + val statics = state.statics + .entries + .associate { (jcField, uTestDescr) -> + val fieldType = jcField.toJavaField(utContext.classLoader)!!.fieldId.type + val fieldId = FieldId(fieldType, jcField.name) + val fieldModel = modelConverter.convert(uTestDescr) + + fieldId to fieldModel + } + val executableId: ExecutableId = MethodId(...) + return EnvironmentModels(thisInstance, parameters, statics, executableId) + } + private fun convertCoverage(jcCoverage: List?, jcClass: JcClassOrInterface) = Coverage( coveredInstructions = jcCoverage.orEmpty().map { val methodSignature = it.enclosingMethod.jcdbSignature diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index a8984ffb3c..a3fea8cf6e 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -1,6 +1,5 @@ package org.utbot.contest.usvm -import org.jacodb.analysis.library.analyzers.thisInstance import org.usvm.instrumentation.classloader.WorkerClassLoader import org.usvm.instrumentation.testcase.api.UTestExpression import org.usvm.instrumentation.testcase.api.UTestMock @@ -13,7 +12,6 @@ import org.usvm.instrumentation.util.toJavaClass import org.usvm.instrumentation.util.toJavaField import org.utbot.framework.plugin.api.ExecutableId import org.utbot.framework.plugin.api.FieldId -import org.utbot.framework.plugin.api.MethodId import org.utbot.framework.plugin.api.UtCompositeModel import org.utbot.framework.plugin.api.UtModel import org.utbot.framework.plugin.api.UtNullModel @@ -60,6 +58,7 @@ class JcToUtModelConverter { val mocklessModel = utModelConstructor.construct(concreteValue, objectType) + //TODO: think about assemble models, arrays, with inner mocks; may be enums if (mocklessModel !is UtCompositeModel) { return mocklessModel } @@ -102,15 +101,11 @@ class JcToUtModelConverter { val fieldModel = convert(fieldModelDescr) fieldId to fieldModel } - .toMutableMap() mocks += mockExpr.methods .entries .associate { (jcMethod, uTestExprs) -> - val type = jcMethod.thisInstance.type.classId - val returnType = jcMethod.returnType.classId - val parameters = jcMethod.parameters.map { it.type.classId } - val executableId: ExecutableId = MethodId(type, jcMethod.name, returnType, parameters) + val executableId: ExecutableId = jcMethod.toExecutableId() val models = uTestExprs .map { expr -> exprToDescriptor(expr) } @@ -118,7 +113,6 @@ class JcToUtModelConverter { executableId to models } - .toMutableMap() return finalModel } diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt new file mode 100644 index 0000000000..914a855d37 --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt @@ -0,0 +1,298 @@ +package org.utbot.contest.usvm + +import org.usvm.instrumentation.testcase.api.UTestAllocateMemoryCall +import org.usvm.instrumentation.testcase.api.UTestArithmeticExpression +import org.usvm.instrumentation.testcase.api.UTestArrayGetExpression +import org.usvm.instrumentation.testcase.api.UTestArrayLengthExpression +import org.usvm.instrumentation.testcase.api.UTestArraySetStatement +import org.usvm.instrumentation.testcase.api.UTestBinaryConditionExpression +import org.usvm.instrumentation.testcase.api.UTestBinaryConditionStatement +import org.usvm.instrumentation.testcase.api.UTestBooleanExpression +import org.usvm.instrumentation.testcase.api.UTestByteExpression +import org.usvm.instrumentation.testcase.api.UTestCastExpression +import org.usvm.instrumentation.testcase.api.UTestCharExpression +import org.usvm.instrumentation.testcase.api.UTestClassExpression +import org.usvm.instrumentation.testcase.api.UTestConstructorCall +import org.usvm.instrumentation.testcase.api.UTestCreateArrayExpression +import org.usvm.instrumentation.testcase.api.UTestDoubleExpression +import org.usvm.instrumentation.testcase.api.UTestFloatExpression +import org.usvm.instrumentation.testcase.api.UTestGetFieldExpression +import org.usvm.instrumentation.testcase.api.UTestGetStaticFieldExpression +import org.usvm.instrumentation.testcase.api.UTestInst +import org.usvm.instrumentation.testcase.api.UTestIntExpression +import org.usvm.instrumentation.testcase.api.UTestLongExpression +import org.usvm.instrumentation.testcase.api.UTestMethodCall +import org.usvm.instrumentation.testcase.api.UTestMock +import org.usvm.instrumentation.testcase.api.UTestNullExpression +import org.usvm.instrumentation.testcase.api.UTestSetFieldStatement +import org.usvm.instrumentation.testcase.api.UTestSetStaticFieldStatement +import org.usvm.instrumentation.testcase.api.UTestShortExpression +import org.usvm.instrumentation.testcase.api.UTestStaticMethodCall +import org.usvm.instrumentation.testcase.api.UTestStringExpression +import org.utbot.framework.codegen.domain.builtin.UtilMethodProvider +import org.utbot.framework.plugin.api.ExecutableId +import org.utbot.framework.plugin.api.FieldId +import org.utbot.framework.plugin.api.UtArrayModel +import org.utbot.framework.plugin.api.UtAssembleModel +import org.utbot.framework.plugin.api.UtClassRefModel +import org.utbot.framework.plugin.api.UtCompositeModel +import org.utbot.framework.plugin.api.UtExecutableCallModel +import org.utbot.framework.plugin.api.UtModel +import org.utbot.framework.plugin.api.UtNullModel +import org.utbot.framework.plugin.api.UtPrimitiveModel +import org.utbot.framework.plugin.api.util.id +import org.utbot.framework.plugin.api.util.objectClassId +import org.utbot.fuzzer.ReferencePreservingIntIdGenerator + +class UTestInst2UtModelConverter( + private val utilMethodProvider: UtilMethodProvider +) { + + private val idGenerator = ReferencePreservingIntIdGenerator() + private val exprToModelCache = mutableMapOf() + + fun convert(uTestInst: UTestInst): UtModel { + exprToModelCache[uTestInst]?.let { return it } + + return when (uTestInst) { + is UTestAllocateMemoryCall -> { + val newModel = UtAssembleModel( + id = idGenerator.createId(), + classId = uTestInst.clazz.classId, + modelName = "", + instantiationCall = UtExecutableCallModel( + instance = null, + executable = utilMethodProvider.createInstanceMethodId, + params = listOf(UtPrimitiveModel(uTestInst.clazz.classId.name)), + ), + ) + exprToModelCache[uTestInst] = newModel + newModel + } + + is UTestConstructorCall -> { + val constructorCall = UtExecutableCallModel( + instance = null, + executable = uTestInst.method.toExecutableId(), + params = uTestInst.args.map { convert(it) }, + ) + + val newModel = UtAssembleModel( + id = idGenerator.createId(), + classId = uTestInst.type.classId, + modelName = "", + instantiationCall = constructorCall, + ) + + exprToModelCache[uTestInst] = newModel + newModel + } + + is UTestMethodCall -> { + val instanceModel = uTestInst.instance?.let { convert(it) } + require(instanceModel is UtAssembleModel) + + val methodCall = UtExecutableCallModel( + instance = instanceModel, + executable = uTestInst.method.toExecutableId(), + params = uTestInst.args.map { convert(it) }, + ) + + instanceModel?.let { + (it.modificationsChain as MutableList).add(methodCall) + } + + val newModel = UtAssembleModel( + id = idGenerator.createId(), + classId = uTestInst.type.classId, + modelName = "", + instantiationCall = methodCall, + ) + + exprToModelCache[uTestInst] = newModel + newModel + } + + is UTestClassExpression -> UtClassRefModel( + id = idGenerator.createId(), + classId = uTestInst.javaClass.id, + value = uTestInst.type.classId, + ) + + + is UTestBooleanExpression -> UtPrimitiveModel(uTestInst.value) + is UTestByteExpression -> UtPrimitiveModel(uTestInst.value) + is UTestCharExpression -> UtPrimitiveModel(uTestInst.value) + is UTestDoubleExpression -> UtPrimitiveModel(uTestInst.value) + is UTestFloatExpression -> UtPrimitiveModel(uTestInst.value) + is UTestIntExpression -> UtPrimitiveModel(uTestInst.value) + is UTestLongExpression -> UtPrimitiveModel(uTestInst.value) + is UTestShortExpression -> UtPrimitiveModel(uTestInst.value) + is UTestStringExpression -> UtPrimitiveModel(uTestInst.value) + + is UTestNullExpression -> UtNullModel(uTestInst.type.classId) + + is UTestCreateArrayExpression -> { + require(uTestInst.size is UTestIntExpression) + val arrayLength = uTestInst.size as UTestIntExpression + + val newModel = UtArrayModel( + id = idGenerator.createId(), + classId = uTestInst.type.classId, + length = arrayLength.value, + constModel = UtNullModel(objectClassId), + stores = mutableMapOf(), + ) + + exprToModelCache[uTestInst] = newModel + newModel + } + + is UTestArraySetStatement -> { + val arrayModel = exprToModelCache[uTestInst.arrayInstance] + requireNotNull(arrayModel) + require(arrayModel is UtArrayModel) + + require(uTestInst.index is UTestIntExpression) + val storeIndex = uTestInst.index as UTestIntExpression + + arrayModel.stores[storeIndex.value] = convert(uTestInst.setValueExpression) + + arrayModel + } + + is UTestGetFieldExpression -> { + val newModel = UtAssembleModel( + id = idGenerator.createId(), + classId = uTestInst.type.classId, + modelName = "", + instantiationCall = UtExecutableCallModel( + instance = null, + executable = utilMethodProvider.getFieldValueMethodId, + params = listOf( + convert(uTestInst.instance), + UtPrimitiveModel(uTestInst.field.type.classId.name), + UtPrimitiveModel(uTestInst.field.name), + ), + ), + ) + + exprToModelCache[uTestInst] = newModel + newModel + } + + is UTestGetStaticFieldExpression -> { + val newModel = UtAssembleModel( + id = idGenerator.createId(), + classId = uTestInst.type.classId, + modelName = "", + instantiationCall = UtExecutableCallModel( + instance = null, + executable = utilMethodProvider.getStaticFieldValueMethodId, + params = listOf( + UtPrimitiveModel(uTestInst.field.type.classId.name), + UtPrimitiveModel(uTestInst.field.name), + ), + ), + ) + + exprToModelCache[uTestInst] = newModel + newModel + } + + // TODO: Is in correct to process [UTestMockObject] and [UTestGlobalMock] similarly? + is UTestMock -> { + val fields = mutableMapOf() + val mocks = mutableMapOf>() + + val newModel = UtCompositeModel( + id = idGenerator.createId(), + classId = uTestInst.type.classId, + isMock = true, + fields = fields, + mocks = mocks, + ) + exprToModelCache[uTestInst] = newModel + + fields += uTestInst.fields + .entries + .associate { (jcField, uTestExpr) -> + val fieldId = FieldId(jcField.type.classId, jcField.name) + val fieldModel = convert(uTestExpr) + fieldId to fieldModel + } + + mocks += uTestInst.methods + .entries + .associate { (jcMethod, uTestExprs) -> + val executableId: ExecutableId = jcMethod.toExecutableId() + val models = uTestExprs.map { expr -> convert(expr) } + + executableId to models + } + + newModel + } + + is UTestSetFieldStatement -> { + val instanceModel = uTestInst.instance?.let { convert(it) } + require(instanceModel is UtAssembleModel) + val fieldType = uTestInst.field.type.classId + val fieldName = uTestInst.field.name + + val methodCall = UtExecutableCallModel( + instance = instanceModel, + executable = utilMethodProvider.setFieldMethodId, + params = listOf( + convert(uTestInst.instance), + UtPrimitiveModel(fieldType.name), + UtPrimitiveModel(fieldName), + convert(uTestInst.value), + ), + ) + + instanceModel?.let { + (it.modificationsChain as MutableList).add(methodCall) + } + + instanceModel + } + + is UTestSetStaticFieldStatement -> { + val fieldType = uTestInst.field.type.classId + val fieldName = uTestInst.field.name + + val methodCall = UtExecutableCallModel( + instance = null, + executable = utilMethodProvider.setStaticFieldMethodId, + params = listOf( + UtPrimitiveModel(fieldType.name), + UtPrimitiveModel(fieldName), + convert(uTestInst.value), + ), + ) + + val newModel = UtAssembleModel( + id = idGenerator.createId(), + classId = objectClassId, + modelName = "", + instantiationCall = methodCall, + ) + + exprToModelCache[uTestInst] = newModel + newModel + } + + + is UTestArithmeticExpression -> error("This expression type is not supported") + is UTestBinaryConditionExpression -> error("This expression type is not supported") + is UTestBinaryConditionStatement -> error("This expression type is not supported") + is UTestStaticMethodCall -> error("This expression type is not supported") + + is UTestCastExpression -> error("This expression type is not supported") + + is UTestArrayGetExpression -> error("This expression type is not supported") + is UTestArrayLengthExpression -> error("This expression type is not supported") + } + } +} \ No newline at end of file From ddcf870d35f96ef846b0ebe6300d4fb88642cd07 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 31 Oct 2023 20:21:19 +0300 Subject: [PATCH 03/30] Refactor JcToUtModelConverter basing on UTestInst2UtModel converter --- .../org/utbot/contest/usvm/ConverterUtils.kt | 8 +- .../contest/usvm/JcToUtModelConverter.kt | 106 +++++------------- 2 files changed, 34 insertions(+), 80 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt index 5c7398ee21..95c5a1f323 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt @@ -5,6 +5,9 @@ import org.jacodb.api.JcClassOrInterface import org.jacodb.api.JcMethod import org.jacodb.api.JcType import org.jacodb.api.TypeName +import org.usvm.instrumentation.testcase.api.UTestInst +import org.usvm.instrumentation.testcase.descriptor.UTestObjectDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor import org.usvm.instrumentation.util.toJavaClass import org.utbot.framework.plugin.api.ClassId import org.utbot.framework.plugin.api.ConstructorId @@ -32,4 +35,7 @@ val JcClassOrInterface.classId: ClassId get() = this.toJavaClass(utContext.classLoader).id val TypeName.classId: ClassId - get() = ClassId(this.typeName) \ No newline at end of file + get() = ClassId(this.typeName) + +val UTestValueDescriptor.origin: UTestInst? + get() = (this as UTestObjectDescriptor)?.originUTestExpr \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index a3fea8cf6e..b7803dc15c 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -1,21 +1,19 @@ package org.utbot.contest.usvm -import org.usvm.instrumentation.classloader.WorkerClassLoader -import org.usvm.instrumentation.testcase.api.UTestExpression -import org.usvm.instrumentation.testcase.api.UTestMock -import org.usvm.instrumentation.testcase.api.UTestMockObject import org.usvm.instrumentation.testcase.descriptor.Descriptor2ValueConverter import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor -import org.usvm.instrumentation.testcase.descriptor.Value2DescriptorConverter -import org.usvm.instrumentation.testcase.executor.UTestExpressionExecutor import org.usvm.instrumentation.util.toJavaClass -import org.usvm.instrumentation.util.toJavaField -import org.utbot.framework.plugin.api.ExecutableId -import org.utbot.framework.plugin.api.FieldId +import org.utbot.framework.codegen.domain.builtin.UtilMethodProvider +import org.utbot.framework.plugin.api.UtArrayModel +import org.utbot.framework.plugin.api.UtAssembleModel +import org.utbot.framework.plugin.api.UtClassRefModel import org.utbot.framework.plugin.api.UtCompositeModel +import org.utbot.framework.plugin.api.UtCustomModel +import org.utbot.framework.plugin.api.UtEnumConstantModel +import org.utbot.framework.plugin.api.UtLambdaModel import org.utbot.framework.plugin.api.UtModel import org.utbot.framework.plugin.api.UtNullModel -import org.utbot.framework.plugin.api.util.fieldId +import org.utbot.framework.plugin.api.UtPrimitiveModel import org.utbot.framework.plugin.api.util.id import org.utbot.framework.plugin.api.util.jClass import org.utbot.framework.plugin.api.util.objectClassId @@ -25,14 +23,11 @@ import org.utbot.instrumentation.instrumentation.execution.constructors.UtModelC import org.utbot.instrumentation.instrumentation.execution.constructors.javaStdLibModelWithCompositeOriginConstructors import java.util.* -class JcToUtModelConverter { +class JcToUtModelConverter(utilMethodProvider: UtilMethodProvider) { private val classLoader = utContext.classLoader private val toValueConverter = Descriptor2ValueConverter(classLoader) - - // TODO: properly deal with test executor and related features - private val testExecutor = UTestExpressionExecutor() - private val toDescriptorConverter = Value2DescriptorConverter(WorkerClassLoader(), null) + private val inst2modelConverter = UTestInst2UtModelConverter(utilMethodProvider) private val utModelConstructor = UtModelConstructor( @@ -43,7 +38,6 @@ class JcToUtModelConverter { } ) - private val exprToModelCache = mutableMapOf() private val descrToModelCache = mutableMapOf() fun convert(valueDescriptor: UTestValueDescriptor?): UtModel { @@ -56,70 +50,24 @@ class JcToUtModelConverter { val concreteValue = toValueConverter.buildObjectFromDescriptor(valueDescriptor) val objectType = valueDescriptor.type.toJavaClass(classLoader).id - val mocklessModel = utModelConstructor.construct(concreteValue, objectType) - - //TODO: think about assemble models, arrays, with inner mocks; may be enums - if (mocklessModel !is UtCompositeModel) { - return mocklessModel + val missingMocksModel = utModelConstructor.construct(concreteValue, objectType) + + return when (missingMocksModel) { + is UtNullModel, + is UtPrimitiveModel, + is UtClassRefModel, + is UtEnumConstantModel, + is UtLambdaModel -> missingMocksModel + is UtCompositeModel, + is UtArrayModel, + is UtAssembleModel -> { + valueDescriptor.origin + ?.let { inst2modelConverter.convert(it) } + ?: missingMocksModel + } + is UtCustomModel -> error("Custom models are not supported in Contest") + else -> error("The type of $missingMocksModel is not supported in Contest") } - - val instantiatingExpr: UTestMock = // TODO: valueDescriptor.instantiatingExpr - UTestMockObject(valueDescriptor.type, emptyMap(), emptyMap()) - - restoreMockInfo(instantiatingExpr, mocklessModel) } } - - - private fun restoreMockInfo( - mockExpr: UTestMock, - mocklessModel: UtCompositeModel, - ): UtModel { - - exprToModelCache[mockExpr]?.let { return it } - - val fields = mutableMapOf() - val mocks = mutableMapOf>() - - val finalModel = UtCompositeModel( - id = mocklessModel.id, - classId = mocklessModel.classId, - isMock = true, - fields = fields, - mocks = mocks, - ) - exprToModelCache[mockExpr] = finalModel - - fields += mockExpr.fields - .entries - .associate { (jcField, uTestExpr) -> - val fieldType = jcField.toJavaField(classLoader)!!.fieldId.type - val fieldId = FieldId(fieldType, jcField.name) - - val fieldModelDescr = exprToDescriptor(uTestExpr) - - val fieldModel = convert(fieldModelDescr) - fieldId to fieldModel - } - - mocks += mockExpr.methods - .entries - .associate { (jcMethod, uTestExprs) -> - val executableId: ExecutableId = jcMethod.toExecutableId() - - val models = uTestExprs - .map { expr -> exprToDescriptor(expr) } - .map { descr -> convert(descr) } - - executableId to models - } - - return finalModel - } - - private fun exprToDescriptor(expr: UTestExpression): UTestValueDescriptor = - toDescriptorConverter - .buildDescriptorFromUTestExpr(expr, testExecutor) - ?.getOrNull()!! - .valueDescriptor!! } \ No newline at end of file From 9532b8a6adb85b3972ac6270d3442bbde41e36fb Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 31 Oct 2023 20:40:37 +0300 Subject: [PATCH 04/30] Some steps to implement JcToUtExecutionConverter --- .../contest/usvm/JcToUtExecutionConverter.kt | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt index 600696375e..b5b2dfbe3e 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -17,6 +17,8 @@ import org.usvm.instrumentation.util.enclosingClass import org.usvm.instrumentation.util.enclosingMethod import org.usvm.instrumentation.util.toJavaField import org.utbot.contest.usvm.executor.JcExecution +import org.utbot.framework.codegen.domain.builtin.TestClassUtilMethodProvider +import org.utbot.framework.plugin.api.ClassId import org.utbot.framework.plugin.api.Coverage import org.utbot.framework.plugin.api.EnvironmentModels import org.utbot.framework.plugin.api.ExecutableId @@ -29,6 +31,7 @@ import org.utbot.framework.plugin.api.UtExecutionSuccess import org.utbot.framework.plugin.api.UtVoidModel import org.utbot.framework.plugin.api.util.fieldId import org.utbot.framework.plugin.api.util.jClass +import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.framework.plugin.api.util.utContext import org.utbot.instrumentation.instrumentation.execution.constructors.StateBeforeAwareIdGenerator import org.utbot.instrumentation.instrumentation.execution.constructors.UtModelConstructor @@ -36,10 +39,14 @@ import org.utbot.instrumentation.instrumentation.execution.constructors.javaStdL import java.util.* class JcToUtExecutionConverter( - private val instructionIdProvider: InstructionIdProvider + private val instructionIdProvider: InstructionIdProvider, ) { + //TODO: obtain in somehow from [JcExecution] or somewhere else + private val testClassId: ClassId = objectClassId + private val utilMethodProvider = TestClassUtilMethodProvider(testClassId) - private val modelConverter = JcToUtModelConverter() + private val modelConverter = JcToUtModelConverter(utilMethodProvider) + private val instConverter = UTestInst2UtModelConverter(utilMethodProvider) fun convert(jcExecution: JcExecution): UtExecution? { val coverage = convertCoverage(getTrace(jcExecution.uTestExecutionResult), jcExecution.method.enclosingType.jcClass) @@ -93,8 +100,8 @@ class JcToUtExecutionConverter( } private fun convertState(state: UTestExecutionState, method: JcTypedMethod): EnvironmentModels { - val thisInstance = modelConverter.convert(state.instanceDescriptor?.valueDescriptor) - val parameters = state.argsDescriptors.map { modelConverter.convert(it!!.valueDescriptor) } + val thisInstance = instConverter.convert(state.instanceDescriptor?.origin!!) + val parameters = state.argsDescriptors.map { instConverter.convert(it?.origin!!) } val statics = state.statics .entries .associate { (jcField, uTestDescr) -> @@ -104,7 +111,7 @@ class JcToUtExecutionConverter( fieldId to fieldModel } - val executableId: ExecutableId = MethodId(...) + val executableId: ExecutableId = method.method.toExecutableId() return EnvironmentModels(thisInstance, parameters, statics, executableId) } From d79ea8bf75cd343e3db1969d937b8c696df3255c Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Wed, 1 Nov 2023 14:19:20 +0300 Subject: [PATCH 05/30] Implement minimalistic jc to ut execution conversion, enable codegen --- utbot-junit-contest/build.gradle | 2 + .../org/utbot/contest/ContestEstimator.kt | 3 + .../org/utbot/contest/usvm/ContestUsvm.kt | 55 ++++++--- .../org/utbot/contest/usvm/ConverterUtils.kt | 7 ++ .../contest/usvm/JcToUtExecutionConverter.kt | 107 +++++++++++------- .../contest/usvm/JcToUtModelConverter.kt | 32 +----- 6 files changed, 122 insertions(+), 84 deletions(-) diff --git a/utbot-junit-contest/build.gradle b/utbot-junit-contest/build.gradle index afea753424..5d2b939a6e 100644 --- a/utbot-junit-contest/build.gradle +++ b/utbot-junit-contest/build.gradle @@ -140,6 +140,8 @@ dependencies { implementation group: 'org.mockito', name: 'mockito-inline', version: mockitoInlineVersion implementation 'junit:junit:4.13.2' + implementation "org.burningwave:core:12.62.7" + implementation('org.usvm:usvm-core') implementation('org.usvm:usvm-jvm') implementation('org.usvm:usvm-jvm-instrumentation') diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/ContestEstimator.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/ContestEstimator.kt index 0894c45f05..df33e461ee 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/ContestEstimator.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/ContestEstimator.kt @@ -354,6 +354,9 @@ interface Tool { } fun main(args: Array) { + // See https://dzone.com/articles/how-to-export-all-modules-to-all-modules-at-runtime-in-java?preview=true + org.burningwave.core.assembler.StaticComponentContainer.Modules.exportAllToAll() + val estimatorArgs: Array val methodFilter: String? val projectFilter: List? diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt index 8780e74b9a..d2c45d805d 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt @@ -11,6 +11,9 @@ import org.objectweb.asm.Type import org.usvm.UMachineOptions import org.usvm.instrumentation.util.toJcdbSignature import org.usvm.machine.JcMachine +import org.usvm.machine.state.JcState +import org.utbot.common.ThreadBasedExecutor +import org.utbot.common.debug import org.utbot.common.info import org.utbot.common.measureTime import org.utbot.contest.* @@ -24,12 +27,14 @@ import org.utbot.framework.codegen.domain.junitByVersion import org.utbot.framework.codegen.generator.CodeGenerator import org.utbot.framework.codegen.generator.CodeGeneratorParams import org.utbot.framework.codegen.services.language.CgLanguageAssistant +import org.utbot.framework.minimization.minimizeExecutions import org.utbot.framework.plugin.api.* import org.utbot.framework.plugin.api.util.constructor import org.utbot.framework.plugin.api.util.jClass import org.utbot.framework.plugin.api.util.method import org.utbot.framework.plugin.services.JdkInfoService import org.utbot.fuzzer.UtFuzzedExecution +import org.utbot.summary.summarizeAll import java.io.File import java.net.URLClassLoader import kotlin.math.max @@ -98,6 +103,7 @@ fun runUsvmGeneration( //remaining budget val startTime = System.currentTimeMillis() + logger.debug { "STARTED COUNTING BUDGET FOR ${cut.classId.name}" } fun remainingBudgetMillisWithoutCodegen() = max(0, generationTimeoutMillisWithoutCodegen - (System.currentTimeMillis() - startTime)) @@ -139,6 +145,8 @@ fun runUsvmGeneration( val totalBudgetPerMethod = remainingBudgetMillisWithoutCodegen() / filteredMethods.size val concreteBudgetMsPerMethod = 500L .coerceIn((totalBudgetPerMethod / 10L).. (totalBudgetPerMethod / 2L)) + val symbolicBudgetPerMethod = totalBudgetPerMethod - concreteBudgetMsPerMethod + logger.debug { "Symbolic budget per method: $symbolicBudgetPerMethod" } // TODO usvm-sbft: reuse same machine for different classes, // right now I can't do that, because `timeoutMs` can't be changed after machine creation @@ -146,7 +154,7 @@ fun runUsvmGeneration( JcMachine( cp = jcDbContainer.cp, // TODO usvm-sbft: we may want to tune UMachineOptions for contest - options = UMachineOptions(timeoutMs = totalBudgetPerMethod - concreteBudgetMsPerMethod) + options = UMachineOptions(timeoutMs = symbolicBudgetPerMethod) ) }.use { machine -> val jcClass = jcDbContainer.cp.findClass(cut.fqn) @@ -167,7 +175,17 @@ fun runUsvmGeneration( logger.error { "Method [$method] not found in jcClass [$jcClass]" } continue } - val states = machine.analyze(jcTypedMethod.method) + val states = logger.debug().measureTime({ "machine.analyze(${method.classId}.${method.signature})" }) { + ((ThreadBasedExecutor.threadLocal.invokeWithTimeout(10 * symbolicBudgetPerMethod) { + machine.analyze(jcTypedMethod.method) + } as? Result>) ?: run { + logger.error { "machine.analyze(${jcTypedMethod.method}) timed out" } + Result.success(emptyList()) + }).getOrElse { e -> + logger.error("JcMachine failed", e) + emptyList() + } + } val jcExecutions = states.mapNotNull { // TODO usvm-sbft: if we have less than `runner.timeout` budget we should only let resolver run // for `remainingBudgetMillisWithoutCodegen()` ms, right now last resolver call may exceed budget, @@ -176,11 +194,13 @@ fun runUsvmGeneration( // TODO usvm-sbft: right now this call fails unless you set: // - "usvm-jvm-instrumentation-jar" environment variable to something like "/home/ilya/IdeaProjects/usvm/usvm-jvm-instrumentation/build/libs/usvm-jvm-instrumentation-1.0.jar" // - "usvm-jvm-collectors-jar" environment variable to something like "/home/ilya/IdeaProjects/usvm/usvm-jvm-instrumentation/build/libs/usvm-jvm-instrumentation-collectors.jar" - runCatching { - resolver.resolve(jcTypedMethod, it) - }.getOrElse { e -> - logger.error(e) { "Resolver failed" } - null + logger.debug().measureTime({ "resolver.resolve(${method.classId}.${method.signature}, ...)" }) { + runCatching { + resolver.resolve(jcTypedMethod, it) + }.getOrElse { e -> + logger.error(e) { "Resolver failed" } + null + } } else null } @@ -193,7 +213,9 @@ fun runUsvmGeneration( statsForClass.statsForMethods.add(statsForMethod) val utExecutions: List = jcExecutions.mapNotNull { - JcToUtExecutionConverter(instructionIdProvider).convert(it) + logger.debug().measureTime({ "Convert JcExecution" }) { + JcToUtExecutionConverter(instructionIdProvider).convert(it) + } } utExecutions.forEach { result -> @@ -220,19 +242,20 @@ fun runUsvmGeneration( logger.error(e) { "Test generation failed during stats update" } } } + logger.debug { "Finished $method" } } } } -// TODO usvm-sbft: codegen, requires proper UtUsvmExecution creation (not just coverage) + val testSets = testsByMethod.map { (method, executions) -> + UtMethodTestSet(method, minimizeExecutions(executions), jimpleBody = null) + }.summarizeAll(cut.classfileDir.toPath(), sourceFile = null) + + logger.info().measureTime({ "Flushing tests for [${cut.simpleName}] on disk" }) { + writeTestClass(cut, codeGenerator.generateAsString(testSets)) + } -// val testSets = testsByMethod.map { (method, executions) -> -// UtMethodTestSet(method, minimizeExecutions(executions), jimpleBody(method)) -// }.summarizeAll(cut.classfileDir.toPath(), sourceFile = null) -// -// logger.info().measureTime({ "Flushing tests for [${cut.simpleName}] on disk" }) { -// writeTestClass(cut, codeGenerator.generateAsString(testSets)) -// } + logger.debug { "STOPPED COUNTING BUDGET FOR ${cut.classId.name}" } statsForClass } \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt index 95c5a1f323..d6ec26ee52 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt @@ -2,6 +2,7 @@ package org.utbot.contest.usvm import org.jacodb.analysis.library.analyzers.thisInstance import org.jacodb.api.JcClassOrInterface +import org.jacodb.api.JcField import org.jacodb.api.JcMethod import org.jacodb.api.JcType import org.jacodb.api.TypeName @@ -9,10 +10,13 @@ import org.usvm.instrumentation.testcase.api.UTestInst import org.usvm.instrumentation.testcase.descriptor.UTestObjectDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor import org.usvm.instrumentation.util.toJavaClass +import org.usvm.instrumentation.util.toJavaField import org.utbot.framework.plugin.api.ClassId import org.utbot.framework.plugin.api.ConstructorId import org.utbot.framework.plugin.api.ExecutableId +import org.utbot.framework.plugin.api.FieldId import org.utbot.framework.plugin.api.MethodId +import org.utbot.framework.plugin.api.util.fieldId import org.utbot.framework.plugin.api.util.id import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.framework.plugin.api.util.utContext @@ -37,5 +41,8 @@ val JcClassOrInterface.classId: ClassId val TypeName.classId: ClassId get() = ClassId(this.typeName) +val JcField.fieldId: FieldId + get() = toJavaField(utContext.classLoader)!!.fieldId + val UTestValueDescriptor.origin: UTestInst? get() = (this as UTestObjectDescriptor)?.originUTestExpr \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt index b5b2dfbe3e..10d320f865 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -1,9 +1,10 @@ package org.utbot.contest.usvm +import mu.KotlinLogging import org.jacodb.api.JcClassOrInterface -import org.jacodb.api.JcMethod import org.jacodb.api.JcTypedMethod import org.jacodb.api.cfg.JcInst +import org.jacodb.api.cfg.JcThrowInst import org.jacodb.api.ext.jcdbSignature import org.usvm.instrumentation.testcase.api.UTestExecutionExceptionResult import org.usvm.instrumentation.testcase.api.UTestExecutionFailedResult @@ -13,30 +14,26 @@ import org.usvm.instrumentation.testcase.api.UTestExecutionState import org.usvm.instrumentation.testcase.api.UTestExecutionSuccessResult import org.usvm.instrumentation.testcase.api.UTestExecutionTimedOutResult import org.usvm.instrumentation.testcase.descriptor.Descriptor2ValueConverter +import org.usvm.instrumentation.testcase.descriptor.UTestExceptionDescriptor import org.usvm.instrumentation.util.enclosingClass import org.usvm.instrumentation.util.enclosingMethod -import org.usvm.instrumentation.util.toJavaField import org.utbot.contest.usvm.executor.JcExecution import org.utbot.framework.codegen.domain.builtin.TestClassUtilMethodProvider import org.utbot.framework.plugin.api.ClassId import org.utbot.framework.plugin.api.Coverage import org.utbot.framework.plugin.api.EnvironmentModels import org.utbot.framework.plugin.api.ExecutableId -import org.utbot.framework.plugin.api.FieldId import org.utbot.framework.plugin.api.Instruction -import org.utbot.framework.plugin.api.MethodId -import org.utbot.framework.plugin.api.MissingState import org.utbot.framework.plugin.api.UtExecution +import org.utbot.framework.plugin.api.UtExecutionFailure import org.utbot.framework.plugin.api.UtExecutionSuccess -import org.utbot.framework.plugin.api.UtVoidModel -import org.utbot.framework.plugin.api.util.fieldId -import org.utbot.framework.plugin.api.util.jClass +import org.utbot.framework.plugin.api.UtExplicitlyThrownException +import org.utbot.framework.plugin.api.UtImplicitlyThrownException +import org.utbot.framework.plugin.api.UtInstrumentation import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.framework.plugin.api.util.utContext -import org.utbot.instrumentation.instrumentation.execution.constructors.StateBeforeAwareIdGenerator -import org.utbot.instrumentation.instrumentation.execution.constructors.UtModelConstructor -import org.utbot.instrumentation.instrumentation.execution.constructors.javaStdLibModelWithCompositeOriginConstructors -import java.util.* + +private val logger = KotlinLogging.logger {} class JcToUtExecutionConverter( private val instructionIdProvider: InstructionIdProvider, @@ -45,42 +42,47 @@ class JcToUtExecutionConverter( private val testClassId: ClassId = objectClassId private val utilMethodProvider = TestClassUtilMethodProvider(testClassId) - private val modelConverter = JcToUtModelConverter(utilMethodProvider) + private val modelConverter = JcToUtModelConverter() private val instConverter = UTestInst2UtModelConverter(utilMethodProvider) + private val toValueConverter = Descriptor2ValueConverter(utContext.classLoader) fun convert(jcExecution: JcExecution): UtExecution? { val coverage = convertCoverage(getTrace(jcExecution.uTestExecutionResult), jcExecution.method.enclosingType.jcClass) + val instrumentation = emptyList() // TODO usvm-sbft: fill up instrumentation with data from UTest - val executionResult = jcExecution.uTestExecutionResult - return when (executionResult) { - is UTestExecutionSuccessResult -> { - val result = UtExecutionSuccess(modelConverter.convert(executionResult.result)) - - + return when (val executionResult = jcExecution.uTestExecutionResult) { + is UTestExecutionSuccessResult -> UtUsvmExecution( + stateBefore = convertState(executionResult.initialState, jcExecution.method), + stateAfter = convertState(executionResult.resultState, jcExecution.method), + result = UtExecutionSuccess(modelConverter.convert(executionResult.result)), + coverage = coverage, + instrumentation = instrumentation, + ) + is UTestExecutionExceptionResult -> toUserRaisedException(executionResult.cause)?.let { exception -> UtUsvmExecution( - stateBefore = MissingState, - stateAfter = MissingState, - result = result, + stateBefore = convertState(executionResult.initialState, jcExecution.method), + stateAfter = convertState(executionResult.resultState, jcExecution.method), + result = createExecutionFailureResult( + exception, + jcExecution.method, + executionResult.trace + ), coverage = coverage, - instrumentation = emptyList() + instrumentation = instrumentation, ) } - - is UTestExecutionExceptionResult -> TODO("usvm-sbft") is UTestExecutionInitFailedResult -> { - val exception = - valueConstructor.buildObjectFromDescriptor(jcExecution.uTestExecutionResult.cause) as Throwable - logger.error(exception) { "Concrete executor failed" } + toUserRaisedException(executionResult.cause)?.let { e -> + logger.warn(e) { "Execution failed before method under test call" } + } null } is UTestExecutionFailedResult -> { - val exception = - valueConstructor.buildObjectFromDescriptor(jcExecution.uTestExecutionResult.cause) as Throwable - if (!jcExecution.uTestExecutionResult.cause.raisedByUserCode) - logger.error(exception) { "Concrete executor failed" } - // TODO usvm-sbft - null + toUserRaisedException(executionResult.cause)?.let { e -> + // TODO usvm-sbft + null + } } is UTestExecutionTimedOutResult -> { @@ -88,7 +90,17 @@ class JcToUtExecutionConverter( null } } + // TODO usvm-sbft: deep map UtExecution to substitute models build from UTest + } + private fun toUserRaisedException(exceptionDescriptor: UTestExceptionDescriptor): Throwable? { + val exception = + toValueConverter.buildObjectFromDescriptor(exceptionDescriptor) as Throwable + return if (exceptionDescriptor.raisedByUserCode) exception + else { + logger.error(exception) { "Concrete execution failed" } + null + } } private fun getTrace(executionResult: UTestExecutionResult): List? = when (executionResult) { @@ -100,21 +112,34 @@ class JcToUtExecutionConverter( } private fun convertState(state: UTestExecutionState, method: JcTypedMethod): EnvironmentModels { - val thisInstance = instConverter.convert(state.instanceDescriptor?.origin!!) - val parameters = state.argsDescriptors.map { instConverter.convert(it?.origin!!) } + val thisInstance = + if (method.isStatic) null + else modelConverter.convert(state.instanceDescriptor) + val parameters = state.argsDescriptors.map { modelConverter.convert(it) } val statics = state.statics .entries .associate { (jcField, uTestDescr) -> - val fieldType = jcField.toJavaField(utContext.classLoader)!!.fieldId.type - val fieldId = FieldId(fieldType, jcField.name) - val fieldModel = modelConverter.convert(uTestDescr) - - fieldId to fieldModel + jcField.fieldId to modelConverter.convert(uTestDescr) } val executableId: ExecutableId = method.method.toExecutableId() return EnvironmentModels(thisInstance, parameters, statics, executableId) } + private fun createExecutionFailureResult( + exception: Throwable, + jcTypedMethod: JcTypedMethod, + jcCoverage: List? + ): UtExecutionFailure { + // TODO usvm-sbft: test that exceptions are correctly classified + val lastJcInst = jcCoverage.orEmpty().lastOrNull() + ?: return UtImplicitlyThrownException(exception, fromNestedMethod = false) + val fromNestedMethod = lastJcInst.enclosingMethod != jcTypedMethod.method + return if (lastJcInst is JcThrowInst) + UtExplicitlyThrownException(exception, fromNestedMethod) + else + UtImplicitlyThrownException(exception, fromNestedMethod) + } + private fun convertCoverage(jcCoverage: List?, jcClass: JcClassOrInterface) = Coverage( coveredInstructions = jcCoverage.orEmpty().map { val methodSignature = it.enclosingMethod.jcdbSignature diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index b7803dc15c..9ed3b41b8e 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -23,12 +23,10 @@ import org.utbot.instrumentation.instrumentation.execution.constructors.UtModelC import org.utbot.instrumentation.instrumentation.execution.constructors.javaStdLibModelWithCompositeOriginConstructors import java.util.* -class JcToUtModelConverter(utilMethodProvider: UtilMethodProvider) { +class JcToUtModelConverter { private val classLoader = utContext.classLoader private val toValueConverter = Descriptor2ValueConverter(classLoader) - private val inst2modelConverter = UTestInst2UtModelConverter(utilMethodProvider) - private val utModelConstructor = UtModelConstructor( objectToModelCache = IdentityHashMap(), @@ -38,36 +36,16 @@ class JcToUtModelConverter(utilMethodProvider: UtilMethodProvider) { } ) - private val descrToModelCache = mutableMapOf() - fun convert(valueDescriptor: UTestValueDescriptor?): UtModel { + // TODO usvm-sbft: ask why `UTestExecutionSuccessResult.result` is nullable //WTF, how can it happen? but null can be passed here if (valueDescriptor == null) { return UtNullModel(objectClassId) } - return descrToModelCache.getOrPut(valueDescriptor) { - val concreteValue = toValueConverter.buildObjectFromDescriptor(valueDescriptor) - val objectType = valueDescriptor.type.toJavaClass(classLoader).id + val concreteValue = toValueConverter.buildObjectFromDescriptor(valueDescriptor) + val objectType = valueDescriptor.type.toJavaClass(classLoader).id - val missingMocksModel = utModelConstructor.construct(concreteValue, objectType) - - return when (missingMocksModel) { - is UtNullModel, - is UtPrimitiveModel, - is UtClassRefModel, - is UtEnumConstantModel, - is UtLambdaModel -> missingMocksModel - is UtCompositeModel, - is UtArrayModel, - is UtAssembleModel -> { - valueDescriptor.origin - ?.let { inst2modelConverter.convert(it) } - ?: missingMocksModel - } - is UtCustomModel -> error("Custom models are not supported in Contest") - else -> error("The type of $missingMocksModel is not supported in Contest") - } - } + return utModelConstructor.construct(concreteValue, objectType) } } \ No newline at end of file From 8e30b30e82953da7592eb03b87608b4f68c76470 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Wed, 1 Nov 2023 17:23:39 +0300 Subject: [PATCH 06/30] Some improvements --- .../contest/usvm/JcToUtExecutionConverter.kt | 18 ++- .../contest/usvm/JcToUtModelConverter.kt | 20 ++- .../usvm/UTestInst2UtModelConverter.kt | 119 ++++++++++++------ 3 files changed, 112 insertions(+), 45 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt index 10d320f865..e5f2f0145e 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -42,26 +42,28 @@ class JcToUtExecutionConverter( private val testClassId: ClassId = objectClassId private val utilMethodProvider = TestClassUtilMethodProvider(testClassId) - private val modelConverter = JcToUtModelConverter() private val instConverter = UTestInst2UtModelConverter(utilMethodProvider) private val toValueConverter = Descriptor2ValueConverter(utContext.classLoader) fun convert(jcExecution: JcExecution): UtExecution? { + val instToModelCache = instConverter.processUTest(jcExecution.uTest) + val modelConverter = JcToUtModelConverter(instToModelCache) + val coverage = convertCoverage(getTrace(jcExecution.uTestExecutionResult), jcExecution.method.enclosingType.jcClass) val instrumentation = emptyList() // TODO usvm-sbft: fill up instrumentation with data from UTest return when (val executionResult = jcExecution.uTestExecutionResult) { is UTestExecutionSuccessResult -> UtUsvmExecution( - stateBefore = convertState(executionResult.initialState, jcExecution.method), - stateAfter = convertState(executionResult.resultState, jcExecution.method), + stateBefore = convertState(executionResult.initialState, jcExecution.method, modelConverter), + stateAfter = convertState(executionResult.resultState, jcExecution.method, modelConverter), result = UtExecutionSuccess(modelConverter.convert(executionResult.result)), coverage = coverage, instrumentation = instrumentation, ) is UTestExecutionExceptionResult -> toUserRaisedException(executionResult.cause)?.let { exception -> UtUsvmExecution( - stateBefore = convertState(executionResult.initialState, jcExecution.method), - stateAfter = convertState(executionResult.resultState, jcExecution.method), + stateBefore = convertState(executionResult.initialState, jcExecution.method, modelConverter), + stateAfter = convertState(executionResult.resultState, jcExecution.method, modelConverter), result = createExecutionFailureResult( exception, jcExecution.method, @@ -111,7 +113,11 @@ class JcToUtExecutionConverter( is UTestExecutionTimedOutResult -> emptyList() } - private fun convertState(state: UTestExecutionState, method: JcTypedMethod): EnvironmentModels { + private fun convertState( + state: UTestExecutionState, + method: JcTypedMethod, + modelConverter: JcToUtModelConverter, + ): EnvironmentModels { val thisInstance = if (method.isStatic) null else modelConverter.convert(state.instanceDescriptor) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index 9ed3b41b8e..b35a9434c8 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -1,5 +1,6 @@ package org.utbot.contest.usvm +import org.usvm.instrumentation.testcase.api.UTestExpression import org.usvm.instrumentation.testcase.descriptor.Descriptor2ValueConverter import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor import org.usvm.instrumentation.util.toJavaClass @@ -23,7 +24,9 @@ import org.utbot.instrumentation.instrumentation.execution.constructors.UtModelC import org.utbot.instrumentation.instrumentation.execution.constructors.javaStdLibModelWithCompositeOriginConstructors import java.util.* -class JcToUtModelConverter { +class JcToUtModelConverter( + private val instToModelCache: Map, +) { private val classLoader = utContext.classLoader private val toValueConverter = Descriptor2ValueConverter(classLoader) @@ -46,6 +49,19 @@ class JcToUtModelConverter { val concreteValue = toValueConverter.buildObjectFromDescriptor(valueDescriptor) val objectType = valueDescriptor.type.toJavaClass(classLoader).id - return utModelConstructor.construct(concreteValue, objectType) + val missingMocksModel = utModelConstructor.construct(concreteValue, objectType) + + return when (missingMocksModel) { + is UtNullModel, + is UtPrimitiveModel, + is UtClassRefModel, + is UtEnumConstantModel, + is UtLambdaModel -> missingMocksModel + is UtCompositeModel, + is UtArrayModel, + is UtAssembleModel -> instToModelCache[valueDescriptor.origin] ?: missingMocksModel + is UtCustomModel -> error("Custom models are not supported in Contest") + else -> error("The type of $missingMocksModel is not supported in Contest") + } } } \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt index 914a855d37..c8e5c4ef7c 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt @@ -1,5 +1,6 @@ package org.utbot.contest.usvm +import org.usvm.instrumentation.testcase.UTest import org.usvm.instrumentation.testcase.api.UTestAllocateMemoryCall import org.usvm.instrumentation.testcase.api.UTestArithmeticExpression import org.usvm.instrumentation.testcase.api.UTestArrayGetExpression @@ -15,14 +16,16 @@ import org.usvm.instrumentation.testcase.api.UTestClassExpression import org.usvm.instrumentation.testcase.api.UTestConstructorCall import org.usvm.instrumentation.testcase.api.UTestCreateArrayExpression import org.usvm.instrumentation.testcase.api.UTestDoubleExpression +import org.usvm.instrumentation.testcase.api.UTestExpression import org.usvm.instrumentation.testcase.api.UTestFloatExpression import org.usvm.instrumentation.testcase.api.UTestGetFieldExpression import org.usvm.instrumentation.testcase.api.UTestGetStaticFieldExpression +import org.usvm.instrumentation.testcase.api.UTestGlobalMock import org.usvm.instrumentation.testcase.api.UTestInst import org.usvm.instrumentation.testcase.api.UTestIntExpression import org.usvm.instrumentation.testcase.api.UTestLongExpression import org.usvm.instrumentation.testcase.api.UTestMethodCall -import org.usvm.instrumentation.testcase.api.UTestMock +import org.usvm.instrumentation.testcase.api.UTestMockObject import org.usvm.instrumentation.testcase.api.UTestNullExpression import org.usvm.instrumentation.testcase.api.UTestSetFieldStatement import org.usvm.instrumentation.testcase.api.UTestSetStaticFieldStatement @@ -37,24 +40,41 @@ import org.utbot.framework.plugin.api.UtAssembleModel import org.utbot.framework.plugin.api.UtClassRefModel import org.utbot.framework.plugin.api.UtCompositeModel import org.utbot.framework.plugin.api.UtExecutableCallModel +import org.utbot.framework.plugin.api.UtInstrumentation import org.utbot.framework.plugin.api.UtModel +import org.utbot.framework.plugin.api.UtNewInstanceInstrumentation import org.utbot.framework.plugin.api.UtNullModel import org.utbot.framework.plugin.api.UtPrimitiveModel import org.utbot.framework.plugin.api.util.id import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.fuzzer.ReferencePreservingIntIdGenerator +data class UTestInstOutput( + val exprToModelCache: Map, + val instrumentations: List, + ) + class UTestInst2UtModelConverter( private val utilMethodProvider: UtilMethodProvider ) { private val idGenerator = ReferencePreservingIntIdGenerator() - private val exprToModelCache = mutableMapOf() + private val exprToModelCache = mutableMapOf() + private val instrumentations = mutableListOf() + + fun processUTest(uTest: UTest): UTestInstOutput { + exprToModelCache.clear() + instrumentations.clear() + + uTest.initStatements.forEach { uInst -> processInst(uInst) } - fun convert(uTestInst: UTestInst): UtModel { - exprToModelCache[uTestInst]?.let { return it } + return UTestInstOutput(exprToModelCache, instrumentations) + } + + private fun processInst(uTestInst: UTestInst) { + exprToModelCache[uTestInst]?.let { return } - return when (uTestInst) { + when (uTestInst) { is UTestAllocateMemoryCall -> { val newModel = UtAssembleModel( id = idGenerator.createId(), @@ -67,14 +87,16 @@ class UTestInst2UtModelConverter( ), ) exprToModelCache[uTestInst] = newModel - newModel } is UTestConstructorCall -> { val constructorCall = UtExecutableCallModel( instance = null, executable = uTestInst.method.toExecutableId(), - params = uTestInst.args.map { convert(it) }, + params = uTestInst.args.map { arg -> + processInst(arg) + exprToModelCache[arg] ?: error("UtModel for $arg should have also been created") + }, ) val newModel = UtAssembleModel( @@ -85,17 +107,23 @@ class UTestInst2UtModelConverter( ) exprToModelCache[uTestInst] = newModel - newModel } is UTestMethodCall -> { - val instanceModel = uTestInst.instance?.let { convert(it) } + val instanceExpr = uTestInst.instance + instanceExpr?.let { processInst(it) } + + val instanceModel = exprToModelCache[instanceExpr] + ?: error("UtModel for $instanceExpr should have also been created") require(instanceModel is UtAssembleModel) val methodCall = UtExecutableCallModel( instance = instanceModel, executable = uTestInst.method.toExecutableId(), - params = uTestInst.args.map { convert(it) }, + params = uTestInst.args.map { arg -> + processInst(arg) + exprToModelCache[arg] ?: error("UtModel for $arg should have also been created") + }, ) instanceModel?.let { @@ -110,7 +138,6 @@ class UTestInst2UtModelConverter( ) exprToModelCache[uTestInst] = newModel - newModel } is UTestClassExpression -> UtClassRefModel( @@ -145,7 +172,6 @@ class UTestInst2UtModelConverter( ) exprToModelCache[uTestInst] = newModel - newModel } is UTestArraySetStatement -> { @@ -156,12 +182,21 @@ class UTestInst2UtModelConverter( require(uTestInst.index is UTestIntExpression) val storeIndex = uTestInst.index as UTestIntExpression - arrayModel.stores[storeIndex.value] = convert(uTestInst.setValueExpression) + val setValueExpression = uTestInst.setValueExpression + processInst(setValueExpression) + val elementModel = exprToModelCache[setValueExpression] + ?: error("UtModel for $setValueExpression should have also been created") - arrayModel + arrayModel.stores[storeIndex.value] = elementModel } is UTestGetFieldExpression -> { + val instanceExpr = uTestInst.instance + instanceExpr?.let { processInst(it) } + + val instanceModel = exprToModelCache[instanceExpr] + ?: error("UtModel for $instanceExpr should have also been created") + val newModel = UtAssembleModel( id = idGenerator.createId(), classId = uTestInst.type.classId, @@ -170,7 +205,7 @@ class UTestInst2UtModelConverter( instance = null, executable = utilMethodProvider.getFieldValueMethodId, params = listOf( - convert(uTestInst.instance), + instanceModel, UtPrimitiveModel(uTestInst.field.type.classId.name), UtPrimitiveModel(uTestInst.field.name), ), @@ -178,7 +213,6 @@ class UTestInst2UtModelConverter( ) exprToModelCache[uTestInst] = newModel - newModel } is UTestGetStaticFieldExpression -> { @@ -197,11 +231,10 @@ class UTestInst2UtModelConverter( ) exprToModelCache[uTestInst] = newModel - newModel } // TODO: Is in correct to process [UTestMockObject] and [UTestGlobalMock] similarly? - is UTestMock -> { + is UTestMockObject -> { val fields = mutableMapOf() val mocks = mutableMapOf>() @@ -218,7 +251,10 @@ class UTestInst2UtModelConverter( .entries .associate { (jcField, uTestExpr) -> val fieldId = FieldId(jcField.type.classId, jcField.name) - val fieldModel = convert(uTestExpr) + + processInst(uTestExpr) + val fieldModel = exprToModelCache[uTestExpr] + ?: error("UtModel for $uTestExpr should have also been created") fieldId to fieldModel } @@ -226,61 +262,70 @@ class UTestInst2UtModelConverter( .entries .associate { (jcMethod, uTestExprs) -> val executableId: ExecutableId = jcMethod.toExecutableId() - val models = uTestExprs.map { expr -> convert(expr) } + val models = uTestExprs.map { expr -> + processInst(expr) + exprToModelCache[expr] ?: error("UtModel for $expr should have also been created") + } executableId to models } - - newModel } is UTestSetFieldStatement -> { - val instanceModel = uTestInst.instance?.let { convert(it) } + val instanceExpr = uTestInst.instance + + instanceExpr?.let { processInst(it) } + val instanceModel = exprToModelCache[instanceExpr] + ?: error("UtModel for $instanceExpr should have also been created") require(instanceModel is UtAssembleModel) + val fieldType = uTestInst.field.type.classId val fieldName = uTestInst.field.name + val setValueExpr = uTestInst.value + processInst(setValueExpr) + val setValueModel = exprToModelCache[setValueExpr] + ?: error("UtModel for $setValueExpr should have also been created") + val methodCall = UtExecutableCallModel( instance = instanceModel, executable = utilMethodProvider.setFieldMethodId, params = listOf( - convert(uTestInst.instance), + instanceModel, UtPrimitiveModel(fieldType.name), UtPrimitiveModel(fieldName), - convert(uTestInst.value), + setValueModel, ), ) instanceModel?.let { (it.modificationsChain as MutableList).add(methodCall) } - - instanceModel } is UTestSetStaticFieldStatement -> { + // TODO: seems we do not need this snippet as we store only expressions in cache val fieldType = uTestInst.field.type.classId val fieldName = uTestInst.field.name + val setValueExpr = uTestInst.value + processInst(setValueExpr) + val setValueModel = exprToModelCache[setValueExpr] + ?: error("UtModel for $setValueExpr should have also been created") + val methodCall = UtExecutableCallModel( instance = null, executable = utilMethodProvider.setStaticFieldMethodId, params = listOf( UtPrimitiveModel(fieldType.name), UtPrimitiveModel(fieldName), - convert(uTestInst.value), + setValueModel, ), ) + } - val newModel = UtAssembleModel( - id = idGenerator.createId(), - classId = objectClassId, - modelName = "", - instantiationCall = methodCall, - ) - - exprToModelCache[uTestInst] = newModel - newModel + is UTestGlobalMock -> { + // TODO: collect instrumentations here } From 5935d7bf0413c852b8c987b0ee84ce8ca0fabf31 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Fri, 3 Nov 2023 15:21:21 +0300 Subject: [PATCH 07/30] DeepMapper for models is used --- .../framework/plugin/api/mapper/Utils.kt | 11 ++++++++++ .../contest/usvm/JcToUtExecutionConverter.kt | 19 +++++++++++++--- .../contest/usvm/JcToUtModelConverter.kt | 18 +++------------ .../org/utbot/contest/usvm/UtUsvmExecution.kt | 22 ++++++++++++++++++- .../kotlin/org/utbot/contest/usvm/Utils.kt | 16 ++++++++++++++ 5 files changed, 67 insertions(+), 19 deletions(-) create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/Utils.kt diff --git a/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/Utils.kt b/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/Utils.kt index 30bbbe01d7..9c8ed80a8a 100644 --- a/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/Utils.kt +++ b/utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/mapper/Utils.kt @@ -5,6 +5,8 @@ import org.utbot.framework.plugin.api.UtDirectGetFieldModel import org.utbot.framework.plugin.api.UtDirectSetFieldModel import org.utbot.framework.plugin.api.UtExecutableCallModel import org.utbot.framework.plugin.api.UtExecution +import org.utbot.framework.plugin.api.UtExecutionResult +import org.utbot.framework.plugin.api.UtExecutionSuccess import org.utbot.framework.plugin.api.UtInstrumentation import org.utbot.framework.plugin.api.UtModel import org.utbot.framework.plugin.api.UtNewInstanceInstrumentation @@ -12,6 +14,7 @@ import org.utbot.framework.plugin.api.UtReferenceModel import org.utbot.framework.plugin.api.UtStatementCallModel import org.utbot.framework.plugin.api.UtStatementModel import org.utbot.framework.plugin.api.UtStaticMethodInstrumentation +import org.utbot.framework.plugin.api.isSuccess inline fun T.mapPreservingType(mapper: UtModelMapper): T = mapper.map(this, T::class.java) @@ -54,6 +57,14 @@ fun EnvironmentModels.mapModels(mapper: UtModelMapper) = EnvironmentModels( executableToCall = executableToCall, ) +fun UtExecutionResult.mapModelIfExists(mapper: UtModelMapper) = if (this.isSuccess) { + val successResult = this as UtExecutionSuccess + UtExecutionSuccess(successResult.model.map(mapper)) +} else { + this +} + + fun UtInstrumentation.mapModels(mapper: UtModelMapper) = when (this) { is UtNewInstanceInstrumentation -> copy(instances = instances.mapModels(mapper)) is UtStaticMethodInstrumentation -> copy(values = values.mapModels(mapper)) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt index e5f2f0145e..8e9ee4e509 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -30,6 +30,8 @@ import org.utbot.framework.plugin.api.UtExecutionSuccess import org.utbot.framework.plugin.api.UtExplicitlyThrownException import org.utbot.framework.plugin.api.UtImplicitlyThrownException import org.utbot.framework.plugin.api.UtInstrumentation +import org.utbot.framework.plugin.api.mapper.UtModelDeepMapper +import org.utbot.framework.plugin.api.mapper.mapStateBeforeModels import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.framework.plugin.api.util.utContext @@ -50,9 +52,10 @@ class JcToUtExecutionConverter( val modelConverter = JcToUtModelConverter(instToModelCache) val coverage = convertCoverage(getTrace(jcExecution.uTestExecutionResult), jcExecution.method.enclosingType.jcClass) - val instrumentation = emptyList() // TODO usvm-sbft: fill up instrumentation with data from UTest + // TODO usvm-sbft: fill up instrumentation with data from UTest + val instrumentation = emptyList() - return when (val executionResult = jcExecution.uTestExecutionResult) { + val utUsvmExecution: UtUsvmExecution = when (val executionResult = jcExecution.uTestExecutionResult) { is UTestExecutionSuccessResult -> UtUsvmExecution( stateBefore = convertState(executionResult.initialState, jcExecution.method, modelConverter), stateAfter = convertState(executionResult.resultState, jcExecution.method, modelConverter), @@ -60,6 +63,7 @@ class JcToUtExecutionConverter( coverage = coverage, instrumentation = instrumentation, ) + is UTestExecutionExceptionResult -> toUserRaisedException(executionResult.cause)?.let { exception -> UtUsvmExecution( stateBefore = convertState(executionResult.initialState, jcExecution.method, modelConverter), @@ -73,6 +77,7 @@ class JcToUtExecutionConverter( instrumentation = instrumentation, ) } + is UTestExecutionInitFailedResult -> { toUserRaisedException(executionResult.cause)?.let { e -> logger.warn(e) { "Execution failed before method under test call" } @@ -91,7 +96,15 @@ class JcToUtExecutionConverter( // TODO usvm-sbft null } - } + } ?: return null + + return utUsvmExecution.mapModels(UtModelDeepMapper { + instToModelCache[ + toValueConverter.cache.getValue( + utModelConstructor.cache.getValue(it) + ).origin + ] ?: it + }) // TODO usvm-sbft: deep map UtExecution to substitute models build from UTest } diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index b35a9434c8..c60f0755cf 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -15,6 +15,8 @@ import org.utbot.framework.plugin.api.UtLambdaModel import org.utbot.framework.plugin.api.UtModel import org.utbot.framework.plugin.api.UtNullModel import org.utbot.framework.plugin.api.UtPrimitiveModel +import org.utbot.framework.plugin.api.mapper.UtModelDeepMapper +import org.utbot.framework.plugin.api.mapper.map import org.utbot.framework.plugin.api.util.id import org.utbot.framework.plugin.api.util.jClass import org.utbot.framework.plugin.api.util.objectClassId @@ -41,7 +43,6 @@ class JcToUtModelConverter( fun convert(valueDescriptor: UTestValueDescriptor?): UtModel { // TODO usvm-sbft: ask why `UTestExecutionSuccessResult.result` is nullable - //WTF, how can it happen? but null can be passed here if (valueDescriptor == null) { return UtNullModel(objectClassId) } @@ -49,19 +50,6 @@ class JcToUtModelConverter( val concreteValue = toValueConverter.buildObjectFromDescriptor(valueDescriptor) val objectType = valueDescriptor.type.toJavaClass(classLoader).id - val missingMocksModel = utModelConstructor.construct(concreteValue, objectType) - - return when (missingMocksModel) { - is UtNullModel, - is UtPrimitiveModel, - is UtClassRefModel, - is UtEnumConstantModel, - is UtLambdaModel -> missingMocksModel - is UtCompositeModel, - is UtArrayModel, - is UtAssembleModel -> instToModelCache[valueDescriptor.origin] ?: missingMocksModel - is UtCustomModel -> error("Custom models are not supported in Contest") - else -> error("The type of $missingMocksModel is not supported in Contest") - } + return utModelConstructor.construct(concreteValue, objectType) } } \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UtUsvmExecution.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UtUsvmExecution.kt index a7f469ab4d..0964c0c29b 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UtUsvmExecution.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UtUsvmExecution.kt @@ -42,6 +42,26 @@ class UtUsvmExecution( summary, testMethodName, displayName, - instrumentation + instrumentation, + ) + + fun copy( + stateBefore: EnvironmentModels = this.stateBefore, + stateAfter: EnvironmentModels = this.stateAfter, + result: UtExecutionResult = this.result, + coverage: Coverage? = this.coverage, + summary: List? = this.summary, + testMethodName: String? = this.testMethodName, + displayName: String? = this.displayName, + instrumentation: List = this.instrumentation, + ) = UtUsvmExecution( + stateBefore, + stateAfter, + result, + coverage, + summary, + testMethodName, + displayName, + instrumentation, ) } \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/Utils.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/Utils.kt new file mode 100644 index 0000000000..f58c682e26 --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/Utils.kt @@ -0,0 +1,16 @@ +package org.utbot.contest.usvm + +import org.utbot.framework.plugin.api.mapper.UtModelMapper +import org.utbot.framework.plugin.api.mapper.mapModelIfExists +import org.utbot.framework.plugin.api.mapper.mapModels + +fun UtUsvmExecution.mapModels(mapper: UtModelMapper) = copy( + stateBefore = stateBefore.mapModels(mapper), + stateAfter = stateAfter.mapModels(mapper), + result = result.mapModelIfExists(mapper), + coverage = this.coverage, + summary = this.summary, + testMethodName = this.testMethodName, + displayName = this.displayName, + instrumentation = instrumentation.map { it.mapModels(mapper) }, +) \ No newline at end of file From 535abb0fbd9d2d10f183376df20fb0bffbf7fe88 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Fri, 3 Nov 2023 17:34:54 +0300 Subject: [PATCH 08/30] Corrections --- .../contest/usvm/JcToUtExecutionConverter.kt | 31 +++++----- .../contest/usvm/JcToUtModelConverter.kt | 57 +++++++++++++++++++ .../usvm/UTestInst2UtModelConverter.kt | 6 +- 3 files changed, 75 insertions(+), 19 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt index 8e9ee4e509..b11c5bdee9 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -30,27 +30,33 @@ import org.utbot.framework.plugin.api.UtExecutionSuccess import org.utbot.framework.plugin.api.UtExplicitlyThrownException import org.utbot.framework.plugin.api.UtImplicitlyThrownException import org.utbot.framework.plugin.api.UtInstrumentation -import org.utbot.framework.plugin.api.mapper.UtModelDeepMapper -import org.utbot.framework.plugin.api.mapper.mapStateBeforeModels import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.framework.plugin.api.util.utContext +import org.utbot.fuzzer.IdGenerator private val logger = KotlinLogging.logger {} class JcToUtExecutionConverter( + private val jcExecution: JcExecution, + private val idGenerator: IdGenerator, private val instructionIdProvider: InstructionIdProvider, ) { - //TODO: obtain in somehow from [JcExecution] or somewhere else + //TODO usvm-sbft: obtain in somehow from [JcExecution] or somewhere else private val testClassId: ClassId = objectClassId - private val utilMethodProvider = TestClassUtilMethodProvider(testClassId) - private val instConverter = UTestInst2UtModelConverter(utilMethodProvider) private val toValueConverter = Descriptor2ValueConverter(utContext.classLoader) - fun convert(jcExecution: JcExecution): UtExecution? { - val instToModelCache = instConverter.processUTest(jcExecution.uTest) - val modelConverter = JcToUtModelConverter(instToModelCache) + private var modelConverter: JcToUtModelConverter + init { + val utilMethodProvider = TestClassUtilMethodProvider(testClassId) + val instToModelConverter = UTestInst2UtModelConverter(idGenerator, utilMethodProvider) + val uTestProcessResult = instToModelConverter.processUTest(jcExecution.uTest) + + modelConverter = JcToUtModelConverter(idGenerator, uTestProcessResult.exprToModelCache) + } + + fun convert(): UtExecution? { val coverage = convertCoverage(getTrace(jcExecution.uTestExecutionResult), jcExecution.method.enclosingType.jcClass) // TODO usvm-sbft: fill up instrumentation with data from UTest val instrumentation = emptyList() @@ -98,14 +104,7 @@ class JcToUtExecutionConverter( } } ?: return null - return utUsvmExecution.mapModels(UtModelDeepMapper { - instToModelCache[ - toValueConverter.cache.getValue( - utModelConstructor.cache.getValue(it) - ).origin - ] ?: it - }) - // TODO usvm-sbft: deep map UtExecution to substitute models build from UTest + return utUsvmExecution } private fun toUserRaisedException(exceptionDescriptor: UTestExceptionDescriptor): Throwable? { diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index c60f0755cf..275344d78a 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -2,9 +2,17 @@ package org.utbot.contest.usvm import org.usvm.instrumentation.testcase.api.UTestExpression import org.usvm.instrumentation.testcase.descriptor.Descriptor2ValueConverter +import org.usvm.instrumentation.testcase.descriptor.UTestArrayDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestClassDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestConstantDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestCyclicReferenceDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestEnumValueDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestExceptionDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestObjectDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor import org.usvm.instrumentation.util.toJavaClass import org.utbot.framework.codegen.domain.builtin.UtilMethodProvider +import org.utbot.framework.plugin.api.FieldId import org.utbot.framework.plugin.api.UtArrayModel import org.utbot.framework.plugin.api.UtAssembleModel import org.utbot.framework.plugin.api.UtClassRefModel @@ -21,12 +29,14 @@ import org.utbot.framework.plugin.api.util.id import org.utbot.framework.plugin.api.util.jClass import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.framework.plugin.api.util.utContext +import org.utbot.fuzzer.IdGenerator import org.utbot.instrumentation.instrumentation.execution.constructors.StateBeforeAwareIdGenerator import org.utbot.instrumentation.instrumentation.execution.constructors.UtModelConstructor import org.utbot.instrumentation.instrumentation.execution.constructors.javaStdLibModelWithCompositeOriginConstructors import java.util.* class JcToUtModelConverter( + private val idGenerator: IdGenerator, private val instToModelCache: Map, ) { @@ -41,12 +51,59 @@ class JcToUtModelConverter( } ) + private val descriptorToModelCache = mutableMapOf() + fun convert(valueDescriptor: UTestValueDescriptor?): UtModel { + valueDescriptor?.origin?.let { + return instToModelCache.getValue(it as UTestExpression) + } + // TODO usvm-sbft: ask why `UTestExecutionSuccessResult.result` is nullable if (valueDescriptor == null) { return UtNullModel(objectClassId) } + when (valueDescriptor) { + is UTestObjectDescriptor -> { + val fields = mutableMapOf() + + val model = UtCompositeModel( + id = idGenerator.createId(), + classId = valueDescriptor.type.classId, + isMock = false, + mocks = mutableMapOf(), + fields = fields, + ) + + descriptorToModelCache[valueDescriptor] = model + // add fields + } + + is UTestArrayDescriptor.Array -> TODO() + is UTestArrayDescriptor.BooleanArray -> TODO() + is UTestArrayDescriptor.ByteArray -> TODO() + is UTestArrayDescriptor.CharArray -> TODO() + is UTestArrayDescriptor.DoubleArray -> TODO() + is UTestArrayDescriptor.FloatArray -> TODO() + is UTestArrayDescriptor.IntArray -> TODO() + is UTestArrayDescriptor.LongArray -> TODO() + is UTestArrayDescriptor.ShortArray -> TODO() + is UTestClassDescriptor -> TODO() + is UTestConstantDescriptor.Boolean -> TODO() + is UTestConstantDescriptor.Byte -> TODO() + is UTestConstantDescriptor.Char -> TODO() + is UTestConstantDescriptor.Double -> TODO() + is UTestConstantDescriptor.Float -> TODO() + is UTestConstantDescriptor.Int -> TODO() + is UTestConstantDescriptor.Long -> TODO() + is UTestConstantDescriptor.Null -> TODO() + is UTestConstantDescriptor.Short -> TODO() + is UTestConstantDescriptor.String -> TODO() + is UTestCyclicReferenceDescriptor -> TODO() + is UTestEnumValueDescriptor -> TODO() + is UTestExceptionDescriptor -> TODO() + } + val concreteValue = toValueConverter.buildObjectFromDescriptor(valueDescriptor) val objectType = valueDescriptor.type.toJavaClass(classLoader).id diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt index c8e5c4ef7c..a46df4d441 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt @@ -47,6 +47,7 @@ import org.utbot.framework.plugin.api.UtNullModel import org.utbot.framework.plugin.api.UtPrimitiveModel import org.utbot.framework.plugin.api.util.id import org.utbot.framework.plugin.api.util.objectClassId +import org.utbot.fuzzer.IdGenerator import org.utbot.fuzzer.ReferencePreservingIntIdGenerator data class UTestInstOutput( @@ -55,10 +56,9 @@ data class UTestInstOutput( ) class UTestInst2UtModelConverter( - private val utilMethodProvider: UtilMethodProvider + private val idGenerator: IdGenerator, + private val utilMethodProvider: UtilMethodProvider, ) { - - private val idGenerator = ReferencePreservingIntIdGenerator() private val exprToModelCache = mutableMapOf() private val instrumentations = mutableListOf() From 509cb73375489c5b4cb0536b88d1c380daab1515 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Fri, 3 Nov 2023 17:42:13 +0300 Subject: [PATCH 09/30] Some improvements to JcToUtModelConverter --- .../contest/usvm/JcToUtModelConverter.kt | 30 +++++++------------ 1 file changed, 11 insertions(+), 19 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index 275344d78a..92e0f9a06c 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -39,18 +39,6 @@ class JcToUtModelConverter( private val idGenerator: IdGenerator, private val instToModelCache: Map, ) { - - private val classLoader = utContext.classLoader - private val toValueConverter = Descriptor2ValueConverter(classLoader) - - private val utModelConstructor = UtModelConstructor( - objectToModelCache = IdentityHashMap(), - idGenerator = StateBeforeAwareIdGenerator(allPreExistingModels = emptySet()), - utModelWithCompositeOriginConstructorFinder = { classId -> - javaStdLibModelWithCompositeOriginConstructors[classId.jClass]?.invoke() - } - ) - private val descriptorToModelCache = mutableMapOf() fun convert(valueDescriptor: UTestValueDescriptor?): UtModel { @@ -63,7 +51,7 @@ class JcToUtModelConverter( return UtNullModel(objectClassId) } - when (valueDescriptor) { + return when (valueDescriptor) { is UTestObjectDescriptor -> { val fields = mutableMapOf() @@ -76,7 +64,16 @@ class JcToUtModelConverter( ) descriptorToModelCache[valueDescriptor] = model - // add fields + + fields += valueDescriptor.fields + .entries + .associate { (jcField, fieldDescr) -> + val fieldId = FieldId(jcField.type.classId, jcField.name) + val fieldModel = convert(fieldDescr) + fieldId to fieldModel + } + + model } is UTestArrayDescriptor.Array -> TODO() @@ -103,10 +100,5 @@ class JcToUtModelConverter( is UTestEnumValueDescriptor -> TODO() is UTestExceptionDescriptor -> TODO() } - - val concreteValue = toValueConverter.buildObjectFromDescriptor(valueDescriptor) - val objectType = valueDescriptor.type.toJavaClass(classLoader).id - - return utModelConstructor.construct(concreteValue, objectType) } } \ No newline at end of file From 21bde03093fe6115dea17e5578eb3e2d19ad1618 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Fri, 3 Nov 2023 18:26:49 +0300 Subject: [PATCH 10/30] Further improvements to JcToUtModelConverter --- .../contest/usvm/JcToUtModelConverter.kt | 105 ++++++++++++------ .../usvm/UTestInst2UtModelConverter.kt | 3 +- 2 files changed, 71 insertions(+), 37 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index 92e0f9a06c..362afc065c 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -1,7 +1,6 @@ package org.utbot.contest.usvm import org.usvm.instrumentation.testcase.api.UTestExpression -import org.usvm.instrumentation.testcase.descriptor.Descriptor2ValueConverter import org.usvm.instrumentation.testcase.descriptor.UTestArrayDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestClassDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestConstantDescriptor @@ -10,30 +9,16 @@ import org.usvm.instrumentation.testcase.descriptor.UTestEnumValueDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestExceptionDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestObjectDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor -import org.usvm.instrumentation.util.toJavaClass -import org.utbot.framework.codegen.domain.builtin.UtilMethodProvider import org.utbot.framework.plugin.api.FieldId import org.utbot.framework.plugin.api.UtArrayModel -import org.utbot.framework.plugin.api.UtAssembleModel import org.utbot.framework.plugin.api.UtClassRefModel import org.utbot.framework.plugin.api.UtCompositeModel -import org.utbot.framework.plugin.api.UtCustomModel -import org.utbot.framework.plugin.api.UtEnumConstantModel -import org.utbot.framework.plugin.api.UtLambdaModel import org.utbot.framework.plugin.api.UtModel import org.utbot.framework.plugin.api.UtNullModel import org.utbot.framework.plugin.api.UtPrimitiveModel -import org.utbot.framework.plugin.api.mapper.UtModelDeepMapper -import org.utbot.framework.plugin.api.mapper.map -import org.utbot.framework.plugin.api.util.id -import org.utbot.framework.plugin.api.util.jClass +import org.utbot.framework.plugin.api.util.classClassId import org.utbot.framework.plugin.api.util.objectClassId -import org.utbot.framework.plugin.api.util.utContext import org.utbot.fuzzer.IdGenerator -import org.utbot.instrumentation.instrumentation.execution.constructors.StateBeforeAwareIdGenerator -import org.utbot.instrumentation.instrumentation.execution.constructors.UtModelConstructor -import org.utbot.instrumentation.instrumentation.execution.constructors.javaStdLibModelWithCompositeOriginConstructors -import java.util.* class JcToUtModelConverter( private val idGenerator: IdGenerator, @@ -76,29 +61,77 @@ class JcToUtModelConverter( model } - is UTestArrayDescriptor.Array -> TODO() - is UTestArrayDescriptor.BooleanArray -> TODO() - is UTestArrayDescriptor.ByteArray -> TODO() - is UTestArrayDescriptor.CharArray -> TODO() - is UTestArrayDescriptor.DoubleArray -> TODO() - is UTestArrayDescriptor.FloatArray -> TODO() - is UTestArrayDescriptor.IntArray -> TODO() - is UTestArrayDescriptor.LongArray -> TODO() - is UTestArrayDescriptor.ShortArray -> TODO() - is UTestClassDescriptor -> TODO() - is UTestConstantDescriptor.Boolean -> TODO() - is UTestConstantDescriptor.Byte -> TODO() - is UTestConstantDescriptor.Char -> TODO() - is UTestConstantDescriptor.Double -> TODO() - is UTestConstantDescriptor.Float -> TODO() - is UTestConstantDescriptor.Int -> TODO() - is UTestConstantDescriptor.Long -> TODO() - is UTestConstantDescriptor.Null -> TODO() - is UTestConstantDescriptor.Short -> TODO() - is UTestConstantDescriptor.String -> TODO() + is UTestArrayDescriptor.Array -> { + val stores = mutableMapOf() + + val model = UtArrayModel( + id = idGenerator.createId(), + classId = valueDescriptor.type.classId, + length = valueDescriptor.length, + constModel = UtNullModel(valueDescriptor.elementType.classId), + stores = stores, + ) + + descriptorToModelCache[valueDescriptor] = model + + valueDescriptor.value + .map { elemDescr -> convert(elemDescr) } + .forEachIndexed { index, elemModel -> stores += index to elemModel } + + model + } + + is UTestArrayDescriptor.BooleanArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.ByteArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.CharArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.DoubleArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.FloatArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.IntArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.LongArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.ShortArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) + + is UTestClassDescriptor -> UtClassRefModel( + id = idGenerator.createId(), + classId = classClassId, + value = valueDescriptor.classType.classId, + ) + + is UTestConstantDescriptor.Null -> UtNullModel(valueDescriptor.type.classId) + + is UTestConstantDescriptor.Boolean -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.Byte -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.Char -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.Double -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.Float -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.Int -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.Long -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.Short -> UtPrimitiveModel(valueDescriptor.value) + is UTestConstantDescriptor.String -> UtPrimitiveModel(valueDescriptor.value) + is UTestCyclicReferenceDescriptor -> TODO() is UTestEnumValueDescriptor -> TODO() is UTestExceptionDescriptor -> TODO() } } + + private fun constructArrayModel(valueDescriptor: UTestArrayDescriptor<*>, arrayContent: List): UtArrayModel { + val stores = mutableMapOf() + + val model = UtArrayModel( + id = idGenerator.createId(), + classId = valueDescriptor.type.classId, + length = valueDescriptor.length, + constModel = UtNullModel(valueDescriptor.elementType.classId), + stores = stores, + ) + + descriptorToModelCache[valueDescriptor] = model + + arrayContent + .map { elemValue -> UtPrimitiveModel(elemValue) } + .forEachIndexed { index, elemModel -> stores += index to elemModel } + + return model + } + } \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt index a46df4d441..6ee76f5ce2 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt @@ -45,6 +45,7 @@ import org.utbot.framework.plugin.api.UtModel import org.utbot.framework.plugin.api.UtNewInstanceInstrumentation import org.utbot.framework.plugin.api.UtNullModel import org.utbot.framework.plugin.api.UtPrimitiveModel +import org.utbot.framework.plugin.api.util.classClassId import org.utbot.framework.plugin.api.util.id import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.fuzzer.IdGenerator @@ -142,7 +143,7 @@ class UTestInst2UtModelConverter( is UTestClassExpression -> UtClassRefModel( id = idGenerator.createId(), - classId = uTestInst.javaClass.id, + classId = classClassId, value = uTestInst.type.classId, ) From 6471f07d82586ec4a39b468e16f404faf7ecbd0d Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Fri, 3 Nov 2023 18:38:22 +0300 Subject: [PATCH 11/30] Another converter little improvement --- .../contest/usvm/JcToUtModelConverter.kt | 2 +- .../usvm/UTestInst2UtModelConverter.kt | 21 ++----------------- 2 files changed, 3 insertions(+), 20 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index 362afc065c..606b91b1a7 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -108,7 +108,7 @@ class JcToUtModelConverter( is UTestConstantDescriptor.Short -> UtPrimitiveModel(valueDescriptor.value) is UTestConstantDescriptor.String -> UtPrimitiveModel(valueDescriptor.value) - is UTestCyclicReferenceDescriptor -> TODO() + is UTestCyclicReferenceDescriptor -> TODO() // создать кэш по рефайди, проверить, что уже есть модель с таким же, или еррор is UTestEnumValueDescriptor -> TODO() is UTestExceptionDescriptor -> TODO() } diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt index 6ee76f5ce2..7c11fe07af 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt @@ -234,7 +234,6 @@ class UTestInst2UtModelConverter( exprToModelCache[uTestInst] = newModel } - // TODO: Is in correct to process [UTestMockObject] and [UTestGlobalMock] similarly? is UTestMockObject -> { val fields = mutableMapOf() val mocks = mutableMapOf>() @@ -305,28 +304,12 @@ class UTestInst2UtModelConverter( } is UTestSetStaticFieldStatement -> { - // TODO: seems we do not need this snippet as we store only expressions in cache - val fieldType = uTestInst.field.type.classId - val fieldName = uTestInst.field.name - - val setValueExpr = uTestInst.value - processInst(setValueExpr) - val setValueModel = exprToModelCache[setValueExpr] - ?: error("UtModel for $setValueExpr should have also been created") + processInst(uTestInst.value) - val methodCall = UtExecutableCallModel( - instance = null, - executable = utilMethodProvider.setStaticFieldMethodId, - params = listOf( - UtPrimitiveModel(fieldType.name), - UtPrimitiveModel(fieldName), - setValueModel, - ), - ) } is UTestGlobalMock -> { - // TODO: collect instrumentations here + // TODO usvm-sbft: collect instrumentations here } From c14067f53b32b4d6e00b8e64bf0250ccc9b6c7d6 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Fri, 3 Nov 2023 19:34:48 +0300 Subject: [PATCH 12/30] Improve `UtExecutionFailure` creation --- .../org/utbot/contest/usvm/ContestUsvm.kt | 9 +++- .../contest/usvm/JcToUtExecutionConverter.kt | 47 ++++++++---------- .../contest/usvm/UTestValueDescriptorUtils.kt | 48 +++++++++++++++++++ 3 files changed, 76 insertions(+), 28 deletions(-) create mode 100644 utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestValueDescriptorUtils.kt diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt index d2c45d805d..b83f7a042c 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt @@ -33,6 +33,7 @@ import org.utbot.framework.plugin.api.util.constructor import org.utbot.framework.plugin.api.util.jClass import org.utbot.framework.plugin.api.util.method import org.utbot.framework.plugin.services.JdkInfoService +import org.utbot.fuzzer.ReferencePreservingIntIdGenerator import org.utbot.fuzzer.UtFuzzedExecution import org.utbot.summary.summarizeAll import java.io.File @@ -85,6 +86,8 @@ fun runUsvmGeneration( val resolver by lazy { JcTestExecutor(jcDbContainer.cp) } + val idGenerator = ReferencePreservingIntIdGenerator() + val instructionIds = mutableMapOf, Long>() val instructionIdProvider = InstructionIdProvider { methodSignature, instrIndex -> instructionIds.getOrPut(methodSignature to instrIndex) { instructionIds.size.toLong() } @@ -214,7 +217,11 @@ fun runUsvmGeneration( val utExecutions: List = jcExecutions.mapNotNull { logger.debug().measureTime({ "Convert JcExecution" }) { - JcToUtExecutionConverter(instructionIdProvider).convert(it) + JcToUtExecutionConverter( + jcExecution = it, + idGenerator = idGenerator, + instructionIdProvider = instructionIdProvider + ).convert() } } diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt index b11c5bdee9..3386647357 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -4,7 +4,6 @@ import mu.KotlinLogging import org.jacodb.api.JcClassOrInterface import org.jacodb.api.JcTypedMethod import org.jacodb.api.cfg.JcInst -import org.jacodb.api.cfg.JcThrowInst import org.jacodb.api.ext.jcdbSignature import org.usvm.instrumentation.testcase.api.UTestExecutionExceptionResult import org.usvm.instrumentation.testcase.api.UTestExecutionFailedResult @@ -69,15 +68,13 @@ class JcToUtExecutionConverter( coverage = coverage, instrumentation = instrumentation, ) - - is UTestExecutionExceptionResult -> toUserRaisedException(executionResult.cause)?.let { exception -> + is UTestExecutionExceptionResult -> { UtUsvmExecution( stateBefore = convertState(executionResult.initialState, jcExecution.method, modelConverter), stateAfter = convertState(executionResult.resultState, jcExecution.method, modelConverter), result = createExecutionFailureResult( - exception, + executionResult.cause, jcExecution.method, - executionResult.trace ), coverage = coverage, instrumentation = instrumentation, @@ -85,17 +82,17 @@ class JcToUtExecutionConverter( } is UTestExecutionInitFailedResult -> { - toUserRaisedException(executionResult.cause)?.let { e -> - logger.warn(e) { "Execution failed before method under test call" } + logger.warn(convertException(executionResult.cause)) { + "Execution failed before method under test call" } null } is UTestExecutionFailedResult -> { - toUserRaisedException(executionResult.cause)?.let { e -> - // TODO usvm-sbft - null + logger.error(convertException(executionResult.cause)) { + "Concrete execution failed" } + null } is UTestExecutionTimedOutResult -> { @@ -107,15 +104,10 @@ class JcToUtExecutionConverter( return utUsvmExecution } - private fun toUserRaisedException(exceptionDescriptor: UTestExceptionDescriptor): Throwable? { - val exception = - toValueConverter.buildObjectFromDescriptor(exceptionDescriptor) as Throwable - return if (exceptionDescriptor.raisedByUserCode) exception - else { - logger.error(exception) { "Concrete execution failed" } - null - } - } + private fun convertException(exceptionDescriptor: UTestExceptionDescriptor): Throwable = + toValueConverter.buildObjectFromDescriptor(exceptionDescriptor.dropStaticFields( + cache = mutableMapOf() + )) as Throwable private fun getTrace(executionResult: UTestExecutionResult): List? = when (executionResult) { is UTestExecutionExceptionResult -> executionResult.trace @@ -144,18 +136,19 @@ class JcToUtExecutionConverter( } private fun createExecutionFailureResult( - exception: Throwable, + exceptionDescriptor: UTestExceptionDescriptor, jcTypedMethod: JcTypedMethod, - jcCoverage: List? ): UtExecutionFailure { - // TODO usvm-sbft: test that exceptions are correctly classified - val lastJcInst = jcCoverage.orEmpty().lastOrNull() - ?: return UtImplicitlyThrownException(exception, fromNestedMethod = false) - val fromNestedMethod = lastJcInst.enclosingMethod != jcTypedMethod.method - return if (lastJcInst is JcThrowInst) + val exception = convertException(exceptionDescriptor) + val fromNestedMethod = exception.stackTrace.firstOrNull()?.let { stackTraceElement -> + stackTraceElement.className != jcTypedMethod.enclosingType.jcClass.name || + stackTraceElement.methodName != jcTypedMethod.name + } ?: false + return if (exceptionDescriptor.raisedByUserCode) { UtExplicitlyThrownException(exception, fromNestedMethod) - else + } else { UtImplicitlyThrownException(exception, fromNestedMethod) + } } private fun convertCoverage(jcCoverage: List?, jcClass: JcClassOrInterface) = Coverage( diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestValueDescriptorUtils.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestValueDescriptorUtils.kt new file mode 100644 index 0000000000..ba7dc42ee7 --- /dev/null +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestValueDescriptorUtils.kt @@ -0,0 +1,48 @@ +package org.utbot.contest.usvm + +import org.usvm.instrumentation.testcase.descriptor.UTestArrayDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestClassDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestConstantDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestCyclicReferenceDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestEnumValueDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestExceptionDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestObjectDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor + +fun UTestValueDescriptor.dropStaticFields( + cache: MutableMap +): UTestValueDescriptor = cache.getOrPut(this) { + when (this) { + is UTestArrayDescriptor.Array -> UTestArrayDescriptor.Array( + elementType = elementType, + length = length, + value = value.map { it.dropStaticFields(cache) }, + refId = refId + ) + + is UTestArrayDescriptor<*> -> this + is UTestClassDescriptor -> this + is UTestConstantDescriptor -> this + is UTestCyclicReferenceDescriptor -> this + is UTestEnumValueDescriptor -> UTestEnumValueDescriptor( + type = type, + enumValueName = enumValueName, + fields = emptyMap(), + refId = refId + ) + + is UTestExceptionDescriptor -> UTestExceptionDescriptor( + type = type, + message = message, + stackTrace = stackTrace.map { it.dropStaticFields(cache) }, + raisedByUserCode = raisedByUserCode + ) + + is UTestObjectDescriptor -> UTestObjectDescriptor( + type = type, + fields = fields.entries.filter { !it.key.isStatic }.associate { it.key to it.value.dropStaticFields(cache) }, + originUTestExpr = originUTestExpr, + refId = refId + ) + } +} \ No newline at end of file From 20967a9519030983f4b7a0be9e265cfa278edbe2 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Sun, 5 Nov 2023 15:11:41 +0300 Subject: [PATCH 13/30] Finish implementing `JcToUtModelConverter` --- .../contest/usvm/JcToUtModelConverter.kt | 32 +++++++++++++++++-- 1 file changed, 29 insertions(+), 3 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index 606b91b1a7..5b890fb2cd 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -8,16 +8,21 @@ import org.usvm.instrumentation.testcase.descriptor.UTestCyclicReferenceDescript import org.usvm.instrumentation.testcase.descriptor.UTestEnumValueDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestExceptionDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestObjectDescriptor +import org.usvm.instrumentation.testcase.descriptor.UTestRefDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor import org.utbot.framework.plugin.api.FieldId import org.utbot.framework.plugin.api.UtArrayModel import org.utbot.framework.plugin.api.UtClassRefModel import org.utbot.framework.plugin.api.UtCompositeModel +import org.utbot.framework.plugin.api.UtEnumConstantModel import org.utbot.framework.plugin.api.UtModel import org.utbot.framework.plugin.api.UtNullModel import org.utbot.framework.plugin.api.UtPrimitiveModel import org.utbot.framework.plugin.api.util.classClassId +import org.utbot.framework.plugin.api.util.id +import org.utbot.framework.plugin.api.util.jClass import org.utbot.framework.plugin.api.util.objectClassId +import org.utbot.framework.plugin.api.util.stringClassId import org.utbot.fuzzer.IdGenerator class JcToUtModelConverter( @@ -25,6 +30,7 @@ class JcToUtModelConverter( private val instToModelCache: Map, ) { private val descriptorToModelCache = mutableMapOf() + private val refIdToDescriptorCache = mutableMapOf() fun convert(valueDescriptor: UTestValueDescriptor?): UtModel { valueDescriptor?.origin?.let { @@ -36,6 +42,9 @@ class JcToUtModelConverter( return UtNullModel(objectClassId) } + if (valueDescriptor is UTestRefDescriptor) + refIdToDescriptorCache[valueDescriptor.refId] = valueDescriptor + return when (valueDescriptor) { is UTestObjectDescriptor -> { val fields = mutableMapOf() @@ -108,9 +117,26 @@ class JcToUtModelConverter( is UTestConstantDescriptor.Short -> UtPrimitiveModel(valueDescriptor.value) is UTestConstantDescriptor.String -> UtPrimitiveModel(valueDescriptor.value) - is UTestCyclicReferenceDescriptor -> TODO() // создать кэш по рефайди, проверить, что уже есть модель с таким же, или еррор - is UTestEnumValueDescriptor -> TODO() - is UTestExceptionDescriptor -> TODO() + is UTestCyclicReferenceDescriptor -> descriptorToModelCache.getValue( + refIdToDescriptorCache.getValue(valueDescriptor.refId) + ) + is UTestEnumValueDescriptor -> UtEnumConstantModel( + id = idGenerator.createId(), + classId = valueDescriptor.type.classId, + value = valueDescriptor.type.classId.jClass.enumConstants.find { + (it as Enum<*>).name == valueDescriptor.enumValueName + } as Enum<*> + ) + is UTestExceptionDescriptor -> UtCompositeModel( + id = idGenerator.createId(), + classId = valueDescriptor.type.classId, + isMock = false, + fields = mutableMapOf( + FieldId(java.lang.Throwable::class.java.id, "detailMessage") to + // TODO usvm-sbft: ask why `UTestExceptionDescriptor.message` is not nullable + (valueDescriptor?.let { UtPrimitiveModel(it) } ?: UtNullModel(stringClassId)) + ) + ) } } From bf6d497e0dc09c9b4e257ad57031798695d3027c Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Sun, 5 Nov 2023 15:48:06 +0300 Subject: [PATCH 14/30] Refactor nullability in `JcToUtModelConverter` and `JcToUtExecutionConverter` --- .../contest/usvm/JcToUtExecutionConverter.kt | 8 ++++-- .../contest/usvm/JcToUtModelConverter.kt | 28 ++++++++----------- 2 files changed, 16 insertions(+), 20 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt index 3386647357..ae25cb0599 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -29,6 +29,7 @@ import org.utbot.framework.plugin.api.UtExecutionSuccess import org.utbot.framework.plugin.api.UtExplicitlyThrownException import org.utbot.framework.plugin.api.UtImplicitlyThrownException import org.utbot.framework.plugin.api.UtInstrumentation +import org.utbot.framework.plugin.api.UtVoidModel import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.framework.plugin.api.util.utContext import org.utbot.fuzzer.IdGenerator @@ -64,7 +65,8 @@ class JcToUtExecutionConverter( is UTestExecutionSuccessResult -> UtUsvmExecution( stateBefore = convertState(executionResult.initialState, jcExecution.method, modelConverter), stateAfter = convertState(executionResult.resultState, jcExecution.method, modelConverter), - result = UtExecutionSuccess(modelConverter.convert(executionResult.result)), + // TODO usvm-sbft: ask why `UTestExecutionSuccessResult.result` is nullable + result = UtExecutionSuccess(executionResult.result?.let { modelConverter.convert(it) } ?: UtVoidModel), coverage = coverage, instrumentation = instrumentation, ) @@ -124,8 +126,8 @@ class JcToUtExecutionConverter( ): EnvironmentModels { val thisInstance = if (method.isStatic) null - else modelConverter.convert(state.instanceDescriptor) - val parameters = state.argsDescriptors.map { modelConverter.convert(it) } + else modelConverter.convert(state.instanceDescriptor ?: error("Unexpected null instanceDescriptor")) + val parameters = state.argsDescriptors.map { modelConverter.convert(it ?: error("Unexpected null argDescriptor")) } val statics = state.statics .entries .associate { (jcField, uTestDescr) -> diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index 5b890fb2cd..2512373198 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -21,7 +21,6 @@ import org.utbot.framework.plugin.api.UtPrimitiveModel import org.utbot.framework.plugin.api.util.classClassId import org.utbot.framework.plugin.api.util.id import org.utbot.framework.plugin.api.util.jClass -import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.framework.plugin.api.util.stringClassId import org.utbot.fuzzer.IdGenerator @@ -32,16 +31,11 @@ class JcToUtModelConverter( private val descriptorToModelCache = mutableMapOf() private val refIdToDescriptorCache = mutableMapOf() - fun convert(valueDescriptor: UTestValueDescriptor?): UtModel { - valueDescriptor?.origin?.let { + fun convert(valueDescriptor: UTestValueDescriptor): UtModel = descriptorToModelCache.getOrPut(valueDescriptor) { + valueDescriptor.origin?.let { return instToModelCache.getValue(it as UTestExpression) } - // TODO usvm-sbft: ask why `UTestExecutionSuccessResult.result` is nullable - if (valueDescriptor == null) { - return UtNullModel(objectClassId) - } - if (valueDescriptor is UTestRefDescriptor) refIdToDescriptorCache[valueDescriptor.refId] = valueDescriptor @@ -90,14 +84,14 @@ class JcToUtModelConverter( model } - is UTestArrayDescriptor.BooleanArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) - is UTestArrayDescriptor.ByteArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) - is UTestArrayDescriptor.CharArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) - is UTestArrayDescriptor.DoubleArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) - is UTestArrayDescriptor.FloatArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) - is UTestArrayDescriptor.IntArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) - is UTestArrayDescriptor.LongArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) - is UTestArrayDescriptor.ShortArray -> constructArrayModel(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.BooleanArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.ByteArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.CharArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.DoubleArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.FloatArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.IntArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.LongArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) + is UTestArrayDescriptor.ShortArray -> constructPrimitiveArray(valueDescriptor, valueDescriptor.value.toList()) is UTestClassDescriptor -> UtClassRefModel( id = idGenerator.createId(), @@ -140,7 +134,7 @@ class JcToUtModelConverter( } } - private fun constructArrayModel(valueDescriptor: UTestArrayDescriptor<*>, arrayContent: List): UtArrayModel { + private fun constructPrimitiveArray(valueDescriptor: UTestArrayDescriptor<*>, arrayContent: List): UtArrayModel { val stores = mutableMapOf() val model = UtArrayModel( From 1a893ad5a99e33ab8c458f7cd87268153336ab17 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Sun, 5 Nov 2023 16:34:50 +0300 Subject: [PATCH 15/30] First version of JC to UT converters without overusing `Descriptor2ValueConverter` --- .../org/utbot/contest/usvm/ContestUsvm.kt | 3 +- .../org/utbot/contest/usvm/ConverterUtils.kt | 2 +- .../contest/usvm/JcToUtExecutionConverter.kt | 9 +- .../usvm/UTestInst2UtModelConverter.kt | 237 ++++++++---------- 4 files changed, 109 insertions(+), 142 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt index b83f7a042c..5cdf7d149f 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt @@ -220,7 +220,8 @@ fun runUsvmGeneration( JcToUtExecutionConverter( jcExecution = it, idGenerator = idGenerator, - instructionIdProvider = instructionIdProvider + instructionIdProvider = instructionIdProvider, + utilMethodProvider = codeGenerator.context.utilMethodProvider ).convert() } } diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt index d6ec26ee52..407c33495f 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt @@ -45,4 +45,4 @@ val JcField.fieldId: FieldId get() = toJavaField(utContext.classLoader)!!.fieldId val UTestValueDescriptor.origin: UTestInst? - get() = (this as UTestObjectDescriptor)?.originUTestExpr \ No newline at end of file + get() = (this as? UTestObjectDescriptor)?.originUTestExpr \ No newline at end of file diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt index ae25cb0599..3c0cad1ef2 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -17,8 +17,7 @@ import org.usvm.instrumentation.testcase.descriptor.UTestExceptionDescriptor import org.usvm.instrumentation.util.enclosingClass import org.usvm.instrumentation.util.enclosingMethod import org.utbot.contest.usvm.executor.JcExecution -import org.utbot.framework.codegen.domain.builtin.TestClassUtilMethodProvider -import org.utbot.framework.plugin.api.ClassId +import org.utbot.framework.codegen.domain.builtin.UtilMethodProvider import org.utbot.framework.plugin.api.Coverage import org.utbot.framework.plugin.api.EnvironmentModels import org.utbot.framework.plugin.api.ExecutableId @@ -30,7 +29,6 @@ import org.utbot.framework.plugin.api.UtExplicitlyThrownException import org.utbot.framework.plugin.api.UtImplicitlyThrownException import org.utbot.framework.plugin.api.UtInstrumentation import org.utbot.framework.plugin.api.UtVoidModel -import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.framework.plugin.api.util.utContext import org.utbot.fuzzer.IdGenerator @@ -40,16 +38,13 @@ class JcToUtExecutionConverter( private val jcExecution: JcExecution, private val idGenerator: IdGenerator, private val instructionIdProvider: InstructionIdProvider, + utilMethodProvider: UtilMethodProvider, ) { - //TODO usvm-sbft: obtain in somehow from [JcExecution] or somewhere else - private val testClassId: ClassId = objectClassId - private val toValueConverter = Descriptor2ValueConverter(utContext.classLoader) private var modelConverter: JcToUtModelConverter init { - val utilMethodProvider = TestClassUtilMethodProvider(testClassId) val instToModelConverter = UTestInst2UtModelConverter(idGenerator, utilMethodProvider) val uTestProcessResult = instToModelConverter.processUTest(jcExecution.uTest) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt index 7c11fe07af..0d4d2f433c 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt @@ -42,14 +42,11 @@ import org.utbot.framework.plugin.api.UtCompositeModel import org.utbot.framework.plugin.api.UtExecutableCallModel import org.utbot.framework.plugin.api.UtInstrumentation import org.utbot.framework.plugin.api.UtModel -import org.utbot.framework.plugin.api.UtNewInstanceInstrumentation import org.utbot.framework.plugin.api.UtNullModel import org.utbot.framework.plugin.api.UtPrimitiveModel import org.utbot.framework.plugin.api.util.classClassId -import org.utbot.framework.plugin.api.util.id import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.fuzzer.IdGenerator -import org.utbot.fuzzer.ReferencePreservingIntIdGenerator data class UTestInstOutput( val exprToModelCache: Map, @@ -73,165 +70,176 @@ class UTestInst2UtModelConverter( } private fun processInst(uTestInst: UTestInst) { - exprToModelCache[uTestInst]?.let { return } - when (uTestInst) { + is UTestExpression -> processExpr(uTestInst) + + is UTestArraySetStatement -> { + val arrayModel = processExpr(uTestInst.arrayInstance) + require(arrayModel is UtArrayModel) + + require(uTestInst.index is UTestIntExpression) + val storeIndex = uTestInst.index as UTestIntExpression + + val elementModel = processExpr(uTestInst.setValueExpression) + + arrayModel.stores[storeIndex.value] = elementModel + } + + is UTestSetFieldStatement -> { + val instanceExpr = uTestInst.instance + + val instanceModel = processExpr(instanceExpr) + require(instanceModel is UtAssembleModel) + + val fieldType = uTestInst.field.type.classId + val fieldName = uTestInst.field.name + val setValueModel = processExpr(uTestInst.value) + + val methodCall = UtExecutableCallModel( + instance = null, + executable = utilMethodProvider.setFieldMethodId, + params = listOf( + instanceModel, + UtPrimitiveModel(fieldType.name), + UtPrimitiveModel(fieldName), + setValueModel, + ), + ) + + instanceModel?.let { + (it.modificationsChain as MutableList).add(methodCall) + } + } + + is UTestSetStaticFieldStatement -> processExpr(uTestInst.value) + + is UTestBinaryConditionStatement -> error("This expression type is not supported") + } + } + + private fun processExpr(uTestExpr: UTestExpression): UtModel = exprToModelCache.getOrPut(uTestExpr) { + when (uTestExpr) { is UTestAllocateMemoryCall -> { - val newModel = UtAssembleModel( + UtAssembleModel( id = idGenerator.createId(), - classId = uTestInst.clazz.classId, + classId = uTestExpr.clazz.classId, modelName = "", instantiationCall = UtExecutableCallModel( instance = null, executable = utilMethodProvider.createInstanceMethodId, - params = listOf(UtPrimitiveModel(uTestInst.clazz.classId.name)), + params = listOf(UtPrimitiveModel(uTestExpr.clazz.classId.name)), ), ) - exprToModelCache[uTestInst] = newModel } is UTestConstructorCall -> { val constructorCall = UtExecutableCallModel( instance = null, - executable = uTestInst.method.toExecutableId(), - params = uTestInst.args.map { arg -> - processInst(arg) - exprToModelCache[arg] ?: error("UtModel for $arg should have also been created") + executable = uTestExpr.method.toExecutableId(), + params = uTestExpr.args.map { arg -> + processExpr(arg) }, ) val newModel = UtAssembleModel( id = idGenerator.createId(), - classId = uTestInst.type.classId, + classId = uTestExpr.type.classId, modelName = "", instantiationCall = constructorCall, ) - exprToModelCache[uTestInst] = newModel + newModel } is UTestMethodCall -> { - val instanceExpr = uTestInst.instance - instanceExpr?.let { processInst(it) } - - val instanceModel = exprToModelCache[instanceExpr] - ?: error("UtModel for $instanceExpr should have also been created") + val instanceModel = processExpr(uTestExpr.instance) require(instanceModel is UtAssembleModel) val methodCall = UtExecutableCallModel( instance = instanceModel, - executable = uTestInst.method.toExecutableId(), - params = uTestInst.args.map { arg -> - processInst(arg) - exprToModelCache[arg] ?: error("UtModel for $arg should have also been created") + executable = uTestExpr.method.toExecutableId(), + params = uTestExpr.args.map { arg -> + processExpr(arg) }, ) - instanceModel?.let { - (it.modificationsChain as MutableList).add(methodCall) - } + (instanceModel.modificationsChain as MutableList).add(methodCall) val newModel = UtAssembleModel( id = idGenerator.createId(), - classId = uTestInst.type.classId, + classId = uTestExpr.type.classId, modelName = "", instantiationCall = methodCall, ) - exprToModelCache[uTestInst] = newModel + newModel } is UTestClassExpression -> UtClassRefModel( - id = idGenerator.createId(), - classId = classClassId, - value = uTestInst.type.classId, - ) + id = idGenerator.createId(), + classId = classClassId, + value = uTestExpr.type.classId, + ) - is UTestBooleanExpression -> UtPrimitiveModel(uTestInst.value) - is UTestByteExpression -> UtPrimitiveModel(uTestInst.value) - is UTestCharExpression -> UtPrimitiveModel(uTestInst.value) - is UTestDoubleExpression -> UtPrimitiveModel(uTestInst.value) - is UTestFloatExpression -> UtPrimitiveModel(uTestInst.value) - is UTestIntExpression -> UtPrimitiveModel(uTestInst.value) - is UTestLongExpression -> UtPrimitiveModel(uTestInst.value) - is UTestShortExpression -> UtPrimitiveModel(uTestInst.value) - is UTestStringExpression -> UtPrimitiveModel(uTestInst.value) + is UTestBooleanExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestByteExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestCharExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestDoubleExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestFloatExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestIntExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestLongExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestShortExpression -> UtPrimitiveModel(uTestExpr.value) + is UTestStringExpression -> UtPrimitiveModel(uTestExpr.value) - is UTestNullExpression -> UtNullModel(uTestInst.type.classId) + is UTestNullExpression -> UtNullModel(uTestExpr.type.classId) is UTestCreateArrayExpression -> { - require(uTestInst.size is UTestIntExpression) - val arrayLength = uTestInst.size as UTestIntExpression + require(uTestExpr.size is UTestIntExpression) + val arrayLength = uTestExpr.size as UTestIntExpression - val newModel = UtArrayModel( + UtArrayModel( id = idGenerator.createId(), - classId = uTestInst.type.classId, + classId = uTestExpr.type.classId, length = arrayLength.value, constModel = UtNullModel(objectClassId), stores = mutableMapOf(), ) - - exprToModelCache[uTestInst] = newModel - } - - is UTestArraySetStatement -> { - val arrayModel = exprToModelCache[uTestInst.arrayInstance] - requireNotNull(arrayModel) - require(arrayModel is UtArrayModel) - - require(uTestInst.index is UTestIntExpression) - val storeIndex = uTestInst.index as UTestIntExpression - - val setValueExpression = uTestInst.setValueExpression - processInst(setValueExpression) - val elementModel = exprToModelCache[setValueExpression] - ?: error("UtModel for $setValueExpression should have also been created") - - arrayModel.stores[storeIndex.value] = elementModel } is UTestGetFieldExpression -> { - val instanceExpr = uTestInst.instance - instanceExpr?.let { processInst(it) } - - val instanceModel = exprToModelCache[instanceExpr] - ?: error("UtModel for $instanceExpr should have also been created") + val instanceModel = processExpr(uTestExpr.instance) - val newModel = UtAssembleModel( + UtAssembleModel( id = idGenerator.createId(), - classId = uTestInst.type.classId, + classId = uTestExpr.type.classId, modelName = "", instantiationCall = UtExecutableCallModel( instance = null, executable = utilMethodProvider.getFieldValueMethodId, params = listOf( instanceModel, - UtPrimitiveModel(uTestInst.field.type.classId.name), - UtPrimitiveModel(uTestInst.field.name), - ), + UtPrimitiveModel(uTestExpr.field.type.classId.name), + UtPrimitiveModel(uTestExpr.field.name), + ), ), ) - - exprToModelCache[uTestInst] = newModel } is UTestGetStaticFieldExpression -> { - val newModel = UtAssembleModel( + UtAssembleModel( id = idGenerator.createId(), - classId = uTestInst.type.classId, + classId = uTestExpr.type.classId, modelName = "", instantiationCall = UtExecutableCallModel( instance = null, executable = utilMethodProvider.getStaticFieldValueMethodId, params = listOf( - UtPrimitiveModel(uTestInst.field.type.classId.name), - UtPrimitiveModel(uTestInst.field.name), + UtPrimitiveModel(uTestExpr.field.type.classId.name), + UtPrimitiveModel(uTestExpr.field.name), ), ), ) - - exprToModelCache[uTestInst] = newModel } is UTestMockObject -> { @@ -240,82 +248,45 @@ class UTestInst2UtModelConverter( val newModel = UtCompositeModel( id = idGenerator.createId(), - classId = uTestInst.type.classId, + classId = uTestExpr.type.classId, isMock = true, fields = fields, mocks = mocks, ) - exprToModelCache[uTestInst] = newModel + exprToModelCache[uTestExpr] = newModel - fields += uTestInst.fields + fields += uTestExpr.fields .entries .associate { (jcField, uTestExpr) -> - val fieldId = FieldId(jcField.type.classId, jcField.name) - - processInst(uTestExpr) - val fieldModel = exprToModelCache[uTestExpr] - ?: error("UtModel for $uTestExpr should have also been created") - fieldId to fieldModel + jcField.fieldId to processExpr(uTestExpr) } - mocks += uTestInst.methods + mocks += uTestExpr.methods .entries .associate { (jcMethod, uTestExprs) -> val executableId: ExecutableId = jcMethod.toExecutableId() val models = uTestExprs.map { expr -> - processInst(expr) - exprToModelCache[expr] ?: error("UtModel for $expr should have also been created") + processExpr(expr) } executableId to models } - } - - is UTestSetFieldStatement -> { - val instanceExpr = uTestInst.instance - - instanceExpr?.let { processInst(it) } - val instanceModel = exprToModelCache[instanceExpr] - ?: error("UtModel for $instanceExpr should have also been created") - require(instanceModel is UtAssembleModel) - - val fieldType = uTestInst.field.type.classId - val fieldName = uTestInst.field.name - - val setValueExpr = uTestInst.value - processInst(setValueExpr) - val setValueModel = exprToModelCache[setValueExpr] - ?: error("UtModel for $setValueExpr should have also been created") - - val methodCall = UtExecutableCallModel( - instance = instanceModel, - executable = utilMethodProvider.setFieldMethodId, - params = listOf( - instanceModel, - UtPrimitiveModel(fieldType.name), - UtPrimitiveModel(fieldName), - setValueModel, - ), - ) - - instanceModel?.let { - (it.modificationsChain as MutableList).add(methodCall) - } - } - - is UTestSetStaticFieldStatement -> { - processInst(uTestInst.value) + newModel } is UTestGlobalMock -> { // TODO usvm-sbft: collect instrumentations here + UtClassRefModel( + id = idGenerator.createId(), + classId = classClassId, + value = uTestExpr.type.classId + ) } - is UTestArithmeticExpression -> error("This expression type is not supported") is UTestBinaryConditionExpression -> error("This expression type is not supported") - is UTestBinaryConditionStatement -> error("This expression type is not supported") + is UTestStaticMethodCall -> error("This expression type is not supported") is UTestCastExpression -> error("This expression type is not supported") From 1717235beb43d522a6d0165df37fdd9351048df6 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 7 Nov 2023 18:44:21 +0300 Subject: [PATCH 16/30] Processed forgotten call method expression --- .../kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt | 1 + 1 file changed, 1 insertion(+) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt index 0d4d2f433c..4b73ab0600 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt @@ -65,6 +65,7 @@ class UTestInst2UtModelConverter( instrumentations.clear() uTest.initStatements.forEach { uInst -> processInst(uInst) } + processInst(uTest.callMethodExpression) return UTestInstOutput(exprToModelCache, instrumentations) } From f2debe4f8751a0da435ca81594dc8a6703181eac Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 7 Nov 2023 20:24:33 +0300 Subject: [PATCH 17/30] Make conversion more class-friendly (do not fail if one method cause failure) --- .../org/utbot/contest/usvm/ContestUsvm.kt | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt index 5cdf7d149f..84510d2c91 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt @@ -38,6 +38,7 @@ import org.utbot.fuzzer.UtFuzzedExecution import org.utbot.summary.summarizeAll import java.io.File import java.net.URLClassLoader +import java.util.* import kotlin.math.max private val logger = KotlinLogging.logger {} @@ -217,12 +218,18 @@ fun runUsvmGeneration( val utExecutions: List = jcExecutions.mapNotNull { logger.debug().measureTime({ "Convert JcExecution" }) { - JcToUtExecutionConverter( - jcExecution = it, - idGenerator = idGenerator, - instructionIdProvider = instructionIdProvider, - utilMethodProvider = codeGenerator.context.utilMethodProvider - ).convert() + try { + JcToUtExecutionConverter( + jcExecution = it, + idGenerator = idGenerator, + instructionIdProvider = instructionIdProvider, + utilMethodProvider = codeGenerator.context.utilMethodProvider + ).convert() + } catch (e: Exception) { + val stackTrace = Arrays.toString(e.stackTrace); + logger.error { "Can't convert execution for method ${method.name}, exception is ${e.message}. \n $stackTrace" } + null + } } } From c191ed3f743f838565b52827e54f15e3f0004012 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 7 Nov 2023 20:25:42 +0300 Subject: [PATCH 18/30] Make it possible to use samples in ContestEstimator --- .../src/main/resources/classes/samples/list | 1 + .../samples/utbot-sample-2023.11-SNAPSHOT.jar | Bin 0 -> 323735 bytes 2 files changed, 1 insertion(+) create mode 100644 utbot-junit-contest/src/main/resources/classes/samples/list create mode 100644 utbot-junit-contest/src/main/resources/projects/samples/utbot-sample-2023.11-SNAPSHOT.jar diff --git a/utbot-junit-contest/src/main/resources/classes/samples/list b/utbot-junit-contest/src/main/resources/classes/samples/list new file mode 100644 index 0000000000..02f3aa7af3 --- /dev/null +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -0,0 +1 @@ +org.utbot.examples.primitives.IntExamples \ No newline at end of file diff --git a/utbot-junit-contest/src/main/resources/projects/samples/utbot-sample-2023.11-SNAPSHOT.jar b/utbot-junit-contest/src/main/resources/projects/samples/utbot-sample-2023.11-SNAPSHOT.jar new file mode 100644 index 0000000000000000000000000000000000000000..ab0e73badfaaa4de36d25688844a0642556b6ea3 GIT binary patch literal 323735 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%0Asbe^^1DNTblU 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 literal 0 HcmV?d00001 From e61cef469804bce0a4e16b9e0fe7ef5c78b10495 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 7 Nov 2023 20:37:17 +0300 Subject: [PATCH 19/30] Tested on all primitives --- .../src/main/resources/classes/samples/list | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/utbot-junit-contest/src/main/resources/classes/samples/list b/utbot-junit-contest/src/main/resources/classes/samples/list index 02f3aa7af3..c910b90190 100644 --- a/utbot-junit-contest/src/main/resources/classes/samples/list +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -1 +1,6 @@ -org.utbot.examples.primitives.IntExamples \ No newline at end of file +org.utbot.examples.primitives.IntExamples +org.utbot.examples.primitives.ByteExamples +org.utbot.examples.primitives.CharExamples +org.utbot.examples.primitives.FloatExamples +org.utbot.examples.primitives.DoubleExamples + From bb82a6ba34832a8266d997daf3c717460cc7ac35 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 7 Nov 2023 22:29:34 +0300 Subject: [PATCH 20/30] contrflow tests added --- utbot-junit-contest/src/main/resources/classes/samples/list | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/utbot-junit-contest/src/main/resources/classes/samples/list b/utbot-junit-contest/src/main/resources/classes/samples/list index c910b90190..7582ac2090 100644 --- a/utbot-junit-contest/src/main/resources/classes/samples/list +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -3,4 +3,8 @@ org.utbot.examples.primitives.ByteExamples org.utbot.examples.primitives.CharExamples org.utbot.examples.primitives.FloatExamples org.utbot.examples.primitives.DoubleExamples +org.utbot.examples.controlflow.Conditions +org.utbot.examples.controlflow.CycleDependedCondition +org.utbot.examples.controlflow.Cycles +org.utbot.examples.controlflow.Switch From 13ee51e8573435b4d13c4c31ccaff212e65384d1 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Tue, 7 Nov 2023 23:14:49 +0300 Subject: [PATCH 21/30] More test classes added --- utbot-junit-contest/src/main/resources/classes/samples/list | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/utbot-junit-contest/src/main/resources/classes/samples/list b/utbot-junit-contest/src/main/resources/classes/samples/list index 7582ac2090..9b466d2e00 100644 --- a/utbot-junit-contest/src/main/resources/classes/samples/list +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -7,4 +7,9 @@ org.utbot.examples.controlflow.Conditions org.utbot.examples.controlflow.CycleDependedCondition org.utbot.examples.controlflow.Cycles org.utbot.examples.controlflow.Switch +org.utbot.examples.recursion.Recursion +org.utbot.examples.math.BitOperators +org.utbot.examples.math.DivRemExamples +org.utbot.examples.math.DoubleFunctions + From b01d6b3cc89a64af3cb777b4d8efbbab9b34825c Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Wed, 8 Nov 2023 12:38:59 +0300 Subject: [PATCH 22/30] Add `build/output/test/samples` to `utbot-junit-contest` test projects --- utbot-junit-contest/build.gradle | 1 + 1 file changed, 1 insertion(+) diff --git a/utbot-junit-contest/build.gradle b/utbot-junit-contest/build.gradle index 5d2b939a6e..27bd4c8c1d 100644 --- a/utbot-junit-contest/build.gradle +++ b/utbot-junit-contest/build.gradle @@ -29,6 +29,7 @@ def testProjects = [ 'build/output/test/seata-core-0.5.0', 'build/output/test/spoon', 'build/output/test/spoon-core-7.0.0', + 'build/output/test/samples', ] sourceSets { From 61c1608195136085e6379bc59299f4458058adda Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Wed, 8 Nov 2023 13:24:22 +0300 Subject: [PATCH 23/30] Steps to avoid duplicating statements --- .../org/utbot/contest/usvm/ContestUsvm.kt | 2 +- .../contest/usvm/JcToUtExecutionConverter.kt | 2 +- .../contest/usvm/JcToUtModelConverter.kt | 21 ++++- .../usvm/UTestInst2UtModelConverter.kt | 80 ++++++++++++------- 4 files changed, 73 insertions(+), 32 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt index 84510d2c91..655a1cb1b9 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt @@ -227,7 +227,7 @@ fun runUsvmGeneration( ).convert() } catch (e: Exception) { val stackTrace = Arrays.toString(e.stackTrace); - logger.error { "Can't convert execution for method ${method.name}, exception is ${e.message}. \n $stackTrace" } + logger.error(e) { "Can't convert execution for method ${method.name}, exception is ${e.message}. \n $stackTrace" } null } } diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt index 3c0cad1ef2..fa70a4254b 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -48,7 +48,7 @@ class JcToUtExecutionConverter( val instToModelConverter = UTestInst2UtModelConverter(idGenerator, utilMethodProvider) val uTestProcessResult = instToModelConverter.processUTest(jcExecution.uTest) - modelConverter = JcToUtModelConverter(idGenerator, uTestProcessResult.exprToModelCache) + modelConverter = JcToUtModelConverter(idGenerator, uTestProcessResult) } fun convert(): UtExecution? { diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index 2512373198..8091fbe4f3 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -12,9 +12,11 @@ import org.usvm.instrumentation.testcase.descriptor.UTestRefDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor import org.utbot.framework.plugin.api.FieldId import org.utbot.framework.plugin.api.UtArrayModel +import org.utbot.framework.plugin.api.UtAssembleModel import org.utbot.framework.plugin.api.UtClassRefModel import org.utbot.framework.plugin.api.UtCompositeModel import org.utbot.framework.plugin.api.UtEnumConstantModel +import org.utbot.framework.plugin.api.UtExecutableCallModel import org.utbot.framework.plugin.api.UtModel import org.utbot.framework.plugin.api.UtNullModel import org.utbot.framework.plugin.api.UtPrimitiveModel @@ -26,14 +28,29 @@ import org.utbot.fuzzer.IdGenerator class JcToUtModelConverter( private val idGenerator: IdGenerator, - private val instToModelCache: Map, + uTestProcessResult: UTestProcessResult, ) { private val descriptorToModelCache = mutableMapOf() private val refIdToDescriptorCache = mutableMapOf() + private val exprToModelCache = uTestProcessResult.exprToModelCache + private val instantiationCallToAssembleModelCache = uTestProcessResult.instantiationCallToAssembleModelCache + fun convert(valueDescriptor: UTestValueDescriptor): UtModel = descriptorToModelCache.getOrPut(valueDescriptor) { valueDescriptor.origin?.let { - return instToModelCache.getValue(it as UTestExpression) + val alreadyCreatedModel = exprToModelCache.getValue(it as UTestExpression) + + if (alreadyCreatedModel is UtAssembleModel ) { + val instantiationCall = alreadyCreatedModel.instantiationCall + if (instantiationCall is UtExecutableCallModel) { + val instantiatedWithCallModel = instantiationCallToAssembleModelCache.getValue(instantiationCall) + val modificationsChain = (instantiatedWithCallModel.modificationsChain as MutableList) + + modificationsChain.remove(alreadyCreatedModel.instantiationCall) + } + } + + return alreadyCreatedModel } if (valueDescriptor is UTestRefDescriptor) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt index 4b73ab0600..d5d75ca953 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt @@ -48,8 +48,9 @@ import org.utbot.framework.plugin.api.util.classClassId import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.fuzzer.IdGenerator -data class UTestInstOutput( +data class UTestProcessResult( val exprToModelCache: Map, + val instantiationCallToAssembleModelCache: Map, val instrumentations: List, ) @@ -58,16 +59,17 @@ class UTestInst2UtModelConverter( private val utilMethodProvider: UtilMethodProvider, ) { private val exprToModelCache = mutableMapOf() + private val instantiationCallToAssembleModelCache = mutableMapOf() private val instrumentations = mutableListOf() - fun processUTest(uTest: UTest): UTestInstOutput { + fun processUTest(uTest: UTest): UTestProcessResult { exprToModelCache.clear() instrumentations.clear() uTest.initStatements.forEach { uInst -> processInst(uInst) } processInst(uTest.callMethodExpression) - return UTestInstOutput(exprToModelCache, instrumentations) + return UTestProcessResult(exprToModelCache, instantiationCallToAssembleModelCache, instrumentations) } private fun processInst(uTestInst: UTestInst) { @@ -121,16 +123,22 @@ class UTestInst2UtModelConverter( private fun processExpr(uTestExpr: UTestExpression): UtModel = exprToModelCache.getOrPut(uTestExpr) { when (uTestExpr) { is UTestAllocateMemoryCall -> { - UtAssembleModel( + val createInstanceCall = UtExecutableCallModel( + instance = null, + executable = utilMethodProvider.createInstanceMethodId, + params = listOf(UtPrimitiveModel(uTestExpr.clazz.classId.name)), + ) + + val newModel = UtAssembleModel( id = idGenerator.createId(), classId = uTestExpr.clazz.classId, modelName = "", - instantiationCall = UtExecutableCallModel( - instance = null, - executable = utilMethodProvider.createInstanceMethodId, - params = listOf(UtPrimitiveModel(uTestExpr.clazz.classId.name)), - ), + instantiationCall = createInstanceCall, ) + + instantiationCallToAssembleModelCache[createInstanceCall] = newModel + + newModel } is UTestConstructorCall -> { @@ -149,6 +157,8 @@ class UTestInst2UtModelConverter( instantiationCall = constructorCall, ) + instantiationCallToAssembleModelCache[constructorCall] = newModel + newModel } @@ -173,6 +183,8 @@ class UTestInst2UtModelConverter( instantiationCall = methodCall, ) + instantiationCallToAssembleModelCache[methodCall] = newModel + newModel } @@ -211,36 +223,48 @@ class UTestInst2UtModelConverter( is UTestGetFieldExpression -> { val instanceModel = processExpr(uTestExpr.instance) - UtAssembleModel( + val getFieldCall = UtExecutableCallModel( + instance = null, + executable = utilMethodProvider.getFieldValueMethodId, + params = listOf( + instanceModel, + UtPrimitiveModel(uTestExpr.field.type.classId.name), + UtPrimitiveModel(uTestExpr.field.name), + ), + ) + + val newModel = UtAssembleModel( id = idGenerator.createId(), classId = uTestExpr.type.classId, modelName = "", - instantiationCall = UtExecutableCallModel( - instance = null, - executable = utilMethodProvider.getFieldValueMethodId, - params = listOf( - instanceModel, - UtPrimitiveModel(uTestExpr.field.type.classId.name), - UtPrimitiveModel(uTestExpr.field.name), - ), - ), + instantiationCall = getFieldCall, ) + + instantiationCallToAssembleModelCache[getFieldCall] = newModel + + newModel } is UTestGetStaticFieldExpression -> { - UtAssembleModel( + val getStaticFieldCall = UtExecutableCallModel( + instance = null, + executable = utilMethodProvider.getStaticFieldValueMethodId, + params = listOf( + UtPrimitiveModel(uTestExpr.field.type.classId.name), + UtPrimitiveModel(uTestExpr.field.name), + ), + ) + + val newModel = UtAssembleModel( id = idGenerator.createId(), classId = uTestExpr.type.classId, modelName = "", - instantiationCall = UtExecutableCallModel( - instance = null, - executable = utilMethodProvider.getStaticFieldValueMethodId, - params = listOf( - UtPrimitiveModel(uTestExpr.field.type.classId.name), - UtPrimitiveModel(uTestExpr.field.name), - ), - ), + instantiationCall = getStaticFieldCall, ) + + instantiationCallToAssembleModelCache[getStaticFieldCall] = newModel + + newModel } is UTestMockObject -> { From a31d6b1ce6c0dbb3a9a59854fc08dfb4df8cd010 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Wed, 8 Nov 2023 15:34:12 +0300 Subject: [PATCH 24/30] Make it working correct on IntExamples.max --- .../contest/usvm/JcToUtExecutionConverter.kt | 16 ++++---- .../contest/usvm/JcToUtModelConverter.kt | 23 ++--------- .../usvm/UTestInst2UtModelConverter.kt | 39 +++++++++---------- 3 files changed, 30 insertions(+), 48 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt index fa70a4254b..fad1b741ca 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -42,13 +42,13 @@ class JcToUtExecutionConverter( ) { private val toValueConverter = Descriptor2ValueConverter(utContext.classLoader) - private var modelConverter: JcToUtModelConverter + private var jcToUtModelConverter: JcToUtModelConverter init { val instToModelConverter = UTestInst2UtModelConverter(idGenerator, utilMethodProvider) - val uTestProcessResult = instToModelConverter.processUTest(jcExecution.uTest) - modelConverter = JcToUtModelConverter(idGenerator, uTestProcessResult) + instToModelConverter.processUTest(jcExecution.uTest) + jcToUtModelConverter = JcToUtModelConverter(idGenerator, instToModelConverter) } fun convert(): UtExecution? { @@ -58,17 +58,17 @@ class JcToUtExecutionConverter( val utUsvmExecution: UtUsvmExecution = when (val executionResult = jcExecution.uTestExecutionResult) { is UTestExecutionSuccessResult -> UtUsvmExecution( - stateBefore = convertState(executionResult.initialState, jcExecution.method, modelConverter), - stateAfter = convertState(executionResult.resultState, jcExecution.method, modelConverter), + stateBefore = convertState(executionResult.initialState, jcExecution.method, jcToUtModelConverter), + stateAfter = convertState(executionResult.resultState, jcExecution.method, jcToUtModelConverter), // TODO usvm-sbft: ask why `UTestExecutionSuccessResult.result` is nullable - result = UtExecutionSuccess(executionResult.result?.let { modelConverter.convert(it) } ?: UtVoidModel), + result = UtExecutionSuccess(executionResult.result?.let { jcToUtModelConverter.convert(it) } ?: UtVoidModel), coverage = coverage, instrumentation = instrumentation, ) is UTestExecutionExceptionResult -> { UtUsvmExecution( - stateBefore = convertState(executionResult.initialState, jcExecution.method, modelConverter), - stateAfter = convertState(executionResult.resultState, jcExecution.method, modelConverter), + stateBefore = convertState(executionResult.initialState, jcExecution.method, jcToUtModelConverter), + stateAfter = convertState(executionResult.resultState, jcExecution.method, jcToUtModelConverter), result = createExecutionFailureResult( executionResult.cause, jcExecution.method, diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index 8091fbe4f3..7f88ed8dc0 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -12,11 +12,9 @@ import org.usvm.instrumentation.testcase.descriptor.UTestRefDescriptor import org.usvm.instrumentation.testcase.descriptor.UTestValueDescriptor import org.utbot.framework.plugin.api.FieldId import org.utbot.framework.plugin.api.UtArrayModel -import org.utbot.framework.plugin.api.UtAssembleModel import org.utbot.framework.plugin.api.UtClassRefModel import org.utbot.framework.plugin.api.UtCompositeModel import org.utbot.framework.plugin.api.UtEnumConstantModel -import org.utbot.framework.plugin.api.UtExecutableCallModel import org.utbot.framework.plugin.api.UtModel import org.utbot.framework.plugin.api.UtNullModel import org.utbot.framework.plugin.api.UtPrimitiveModel @@ -28,29 +26,14 @@ import org.utbot.fuzzer.IdGenerator class JcToUtModelConverter( private val idGenerator: IdGenerator, - uTestProcessResult: UTestProcessResult, + private val instToUtModelConverter: UTestInst2UtModelConverter, ) { private val descriptorToModelCache = mutableMapOf() private val refIdToDescriptorCache = mutableMapOf() - private val exprToModelCache = uTestProcessResult.exprToModelCache - private val instantiationCallToAssembleModelCache = uTestProcessResult.instantiationCallToAssembleModelCache - fun convert(valueDescriptor: UTestValueDescriptor): UtModel = descriptorToModelCache.getOrPut(valueDescriptor) { - valueDescriptor.origin?.let { - val alreadyCreatedModel = exprToModelCache.getValue(it as UTestExpression) - - if (alreadyCreatedModel is UtAssembleModel ) { - val instantiationCall = alreadyCreatedModel.instantiationCall - if (instantiationCall is UtExecutableCallModel) { - val instantiatedWithCallModel = instantiationCallToAssembleModelCache.getValue(instantiationCall) - val modificationsChain = (instantiatedWithCallModel.modificationsChain as MutableList) - - modificationsChain.remove(alreadyCreatedModel.instantiationCall) - } - } - - return alreadyCreatedModel + valueDescriptor.origin?.let { originExpr -> + return instToUtModelConverter.findModelByInst(originExpr as UTestExpression) } if (valueDescriptor is UTestRefDescriptor) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt index d5d75ca953..9ce2eaaddd 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt @@ -48,28 +48,37 @@ import org.utbot.framework.plugin.api.util.classClassId import org.utbot.framework.plugin.api.util.objectClassId import org.utbot.fuzzer.IdGenerator -data class UTestProcessResult( - val exprToModelCache: Map, - val instantiationCallToAssembleModelCache: Map, - val instrumentations: List, - ) - class UTestInst2UtModelConverter( private val idGenerator: IdGenerator, private val utilMethodProvider: UtilMethodProvider, ) { private val exprToModelCache = mutableMapOf() - private val instantiationCallToAssembleModelCache = mutableMapOf() private val instrumentations = mutableListOf() - fun processUTest(uTest: UTest): UTestProcessResult { + fun processUTest(uTest: UTest) { exprToModelCache.clear() instrumentations.clear() uTest.initStatements.forEach { uInst -> processInst(uInst) } - processInst(uTest.callMethodExpression) + removeInstantiationCallFromThisInstanceModificationChain(processExpr(uTest.callMethodExpression)) + } - return UTestProcessResult(exprToModelCache, instantiationCallToAssembleModelCache, instrumentations) + fun findModelByInst(expr: UTestExpression): UtModel { + val alreadyCreatedModel = exprToModelCache.getValue(expr) + removeInstantiationCallFromThisInstanceModificationChain(alreadyCreatedModel) + return alreadyCreatedModel + } + + private fun removeInstantiationCallFromThisInstanceModificationChain(model: UtModel) { + if (model is UtAssembleModel) { + val instantiationCall = model.instantiationCall + if (instantiationCall is UtExecutableCallModel) { + val instanceModel = instantiationCall.instance as? UtAssembleModel + instanceModel?.let { + (it.modificationsChain as MutableList).remove(instantiationCall) + } + } + } } private fun processInst(uTestInst: UTestInst) { @@ -136,8 +145,6 @@ class UTestInst2UtModelConverter( instantiationCall = createInstanceCall, ) - instantiationCallToAssembleModelCache[createInstanceCall] = newModel - newModel } @@ -157,8 +164,6 @@ class UTestInst2UtModelConverter( instantiationCall = constructorCall, ) - instantiationCallToAssembleModelCache[constructorCall] = newModel - newModel } @@ -183,8 +188,6 @@ class UTestInst2UtModelConverter( instantiationCall = methodCall, ) - instantiationCallToAssembleModelCache[methodCall] = newModel - newModel } @@ -240,8 +243,6 @@ class UTestInst2UtModelConverter( instantiationCall = getFieldCall, ) - instantiationCallToAssembleModelCache[getFieldCall] = newModel - newModel } @@ -262,8 +263,6 @@ class UTestInst2UtModelConverter( instantiationCall = getStaticFieldCall, ) - instantiationCallToAssembleModelCache[getStaticFieldCall] = newModel - newModel } From 98b4398e62e855705cc1430e4c5c8880af4591f9 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Wed, 8 Nov 2023 15:43:08 +0300 Subject: [PATCH 25/30] Remove OptimizeImportsProcessor (seems it was not called, but a source of bugs) --- .../utbot/intellij/plugin/generator/CodeGenerationController.kt | 1 - 1 file changed, 1 deletion(-) diff --git a/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/CodeGenerationController.kt b/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/CodeGenerationController.kt index 550c366084..02601bc67c 100644 --- a/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/CodeGenerationController.kt +++ b/utbot-intellij/src/main/kotlin/org/utbot/intellij/plugin/generator/CodeGenerationController.kt @@ -776,7 +776,6 @@ object CodeGenerationController { } DumbService.getInstance(model.project).runWhenSmart { - OptimizeImportsProcessor(project, file).run() codeStyleManager.reformat(file) when (model.codegenLanguage) { CodegenLanguage.JAVA -> { From 0ca848a816f633c22f06f86183180bcb4419efc9 Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Wed, 8 Nov 2023 16:09:18 +0300 Subject: [PATCH 26/30] Process UTestStaticMethodCall --- .../usvm/UTestInst2UtModelConverter.kt | 37 +++++++++---------- 1 file changed, 18 insertions(+), 19 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt index 9ce2eaaddd..3b219e8e2b 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt @@ -138,14 +138,12 @@ class UTestInst2UtModelConverter( params = listOf(UtPrimitiveModel(uTestExpr.clazz.classId.name)), ) - val newModel = UtAssembleModel( + UtAssembleModel( id = idGenerator.createId(), classId = uTestExpr.clazz.classId, modelName = "", instantiationCall = createInstanceCall, ) - - newModel } is UTestConstructorCall -> { @@ -157,14 +155,12 @@ class UTestInst2UtModelConverter( }, ) - val newModel = UtAssembleModel( + UtAssembleModel( id = idGenerator.createId(), classId = uTestExpr.type.classId, modelName = "", instantiationCall = constructorCall, ) - - newModel } is UTestMethodCall -> { @@ -174,21 +170,30 @@ class UTestInst2UtModelConverter( val methodCall = UtExecutableCallModel( instance = instanceModel, executable = uTestExpr.method.toExecutableId(), - params = uTestExpr.args.map { arg -> - processExpr(arg) - }, + params = uTestExpr.args.map { arg -> processExpr(arg) }, ) (instanceModel.modificationsChain as MutableList).add(methodCall) - val newModel = UtAssembleModel( + UtAssembleModel( id = idGenerator.createId(), classId = uTestExpr.type.classId, modelName = "", instantiationCall = methodCall, ) + } - newModel + is UTestStaticMethodCall -> { + UtAssembleModel( + id = idGenerator.createId(), + classId = uTestExpr.type.classId, + modelName = "", + instantiationCall = UtExecutableCallModel( + instance = null, + executable = uTestExpr.method.toExecutableId(), + params = uTestExpr.args.map { arg -> processExpr(arg) }, + ), + ) } is UTestClassExpression -> UtClassRefModel( @@ -236,14 +241,12 @@ class UTestInst2UtModelConverter( ), ) - val newModel = UtAssembleModel( + UtAssembleModel( id = idGenerator.createId(), classId = uTestExpr.type.classId, modelName = "", instantiationCall = getFieldCall, ) - - newModel } is UTestGetStaticFieldExpression -> { @@ -256,14 +259,12 @@ class UTestInst2UtModelConverter( ), ) - val newModel = UtAssembleModel( + UtAssembleModel( id = idGenerator.createId(), classId = uTestExpr.type.classId, modelName = "", instantiationCall = getStaticFieldCall, ) - - newModel } is UTestMockObject -> { @@ -311,8 +312,6 @@ class UTestInst2UtModelConverter( is UTestArithmeticExpression -> error("This expression type is not supported") is UTestBinaryConditionExpression -> error("This expression type is not supported") - is UTestStaticMethodCall -> error("This expression type is not supported") - is UTestCastExpression -> error("This expression type is not supported") is UTestArrayGetExpression -> error("This expression type is not supported") From 9442c722475bd2afebd601ccde0e17d4a506d6e3 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Wed, 8 Nov 2023 14:57:52 +0300 Subject: [PATCH 27/30] Comment out includes for IDE related projects in `settings.gradle.kts` --- settings.gradle.kts | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/settings.gradle.kts b/settings.gradle.kts index cbeca8b19d..cad5a70f52 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -48,13 +48,13 @@ include("utbot-summary-tests") include("utbot-framework-test") include("utbot-testing") include("utbot-rd") -include("utbot-android-studio") +//include("utbot-android-studio") -if (includeRiderInBuild.toBoolean()) { - include("utbot-rider") -} +//if (includeRiderInBuild.toBoolean()) { +// include("utbot-rider") +//} -include("utbot-ui-commons") +//include("utbot-ui-commons") include("utbot-spring-framework") include("utbot-spring-commons-api") @@ -63,14 +63,14 @@ include("utbot-spring-analyzer") include("utbot-spring-sample") include("utbot-spring-test") -if (javaIde.split(",").contains(ideType)) { - include("utbot-intellij") -} +//if (javaIde.split(",").contains(ideType)) { +// include("utbot-intellij") +//} if (pythonIde.split(",").contains(ideType)) { include("utbot-python") include("utbot-cli-python") - include("utbot-intellij-python") +// include("utbot-intellij-python") include("utbot-python-parser") include("utbot-python-types") include("utbot-python-executor") @@ -80,19 +80,19 @@ if (projectType == ultimateEdition) { if (jsBuild == buildType || jsIde.split(",").contains(ideType)) { include("utbot-js") include("utbot-cli-js") - include("utbot-intellij-js") +// include("utbot-intellij-js") } if (goIde.split(",").contains(ideType)) { include("utbot-go") include("utbot-cli-go") - include("utbot-intellij-go") +// include("utbot-intellij-go") } } include("utbot-light") -include("utbot-intellij-main") +//include("utbot-intellij-main") // TODO usvm-sbft-merge: add if here if we want merge contest it into main includeBuild("../usvm") \ No newline at end of file From f37c1ebce64c4a67d830abeec56ba91ce7464480 Mon Sep 17 00:00:00 2001 From: IlyaMuravjov Date: Wed, 8 Nov 2023 15:00:36 +0300 Subject: [PATCH 28/30] Avoid using burningwave to export modules on Java 8 --- .../src/main/kotlin/org/utbot/contest/ContestEstimator.kt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/ContestEstimator.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/ContestEstimator.kt index df33e461ee..40abcdcdac 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/ContestEstimator.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/ContestEstimator.kt @@ -355,7 +355,8 @@ interface Tool { fun main(args: Array) { // See https://dzone.com/articles/how-to-export-all-modules-to-all-modules-at-runtime-in-java?preview=true - org.burningwave.core.assembler.StaticComponentContainer.Modules.exportAllToAll() + // `Modules` is `null` on JDK 8 (see comment to StaticComponentContainer.Modules) + org.burningwave.core.assembler.StaticComponentContainer.Modules?.exportAllToAll() val estimatorArgs: Array val methodFilter: String? From cea02dd28c9b7f82b4de33a4523ab730cdf53d2a Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Wed, 8 Nov 2023 19:25:17 +0300 Subject: [PATCH 29/30] Fix review comments --- .../src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt | 5 +++-- .../main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt | 4 +++- .../org/utbot/contest/usvm/JcToUtExecutionConverter.kt | 1 + .../kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt | 5 ++--- .../org/utbot/contest/usvm/UTestInst2UtModelConverter.kt | 4 ++-- .../src/main/resources/classes/samples/list | 8 ++++++++ 6 files changed, 19 insertions(+), 8 deletions(-) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt index 655a1cb1b9..97b073b2f0 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ContestUsvm.kt @@ -226,8 +226,9 @@ fun runUsvmGeneration( utilMethodProvider = codeGenerator.context.utilMethodProvider ).convert() } catch (e: Exception) { - val stackTrace = Arrays.toString(e.stackTrace); - logger.error(e) { "Can't convert execution for method ${method.name}, exception is ${e.message}. \n $stackTrace" } + logger.error(e) { + "Can't convert execution for method ${method.name}, exception is ${e.message}" + } null } } diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt index 407c33495f..70c2551142 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/ConverterUtils.kt @@ -33,11 +33,13 @@ fun JcMethod.toExecutableId(): ExecutableId { } val JcType?.classId: ClassId - get() = this?.toJavaClass(utContext.classLoader)?.id ?: objectClassId + get() = this?.toJavaClass(utContext.classLoader)?.id + ?: error("Can not construct classId for $this") val JcClassOrInterface.classId: ClassId get() = this.toJavaClass(utContext.classLoader).id +//TODO usvm-sbft: incorrectly converts types of com.google.common.util.concurrent.AtomicDoubleArray. parameters val TypeName.classId: ClassId get() = ClassId(this.typeName) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt index fad1b741ca..0f76278ec5 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtExecutionConverter.kt @@ -121,6 +121,7 @@ class JcToUtExecutionConverter( ): EnvironmentModels { val thisInstance = if (method.isStatic) null + else if (method.method.isConstructor) null else modelConverter.convert(state.instanceDescriptor ?: error("Unexpected null instanceDescriptor")) val parameters = state.argsDescriptors.map { modelConverter.convert(it ?: error("Unexpected null argDescriptor")) } val statics = state.statics diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index 7f88ed8dc0..b3bf3a4201 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -23,6 +23,7 @@ import org.utbot.framework.plugin.api.util.id import org.utbot.framework.plugin.api.util.jClass import org.utbot.framework.plugin.api.util.stringClassId import org.utbot.fuzzer.IdGenerator +import java.lang.Throwable class JcToUtModelConverter( private val idGenerator: IdGenerator, @@ -126,9 +127,7 @@ class JcToUtModelConverter( classId = valueDescriptor.type.classId, isMock = false, fields = mutableMapOf( - FieldId(java.lang.Throwable::class.java.id, "detailMessage") to - // TODO usvm-sbft: ask why `UTestExceptionDescriptor.message` is not nullable - (valueDescriptor?.let { UtPrimitiveModel(it) } ?: UtNullModel(stringClassId)) + FieldId(Throwable::class.java.id, "detailMessage") to UtPrimitiveModel(valueDescriptor.message) ) ) } diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt index 3b219e8e2b..0ceab1c6aa 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/UTestInst2UtModelConverter.kt @@ -89,9 +89,7 @@ class UTestInst2UtModelConverter( val arrayModel = processExpr(uTestInst.arrayInstance) require(arrayModel is UtArrayModel) - require(uTestInst.index is UTestIntExpression) val storeIndex = uTestInst.index as UTestIntExpression - val elementModel = processExpr(uTestInst.setValueExpression) arrayModel.stores[storeIndex.value] = elementModel @@ -302,6 +300,8 @@ class UTestInst2UtModelConverter( is UTestGlobalMock -> { // TODO usvm-sbft: collect instrumentations here + // UtClassRefModel is returned here for consistency with [Descriptor2ValueConverter] + // which returns Class<*> instance for [UTestGlobalMock] descriptors. UtClassRefModel( id = idGenerator.createId(), classId = classClassId, diff --git a/utbot-junit-contest/src/main/resources/classes/samples/list b/utbot-junit-contest/src/main/resources/classes/samples/list index 9b466d2e00..df9d9e4e48 100644 --- a/utbot-junit-contest/src/main/resources/classes/samples/list +++ b/utbot-junit-contest/src/main/resources/classes/samples/list @@ -11,5 +11,13 @@ org.utbot.examples.recursion.Recursion org.utbot.examples.math.BitOperators org.utbot.examples.math.DivRemExamples org.utbot.examples.math.DoubleFunctions +org.utbot.examples.wrappers.ShortWrapper +org.utbot.examples.wrappers.LongWrapper +org.utbot.examples.wrappers.IntegerWrapper +org.utbot.examples.wrappers.FloatWrapper +org.utbot.examples.wrappers.DoubleWrapper +org.utbot.examples.wrappers.CharacterWrapper +org.utbot.examples.wrappers.ByteWrapper +org.utbot.examples.wrappers.BooleanWrapper From 813c2d6e37e487c6e06144ddeefaf53a7b9fceab Mon Sep 17 00:00:00 2001 From: Egor Kulikov Date: Thu, 9 Nov 2023 11:58:57 +0300 Subject: [PATCH 30/30] Fix review comments --- .../main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt | 1 + 1 file changed, 1 insertion(+) diff --git a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt index b3bf3a4201..ef3f5285b0 100644 --- a/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt +++ b/utbot-junit-contest/src/main/kotlin/org/utbot/contest/usvm/JcToUtModelConverter.kt @@ -127,6 +127,7 @@ class JcToUtModelConverter( classId = valueDescriptor.type.classId, isMock = false, fields = mutableMapOf( + // TODO usvm-sbft: ask why `UTestExceptionDescriptor.message` is not nullable, support it here FieldId(Throwable::class.java.id, "detailMessage") to UtPrimitiveModel(valueDescriptor.message) ) )

qK5MpGYM+}50w#?vepk1LB1;ZDm6^7%Q0Vy#K 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Π!RRcLX20{?=Vvr*g2d_TJ&jXMZmUF;hAwq2;7?Lb~(;+W%2VY zHWs@?WAQ3f^Q+!;zd>3hhn>gQwvrW$W~2=Jfm;D>;`;(-qtnx&ws;H`>LU>x6uD8e zSx-{7n*k%a>HG_?YLPS&lr#^W*@itTinY}K+}tn-Gk$u1;yD|~SF}QM@pBfSR+oj$0y3rvQl4~J9!+fgRFM`-F}T4rRs?2&9<=QUD9oo$z?0mF zeVCptq5KxnBjtj2z%htcHqJFf>fX=TCNKl@1ALF@39%3SB0GUSg&3Gq94a;%RjwYH z`Xwm?FinpBsWP}?;b%Qr=M4tx*&6hy0Kp+Wqx~?t5H^iYMkn(|t&s!Zl(@#kAH@6B zZ$?5TIL;}9!aiu^SV`!()}J+$9LB!C>tgIHI>H`5_>2e#xnhrN-2>NB1llqflv7F$ zRPos+Q0%o_xAT^c5RGqmzC+waP>}JO!3B@p69$<*=rJSQsxh!E;MUlx1o|ULdl%6Y z6ORQo{YxHe1JnZ>z01Q4*F8M-G_)1NxeDng#RoAW#JpD=gB{B&c%gEEj@_M?GwdT2 zT{n1CUg*lF-xrqW4tGbAJ)y3MNT#SxM{v!Y$wjeS9?LPqq(W|>Ey`G1eBV=>*l%eY zf>dg`)^kyzgflIxxRGzRbJ0puk(8$p|Ag`6&)$X_Q5A9$brrXo%iuO&`HjUTmv!3a zm2q~BR%zMpyc@3{(YjAwe{jPjWgdKE22d?=#|rG@q#*s02DaHj<5XVOgfFtT@~~)3 zpXO6x>Yf$hH9;&AqIHGJoN+f3LviO|w^agfUr8B{A5?=)Z5+6olAg9Zhd2-Hubiso z-?Bx&yppd?V`j@IzNm)5KIM9a5f#Y~IoVi6a$zM#O+xVu!UJBOYVR+R+UI0NNRwW) z7C;ucYAN%q#@B%rEhC>Drgkg+=U-7O@7WI>TpFcNjP^!yT7`j@nASVM`8V`w(erKF zQlT{-mK`fRXtU%R2Kn+j1?9S1+LiGWl<||4^Wv5BY<7|-nr17`dz7y#OTC|ne%#-O znAOG}mYs0?Y>!=LU%ur$Z4>6|A;A5?7X;T+5jzZkE3X}wFy(@?sWYNpyia%flIgtR z1%}K1<%Vl=jNoPmG{!k?l!1Wz3s$}5Wf^&{RphO+Ba2|k5qU_5D@Rc!->Y8pIxqsl z3y&jv$!%(vs|^AMyw;VkdZ+ZB&43eS$PNy>D*W?5bbmaFVW9iIH*eG5;QhZ4fBMV9 z^9^eGJ3YhkAA9yhU1{uZ)6DJ0RaOUNBP<*1&)Nr~h?7c`28wP53XniO3dC!!2;rYU zS7F}?ziNa^enEJn5CoX=aL-_w@yQ1B=ZDWBii=x}HIF1%4nm zX()%l^`ILAh8L4l5l4#AK30^3{^8-k1ZsBPhONX^qVhic6Ma zGm?APec+p(l%u^GQ|8g@4G21kP|dwdnkXO}xC&wG&b997|E>YlW63a=!S>obyl->@B-bcuTU zK$44bWp!Nf!xU5P9PWbO4?dV|Jcy!9P6qh`o!te@*j5Yxc!`C?b>T zYtYvX4v4hJuqC*$P%17ClyOj?0>;^z);jVQ64bIM*Jm>>;q}uR@&N5a)R9L=rx%wu z#M0d(YE>g4xZ~xH3IV(h1m_tSuYq5F%j&jl)yn6$1TNQL=Yq-7{YgI*N*_Yz)+PU9 z85_I9Jp(9ILHLkcSf_U`T=4E8>Xf2|mX%G_n^kF)1RAvhPzee7#eRs`FBrRPNYBA9 zg?d-fw7RM5$6z1kMgx-MRfA-pqW%~LmI!O1-&gR#KDrR|6Ux#uv2n{-Rec;31L32Yyj2K)XO>Y$-5Y+=6#{ z1c=;LKO`vB^@*g5tXmP*T)xB)6-oT~&Y9${n!8URlwFyt&U02}-~&HOcM zI^Hly6Wsp`E^~MN?3{=KEqxD&dQw#%Z&KX8yd!H{78qgUXh$t%ZLXzXNSPf$6 zD+P%OHmdsA_+(yQeaN=A&K;v3iIk@OI_Mk(eaAsZllb|V898?e2uk_iQWg25&BZa( zI5&{7nPpMl-i^>G5X^JAMGVMJ=C=|9z#~YTYu@C1J}d{q-}!WIxuNe_L$%cGJXtQYse?Jw_55H_9bX? z!ny`OvY;Ieq|hz`tS;6xrrtRm<7ZIQw3xAhT9jJlY2CbixxV(9Q{D*YT3&8ll>ukZ=mx!t18$6d!c*Qb@C=yoEHwY# z-~0tBW;t4=%K%b(6Z$}9kML%G1-BJ*cnKkF_{@Se7&@?Ty(~{qO=E}G=bOI%4CMEF zzS+v7tZo7s&cf4ADxhpvyh$^;`N7=+KTF0jn8i3Foh0fHW0W78W~DKmFm7X4lDIn% zGxHJcg6jh4;0}3pbRJQ1hV}wbuP+3yJ%(P>pmgAX#-$nB^(2+Z^uF$Kp^Kb zkf~;*R-f$I7*tp=Z*8~+4zw|0{CBmhU%gF2Z`64w;o%s9QEXuQ$pHYylAOxNNvZt- zO%e3{C5J{oP_3G7gs{1Ei$_P=t81vog#u`p0ikFF0jmO`lI<0kLtEf5j*SgptxJ1} zNy9W5rdA-bzODw zVZ(F(Y8t^zix@F`1B^eTQ@^A}n~hK{#?74)RyTMjL5p@^mlSFOT{r?USH)3>3_7;jmb|7!*@XDw;fX(hgL^TREb4wff2`%EIBs`H0HSZ6aQbJhT)Gghtf~9+?eDyfRe{j|-O+Q<^>S zCzeR5f~|0@!B20NNgqR(3~SKrM>|kzk&S7$l&duDjEOGc#Eu(DakVbNLR2S=mLtxQ zcWj05036>Eh`G31g!BY;|>*B&2-uiI15&>OrNfL*^Di(P>hUOU?ngLG`Y5lp`7 zz`S^LLYTH}myrx|f&_MEl5BIq!Jb}H5n31q*i7A)5*1Pn&}?PF`*v&0ZL6-22S$N^ zS=S*GSQ60yf+-!Iv<53nrcpRdBp4v=A%;Ff5N2uv(L8H=#P%N4W5SE8?X6qIW7%_P z3FpBZu$W87-#Z~@<(`%2T3{;B5Tmki2>t8~`iU4bd95dCP&Ftnu1qgMM#@h$CJ!=< z6{wtE=qEuFqnm?BwVx!LY2p}r6kjY@V-V-Yt)80cU#<3MDL>48_P(@uXR3tMB-z>F z5=nVkt;a#IC$r>5W*u39-XiDL=OBf<)0s3Gacf)$6$(f%H6+?nSB~O{JcDmyssl`Nb0^MMUu2e;gg>*>*=Ut{)8V6Z(gM?cc z!#;(pSYEbWm+O3*s|)i_4m0k`Kj(bGW1nzL+q3n1&zc$7d(eWmJRDCeaX z?QH8^FIe5A5-d*N4Gas*)y=s!t$Wbsw;c~iHJSu{OHmhFT)UIc>@&}J=eLibLq9)W z^*fFiROAFD(1NLr9MVNl8mW*BhW*vzGID63;Es&Bch)h%$8wZd?=mCrlEuDgM$a!# zPrj-Br{TV~nFvdzc#PBzISYsiaE97mj7P#q$h!`1{--wi(`@2;-#X`xp2V$Gp30iz z-PVr{y?R_XHpLNRuD@q@;m;Xi zdQV&zK_yy7MNo>9Ig!{Aqm*Tiyc|r)ItM*qXPGDY>LSM^Cs1d6bBe_w(H!NQ4z=*G zyWKIZU5$eDT@#Y52OU{6Ce|ODEhna!YE?jmLOruqrt(-|%`KT^Ubh6w*O$?r9i$@I zuPjMx{k|IX7HD>vlkG8Cj#r9_n(&hRjk&aZtgVyss))GMC0%qdyjZb{xE~xT&DUZS zOx6;jH{9<{lsJM$W71=tB|H)b2*tP5M1dPzlTcs}`f~;R&u7&5oKQ{O_)3=riUHw2 zH-$W8MTCSOuFTE*<{L_;_G2|Cc^h&)$FmXznlGG}Npm;}&uFLQw6n`egw7V~R???2 z$jpW+Cv^FFJ(gLR5LQuJ@vq)0DBnus7sqBTQ zC<0ax&T8w9vnve+z^UI}$0rXQE$XBmYlmP)bbp{vfxeBg$~Xb0X&QmZSnr+Y>aX;z zkSy{VXff&5k#Q$D!C2IK4J?pcHWdjQcQQ)5%BN>n8!4$I7DU?1r(-m4rr!g%`f zx)k|Lg8Ck(UVKtrq+22Tql{4tIm;Wv!n$xQ%KgqEGM%7W?hP1Sab3yQN=+n3piID0 zV;YtkMNt|SW3<_zOj(6%R#={|4C8!A^`U8tQfzhwmdCY-$a2WN3_~84++omER3*Z) zth^MAp1p~(P)KD?o4eOWb%;ap3dMK&2;6l}V#pN@QDF#!F?B2O15IhjeAhM7PLzK} zetjZ7+BOwYO(a9g0=ze;FkFdofYP-hF9UYrJu!J+WBfFd!k{KM;UFn%k>y4P&pnkW za#*1ZLkiZ+X^=A#qt^CU`-f{TQRG4^^vk7?C`zRr`u+MdDx-`~XYw|k@(_aRIO>OM z2@#b0XH`+&5Sj1OYTn|?Fe}Zu7HDrDea_z7$)bC&WSJzkU}wVcW-&zCs9U7BW!oZP z*su*$5528;eF{698VlEOjzc=K6Wpp{q9aE`{Lt3a`9@JV&#v=bp3gVF%(tnYYnjaV z#GiQ2SM&lM{w8e$h3df?ZStq;9Q${!0^onHRul)TmbFEB7gYbL46FL zlM2{jhVY*%O@M8{^1Ii@J8~PMMeaY-JT=_q7Vq_2uRyCx&@WWqD~2nj9Ll>xND3rU zSVXXK6GY_8_AEdSoPAJjS7m9Ad|xG*6##v{p1-5Wol% zqKG&kULhJ!mlcBfFyQPF#30@n!FItg!&f4^DnI@HWEoa!nET{iv=W$W$#(vBUso zWk9!7tt4he;97J^JhLx!BGePnmtS_X&k<92(v|U%Va28qd6X`1*?%UTmyS3!ac?*F zgqJ-!m7a2=9cWEM(;2(;BE3h_Rrz29Pwmr8x$ zYEq6PCi$X{^ig$lRutTu96)E5Ujz2iP~&iOjPT(B;>Xu-$6@;71@Xn|eyKR{V?uzP z>G#y%-++$%K?>qW*>A^b`m&7paefO1`3DEGmu@vdefJeZj~gGLmj~c>%be6e$D~iK z%&1DbPtA;D^dRQ$0oj{auv4=2{QVHJR^BmC{s_4`XPR$ix-Ag$NE^!atv$7`rpTx{ zfM-$+1Dt%0@NocSMW3Vak!#2EGaPO>>ozr=SgWo=^=XqT&Kw4^e7mC9r&YmOP?KcE@FeJ2%O?QM}H_nQbsWyf^!fIZ2FO!?D_ER9v%8!^5$F@s^ zSYFtsbFpvG5n=lH#n~Zh$-*W}Sry45%Ye2C&tJOo^xEdO?1MmOTKto$5kg&r4`c^P z>C*&dypEtyU5TeHvulo(>Q)kqB&SUsi9QIl4gQ*VG)3e-OeXtiap!Zvl(oFiNqea5haSt7G3Ps_2~u?dQpHP18)Pa)%3f`%dSm={2EOcbefipX21a0Vq#-r9R{8 zv&`BuIOU_EN%cZXgA!Fyyvj|yB`C2z5nps%Jku}5aRmwHYL@MSDb>XRsKw&T)VZbw zfh-S!ymsw8$$gba)N-^3R+R!={N}+?`d56KxMV6GiOBPL*$BWJMXjVg5#ud5Vir`m zP;R&ZT{NZyFXXu*^KJOaNpWuaI3%`l42$0~?i&bHODCCHN#DOPV1%KK4#BM4t@Tx| z!V7-J?QYr0iC(VfWsft99BLNc;V5!G{1H054L2A(pOdGRGFXAHHxP$eD*+_u_EqT9 z8)famiq>@Mqer~UOQP(NIr&kL{ivEQM$I;m1qR+CVb&nQzKONzJYrF5Wj`F{ypL0c zSvKwv?`&eUg3t&H_7a@yy+OD?evmFCem^w4v`(zD03|G+0!Ly@p!N01cKWJ28b-_j zvjxoVtq(z&Gl z{5b~=WoAOpqqQnN2zj4`=Gyp9Qg>*RC4n~Ci?E8m%Il0~m8&(8YUp3;cmwGmxPg*8#@R)QyZtRz4w^fV` z_@I-lk4O-3$cE6SI?pmRJ&M-*$qGV@dUca(*mK$0yk=~mjMgd;)LLHzCQA^n1KFey zIn5A{My%Xmg?1IQE_DW%0V7{bn7LW#fcFRFm&z}h%Y~YhGP!fFfVU=)z}8pl^468x z`h!161uq%49dYxPJbucPa^l%zZKI4{xF;i7AN$Lbm+X_5qk}hm88yBrep!Yx)gwa& z#UVr(frAEMsTe#*WI2zeAaU)KOGZd_TtSy#IDUkfE)!U#EYq%#M)V(71m5F(A2SZ9 z(6L}&VZw?eC0vPfAS5LXsL~H#2PQ}l<9+b6KQwj!NH~N)07lR@gh5b8h_Ti%%E=vg1fGxDU&wUNl%ES>K)sa*j_0*dvJKhgo4| zUqb`&gaP=JK&)!Tgj%ZHJM<>i$EV4%VW`GJQ}t8KDg4a*X z*lk4=%MW>*h?S<8Cu0H@8b@AotnPtGSosO>l%e^yHx<>0(75vbhvmpNjNy!?G%NV0 z!x83qo!i?iTVY0vB2H4v;y*vbUK1{v%{76I@>C4BsbNAcyoL57D)r z&?X;Ti+9htrR}1 z3vcJjpZn4Oc>sV<0RFGhnJRB{;bsX7RuP!kR^)Mla4bv-Lg|mT)C>f3=qmV+OUzrLu%DTt*O< zcthk3CYGdDb<0`!$}?GlV+&|vCrv4>9TP@b=YhzR+{^IES)5yuOzu014OR6>Zdg!N ztcxWKcj$dxrK*8g@`S$=#;B^%$pTn&-TD)10x&BR9!&}Lh>Di=K)!cyd&0*qEsq^_ z_~JcD#pTIx_N!8l#-J8Wn8z!ntq0BnB?9V3c90G2G(GBuI2{$an}~D=-~4OD)4f}V z49O&-U0b@@l~CCROKF=BLj0t@S6muXx|<1C2-BB@*&pXIcG%r()aUrjr?aRvY<3~G z=z{#EV#uR)Xv{(YuA+Dn;u#>;ssR6RIZ!w-W~5rpS%eqAB6E;mspXa&Bg&6)hpiOI zuUN0RvW@_d{rOY#I%;PcOqwq5KJY|#=7)KE@7}f&Iim)lJe!($Qu>Kg_OCyZSbx}U zUXF{q=@Us9^LDrQ6VqpI@Jl5p`6c&yC32rUP7UV*GR>b2U?1S@lU_K!Oj&?sG+v}~StjnQ~%sXWyjXVrpEW;;&)oD{Ai-c#mWR%b7YTT~!A zMd{eeO*&3gT6sFy;+NDgMq$OKjDkds2KEmCrU)@6hc=P|Ko29=-nQRW=bPJSdNyRr z&+f1UQU88(J@@H+wTD9!%i1Hn`^T5?&H=r)k`eCqG$9zF_OWiOaY!GK}e z)3f>dg8E9OlGk&jt>=;@d8qmD64SF~+pg!ZNH|)^YLn{oV2u3!vf5Es`3AryhOXx1 zqX?2=$iX2(c@U1cgHj|xU1SiBVFjR64NSQdfP(G6()X?NnGN?X)ciU|aRlmi9{#~zo^0Fn*yRZXB`O}I!Ecz4x2 zJxA2&@>H-nQ)mhYK&6Uuq52^eeEtyE;_jefRVcyecsv9rB@8C7QKNAGHWH&82d{sp zMsg(|5Mq5cuRa?PLVG!{US~IXU|b~$bkq|jwz_D+%pqH?J~;Hagx{M3)-A&OQ^LxP z3p52ho%$Sz@l|t7JgvWelOAePr=Yai&SG6Y4|=uWq^=VS>I`A zM@7#heD)k3p6)T9(xfQx;#O|iN3}#ee=8Zl2zPN9`!5z= zv=QR#1g>-D9k!N#yAxKh|4@UZhFwg-!?{AIbWUJ??jeH7zQ4gkR@H zKG(xZnef(W=1ee%AU7l=k4ePH$)YG1T!2-=D;C(qCsCmn%D@^FXw>pDhmdB8@>0jj z_J^frEBR`W$io-U=CK;os*{|SqmU1yWe14OtP_~Ag5|A~oa9rTutma7l9f7~DR~Xc zk{v5`+*)5+USh4^Yh%y6-sWH5=0)G4r5`ZUCR(b7@EmfyI|Mgq@@x^^%H`c6y7%-R zPr>*2Zu7l8H6F&d_*UP8-KBVlo1cs-nmPA8K2OW;PU&t7U)n`(pd<1HyDF`oVOL$# z+@)i!5PE05woA621NhZ{4j`@&^8tKqM_eM}D}{b(Z~ZVUed&G)dI5p@^B;KK#+lR< zH%tHkKZXArr4>VKxZk9=lKWAO(G!3MDL1PsPu@hPO?f&)k}Adn)U zsG-I{#A7m<83Y>I&6ds0i;>)Idx6jpwgQDpR@&w@EiFw_HLlB*n-w)J&2N9MeC)2e zG@0y5FK7G~mx%`r^4D5Q(5=hE*!eX^+DgRnpQrQGUTe~xT7lsL-T zbNU+Oa3h>t-!iO9FQvAaDZ?FdQOFk|9vD-_zdwL?Z>9w3=Z$PCuO3`)uUuLr!IFvp z?#-{8>DH~L(_K!MEi!Kk`en|N`it=}SiRL9_`3)Ce+WCPm`Z{u4KwKA?l!o)`{3?= zad*GC3^KSogS)#9GPpZj+?|X2;LNhgzU(Hu`_NrgT}daMN_8sdJO6)>8Bb4;9nerZhg&sA~?7XaI!`Asd9M^%1lo>(Wozh`5Ls?xky zvn#RJVDKt8qn9t9BFO7>^0lign<2h`G|?r%MtGfBvPPM*AXwUcgxNGS3bbi1$QW}W z{7HH+D;TRpwcEwYqV5I>k=UslQm;$fb%lszjw5DIfs6v{kXuRtK)-_URVEt@LDDCL&w#W)WHdeN= zpN#6#t%gO&2bSY0qd-x4OtI($Ot>sO?H&GdkSNKQTEsbuK7Ha%b{Y%S0!*?tRa(y= zDZO$+(YmU2VtwX~j+1R*7H#|z@H!yY=R`ff1+!uC4AZmszzdz(w1qe0OKk8$d{gTf zCKk$yKEYWaN=E`6&&K9w9surSVNJ6^Q8XBIJst?Q@$`H=GwGa?9dQ36Ts21}Ru=<7 z?ZwY=!v2yS!n_Pd=t#2hd7{6ycYD0|@P)j=GANE`yWxK8b#evM$JUmzL?Bib4S)!n zc}Ec6gq9;jlw6_$f54dbokP1zSr?c9!LwK+R-J-&4TpI(PngV}cAy)`nF zUPQRr&TwKKOV(Md*4Ouks_CdEs(+Cb*adV-c}BGS?Zt7bOU?$SCQF@)KUz0uU1BR8 zUFjWMt}rsknLD=#?0yZ!kBtUm=WqhNF7bS1px?ro;`UFrBJddRSE}ZOeXtI8d`_+) zoIvuKNjNHN2NM0?ZUm_h1aqGdq75A~SJxPh+B+X2>vwn!&eaKsi^X?fuc^dW*o;UC z7Qi+>QX7JXq@cm1pL@e+cHNb8ZZ8Cn+%y9C>Mdf-)WG?U2LvWqPViVLP{b-P?i`-Sn+dgI+Hh7sOBzV^_o;tsM;m7rT zg%qVx1ce6_%&|ybrgqQuOo2`Y{b@S47r;y}$bWBP-ETAG$m{FQG0O%z7eV$4&MhAJ z!!xCxU<0^!t)lJ7jrr6`^6UClVx8Sp9IUE;`E#Tv%Dhs-K-O4#whkle zgVV_ss6@W(d+HcBhxgx-e@MI$_!P|q$_Bc#1cglyl=oQ6mH>2kQRccz#Um}IWsI>+ zx|sO>vn$rRg;066^IB4*0u}n(^ve6_F#t*^Z%V-o8~?~5pJOoEJ3BWwkFgz!KqMRI zL%*c|CX7q21Wx>!!92gZ^A?vK3GS8i%{A$8#)>ch>S2(is_QyZB z#-TBrh$%S*?21G~Ur~v?b#bR(E>D0dd-!(?El0fwE5j;^j@`yK168ysd6jib4X)@V zGjq`N=PvgZbsiz}UZfmkn3{YB8{)5~#`|&|`8qpD@eB~d>3DG!yN*(P(iga*at1j^ z-34Us;x)0d4HdT1lsp{i=anw*r1}C^XKPa-yR8oDz8Ugtg^Bj-z=QlD5HF8L8x>_G zADKv^WKPJ8%%I%hL9uQSq<1BXd^!F2)sOagR;h!N^%N#>Ql$!cVUsO7I?>Lx#*@qkrBLU+;wPW^ zW9AVS<4_obwkw;r`Yt85@G{fw{Q`Y58MU#(>{Wxxwc=EPKLuizgG``K55JQWaz+B{ zLHme4L%yPpa$0-}L>D}_cbbWv8iSYYK(!elK<$+(DFLRbaI2 z_)XUwcZp%JR!XzTV@f?#;kP_Ct4XE#ZeixMO5eOCIlq5ZfJ9D%1@y|?U5=$D7>i2# z=(~l#g`M__Du2iO7iFu3Ec6MZ@N0ZfuUDwnST1E1+xI z76Z;c0$%f)%Z$<$QTsxn)X$7oj#PV!s5CgCSLb_e=IZWx|ACQMd?b43FJ0%wNikPT zq%1zS#RZO79@xTX_r--!xT5zyP4z76da1VQHP%^LT(?CH8oVm@SV@wv+EbGSBb6py zbi*quBO97R0tyP|&d!=yljd<^wYC{HDQswQnzg6=>TOY0wWn*&p1eoxl_n{&Ql1+b z=asc6zUoE?5o1~8b*S18lh-N-n){WR9QU*KIRze{#fCKp+S01V&EfA3k18usSy&A= zYAZX)UhD=E$Zw&wH5D^P%d`76H67Fh$-lU0YDOlF-8%Hmo+*A{=0vm~QQ~nRwK6jD z(eDGN2z<&7jW&q5D6%s>I*>;>w3gTEQM-7O=K>JPNb~mIR`(| zDcifpM|UqA-@_dIvZY+I^LV{oV2{XG$c;Y}LVZ&o)88FoNvHPA-k9Ki=1EKcfB*v;LP z4u_Z?Lhx_l5MNpQ>9htg0D3@A33$R0aUxN1A~tU+_BmKJJ=SlO+Yw7fl4ni?B4m1` z5lh=#0WqXA`y+EV1>mRjVYq|q5$jc%{dck3fp+{>&N-9iC)L$)G^X(3*Fkf=QfmvF zF74091hqF5jj0R(Zvqj@Wj;x};$hVBhPgs6sePeFE~VyMt^f$VHR@501xiLohS9?0 zReo&L&!)F@+!0I`#aQhr8fR&x! zpKHc-z#O3LM*CpJyU@LRc=^_Sv^djWMiZyd8qo_9B}-t>%t)a&%ot;QiKtbn)JB%r zD!eATg7rq@pzXyxQz1Q3v0I;rS~zRB0(<5p1Wo;Ax93s42%TBY{n#~e_-jVb;5WgZ27#D+6l$O-^ij1PkhACJ&)u)D$dOD z`~Vomf|CWARJ9v`zfp-7V!9g)R-O!pH~&+!i3k47jvR!&#Cb-fuz)t5S@iQ_M%_$h zPzCg?eq+4#LA*7N!0$A|UuRTzO%OiZGi=}UIKS6LBKjoQMx>#t`C}cm|8*tF*X8br zl{#2wfGzL){^MI?$t-RX)Q=?ye`3YJ-(#GJhJ4a*si*+4I|VJBqU!qL`hMul3Agqy zQA(wN0fbbI!MpFZs|a>T4B#d)Ej&@1d4v`eVQdfQUQ%~~Y*+!#TgU+vQozbCr%iaM zmWMUQXnNRrK0wt&2SR`mx|SOJsjyD#MUlTbZlpYS_JI@t!+kS{^ZyXz5{Z+{Bxh{I z!_n=RPri@gD3%1&FgB{K7`u;>S7KWvYUvy(Sa%_Gw0>D6&?zRy;S+$5=KOb@`x!k% zVX7Z+HB2lfo=)`Oof$_tMm!)C_fV;!708AYsD`UWo?S#{B(4{yIiF4aNeuYsCQuzy zKR~}ypePwdL)IU+?G{!)K)oW`_C2(@H|iv$Syw{JNrBT@PE;?j1+L>24cnKho82EO z)G4lCn^tv|)$ON5s-+m0^s{e)gax7j7lpsS!hIcn46`f|*td|D_!}t==6*{h=otSWjdZ(>Dz4{j#CRo5cpU0L2Ktj0x(TDmX7` z@b&x^+ZQFmd|^T%X}$EbkiXN-eSJI zAW1g~!RW%zQT4ju3tqX_`@uK{&VblE2&_I3uOIA+L(@*>=n)_Aa57_FYjS2FBiI3> zRs+m7IwH|CqItv^)N)lN;?vG2g!t4|4|rN2tHp19b3$8}DOzr`TEoge^QsTs!!|7m zJ=W2dl}XCvcPaD2lac0eWr@5t@jN#1PEOyB56cFEYSCfW#0LhDO_++4t(1`jRPY<= z3W=Tb3F-12OJ#wG*mE_%IX!n_J8}SErJqBaK;caq#a4t;hcJe024h6U)EjQR;fe75 zY?@6w45pnsZ=o3NpUz|omf;(&HjO};srizOn6^IFT;U#Aex+0(Li#IS5Z!=iI$wea zzgGwe&mdPOejF*G$p8wrh~dceo>v_adB6r5u?Uj#pY&{y^js_y&@FRUS5?vC&&@n6 zYQGOE1)gBAaYKCNiK>1ZoWia}N#mRxw&AIU7hNPg3xlRt1xIK)5kBWXNe)xjsOe(# zt7fq-28^3pGBgpG!SMWT6R^nFL1n0$ro3;a@%(J(Jy|(Vm1Pkru z>c^&G{J6>YZYGW6w(bO$8A{?oE(DfC0>~&JQLvihO{L5GWOSw1z20$mhJdo+6TB znmuSiSx=lDk+J6OCv5!fj6{@@#N-R!RQw2Sl$5DorB7OQ-ITeX+CZ@a(wC-TMqug*^$Cwyq+y%JTs`Z`4898{-}YN#J^sad$PlRYa#dmyuv@*p}jsbpoI56 z_>t=y;Xa3bFd!@w?bt%pdiQdX{#Jsjg~>x>?)%JjWM!)@igYFhxe!MWwc!0ugVg45 z&iSIx)Z4O$+24Zv>V&FU>KCu-f+V%~66ZH`ZFzY!hBGS~DpR)pt1-`cGu8 zHdlV)${N9+=jh*v%Kv4xQiEiSsX%W<5}?*OAvQ;mA+}Tf;xvY&sPTZ0iX7 ze#lZfh{$5S8A&hj{N^j=k1@i!DU5oIjBl#n{jvcYzt8Oj$t@`3_JqcD8+f7>;h%b} zq4`kEtNDQ8&X7@cs^6I96ew~CSvn0lS%`TLgXdzYPCmEib8AKhh#CE7B+Vo+U*QjaBQ>=)y0 zf7_6Hj@OIO@VxxbiGS@y-ZLXkm2(X@Qu6&4qC&{wDBBR#MZaa@=QuyOPZM!>z%28S z0g;){oeTXe1G_!SXU}lWk?|myw`(d4N1-VQ&${z5)`|CiKnHFg-UuEW!OBlC+~X!< ztFBhp4rZzB@o4lqQDk{9-{-XG)2X6R{cK10K8!oGZke1osH6V_Bl47MMXXJcLL%zK z4EBVgaKN5$2tTpzNg=QL8MRb-$!vkFXsy?CL{+Yg5YO`=Q`*BUHCV0 zXawAf@ZORTK|!%0Y}fSc2!o@wvg37BH^&9X4#|J8uidC}BKhne(%FI_rN!G8XplA9 zBJ_>qfJ$RKBCC9tqNy+B9NDw}c>%0TXjW>WZ9cNPZqT6<$exF#j+Teh-Y_mlpifU$-Ys>OY0|X*qb!65DNr@9$JVT)P_=$hk^ja5=r1}&&Z`p|1Db1bN9j*7Jc2EriW&HFjA{yw;CMk9VSPc-B$!#6;uBG`0u_e z&n8(f{-16OaT*Z+TS1ur(&~L`Hvbohqp$fOd~A_qGrvxq!|jk<%A{DPm|3jY1pJgy z%FA_p$L;(EOj4LH7*iNk=%~MnprsF%QPpZ-gc;w0EoX#m3^7KRkbn^#g25JD`saD& z>vlXPT=el2-R$it@aVVA_qgG<6)pI@+AB(K%Q?;TEyOkZ04+t{TS1b>tJT-GQ|P01 zP1AwKYh7HydrG*6g)^S6%ys+)l0f2Fi5`tJ16o}+zpkoPWC7>vqK}V%i%`&Chn6!j zhHI!Z!9L?3@#$l#?Ka~teVi!>IU1DKc={xj4argn1d>I+!lcq#UxHO;PY{_;PLMCu2pp4|N0|9V^j&<4{KF30I=&?9r+KmI1L?9>?$_JY-_7AZs15Hn>QcMt%! zaghL&48{93BTlAVVWESw18;%$Ik!(EQ6thlKzX}X z^Us#BGVN?Q7aymRnvmWsQ6{468q`O^$T2EAw%*H%ev>SLFD(}$e|E8NuxzR1*nQj< zee5MlCX4kKCi8L4?tYD2tdQ1NL}}~n1?$NCl4eGGJ=%$d6ond%w3cVJXhEI{Dr9x; z5zO5}L0jzRU@dm!*6dEMoh#Eyh04Ecf!QYNTQ>ARn)A)9k=47^wo)2DE&SQUFpLxS z2}bw zylN}`Nr0rHX!I0_JU(#>`!W<7Z>oN!(gr%KEIi!K^1$JCG^JyCWM#DG*ba0Mf2U9Z z_I$zdyFjklqlJkn>etf}%-s~?ubIL(@;s7^tASLLNN-)U|rg7P9L0RKo7f~YfM_%P`?p3KUC8r%uw zvvhy;@yp=qcJ(IcMB%{x$j!f+2#x!+rLK$C2X;q?Wr;6;?MSOlp2h;}?b&S8*M&4Y zFLfGw@R~Qg*->63vb}|A1eq7G&^M09I$;1gE<$0PweQ=i2G){RZM{|F*;{%P5mwXp zsG|&Qvsx>)m2QD%I2i;E2wm#42J8%@U(|3@Gjbjg)|BB6E_UxI@+uUVOBVER|H#jGO>?+cjaxMz%OAL+3RrJ;E z6#p*QM^WYsH^RAhK#MIKJgz%#XX2G;ggCq#Rgv8Z1URMEB_Q-?8mEHi1L zGW9TCjVEOPb=m|j8NIg#sB?If##vwyb$?3lfj~0&oDjF;WHB)&ev%omF(X`u03oPT zze8qQVpRB88d2Y?(2WGj7)dy-`Zi55{S;62KHi zJV1AHap!1MB&V4!ms)5mOw@7jP8Jum-8qoL#=d6T=`)a)h1cZX#I#agTw_B5Jtfnr zSLm)}h!n5bhVj@>V3fWMr5z}oZ00RTsiUSH=x5L*K%TofHBbMEfy{P`V@x5=gEH`e zw+PoseUQ3CmW4GMC9L|7HaRp@vwXsdut6uT{u@U&rJPQViAy@s_rebnrK`WlQW+4|;;qW> zrP;XZxad?~sbD=#;U4U6IyQpPjlO#<6g-b9o$V$+}eO*nHG zqTMKUA_vKJ$k9+*mH`U)DRei`R23*0nH<51K<_Urv#&V$I1OBa0`B7F1nj9W=~m-l z*IzPOp;2kt$>_#a0g)AxjeXTrF>wsu&CCyU?y@@YLtW+L5=E4*2m_1BS~NX8`ix}h zvUlFd=fh)urAbr5K2*F~Di zorin;F`kLNp8D5p;J!_)MAfciwH19sm?_YMXNfHq88Jrs+%cP^J~@p8i+86HNV%oEQge$FMU6d za$TOOcR$mcFxbXBiQBNhdnownVIk`yw!U5D|k zYB!PYMS=3XCO(6;Qo?hYiV#8|By+v9hGh%J4)WdqVyi?LUpm@s+g2g@Z69EW_w}bS zgz^=FleJwwg-*su9qx7A6Ee*|z_rs;8*fsg*YTYbs{P$kYvpD`KPd7i|7@FlKx$)K zZY!LuU1ED*BFPWwHXg7eGIZ<1BloJAP5I36m91Q>N;ksOBkUBDdR-2NNXJ(b2jqTl zb@ZOp158K66`#()=>t#bf7wp-N&mKjx;-tn^PqbsJ+W>cz)w}@Udq>Gi!Yt_@8Z`p zta&eUH$mr5D%a6(YUn*b>OK6u$nVSU%RiYNP|9|! zG#HFp5uin;cnYY@?IL!{G^$iuqo76llyPp7!FbF9QeQtJ2}tPlil9Z9sYGJp)K=M~ zuFWdBv|5MZ12hzc6BqNtu1|H=jfUrmMy;G4eUI?!YY+wl^+PJ_RiD>$e`kcPqCXO)Nq7 zK~=WMwBjHN=L6&|?0)UMS1yw4O~7nd0csjs#IA+r!-nZs0ZdPhTpls@HRyin1bQ@j zXE56p!`!1wQhjYz4O5No)jR&S=e(=@hSv_2hlw@ZeQlLm;r8Az+l2sw#um+M!$p44 z)>im#-4-A736>|R6IKf_ud2sAe79(eSmPp#SNuJ*S-AZL)|)t&N0NOG;}e{p5PL0- z2u7}Cd0EI-K8Tm;RKP=D_^Wz(%&blJ7$;rP-8ttpiuROjSz#9|4G5Y)8R-GTGvUoL zs?6PMx0gbdQok|f^0;`lPfz33Ed_M?S8&d5?*MQFBTtxMO6*1E{ z)1bPCI*V3{%?0PF?l`@b8RGlkNFf^lg%`g`J?oq)Q#7Vn!l`@Vmq90UCAhSKe}~`& zI|FT7FrIu_Y>O$9rorxtHva8Tpq(N`O?-w|XQ6pgn30i>S z9LxXGzXeym^sVH+?^j%->4@f%SjF#wQZFuSkOqB-9DGm{)klboS`yvzxvE}|%9AnRz|2v zN|BB=(3Qco~;q!TF*Th;W)(V ziiD?&7`rUG{P4ZyON>1jsQG$);Uo zVhlc6@DD4?q3xgToB2tvxay;PnQ!+A^vr-~c_bj*$%b06nhk0859I@cGqi=cH+Ys+ z_kM?aEbYv+c(~<>aq=t|mr*VQpSzN}pn&uvfKH-Mo}}CBf+Bb&sPpW%0ge0Z)F9$u z&+hs;8cSR{Q_eQbhcS$LC*aPN=DWrm`6VO^-zQFLE1dZPZxPj^KZ;-IM=>)Dh#$)2 zvm?VG0__ts4`n8|a(qZUN5(7Hdu2J?v{Du1ZHQX+%1(zQBh6~dl6WN}h099S3jdR& zYIn{@q!RVDmMJD%eSrmqHAX;bl4X&1V4(o<*()a!kIzfTfG|_}3@%Uxk~Ki&{{06a z(S>RXF_f*|4#GO6eMJSeQ?#TZJW-im`?43HSLhthI~kps(gJ0)Ml0n|%r=N_NNNiw zTF~u746IW(NoR2B23;yhlXFsx?))bZpXY!plQfc)CU`)YSj2E(`qryX2}7itm{5dK z`A?j_y7Vj+99V!a&1#5~%eN#dB&%2HCZ2;UO;ahAP3rWjWQmN@GKMeljPiENcy&gItVp;B@F%tfkq0w2iNm`kj&o{ zp~29$nR_U*T`ec0>hmf%P0)9kB_SXRXwFF*ONs9xg*hGB-B#{x%9Geuzdo{Zmdlki z_9mg(mmKO9R41M41^6>(-nVBI%nWh*GY@AS_YaQ){0T}|l?HUqI49+R1lg@2vvr$$ z7H2OuaTQ*ZddF}skrKc5`Db^&9xualoTaOx{RtL3)`WP4(VS(e2s0eXxeL3vv{|C$ z)T2ZyqhoEPEci(c@KlDu9yvsw!U4Kz9b6`cE?C`a51I;@`mRubnIclMSlU9EDj{dj z_Bp5zS<{oN230kq<*kwrAB}M3`PjpJPw!;Olq8u&d zkD-!Rjr>ucN$6g@lx|>8Y^ZZp4Mq{EMXU)_=r)@nvha_y_nZ7x3I>0w9!&s%x)`ZH1l+J%Zzxs|v1Z1rL9X;^}6FW^gcYA@jZU&sTeuuw}6iNays=$d0gz~GY|lkrlY(b;ZY z?Dg^|Q_?j`=*bOwpE+n!+ka7|*GC=K7>6Sa(Nq~GW8#Z zP@kOZ6j9%rgPT){P-0hx@PKKCF@J?4&2q4Zx~y!j{XvD4M23G<4bRQSb;ywi8TOdA z?2ZT2?@gH^Z%oCbshz(%nNuVCY7etMjz!#;`RXh3$G2J?8U8>RwMN3<;f}|KdXl{P z4y^eO&QL!>Ss=`cP5=yy3Z?Rs^?_=o;)~Jk3sQtnRbGv_Tu^DDlc~EZY>7X;Tlk*E zKr-URee^0sdq!+BA2V8dKZJ5tbJZ<eV4L)SpY))c{7am1!Jcu^$-0isy8dX=%3#u3WzuSA z+)CPOzdT^i)BBC5-`@9M+tgp=oQy6@n12>?mcCS)*FUgTw;QMSI|g1vRjGZcGQRCxq~?7g?t1x@$DzkGr4x{r=e`B7DDFs`?w;E!#0@Ff;lYT zX`qf><%kFHYkQdCj(3dZ@LvIYy4bAeJ#LmdqXj(%-Ce8J5pmo*teNdS(%8%gdMtgj z6t)Y2CM8HFfURAj=bg4;{)o9#iZ49e{iSH>#31fB*z5P6(V@5y$(GeG#R=Tne`~H! zxii}+@v#c5pNqhr9A^BQ9tcKjj80GV?GjUe)-1d(sWt|Xb6RZI-et9*tXh0s&i zea(hf=qs-ZN;!JoJOHF=@0vi{n+z(J znl=2vT<)Xly35AZuievsS;af|_KAW~uQxEZ^dXdWceK&g+pM6Wb z=yYq*DkPAT=@{}Dy-|rq2{?GQ&S@43%pJL>(=*`gy4M~^cOx) zq{+XZv_fRpsHTLexj2@&l3<6N&Pj*fJIo}R2QbkoH6bwL)1Yglu_zdLyI8w}&^|I+ zE~K@jusKs?>Y-*%P@lM4j6VFWk`=)oy>)Ai3l3eUyVT_QhxD)z6uT+}%CL|+&8N#> zixLML`2#keB+RR~f|$Oz!|$KN?gkk6`Jc2M2}l9ZV@V4#JSQcV}2{q`GB&W1saX#4Aap@z%ws zD}8?p-e%z)C864PB8!5-5=JX+xNHZT**RV5pt1F=oUY^fu}&%hZ{^}-PdkrW5?Pw7 z*7JkSM5V3n^8S~D9lXh;CyOMf=CUr+?{=>_0 zvG$9TluiMGL+(=b%Us5k^#rAM-zN3Ta^U#IjM7#Y@D|0Krj9wME9m^79W>U-BH%rA zaf;<7&l>Df~?=3Q}v{iL-Ae52QMFSf1jUa73;L`E5`XB~Moumnz z#H<)aG>1R=-BpYBQmoQ(CMXq?BquC@%q={fvo^A&f3J!oaq?G#{)Z6>zUYQ^$ta##! zC6gC7pwi9VdEjCxv{c9w_B-N<*;uuxt6R0RX_XjQFX5$9>=iKpS$t-m^MmST>tOrl zY7s>G6#qn#_c8gSkJRnnX$k!Lru>n<_?Wo(NN0PXJS7}5B|KnqK!8%^l)!bRXy&XF z#kPQF`OtoE-O%FEtZEw5`Z9hG_IlT-Jyx8*qkph&3COgZs^TDs;jeNkCCMqu%X|Q# zzt|K601ETskT}eVEZFW#8`K_&YhIU5yID@U6#?Vv4@kL^EKQ#m|mS*kzYG(laRIlkRj*}j*2 zSBJ-Dq{zfng+A-G`i-h-$>#)ov{@C`3N!g-9V7eOfIqeqzqY2))c-=}ZQ}w)Q#7@@ znbX5mL${$p?U+#xt# z21$c$%NeY%fO#McMP{Vz&bn~*aIe({_ogRsK=DbmtWT~U&#~+#cv=qUXbCQg*$84w zToj%YTQ0i4aROh0<$Yhp1WKX^ht6*Z6!Rl>NbYkkQa5XucbMj^F%&Jw@9rNS&h6o& zgnpH#rnX5-c%VKBh<69}_$YoyV&TYC6tl08QXfOM78Rd^|FpQFy(U~ zdPM}4FujgOpQD+DB$YgHsMhI9x#9IzuSS}Fd`p1xziCbXt$jajnYB@=nO(>&D*0UM#jc;CctKE;pQ_LvR@U|+ zPIqF2*^88Xt7P!3&dHz3-#;!-CZ9x4%0%%65{UuL&L$^W36pn;BUV{h6ZH%4p8@M4 zsVuO%!T_>@JS3E!k8=ludfzK3tyrRAvRR90Bwvb*pcj7q6dC@}jw#+#geGT51MTE;1qY0JIREWp0c_6?Cyb9J zbS5YSCDti{~WoEnLXlJ$zop=w`0=0*&+mVIIO@czE1YU$? z(OvRI;{D9Jfft43f9@ir#DVd@HT?p9RyJap4xcf^*#djI`aXyBs_A|4Hx={tu@4+H_1~l*5R!{$iw!jW)4PCv`*X1G0%_Q%2^hX2i>4u_$-E*b z=c`s!1}@`$Bl$OtotxksY;&@4M`*yQ8}X|!`uUfX$nwzry$l;OJ@$b5!|pMck0{dd z6I4JQ+vQTY;XGJ7I6vDlugC6Jod}-m9H&2+hv1J`k7Uv@ycFChU1Yzy#-RJIWeR&h z+1weqqMJSZ`L##8b=cN>nADGA5m6%}na8iCC#quFkI^AVg!iokm>X3cB^GyJCZBcL zA4^~s@-Iv+hLD&}chK5Co<9fIdTj4`UIeC#NQo6{+1*xB1PKX(=Yv& zs2)$Q!g+)a-ePuX`k+WJbFN4(D-=dIRKY{1JS#W$XzF9|b9Tu`B*bZcecMWf`lHwN zZYRk8=+XkmFZ8)7-i7D5`7a6_ga6Ads*?`p3W0v$fxpsK)-N7(KcLS-&&Zb8%=(7pZ=k6+&2R5>m zDPvWFK#1_;(bR`8&hW-OdFte0Fw7+D>_MpQy2)^gKsGJ$g3&XIP zR?;&lPjJHWmRk&VwkY)pJJU?G73h#W`dQ4XR62?)*r!s}GtnvjlPo?XjRqk@10AvW z(5nM|NozvRY7mFT7P@YdTp-pKnJNW^v7)Ckvv2Ir*gLBr!=^RFBBw44-TR${O%dQ( ziVO3Eb?ckdD9A2W<7r*OcIEIP+;2~_@GII09gX22bj;xU0@#3l&r?=Qh&3l+$#HD? zI9RR4jkywAeV|F4i&GaUmBB8DzNng-HZ2v}58UgiYDr>ct}R#XSSVSba;c%f7(~*P zqb~oZ|BWux^`-w1Z5-k(Nw#bJn!M=T^>%2Kv-&8SI2Isxp;JCyCX-H|rLhbKyUIQ+ z7gMsTVq@Qhu@JvtM9-N&lyJI)R@I^;r}M);{8q!$L+xX6uc)ciaw}7>2om+*th^jm zy-JC6MdIM=9%UE~c80;^!Y{; zWvxvNBP$idWo8)V`vba+YI|a5DYNNlhTyn?8NcD2YQ#u}_^tU( zBTq`%>*#pkt9$0V2XLs(kxT{QBJ} znGY@O#s9ZJ5);DgNU^U9%Ua8oJX3|xTgYnsNJ5cza)PC7>sn|`A zKiF6C{#|K5@3vd48;AG@8nKi0r%dTxws~veNtW%O16e0iA1=|S@odIZ+;IFIX6PF< z{|7Vw*5VV5>7g0;sSNC8v@dOO1~vDhvM)V&Jpi-HEfyZjB}}cSTWGQTG~$N|SS>tU zcp_UJN3YS3{UOnbXv4!F79HmoOPVqeTF51~Pl_=1SZJ04#;du3YUI*t9=7r8$rdzh zrndIeX#G5%N$kIx+cjD%&OMQ|J62k^bCD#Ofh6t1hNaD`^qc89g=3f;G;g6>;D;TW zTu+4bTBO45HLVvTY+4AmnQ#}QwL*r&&F$i>rxu@>S2I}viUiwqdNdJBVzE~VHI{R> zb5Hs9OgJ@E1f&Ty7KJVP`|F_&4mE{~r8f?))dtO4)^AXJt#Zv;c3nnsIrIQxf^GVd zrKlzTSf@m@GfBIU;qCMq#li==Sf{iakmMOs?BjTvbaSiqo6zbh22q5fG;Ota~S{owM4Om_?Q8v%@I4)3Y6lK(u`CZQyr!RVT{J1}p} z0V#6%jB3S!J+@fwTp)EA#MyplZji9nuCtAQ=h~ij76#QU z8iwtOc?odR{e-3X^;e=omi!k*I|I};54lK9Y%p#83@nt zzu~Gd3Pv!;uTN5ZLQd9ASz;(_Rk89(0bft2sX}@}vL71&4^HMl(;=gOfWOE-I{i}@ zgpi@FP@%10(a2`Kbw?%(PEjh^)yqrIypf`{Q&5SkK*6mBqRUlbh|ByF;LN+gI%+^G7y8CL z85$U2#g@N*m`-$&VUN28z;@C}VX%o|a$2|c9RfY1|9qr9nEMUD3fk#9B#rLPEG%A2 zN&jH!cXpVZ=&e1MJBP4nB=&$hf?GA0FqIf3y8#B&X#{wkzRflj!u6Ycbkx-Ok25h^>Mq73th1tTM< zy*ZErpdc944vo}M=L_fcL;nkoNMr>+gh}g3urd6-qA!!@LWG2~b#O^Ho|y!O$*y*BYR2?e#XNw9%7$J2!IH#OFmeWv?qVkTQ>#>{uW7KP7fQ$0-}}1^g9p3 zAs@PDD;9e)2lTjj7jG%m{z4i#CnMAgMoexrznuB%#gGp`Rt|H@?UE7AA^O7%1$ zUe^nGtFY`>B@*;thsO!@5}x|eBkX_=J^KZQ^B2iV11>|yEEjVy?xc_(XDXAE>ER_> z*)*ly4aAiyG37YkTnh{Mz{M(JU!%mk)KiubzMM*kuqTeky% zeX{q>VQBP)1D$g~;hF(ng=PV+Q4^)#`{S|Z{7fTHLc<_|A$i2mKu{1~isd!~gN2*M zPQ#FY-bmyYM^VftG>v$IC@Qgt2ZoSTj1+noMSMH?4t_hO9kvph${iy9RXu>UVHFip@Qen zLlw-&TXo&p;0yMJ!pjWNty?EI>_;zKbT>;uyrY3@XIF+Y8N?(@C3D~d@bPn16$#O#9 z!TK*OCl0GC#bxh5b^ijV?hf(TWUuzxk|sj{PJp0`2#i^#ck9~{M-_187=FMhKx;)d z8YMOw6*e5yA8^WKa2|w>Ca!hQY+=aLPOlnYY54B%WD!U6c)Sw9D`8ugoB zo!{)J7QXmy<(G?JH_K0pAi!hm7c1D0X1Fg+ct4vDkk3bLKKdWbsdV5me~kS>kFiZe z!x6}y7No{>*AlR1I1i!bzW)2<6}rL!_gBcd0q)A+ZJR7m4cjgkW}7O&KcJ~k$h|kB zr(Oc>j5`;xVMdggbMiaX!Gqgc3>f!J@3NcVm?uok!{&%e?#&w4$84QL4zfh*WEZdU zatbY$1`}eUDW2iQEO*-%L5EI=73y0}doQdu9k~N{V40JcU039qxrK@t_JyAk5Qsnk&(GaG4*s=wNnGYN9i;gEZnA$ z<$FGl3fB4ip&XgGy`|du7U6Zj$MHNXT03H~X|JPr+I&Im^cFj{?AG)+IK>#?e2~D0YJuyMF7P(6y&N z>z#nLn$WeHpKHjPt^b;B@Y>S=0sEkJ>z7^DB~nUympRDy(VXeKN#*W0QDKikR+viI zZB(JI@~zG84FCsE_{L91VKBFV!9f=IW((#WqYl&`z^7eVg_lxLrCWOo>bSDQ|KeDy zU^Y3|JBFSWArBN#NW|hF$dvFy0|ngS`M6$I|JaP<2S9|~Y{HCViPV{*jzvZO*KMt` z+U!HYANk|+fyTwOM4eD3<{u2IQt_BI_VcO0$~k%n{V80GIa!Q(pCvOvn)tS4zrp@# zgj6hM&FF^}MOwXZog(X}zrdJFl(@(~tQ6$#32qcSzW>pEZn5@$Yh~$dT{t(MkX@S) zDjYTncrLm5S8k5Q7i)NqnZt#@2$2 zLtN)jParhWUvYanug+Y!iNk+cUgp^yS}w^dJ*Ab8l7!!qH?E3XBco(8_F6MyW@@%Z z)V6LFRCzkWvct~wTGjAMh5!ZTMkDOGC3K-n7&U+^F@eT*~gF?WqEvorImv+#V+`1k!)MQYtpSTn&r zpnou=?;{y#haHke5vaEaL>DGtKopCx&I4k&NMks~F)cx%bE(bNAFCuL-H0o#`E3eWIJw&#fu(`E%+Jw=U7`m+4*2&yD(;`LG#7w>afcyME(A zbdKiAF^Pl3eIRRK-!Thw|H-U$J3qyfe@vnq@P|P)Dc$|}Lzc=-@GR4)a3f%TT(4f_ zPS5B4O@2;k#x0R_q+)T*ql2f{bGsc~M=vmyv9uGAsU4t3pURzSz2|vHe zj?|8V*&|MKyff^Y^^g@~l=hk+$4xNeq>%fxYn7jzCG3sovq^BsC!@l7NUEeLV|?R> z^z}7$c-itp!6Hl6$%t>jH!YnXR;A+od4A*X!%v9j1UkFi)1hmi(QXgy1}Rm$y0mJ( zsU)KYwgWqF=Lk?La!(58W*}9|PYz}et?EPEgD_YR)=<(MQuH`Ox7`*Dcf2H$vW9)) zjEcq)sT}cFM&WJgBDfiLFeEgW-wh#Pv#joGf=AIG#qVdv=#t~Buu}vqL-&j~R^ZD1bTN2pP z=Getz&??FzEVoHmYn5YUmE=rDx}-LwwMypLwPKbl%ETU7OziU03hs^G%Vt7}jIfOEwEO%d-uz$Yg`Cm9oGb30>26DJpI z=l@is{g38&&1zcz5Mlk2#ZF|yB`Ds60xgjtv?wT;O*Mo{-6lx~Qq)AfWs)I3Yf8#U zm!=wqE+pE%X1@uQ>p4ZzQ+Bt1Ew*a^5aesqzG7z1AXzAe(~08Ap5%Mq_<3jh93Rg3 z*?mLhqwl;Zgn8og04?`TBBZ0E50?{Fo}E@?cu-a_yMvpkEXOe|h7m9LvgFT!_xh7T zz|d;a;nJQmXX2qYIi$*;;3+wc(0=0XOHsU8BAo$$mtT~8zVVISOI$#YFkzT7I%s|i;K@Nvy z7Y2eo#xrAevqY?A2xbVIy&P?3sSxO#AfUK_S<^UyW)p*MQ01TiYC~zL%t}}QLCyyt zKM@8R!$6!yQ1#!1LdAG*45L$el|W~~DPvShJrAk7(L3ZszOw1ugga1CeCCwXrdadF z#ouycmCgd#s>aZaFf{j}81ToySMpe1u)KgDC0dRV%XvkcKz#7cXu zSZki|UY@R)wPC5Y;JWNgXLY$d?{;60!@1)-1%gs1nIT=9dy?86XWlD(aG2vn?;QfCjauo`F?gQf}Dn|Dmb9Re0uTVr~5TH@uu8sex`7 zsI4y#WfC7Hfy3my5WmP>)j#kR;8^ko2wfYgPJfE-e(e{KanFYoEH}BttxAo%N*|6Q zV6nsv7AhJU zzJ+`kc=;oi5a4Lcvb+EeISep7k)S4ycZO=)+*8fY-n}=p+$a5w%hrHqsMXCve#Tzu zQbOh^!?d14c8EVfcQSiEDmE;8mW)zMmaFtG2`7h%(r)4ci{}`D`VPZTAcv8BZt)XM zDUGI|(u_|rPE!j5jzxED3|Y~}D%|D(uS?t7-*$ykbw6lamlxQCr1vihN;lM$sK9Q~ z0NgcO7RAn#Ra;@^;pPzC8w1ay#{yVkh&ecCgwZ-go3ioQST+;U4e9zO{Y)YZA}{y@ zL{GRhrg*AJfNnub;O|*KkRq%5IpUeAk)p-iK_j>H7$2ToytK7bYASTlPtgEkY_A9p zcG2d%hB@K-XQZY)L+pHOoKkC;?MLhEvL^=~hp;t{p@WF_sgY07qeA_13VUOt@N{@3 z<)Y*m#siWEg&|>O`684_6j7(v##`gQnOfYcx96l_qwXC3z11aroFl)E>W}VpLO%lM zc~Z|pD$iw7&uXenx^2r->K*RcAeA|bw9`SAIVZX~UX{6rGY!`Rq&IGG4sC}6w0`KT zK3tXlNbZ~1BYiGiOyOT4VxJyd0~(3EL8LrpF}bbc^qNI!4xqIfMJtzcTFa+8U2$>M zbE8kE%ve6McprzK(B2`~=CA*)lHtE9p=1AiuyZt{cX2kfbEY?OH?Xm{HgTf=A>~@w znmPSnQs@f|_CYs4s;n(Ps;mtE^HgyYTN6hMqyId1oc`n7Nl~1%T@XOwMLw~>S?{oL zM=@8_mDQ|^S5Kfos)Q1XJS9>f?Z|2?GEQ8C^Hsi)vtBJmlJEw=4{1B#V1Y;59p21v zy5c?A#{B+xyae}8b1x+Zr44HefN6lq680UxWORFflC-19jwjqmu7S~l$yDK1Ir9Jp zJ%xFlJrC}2eup8gTJEXIE{NfQ2~B37cR0Az+o%4Uk zy=6qIA;xNM#F2t=nYrFjSiKk0^4>>Js)x8BScbf49YF1Ijz!iUWozQGWlSGEaM}Y; z0qjLd(cg~=t{US8yE04@%zMv^#&AXBPS*kQU@ng9a_X;}ORaIo*LeuuIqGI4G~IA| zc}ad(%t2-;Da6wQ%i>L5r}^wJYz?$_k~BGN5oa-Z?Tj zOcGosl89+{@j;K!|F|1cpT4ScsbAiCc#K7Vjddqhaj_`rJ*fmx>G(!jEDNZ}i(B?` z_LNCbm|Cpu>lu0Q(QITa-vj(TLIdbkE?-SY_>Pj{se+{DXoiv!@jqM74;@_Iz~VpkdqWg-=z#@Mcw2wl z{uWiKn0YHjy@+a!1Q%klh)0MRwcxfizGUmvx^0vwmXY`X;FsE5V}n3Un%c}@KFRhn zyV`iar}nq0&Il*8B`_#}mlS#v+l1Uev>oKD*dEiAkhr2y3+W7YFK{;?5FPVL_#>p( z9@Cxb_;;S&fM7cgP#p}67RDgG?(`M56IHc)HuZVG=8WIvfN&fK+ zg#C38An_z%u&`0VtZg!hk{IbzLm8025DTt;)wj4nw-L~-qUjyX6TB@hx3n}jw_I!d zetNwqY<^nmDZ5sw5)PdtKJ`PN<7wB~PnFQ~Gve$ef(ZUeP-Da{JXkhkj_-#>sVP;Ys3ulGA zyr3S9Zr-Z8(z(u$OvNybs3eq=aMg^#Rk5PIN^vQtMPPolMYC+BzDtLfC$NufW;m-~ zYgCu=QNAU+Oev*N{x6A(i-_QZFMSTO@=Y3%b5p-2X8SXFf=y)e%1g&N<;>%JEY)_j zbrSZLu!Ddv0cCjy8856OS}y|;-v`a7Yz_y1d~)qY0cKohGGr^1=M1zb-tJIPL zVlb}M#c}$`1EZ1c_G0XW^A+RT;}I$k9)I*uc$3&Hrjqinya`Gqw}EK=_#U^ z=FaRzB8e%-c}|SX*BeFloL?u9jv~N8gnn`Yvz(X;6XDzA)#(pR>^=coqmds_!s(v)Pg{)1>g69}Rk46I4YnbqLp|lo0 z4#b5ZvipTH&H+JmhX?48R5;X~z2vs(O{~9f(&Bdnx4fIg<#R0tk0n_CjB+jDLCfa_ zy}hm;Gtw<0MFazVG2mZFdD&ChI4r0_^}}s^6cqGL@Ch!+BGyjOADz`@5wSp+!G|84 zr~6N#Twa7JkinefIYK#JWXO2ykI8J9cjjLps3s1j*7LeD)zjx@VrZ2|z-u3uZaH&? zyBLv5R)-L7PY(5voJK2=l7Z=99Z9k4h^jS~-76+)lMDONCUssdwow{MIBo5gVxLV0 zZf=bjCK{&&*&-?11ahN5J-iD~&wUjH2ykq-6p=Gvz>5vYc4*8Rvx%XU-h&x!Un&5o zojiIW;(y6cVaK_5qPtsh;QGca?5%+Qa8*giFWjgdwQ^P@TZyHtbeiHq+gUDV5SGrf zoyifNywE*6`&|Q)uEflj0xFW=Ch*a)`8iJG^AnTSo*o^x+S1NPx*q_dUh?xh7HH7D z+alnP+fT6{WWaqUWyDVn1Wgjm{RZW`xRLB`;K8uLhu9c?larCc7N_2rjS-Z?D1)|wzavJsciS2}R9$)4boHWWA`I;WsqFq|B z^A5JJFz&`ZTf+@;oO`dx>=d2sD)+CxP4~MKuuLo#bhqtUH~eH*E^`;v7I6^LFhqK5;@v zy->4v4?Hq(vn|^A|1H)VcNbd&Mw z(45fnJt^IBqO1ewEJo1%N7J4X{Es=AYlcpTUt- z?l{T6>6|@&6#P-|-YJ;4!hi4>#~9=WN!U#oo*Xx-M?zPJ!YGg>Fh~bHc(Mf^Ey;wcW*epG|~r>0D!DV{?9CtoUlH&{uwf zeQa|LFJ1^pH!B;^GJ}Zy_Y88#P*x#2jn9vP1!b82zyQ5hDcRuEHPR7=mrj9_jBALb z^(L}Xq>2p%J`}6inK1*EE3lqJEm+2ar<~X$u$9$eBO4r4GXS8{S)2h!osnf0H@xQ7 zEv#<;Ed1d``21szptnlY%G(K{+8ehlhc&a!AR^f717T`@bl*d^1=}~$At}f1!uUk` z;p(PpW-nymM@lcc^qv}mJ3LR`MlQ@h-yz4rZ)W-EOR&T;x4wiGNz4c%R`|T4EM-AZ zO23hOj-wXFjUY-yB`pQq!PW<|5K+-h{r5&J9hHij;M7zIl+K7e-~M zi#^0wuwhRHsR46eq2|P#eF{f&{xNdb-?eS(=ewXRZWZR7W#><#(ow^8v6IR4FAk{zw?)tgWAqV{d0$%P~3}}beElv!xIB??ozE^^Pr^Xq?Eg<__3bAWoes`l_O+3{3 zXos1JQsTrMq3W^>p|TvSovsw&*`~OOgYFB34}mTL<}mMTVQqeMY-3l@Vnz;h+?y5P z`69Kqi7}hlD))i<)|7V4ZW4I;WUX1~^$xK3%(W(uLnCkF>15zNAOze%23Ht}05B$^ zBdO&%2{Wn9)A2Mq=&9QiL_qd!j6yu8U*SGow42mXE%}+wLrn5PhA9@~eZDp{_^S{7 zu{jaEj*MfmDKYkmYVi#3FBu=^hodyUQ(|qfV!%HAxYK*vvTZg9fv6bNQ>N2T5VoxH zMEvb74Yl-WW3!2+?{xs>F@yPuQxlL>XYvvo@A;6BSbb}-R6GhuTJ7h^O&3k(Ii@*{ zq7ETompDrhaAW4&G9`q+o9V|?dIem3Omi*~St;2b?T=wWc@qKz`86vL0cUJJ=Df;D_e4vO6-XdL-ow9E4Odw)Ho|*AX(yjUyaf#6k;s14;zp_6F){<#~}y zsI(ay4#O&5NnVslAsI34VBL{F)-2x?kmB?cNlSMv(xOE7VR*Jiz!+7e2Ps5gee&V* zW_I`((fCATW5g*p*rjT?KCnwR6HpXM6O&g~Yb0)~Ri)E<(V_57H3+oHO)2iu_H#^X z?mxpvsL}A?PlMzT?D4YKk*r6st+jI-9=KGq+>*;PI=vEk zEIdaxPK+PPwpXmk0&b0FDO#jIoMnm?i8e=LA6P2NA}(va=2(Y5r{TCy@golD{P?8M%+!*{^diYZ)yBh+|RZLveEYCU zdy{mFkkNo8$2WP#i$Syu$@ss4MJ#pY`?3uxI29a)86E(TbHD9-HV9rW_4%?1fiYS8 zAj32YlxVdtIF1}m)G1XdbF%~!EF3+%os;*cw=cB%mfq{0_fTra!kpnb@Paq+nH(O? zYw)I*NdJg$GdoO&Q4U+qWr!`{7Bx{Pm5vENAh3Lbz4)FdXObE5Rh(hfv%${r7CDQO zv9 zBcQxq2zU$&R(eG~*+@Si>j`2j@JZ=CZU#z%%GokwMHM-ZHXfmdjb*KR5Y*q(H7{&_ zZYEuc|CW!S$)DMK^{EVFXgu{u4#&?*#+sFaJ&o1>Dd<+Gtm=W9uwK+~0w+o^2=smy z3Vv6e5@77``-D*i5zg_Bo!>J)#8&KrX!C`W&=ZPy16^;>lcFreZfZi&-9qtHQ5yR$ z*(7Ci2#$mv3Xy^ej;66Z@SaH;^h~cF)hM0Fd-*9$<^V^!&M$eiYINN7`6>!UeA zV%s1csI5v&upv{%0RW%rt&m{f4NyHnm^SRYiJtv=_~(;ovIC z;_|n{-)@jhCRlhn*fH(m!U*%t@Cq`%0>|jNT_Buy3nk1r8CQ5)F#z>eWFY?R3Ddo( z75LyqzB_1^KNv<+x=v7`N!Y3M_^sLnWv~+M9ewu^5Yh9h${6Y!P>e5C?BWphKv4)j zFGRg{bjd`+yMcfYb>z zwhap0T~YLN!4hmyhYd1l(=T`PT8iRx5ylB4$}OsiQ#u8@1Z^9Dq6BXNlXgp#6TmB> zK8IEaBU8W~8=}Ar)J^bV0>}KAO!KHV6lU&b`M7Yy<9OBbLYyJBDv_`;rHpYcC(YHjxi?QaY^CZ)Vxw z~^G)^sYMe8(TwM`Ji0HX)UuKCL<29^`V3qdf&$Xgo2chDrA92(NMJuAS1Z&nl)!49 z3Q&5w3`0+r6g+Lx8`|e*FeJO~SdQ+3zqa7q=um!DV0=D`upsF==Z!yqg)|C$=19#6z9sy` zbPn+qEAwbb`WCH%@YlN%DMzt<4UCp{5#?tTxlgVg%_HYX@mMi^stNLpHH!nUl-3Br z<)MysCpaP_VM~{~nU}&%FA{3p%9z*wIgC=l>Ey`jfqB&Z^*T%VL5AGPqLTJyd`G$! z{SE2$@>Dn5XwVK%ddsST#3|U@RT!HGUClgE4WBse3i5l@4t;f^nrC&=+T;m*+#oE7 zGZBsr_Y$z+O+)_7QT}Npg0}8MHP{wH72jWn7-CJ(Qh>_{a)#O63KE?Pl9mNuGSw?t zs1jAJ4!kd`aySKsEzu;Q4T>2%@rc8L)zsC(AF2Vb%z>e=OgXqLJDQ!0Nxx=JQ?C}m zT7SoWdoW^rR4*D0bKUEULCWshEXOC8KW4soFA0UUVHu&z3|oH-kkoCU+pRx|E~qdq zYu9def)!(eQm?*Un~pfPcFFL!vP1M;7a+s8#*&$qC5WCup`YS)cKEKg|Ow#L~wL^Cyp4wV%;0D!3fiakInI=p2yxDk<$|k^z zZSd;*Y}hskKI0A*HOm1ME;Q;s*p^j6=cITTsVz!GoF9Azi@aL{NZm!=iDuOAF|`!8 z#(EE^2Jgo&-s3gavF0_Z?@IW^*Y_ zvj1avi%zHoHnIy-5tniKA2rOhbw;tLz|#{#^=MIKT-@IrmWX0&DX@{+WnM`)3{ zaeJbzF_1j)z!8~)5814n*ecK|k?I^0yCzJ$kAo)6Mhr+&!B=+nh{RAAwKK~ zd-%ege)S#Vt7z6x(W<2+Mwzu%-6@cfHj$Cipp_FjYX`Z+G>DJ}J&qe{Os*<?p;|s7HOpZ(11p0y zCF_d~^A_iG#{&+e0q)htQ|k$acSj<;v%U_UlR=y}$3JS0dBPfWhuT|G1t-mALo-$n z`-ntroCY)$2uUm#?o9y-We-;5v?lLZfz;N6obm9%1aysL@tUvs2Mj zB)p(2Rkm2vu<4v!Be_vCIiY6I=uyQy%dj-C#LyfFv&rrhSv*u!YD{c771&3=K#8_k zH{GN%@Bez`BH|0S#qXcOCsyPWEakG@SFYqt$>hr*uHt?*G6?wc?A5(}K#6n^AdtJe zi$;koOtwo}J)A&F&N5+i;5;kR*^e@&D+R9*VB}Qu3H;qODOVR#SnO2PET8OZ+k_ek zne(HIsG#tpzLC1{pu>u&Ahb#ChWkeT@2T0JY%IV}R{ftZyr1j;8`E(ya&~e2fp>ua zTVnT6cFJ@I1OPx0;(toa|7*5{iGlrpz&Rl*J4(oEC|{{tG7{RpFT@mN$%adzs1ndn z%^;O3)gmG`DBwAN>PW2AVI?!IlUr(^_-`usN8sqYn&AIX{Ap5p+wO6F%X2PWuxQ?C z?*#h`oiWb)ob7eZx%2v`-ObPE_5jU4>4hVf?Nk8+OT%SD#HLsmxE zc}Zi^E3Xr)NrQ98qTm-?YpuNo+ECld03V|m)%21{E8cK`PPd**R|n2zy*)x0OL`vL z7FiKaCvWR}|2PF4^MGqd<57c_7+w74 z{TtU~hjO#?Vo?{gf)$&3>NfWsliglvQ|JC%w!im6#auVVL2izAQKxKAH&MovD=o>m zqms4tN`f#@`Lya{n^4bmi~6^`r5og~>|n2^4a7o9Vdm+VrOk7(GBJX5&w4fbCUmYq zjHEB|JURx!s7)6c*tfOYSS@w(yU_TbgH<@0EBH~RMKpJ*BJTxXxaq4{e&NOCyaM4+ z+YR5y)0x$8m-a~(dGIR z@&`IT@jG*z?3siC21%R38 z{&q^X%~xc~J#YdXEvm91lYRQV*L-RrhA)!H7q?n=Tj$AsVHJTqRn;y(G|9wi01F;0SM`FPA8bi zKqs7;sz3ZgL}VHx3&splICpJB;0AbkyHKh2sG!?vkdK$FOP?7k>_-T0CmahNuA$^K z!xHr=9uDHixY}L;k}?aP--=?sAVN@;e?b8g1+ng>Kq!w>F#hy@oob7tu)9a0k9|$6 zs?Ca0yC$;px`!vWRnOj?OCPF*s~U;zU$6hSUe+B3x_r7nK6dE``=L2K`|Yf?&(D($IRN-u0b!tV7)37AcvFVh z*YpkGtEUUKOQX32m^1O%^RZDF$;Rag!YFO9%vg<6m{#6iv#^FsNv-UgJ#zve?s(tT zgaWyZ(u1pC+a8k)$kNvP* z5Qaou@=IZw8X+C&dBAOLRkBJbEz?b7nP$gP>w*ch*~7ni@+TS&UD*pld&WH)?N7eo z1`Jwz>Ak&}C2()u*bkCN&2ky$V9sr;{u3WJpXrTqF!N@38Y8M5e+9XwoRkk-Xl%0s z{Tb_iRX+6rI+|(;jm>flg6o~g$0bm1#@E8)rKzO-QVkMHEY7>6KckH}Dy?5-R9`e-{|E8!AKywZuDrjwc z_CIOo{_8ORm!1Awd0>q4j@^PP1}}T;C7XjVrR3xUg^gOuhy9IIN2($ih-!-%tgv%s z`fAj5Za;#E;Mcn%@_qB!M%K#?WMP8ZAr?LzB-H0pg4aTKn$=kv1ylc1X*FSDo z_20hF?~wi~EKCxDa|vwuLdfafrub{B8&@sW^v`+ivIO~CcOAO+S^|`*PtMVhG(9^_ zTeh9FojT82L9rXKExFuR2D^_Pn5Xi}A~XFAFVt|s8T}s8XKnffae)HOC#}_jbvw{B z&+S{B)}208_%FcZ7%wncx^C=sIoBzJ_m%t4sii?;y*8rn$e zc$evY=|1*#X071WIdp7NUPvbm0i4|$PH3F*W)wfV5-NX*W*$bp1r_% zTy00sJK(`{d{(|Ew$mD9E+23@yUpHnz2ndq`dfAN`mhuRUf|f)S`Rv11wbAt6vbHD zFh+)`V?9ZMkPT*=;DyCHtVzYY-MVe7E=MZmB#=E5y+P*jH^C6Y?w#*Uczj0PxO&!p(m+q*;^)QR=iMK&0R(H)su0KJ1#DLe>tJdAAGZ2T0+B&D&=aPmIM*oWosQorkJlu}?$dA#B+! z%m4F1O3|*QoPWkqdypH885>yGMcUQ(S%CKfXz>N@zvd{)hS|~w$8^o2>2MyhY-0g~8fPknb;c5v_4W{|vas$wqUnGYRFsk~eYx3etyn;5WJ3ujeH_qtKoz7MUYbX(y(8vUeo> z(fhv;vR>D}hY@bTMq#1slSN=x5*m|5w)hYtR3e%9{9TsX=*!kQtkW#o~&J zX3M2ze(goNDIvE=?0!*7DrG3Tg$GR~L*iFNy@?QgMC}&C$elDag@idiZueFOfxYY+3eg)sUFLGXTD zJKO&ng8alEw#EjI#y_<<|GD!25sc(0ul=(KZ-FLup;$vxaamDl!L$HYnE+2wMTmfe zq?M=mZ)Z|;;D)t}wMgD8)E5yC;jRA=G7^3W#{tRoA4RPWr<2X2>~_4@liJ!H0G?r6 zj9)hvH{u8a@&vx7J?v4ijVkm#zq7|Hi4l0}G*g`@b|;TzS%X1Te~23OSi|ToHo91< zD{}~F>e!$#RW5W^pAsSjjFH)^ig+2gu++$)x@Bs211VVhKye$cIRR1|loRl#jSKNx zhAZ`3l?Ut2ld)@+8Lq#*K_OrCTC5Za#4J57*r@0E7^z{2B#U%dvCB$rDn0=oxUXr@ zF0sFVDI?APomUV?mN1LCWp>L^w8bJ&8Jvun5mQW>pyL*H$*9-_HhM7FZo<(>b3KcP zEnHONJ>dX%@m#BHl`c{0OJ8Q|9dFtdRTjj{6amUQ@QILimiN+4DV2(z-kl*&@KAv$->*nr+R*Z{j z#eUpoMQJPaPJxe5{%ldva}GX4xNgA-Vr4A$toaYBF{^<~o@qRavXj+z#8~pS1tvYA zgxK#=E=1^dy7h?i`XCSR%rl1#a&6>9aA8P5Bgi{>|5&UJk7h-)#FU(Kb9!SWi9fMQl-mE4{VMWp!N>O%LSx)nqMk_3j2C*!l-kkR0HqI1(a7@bF# zV7Uc;DTr=d`9(+zNZ-EJzV`Zk%-_!M=l2D6187I3?tf6YYk(*^aF_8y6)1nIV86(p z1T0K(Me%!zJaEDCS&9O2tgRdYYo&XXOu_TPqk5n~nu=nuey<>mR5^oSU;QtkLFZD= zlJmM#3C;rL9^yeS>&CbZ*+j8YIC!r$_?C!E^qwk@0E~YZ3HQ2RruPPB_xfi_+ zGe)l{0-ht9-6ZRyOVm?va%lIF`gByEYWoK=SoL8iK1i$bll@EWi^a`r=J^rW3g(oW z15vuI6WjCA?~uDRY94nt$l8{vJ)~xhWy_JwmuIKc=}h+wO!ttO>^DXwL*JxhSP&UR z7E$Z%xYaK3Tdwn+H}HQqlPP4+^5vh^Hu+g?+W%>_mH%NZLXHNuM&>_7hX1+ji8G1| z@+c#{8>ywR1(1~aipn4%Ek&k9)Hvu|2bHIV(&!hqLS)_Yw&{nwaNO!ZdhVbgzr=0 zg}P14pTU#RG-0II>guig9qIz%27NP0`?W(Vp!VfHJ`B-L0``R}cO^#IG1KOh$AYKs zoO4AP2Q~c|-X^iCqI2P!exK;0@(B~8-$fgA_okOlsuwYlm~_j?jZNc1V)o|cg*mtm z4PtJ+6tV0#Le2#9rKQ2LqH+%EKjb~)A&{)-LX*m~3;7DgejfA(r&6Ri8;-(I8x0pV z3i}$Qqq*9$G{+|qNGc(%8ZE@S38}4gL;BUIxP$N#e$obj8(F2?A@}GU)6BL*XPnX=1@3O%VTdgq z!{m>)D(6h|7iZ8GG$&R58or75q4PW6Hc>0CT8U0l#rFP92N;mc~Oy{ z#$<&4+RklL9MOC(i-@7%-cr9x!F~-CR}_7ZgZuPj;(q{sQH;7I8uhUW*TbKrHuiKs zPssXxe%&JXfwi!b#7_~G5XVFd>`i@`W6>^HVAY8MXx1!t6kSSu@Zuh{(KF0LEX{PA zf*@c}KUY$XDn1L07B7~px7-WjNuQ;UL<>j;Y-{?CI=$5gBAqx-O}^b3v`qLf26#+bN7;s*h1 zgE)uWmIo-f3g+hHgd!s6jWTLE>nIRQs_HGw-VA&xlSm=1P+p= z+h$d4+qP|0Y}Mi804?Ol_T$ zPW$eEG!U&nSWGIzGr$-7>OaVPtybU_v7?nz*XfkrCiN{GeN?iN@H#7RclnENjGn?R z+ckGNQ>#w*^Z8xcC>Ho$h7uwn2r#uxcV*fom&J1g`<5eV4v_|&1% z3UCSwGKAUSDz0u*3zOOku9JGV$xVYa!8sai>*&VK(HhD>{$a9A@kv|62JP{7$<20X zmEAi?mzV6UA^LM_y}xzm!1?Ag*nir$bm6u_B@h6cfB?w+|7zdLmVbmfkBr6a70qUsMzi2xV*5Ow*P*Yomm7eF~*?rB~h?o z<4sCOM_vsKu|#W$!JdFU6?L4(x8R?%b6~Xhe+U{{R0>(`Ht}9XG64+P4s(Lb6bi1F zObQhp#T+-gejC_CDWc{0wGFLdc*}rU&M}gdg)gUHr+DB(s<^|5NVlr7`*p<^3%6_* zLzT{(27U^%)el);Dvxl_Ls9*nmqpEIDloK1EuydIf$)Q;u!n2{*PG0BDotJFOcaH? zD#!1mY*#93FP{)z0G|(Aj{=Q_}*{to_1A`9kQJbg(&s@mA9J&eX6k7qyW zkD-^0w(WGJykcd-;*f&mj&w<+d7tRzY}t_J)^VBdod`Cii@&Z>(@r-9B^PuBP3}&e@}M%iW&g zJ-bzIJpJY7^Blr-9RnVGG4SC3rnLCa0O=n$-yiy-3WhEg|B83U<<jgnE)dWFJ`4LmGaZZ2as`!3uC{V)k1tEZS9N~~7lGq;RW*ztmOhAvZig_u$)tTUJE~mYh2M^YJD+)JNAhTd3;+OJ8HpPpmp#v@mQ9J<+A6& zUWc&**)EQRo$@qNPh3Q4tIwG`Xme=8QL*_pF*%2GKyZ64vVo zRkewU6};L+p*x83&}DO35R#qE-mFi$b(v^!9eMmaE?(VnZ6gk&X4H_DSI`|Z;XRr0 zmCMi70ahcPGguUL%bsRpn&~oj=i@SwhbNT(#Dcb0k+KP(NhkwNg5kenfxL?a@TRjd zbpG>_i%I-Py*YF%CWp&4heCFa@r%?GjhxbDh&D=^l!Qd-=cdRZ#~g+u%w@!T$g5T_ z$r80)sLLW`R=H%UV2MYj#?H(KU$fDdlZP{T5c^q2#lVBUdj&Dkd`IfuaiY{QCawsE z#Xe}2%_EVl2hh~5Bi?e@)6x|tKo%8yz%y~JSp5$$QdgtEILSg5EJQlQDgwTR@5J(> zD*`Z0Z*m?;TNroUq2^$GSpo#rqV06@HN#7{?MV+hv0ZGId$Gi4YOr% zfvitlC<%fBeV@z9cI0EmqT!8<$~`T*&8|^EaxIJp9Q@9qOl=`W?Z1|Gj!mjEK>kc96 z3Z3^B_OX%Z5nsVaqVsD*zRvlkfX;kjusAyHa6!l@dbi~#x2s?l*Uwn~MOInYQ~24_ zoEk9RXl;33P-x%qAN1sBx;WR#z*?&3>?;**3`5>iv_U$Qld$t6U61dviLHYDVzKsT zNDid694}s+U$Oj_lUuPav+ytvCv=N6#FKJ&F&)!;IPcQuah;!!qZuwM9j-tA(yBc* z6VHDE#z3V|ARsLN)h-l(7V*~rs3dvipMW7Lgc?X~u#{S&02^$>pshJTuuapXDhRwK z98qc6!PgpcDt(iCAi80cXzxBfE2vKYq$nN|6qGH#%D8&^xR}V0@%wnXg6m_6HG(Dr z2ucV*4ZwF}U7KrGe%I3U(r#0TWSiZ$M4<#EtO3zQ8a~PC_lLwJgRm2Y^l>4(dOZYgt;M2Q-AEqeIQqeKD2zd&eCxUZ(8G^{=L?%j^xHDt_QX6BvD+{A_)~c zzN7!25KFnbY^nluB~qZM!heU@KV0eGW38MdeffC>z(`(WtZg*Ow^&)g50HQwrengc z%qyXoE2I1|=!mOI+)29F7ENAYnIS8|0*J7}*m?6D5S)cWx?R7s-7jvuH*d=L{e53P zZG%9Gn&j^%s4@p-_w8ofjj=$bu5oU;OrPpe#d{yO$vw&l%;Hi)po5E~i!0`PX|BP9 z#jg2(ae^$nuM5|tVwtFF3xPnT+iKlV4k+EsU1-8lt^l8>$roYNPqeF|GM3Co_Hv97 z(9Bb7i3AdC3C3yEOxn*8UVc%XdKFmuw@keS;HMWHv=w;L?P=3O^Tf(Dj`raqc(;Im zt89z%2Gz{_fV0^uKl)7u1Oj^{3qZS`cD=^gRxB3h{o&k+!doKO`Y}quZ%6 zf~LwxAT0W}srDf#cFjoCnqJdjj!rQu5~V!7BW~HNO!*Hk(tX_n+BcY0Y!eLOZ4=oE z>uDT)2ND}~Pel=I-msc)k!ZH0g?v$|nSH;c&_XAWh(ubHj=t*oP0TF-ism?es-MmL z#5F!ctsow6n+VeD$FtHHvI?#p9RTMaWR1CU4!&?s-C383;j1Ap<1tj>Wy$pasTvNt z1UM0?o;L_;pZq=-j#5#Qs#O_b8WD=brJU~jn5Ju|*E?=2M{}P{JBLg;3m_YuluK;yY+_?3P_hJrULjTXF;j(kv%# z&xu`aLaQh1X-T$k^aC$J(IRzqWRgaIz*b*td^0@O(ryiTtPy$$4JtP=8nil&PQ)mx z=07J~boCam$_g*0RTE})XJ6aCuyZJU=nkl1P?zh4GR>}L7>!|rZ|hhZ!V%htWo0ZR z$Nd~6JtY||Fd=(m<_`gF$}d81yY!GHyCLXNW8SnXy#Sb@}*YU&7gB_bx$1qK|p zOE@vWmPH~VLh7|QUfVt*v%~2^X(V;k+qs*?>%b#xHG(^PZ21H zwFUtw{m|9MD%s$x`A{A#em`}uB54uJiu^r`m4)Z(k{O;Q%DUz(^)1K5GcTp4pQRkz zb&iBhZWtzBW#?b)sWbQsRCpqHg3Y?VMH@`=JTXK~_Y}+4e_i)DPUgS!0l`@AE78M} z!r4fP5{9Ngks(nFLb>@A{$wy@1Y$%ENI(+MK@cnd6pq^;t^~5H#tn@IpPv0q+!4I`;y`K`qKU@>~rq(A0 zGgwg#aL_IG5TFHSf-i7(<}y1FX7jrZV`vb0#`?>WX+eEDP+FZeL^#kO%q^ov1SSwvOE}CXtn_^I~i{ z@4%bqh!c3P9s+jp9zIDh^1E&&Y!dEg7v5@sVHV{8MJ#OV2EGRkLhD9{k`t6&)NU8= z8@}5Z}=U z0R3a$Bw{f?hz(Tsr2PoqV;9zH*ezg&5G=pbSdHg*$UFQIf%{(Es%+0xw3@DHxwpE;(=ksYcc`a44> z6Fq&2!b7)G$M&37%4%hEmQrgb1^)bV^M#Q}=7K z?YSRvdHp}$p1}+Vv>m~bqe+U1qr>~YtG{LGm7l0pUv|7MmUDq7kk7N^m$YOs;|d~j7sd%qAcO3lW%^dxXH(;XuAGhYGm&i=ASPMW zFJp`|2fzyFcHmdS4LGNkzKHUdg!VIBV4SHGD9UHf=KuOAnFMmKOz6l-s!^c%Ye##X;r%i;y@B>dH+JJ$Nwc1B5j*{h_j~fS%j@sf8&)=*sc9F7ZpMTH9P<}L zEyt(WM1fGU=R{3vY%wXIqWVzY7^#M8qN?XXhHxVO`n9S~;X5-ky>YO{Xhd~wx?*IJ z6mtQ39_{cn%UFa@xv+k%57m1A1P87D!=g#;G;=Wf50jkh)k_OGiOKLEPT_3cSly*; z{F0N&6N$-iYvKz^(25^{Z2EJODO6FmaY|CAoMb6%Mi-{7HOU;*nN?yZv>RvE@SQsL z;Rp0jKEEqiWUs_kQ*7JXCO`f&Aa&f?_74K){QJP5l;*$YcK;rX#>C6Y4+tQKZl%ae zi-Heb)D8jqEEv7!JeU=cVhETvTYmymyHed~erd*Zk4vb>qG;9!o~0D$ioFI6cEX)O5^N3H-Wuyyh z65-Qa2paT!Ss7tfv4o84kbBcEoLv3k%=q$o6rrYMP|S4Ae*8QJ9(`-iNNcM?!C>@# zx=wr_nZ;rt?|%Ec_JFHT9%2zj_mND!sAY8Bw3JN%)`UJ}pt_7>t{rAhAdt-+t}a!o zP?R1MsY$267KWfPgqjn`i68Y~b%zfveUclYgw6TtF;08{cNc){pI2Mw|ct!~R0RL5B8TC*Uo;_^F=>W+prU?$k zT!bCXilLxJyd%c`KaUd6N$U{@c#OV4R`q{R)0HjltpA#(rzHJDDkt|LW>Uu35EtK z1DRe|Uv4}$!lDL<4RY9y7Ue{aeHg>nMe6>J!tf9>pK2WSLO2E5I}L&K8s4VJgy>B$ zsMS8#MZbnh`~X#!s9WcVWDUO(UJO5c?XxOcVq6%GfS<*2ZhX>;xQhpAyd5zTb6IZD zqSJ08aUUC_Yq=V!+l8kag$tVp;p^12zTflU#&_&xxORqkR6GOkbzZj@s&k$+_|0QF zLeu_Tey_~MKLLE|PDp*ADAg)Occ%2@UO(7Gzf4qHbxvqS_*a8qSP)V8V5rWpV`E9C z=Wt2qWb&@7COT5Z2mJmhNYaJe9@r{3+k7L5`Wx(h2qyOFY`S`wXR<}p9=H%+Va8aP z{19b?2JK; z*;{X^jVGgXKh)Cd^$YEoPWv(mSI?Q%{X7JGLLlf_d#A*Al7s;uHokuyIv zgTgL#$Enhv5v2SUy~)*dXq-$83a8Kg0qAe!PmPS&DYzfy}-j0m0&-C!?15KgW zXsyiN=Off2226-KmyKAqK-pe{u54DMvY*h}udYK^U>CX84 zxs4{w?}s-d)>C(UMuZy|rJBz@luS)%os&WI4^&{lJ!qRgR)e;)ngOUm3!tB3uIyMM zP(5{;-2kOD!eV7Cx&%r&2^?Furj1AI#MTYG=W~ys`=eju<04M*1XFyK{sg?)?_ z`tWP45>=R|7iAzs=p3-F*-eMn*2x#rpI{f~Vyowv<)wrGzYvoZOoU_LB{O9fu_eW# zG)VUJl*rjam6yN9q1d5(@l)m6GKcg}Tt~;M<$J@DzSRVMxFT|_Tz5aGXIC;+i=qU$ zRE|>uc#BHVrj$O137Sonn~AADeJ)YEu0VTQfT+Zh)a?k?I#cHV-ixAXZ;2Se*;+~a zyA3l3yb66&{x_TOx0KVTCK_Yf(~Jh!#58OSK<)lS&Fg%EYNhr5&$NjiFZyHBO2VWL zKbYp!J&7a!SiX{9*!C~kv0ZHqq;5i*FMsKJ0d4mGXNUZa9GQ!$lbxZH=l|e`T()$3 zeE<=b5cY3rZ~uB!<)1(C&v-UOO_0--lCui3rQSf z3TYu%YN$kCfh1+t^AaeNxGvjt93p)$wW^ZXG)b_VtBhi(s_ZS|FS7DFpP0NGBBQ}{ zKF{`^dg{4pTYf*;+5+xghR7R12`nVZ76Dfby#?F*Ue1Q#-P@q&Z*blLKYNmD+pY>} z+R;@aXe^NZ1qNe`EY#r`qYPoW{?ylrrS}wP5^?bI_SoQi$h8}urHP735?2hKaH+jg zqptIo3!tfG$3?~qKYWLjF4-DK3@~!;igZ${+`v=fJIbb`)d3Z%o7r1#m~429u%^zw zk3Dtoo@G|HXYV;AZCB;Oj)*UcVV(pKk1%XFI92bk>poDMFy5<^Wx#;7z?~ZWQOX$6 zY})DGaev;WUW0?goH3-m{&BEGUc;9+guY2pB)peS%%WTMG;%;@)~3hXbV^^e!j3&K zUJV(sP-&X=WkdfY6S9ED7NVb$eX zq73lfMtey?IN!=VL$(Qw8A!Jr7$IO!obY#o|JPmyg#@>=4DQ}}eR_Qt+R&ePO zrwwVkAf*Jk7lAEm^e5uZQq3d12UN}l@x0I~ae_WQhEqo?K)i6rNDV3ae6>b*4L-#* zkyE4+{=p)D%wq>V!E<({Q553x3e$AzfK(AUqHgXLZZeuHIiXA-7F)>{%}U079)5w_ zSM8PI#D*Y6;-*Yq6HU0AWcz%CV2k4|oP}wcl`7YAL}3RL948UV7d$#MhajW?i4ytg zS}@pj9dqAw9b@d3wVzLQCXYyM#@#C%^LE7GGy>!$IXY(mzyC`}r{H~rHr|17#C5yC zm?Jv-`k;c~$0w`cxo||G93+7QG8H+Y15ky9m-JtzDmOGk^*yDZzf>qQ){p2L#T<&x ziNNSGCW?`}*dll1rQcCUd?BAL1Lx8AJ)P{}$4E#oeUec#U0NeKfj37j+mjC}NK6NS z=fD+bC*)(pWO_DtNZPM1lTEeme}9s5%2sBDc;lWDMe>sH7`Hsjf0k(1CsRBH`wfGG z&L-3F{=p~2ST16S!DH+q)#lS5CP0NQuk_Vb zv)+CvI+|8huW{Z*maPZtM&k@+68_x=d_3iDqH4cIVi_3BHfMdR*-JcW+vj0u3;o`r zU&=M`K{TG4KENpbJVp#X8Nmocj(@S$=clL!s*e&00(+&8OR3`=RMWiN#lwg8v=8DgGw>_&-nEx!M|;I{nW9#4?Uw5Pxu&pMYS_`~Una zf=-q$7Ph7?md2_smNtJ@J#&<$m4W=f_t4Wsz;&O5h%AYsBAST0!Y)`eiCD}vji6LA zjTPERUEPWMB(h8o-7yR+>ux#t@yb zx{oedHIihmJOFK_mFlgISYg4^x~iYKjYKjG#S8+4vkjnpDm2AG=gaUqBO-(+3KSmF zZl<%FV9J(9I47UW+BC0pJaHu|L>w{<^`QB%7blEmV(XISMT&($7S8UcoY1A*ONgU&9+3eM=rYsuj7(r(vtOB%7~m))<)2$ZCq z?MJTMgRd}3CDy1p7HYgLSuZ@kRg*ioIpP~E*jev>zj_t1<9RS~G2!Cm`?4{Nydob@ z1SwNQq9QC)?v?U!XUQ4FW-v8l>Y>2;ShqIp*qrYSHBVRh9BgGBtH&y}a05G-(*J=2 zMRHI-kp^#*i)lItJtwRz$ZBu{YbtZ>!&%YKT!8sIOr;8Qncqz9jHI`UTWXx(C!E~% zq0m=9Xbb#7ZkNE3u|=U`{YPQ@lHqKAkxn7Z5IM23^?Hc=G1qnp?;>j(at-9VldpC< zg-Nsar$2os#E23o>rg+wDz9D2+3of1V`h>R$g+)c&Z1h98=?UT;*XfxqD(!owM~d) zjVMV=MAEqRq3pqXb54_+btv|BFX7u9iAf1b+7=&}(^A;fsR?Lv*WTcTN-FQs^VrnH z-9ISQX4_&NR5qK(PWb&rN)QV79F;wSF;{DmhpQ~a8I=x;(CrcrFl!7!G}rsV)(5H1 z_oxYsV1v>}kYNG+bej4G@T$?qFmYFq@|TFy>rN)_$~7s2310Dz(oI4?v1zu^F@DoX z5)7OaYhdpxnlvLVzPmZ zN<@_}#+-@l(%ke)MJFv%5vXJ^zmYxDELwkSOk!RJS?SN8CG zI^60)zHL0OQvHV$zYX>+q+TBg2RL=vXkyc^+7hILO!cICFrBooEpOl2Np*+g+b^DS zz53!S7h7db5?BqixFDi-WRP3VB-p`Bqk7CAK;4)93OJ5Paslv#xhC7qX_;KHfdMdZ zqR9Zv-7g8(9WA(zcIcsV>i1U2PsfgztM0*0yznb6D$JOiTM{2qu?%W0Ohp*K*HJ9d zzuCN+zLXZ=V9leE8>FZu&6_V;+1VlDOH@4^-G;(hR% zL%XP%c|TC6#j9|a`KJrHad?W!w%t~j@B%ewxw`a&XUM@eZyU`;G)3&W^I0)$jIk#t z`=*`ORMhkH(nCt+3~fR54yVcasrBAF{ds!FPdB$wx7c9wAK|Cm*ESv48%M+P286qp zo(&lQHU(m9d~$_|D8~Q@9jWj9ebi_g_C7)VTR~-C1}%I<{7Mqn{Gp6tlZ2hh*j>WX zJVA2_lpg6>Ouu|fZfASgvT$*e_<|ul3~EOz&jIxo5p|m@_{o_{(FRpj#yBGWB)z1| zbDi`SWlWpYQ0tOpj6~5NycTVbMUr8cp(bC9RE@e(j!~{X|3}8Du-jJ>{yy~SV^7>G zid4V9qzSM6*w;}&LyH9xAGrQ^V-xi-HFkBecTzTWaS4+J8JS}?oNjCGRF@9tDkvCzjJGfEC%1$;{g2@^4I8E>P3P*)&flD9}X`?y>DmSYVE_fq^$y^>T(+r=gbmF~CDI>&#WV6BvNx zm{3r+6{g_^kyAz!)AW#!pBl@41{te|{&r-VmxZiL22! zD&nR*rcPLeb1p1zu)9!$!*oT>eIqAc;>ZKLoY7OK09p@^Ej`D#q)k?r% zHztyBZ*5D8(12M0!u>4ep*~ z>PhH%%gQYqvP9m-eBedzv4QHJ_nVf=U^kVJ`BsFd8nGqI4ei-we^=Ks^11d%$`B)= zsPeUVp5kpqfWC))(RQ-Wb=`mor-yMMbF@f81czV-xeLV`0V!~Yy{jj{4r{q;QT6=VoY=cnJ4XNrD@%?=M zMcQV3W}wz1c>d!r4!&vKe>4e<|6+md?!QqNcKP!n5_A2dH}x04R?}4nYEf)(8h{!? zGv^bDMgxdGvHLZx;tUyq%itE1<5X6+B<-U@hGw`pg$-EizoO1E6$hbEt?NZO5ITJ{u;zb?%i zZR~iJK zsNib7Kg+jcKfkxnnN{q)2T7E+h*G9iH5;ovExeRN>6SknW;tjwG=&g2=QNNE6AT;Z zmtGMWJLf8P@P%Rxo0=P9_m;qG*?a(A__>NtaSjioK^QLQ|ryp~%p#{SIXCmJe! zAu73^-|?bHUm>HDMmlfT1laZKW8O$>6H{gUS)=?5F7!0-eQBhdhM79z!B%@Aq-Z&n z3%^9^0&aJWsb}y8Sn&;Z4i**J?YoNm+AY%{ofXe4*srb|R&xP5IZ+4jw!k04WfCQu8(DUbx&D>;#)1E9Z-VLviP6r zSd#IX>yV9r?CW!OUmx1aFT+>QxtP1~v){p!mQ^!%_&j6Uk(wJYOg~n0F%+)@1ela>)DI@Fm6EQ$YSk zN&*DVL!yfD5T4)+F3-&X$(-ygzVHo>l#%(_I*9k1k5Mq^%naik7IKC`otV`)O1(XGGU-1fQ7x(DH1EMU=;Cq2bC(Pwv`2=}VbA4bL5p`qs7>NL3iFZ9~PZ7X}7&@#Tj==vv?m z^fOVBRah6sh<#-mQlas_woSC?I$>%}Yn!O%>+Q7g=I7)*)!`3>+&SM!tJi279;w>| zc|2<-pS4i?`Fhd3Oe?uiLdCEs=f949T7R-z83cwt*1+EVe?dl-e<0*vkvI~Br0Kk)&(wf9N6Dp_3D6dCI)SR~kY+kSv@>(YjK}7&iKl;e|Zu!wl(?*m=vv=|^`kwD(;t0E$XQ z@Ov5a$SVy4IvnvTZjf1t-b#bG@YICsiK#iAC!Vi;O_@sKu(M?0(h>4Z6Jgn3WQecJ zRsjR5I`d4X+p;pO(YGTCh^~SUv>8V3E(&p7p_-xNIY))0qPiYDW)2&D2*udDsifoU zb}+qW!(=HQI@P_VL_u^xEoGRTx#cW(62Uq>y`o_Dd-z7%&6(FubCUPRq-` zJgw4+Kq-2C3e#+B6|e%I;kRh_UEZS-ES-a(NPq={$G=&7FLhB9J?V_1v}!QM>hpcP+&~I zB$z?(W)GQ)gR;*rW~s#G#isj1gzL5r$%Vwfyqdaxd_5Nf=?iNUmJf|v?XL=dwvI5i zSQBpp$1{55M#axX5dv}Cone-OatLFb{q+JkikC;#%E;yyvwA^Rml^K#2(Diqikihr zkKSgS;2T}94UTrJh>n*7MZ0axR~Z2QmId^uL zcdzrSdFOJJOFU=S_vhHQJdqE1HV%G=&r9lzO{(aV6jJ9U0Y(J5Vegpgb|Jm~U_mutb=4m}0{x3RTch4vVy+DEi6%b7Rt}FeI z2L+v+3_VqVUlk0U41pCkV9oB&2_vO7;Osc^=e0KGc2uu2h}E7F`pS^VV39(J5*p|+ zonnn@m0XS~nw8z3vtBXZ%Px_8cVK42{D3Q5(l^>tP;;#;&CRB>xmheulimVI?)Tvs9H?vT*C@x)_JS8KS?qCP*qVdE!XxcHQj$= zA#b3apP$u`r+XO?&DrrRgcLa5ItYMOAS)(<`5ZIk@@_P~zNQTMMBgg5w%xA5gL@u9+%9jVuEd(UT8NgdIs zhE??HmrvRn%lx+$M7@_A_qF3!BZ@C_eur<4#7Y~L~IA3@{3tCfM%8D_lxfNzk>JqJG_v)(sa&46qU+H%15GXQeo z+DZEAfekpQScO6;oqk%{UJm;22eM58qhyUNN!s1xwn}#6h(BmNjQkI&t1WNg*Oo3` z{}ORmUxSy&0Zm~Z*gB^Do0R$=<{)h7{IC6S|KgS^OWSLUqQ6r-sP-QJjLB+?)h?SF zbUW)v<|siIodPQoD}Y`(4u$A;lil5Y7Mo(Xa+4@WMXeMe$)~G~6eY)Oi_st^2KV+8 z{SbWmq&Uc#)F08Yt2YVU*mCD6&4x z*ZsQlo>Xh5CpI4K?4jZ(C}o;bjE@5&4hvuzQ_kqzw!`oXdQABNJ@tLMJQ`9dd1nwr zhGbHAn{Mi8UmxHb=)JSP%zLwh9+FdsdY_ZyNx2gZnb$AJ1!n09X})isJ~AbsngVSe zPFy8LBbXT3sD%2dFc|$f@EVJ)a)HH0i0X`wJt%|qyHTchd=Iu2N0p30YGx3(Sg1kQ zNHH>rMuP6I_~oJAKp5_mjD^9muyY`pI{PAbAk&LsdI8iJI^KT!Dc&v{TOb*^h${kc zKrPysf0{u&3BMIs2>b)e_}%RN8wnjXgu$utLbQquq^^J>+Or}WjTxaVzg5kzQDo0o z^eI50_k!_4^Ok~c^%YGdgy9Jv-gIxGys^8WIHJ6Hu+!ct|byuYz? z4?tu|`;pkDcBx%iL+MzGlZLc|f5o%X1dV47!G!xp^Lk|E(zaDn`$#o7#Tu{7Aju<7 z`Q3o0a@RrLZzCMSomPB@p&}kYEDV;Q&XXb#8nsB{B>p5DEwZ0Jv6l(?k~rJ2+=q))o!jRIyjyJMWVD9=Gq@};My@s=BCgl$a`q7`^s=a} z^1t5j|BFmWq4c#5JrL%JfwkHH73TjjF{Tb|qR88s{<*K~Pnb`bmI7l&9_ejrZf@49 z-qmC*B-scGG#C$D;7=RI>{xJi<87k0ZZT;rj60CL+y;A8*gfq?Bk-~yx{>XfctuUj z+XAAyI+sO$uoFTG1&0C#SH$Fkq%E>`*yjE?N#Ria1zc=g@mRS76@n$L!Wnh-H(G@+ zpK+J#s2%DXnhD3qJk{JdW>gHoY2G}9KOXtp+|=ojqD=HUh7aTpX*sF+#n4SO zh*QMHPW-w2^vkHQrMY_((dV6wLbmn~N|y#>hhQ9kH4bq3cZMY%^VV@M)Zc9ao!fcJ3jtGw7p%4Mr8%Qd|u$oXZ>G6^^bAAKVH6y zyZxUp|6iA^qO9~FP%Un4VQI;#Inum495yqGh^++qc$D0tz95(LXwFWO)3otw&)gH0 z4_E?M+$9?k?kDJ|yO`|R@MJyxhbB*3pB_HBhH5gdhH%IZ)sitUyP%ED)qwep1X+t` z4%#Lxc@zAL4xA}~2EU^Ch(%+Ra*$>Tdn&c`o+OtnZcgU)cUv8Bw`#Ws86Y!PWtSlb zLgRG7B%3(TWTi`O2o0DqiTDD5sYemtKw8;+5~Hdk%x<5~S0&Hc9q& zK9|=P&I9@N*fyNChkljd5yy|&j`0)vS9*+cq+OM;T`@CXg8TLiorrb?(vCOl-_OfC ze6&GeDwfeJMopISL+p_{yE@#yP~Js-LOFGbQMNY79FfV891*RU$rO$-YuxAgDL3bT z*>DGL{%xWhcm`O&%k6L0)VcigVzalgF*W`}9YD}o%o4b@@lW$l+_J_2YKZinRQ%Qj zl5$2k-Zu8h6B3JNx`u?Q0{8oyAVd%MyzC}JCv(=T$)6g9r~)vrq4wiob3T(7{wnZo z%gAZZn4UO2-FUmu2Fa^CA%Pkf+Z6sJ8hVWVG3Gm5l93gFn0r7&Oco3CU4^r%#EPY+&_&9D@T*2wJd zCi)N@77s-{SN3HVG92L&Rz|_tP{CU7pG-QGIiuXV+>vd$WPv*l%#?={;z!3KVnrjB zWh(|$ujwsyvzoa%ep=lGV?MM5u=6R=Luq4A0%V`RC=Bcm5v%*=N*GUPd-~ESha%