@Override public void visitMethodStatement(MethodStatement statement) { addVariable(statement); GenericMethod method = statement.getMethod(); List<VariableReference> parameterVariables = statement.getParameterReferences(); Type[] genericParameterTypes = method.getGenericParameterTypes(); for (int i = 0; i < genericParameterTypes.length; i++) { Type genericType = genericParameterTypes[i]; VariableReference value = parameterVariables.get(i); addTypeAssignment(genericType, value); } }
if (statement instanceof MethodStatement) { MethodStatement ms = (MethodStatement) statement; parameters.addAll(ms.getParameterReferences()); } else if (statement instanceof ConstructorStatement) { ConstructorStatement cs = (ConstructorStatement) statement;
for (VariableReference v : ms.getParameterReferences()) { logger.info("Parameter " + num); logger.info(v.getVariableClass().toString());
public void visitMethodStatement(TestCase test, MethodStatement statement) { // The problem is that at this point in the test case the parameters // might have already changed int i = 0; for (VariableReference var : statement.getParameterReferences()) { if (var.isPrimitive() || var.isString()) { if (usedVariables.contains(var) && test.getStatement(var.getStPosition()) instanceof PrimitiveStatement<?>) { // Duplicate and replace VariableReference varCopy = duplicateStatement(test, var); statement.replaceParameterReference(varCopy, i); usedVariables.add(varCopy); } usedVariables.add(var); } i++; } addUnchangedMapping(test, statement.getReturnValue()); }
private static boolean checkBoundedVariableAtMostOnce(TestCase tc, int i, MethodStatement ms) { List<VariableReference> inputs = ms.getParameterReferences(); List<VariableReference> atMostOnce = new ArrayList<>(); for(VariableReference ref : other.getParameterReferences()){ for(VariableReference bounded : atMostOnce){ if(ref.same(bounded)){
@SuppressWarnings("unused") private void mutateTransformedBoolean(TestCase test) { if (Randomness.nextDouble() > Properties.RANDOM_PERTURBATION) { boolean done = false; for (Statement s : test) { if (s instanceof MethodStatement) { MethodStatement ms = (MethodStatement) s; List<VariableReference> parameters = ms.getParameterReferences(); int index = parameters.indexOf(retval); if (index >= 0) { Method m = ms.getMethod().getMethod(); org.objectweb.asm.Type[] types = org.objectweb.asm.Type.getArgumentTypes(m); if (types[index].equals(org.objectweb.asm.Type.BOOLEAN_TYPE)) { logger.warn("MUTATING"); ((IntPrimitiveStatement) this).negate(); done = true; break; } } } } if (!done) randomize(); } else { randomize(); } }
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; }
List<VariableReference> parameters = getParameterReferences();
inputs = ms.getParameterReferences();
List<VariableReference> parameters = statement.getParameterReferences(); pushParameterList(parameters, scope, desc);
parameterValues = ms.getParameterReferences(); determineVariablesFromParameters(parameterValues, parameterTypes, typeMap);
ms = (MethodStatement) st; annotations = ms.getMethod().getMethod().getParameterAnnotations(); inputs = ms.getParameterReferences();
List<VariableReference> parameters = statement.getParameterReferences(); if (parameters.isEmpty()) return false;
for (VariableReference parameter : statement.getParameterReferences()) { logger.info("Replacing parameter " + numParameter);
@Test public void testGetCandidatesForReuse() throws ClassNotFoundException, NoSuchFieldException, ConstructionFailedException, NoSuchMethodException { TestFactory testFactory = TestFactory.getInstance(); Class<?> sut = TestGenerationContext.getInstance().getClassLoaderForSUT().loadClass(FactoryExample.class.getCanonicalName()); Properties.PRIMITIVE_REUSE_PROBABILITY = 1.0; Properties.OBJECT_REUSE_PROBABILITY = 1.0; DefaultTestCase test = new DefaultTestCase(); GenericConstructor constructor = new GenericConstructor(sut.getConstructor(), sut); VariableReference var1 = testFactory.addConstructor(test, constructor, 0, 0); test.addStatement(new CharPrimitiveStatement(test,'-')); GenericMethod method = new GenericMethod(sut.getMethod("testInt", int.class), sut); testFactory.addMethodFor(test, var1, method, 2); MethodStatement stmt = (MethodStatement)test.getStatement(test.size()-1); VariableReference var = stmt.getParameterReferences().get(0); assertNotEquals("Char should not be passed as Integer", var.getType(), char.class); assertEquals("Incorrect test size", 4, test.size()); } }
GenericMethod method = statement.getMethod(); Throwable exception = getException(statement); List<VariableReference> parameters = statement.getParameterReferences(); boolean isGenericMethod = method.hasTypeParameters();