// Copyright 2008 Google Inc.  All rights reserved.

// http://code.google.com/p/protobuf/

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

* Test micro runtime.

*

* @author wink@google.com Wink Saville

*/

  public void setUp() throws Exception {

  }

  public void testSimpleMessageMicro() throws Exception {

    SimpleMessageMicro msg = new SimpleMessageMicro();

    assertFalse(msg.hasD());

    assertEquals(123, msg.getD());

    assertFalse(msg.hasNestedMsg());

    assertEquals(null, msg.getNestedMsg());

    assertFalse(msg.hasDefaultNestedEnum());

    assertEquals(SimpleMessageMicro.BAZ, msg.getDefaultNestedEnum());

    msg.setD(456);

    assertTrue(msg.hasD());

    assertEquals(456, msg.getD());

    msg.clearD()

       .setD(456);

    assertTrue(msg.hasD());

    SimpleMessageMicro.NestedMessage nestedMsg = new SimpleMessageMicro.NestedMessage()

      .setBb(2);

    assertTrue(nestedMsg.hasBb());

    assertEquals(2, nestedMsg.getBb());

    msg.setNestedMsg(nestedMsg);

    assertTrue(msg.hasNestedMsg());

    assertEquals(2, msg.getNestedMsg().getBb());

    msg.setDefaultNestedEnum(SimpleMessageMicro.BAR);

    assertTrue(msg.hasDefaultNestedEnum());

    assertEquals(SimpleMessageMicro.BAR, msg.getDefaultNestedEnum());

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 9);

    assertEquals(result.length, msgSerializedSize);

    SimpleMessageMicro newMsg = SimpleMessageMicro.parseFrom(result);

    assertTrue(newMsg.hasD());

    assertTrue(newMsg.hasNestedMsg());

    assertTrue(newMsg.hasDefaultNestedEnum());

    assertEquals(456, newMsg.getD());

    assertEquals(2, msg.getNestedMsg().getBb());

    assertEquals(SimpleMessageMicro.BAR, msg.getDefaultNestedEnum());

  }

  public void testRecursiveMessageMicro() throws Exception {

    RecursiveMessageMicro msg = new RecursiveMessageMicro();

    assertFalse(msg.hasId());

    assertFalse(msg.hasNestedMessage());

    assertFalse(msg.hasOptionalRecursiveMessageMicro());

    assertEquals(0, msg.getRepeatedRecursiveMessageMicroCount());

    RecursiveMessageMicro msg1 = new RecursiveMessageMicro();

    msg1.setId(1);

    assertEquals(1, msg1.getId());

    RecursiveMessageMicro msg2 = new RecursiveMessageMicro();

    msg2.setId(2);

    RecursiveMessageMicro msg3 = new RecursiveMessageMicro();

    msg3.setId(3);

    RecursiveMessageMicro.NestedMessage nestedMsg = new RecursiveMessageMicro.NestedMessage();

    nestedMsg.setA(msg1);

    assertEquals(1, nestedMsg.getA().getId());

    msg.setId(0);

    msg.setNestedMessage(nestedMsg);

    msg.setOptionalRecursiveMessageMicro(msg2);

    msg.addRepeatedRecursiveMessageMicro(msg3);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 16);

    assertEquals(result.length, msgSerializedSize);

    RecursiveMessageMicro newMsg = RecursiveMessageMicro.parseFrom(result);

    assertTrue(newMsg.hasId());

    assertTrue(newMsg.hasNestedMessage());

    assertTrue(newMsg.hasOptionalRecursiveMessageMicro());

    assertEquals(1, newMsg.getRepeatedRecursiveMessageMicroCount());

    assertEquals(0, newMsg.getId());

    assertEquals(1, newMsg.getNestedMessage().getA().getId());

    assertEquals(2, newMsg.getOptionalRecursiveMessageMicro().getId());

    assertEquals(3, newMsg.getRepeatedRecursiveMessageMicro(0).getId());

  }

  public void testMicroRequiredInt32() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasId());

    assertFalse(msg.isInitialized());

    msg.setId(123);

    assertTrue(msg.hasId());

    assertTrue(msg.isInitialized());

    assertEquals(123, msg.getId());

    msg.clearId();

    assertFalse(msg.hasId());

    assertFalse(msg.isInitialized());

    msg.clearId()

       .setId(456);

    assertTrue(msg.hasId());

    msg.clear();

    assertFalse(msg.hasId());

    assertFalse(msg.isInitialized());

    msg.setId(123);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 3);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasId());

    assertTrue(newMsg.isInitialized());

    assertEquals(123, newMsg.getId());

  }

  public void testMicroOptionalInt32() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalInt32());

    msg.setOptionalInt32(123);

    assertTrue(msg.hasOptionalInt32());

    assertEquals(123, msg.getOptionalInt32());

    msg.clearOptionalInt32();

    assertFalse(msg.hasOptionalInt32());

    msg.clearOptionalInt32()

       .setOptionalInt32(456);

    assertTrue(msg.hasOptionalInt32());

    msg.clear();

    assertFalse(msg.hasOptionalInt32());

    msg.setOptionalInt32(123);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 2);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalInt32());

    assertEquals(123, newMsg.getOptionalInt32());

  }

  public void testMicroOptionalInt64() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalInt64());

    msg.setOptionalInt64(123);

    assertTrue(msg.hasOptionalInt64());

    assertEquals(123, msg.getOptionalInt64());

    msg.clearOptionalInt64();

    assertFalse(msg.hasOptionalInt64());

    msg.clearOptionalInt64()

       .setOptionalInt64(456);

    assertTrue(msg.hasOptionalInt64());

    msg.clear();

    assertFalse(msg.hasOptionalInt64());

    msg.setOptionalInt64(123);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 2);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalInt64());

    assertEquals(123, newMsg.getOptionalInt64());

  }

  public void testMicroOptionalUint32() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalUint32());

    msg.setOptionalUint32(123);

    assertTrue(msg.hasOptionalUint32());

    assertEquals(123, msg.getOptionalUint32());

    msg.clearOptionalUint32();

    assertFalse(msg.hasOptionalUint32());

    msg.clearOptionalUint32()

       .setOptionalUint32(456);

    assertTrue(msg.hasOptionalUint32());

    msg.clear();

    assertFalse(msg.hasOptionalUint32());

    msg.setOptionalUint32(123);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 2);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalUint32());

    assertEquals(123, newMsg.getOptionalUint32());

  }

  public void testMicroOptionalUint64() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalUint64());

    msg.setOptionalUint64(123);

    assertTrue(msg.hasOptionalUint64());

    assertEquals(123, msg.getOptionalUint64());

    msg.clearOptionalUint64();

    assertFalse(msg.hasOptionalUint64());

    msg.clearOptionalUint64()

       .setOptionalUint64(456);

    assertTrue(msg.hasOptionalUint64());

    msg.clear();

    assertFalse(msg.hasOptionalUint64());

    msg.setOptionalUint64(123);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 2);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalUint64());

    assertEquals(123, newMsg.getOptionalUint64());

  }

  public void testMicroOptionalSint32() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalSint32());

    msg.setOptionalSint32(123);

    assertTrue(msg.hasOptionalSint32());

    assertEquals(123, msg.getOptionalSint32());

    msg.clearOptionalSint32();

    assertFalse(msg.hasOptionalSint32());

    msg.clearOptionalSint32()

       .setOptionalSint32(456);

    assertTrue(msg.hasOptionalSint32());

    msg.clear();

    assertFalse(msg.hasOptionalSint32());

    msg.setOptionalSint32(-123);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 3);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalSint32());

    assertEquals(-123, newMsg.getOptionalSint32());

  }

  public void testMicroOptionalSint64() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalSint64());

    msg.setOptionalSint64(123);

    assertTrue(msg.hasOptionalSint64());

    assertEquals(123, msg.getOptionalSint64());

    msg.clearOptionalSint64();

    assertFalse(msg.hasOptionalSint64());

    msg.clearOptionalSint64()

       .setOptionalSint64(456);

    assertTrue(msg.hasOptionalSint64());

    msg.clear();

    assertFalse(msg.hasOptionalSint64());

    msg.setOptionalSint64(-123);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 3);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalSint64());

    assertEquals(-123, newMsg.getOptionalSint64());

  }

  public void testMicroOptionalFixed32() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalFixed32());

    msg.setOptionalFixed32(123);

    assertTrue(msg.hasOptionalFixed32());

    assertEquals(123, msg.getOptionalFixed32());

    msg.clearOptionalFixed32();

    assertFalse(msg.hasOptionalFixed32());

    msg.clearOptionalFixed32()

       .setOptionalFixed32(456);

    assertTrue(msg.hasOptionalFixed32());

    msg.clear();

    assertFalse(msg.hasOptionalFixed32());

    msg.setOptionalFixed32(123);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 5);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalFixed32());

    assertEquals(123, newMsg.getOptionalFixed32());

  }

  public void testMicroOptionalFixed64() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalFixed64());

    msg.setOptionalFixed64(123);

    assertTrue(msg.hasOptionalFixed64());

    assertEquals(123, msg.getOptionalFixed64());

    msg.clearOptionalFixed64();

    assertFalse(msg.hasOptionalFixed64());

    msg.clearOptionalFixed64()

       .setOptionalFixed64(456);

    assertTrue(msg.hasOptionalFixed64());

    msg.clear();

    assertFalse(msg.hasOptionalFixed64());

    msg.setOptionalFixed64(123);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 9);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalFixed64());

    assertEquals(123, newMsg.getOptionalFixed64());

  }

  public void testMicroOptionalSfixed32() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalSfixed32());

    msg.setOptionalSfixed32(123);

    assertTrue(msg.hasOptionalSfixed32());

    assertEquals(123, msg.getOptionalSfixed32());

    msg.clearOptionalSfixed32();

    assertFalse(msg.hasOptionalSfixed32());

    msg.clearOptionalSfixed32()

       .setOptionalSfixed32(456);

    assertTrue(msg.hasOptionalSfixed32());

    msg.clear();

    assertFalse(msg.hasOptionalSfixed32());

    msg.setOptionalSfixed32(123);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 5);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalSfixed32());

    assertEquals(123, newMsg.getOptionalSfixed32());

  }

  public void testMicroOptionalSfixed64() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalSfixed64());

    msg.setOptionalSfixed64(123);

    assertTrue(msg.hasOptionalSfixed64());

    assertEquals(123, msg.getOptionalSfixed64());

    msg.clearOptionalSfixed64();

    assertFalse(msg.hasOptionalSfixed64());

    msg.clearOptionalSfixed64()

       .setOptionalSfixed64(456);

    assertTrue(msg.hasOptionalSfixed64());

    msg.clear();

    assertFalse(msg.hasOptionalSfixed64());

    msg.setOptionalSfixed64(-123);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 9);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalSfixed64());

    assertEquals(-123, newMsg.getOptionalSfixed64());

  }

  public void testMicroOptionalFloat() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalFloat());

    msg.setOptionalFloat(123f);

    assertTrue(msg.hasOptionalFloat());

    assertTrue(123.0f == msg.getOptionalFloat());

    msg.clearOptionalFloat();

    assertFalse(msg.hasOptionalFloat());

    msg.clearOptionalFloat()

       .setOptionalFloat(456.0f);

    assertTrue(msg.hasOptionalFloat());

    msg.clear();

    assertFalse(msg.hasOptionalFloat());

    msg.setOptionalFloat(-123.456f);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 5);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalFloat());

    assertTrue(-123.456f == newMsg.getOptionalFloat());

  }

  public void testMicroOptionalDouble() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalDouble());

    msg.setOptionalDouble(123);

    assertTrue(msg.hasOptionalDouble());

    assertTrue(123.0 == msg.getOptionalDouble());

    msg.clearOptionalDouble();

    assertFalse(msg.hasOptionalDouble());

    msg.clearOptionalDouble()

       .setOptionalDouble(456.0);

    assertTrue(msg.hasOptionalDouble());

    msg.clear();

    assertFalse(msg.hasOptionalDouble());

    msg.setOptionalDouble(-123.456);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 9);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalDouble());

    assertTrue(-123.456 == newMsg.getOptionalDouble());

  }

  public void testMicroOptionalBool() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalBool());

    msg.setOptionalBool(true);

    assertTrue(msg.hasOptionalBool());

    assertEquals(true, msg.getOptionalBool());

    msg.clearOptionalBool();

    assertFalse(msg.hasOptionalBool());

    msg.clearOptionalBool()

       .setOptionalBool(true);

    assertTrue(msg.hasOptionalBool());

    msg.clear();

    assertFalse(msg.hasOptionalBool());

    msg.setOptionalBool(false);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 2);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalBool());

    assertEquals(false, newMsg.getOptionalBool());

  }

  public void testMicroOptionalString() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalString());

    msg.setOptionalString("hello");

    assertTrue(msg.hasOptionalString());

    assertEquals("hello", msg.getOptionalString());

    msg.clearOptionalString();

    assertFalse(msg.hasOptionalString());

    msg.clearOptionalString()

       .setOptionalString("hello");

    assertTrue(msg.hasOptionalString());

    msg.clear();

    assertFalse(msg.hasOptionalString());

    msg.setOptionalString("bye");

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 5);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalString());

    assertEquals("bye", newMsg.getOptionalString());

  }

  public void testMicroOptionalBytes() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalBytes());

    msg.setOptionalBytes(ByteStringMicro.copyFromUtf8("hello"));

    assertTrue(msg.hasOptionalBytes());

    assertEquals("hello", msg.getOptionalBytes().toStringUtf8());

    msg.clearOptionalBytes();

    assertFalse(msg.hasOptionalBytes());

    msg.clearOptionalBytes()

       .setOptionalBytes(ByteStringMicro.copyFromUtf8("hello"));

    assertTrue(msg.hasOptionalBytes());

    msg.clear();

    assertFalse(msg.hasOptionalBytes());

    msg.setOptionalBytes(ByteStringMicro.copyFromUtf8("bye"));

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 5);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalBytes());

    assertEquals("bye", newMsg.getOptionalBytes().toStringUtf8());

  }

  public void testMicroOptionalGroup() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    TestAllTypesMicro.OptionalGroup grp = new TestAllTypesMicro.OptionalGroup();

    grp.setA(1);

    assertFalse(msg.hasOptionalGroup());

    msg.setOptionalGroup(grp);

    assertTrue(msg.hasOptionalGroup());

    assertEquals(1, msg.getOptionalGroup().getA());

    msg.clearOptionalGroup();

    assertFalse(msg.hasOptionalGroup());

    msg.clearOptionalGroup()

       .setOptionalGroup(new TestAllTypesMicro.OptionalGroup().setA(2));

    assertTrue(msg.hasOptionalGroup());

    msg.clear();

    assertFalse(msg.hasOptionalGroup());

    msg.setOptionalGroup(grp);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 7);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalGroup());

    assertEquals(1, newMsg.getOptionalGroup().getA());

  }

  public void testMicroOptionalNestedMessage() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    TestAllTypesMicro.NestedMessage nestedMsg = new TestAllTypesMicro.NestedMessage();

    nestedMsg.setBb(1);

    assertFalse(msg.hasOptionalNestedMessage());

    msg.setOptionalNestedMessage(nestedMsg);

    assertTrue(msg.hasOptionalNestedMessage());

    assertEquals(1, msg.getOptionalNestedMessage().getBb());

    msg.clearOptionalNestedMessage();

    assertFalse(msg.hasOptionalNestedMessage());

    msg.clearOptionalNestedMessage()

       .setOptionalNestedMessage(new TestAllTypesMicro.NestedMessage().setBb(2));

    assertTrue(msg.hasOptionalNestedMessage());

    msg.clear();

    assertFalse(msg.hasOptionalNestedMessage());

    msg.setOptionalNestedMessage(nestedMsg);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 5);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalNestedMessage());

    assertEquals(1, newMsg.getOptionalNestedMessage().getBb());

  }

  public void testMicroOptionalForeignMessage() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    MicroOuterClass.ForeignMessageMicro foreignMsg =

        new MicroOuterClass.ForeignMessageMicro();

    assertFalse(foreignMsg.hasC());

    foreignMsg.setC(1);

    assertTrue(foreignMsg.hasC());

    assertFalse(msg.hasOptionalForeignMessage());

    msg.setOptionalForeignMessage(foreignMsg);

    assertTrue(msg.hasOptionalForeignMessage());

    assertEquals(1, msg.getOptionalForeignMessage().getC());

    msg.clearOptionalForeignMessage();

    assertFalse(msg.hasOptionalForeignMessage());

    msg.clearOptionalForeignMessage()

       .setOptionalForeignMessage(new MicroOuterClass.ForeignMessageMicro().setC(2));

    assertTrue(msg.hasOptionalForeignMessage());

    msg.clear();

    assertFalse(msg.hasOptionalForeignMessage());

    msg.setOptionalForeignMessage(foreignMsg);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 5);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalForeignMessage());

    assertEquals(1, newMsg.getOptionalForeignMessage().getC());

  }

  public void testMicroOptionalImportMessage() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    UnittestImportMicro.ImportMessageMicro importMsg =

        new UnittestImportMicro.ImportMessageMicro();

    assertFalse(importMsg.hasD());

    importMsg.setD(1);

    assertTrue(importMsg.hasD());

    assertFalse(msg.hasOptionalImportMessage());

    msg.setOptionalImportMessage(importMsg);

    assertTrue(msg.hasOptionalImportMessage());

    assertEquals(1, msg.getOptionalImportMessage().getD());

    msg.clearOptionalImportMessage();

    assertFalse(msg.hasOptionalImportMessage());

    msg.clearOptionalImportMessage()

       .setOptionalImportMessage(new UnittestImportMicro.ImportMessageMicro().setD(2));

    assertTrue(msg.hasOptionalImportMessage());

    msg.clear();

    assertFalse(msg.hasOptionalImportMessage());

    msg.setOptionalImportMessage(importMsg);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 5);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalImportMessage());

    assertEquals(1, newMsg.getOptionalImportMessage().getD());

  }

  public void testMicroOptionalNestedEnum() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    msg.setOptionalNestedEnum(TestAllTypesMicro.BAR);

    assertTrue(msg.hasOptionalNestedEnum());

    assertEquals(TestAllTypesMicro.BAR, msg.getOptionalNestedEnum());

    msg.clearOptionalNestedEnum();

    assertFalse(msg.hasOptionalNestedEnum());

    msg.clearOptionalNestedEnum()

       .setOptionalNestedEnum(TestAllTypesMicro.BAZ);

    assertTrue(msg.hasOptionalNestedEnum());

    msg.clear();

    assertFalse(msg.hasOptionalNestedEnum());

    msg.setOptionalNestedEnum(TestAllTypesMicro.BAR);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 3);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalNestedEnum());

    assertEquals(TestAllTypesMicro.BAR, newMsg.getOptionalNestedEnum());

  }

  public void testMicroOptionalForeignEnum() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    msg.setOptionalForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);

    assertTrue(msg.hasOptionalForeignEnum());

    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR,

        msg.getOptionalForeignEnum());

    msg.clearOptionalForeignEnum();

    assertFalse(msg.hasOptionalForeignEnum());

    msg.clearOptionalForeignEnum()

       .setOptionalForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAZ);

    assertTrue(msg.hasOptionalForeignEnum());

    msg.clear();

    assertFalse(msg.hasOptionalForeignEnum());

    msg.setOptionalForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 3);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalForeignEnum());

    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR,

        newMsg.getOptionalForeignEnum());

  }

  public void testMicroOptionalImportEnum() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    msg.setOptionalImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);

    assertTrue(msg.hasOptionalImportEnum());

    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR,

        msg.getOptionalImportEnum());

    msg.clearOptionalImportEnum();

    assertFalse(msg.hasOptionalImportEnum());

    msg.clearOptionalImportEnum()

       .setOptionalImportEnum(UnittestImportMicro.IMPORT_MICRO_BAZ);

    assertTrue(msg.hasOptionalImportEnum());

    msg.clear();

    assertFalse(msg.hasOptionalImportEnum());

    msg.setOptionalImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 3);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalImportEnum());

    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR,

        newMsg.getOptionalImportEnum());

  }

  public void testMicroOptionalStringPiece() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalStringPiece());

    msg.setOptionalStringPiece("hello");

    assertTrue(msg.hasOptionalStringPiece());

    assertEquals("hello", msg.getOptionalStringPiece());

    msg.clearOptionalStringPiece();

    assertFalse(msg.hasOptionalStringPiece());

    msg.clearOptionalStringPiece()

       .setOptionalStringPiece("hello");

    assertTrue(msg.hasOptionalStringPiece());

    msg.clear();

    assertFalse(msg.hasOptionalStringPiece());

    msg.setOptionalStringPiece("bye");

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 6);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalStringPiece());

    assertEquals("bye", newMsg.getOptionalStringPiece());

  }

  public void testMicroOptionalCord() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertFalse(msg.hasOptionalCord());

    msg.setOptionalCord("hello");

    assertTrue(msg.hasOptionalCord());

    assertEquals("hello", msg.getOptionalCord());

    msg.clearOptionalCord();

    assertFalse(msg.hasOptionalCord());

    msg.clearOptionalCord()

      .setOptionalCord("hello");

    assertTrue(msg.hasOptionalCord());

    msg.clear();

    assertFalse(msg.hasOptionalCord());

    msg.setOptionalCord("bye");

    byte [] result = msg.toByteArray();

    int msgSerializedSize = msg.getSerializedSize();

    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);

    assertTrue(msgSerializedSize == 6);

    assertEquals(result.length, msgSerializedSize);

    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);

    assertTrue(newMsg.hasOptionalCord());

    assertEquals("bye", newMsg.getOptionalCord());

  }

  public void testMicroRepeatedInt32() throws Exception {

    TestAllTypesMicro msg = new TestAllTypesMicro();

    assertEquals(0, msg.getRepeatedInt32Count());

    msg.addRepeatedInt32(123);

    assertEquals(1, msg.getRepeatedInt32Count());

    assertEquals(123, msg.getRepeatedInt32(0));

    msg.addRepeatedInt32(456);

    assertEquals(2, msg.getRepeatedInt32Count());

    assertEquals(123, msg.getRepeatedInt32(0));

    assertEquals(456, msg.getRepeatedInt32(1));

    msg.setRepeatedInt32(0, 789);

    assertEquals(2, msg.getRepeatedInt32Count());

    assertEquals(789, msg.getRepeatedInt32(0));

    assertEquals(456, msg.getRepeatedInt32(1));

    msg.clearRepeatedInt32();

    assertEquals(0, msg.getRepeatedInt32Count());

    msg.clearRepeatedInt32()

       .addRepeatedInt32(456);