@Override public void addAssertionAndComments(Statement statement, List<VariableReference> variables, Throwable exception) { EqualsAssertion assertion = new EqualsAssertion(); assertion.setStatement(statement); VariableReference var = variables.get(0); assertion.setSource(var); assertion.setDest(new ConstantValue(statement.getTestCase(), Object.class)); //assertion.setDest(new NullReference(statement.getTestCase(), var.getType())); assertion.setValue(false); statement.addAssertion(assertion); statement.addComment("Violates contract equals(null)"); }
Set<VariableReference> dependencies = currentTest.getDependencies(statement.getReturnValue()); if (!hasCUT(statement, dependencies)){ return; if (statement.getReturnClass().equals(void.class)) return; if(statement.isAssignmentStatement()) return; visit(statement, scope, statement.getReturnValue()); } catch (CodeUnderTestException e) {
/** {@inheritDoc} */ @Override public boolean isValid() { for (Statement s : statements) { assert (s.isValid()) : toCode(); } return true; }
protected boolean primitiveWithoutAssertion(Statement statement) { if (!statement.getReturnValue().isPrimitive()) return false; Set<Assertion> assertions = statement.getAssertions(); if (assertions.isEmpty()) return true; else { Iterator<Assertion> iterator = assertions.iterator(); VariableReference ret = statement.getReturnValue(); while (iterator.hasNext()) { Assertion ass = iterator.next(); if (ass instanceof PrimitiveAssertion) { if (ass.getReferencedVariables().contains(ret)) { return false; } } } return true; } }
Statement copy = s.clone(t); t.statements.add(copy); copy.setRetval(s.getReturnValue().clone(t)); copy.setAssertions(s.copyAssertions(t, 0));
private Set<Integer> getReferencePositions(TestCase test, int position) { Set<VariableReference> references = new LinkedHashSet<>(); Set<Integer> positions = new LinkedHashSet<>(); references.add(test.getReturnValue(position)); for (int i = position; i < test.size(); i++) { Set<VariableReference> temp = new LinkedHashSet<VariableReference>(); for (VariableReference v : references) { if (test.getStatement(i).references(v)) { temp.add(test.getStatement(i).getReturnValue()); positions.add(i); } } references.addAll(temp); } return positions; }
private void addVariable(Statement statement) { VariableReference retVal = statement.getReturnValue(); variableMap.put(retVal, new LinkedHashSet<Type>()); }
for (Assertion assertion : assertions) { if (assertion instanceof PrimitiveAssertion) { if (assertion.getStatement().equals(test.getStatement(test.size() - 1))) { logger.debug("Adding a primitive assertion " + assertion); test.getStatement(test.size() - 1).addAssertion(assertion); break; if (test.getStatement(test.size() - 1).getAssertions().isEmpty() || justNullAssertion(test.getStatement(test.size() - 1))) { logger.info("Last statement has no assertions: " + test.toCode()); logger.info("Assertions to choose from: " + assertions.size()); if (test.getStatement(test.size() - 1).getAssertions().isEmpty()) { logger.debug("Last statement: " + test.getStatement(test.size() - 1).getCode()); for (Assertion assertion : assertions) { if (assertion instanceof PrimitiveAssertion) { if (assertion.getStatement().equals(test.getStatement(test.size() - 1))) { logger.debug("Adding a primitive assertion " + assertion); test.getStatement(test.size() - 1).addAssertion(assertion); haveAssertion = true; break; if (assertion.getStatement().equals(test.getStatement(test.size() - 1))) { logger.info("Adding an assertion: " + assertion); test.getStatement(test.size() - 1).addAssertion(assertion); haveAssertion = true; break;
@Test public void testDownCastNecessaryForInspectorAssertion() throws NoSuchMethodException { 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 DefaultTestCase test = builder.getDefaultTestCase(); Inspector inspector = new Inspector(ConcreteSubclass.class, ConcreteSubclass.class.getMethod("getBar")); InspectorAssertion assertion = new InspectorAssertion(inspector, test.getStatement(num0.getStPosition()), num0, true); test.getStatement(num0.getStPosition()).addAssertion(assertion); test.removeDownCasts(); System.out.println(test); assertEquals(ConcreteSubclass.class, test.getStatement(1).getReturnClass()); }
@Override public void addAssertionAndComments(Statement statement, List<VariableReference> variables, Throwable exception) { TestCase test = statement.getTestCase(); VariableReference x = test.addStatement(st1, statement.getPosition() + 1); VariableReference y = test.addStatement(st2, statement.getPosition() + 2); assertion.setDest(y); assertion.setValue(true); newStatement.addAssertion(assertion); newStatement.addComment("Violates contract a.equals(b) <-> b.equals(a)");
@Override public void addAssertionAndComments(Statement statement, List<VariableReference> variables, Throwable exception) { TestCase test = statement.getTestCase(); int position = statement.getPosition(); VariableReference a = variables.get(0); int pos = a.getStPosition(); try { Constructor<?> defaultConstructor = theoryReceiver.getClass().getConstructor(); GenericConstructor constructor = new GenericConstructor(defaultConstructor, theoryReceiver.getClass()); Statement st1 = new ConstructorStatement(test, constructor, new ArrayList<VariableReference>()); VariableReference receiver = test.addStatement(st1, position + 1); Statement st2 = new MethodStatement(test, theoryMethod, receiver, Arrays.asList(new VariableReference[] {test.getStatement(pos).getReturnValue()})); test.addStatement(st2, position + 2); st2.addComment("Violates theory: "+theoryMethod.getName()); } catch (NoSuchMethodException e) { // TODO Auto-generated catch block logger.warn("Error while creating contract violation: "+e); e.printStackTrace(); } catch (SecurityException e) { // TODO Auto-generated catch block logger.warn("Error while creating contract violation: "+e); e.printStackTrace(); } }
&& mutation.getStatement().getPosition() <= lastPosition) { if (Properties.LOCAL_SEARCH_SELECTIVE_PRIMITIVES) { if (!(mutation.getStatement() instanceof PrimitiveStatement<?>)) if (!test.hasReferences(mutation.getStatement().getReturnValue()) && !mutation.getStatement().getReturnClass().equals(targetClass)) { continue;
if (!test.hasReferences(test.getStatement(i).getReturnValue()) && !test.getStatement(i).getReturnClass().equals(targetClass)) { logger.info( "Return value of statement " + i + " is not referenced and not SUT, not doing local search");
return; if(statement.isAssignmentStatement()) { if(statement.getReturnValue().isArrayIndex()) { return; if(statement.getReturnValue().isFieldReference()) { return; int position = statement.getPosition();
Set<Statement> newStatements = new LinkedHashSet<Statement>(); for (Statement s : dependentStatements) { if (s.references(statements.get(i).getReturnValue()) || s.references(statements.get(i).getReturnValue().getAdditionalVariableReference())) { newStatements.add(statements.get(i)); break; dependentPositions.add(s.getPosition());
@Override public void addAssertionAndComments(Statement statement, List<VariableReference> variables, Throwable exception) { TestCase test = statement.getTestCase(); int position = statement.getPosition(); VariableReference a = variables.get(0); try { Method hashCodeMethod = a.getGenericClass().getRawClass().getMethod("hashCode", new Class<?>[] {}); GenericMethod method = new GenericMethod(hashCodeMethod, a.getGenericClass()); Statement st1 = new MethodStatement(test, method, a, Arrays.asList(new VariableReference[] {})); test.addStatement(st1, position + 1); st1.addComment("Throws exception: "+exception.getMessage()); } catch (NoSuchMethodException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
for (Statement s : statements) { try { logger.info(s.getCode()); } catch (AssertionError e2) { logger.info("Found error in: " + s); return statement.getReturnValue();
/** {@inheritDoc} */ @Override public Statement clone(TestCase newTestCase) { Statement result = copy(newTestCase, 0); result.getReturnValue().setOriginalCode(retval.getOriginalCode()); result.addComment(getComment()); return result; }
@Override public void addAssertionAndComments(Statement statement, List<VariableReference> variables, Throwable exception) { EqualsAssertion assertion = new EqualsAssertion(); assertion.setStatement(statement); assertion.setSource(variables.get(0)); assertion.setDest(variables.get(0)); assertion.setValue(true); statement.addAssertion(assertion); statement.addComment("Violates contract a.equals(a)"); }
@Override public void afterStatement(Statement statement, Scope scope, Throwable exception) { int numStatement = statement.getPosition(); VariableReference returnValue = statement.getReturnValue(); if (!returnValue.isPrimitive()) { // Only interested in primitive values return; } TestCase test = super.getCurrentTest(); if (test.getStatement(returnValue.getStPosition()) instanceof PrimitiveStatement<?>) { // Don't need to collect primitive statement values return; } try { Object object = statement.getReturnValue().getObject(scope); concreteValues.put(numStatement, object); } catch(CodeUnderTestException e) { // Ignore } }