/** * <p> * Setter for the field <code>callee</code>. * </p> * * @param callee * a {@link org.evosuite.testcase.variable.VariableReference} object. */ public void setCallee(VariableReference callee) { if (!isStatic()) this.callee = callee; }
@Override public int getNumParameters() { return parameters.size() + (isStatic() ? 0 : 1); }
/** {@inheritDoc} */ @Override public boolean isValid() { assert (super.isValid()); for (VariableReference v : parameters) { v.getStPosition(); } if (!isStatic()) { callee.getStPosition(); } return true; }
if (s instanceof MethodStatement) { MethodStatement ms = (MethodStatement) s; if (!ms.isStatic()) { logger.info("Callee: "); logger.info(ms.getCallee().toString());
if (isStatic()) this.callee = null; else
private boolean methodNeedsDownCast(MethodStatement methodStatement, VariableReference var, Class<?> abstractClass) { if(!methodStatement.isStatic() && methodStatement.getCallee().equals(var)) { if(!ClassUtils.hasMethod(abstractClass, methodStatement.getMethod().getName(), methodStatement.getMethod().getRawParameterTypes())) { // Need downcast for real return true; } else { Method superClassMethod = ClassUtils.getMethod(abstractClass, methodStatement.getMethod().getName(), methodStatement.getMethod().getRawParameterTypes()); if(!methodStatement.getMethod().getRawGeneratedType().equals(superClassMethod.getReturnType())) { // Overriding can also change return value, in which case we need to keep the downcast return true; } } } List<VariableReference> parameters = methodStatement.getParameterReferences(); Class<?>[] parameterTypes = methodStatement.getMethod().getRawParameterTypes(); for(int i = 0; i < parameters.size(); i++) { VariableReference param = parameters.get(i); if(param.equals(var) && !parameterTypes[i].isAssignableFrom(abstractClass)) { // Need downcast for real return true; } } return false; }
private void updateMethodCallsOfGenericOwner(VariableReference callee) { for (int pos = callee.getStPosition() + 1; pos < test.size(); pos++) { Statement statement = test.getStatement(pos); if (!(statement instanceof MethodStatement)) continue; MethodStatement ms = (MethodStatement) statement; if (ms.isStatic()) continue; if (!ms.getCallee().equals(callee)) continue; GenericMethod method = ms.getMethod(); logger.info("Updating callee of statement " + statement.getCode()); ms.setMethod(method.copyWithNewOwner(callee.getGenericClass())); ms.getReturnValue().setType(ms.getMethod().getReturnType()); logger.info("Result: " + statement.getCode()); } }
if (test.getStatement(pos) instanceof MethodStatement) { MethodStatement ms = (MethodStatement) test.getStatement(pos); if (ms.isStatic()) continue; if (!ms.getCallee().equals(constructorStatement.getReturnValue()))
if (!statement.isStatic()) { max++;
/** {@inheritDoc} */ @Override public Statement copy(TestCase newTestCase, int offset) { ArrayList<VariableReference> newParams = new ArrayList<VariableReference>(); for (VariableReference r : parameters) { newParams.add(r.copy(newTestCase, offset)); } MethodStatement m; if (isStatic()) { // FIXXME: If callee is an array index, this will return an invalid // copy of the cloned variable! m = new MethodStatement(newTestCase, method.copy(), null, newParams); } else { VariableReference newCallee = callee.copy(newTestCase, offset); m = new MethodStatement(newTestCase, method.copy(), newCallee, newParams); } if (retval instanceof ArrayReference && !(m.getReturnValue() instanceof ArrayReference)) { // logger.info("Copying array retval: " + retval.getGenericClass()); // assert (retval.getGenericClass() != null); // assert (retval.getGenericClass().isArray()) : method.toString(); ArrayReference newRetVal = new ArrayReference(newTestCase, retval.getGenericClass(), ((ArrayReference) retval).getArrayLength()); m.setRetval(newRetVal); } m.getReturnValue().setType(retval.getType()); // Actual type may have changed, e.g. subtype // m.assertions = copyAssertions(newTestCase, offset); return m; }
if (!statement.isStatic()) { logger.info("Replacing callee"); VariableReference callee = statement.getCallee();