@Test
public void testDefaultOrderedInboundConversionOneIndexed() {
final IStructHandler c = getConverter(SimpleTableDefaultOrdering.class);
verifyFieldOrder(c, "a", "b");
final String inputA = "ca";
final String inputB = "zzzz";
Map<Object, Object> input = Maps.newHashMap();
input.put(1, inputA);
input.put(2, inputB);
final String resultA = "ca";
final int resultB = 2;
setupInboundConverter(inputA, String.class, resultA);
setupInboundConverter(inputB, int.class, resultB);
Object o = c.toJava(converter, input, 1);
verifyInboundConversion(inputA, String.class);
verifyInboundConversion(inputB, int.class);
Assert.assertTrue(o instanceof SimpleTableDefaultOrdering);
SimpleTableDefaultOrdering converted = (SimpleTableDefaultOrdering) o;
Assert.assertEquals(resultA, converted.a);
Assert.assertEquals(resultB, converted.b);
}
@Test
public void testNamedInboundConversionOptionalFields() {
final IStructHandler c = getConverter(SimpleStructOptional.class);
verifyFieldOrder(c, "a", "b");
final String inputB = "ca";
Map<Object, Object> input = Maps.newHashMap();
input.put("b", inputB);
final int resultB = 12;
setupInboundConverter(inputB, int.class, resultB);
Object o = c.toJava(converter, input, 6);
verifyInboundConversion(inputB, int.class);
Assert.assertTrue(o instanceof SimpleStructOptional);
SimpleStructOptional converted = (SimpleStructOptional) o;
Assert.assertEquals(resultB, converted.b);
Assert.assertEquals(SKIP_VALUE, converted.a);
}
private void assertOutboundConversionFail(
IStructHandler structConverter, Map<Object, Object> input, int indexOffset) {
try {
structConverter.toJava(converter, input, indexOffset);
Assert.fail("Exception not thrown");
} catch (RuntimeException e) {
}
}
@Test
public void testGenericBaseInboundConversion() {
final IStructHandler c = getConverter(GenericDerrived.class);
verifyFieldOrder(c, "fieldA", "fieldB", "fieldC", "fieldD");
final Boolean inputA = false;
final Float inputB = 999.3f;
final Integer inputC = 3214;
final String inputD = "zzzz";
Map<Object, Object> input = Maps.newHashMap();
input.put("fieldA", inputA);
input.put("fieldB", inputB);
input.put("fieldC", inputC);
input.put("fieldD", inputD);
final Boolean resultA = true;
final Float resultB = 9432.4f;
final Integer resultC = 5425;
final String resultD = "sfs";
setupInboundConverter(inputA, Boolean.class, resultA);
setupInboundConverter(inputB, Float.class, resultB);
setupInboundConverter(inputC, Integer.class, resultC);
setupInboundConverter(inputD, String.class, resultD);
Object o = c.toJava(converter, input, 1);
verifyInboundConversion(inputA, Boolean.class);
verifyInboundConversion(inputB, Float.class);
verifyInboundConversion(inputC, Integer.class);
verifyInboundConversion(inputD, String.class);
Assert.assertTrue(o instanceof GenericDerrived);
GenericDerrived converted = (GenericDerrived) o;
Assert.assertEquals(resultA, converted.fieldA);
Assert.assertEquals(resultB, converted.fieldB);
Assert.assertEquals(resultC, converted.fieldC);
Assert.assertEquals(resultD, converted.fieldD);
}
@Test
public void testCustomOrderedInboundConversion() {
final IStructHandler c = getConverter(SimpleTableForcedOrdering.class);
verifyFieldOrder(c, "b", "a", "c");
final String inputA = "ca";
final String inputB = "zzzz";
final int inputC = 999;
Map<Object, Object> input = Maps.newHashMap();
input.put(1, inputB);
input.put(2, inputA);
input.put(3, inputC);
final String resultA = "ca";
final int resultB = 2;
final Float resultC = 2.4f;
setupInboundConverter(inputA, String.class, resultA);
setupInboundConverter(inputB, int.class, resultB);
setupInboundConverter(inputC, Float.class, resultC);
Object o = c.toJava(converter, input, 1);
verifyInboundConversion(inputA, String.class);
verifyInboundConversion(inputB, int.class);
verifyInboundConversion(inputC, Float.class);
Assert.assertTrue(o instanceof SimpleTableForcedOrdering);
SimpleTableForcedOrdering converted = (SimpleTableForcedOrdering) o;
Assert.assertEquals(resultA, converted.a);
Assert.assertEquals(resultB, converted.b);
Assert.assertEquals(resultC, converted.c);
}
