@Test
public void testStaticField() {
Class<?> c = ClassWithFields.class;
try {
StaticField sf = new StaticField(c.getField("fourField"));
FieldGetter rhs = new FieldGetter(sf);
// types
assertTrue("Should be no input types", rhs.getInputTypes().isEmpty());
assertEquals("Output type should match type of field", sf.getType(), rhs.getOutputType());
// code generation
String expected = "int i0 = randoop.operation.ClassWithFields.fourField;" + Globals.lineSep;
Statement st = new Statement(rhs);
Sequence seq = new Sequence().extend(rhs, new ArrayList<Variable>());
Variable var = new Variable(seq, 0);
StringBuilder b = new StringBuilder();
st.appendCode(var, new ArrayList<Variable>(), b);
assertEquals("Expect initialization of variable from static field", expected, b.toString());
// execution - should be 4 (haven't changed value yet)
NormalExecution expectedExec = new NormalExecution(4, 0);
NormalExecution actualExec = (NormalExecution) rhs.execute(new Object[0], null);
assertTrue(
"Execution should simply return value",
expectedExec.getRuntimeValue().equals(actualExec.getRuntimeValue())
&& expectedExec.getExecutionTime() == actualExec.getExecutionTime());
} catch (NoSuchFieldException e) {
fail("test failed because field in test class not found");
} catch (SecurityException e) {
fail("test failed because of unexpected security exception");
}
}
@Test
public void testInstanceField() {
Class<?> c = ClassWithFields.class;
try {
InstanceField f = new InstanceField(c.getField("oneField"));
FieldGetter rhs = new FieldGetter(f);
// types
List<Class<?>> inputTypes = new ArrayList<>();
inputTypes.add(c);
assertEquals("Input types should just be declaring class", inputTypes, rhs.getInputTypes());
assertEquals("Output type should match type of field", f.getType(), rhs.getOutputType());
// code generation
String expected = "int i1 = classWithFields0.oneField;" + Globals.lineSep;
// first need a variable referring to an instance
// - sequence where one is declared and initialized by constructed object
ConstructorCall cons =
new ConstructorCall(
ConstructorSignatures.getConstructorForSignatureString(
"randoop.operation.ClassWithFields.ClassWithFields()"));
Sequence seqInit = new Sequence().extend(cons, new ArrayList<Variable>());
ArrayList<Variable> vars = new ArrayList<>();
vars.add(new Variable(seqInit, 0));
// bind getter "call" to initialization
Statement st_rhs = new Statement(rhs);
Sequence seq = seqInit.extend(rhs, vars);
// - first variable is object
Variable var1 = new Variable(seq, 0);
// - second variable is for value
Variable var2 = new Variable(seq, 1);
vars = new ArrayList<>();
vars.add(var1);
StringBuilder b = new StringBuilder();
st_rhs.appendCode(var2, vars, b);
assertEquals("Expect initialization of variable from static field", expected, b.toString());
// execution
// null object
ExecutionOutcome nullOutcome = rhs.execute(new Object[0], null);
assertTrue(
"Expect null pointer exception",
nullOutcome instanceof ExceptionalExecution
&& ((ExceptionalExecution) nullOutcome).getException()
instanceof NullPointerException);
// actual object
NormalExecution expectedExec = new NormalExecution(1, 0);
Object[] inputs = new Object[1];
inputs[0] = c.newInstance();
NormalExecution actualExec = (NormalExecution) rhs.execute(inputs, null);
assertTrue(
"Execution should simply return value",
expectedExec.getRuntimeValue().equals(actualExec.getRuntimeValue())
&& expectedExec.getExecutionTime() == actualExec.getExecutionTime());
} catch (NoSuchFieldException e) {
fail("test failed because field in test class not found");
} catch (SecurityException e) {
fail("test failed because of unexpected security exception");
} catch (InstantiationException e) {
fail("test failed because of unexpected exception creating class instance");
} catch (IllegalAccessException e) {
fail("test failed because of unexpected access exception when creating instance");
e.printStackTrace();
} catch (OperationParseException e) {
fail("test failed because ClassWithFields constructor not found");
}
}