/** * var := array[index] * * @param var * @param array * @param index */ public void appendAssignment(VariableReference var, ArrayReference array, int index) { ArrayIndex arrayIndex = new ArrayIndex(tc, array, index); AssignmentStatement stmt = new AssignmentStatement(tc, var, arrayIndex); tc.addStatement(stmt); }
/** * array[index] := var * * @param array * @param index * @param var */ public void appendAssignment(ArrayReference array, int index, VariableReference var) { ArrayIndex arrayIndex = new ArrayIndex(tc, array, index); AssignmentStatement stmt = new AssignmentStatement(tc, arrayIndex, var); tc.addStatement(stmt); }
/** {@inheritDoc} */ @Override public Statement copy(TestCase newTestCase, int offset) { try { VariableReference newParam = parameter.copy(newTestCase, offset); VariableReference newTarget; // FIXXME: Return value should always be an existing variable //if (retval.getAdditionalVariableReference() != null) newTarget = retval.copy(newTestCase, offset); //else // newTarget = retval.copy(newTestCase, offset); //newTarget = new VariableReferenceImpl(newTestCase, retval.getType()); AssignmentStatement copy = new AssignmentStatement(newTestCase, newTarget, newParam); // copy.assertions = copyAssertions(newTestCase, offset); //logger.info("Copy of statement is: " + copy.getCode()); return copy; } catch (Exception e) { logger.info("Error cloning statement " + getCode()); logger.info("In test: " + this.tc.toCode()); logger.info("New test: " + newTestCase.toCode()); e.printStackTrace(); assert (false) : e.toString(); } return null; }
final VariableReference nullReference = testCase.addStatement(nullStmt); assignment = new AssignmentStatement(testCase, targetFieldRef, nullReference); } else { assignment = new AssignmentStatement(testCase, targetFieldRef, this.oidToVarRefMap.get(arg));
assignStmt = new AssignmentStatement(testCase, arrIndex, valueRef); testCase.addStatement(assignStmt); logger.debug("Adding assignment (array): "+assignStmt.getCode());
public void appendAssignment(VariableReference receiver, Field field, VariableReference value) { FieldReference fieldReference; if (receiver == null) { fieldReference = new FieldReference(tc, new GenericField(field, field.getDeclaringClass())); } else { fieldReference = new FieldReference(tc, new GenericField(field, receiver.getType()), receiver); } AssignmentStatement stmt = new AssignmentStatement(tc, fieldReference, value); tc.addStatement(stmt); }
Statement st = new AssignmentStatement(test, index, choice); test.addStatement(st, position); } else { Statement st = new AssignmentStatement(test, index, var); test.addStatement(st, position);
/** * Add reference to a field of variable "callee" * * @param test * @param callee * @param field * @param position * @return * @throws ConstructionFailedException */ public VariableReference addFieldFor(TestCase test, VariableReference callee, GenericField field, int position) throws ConstructionFailedException { logger.debug("Adding field " + field + " for variable " + callee); if(position <= callee.getStPosition()) throw new ConstructionFailedException("Cannot insert call on object before the object is defined"); currentRecursion.clear(); FieldReference fieldVar = new FieldReference(test, field, callee); int length = test.size(); VariableReference value = createOrReuseVariable(test, fieldVar.getType(), position, 0, callee, true, false, true); int newLength = test.size(); position += (newLength - length); Statement st = new AssignmentStatement(test, fieldVar, value); VariableReference ret = test.addStatement(st, position); ret.setDistance(callee.getDistance() + 1); assert (test.isValid()); return ret; }
retVal = test.addStatement(nullStatement, position++); AssignmentStatement assignment = new AssignmentStatement(test, index, retVal); test.addStatement(assignment, position++);
throw new ConstructionFailedException("Self assignment"); Statement st = new AssignmentStatement(test, f, var); VariableReference ret = test.addStatement(st, position);
/** * x.f1 := y.f2 * * @param var * @param array * @param index */ public void appendAssignment(VariableReference receiver, Field field, VariableReference src, Field fieldSrc) { FieldReference dstFieldReference; if (receiver == null) { dstFieldReference = new FieldReference(tc, new GenericField(field, field.getDeclaringClass())); } else { dstFieldReference = new FieldReference(tc, new GenericField(field, receiver.getType()), receiver); } FieldReference srcFieldReference; if (src == null) { srcFieldReference = new FieldReference(tc, new GenericField(fieldSrc, fieldSrc.getDeclaringClass())); } else { srcFieldReference = new FieldReference(tc, new GenericField(fieldSrc, src.getType()), src); } AssignmentStatement stmt = new AssignmentStatement(tc, dstFieldReference, srcFieldReference); tc.addStatement(stmt); }
ArrayIndex ai1 = new ArrayIndex(test, arrayVar, 1); ArrayIndex ai2 = new ArrayIndex(test, arrayVar, 2); test.addStatement(new AssignmentStatement(test, ai0, objectVar)); test.addStatement(new AssignmentStatement(test, ai1, objectVar)); test.addStatement(new AssignmentStatement(test, ai2, objectVar));
@Test public void testInputCoverageClassWithField() throws NoSuchFieldException, NoSuchMethodException { Class<?> sut = ClassWithField.class; DefaultTestCase tc = new DefaultTestCase(); // ClassWithField classWithField0 = new ClassWithField(); GenericConstructor constructor = new GenericConstructor(sut.getConstructors()[0], sut); ConstructorStatement constructorStatement = new ConstructorStatement(tc, constructor, Arrays.asList(new VariableReference[] {})); VariableReference obj = tc.addStatement(constructorStatement); // classWithField0.testFoo(classWithField0.BOOLEAN_FIELD); FieldReference field = new FieldReference(tc, new GenericField(sut.getDeclaredField("BOOLEAN_FIELD"), sut),obj); Method m = sut.getMethod("testFoo", new Class<?>[] { Boolean.TYPE}); GenericMethod gm = new GenericMethod(m, sut); tc.addStatement(new MethodStatement(tc, gm, obj, Arrays.asList(new VariableReference[] {field}))); // classWithField0.BOOLEAN_FIELD = false; VariableReference boolRef = tc.addStatement(new BooleanPrimitiveStatement(tc,false)); tc.addStatement(new AssignmentStatement(tc, field, boolRef)); tc.addStatement(new MethodStatement(tc, gm, obj, Arrays.asList(new VariableReference[] {field}))); Properties.TARGET_CLASS = sut.getCanonicalName(); Properties.JUNIT_TESTS = true; TestSuiteChromosome testSuite = new TestSuiteChromosome(); testSuite.addTest(tc); FitnessFunction ffunction = FitnessFunctions.getFitnessFunction(Properties.Criterion.INPUT); assertEquals("Should be 0.0", 0.0, ffunction.getFitness(testSuite), 0.0); assertEquals("Should be 1.0", 1.0, testSuite.getCoverage(ffunction), 0.0); }
ArrayIndex ai1 = new ArrayIndex(test, arrayVar, 1); ArrayIndex ai2 = new ArrayIndex(test, arrayVar, 2); test.addStatement(new AssignmentStatement(test, ai0, intVar)); test.addStatement(new AssignmentStatement(test, ai1, intVar)); test.addStatement(new AssignmentStatement(test, ai2, intVar));
@Test public void testFieldReferenceNeedsDowncast() throws NoSuchMethodException, NoSuchFieldException { TestCaseBuilder builder = new TestCaseBuilder(); VariableReference var = builder.appendConstructor(DowncastExample.class.getConstructor()); VariableReference num0 = builder.appendMethod(var, DowncastExample.class.getMethod("getAbstractFoo")); num0.setType(ConcreteSubclass.class); // This would be set during execution VariableReference bool0 = builder.appendBooleanPrimitive(true); DefaultTestCase test = builder.getDefaultTestCase(); FieldReference fr = new FieldReference(test, new GenericField(ConcreteSubclass.class.getField("fieldInConcreteClass"), ConcreteSubclass.class), num0); AssignmentStatement statement = new AssignmentStatement(test, fr, bool0); test.addStatement(statement); test.removeDownCasts(); System.out.println(test); FieldReference fr2 = (FieldReference)test.getStatement(3).getReturnValue(); assertEquals(ConcreteSubclass.class, fr2.getSource().getVariableClass()); }
@Test public void testFieldReferenceDoesNotNeedDowncast() throws NoSuchMethodException, NoSuchFieldException { TestCaseBuilder builder = new TestCaseBuilder(); VariableReference var = builder.appendConstructor(DowncastExample.class.getConstructor()); VariableReference num0 = builder.appendMethod(var, DowncastExample.class.getMethod("getAbstractFoo")); num0.setType(ConcreteSubclass.class); // This would be set during execution VariableReference bool0 = builder.appendBooleanPrimitive(true); DefaultTestCase test = builder.getDefaultTestCase(); FieldReference fr = new FieldReference(test, new GenericField(AbstractSuperclass.class.getField("fieldInAbstractClass"), AbstractSuperclass.class), num0); AssignmentStatement statement = new AssignmentStatement(test, fr, bool0); test.addStatement(statement); test.removeDownCasts(); System.out.println(test); FieldReference fr2 = (FieldReference)test.getStatement(3).getReturnValue(); assertEquals(AbstractSuperclass.class, fr2.getSource().getVariableClass()); }
@Test public void testCastAndBoxingInArray() { // short[] shortArray0 = new short[5]; // Long[] longArray0 = new Long[5]; // longArray0[0] = (Long) shortArray0[1]; <-- this gives a compile error TestCase tc = new DefaultTestCase(); ArrayStatement shortArrayStatement = new ArrayStatement(tc, short[].class, 5); tc.addStatement(shortArrayStatement); ArrayStatement longArrayStatement = new ArrayStatement(tc, Long[].class, 5); tc.addStatement(longArrayStatement); ArrayIndex longIndex = new ArrayIndex(tc, longArrayStatement.getArrayReference(), 0); ArrayIndex shortIndex = new ArrayIndex(tc, shortArrayStatement.getArrayReference(), 1); AssignmentStatement assignmentStatement = new AssignmentStatement(tc, longIndex, shortIndex); tc.addStatement(assignmentStatement); String code = tc.toCode(); System.out.println(tc); assertFalse(code.contains("longArray0[0] = (Long) shortArray0[1]")); }
@Test public void testWrapperCastInArray() { // Short[] shortArray0 = new Short[5]; // Integer[] integerArray0 = new Integer[9]; // integerArray0[0] = (Integer) shortArray0[3]; TestCase tc = new DefaultTestCase(); ArrayStatement shortArrayStatement = new ArrayStatement(tc, Short[].class, 5); tc.addStatement(shortArrayStatement); ArrayStatement intArrayStatement = new ArrayStatement(tc, Integer[].class, 9); tc.addStatement(intArrayStatement); ArrayIndex intIndex = new ArrayIndex(tc, intArrayStatement.getArrayReference(), 0); ArrayIndex shortIndex = new ArrayIndex(tc, shortArrayStatement.getArrayReference(), 3); AssignmentStatement assignmentStatement = new AssignmentStatement(tc, intIndex, shortIndex); tc.addStatement(assignmentStatement); String code = tc.toCode(); System.out.println(tc); assertFalse(code.contains("integerArray0[0] = (Integer) shortArray0[3]")); }
private TestCase getArrayTest(int length) throws NoSuchMethodException, SecurityException, ConstructionFailedException, ClassNotFoundException { Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(Properties.TARGET_CLASS); GenericClass clazz = new GenericClass(sut); DefaultTestCase test = new DefaultTestCase(); GenericConstructor gc = new GenericConstructor(clazz.getRawClass().getConstructors()[0], clazz); TestFactory testFactory = TestFactory.getInstance(); VariableReference callee = testFactory.addConstructor(test, gc, 0, 0); VariableReference arrayVar = test.addStatement(new ArrayStatement(test, int[].class, length)); for(int i = 0; i < length; i++) { // Add value VariableReference intVar = test.addStatement(new IntPrimitiveStatement(test, 0)); test.addStatement(new AssignmentStatement(test, new ArrayIndex(test, (ArrayReference) arrayVar, i), intVar)); } Method m = clazz.getRawClass().getMethod("testMe", new Class<?>[] { int[].class }); GenericMethod method = new GenericMethod(m, sut); MethodStatement ms = new MethodStatement(test, method, callee, Arrays.asList(new VariableReference[] {arrayVar})); test.addStatement(ms); return test; }
ArrayReference mockedArray = (ArrayReference) tc.addStatement(new ArrayStatement(tc,String[].class,1)); ArrayIndex arrayIndex = new ArrayIndex(tc, mockedArray, 0); AssignmentStatement stmt = new AssignmentStatement(tc, arrayIndex, aString); tc.addStatement(stmt);