public ArrayReference appendArrayStmt(Type type, int... length) { ArrayStatement arrayStmt = new ArrayStatement(tc, type, length); tc.addStatement(arrayStmt); return (ArrayReference) arrayStmt.getReturnValue(); }
/** * <p> * Constructor for ArrayStatement. * </p> * * @param tc * a {@link org.evosuite.testcase.TestCase} object. * @param type * a {@link java.lang.reflect.Type} object. */ public ArrayStatement(TestCase tc, java.lang.reflect.Type type) { this(tc, type, createRandom(determineDimensions(type))); }
/** {@inheritDoc} */ @Override public List<VariableReference> getUniqueVariableReferences() { return new ArrayList<VariableReference>(getVariableReferences()); }
@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]")); }
ArrayStatement statement = new ArrayStatement(test, arrayClass.getType()); VariableReference reference = test.addStatement(statement, position); position++; logger.debug("Array length: " + statement.size()); logger.debug("Array component type: " + reference.getComponentType()); if (current instanceof ArrayIndex) { ArrayIndex index = (ArrayIndex) current; if (index.getArray().equals(statement.getReturnValue())) iterator.remove(); objects.remove(statement.getReturnValue()); logger.debug("Found assignable objects: " + objects.size()); Set<GenericAccessibleObject<?>> currentArrayRecursion = new LinkedHashSet<>(currentRecursion); for (int i = 0; i < statement.size(); i++) { currentRecursion.clear(); currentRecursion.addAll(currentArrayRecursion);
/** {@inheritDoc} */ @Override public Statement copy(TestCase newTestCase, int offset) { ArrayStatement copy = new ArrayStatement(newTestCase, retval.getType(), lengths); // copy.assertions = copyAssertions(newTestCase, offset); return copy; }
} else { arrRef = new ArrayReference(testCase, arrType); final ArrayStatement arrStmt = new ArrayStatement(testCase, arrRef); arrStmt.setSize(params.length); testCase.addStatement(arrStmt); this.oidToVarRefMap.put(oid, arrRef);
p.size()); ExecutionResult oldResult = test.getLastExecutionResult(); oldLength = p.size(); boolean done = false; while (!done) { done = true; p.setSize(oldLength + 1); logger.debug("Trying increment of {}", p.getCode()); if (objective.hasImproved(test)) { done = false; oldLength = p.size(); oldResult = test.getLastExecutionResult(); p.setSize(oldLength + 1); logger.debug("Trying increment of {}", p.getCode()); improved = objective.hasImproved(test); p.setSize(oldLength); test.setLastExecutionResult(oldResult); test.setChanged(false); p.setSize(oldLength); test.setLastExecutionResult(oldResult); test.setChanged(false); p.setSize(oldLength - 1); } else { p.setSize(Properties.MAX_ARRAY);
public void visitArrayStatement(TestCase test, ArrayStatement statement) { ArrayReference arrRef = (ArrayReference) statement.getReturnValue(); int position = statement.getPosition() + 1; position = statement.getPosition() + 1; for (int i = 0; i < statement.size(); i++) { if (assignments.contains(i)) continue;
VariableReference retval = statement.getReturnValue(); List<Integer> lengths = statement.getLengths();
private int stripAssignments(ArrayStatement statement, TestChromosome test, LocalSearchObjective<TestChromosome> objective) { int difference = 0; ArrayReference arrRef = (ArrayReference) statement.getReturnValue(); TestFactory factory = TestFactory.getInstance(); for (int position = test.size() - 1; position > statement.getPosition(); position--) { logger.debug("Current delete position: " + position); if (test.getTestCase().getStatement(position) instanceof AssignmentStatement) { || valueStatement instanceof NullStatement) { if (!test.getTestCase().hasReferences(valueStatement.getReturnValue())) { if (valueStatement.getPosition() < statement.getPosition()) differenceDelta = 1; currentDelta = 1;
public ArrayReference getArrayReference() { return (ArrayReference) getReturnValue(); } }
/** * <p> * Constructor for ArrayReference. * </p> * * @param tc * a {@link org.evosuite.testcase.TestCase} object. * @param clazz * a {@link java.lang.Class} object. */ public ArrayReference(TestCase tc, Class<?> clazz) { this(tc, new GenericClass(clazz), new int[ArrayStatement.determineDimensions(clazz)]); }
logger.debug("Finished local search with result {}", p.getCode()); return hasImproved;
@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; }
private void after(ArrayStatement s, Scope scope) { try { ArrayReference arrayRef = (ArrayReference) s.getReturnValue(); Object conc_array; conc_array = arrayRef.getObject(scope);
VariableReference objectVar = test.addStatement(cs); ArrayStatement as = new ArrayStatement(test, Object[].class, 3); test.addStatement(as); ArrayReference arrayVar = as.getArrayReference();
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);
/** * <p> * Constructor for ArrayStatement. * </p> * * @param tc * a {@link org.evosuite.testcase.TestCase} object. * @param arrayReference * a {@link org.evosuite.testcase.variable.ArrayReference} object. */ public ArrayStatement(TestCase tc, ArrayReference arrayReference) { this(tc, arrayReference, createRandom(determineDimensions(arrayReference.getType()))); }