/** * 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); }
/** {@inheritDoc} */ @Override public Set<VariableReference> getVariableReferences() { Set<VariableReference> vars = new LinkedHashSet<VariableReference>(); vars.add(retval); vars.add(parameter); if (retval.getAdditionalVariableReference() != null) vars.add(retval.getAdditionalVariableReference()); if (parameter.getAdditionalVariableReference() != null) vars.add(parameter.getAdditionalVariableReference()); vars.addAll(getAssertionReferences()); return vars; }
/** {@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; }
public void visitAssignmentStatement(TestCase test, AssignmentStatement statement) { VariableReference var = statement.getValue(); if (var.isPrimitive() || var.isString()) { if (usedVariables.contains(var) && test.getStatement(var.getStPosition()) instanceof PrimitiveStatement<?>) { // Duplicate and replace VariableReference varCopy = duplicateStatement(test, var); statement.replace(var, varCopy); usedVariables.add(varCopy); } usedVariables.add(var); } addUnchangedMapping(test, statement.getReturnValue()); }
private void after(AssignmentStatement s, Scope scope) { VariableReference lhs = s.getReturnValue(); VariableReference rhs = s.getValue(); ReferenceExpressionPair readResult = read(rhs, scope); if (lhs instanceof FieldReference) { writeField((FieldReference) lhs, readResult, scope); } else if (lhs instanceof ArrayIndex) { writeArray((ArrayIndex) lhs, readResult, scope); } else { writeVariable(lhs, readResult); } }
assert (isValid()); Set<VariableReference> objects = getSourceReplacements(); objects.remove(retval); objects.remove(parameter); assert (isValid()); return true; assert (isValid());
/** {@inheritDoc} */ @Override public List<VariableReference> getUniqueVariableReferences() { return new ArrayList<VariableReference>(getVariableReferences()); }
@Override public int getPosition() { int pos = 0; for(Statement s : getTestCase()) { if(this == s) return pos; pos++; } throw new RuntimeException("Could not find position of assignment statement"); } }
/** * own comment.. */ @Override public void afterStatement(final Statement statement, final Scope scope, final Throwable exception) { if (statement instanceof AssignmentStatement) { final AssignmentStatement assign = (AssignmentStatement) statement; final VariableReference left = assign.getReturnValue(); if (left instanceof FieldReference) { final FieldReference fieldRef = (FieldReference) left; final GenericField field = fieldRef.getField(); FieldRegistry.notifyModification(field.isStatic() ? null : scope.getObject(fieldRef.getSource()), this.captureId, Type.getInternalName(field.getDeclaringClass()), field.getName(), Type.getDescriptor(field.getField().getType())); //PUTFIELDRegistry creates PUTXXX as well as corresponding GETXXX statements this.captureId -= 2; } } }
if (s.isAssignmentStatement()) { AssignmentStatement assignment = (AssignmentStatement) s; if (assignment.getValue() == var) { VariableReference replacementVar = Randomness.choice(alternatives); if (assignment.getReturnValue().isAssignableFrom(replacementVar)) { s.replace(var, replacementVar); changed = true; } else if (assignment.getReturnValue() == var) { VariableReference replacementVar = Randomness.choice(alternatives); if (replacementVar.isAssignableFrom(assignment.getValue())) { s.replace(var, replacementVar); changed = true;
/** * 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); }
final VariableReference nullReference = testCase.addStatement(nullStmt); assignment = new AssignmentStatement(testCase, targetFieldRef, nullReference); } else { assignment = new AssignmentStatement(testCase, targetFieldRef, this.oidToVarRefMap.get(arg)); logger.debug("Adding assignment statement: "+assignment.getCode()); if (arg != null) { this.oidToVarRefMap.put(arg, varRef);
logger.debug("Is assignment statement"); AssignmentStatement assignment = (AssignmentStatement) test.getTestCase().getStatement(position); Statement valueStatement = test.getTestCase().getStatement(assignment.getValue().getStPosition()); if (assignment.getReturnValue().getAdditionalVariableReference() == arrRef) {
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); }
assignStmt = new AssignmentStatement(testCase, arrIndex, valueRef); testCase.addStatement(assignStmt); logger.debug("Adding assignment (array): "+assignStmt.getCode());
public void visitAssignmentStatement(AssignmentStatement statement) { String cast = ""; VariableReference retval = statement.getReturnValue(); VariableReference parameter = statement.getValue();
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++);
/** * 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); }