public VariableReference appendEnumPrimitive(Enum<?> value) { EnumPrimitiveStatement primitiveStmt = new EnumPrimitiveStatement(tc, value); tc.addStatement(primitiveStmt); return primitiveStmt.getReturnValue(); }
/** {@inheritDoc} */ @SuppressWarnings({ "rawtypes", "unchecked" }) @Override public boolean doSearch(TestChromosome test, int statement, LocalSearchObjective<TestChromosome> objective) { EnumPrimitiveStatement p = (EnumPrimitiveStatement) test.getTestCase().getStatement(statement); ExecutionResult oldResult = test.getLastExecutionResult(); oldValue = p.getValue(); for (Object value : p.getEnumValues()) { p.setValue(value); if (!objective.hasImproved(test)) { // Restore original p.setValue(oldValue); test.setLastExecutionResult(oldResult); test.setChanged(false); } else { logger.debug("Finished local search with result " + p.getCode()); return true; } } return false; }
protected String getEnumValue(EnumPrimitiveStatement<?> statement) { Object value = statement.getValue(); Class<?> clazz = statement.getEnumClass(); String className = getClassName(clazz); try { if (value.getClass().getField(value.toString()) != null) return className + "." + value; } catch (NoSuchFieldException e) { // Ignore } for (Field field : value.getClass().getDeclaredFields()) { if (field.isEnumConstant()) { try { if (field.get(value).equals(value)) { return className + "." + field.getName(); } } catch (Exception e) { // ignore } } } return className + ".valueOf(\"" + value + "\")"; }
private void after(EnumPrimitiveStatement<?> s, Scope scope) { VariableReference varRef = s.getReturnValue(); String varName = varRef.getName(); Object conc_value = s.getValue(); ReferenceExpression symb_value = env.heap.getReference(conc_value); symb_references.put(varName, symb_value); }
@Test public void testInnerClassAbstractEnum() throws NoSuchMethodException, ConstructionFailedException { //first construct a test case for the Generic method TestCase tc = new DefaultTestCase(); VariableReference userObject = TestFactory.getInstance().addConstructor(tc, new GenericConstructor(AbstractEnumUser.class.getDeclaredConstructor(), AbstractEnumUser.class), 0, 0); EnumPrimitiveStatement primitiveStatement = new EnumPrimitiveStatement(tc, AbstractEnumInInnerClass.AnEnum.class); primitiveStatement.setValue(AbstractEnumInInnerClass.AnEnum.FOO); VariableReference enumObject = tc.addStatement(primitiveStatement); Method m = AbstractEnumUser.class.getDeclaredMethod("foo", AbstractEnumInInnerClass.AnEnum.class); GenericMethod gm = new GenericMethod(m, AbstractEnumUser.class); MethodStatement ms = new MethodStatement(tc, gm, userObject, Arrays.asList(enumObject)); tc.addStatement(ms); //Finally, visit the test TestCodeVisitor visitor = new TestCodeVisitor(); tc.accept(visitor); //should not throw exception String code = visitor.getCode(); System.out.println(code); assertFalse(code.contains("= AbstractEnumInInnerClass.AnEnum.1.FOO")); assertTrue(code.contains("= AbstractEnumInInnerClass.AnEnum.FOO")); } }
statement = new StringPrimitiveStatement(tc); } else if (GenericTypeReflector.erase(clazz).isEnum()) { statement = new EnumPrimitiveStatement(tc, GenericTypeReflector.erase(clazz)); } else if (EnvironmentStatements.isEnvironmentData(clazz)) { statement = EnvironmentStatements.getStatement(clazz, tc);
/** * <p> * Constructor for EnumPrimitiveStatement. * </p> * * @param tc * a {@link org.evosuite.testcase.TestCase} object. * @param value * a T object. */ @SuppressWarnings("unchecked") public EnumPrimitiveStatement(TestCase tc, T value) { super(tc, value.getClass(), value); boolean tracerEnabled = ExecutionTracer.isEnabled(); if (tracerEnabled) ExecutionTracer.disable(); enumClass = (Class<T>) retrieveEnumClass(value.getClass()); constants = (T[]) retrieveEnumClass(value.getClass()).getEnumConstants(); if (tracerEnabled) ExecutionTracer.enable(); }
@Test public void testInnerClassEnum() throws Throwable { //first construct a test case for the Generic method TestCase tc = new DefaultTestCase(); VariableReference userObject = TestFactory.getInstance().addConstructor(tc, new GenericConstructor(EnumUser.class.getDeclaredConstructor(), EnumUser.class), 0, 0); EnumPrimitiveStatement primitiveStatement = new EnumPrimitiveStatement(tc, EnumInInnerClass.AnEnum.class); primitiveStatement.setValue(EnumInInnerClass.AnEnum.FOO); VariableReference enumObject = tc.addStatement(primitiveStatement); Method m = EnumUser.class.getDeclaredMethod("foo", EnumInInnerClass.AnEnum.class); GenericMethod gm = new GenericMethod(m, EnumUser.class); MethodStatement ms = new MethodStatement(tc, gm, userObject, Arrays.asList(enumObject)); tc.addStatement(ms); //Finally, visit the test TestCodeVisitor visitor = new TestCodeVisitor(); tc.accept(visitor); //should not throw exception String code = visitor.getCode(); assertTrue(code.contains("= EnumInInnerClass.AnEnum.FOO")); }