merge

Author: DaniilStepanov

utbot-cli/src/main/kotlin/org/utbot/cli/GenerateTestsAbstractCommand.kt

@@ -39,6 +39,7 @@ import java.nio.file.Path
 import java.nio.file.Paths
 import java.time.LocalDateTime
 import java.time.temporal.ChronoUnit
+import org.utbot.engine.greyboxfuzzer.util.CustomClassLoader
 
 private const val LONG_GENERATION_TIMEOUT = 1_200_000L
 
@@ -143,8 +144,16 @@ abstract class GenerateTestsAbstractCommand(name: String, help: String) :
     protected fun getWorkingDirectory(classFqn: String): Path? {
         val classRelativePath = classFqnToPath(classFqn) + ".class"
         val classAbsoluteURL = classLoader.getResource(classRelativePath) ?: return null
-        val classAbsolutePath = replaceSeparator(classAbsoluteURL.toPath().toString())
-            .removeSuffix(classRelativePath)
+        val classAbsolutePath =
+            if (classAbsoluteURL.toURI().scheme == "jar") {
+                replaceSeparator(classAbsoluteURL.file.removePrefix("file:"))
+                    .removeSuffix(classRelativePath)
+                    .removeSuffix("/")
+                    .removeSuffix("!")
+            } else {
+                replaceSeparator(classAbsoluteURL.toPath().toString())
+                    .removeSuffix(classRelativePath)
+            }
         return Paths.get(classAbsolutePath)
     }
 
@@ -154,15 +163,17 @@ abstract class GenerateTestsAbstractCommand(name: String, help: String) :
         sourceCodeFile: Path? = null,
         searchDirectory: Path,
         chosenClassesToMockAlways: Set<ClassId>
-    ): List<UtMethodTestSet> =
-        testCaseGenerator.generate(
+    ): List<UtMethodTestSet> {
+        CustomClassLoader.classLoader = classLoader
+        return testCaseGenerator.generate(
             targetMethods,
             mockStrategy,
             chosenClassesToMockAlways,
             generationTimeout
         ).map {
             if (sourceCodeFile != null) it.summarize(sourceCodeFile.toFile(), searchDirectory) else it
         }
+    }
 
 
     protected fun withLogger(targetClassFqn: String, block: Runnable) {

utbot-core/src/main/kotlin/org/utbot/common/FileUtil.kt

@@ -90,7 +90,10 @@ object FileUtil {
 
         for (clazz in classes) {
             val path = clazz.toClassFilePath()
-            val resource = clazz.classLoader.getResource(path) ?: error("No such file: $path")
+            val resource =
+                clazz.classLoader.getResource(path)
+                    ?: ClassLoader.getSystemClassLoader().getResource(path)
+                    ?: error("No such file: $path")
 
             if (resource.toURI().scheme == "jar") {
                 val jarLocation = resource.toURI().extractJarName()

utbot-framework-api/src/main/kotlin/org/utbot/framework/UtSettings.kt

@@ -239,7 +239,12 @@ object UtSettings : AbstractSettings(logger, defaultKeyForSettingsPath, defaultS
     /**
      * Set to true to start fuzzing if symbolic execution haven't return anything
      */
-    var useFuzzing: Boolean by getBooleanProperty(true)
+    var useFuzzing: Boolean by getBooleanProperty(false)
+
+    /**
+     * Set to true to start grey-box fuzzing
+     */
+    var useGreyBoxFuzzing: Boolean by getBooleanProperty(true)
 
     /**
      * Set the total attempts to improve coverage by fuzzer.

utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/Api.kt

@@ -480,12 +480,13 @@ data class UtArrayModel(
  * @param instantiationCall is an [UtExecutableCallModel] to instantiate represented object. It **must** not return `null`.
  * @param modificationsChain is a chain of [UtStatementModel] to construct object state.
  */
-data class UtAssembleModel private constructor(
+data class UtAssembleModel constructor(
     override val id: Int?,
     override val classId: ClassId,
     override val modelName: String,
     val instantiationCall: UtExecutableCallModel,
-    val modificationsChain: List<UtStatementModel>,
+    //TODO: get rid of var
+    var modificationsChain: List<UtStatementModel>,
     val origin: UtCompositeModel?
 ) : UtReferenceModel(id, classId, modelName) {
 

utbot-framework-api/src/main/kotlin/org/utbot/framework/plugin/api/UtExecutionResult.kt

@@ -1,5 +1,6 @@
 package org.utbot.framework.plugin.api
 
+import org.utbot.framework.plugin.api.util.objectClassId
 import org.utbot.framework.plugin.api.visible.UtStreamConsumingException
 import java.io.File
 import java.util.LinkedList
@@ -21,6 +22,10 @@ sealed class UtExecutionFailure : UtExecutionResult() {
         get() = exception
 }
 
+data class UtExecutionSuccessConcrete(val result: Any?) : UtExecutionResult() {
+    override fun toString() = "$result"
+}
+
 data class UtOverflowFailure(
     override val exception: Throwable,
 ) : UtExecutionFailure()
@@ -102,7 +107,14 @@ inline fun UtExecutionResult.onFailure(action: (exception: Throwable) -> Unit):
     return this
 }
 
+fun UtExecutionResult.getOrThrow(): UtModel = when (this) {
+    is UtExecutionSuccess -> model
+    is UtExecutionFailure -> throw exception
+    is UtExecutionSuccessConcrete -> UtNullModel(objectClassId)
+}
+
 fun UtExecutionResult.exceptionOrNull(): Throwable? = when (this) {
     is UtExecutionFailure -> rootCauseException
     is UtExecutionSuccess -> null
+    is UtExecutionSuccessConcrete -> null
 }

utbot-framework/build.gradle

@@ -34,6 +34,10 @@ dependencies {
     implementation group: 'io.github.microutils', name: 'kotlin-logging', version: kotlinLoggingVersion
     implementation group: 'org.jacoco', name: 'org.jacoco.report', version: jacocoVersion
     implementation group: 'org.apache.commons', name: 'commons-text', version: apacheCommonsTextVersion
+    implementation "org.javaruntype:javaruntype:1.3"
+    implementation "ru.vyarus:generics-resolver:3.0.3"
+    implementation "ognl:ognl:3.3.2"
+
     // we need this for construction mocks from composite models
     implementation group: 'org.mockito', name: 'mockito-core', version: '4.2.0'
 

utbot-framework/src/main/java/org/utbot/quickcheck/From.java

@@ -0,0 +1,65 @@
+/*
+ The MIT License
+
+ Copyright (c) 2010-2021 Paul R. Holser, Jr.
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+package org.utbot.quickcheck;
+
+import org.utbot.quickcheck.Produced;
+import org.utbot.quickcheck.Property;
+import org.utbot.quickcheck.generator.Generator;
+
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.*;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+/**
+ * <p>Mark a parameter of a {@link Property} method with this annotation to
+ * have random values supplied to it via the specified
+ * {@link Generator}.</p>
+ *
+ * <p>You may specify as many of these annotations as as you wish on a given
+ * parameter. On a given generation, one of the specified generators will be
+ * chosen at random with probability in proportion to {@link #frequency()}.</p>
+ *
+ * <p>If any such generator produces values of a type incompatible with the
+ * type of the marked parameter, {@link IllegalArgumentException} is
+ * raised.</p>
+ */
+@Target({ PARAMETER, FIELD, ANNOTATION_TYPE, TYPE_USE })
+@Retention(RUNTIME)
+@Repeatable(Produced.class)
+public @interface From {
+    /**
+     * @return the generator to be used for the annotated property parameter
+     */
+    Class<? extends Generator> value();
+
+    /**
+     * @return a weight to influence how often the generator is chosen
+     */
+    int frequency() default 1;
+}

utbot-framework/src/main/java/org/utbot/quickcheck/MinimalCounterexampleHook.java

@@ -0,0 +1,46 @@
+/*
+ The MIT License
+
+ Copyright (c) 2010-2021 Paul R. Holser, Jr.
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+package org.utbot.quickcheck;
+
+import org.utbot.quickcheck.Property;
+
+/**
+ * <p>Allows access to an actual failing example.</p>
+ *
+ * <p>This may be useful if any of the objects' {@link Object#toString()}
+ * representations is difficult to understand.</p>
+ *
+ * @see Property#onMinimalCounterexample()
+ */
+public interface MinimalCounterexampleHook {
+    /**
+     * @param counterexample the minimal counterexample (after shrinking)
+     * @param action work to perform with the minimal counterexample;
+     * for example, this could repeat the test using the same inputs.
+     * This action should be safely callable multiple times.
+     */
+    void handle(Object[] counterexample, Runnable action);
+}

utbot-framework/src/main/java/org/utbot/quickcheck/Mode.java

@@ -0,0 +1,63 @@
+/*
+ The MIT License
+
+ Copyright (c) 2010-2021 Paul R. Holser, Jr.
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+package org.utbot.quickcheck;
+
+import org.utbot.quickcheck.Property;
+import org.utbot.quickcheck.internal.ParameterSampler;
+import org.utbot.quickcheck.internal.sampling.ExhaustiveParameterSampler;
+import org.utbot.quickcheck.internal.sampling.TupleParameterSampler;
+
+/**
+ * Represents different modes of execution of property-based tests.
+ *
+ * @see org.utbot.quickcheck.generator.Only
+ * @see org.utbot.quickcheck.generator.Also
+ */
+public enum Mode {
+    /**
+     * Verify {@link org.utbot.quickcheck.Property#trials()} tuples of arguments for a property's
+     * parameters.
+     */
+    SAMPLING {
+        @Override ParameterSampler sampler(int defaultSampleSize) {
+            return new TupleParameterSampler(defaultSampleSize);
+        }
+    },
+
+    /**
+     * Generate {@link Property#trials()} arguments for each parameter
+     * property, and verify the cross-products of those sets of arguments.
+     * This behavior mirrors that of the JUnit
+     * {@link org.junit.experimental.theories.Theories} runner.
+     */
+    EXHAUSTIVE {
+        @Override ParameterSampler sampler(int defaultSampleSize) {
+            return new ExhaustiveParameterSampler(defaultSampleSize);
+        }
+    };
+
+    abstract ParameterSampler sampler(int defaultSampleSize);
+}

utbot-framework/src/main/java/org/utbot/quickcheck/NonTrackingGenerationStatus.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2017-2018 The Regents of the University of California
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.utbot.quickcheck;
+
+import org.utbot.quickcheck.generator.GenerationStatus;
+import org.utbot.quickcheck.internal.GeometricDistribution;
+import org.utbot.quickcheck.random.SourceOfRandomness;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+
+/**
+ * Provides a generation status that does not track the number of trials
+ * generated so far. This is useful for guided fuzzing where the burden
+ * of making choices is on the guidance system rather than on quickcheck.
+ *
+ * @author Rohan Padhye
+ */
+public class NonTrackingGenerationStatus implements GenerationStatus {
+
+    public static final int MEAN_SIZE = 10;
+
+    private final SourceOfRandomness random;
+    private final Map<Key<?>, Object> contextValues = new HashMap<>();
+    private final GeometricDistribution geometric = new GeometricDistribution();
+
+
+    public NonTrackingGenerationStatus(SourceOfRandomness random) {
+        this.random = random;
+    }
+
+    @Override
+    public int size() {
+        return geometric.sampleWithMean(MEAN_SIZE, random);
+    }
+
+    @Override
+    public int attempts() {
+        throw new UnsupportedOperationException("attempts() and @ValueOf" +
+                " is not supported in guided mode.");
+    }
+
+    @Override
+    public <T> GenerationStatus setValue(Key<T> key, T value) {
+        contextValues.put(key, value);
+        return this;
+    }
+
+    @Override
+    public <T> Optional<T> valueOf(Key<T> key) {
+        return Optional.ofNullable(key.cast(contextValues.get(key)));
+    }
+}