From 4692dbb2dfc8eb7173e71ab37e8a3211ef8649ab Mon Sep 17 00:00:00 2001 From: Nicolas Harrand Date: Fri, 2 Mar 2018 11:42:44 +0100 Subject: [PATCH] multiple fixes --- .../buildSystem/maven/MavenOutputParser.java | 3 +- .../transformation/SingleTransformation.java | 4 +- .../special/JsonAddMethodInvocationInput.java | 14 ++- .../diversify/runner/SinglePointRunner.java | 21 ----- .../inria/diversify/runner/SmartRunner.java | 88 +++++++++++++++++++ .../transformation/AddMethodInvocation.java | 15 +++- .../diversify/transformation/ForEachFlip.java | 66 ++++++++++++++ .../diversify/transformation/LoopFlip.java | 18 +++- .../diversify/transformation/SwapSubType.java | 17 +++- .../query/AddMethodInvocationQuery.java | 42 ++++++++- .../query/ForEachFlipQuery.java | 21 +++++ .../inria/diversify/util/ChangIterable.java | 32 +++++++ .../diversify/util/RandomLiteralFactory.java | 21 +++-- .../src/resources/ReverseIterableTemplate | 30 +++++++ .../query/LoopFlipQueryTest.java | 2 +- .../diversify/util/ChangIterableTest.java | 61 +++++++++++++ .../fr/inria/diversify/DiversifyMain.java | 3 + 17 files changed, 417 insertions(+), 41 deletions(-) create mode 100644 generator/src/main/java/fr/inria/diversify/runner/SmartRunner.java create mode 100644 generator/src/main/java/fr/inria/diversify/transformation/ForEachFlip.java create mode 100644 generator/src/main/java/fr/inria/diversify/transformation/query/ForEachFlipQuery.java create mode 100644 generator/src/main/java/fr/inria/diversify/util/ChangIterable.java create mode 100644 generator/src/resources/ReverseIterableTemplate create mode 100644 generator/src/test/java/fr/inria/diversify/util/ChangIterableTest.java diff --git a/core/src/main/java/fr/inria/diversify/buildSystem/maven/MavenOutputParser.java b/core/src/main/java/fr/inria/diversify/buildSystem/maven/MavenOutputParser.java index d91beb01..6ada7f07 100644 --- a/core/src/main/java/fr/inria/diversify/buildSystem/maven/MavenOutputParser.java +++ b/core/src/main/java/fr/inria/diversify/buildSystem/maven/MavenOutputParser.java @@ -57,7 +57,7 @@ public int parse(String output, String regex) { */ public int parse(String[] output) { Pattern failedTestPattern = Pattern.compile("(\\w+)\\(((\\w+\\.)*\\w+)\\)\\s+Time elapsed:\\s+((\\d+\\.)?\\d+)\\s+sec\\s+<<<\\s+((FAILURE)|(ERROR))!"); - Pattern deviationPattern = Pattern.compile(".+>>>> OffTrack <<<<"); + Pattern deviationPattern = Pattern.compile(".*\\[OFF TRACK\\].*"); List resultFailedTests = new ArrayList<>(); @@ -111,6 +111,7 @@ public int parse(String[] output) { status = 0; } } + if((status == 0) && (this.hasDeviated)) status = 1; //We assume that if no explicit Build success message was issue something really wrong happened if ( status == -3 ) { diff --git a/core/src/main/java/fr/inria/diversify/transformation/SingleTransformation.java b/core/src/main/java/fr/inria/diversify/transformation/SingleTransformation.java index c83117fd..d5c2be88 100644 --- a/core/src/main/java/fr/inria/diversify/transformation/SingleTransformation.java +++ b/core/src/main/java/fr/inria/diversify/transformation/SingleTransformation.java @@ -61,8 +61,10 @@ public void printJavaFile(String directory) throws IOException { Factory factory = type.getFactory(); Environment env = factory.getEnvironment(); - JavaOutputProcessor processor = new JavaOutputProcessor(new File(directory), new DefaultJavaPrettyPrinter(env)); + JavaOutputProcessor processor = new JavaOutputProcessor(new DefaultJavaPrettyPrinter(env)); + //JavaOutputProcessor processor = new JavaOutputProcessor(new File(directory), new DefaultJavaPrettyPrinter(env)); processor.setFactory(factory); + processor.setOutputDirectory(new File(directory)); processor.createJavaFile(type); Log.debug("write type {} in directory {}", type.getQualifiedName(), directory); diff --git a/generator/src/main/java/fr/inria/diversify/persistence/json/input/special/JsonAddMethodInvocationInput.java b/generator/src/main/java/fr/inria/diversify/persistence/json/input/special/JsonAddMethodInvocationInput.java index e11b380a..95a2a39f 100644 --- a/generator/src/main/java/fr/inria/diversify/persistence/json/input/special/JsonAddMethodInvocationInput.java +++ b/generator/src/main/java/fr/inria/diversify/persistence/json/input/special/JsonAddMethodInvocationInput.java @@ -15,6 +15,7 @@ import spoon.reflect.declaration.CtType; import spoon.reflect.declaration.ModifierKind; import spoon.reflect.factory.Factory; +import spoon.reflect.path.CtPathStringBuilder; import spoon.reflect.reference.CtTypeReference; import java.util.ArrayList; @@ -48,12 +49,19 @@ public void read(Map transformations) { //CodeFragment cf = getCodeFragment(cfJson.getString(POSITION), cfJson.getString(SOURCE_CODE)); //CtStatement tp = (CtStatement) cf.getCtCodeFragment(); - - CtStatement tp = getInputProgram().findElement( + CtStatement tp = (CtStatement) new CtPathStringBuilder() + .fromString(cfJson.getString("path")) + .evaluateOn(getInputProgram() + .getFactory() + .getModel() + .getRootPackage()) + .iterator() + .next(); + /*CtStatement tp = getInputProgram().findElement( Class.forName(cfJson.getString("type")), cfJson.getString(POSITION), cfJson.getString(SOURCE_CODE) - ); + );*/ if(tp == null) { System.out.println(cfJson.toString()); diff --git a/generator/src/main/java/fr/inria/diversify/runner/SinglePointRunner.java b/generator/src/main/java/fr/inria/diversify/runner/SinglePointRunner.java index 9acd95d3..8f99ea0a 100644 --- a/generator/src/main/java/fr/inria/diversify/runner/SinglePointRunner.java +++ b/generator/src/main/java/fr/inria/diversify/runner/SinglePointRunner.java @@ -72,28 +72,7 @@ protected void run(Transformation trans) throws Exception { try { int status; - if(trans instanceof AddMethodInvocation) { - AddMethodInvocation a = (AddMethodInvocation) trans; - CtMethod m = a.getTp().getParent(CtMethod.class); - String params = "("; - boolean isFirst = true; - List ps = m.getParameters(); - for(CtParameter p : ps) { - if(isFirst) isFirst = false; - else params +=", "; - params += p.getType().getQualifiedName(); - } - params += ")"; - String method = m.getDeclaringType().getQualifiedName() + "." + - m.getSimpleName() + params; - Properties p = new Properties(); - if(testImpact != null) { - p.setProperty("test", getTests(method)); - } - status = runTest(tmpDir, p); - } else { status = runTest(tmpDir); - } // if(status == 0) { diff --git a/generator/src/main/java/fr/inria/diversify/runner/SmartRunner.java b/generator/src/main/java/fr/inria/diversify/runner/SmartRunner.java new file mode 100644 index 00000000..4fca77cf --- /dev/null +++ b/generator/src/main/java/fr/inria/diversify/runner/SmartRunner.java @@ -0,0 +1,88 @@ +package fr.inria.diversify.runner; + +import fr.inria.diversify.statistic.SinglePointSessionResults; +import fr.inria.diversify.transformation.AddMethodInvocation; +import fr.inria.diversify.transformation.SingleTransformation; +import fr.inria.diversify.transformation.Transformation; +import fr.inria.diversify.util.Log; +import spoon.reflect.declaration.CtMethod; +import spoon.reflect.declaration.CtParameter; + +import java.util.List; +import java.util.Properties; + +public class SmartRunner extends SinglePointRunner { + public SmartRunner(InputConfiguration inputConfiguration, String projectDir, String srcDir) { + super(inputConfiguration, projectDir, srcDir); + + } + + private void initTraces() { + String tracesDir = inputConfiguration.getProperty("traces"); + if(tracesDir != null) { + + } + } + + private String buildAgentLine(String test) { + if(inputConfiguration.getProperty("traces") == null) return null; + if(inputConfiguration.getProperty("traceAgent") == null) return null; + if(inputConfiguration.getProperty("tracePackage") == null) return null; + return"-javaagent:" + + inputConfiguration.getProperty("traceAgent") + + "=\"strict-includes|includes=" + + inputConfiguration.getProperty("tracePackage") + + "|excludes=fr.inria.yalta|follow=" + + inputConfiguration.getProperty("traces") + + "/" + test + + "\""; + } + + @Override + protected void run(Transformation trans) throws Exception { + Log.info("trial {}", trial); + Log.debug("output dir: " + tmpDir + "/" + sourceDir); +// writePosition(tmpDir + "/transplant.json", (ASTTransformation) trans); + + try { + applyTransformation(trans); + + try { + int status; + if(trans instanceof SingleTransformation) { + SingleTransformation a = (SingleTransformation) trans; + Properties p = new Properties(); + if(testImpact != null) { + p.setProperty("test", getTests(a.methodLocationName())); + p.setProperty("argLine", buildAgentLine(getTests(a.methodLocationName()))); + } + status = runTest(tmpDir, p); + } else { + status = runTest(tmpDir); + } + + +// if(status == 0) { +// writeAllInfo((SingleTransformation) trans, trial); +// } + + trans.setStatus(status); + trans.setFailures(builder.getFailedTests()); + // error during runTest + } catch (Exception e) { + trans.setStatus(-2); + Log.debug("compile error during diversification", e); + } + + trial++; + trans.restore(tmpDir + "/" + sourceDir); + + ((SinglePointSessionResults) sessionResults).addRunResults(trans); + } catch (Exception e) { + trans.setStatus(-2); + tryRestore(trans, e); + } + transformations.add(trans); + + } +} diff --git a/generator/src/main/java/fr/inria/diversify/transformation/AddMethodInvocation.java b/generator/src/main/java/fr/inria/diversify/transformation/AddMethodInvocation.java index b6a81aa0..a21c032e 100644 --- a/generator/src/main/java/fr/inria/diversify/transformation/AddMethodInvocation.java +++ b/generator/src/main/java/fr/inria/diversify/transformation/AddMethodInvocation.java @@ -120,7 +120,20 @@ public String packageLocationName() { @Override public String methodLocationName() { - return "unknown"; + + CtMethod m = getTp().getParent(CtMethod.class); + String params = "("; + boolean isFirst = true; + List ps = m.getParameters(); + for(CtParameter p : ps) { + if(isFirst) isFirst = false; + else params +=", "; + params += p.getType().getQualifiedName(); + } + params += ")"; + String method = m.getDeclaringType().getQualifiedName() + "." + + m.getSimpleName() + params; + return method; } @Override diff --git a/generator/src/main/java/fr/inria/diversify/transformation/ForEachFlip.java b/generator/src/main/java/fr/inria/diversify/transformation/ForEachFlip.java new file mode 100644 index 00000000..4c3838c9 --- /dev/null +++ b/generator/src/main/java/fr/inria/diversify/transformation/ForEachFlip.java @@ -0,0 +1,66 @@ +package fr.inria.diversify.transformation; + +import fr.inria.diversify.transformation.exception.RestoreTransformationException; +import spoon.reflect.code.CtExpression; +import spoon.reflect.code.CtForEach; +import spoon.reflect.cu.SourcePosition; +import spoon.reflect.declaration.CtClass; +import spoon.reflect.declaration.CtPackage; +import spoon.reflect.declaration.CtType; +import spoon.reflect.factory.Factory; + +public class ForEachFlip extends SingleTransformation { + CtClass host; + CtForEach tp; + Factory f; + CtType newType; + public ForEachFlip(CtForEach tp) { + host = tp.getParent(CtClass.class); + this.tp = tp; + f = tp.getFactory(); + //newType = f.Class().create() + } + + @Override + public String classLocationName() { + return null; + } + + @Override + public String packageLocationName() { + return null; + } + + @Override + public String methodLocationName() { + return null; + } + + @Override + public SourcePosition getPosition() { + return null; + } + + @Override + public int line() { + return 0; + } + + @Override + public String getTransformationString() throws Exception { + return null; + } + + @Override + public void apply(String srcDir) throws Exception { + //ctPackage.addType() + CtExpression old = tp.getExpression(); + CtExpression newE = f.Code().createCodeSnippetExpression(""); + //tp.setExpression() + } + + @Override + public void restore(String srcDir) throws RestoreTransformationException { + + } +} diff --git a/generator/src/main/java/fr/inria/diversify/transformation/LoopFlip.java b/generator/src/main/java/fr/inria/diversify/transformation/LoopFlip.java index cdfc9dbd..446335fe 100644 --- a/generator/src/main/java/fr/inria/diversify/transformation/LoopFlip.java +++ b/generator/src/main/java/fr/inria/diversify/transformation/LoopFlip.java @@ -7,11 +7,14 @@ import spoon.reflect.cu.SourcePosition; import spoon.reflect.declaration.CtMethod; import spoon.reflect.declaration.CtPackage; +import spoon.reflect.declaration.CtParameter; import spoon.reflect.declaration.CtType; import spoon.reflect.factory.Factory; import spoon.reflect.reference.CtVariableReference; import spoon.support.reflect.code.*; +import java.util.List; + /** * Created by nicolas on 11.10.16. */ @@ -62,7 +65,20 @@ public String packageLocationName() { @Override public String methodLocationName() { - return tp.getParent(CtMethod.class).getSimpleName(); + + CtMethod m = tp.getParent(CtMethod.class); + String params = "("; + boolean isFirst = true; + List ps = m.getParameters(); + for(CtParameter p : ps) { + if(isFirst) isFirst = false; + else params +=", "; + params += p.getType().getQualifiedName(); + } + params += ")"; + String method = m.getDeclaringType().getQualifiedName() + "." + + m.getSimpleName() + params; + return method; } @Override diff --git a/generator/src/main/java/fr/inria/diversify/transformation/SwapSubType.java b/generator/src/main/java/fr/inria/diversify/transformation/SwapSubType.java index 139dd6b6..e6c4f281 100644 --- a/generator/src/main/java/fr/inria/diversify/transformation/SwapSubType.java +++ b/generator/src/main/java/fr/inria/diversify/transformation/SwapSubType.java @@ -8,6 +8,8 @@ import spoon.reflect.declaration.*; import spoon.reflect.factory.Factory; +import java.util.List; + /** * Created by nharrand on 06/12/16. */ @@ -56,7 +58,20 @@ public String packageLocationName() { @Override public String methodLocationName() { - return "unknown"; + + CtMethod m = tp.getParent(CtMethod.class); + String params = "("; + boolean isFirst = true; + List ps = m.getParameters(); + for(CtParameter p : ps) { + if(isFirst) isFirst = false; + else params +=", "; + params += p.getType().getQualifiedName(); + } + params += ")"; + String method = m.getDeclaringType().getQualifiedName() + "." + + m.getSimpleName() + params; + return method; } @Override diff --git a/generator/src/main/java/fr/inria/diversify/transformation/query/AddMethodInvocationQuery.java b/generator/src/main/java/fr/inria/diversify/transformation/query/AddMethodInvocationQuery.java index 55345a1a..a42f0186 100644 --- a/generator/src/main/java/fr/inria/diversify/transformation/query/AddMethodInvocationQuery.java +++ b/generator/src/main/java/fr/inria/diversify/transformation/query/AddMethodInvocationQuery.java @@ -9,6 +9,7 @@ import spoon.reflect.factory.Factory; import spoon.reflect.reference.CtExecutableReference; import spoon.reflect.reference.CtTypeReference; +import spoon.reflect.visitor.filter.TypeFilter; import java.util.*; import java.util.stream.Collectors; @@ -86,7 +87,11 @@ private void findCandidates() { //.collect(Collectors.toList()) .collect(Collectors.toMap(ce -> ce, ce -> VarFinder.getAccessibleMethods(ce))) );*/ - Collection stmts = getInputProgram().getAllElement(CtStatement.class); + //Collection stmts = getInputProgram().getAllElement(CtStatement.class); + Collection stmts = getInputProgram() + .getFactory() + .getModel() + .getElements(new TypeFilter<>(CtStatement.class)); Collection stmtsFiltered = new ArrayList<>(); for(CtStatement statement: stmts) { @@ -284,6 +289,34 @@ private CtStatement buildSuitableInvocation(CtStatement tp, List metho int cur = 0; + public Transformation buildTransformation() throws QueryException { + Transformation res = null; + while (res == null && hasNextTransformation()) { + if((dumpMethodsAfterSuccess && (cur >= maxMethodsPerStmt)) || (((curCandidate == null) || curMethods.isEmpty()))) { + if(!candidateIt.hasNext()) throw new QueryException("No valid candidate"); + cur = 0; + curCandidate = candidateIt.next(); + if(externalMethods && nonstaticMethods && !internalMethods && !staticMethods) + curMethods = new ArrayList<>(VarFinder.getTargetableMethods(curCandidate)); + else if (!externalMethods && internalMethods) + curMethods = new ArrayList<>(VarFinder.getInternalMethods(curCandidate, staticMethods, nonstaticMethods)); + else + curMethods = new ArrayList<>(VarFinder.getAccessibleMethods(curCandidate, staticMethods, nonstaticMethods)); + } + + + if(shuffleMethods) Collections.shuffle(curMethods); + CtStatement invocation = buildInvocation(curCandidate, curMethods); + curMethods.removeAll(toRemove); + toRemove.clear(); + if(invocation != null) { + cur++; + res = new AddMethodInvocation(curCandidate, invocation); + } + } + return res; + } + @Override public Transformation query() throws QueryException { //curCandidate = candidateIt.next(); @@ -291,7 +324,7 @@ public Transformation query() throws QueryException { //curMethods = new ArrayList<>(VarFinder.getInternalMethods(curCandidate, staticMethods, nonstaticMethods)); - if((dumpMethodsAfterSuccess && (cur >= maxMethodsPerStmt)) || (((curCandidate == null) || curMethods.isEmpty()))) { + /*if((dumpMethodsAfterSuccess && (cur >= maxMethodsPerStmt)) || (((curCandidate == null) || curMethods.isEmpty()))) { if(!candidateIt.hasNext()) throw new QueryException("No valid candidate"); cur = 0; curCandidate = candidateIt.next(); @@ -316,7 +349,12 @@ else if (!externalMethods && internalMethods) return query(); } else { throw new QueryException("No valid candidate"); + }*/ + Transformation t = buildTransformation(); + if(t == null) { + new QueryException("No valid candidate"); } + return t; } // diff --git a/generator/src/main/java/fr/inria/diversify/transformation/query/ForEachFlipQuery.java b/generator/src/main/java/fr/inria/diversify/transformation/query/ForEachFlipQuery.java new file mode 100644 index 00000000..4a922957 --- /dev/null +++ b/generator/src/main/java/fr/inria/diversify/transformation/query/ForEachFlipQuery.java @@ -0,0 +1,21 @@ +package fr.inria.diversify.transformation.query; + +import fr.inria.diversify.runner.InputProgram; +import fr.inria.diversify.transformation.Transformation; +import spoon.reflect.code.CtForEach; +import spoon.reflect.code.CtStatement; + +import java.util.List; + +public class ForEachFlipQuery extends TransformationQuery { + private List candidateList; + public ForEachFlipQuery(InputProgram inputProgram) { + super(inputProgram); + candidateList = inputProgram.getAllElement(CtForEach.class); + } + + @Override + public Transformation query() throws QueryException { + return null; + } +} diff --git a/generator/src/main/java/fr/inria/diversify/util/ChangIterable.java b/generator/src/main/java/fr/inria/diversify/util/ChangIterable.java new file mode 100644 index 00000000..209c2ca0 --- /dev/null +++ b/generator/src/main/java/fr/inria/diversify/util/ChangIterable.java @@ -0,0 +1,32 @@ +package fr.inria.diversify.util; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +public class ChangIterable> implements Iterable { + private T iterable; + + public ChangIterable(T iterable) { + this.iterable = iterable; + } + + @Override + public Iterator iterator() { + List list = new ArrayList<>(); + for(U o: iterable) list.add(o); + return new Iterator() { + int i = list.size()-1; + List l = list; + @Override + public boolean hasNext() { + return i >= 0; + } + + @Override + public U next() { + return l.get(i--); + } + }; + } +} diff --git a/generator/src/main/java/fr/inria/diversify/util/RandomLiteralFactory.java b/generator/src/main/java/fr/inria/diversify/util/RandomLiteralFactory.java index 7e570f4d..b47b1ecb 100644 --- a/generator/src/main/java/fr/inria/diversify/util/RandomLiteralFactory.java +++ b/generator/src/main/java/fr/inria/diversify/util/RandomLiteralFactory.java @@ -91,39 +91,42 @@ public static CtLiteral randomValue(CtTypeReference t) { SecureRandom sr = new SecureRandom(); byte b[]; //if(t.getActualClass() == byte.class) { - if(t.getQualifiedName() == "byte") { + if(t.getQualifiedName().equals("byte")) { b = new byte[1]; sr.nextBytes(b); return f.Code().createLiteral(toByte(b)); - } else if (t.getQualifiedName() == "short") { + } else if (t.getQualifiedName().equals("short")) { b = new byte[2]; sr.nextBytes(b); return f.Code().createLiteral(toShort(b)); - } else if (t.getQualifiedName() == "char") { + } else if (t.getQualifiedName().equals("char")) { b = new byte[2]; sr.nextBytes(b); return f.Code().createLiteral(toChar(b)); - } else if (t.getQualifiedName() == "int") { + } else if (t.getQualifiedName().equals("int")) { b = new byte[4]; sr.nextBytes(b); return f.Code().createLiteral(toInt(b)); - } else if (t.getQualifiedName() == "long") { + } else if (t.getQualifiedName().equals("long")) { b = new byte[8]; sr.nextBytes(b); return f.Code().createLiteral(toLong(b)); - } else if (t.getQualifiedName() == "float") { + } else if (t.getQualifiedName().equals("float")) { b = new byte[4]; sr.nextBytes(b); return f.Code().createLiteral(toFloat(b)); - } else if (t.getQualifiedName() == "double") { + } else if (t.getQualifiedName().equals("double")) { b = new byte[8]; sr.nextBytes(b); return f.Code().createLiteral(toDouble(b)); - } else if (t.getQualifiedName() == "boolean") { + } else if (t.getQualifiedName().equals("boolean")) { b = new byte[1]; sr.nextBytes(b); - if(b[0] <= 127) return f.Code().createLiteral(true); + if(b[0] <= 0) return f.Code().createLiteral(true); else return f.Code().createLiteral(false); + } else if (t.getQualifiedName().equals("java.lang.String")) { + + return f.Code().createLiteral(createString()); } else { return f.Code().createLiteral(null); } diff --git a/generator/src/resources/ReverseIterableTemplate b/generator/src/resources/ReverseIterableTemplate new file mode 100644 index 00000000..dd7022ee --- /dev/null +++ b/generator/src/resources/ReverseIterableTemplate @@ -0,0 +1,30 @@ +new java.util.Iterable<#TYPE#>() { + java.util.List<#TYPE#> list = new java.util.ArrayList<>(); + boolean initialized = false; + + void init() { + for (#TYPE# o : #ITERABLE#) list.add(o); + initialized = true; + } + + @Override + public Iterator<#TYPE#> iterator() { + + return new Iterator() { + int i = list.size() - 1; + java.util.List<#TYPE#> l2 = list; + + @Override + public boolean hasNext() { + if(!initialized) {init();i = list.size() - 1;} + return i >= 0; + } + + @Override + public #TYPE# next() { + if(!initialized) {init();i = list.size() - 1;} + return l2.get(i--); + } + }; + } +} \ No newline at end of file diff --git a/generator/src/test/java/fr/inria/diversify/transformation/query/LoopFlipQueryTest.java b/generator/src/test/java/fr/inria/diversify/transformation/query/LoopFlipQueryTest.java index a4e02ca9..def976c8 100644 --- a/generator/src/test/java/fr/inria/diversify/transformation/query/LoopFlipQueryTest.java +++ b/generator/src/test/java/fr/inria/diversify/transformation/query/LoopFlipQueryTest.java @@ -42,7 +42,7 @@ public void setUp() { public static boolean containsString(Iterable s, String v) { for(String str : s) { - if(str.compareTo(v) == 0) return true; + if(v.contains(str)) return true; } return false; } diff --git a/generator/src/test/java/fr/inria/diversify/util/ChangIterableTest.java b/generator/src/test/java/fr/inria/diversify/util/ChangIterableTest.java new file mode 100644 index 00000000..6b448244 --- /dev/null +++ b/generator/src/test/java/fr/inria/diversify/util/ChangIterableTest.java @@ -0,0 +1,61 @@ +package fr.inria.diversify.util; + +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import static org.junit.Assert.*; + +public class ChangIterableTest { + @Test + public void iterator() throws Exception { + List l = new ArrayList<>(); + l.add("a"); + l.add("b"); + l.add("c"); + l.add("d"); + int i = 4; + //ChangIterable> c = new ChangIterable<>(l); + for(String s : new ChangIterable<>(l)) { + System.out.println(s); + assertEquals(s,l.get(--i)); + } + i = 4; + for(String s: new Iterable() { + List list = new ArrayList<>(); + boolean initialized = false; + + void initia() { + for (String o : l) list.add(o); + initialized = true; + } + + @Override + public Iterator iterator() { + + return new Iterator() { + int i = list.size() - 1; + List l2 = list; + + @Override + public boolean hasNext() { + if(!initialized) {initia();i = list.size() - 1;} + return i >= 0; + } + + @Override + public String next() { + if(!initialized) {initia();i = list.size() - 1;} + return l2.get(i--); + } + }; + } + }) { + System.out.println(s); + assertEquals(s,l.get(--i)); + } + } + +} \ No newline at end of file diff --git a/main/src/main/java/fr/inria/diversify/DiversifyMain.java b/main/src/main/java/fr/inria/diversify/DiversifyMain.java index 3e86dc09..6b2bfef4 100644 --- a/main/src/main/java/fr/inria/diversify/DiversifyMain.java +++ b/main/src/main/java/fr/inria/diversify/DiversifyMain.java @@ -160,6 +160,9 @@ protected AbstractRunner initRunner() throws Exception { String resultDir = inputConfiguration.getProperty("result"); switch (runner) { + case "smart": + abstractRunner = new SmartRunner(inputConfiguration, project, src); + break; case "simple": abstractRunner = new SinglePointRunner(inputConfiguration, project, src); break;