Stacktrace processing

.gitignore

@@ -3,7 +3,6 @@
 
 # Log file
 *.log
-!sample.log
 
 # BlueJ files
 *.ctxt
@@ -13,7 +12,8 @@
 
 # Package Files #
 *.jar
-!atos.jar
+!evosuite-client-botsing-*.jar
+!*projectA*.jar
 *.war
 *.nar
 *.ear
@@ -30,6 +30,7 @@ hs_err_pid*
 .Rapp.history
 
 # Maven
+dependency-reduced-pom.xml
 target/
 
 # OS generated files #
@@ -48,3 +49,7 @@ Thumbs.db
 .project
 .settings/
 
+# local test directory
+**/test/**/botsing/local/
+**/test/**/botsing/model/generation/local/
+

.travis.yml

@@ -3,12 +3,13 @@ language: java
 jdk:
   - oraclejdk8
 
-install: true
-
 script: mvn package checkstyle:check
 
 before_script:
   - mvn clean
 
+before_install:
+  - mvn install:install-file -Dfile=botsing-reproduction/evosuite-client-botsing-1.0.7.jar -DgroupId=org.evosuite -DartifactId=evosuite-client-botsing -Dversion=1.0.7 -Dpackaging=jar
+
 after_success:
-  - mvn jacoco:report coveralls:report
+  - mvn jacoco:report coveralls:report

README.md

@@ -2,9 +2,54 @@
 
 [![Build Status](https://travis-ci.org/STAMP-project/botsing.svg?branch=master)](https://travis-ci.org/STAMP-project/botsing)
 [![Coverage Status](https://coveralls.io/repos/github/STAMP-project/botsing/badge.svg?branch=master)](https://coveralls.io/github/STAMP-project/botsing?branch=master)
+[![Maven Central](https://img.shields.io/maven-central/v/eu.stamp-project/botsing-reproduction.svg?label=Maven%20Central)](https://search.maven.org/search?q=g:%22eu.stamp-project%22%20AND%20a:%22botsing-reproduction%22)
 
 Botsing is a Java framework for crash reproduction. It relies on [EvoSuite](http://www.evosuite.org) for code instrumentation.
 
+## Usage
+
+### From Maven
+
+See the [documentation for the Maven Plugin](https://github.com/STAMP-project/botsing/tree/master/botsing-maven).
+
+### Command line interface
+
+
+#### botsing reproduction
+The latest version of Botsing command line (botsing-reproduction-X-X-X.jar) is available at [https://github.com/STAMP-project/botsing/releases](https://github.com/STAMP-project/botsing/releases). 
+
+Botsing has three mandatory parameters:
+ - `-crash_log` the file with the stack trace. The stack trace should be clean (no error message) and cannot contain any nested exceptions.
+ - `-target_frame` the target frame to reproduce. This number should be between 1 and the number of frames in the stack trace.
+ - `-project_cp` the classpath of the project and all its dependencies. The classpath can be a folder containing all the  `.jar` files required to run the software under test.
+
+
+By default, Botsing uses the following parameter values:
+ - `-Dsearch_budget=1800`, a time budget of 30 min. This value can be modified by specifying an additional parameter in format `-Dsearch_budget=60` (here, for 60 seconds). 
+ - `-Dpopulation=100`, a default population with 100 individuals. This value may be modified using `-Dpopulation=10` (here, for 10 individuals).
+ - `-Dtest_dir=crash-reproduction-tests`, the output directory where the tests will be created (if any test is generated). This value may be modified using `-Dtest_dir=newoutputdir`.
+
+To check the list of options, use:
+
+```sh
+$ java -jar botsing-reproduction.jar -help
+usage: java -jar botsing-reproduction.jar -crash_log stacktrace.log -target_frame 2
+
+            -project_cp dep1.jar;dep2.jar  )
+ -crash_log <arg>      File with the stack trace
+ -D <property=value>   use value for given property
+ -help                 Prints this help message.
+ -project_cp <arg>      classpath of the project under test and all its
+                       dependencies
+ -target_frame <arg>   Level of the target frame
+```
+
+#### Example
+
+```
+java -jar botsing-reproduction.jar -crash_log LANG-1b.log -target_frame 2 -project_cp ~/bin
+```
+
 
 ## Contributing
 
@@ -14,6 +59,18 @@ Botsing is licensed under Apache-2.0, pull request as are welcome.
 
 The coding style is described in [`checkstyle.xml`](checkstyle.xml). Please (successfully) run the command `mvn checkstyle:check` before submitting a pull request.
 
+### Building Botsing
+
+Currently, Botsing using a customized version of the EvoSuite-client. Hence, the building process contains two steps:
+1- Installing the customized version of EvoSuite-client:
+```
+mvn install:install-file -Dfile=botsing-reproduction/evosuite-client-botsing-1.0.7.jar -DgroupId=org.evosuite -DartifactId=evosuite-client-botsing -Dversion=1.0.7 -Dpackaging=jar
+```
+2- Build the Botsing project:
+
+```
+mvn package
+```
 
 ### Adding a dependency
 
@@ -40,7 +97,50 @@ And referenced in the dependencies of the module using the following syntax:
 ```
 Please check in the list of properties that the dependency version is not already there before adding a new one.
 
+#### botsing preprocessing
+
+The latest version of Botsing command line (botsing-preprocessing-X-X-X.jar) is available at [https://github.com/STAMP-project/botsing/releases](https://github.com/STAMP-project/botsing/releases). 
+
+Botsing preprocessing has these mandatory parameters:
+ - `-i` represents the input file path (`crash_log`) with the stack trace to clean. For example `-i=path-name-of-crash-log`
+ - `-o` represents the output file path (`output_log`) cleaned of the error message and/or nested exceptions. For example `-o=path-name-of-output-log` 
+
+These parameters define actions to perform (clean) in the stack trace: 
+ - `-f` to flatten the stack trace.
+ - `-e` to remove the error message.
+
+ - `-p` to set the regexp in the stack trace use case. For example `-p=my.package.*` 
+
+#### Example
+
+To clean the nested stack trace
+
+```
+java -jar botsing-preprocessing.jar -i=crash_log.txt -o=output_log.log -f -p=com.example.*
+```
+
+or to remove the error message
+
+```
+java -jar botsing-preprocessing.jar -e -i=crash_log.txt -o==output_log.log 
+```
+
+Note that you can use also both actions (`-f` and `-e`).
+
+## Background
+
+Botsing (Dutch for 'crash') is a complete re-implementation of the crash replication tool [EvoCrash](http://www.evocrash.org) ([github](https://github.com/STAMP-project/EvoCrash)).
+Whereas EvoCrash was a full clone of EvoSuite (making it hard to update EvoCrash as EvoSuite evolves), Botsing relies on EvoSuite as a (maven) dependency only. Furthermore, it comes with an extensive test suite, making it easier to extend. The license adopted is Apache, in order to facilitate adoption in industry and academia.
+
+The underlying evolutionary algorithm and fitness function are described in:
+
+* Mozhan Soltani, Annibale Panichella, and Arie van Deursen. Search-Based Crash Reproduction and Its Impact on Debugging. _IEEE Transactions on Software Engineering_, 2018. ([DOI](http://dx.doi.org/10.1109/TSE.2018.2877664), [preprint](https://pure.tudelft.nl/portal/en/publications/searchbased-crash-reproduction-and-its-impact-on-debugging(1281ce36-7afc-43d9-ad83-b69c60fbd49a).html))
+
+* Mozhan Soltani, Pouria Derakhshanfar, Annibale Panichella, Xavier Devroey, Andy Zaidman, and Arie van Deursen. Single-objective versus Multi-Objectivized Optimization for Evolutionary Crash Reproduction. In Colanzi and McMinn, editors, _Search-Based Software Engineering - 10th International Symposium, SSBSE 2018 - Proceedings_. Lecture Notes in Computer Science, Springer. 2018. p. 325-340. ([DOI](http://dx.doi.org/10.1007/978-3-319-99241-9_18), [preprint](https://pure.tudelft.nl/portal/en/publications/singleobjective-versus-multiobjectivized-optimization-for-evolutionary-crash-reproduction(ccece8a1-79cd-4303-adca-34a920bf7d14).html)).
+
+
 ## Funding
 
-Botsing is partially funded by research project STAMP (European Commission - H2020)
-![STAMP - European Commission - H2020](https://github.com/STAMP-project/docs-forum/blob/master/docs/images/logo_readme_md.png)
+Botsing is partially funded by research project STAMP (European Commission - H2020) ICT-16-10 No.731529.
+
+![STAMP - European Commission - H2020](docs/logo_readme_md.png)

botsing-commons/pom.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>botsing</artifactId>
+        <groupId>eu.stamp-project</groupId>
+        <version>1.0.4-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>botsing-commons</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>org.evosuite</groupId>
+            <artifactId>evosuite-client-botsing</artifactId>
+            <version>${evosuite-client.version}</version>
+        </dependency>
+    </dependencies>
+
+
+</project>

botsing-commons/src/main/java/eu/stamp/botsing/commons/BotsingTestGenerationContext.java

@@ -0,0 +1,36 @@
+package eu.stamp.botsing.commons;
+
+import eu.stamp.botsing.commons.instrumentation.InstrumentingClassLoader;
+
+
+public class BotsingTestGenerationContext {
+
+    private static final BotsingTestGenerationContext instance = new BotsingTestGenerationContext();
+
+    private InstrumentingClassLoader classLoader;
+    private ClassLoader originalClassLoader;
+
+    private BotsingTestGenerationContext(){
+        originalClassLoader = this.getClass().getClassLoader();
+        classLoader = new InstrumentingClassLoader();
+    }
+
+
+    public static BotsingTestGenerationContext getInstance() {
+        return instance;
+    }
+
+    public void goingToExecuteSUTCode() {
+
+        Thread.currentThread().setContextClassLoader(classLoader);
+    }
+
+
+    public void doneWithExecutingSUTCode() {
+        Thread.currentThread().setContextClassLoader(originalClassLoader);
+    }
+
+    public InstrumentingClassLoader getClassLoaderForSUT() {
+        return classLoader;
+    }
+}

botsing-commons/src/main/java/eu/stamp/botsing/commons/instrumentation/BotsingBytecodeInstrumentation.java

@@ -0,0 +1,87 @@
+package eu.stamp.botsing.commons.instrumentation;
+
+import org.evosuite.Properties;
+import org.evosuite.assertion.CheapPurityAnalyzer;
+import org.evosuite.graphs.cfg.CFGClassAdapter;
+import org.evosuite.instrumentation.*;
+import org.evosuite.runtime.RuntimeSettings;
+import org.evosuite.runtime.instrumentation.*;
+import org.evosuite.runtime.util.ComputeClassWriter;
+import org.evosuite.seeding.PrimitiveClassAdapter;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.commons.SerialVersionUIDAdder;
+import org.objectweb.asm.util.TraceClassVisitor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.PrintWriter;
+
+public class BotsingBytecodeInstrumentation {
+
+    private static final Logger LOG = LoggerFactory.getLogger(BotsingBytecodeInstrumentation.class);
+    public byte[] transformBytes(ClassLoader classLoader, String className, ClassReader reader) {
+
+        TransformationStatistics.reset();
+
+        int asmFlags = ClassWriter.COMPUTE_FRAMES;
+        ClassWriter writer = new ComputeClassWriter(asmFlags);
+
+        ClassVisitor cv = writer;
+        if (LOG.isDebugEnabled()) {
+            cv = new TraceClassVisitor(cv, new PrintWriter(System.err));
+        }
+
+        if (Properties.RESET_STATIC_FIELDS) {
+            cv = new StaticAccessClassAdapter(cv, className);
+        }
+
+        if (Properties.PURE_INSPECTORS) {
+            CheapPurityAnalyzer purityAnalyzer = CheapPurityAnalyzer.getInstance();
+            cv = new PurityAnalysisClassVisitor(cv, className, purityAnalyzer);
+        }
+
+        if (Properties.MAX_LOOP_ITERATIONS >= 0) {
+            cv = new LoopCounterClassAdapter(cv);
+        }
+
+        cv = new RemoveFinalClassAdapter(cv);
+
+        cv = new ExecutionPathClassAdapter(cv, className);
+
+        cv = new CFGClassAdapter(classLoader, cv, className);
+
+        // Collect constant values for the value pool
+        cv = new PrimitiveClassAdapter(cv, className);
+
+        cv = handleStaticReset(className, cv);
+
+        cv = new MethodCallReplacementClassAdapter(cv, className);
+        if(RuntimeSettings.applyUIDTransformation){
+            cv = new SerialVersionUIDAdder(cv);
+        }
+
+        reader.accept(cv, ClassReader.SKIP_FRAMES);
+        try{
+            return writer.toByteArray();
+        }catch (RuntimeException e){
+            LOG.warn("Method code is too large");
+            return new byte[0];
+        }
+
+    }
+
+    private static ClassVisitor handleStaticReset(String className, ClassVisitor cv) {
+        cv = new CreateClassResetClassAdapter(cv, className, Properties.RESET_STATIC_FINAL_FIELDS);
+        // Adds a callback before leaving the <clinit> method
+        cv = new EndOfClassInitializerVisitor(cv, className);
+
+        return cv;
+    }
+
+
+    public static boolean checkIfCanInstrument(String className) {
+        return RuntimeInstrumentation.checkIfCanInstrument(className);
+    }
+}

botsing-commons/src/main/java/eu/stamp/botsing/commons/instrumentation/ClassInstrumentation.java

@@ -0,0 +1,34 @@
+package eu.stamp.botsing.commons.instrumentation;
+
+import eu.stamp.botsing.commons.BotsingTestGenerationContext;
+import org.evosuite.Properties;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ClassInstrumentation {
+    private static final Logger LOG = LoggerFactory.getLogger(ClassInstrumentation.class);
+    public List<Class> instrumentClasses(List<String> interestingClasses){
+        List<Class> instrumentedClasses = new ArrayList<>();
+        List<String> instrumentedClassesName = new ArrayList<>();
+
+        for(String clazz: interestingClasses){
+            if(instrumentedClassesName.contains(clazz)){
+                continue;
+            }
+            LOG.debug("Instrumenting class "+ clazz);
+            Class<?> cls;
+            try {
+                Properties.TARGET_CLASS=clazz;
+                cls = Class.forName(clazz,false, BotsingTestGenerationContext.getInstance().getClassLoaderForSUT());
+                instrumentedClasses.add(cls);
+                instrumentedClassesName.add(clazz);
+            } catch (ClassNotFoundException | NoClassDefFoundError e) {
+                LOG.warn("Error in loading {}",clazz);
+            }
+        }
+        return instrumentedClasses;
+    }
+}