public VariableReference appendStaticFieldStmt(Field field) { Class<?> declaringClass = field.getDeclaringClass(); final GenericField genericField = new GenericField(field, declaringClass); // static field (receiver is null) FieldStatement stmt = new FieldStatement(tc, genericField, null); tc.addStatement(stmt); return stmt.getReturnValue(); }
private void after(FieldStatement s, Scope scope) { ReferenceExpressionPair readResult; if (s.getSource() != null) { readResult = readInstanceField(s.getSource(), s.getField().getField(), scope); } else { readResult = readStaticField(s.getField().getField()); } String lhs_name = s.getReturnValue().getName(); Expression<?> expr = readResult.getExpression(); ReferenceExpression ref = readResult.getReference(); if (expr != null) symb_expressions.put(lhs_name, expr); if (ref != null) symb_references.put(lhs_name, ref); }
/** * Try to replace source of field with all possible choices * * @param test * @param statement * @param objective */ private boolean doSearch(TestChromosome test, FieldStatement statement, LocalSearchObjective<TestChromosome> objective) { if (!statement.isStatic()) { VariableReference source = statement.getSource(); List<VariableReference> objects = test.getTestCase().getObjects(source.getType(), statement.getPosition()); objects.remove(source); for (VariableReference replacement : objects) { statement.setSource(replacement); if (objective.hasImproved(test)) { return true; } } statement.setSource(source); } return false; } }
private boolean fieldNeedsDownCast(FieldStatement fieldStatement, VariableReference var, Class<?> abstractClass) { if(!fieldStatement.isStatic() && fieldStatement.getSource().equals(var)) { if(!fieldStatement.getField().getDeclaringClass().isAssignableFrom(abstractClass)) { // Need downcast for real return true; } } return false; }
if (fieldStatement.getField().isStatic()) { VariableReference fieldReference = fieldStatement.getReturnValue(); if (Properties.RESET_STATIC_FIELD_GETS) { moreClassesForStaticReset.add(fieldStatement.getField().getOwnerClass().getClassName()); for (int i = fieldStatement.getPosition() + 1; i < result.getExecutedStatements(); i++) { Statement invokedStatement = tc.getStatement(i); if (invokedStatement.references(fieldReference)) { .isPure(((MethodStatement) invokedStatement).getMethod().getMethod())) { moreClassesForStaticReset .add(fieldStatement.getField().getOwnerClass().getClassName()); break;
FieldStatement f = new FieldStatement(test, field, source, retval); test.setStatement(f, position); logger.debug("Using field {}", f.getCode()); } catch (Throwable e) { logger.error("Error: " + e + " , Field: " + field + " , Test: " + test);
private static Class<?> getUnderlyingType(FieldStatement fs) { return fs.getField().getDeclaringClass(); }
@Override public int getNumParameters() { if (isStatic()) return 0; else return 1; }
/** * Returns true if the variable var is used as callee later on in the test * * @param test * @param var * @return */ protected boolean isUsedAsCallee(TestCase test, VariableReference var) { for (int pos = var.getStPosition() + 1; pos < test.size(); pos++) { Statement statement = test.getStatement(pos); if (statement instanceof MethodStatement) { if (((MethodStatement) statement).getCallee() == var) return true; } else if (statement instanceof FieldStatement) { if (((FieldStatement) statement).getSource() == var) return true; } } return false; }
final FieldStatement fieldStatement = new FieldStatement(testCase, new GenericField(FieldUtils.getField(type, fieldName, true), type), this.oidToVarRefMap.get(oid));
/** {@inheritDoc} */ @Override public List<VariableReference> getUniqueVariableReferences() { return new ArrayList<VariableReference>(getVariableReferences()); }
} else if (s instanceof FieldStatement) { FieldStatement fs = (FieldStatement) s; accessedClasses.add(fs.getField().getField().getDeclaringClass()); accessedClasses.add(fs.getField().getField().getType()); } else if (s instanceof ConstructorStatement) { ConstructorStatement cs = (ConstructorStatement) s;
/** {@inheritDoc} */ @Override public Set<VariableReference> getVariableReferences() { Set<VariableReference> references = new LinkedHashSet<VariableReference>(); references.add(retval); if (!isStatic()) { references.add(source); if (source.getAdditionalVariableReference() != null) references.add(source.getAdditionalVariableReference()); } return references; }
if(var.equals(fs.getSource())) {
Statement st = new FieldStatement(test, field, callee);
/** * Try to replace source of field with all possible choices * * @param test * @param statement */ private boolean replaceFieldSource(TestChromosome test, FieldStatement statement) { if (!statement.isStatic()) { VariableReference source = statement.getSource(); List<VariableReference> objects = test.getTestCase().getObjects(source.getType(), statement.getPosition()); objects.remove(source); if (!objects.isEmpty()) { statement.setSource(Randomness.choice(objects)); test.setChanged(true); } } return false; }
StringBuilder builder = new StringBuilder(); VariableReference retval = statement.getReturnValue(); GenericField field = statement.getField(); VariableReference source = statement.getSource(); builder.append(getVariableName(retval)); builder.append(" = ");
public VariableReference appendFieldStmt(VariableReference receiver, Field field) { if (receiver == null) { throw new NullPointerException( "Receiver object for a non-static field cannot be null"); } FieldStatement stmt = new FieldStatement(tc, new GenericField(field, receiver.getType()), receiver); tc.addStatement(stmt); return stmt.getReturnValue(); }
/** * Check if this statement is related to the unit under test * * @param statement * a {@link org.evosuite.testcase.statements.Statement} object. * @return a boolean. */ protected boolean isTargetStatement(Statement statement) { //if (statement.getReturnClass().equals(Properties.getTargetClass())) // return true; if (statement instanceof MethodStatement) { MethodStatement ms = (MethodStatement) statement; final Class<?> targetClass = Properties.getTargetClassAndDontInitialise(); if (targetClass.equals(ms.getMethod().getDeclaringClass())) return true; } else if (statement instanceof ConstructorStatement) { ConstructorStatement cs = (ConstructorStatement) statement; final Class<?> targetClass = Properties.getTargetClassAndDontInitialise(); if (targetClass.equals(cs.getConstructor().getDeclaringClass())) return true; } else if (statement instanceof FieldStatement) { FieldStatement fs = (FieldStatement) statement; final Class<?> targetClass = Properties.getTargetClassAndDontInitialise(); if (targetClass.equals(fs.getField().getDeclaringClass())) return true; } return false; }
/** * Try to replace source of field with all possible choices * * @param test * @param statement * @param objective */ /* (non-Javadoc) * @see org.evosuite.testcase.AbstractStatement#mutate(org.evosuite.testcase.TestCase, org.evosuite.testcase.TestFactory) */ @Override public boolean mutate(TestCase test, TestFactory factory) { if (Randomness.nextDouble() >= Properties.P_CHANGE_PARAMETER) return false; if (!isStatic()) { VariableReference source = getSource(); List<VariableReference> objects = test.getObjects(source.getType(), getPosition()); objects.remove(source); if (!objects.isEmpty()) { setSource(Randomness.choice(objects)); return true; } } return false; }