Generate java bindings for structs.

mojo/android/javatests/src/org/chromium/mojo/bindings/BindingsTest.java

Index: mojo/android/javatests/src/org/chromium/mojo/bindings/BindingsTest.java
diff --git a/mojo/android/javatests/src/org/chromium/mojo/bindings/BindingsTest.java b/mojo/android/javatests/src/org/chromium/mojo/bindings/BindingsTest.java
index 27fba624154d02fa191076a7826d097c2fbdeebd..f3a607853362c8772560874a6db7557b500fb5a5 100644
--- a/mojo/android/javatests/src/org/chromium/mojo/bindings/BindingsTest.java
+++ b/mojo/android/javatests/src/org/chromium/mojo/bindings/BindingsTest.java
@@ -8,57 +8,261 @@ import android.test.suitebuilder.annotation.SmallTest;
 
 import junit.framework.TestCase;
 
+import org.chromium.mojo.HandleMock;
 import org.chromium.mojo.bindings.test.imported.Color;
+import org.chromium.mojo.bindings.test.imported.Point;
 import org.chromium.mojo.bindings.test.imported.Shape;
+import org.chromium.mojo.bindings.test.imported.Thing;
+import org.chromium.mojo.bindings.test.sample.Bar;
+import org.chromium.mojo.bindings.test.sample.Bar.Type;
+import org.chromium.mojo.bindings.test.sample.DefaultsTest;
 import org.chromium.mojo.bindings.test.sample.Enum;
+import org.chromium.mojo.bindings.test.sample.Foo;
 import org.chromium.mojo.bindings.test.sample.InterfaceConstants;
 import org.chromium.mojo.bindings.test.sample.SampleServiceConstants;
+import org.chromium.mojo.system.DataPipe.ConsumerHandle;
+import org.chromium.mojo.system.DataPipe.ProducerHandle;
+import org.chromium.mojo.system.MessagePipeHandle;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
+import java.util.Arrays;
 
 /**
  * Testing generated classes and associated features.
  */
 public class BindingsTest extends TestCase {
 
-    private static void checkConstantField(Field field, Class<?> expectedClass) {
+    /**
+     * Create a new typical Bar instance.
+     */
+    private static Bar newBar() {
+        Bar bar = new Bar();
+        bar.alpha = (byte) 0x01;
+        bar.beta = (byte) 0x02;
+        bar.gamma = (byte) 0x03;
+        bar.type = Type.TYPE_BOTH;
+        return bar;
+    }
+
+    /**
+     * Check that 2 Bar instances are equals.
+     */
+    private static void assertBarEquals(Bar bar, Bar bar2) {
+        if (bar == bar2) {
+            return;
+        }
+        assertTrue(bar != null && bar2 != null);
+        assertEquals(bar.alpha, bar2.alpha);
+        assertEquals(bar.beta, bar2.beta);
+        assertEquals(bar.gamma, bar2.gamma);
+        assertEquals(bar.type, bar2.type);
+    }
+
+    /**
+     * Create a new typical Foo instance.
+     */
+    private static Foo createFoo() {
+        Foo foo = new Foo();
+        foo.name = "HELLO WORLD";
+        boolean[][] b = new boolean[5][];
+        b[0] = new boolean[3];
+        b[0][0] = true;
+        b[0][2] = true;
+        foo.arrayOfArrayOfBools = b;
+        foo.bar = newBar();
+        foo.a = true;
+        foo.c = true;
+        foo.data = new byte[] {
+            0x01, 0x02, 0x03 };
+        Bar[] bars = new Bar[2];
+        for (int i = 0; i < bars.length; ++i) {
+            bars[i] = newBar();
+        }
+        foo.extraBars = bars;
+        String[][][] strings = new String[3][2][1];
+        for (int i0 = 0; i0 < strings.length; ++i0) {
+            for (int i1 = 0; i1 < strings[i0].length; ++i1) {
+                for (int i2 = 0; i2 < strings[i0][i1].length; ++i2) {
+                    strings[i0][i1][i2] = "Hello(" + i0 + ", " + i1 + ", " + i2 + ")";
+                }
+            }
+        }
+        foo.multiArrayOfStrings = strings;
+        ConsumerHandle[] inputStreams = new ConsumerHandle[5];
+        for (int i = 0; i < inputStreams.length; ++i) {
+            inputStreams[i] = new HandleMock();
+        }
+        foo.inputStreams = inputStreams;
+        ProducerHandle[] outputStreams = new ProducerHandle[3];
+        for (int i = 0; i < outputStreams.length; ++i) {
+            outputStreams[i] = new HandleMock();
+        }
+        foo.outputStreams = outputStreams;
+        foo.source = new HandleMock();
+        return foo;
+    }
+
+    /**
+     * Check that 2 Foo instances are equals.
+     */
+    private static void assertFooEquals(Foo foo1, Foo foo2) {
+        assertEquals(foo1.a, foo2.a);
+        assertEquals(foo1.b, foo2.b);
+        assertEquals(foo1.c, foo2.c);
+        assertEquals(foo1.name, foo2.name);
+        assertEquals(foo1.x, foo2.x);
+        assertEquals(foo1.y, foo2.y);
+        TestCase.assertTrue(Arrays.deepEquals(foo1.arrayOfArrayOfBools, foo2.arrayOfArrayOfBools));
+        assertBarEquals(foo1.bar, foo2.bar);
+        assertTrue(Arrays.equals(foo1.data, foo2.data));
+        TestCase.assertTrue(Arrays.deepEquals(foo1.multiArrayOfStrings, foo2.multiArrayOfStrings));
+        assertEquals(foo1.source, foo2.source);
+        TestCase.assertTrue(Arrays.deepEquals(foo1.inputStreams, foo2.inputStreams));
+        TestCase.assertTrue(Arrays.deepEquals(foo1.outputStreams, foo2.outputStreams));
+        if (foo1.extraBars != foo2.extraBars) {
+            assertEquals(foo1.extraBars.length, foo2.extraBars.length);
+            for (int i = 0; i < foo1.extraBars.length; ++i) {
+                assertBarEquals(foo1.extraBars[i], foo2.extraBars[i]);
+            }
+        }
+    }
+
+    private static <T> void checkConstantField(
+            Field field, Class<T> expectedClass, T value) throws IllegalAccessException {
         assertEquals(expectedClass, field.getType());
         assertEquals(Modifier.FINAL, field.getModifiers() & Modifier.FINAL);
         assertEquals(Modifier.STATIC, field.getModifiers() & Modifier.STATIC);
+        assertEquals(value, field.get(null));
+    }
+
+    private static void checkField(Field field, Class<?> expectedClass) {
+        assertEquals(expectedClass, field.getType());
+        assertEquals(0, field.getModifiers() & Modifier.FINAL);
+        assertEquals(0, field.getModifiers() & Modifier.STATIC);
     }
 
     /**
      * Testing constants are correctly generated.
      */
     @SmallTest
-    public void testConstants() throws NoSuchFieldException, SecurityException {
-        assertEquals(12, SampleServiceConstants.TWELVE);
-        checkConstantField(SampleServiceConstants.class.getField("TWELVE"), byte.class);
-
-        assertEquals(4405, InterfaceConstants.LONG);
-        checkConstantField(InterfaceConstants.class.getField("LONG"), long.class);
+    public void testConstants() throws NoSuchFieldException, SecurityException,
+            IllegalAccessException {
+        checkConstantField(SampleServiceConstants.class.getField("TWELVE"), byte.class, (byte) 12);
+        checkConstantField(InterfaceConstants.class.getField("LONG"), long.class, 4405L);
     }
 
     /**
      * Testing enums are correctly generated.
      */
     @SmallTest
-    public void testEnums() throws NoSuchFieldException, SecurityException {
-        assertEquals(0, Color.COLOR_RED);
-        assertEquals(1, Color.COLOR_BLACK);
-        checkConstantField(Color.class.getField("COLOR_BLACK"), int.class);
-        checkConstantField(Color.class.getField("COLOR_RED"), int.class);
-
-        assertEquals(0, Enum.ENUM_VALUE);
-        checkConstantField(Enum.class.getField("ENUM_VALUE"), int.class);
-
-        assertEquals(1, Shape.SHAPE_RECTANGLE);
-        assertEquals(2, Shape.SHAPE_CIRCLE);
-        assertEquals(3, Shape.SHAPE_TRIANGLE);
-        checkConstantField(Shape.class.getField("SHAPE_RECTANGLE"), int.class);
-        checkConstantField(Shape.class.getField("SHAPE_CIRCLE"), int.class);
-        checkConstantField(Shape.class.getField("SHAPE_TRIANGLE"), int.class);
+    public void testEnums() throws NoSuchFieldException, SecurityException,
+            IllegalAccessException {
+        checkConstantField(Color.class.getField("COLOR_RED"), int.class, 0);
+        checkConstantField(Color.class.getField("COLOR_BLACK"), int.class, 1);
+
+        checkConstantField(Enum.class.getField("ENUM_VALUE"), int.class, 0);
+
+        checkConstantField(Shape.class.getField("SHAPE_RECTANGLE"), int.class, 1);
+        checkConstantField(Shape.class.getField("SHAPE_CIRCLE"), int.class, 2);
+        checkConstantField(Shape.class.getField("SHAPE_TRIANGLE"), int.class, 3);
+    }
+
+    /**
+     * Testing default values on structs.
+     */
+    @SmallTest
+    public void testStructDefaultValue() throws NoSuchFieldException, SecurityException {

[rmcilroy, 2014/06/23 18:09:36]

nit - testStructDefaults()

[qsr, 2014/06/24 13:23:59]

Done.

+        // Check default values.
+        DefaultsTest test = new DefaultsTest();
+
+        assertEquals((byte) -12, test.a0);
+        checkField(DefaultsTest.class.getField("a0"), byte.class);

[rmcilroy, 2014/06/23 18:09:36]

Do the same as checkConstantField for checkField and replace all:
         assertEquals((byte) -12, test.a0);
         checkField(DefaultsTest.class.getField("a0"), byte.class);
with:
         checkField(DefaultsTest.class.getField("a0"), byte.class, (byte) -12);

etc.,

[qsr, 2014/06/24 13:23:59]

Done.

+
+        assertEquals((byte) 12, test.a1);
+        checkField(DefaultsTest.class.getField("a1"), byte.class);
+

[rmcilroy, 2014/06/23 18:09:36]

nit - remove newlines between checks when you've updated checkField()

[qsr, 2014/06/24 13:23:59]

Done.

+        assertEquals(1234, test.a2);
+        checkField(DefaultsTest.class.getField("a2"), short.class);
+
+        assertEquals((short) 34567, test.a3);
+        checkField(DefaultsTest.class.getField("a3"), short.class);
+
+        assertEquals(123456, test.a4);
+        checkField(DefaultsTest.class.getField("a4"), int.class);
+
+        assertEquals(111111111111L, test.a6);
+        checkField(DefaultsTest.class.getField("a6"), long.class);
+
+        assertEquals(0x12345, test.a8);
+        checkField(DefaultsTest.class.getField("a8"), int.class);
+
+        assertEquals(-0x12345, test.a9);
+        checkField(DefaultsTest.class.getField("a9"), int.class);
+
+        assertEquals(1234, test.a10);
+        checkField(DefaultsTest.class.getField("a10"), int.class);
+
+        assertEquals(true, test.a11);
+        checkField(DefaultsTest.class.getField("a11"), boolean.class);
+
+        assertEquals(false, test.a12);
+        checkField(DefaultsTest.class.getField("a12"), boolean.class);
+
+        assertEquals(123.25, test.a13, 1e-6);
+        checkField(DefaultsTest.class.getField("a13"), float.class);
+
+        assertEquals(1234567890.123, test.a14, 1e-6);
+        checkField(DefaultsTest.class.getField("a14"), double.class);
+
+        assertEquals(1E10, test.a15, 1);
+        checkField(DefaultsTest.class.getField("a15"), double.class);
+
+        assertEquals(-1.2E+20, test.a16, 1);
+        checkField(DefaultsTest.class.getField("a16"), double.class);
+
+        assertEquals(+1.23E-20, test.a17, 1);
+        checkField(DefaultsTest.class.getField("a17"), double.class);
+
+        assertNull(test.a18);
+        checkField(DefaultsTest.class.getField("a18"), byte[].class);
+
+        assertNull(test.a19);
+        checkField(DefaultsTest.class.getField("a19"), String.class);
+
+        assertEquals(Bar.Type.TYPE_BOTH, test.a20);
+        checkField(DefaultsTest.class.getField("a20"), int.class);
+
+        assertNull(test.a21);
+        checkField(DefaultsTest.class.getField("a21"), Point.class);
+
+        assertNotNull(test.a22);
+        checkField(DefaultsTest.class.getField("a22"), Thing.class);
     }
 
+    /**
+     * Testing generation of the Foo class.
+     *
+     * @throws IllegalAccessException
+     */
+    @SmallTest
+    public void testFooGeneration() throws NoSuchFieldException, SecurityException,
+            IllegalAccessException {
+        // Checking creation of a Foo object.
+        Foo typicalFoo = createFoo();
+        assertFooEquals(typicalFoo, typicalFoo);

[rmcilroy, 2014/06/23 18:09:36]

Please see comment on Patch-Set 2

[qsr, 2014/06/24 13:23:59]

 I don't really agree, but won't fight on this.

+
+        // Checking Foo constants.
+        checkConstantField(Foo.class.getField("FOOBY"), String.class, "Fooby");
+
+        // Checking Foo default values.
+        Foo foo = new Foo();
+
+        assertEquals(Foo.FOOBY, foo.name);
+        checkField(Foo.class.getField("name"), String.class);
+
+        assertNotNull(foo.source);
+        assertFalse(foo.source.isValid());
+        checkField(Foo.class.getField("source"), MessagePipeHandle.class);
+    }
 }