Examples of com.google.protobuf.micro.MicroOuterClass.TestAllTypesMicro

Package com.google.protobuf.micro.MicroOuterClass

Examples of com.google.protobuf.micro.MicroOuterClass.TestAllTypesMicro

com.google.protobuf.micro.MicroOuterClass.TestAllTypesMicro

    assertEquals("hello", newMsg.getRepeatedBytes(0).toStringUtf8());
    assertEquals("world", newMsg.getRepeatedBytes(1).toStringUtf8());
  }


  public void testMicroRepeatedGroup() throws Exception {
    TestAllTypesMicro msg = new TestAllTypesMicro();
    TestAllTypesMicro.RepeatedGroup group0 =
      new TestAllTypesMicro.RepeatedGroup().setA(0);
    TestAllTypesMicro.RepeatedGroup group1 =
      new TestAllTypesMicro.RepeatedGroup().setA(1);
    TestAllTypesMicro.RepeatedGroup group2 =
      new TestAllTypesMicro.RepeatedGroup().setA(2);


    msg.addRepeatedGroup(group0);
    assertEquals(1, msg.getRepeatedGroupCount());
    assertEquals(0, msg.getRepeatedGroup(0).getA());
    msg.addRepeatedGroup(group1);
    assertEquals(2, msg.getRepeatedGroupCount());
    assertEquals(0, msg.getRepeatedGroup(0).getA());
    assertEquals(1, msg.getRepeatedGroup(1).getA());
    msg.setRepeatedGroup(0, group2);
    assertEquals(2, msg.getRepeatedGroupCount());
    assertEquals(2, msg.getRepeatedGroup(0).getA());
    assertEquals(1, msg.getRepeatedGroup(1).getA());
    msg.clearRepeatedGroup();
    assertEquals(0, msg.getRepeatedGroupCount());
    msg.clearRepeatedGroup()
       .addRepeatedGroup(group1);
    assertEquals(1, msg.getRepeatedGroupCount());
    assertEquals(1, msg.getRepeatedGroup(0).getA());
    msg.clear();
    assertEquals(0, msg.getRepeatedGroupCount());


    // Test 1 entry
    msg.clear()
       .addRepeatedGroup(group0);
    assertEquals(1, msg.getRepeatedGroupCount());
    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);
    assertEquals(1, newMsg.getRepeatedGroupCount());
    assertEquals(0, newMsg.getRepeatedGroup(0).getA());


    // Test 2 entries
    msg.clear()
       .addRepeatedGroup(group0)
       .addRepeatedGroup(group1);
    assertEquals(2, msg.getRepeatedGroupCount());
    result = msg.toByteArray();
    msgSerializedSize = msg.getSerializedSize();
    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
    assertTrue(msgSerializedSize == 14);
    assertEquals(result.length, msgSerializedSize);


    newMsg = TestAllTypesMicro.parseFrom(result);
    assertEquals(2, newMsg.getRepeatedGroupCount());
    assertEquals(0, newMsg.getRepeatedGroup(0).getA());
    assertEquals(1, newMsg.getRepeatedGroup(1).getA());
  }

View Full Code Here

    assertEquals(1, newMsg.getRepeatedGroup(1).getA());
  }




  public void testMicroRepeatedNestedMessage() throws Exception {
    TestAllTypesMicro msg = new TestAllTypesMicro();
    TestAllTypesMicro.NestedMessage nestedMsg0 =
      new TestAllTypesMicro.NestedMessage().setBb(0);
    TestAllTypesMicro.NestedMessage nestedMsg1 =
      new TestAllTypesMicro.NestedMessage().setBb(1);
    TestAllTypesMicro.NestedMessage nestedMsg2 =
      new TestAllTypesMicro.NestedMessage().setBb(2);


    msg.addRepeatedNestedMessage(nestedMsg0);
    assertEquals(1, msg.getRepeatedNestedMessageCount());
    assertEquals(0, msg.getRepeatedNestedMessage(0).getBb());
    msg.addRepeatedNestedMessage(nestedMsg1);
    assertEquals(2, msg.getRepeatedNestedMessageCount());
    assertEquals(0, msg.getRepeatedNestedMessage(0).getBb());
    assertEquals(1, msg.getRepeatedNestedMessage(1).getBb());
    msg.setRepeatedNestedMessage(0, nestedMsg2);
    assertEquals(2, msg.getRepeatedNestedMessageCount());
    assertEquals(2, msg.getRepeatedNestedMessage(0).getBb());
    assertEquals(1, msg.getRepeatedNestedMessage(1).getBb());
    msg.clearRepeatedNestedMessage();
    assertEquals(0, msg.getRepeatedNestedMessageCount());
    msg.clearRepeatedNestedMessage()
       .addRepeatedNestedMessage(nestedMsg1);
    assertEquals(1, msg.getRepeatedNestedMessageCount());
    assertEquals(1, msg.getRepeatedNestedMessage(0).getBb());
    msg.clear();
    assertEquals(0, msg.getRepeatedNestedMessageCount());


    // Test 1 entry
    msg.clear()
       .addRepeatedNestedMessage(nestedMsg0);
    assertEquals(1, msg.getRepeatedNestedMessageCount());
    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);
    assertEquals(1, newMsg.getRepeatedNestedMessageCount());
    assertEquals(0, newMsg.getRepeatedNestedMessage(0).getBb());


    // Test 2 entries
    msg.clear()
       .addRepeatedNestedMessage(nestedMsg0)
       .addRepeatedNestedMessage(nestedMsg1);
    assertEquals(2, msg.getRepeatedNestedMessageCount());
    result = msg.toByteArray();
    msgSerializedSize = msg.getSerializedSize();
    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
    assertTrue(msgSerializedSize == 10);
    assertEquals(result.length, msgSerializedSize);


    newMsg = TestAllTypesMicro.parseFrom(result);
    assertEquals(2, newMsg.getRepeatedNestedMessageCount());
    assertEquals(0, newMsg.getRepeatedNestedMessage(0).getBb());
    assertEquals(1, newMsg.getRepeatedNestedMessage(1).getBb());
  }

View Full Code Here

    assertEquals(0, newMsg.getRepeatedNestedMessage(0).getBb());
    assertEquals(1, newMsg.getRepeatedNestedMessage(1).getBb());
  }


  public void testMicroRepeatedForeignMessage() throws Exception {
    TestAllTypesMicro msg = new TestAllTypesMicro();
    MicroOuterClass.ForeignMessageMicro foreignMsg0 =
      new MicroOuterClass.ForeignMessageMicro().setC(0);
    MicroOuterClass.ForeignMessageMicro foreignMsg1 =
      new MicroOuterClass.ForeignMessageMicro().setC(1);
    MicroOuterClass.ForeignMessageMicro foreignMsg2 =
      new MicroOuterClass.ForeignMessageMicro().setC(2);


    msg.addRepeatedForeignMessage(foreignMsg0);
    assertEquals(1, msg.getRepeatedForeignMessageCount());
    assertEquals(0, msg.getRepeatedForeignMessage(0).getC());
    msg.addRepeatedForeignMessage(foreignMsg1);
    assertEquals(2, msg.getRepeatedForeignMessageCount());
    assertEquals(0, msg.getRepeatedForeignMessage(0).getC());
    assertEquals(1, msg.getRepeatedForeignMessage(1).getC());
    msg.setRepeatedForeignMessage(0, foreignMsg2);
    assertEquals(2, msg.getRepeatedForeignMessageCount());
    assertEquals(2, msg.getRepeatedForeignMessage(0).getC());
    assertEquals(1, msg.getRepeatedForeignMessage(1).getC());
    msg.clearRepeatedForeignMessage();
    assertEquals(0, msg.getRepeatedForeignMessageCount());
    msg.clearRepeatedForeignMessage()
       .addRepeatedForeignMessage(foreignMsg1);
    assertEquals(1, msg.getRepeatedForeignMessageCount());
    assertEquals(1, msg.getRepeatedForeignMessage(0).getC());
    msg.clear();
    assertEquals(0, msg.getRepeatedForeignMessageCount());


    // Test 1 entry
    msg.clear()
       .addRepeatedForeignMessage(foreignMsg0);
    assertEquals(1, msg.getRepeatedForeignMessageCount());
    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);
    assertEquals(1, newMsg.getRepeatedForeignMessageCount());
    assertEquals(0, newMsg.getRepeatedForeignMessage(0).getC());


    // Test 2 entries
    msg.clear()
       .addRepeatedForeignMessage(foreignMsg0)
       .addRepeatedForeignMessage(foreignMsg1);
    assertEquals(2, msg.getRepeatedForeignMessageCount());
    result = msg.toByteArray();
    msgSerializedSize = msg.getSerializedSize();
    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
    assertTrue(msgSerializedSize == 10);
    assertEquals(result.length, msgSerializedSize);


    newMsg = TestAllTypesMicro.parseFrom(result);
    assertEquals(2, newMsg.getRepeatedForeignMessageCount());
    assertEquals(0, newMsg.getRepeatedForeignMessage(0).getC());
    assertEquals(1, newMsg.getRepeatedForeignMessage(1).getC());
  }

View Full Code Here

    assertEquals(0, newMsg.getRepeatedForeignMessage(0).getC());
    assertEquals(1, newMsg.getRepeatedForeignMessage(1).getC());
  }


  public void testMicroRepeatedImportMessage() throws Exception {
    TestAllTypesMicro msg = new TestAllTypesMicro();
    UnittestImportMicro.ImportMessageMicro importMsg0 =
      new UnittestImportMicro.ImportMessageMicro().setD(0);
    UnittestImportMicro.ImportMessageMicro importMsg1 =
      new UnittestImportMicro.ImportMessageMicro().setD(1);
    UnittestImportMicro.ImportMessageMicro importMsg2 =
      new UnittestImportMicro.ImportMessageMicro().setD(2);


    msg.addRepeatedImportMessage(importMsg0);
    assertEquals(1, msg.getRepeatedImportMessageCount());
    assertEquals(0, msg.getRepeatedImportMessage(0).getD());
    msg.addRepeatedImportMessage(importMsg1);
    assertEquals(2, msg.getRepeatedImportMessageCount());
    assertEquals(0, msg.getRepeatedImportMessage(0).getD());
    assertEquals(1, msg.getRepeatedImportMessage(1).getD());
    msg.setRepeatedImportMessage(0, importMsg2);
    assertEquals(2, msg.getRepeatedImportMessageCount());
    assertEquals(2, msg.getRepeatedImportMessage(0).getD());
    assertEquals(1, msg.getRepeatedImportMessage(1).getD());
    msg.clearRepeatedImportMessage();
    assertEquals(0, msg.getRepeatedImportMessageCount());
    msg.clearRepeatedImportMessage()
       .addRepeatedImportMessage(importMsg1);
    assertEquals(1, msg.getRepeatedImportMessageCount());
    assertEquals(1, msg.getRepeatedImportMessage(0).getD());
    msg.clear();
    assertEquals(0, msg.getRepeatedImportMessageCount());


    // Test 1 entry
    msg.clear()
       .addRepeatedImportMessage(importMsg0);
    assertEquals(1, msg.getRepeatedImportMessageCount());
    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);
    assertEquals(1, newMsg.getRepeatedImportMessageCount());
    assertEquals(0, newMsg.getRepeatedImportMessage(0).getD());


    // Test 2 entries
    msg.clear()
       .addRepeatedImportMessage(importMsg0)
       .addRepeatedImportMessage(importMsg1);
    assertEquals(2, msg.getRepeatedImportMessageCount());
    result = msg.toByteArray();
    msgSerializedSize = msg.getSerializedSize();
    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
    assertTrue(msgSerializedSize == 10);
    assertEquals(result.length, msgSerializedSize);


    newMsg = TestAllTypesMicro.parseFrom(result);
    assertEquals(2, newMsg.getRepeatedImportMessageCount());
    assertEquals(0, newMsg.getRepeatedImportMessage(0).getD());
    assertEquals(1, newMsg.getRepeatedImportMessage(1).getD());
  }

View Full Code Here

    assertEquals(0, newMsg.getRepeatedImportMessage(0).getD());
    assertEquals(1, newMsg.getRepeatedImportMessage(1).getD());
  }


  public void testMicroRepeatedNestedEnum() throws Exception {
    TestAllTypesMicro msg = new TestAllTypesMicro();
    msg.addRepeatedNestedEnum(TestAllTypesMicro.FOO);
    assertEquals(1, msg.getRepeatedNestedEnumCount());
    assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
    msg.addRepeatedNestedEnum(TestAllTypesMicro.BAR);
    assertEquals(2, msg.getRepeatedNestedEnumCount());
    assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
    assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
    msg.setRepeatedNestedEnum(0, TestAllTypesMicro.BAZ);
    assertEquals(2, msg.getRepeatedNestedEnumCount());
    assertEquals(TestAllTypesMicro.BAZ, msg.getRepeatedNestedEnum(0));
    assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
    msg.clearRepeatedNestedEnum();
    assertEquals(0, msg.getRepeatedNestedEnumCount());
    msg.clearRepeatedNestedEnum()
       .addRepeatedNestedEnum(TestAllTypesMicro.BAR);
    assertEquals(1, msg.getRepeatedNestedEnumCount());
    assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(0));
    msg.clear();
    assertEquals(0, msg.getRepeatedNestedEnumCount());


    // Test 1 entry
    msg.clear()
       .addRepeatedNestedEnum(TestAllTypesMicro.FOO);
    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);
    assertEquals(1, newMsg.getRepeatedNestedEnumCount());
    assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));


    // Test 2 entries
    msg.clear()
       .addRepeatedNestedEnum(TestAllTypesMicro.FOO)
       .addRepeatedNestedEnum(TestAllTypesMicro.BAR);
    assertEquals(2, msg.getRepeatedNestedEnumCount());
    result = msg.toByteArray();
    msgSerializedSize = msg.getSerializedSize();
    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
    assertTrue(msgSerializedSize == 6);
    assertEquals(result.length, msgSerializedSize);


    newMsg = TestAllTypesMicro.parseFrom(result);
    assertEquals(2, newMsg.getRepeatedNestedEnumCount());
    assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
    assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
  }

View Full Code Here

    assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
    assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
  }


  public void testMicroRepeatedForeignEnum() throws Exception {
    TestAllTypesMicro msg = new TestAllTypesMicro();
    msg.addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_FOO);
    assertEquals(1, msg.getRepeatedForeignEnumCount());
    assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
    msg.addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
    assertEquals(2, msg.getRepeatedForeignEnumCount());
    assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
    msg.setRepeatedForeignEnum(0, MicroOuterClass.FOREIGN_MICRO_BAZ);
    assertEquals(2, msg.getRepeatedForeignEnumCount());
    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAZ, msg.getRepeatedForeignEnum(0));
    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
    msg.clearRepeatedForeignEnum();
    assertEquals(0, msg.getRepeatedForeignEnumCount());
    msg.clearRepeatedForeignEnum()
       .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
    assertEquals(1, msg.getRepeatedForeignEnumCount());
    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(0));
    msg.clear();
    assertEquals(0, msg.getRepeatedForeignEnumCount());


    // Test 1 entry
    msg.clear()
       .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_FOO);
    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);
    assertEquals(1, newMsg.getRepeatedForeignEnumCount());
    assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));


    // Test 2 entries
    msg.clear()
       .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_FOO)
       .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
    assertEquals(2, msg.getRepeatedForeignEnumCount());
    result = msg.toByteArray();
    msgSerializedSize = msg.getSerializedSize();
    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
    assertTrue(msgSerializedSize == 6);
    assertEquals(result.length, msgSerializedSize);


    newMsg = TestAllTypesMicro.parseFrom(result);
    assertEquals(2, newMsg.getRepeatedForeignEnumCount());
    assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
  }

View Full Code Here

    assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
  }


  public void testMicroRepeatedImportEnum() throws Exception {
    TestAllTypesMicro msg = new TestAllTypesMicro();
    msg.addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_FOO);
    assertEquals(1, msg.getRepeatedImportEnumCount());
    assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
    msg.addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
    assertEquals(2, msg.getRepeatedImportEnumCount());
    assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
    msg.setRepeatedImportEnum(0, UnittestImportMicro.IMPORT_MICRO_BAZ);
    assertEquals(2, msg.getRepeatedImportEnumCount());
    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAZ, msg.getRepeatedImportEnum(0));
    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
    msg.clearRepeatedImportEnum();
    assertEquals(0, msg.getRepeatedImportEnumCount());
    msg.clearRepeatedImportEnum()
       .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
    assertEquals(1, msg.getRepeatedImportEnumCount());
    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(0));
    msg.clear();
    assertEquals(0, msg.getRepeatedImportEnumCount());


    // Test 1 entry
    msg.clear()
       .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_FOO);
    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);
    assertEquals(1, newMsg.getRepeatedImportEnumCount());
    assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));


    // Test 2 entries
    msg.clear()
       .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_FOO)
       .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
    assertEquals(2, msg.getRepeatedImportEnumCount());
    result = msg.toByteArray();
    msgSerializedSize = msg.getSerializedSize();
    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
    assertTrue(msgSerializedSize == 6);
    assertEquals(result.length, msgSerializedSize);


    newMsg = TestAllTypesMicro.parseFrom(result);
    assertEquals(2, newMsg.getRepeatedImportEnumCount());
    assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
  }

View Full Code Here

    assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
  }


  public void testMicroRepeatedStringPiece() throws Exception {
    TestAllTypesMicro msg = new TestAllTypesMicro();
    assertEquals(0, msg.getRepeatedStringPieceCount());
    msg.addRepeatedStringPiece("hello");
    assertEquals(1, msg.getRepeatedStringPieceCount());
    assertEquals("hello", msg.getRepeatedStringPiece(0));
    msg.addRepeatedStringPiece("bye");
    assertEquals(2, msg.getRepeatedStringPieceCount());
    assertEquals("hello", msg.getRepeatedStringPiece(0));
    assertEquals("bye", msg.getRepeatedStringPiece(1));
    msg.setRepeatedStringPiece(0, "boo");
    assertEquals(2, msg.getRepeatedStringPieceCount());
    assertEquals("boo", msg.getRepeatedStringPiece(0));
    assertEquals("bye", msg.getRepeatedStringPiece(1));
    msg.clearRepeatedStringPiece();
    assertEquals(0, msg.getRepeatedStringPieceCount());
    msg.clearRepeatedStringPiece()
       .addRepeatedStringPiece("hello");
    assertEquals(1, msg.getRepeatedStringPieceCount());
    assertEquals("hello", msg.getRepeatedStringPiece(0));
    msg.clear();
    assertEquals(0, msg.getRepeatedStringPieceCount());


    // Test 1 entry and an empty string
    msg.clear()
       .addRepeatedStringPiece("");
    assertEquals(1, msg.getRepeatedStringPieceCount());
    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);
    assertEquals(1, newMsg.getRepeatedStringPieceCount());
    assertEquals("", newMsg.getRepeatedStringPiece(0));


    // Test 2 entries
    msg.clear()
       .addRepeatedStringPiece("hello")
       .addRepeatedStringPiece("world");
    assertEquals(2, msg.getRepeatedStringPieceCount());
    result = msg.toByteArray();
    msgSerializedSize = msg.getSerializedSize();
    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
    assertTrue(msgSerializedSize == 16);
    assertEquals(result.length, msgSerializedSize);


    newMsg = TestAllTypesMicro.parseFrom(result);
    assertEquals(2, newMsg.getRepeatedStringPieceCount());
    assertEquals("hello", newMsg.getRepeatedStringPiece(0));
    assertEquals("world", newMsg.getRepeatedStringPiece(1));
  }

View Full Code Here

    assertEquals("hello", newMsg.getRepeatedStringPiece(0));
    assertEquals("world", newMsg.getRepeatedStringPiece(1));
  }


  public void testMicroRepeatedCord() throws Exception {
    TestAllTypesMicro msg = new TestAllTypesMicro();
    assertEquals(0, msg.getRepeatedCordCount());
    msg.addRepeatedCord("hello");
    assertEquals(1, msg.getRepeatedCordCount());
    assertEquals("hello", msg.getRepeatedCord(0));
    msg.addRepeatedCord("bye");
    assertEquals(2, msg.getRepeatedCordCount());
    assertEquals("hello", msg.getRepeatedCord(0));
    assertEquals("bye", msg.getRepeatedCord(1));
    msg.setRepeatedCord(0, "boo");
    assertEquals(2, msg.getRepeatedCordCount());
    assertEquals("boo", msg.getRepeatedCord(0));
    assertEquals("bye", msg.getRepeatedCord(1));
    msg.clearRepeatedCord();
    assertEquals(0, msg.getRepeatedCordCount());
    msg.clearRepeatedCord()
       .addRepeatedCord("hello");
    assertEquals(1, msg.getRepeatedCordCount());
    assertEquals("hello", msg.getRepeatedCord(0));
    msg.clear();
    assertEquals(0, msg.getRepeatedCordCount());


    // Test 1 entry and an empty string
    msg.clear()
       .addRepeatedCord("");
    assertEquals(1, msg.getRepeatedCordCount());
    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);
    assertEquals(1, newMsg.getRepeatedCordCount());
    assertEquals("", newMsg.getRepeatedCord(0));


    // Test 2 entries
    msg.clear()
       .addRepeatedCord("hello")
       .addRepeatedCord("world");
    assertEquals(2, msg.getRepeatedCordCount());
    result = msg.toByteArray();
    msgSerializedSize = msg.getSerializedSize();
    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
    assertTrue(msgSerializedSize == 16);
    assertEquals(result.length, msgSerializedSize);


    newMsg = TestAllTypesMicro.parseFrom(result);
    assertEquals(2, newMsg.getRepeatedCordCount());
    assertEquals("hello", newMsg.getRepeatedCord(0));
    assertEquals("world", newMsg.getRepeatedCord(1));
  }

View Full Code Here

    assertEquals("hello", newMsg.getRepeatedCord(0));
    assertEquals("world", newMsg.getRepeatedCord(1));
  }


  public void testMicroDefaults() throws Exception {
    TestAllTypesMicro msg = new TestAllTypesMicro();
    assertFalse(msg.hasDefaultInt32());
    assertEquals(41, msg.getDefaultInt32());
    assertFalse(msg.hasDefaultInt64());
    assertEquals(42, msg.getDefaultInt64());
    assertFalse(msg.hasDefaultUint32());
    assertEquals(43, msg.getDefaultUint32());
    assertFalse(msg.hasDefaultUint64());
    assertEquals(44, msg.getDefaultUint64());
    assertFalse(msg.hasDefaultSint32());
    assertEquals(-45, msg.getDefaultSint32());
    assertFalse(msg.hasDefaultSint64());
    assertEquals(46, msg.getDefaultSint64());
    assertFalse(msg.hasDefaultFixed32());
    assertEquals(47, msg.getDefaultFixed32());
    assertFalse(msg.hasDefaultFixed64());
    assertEquals(48, msg.getDefaultFixed64());
    assertFalse(msg.hasDefaultSfixed32());
    assertEquals(49, msg.getDefaultSfixed32());
    assertFalse(msg.hasDefaultSfixed64());
    assertEquals(-50, msg.getDefaultSfixed64());
    assertFalse(msg.hasDefaultFloat());
    assertTrue(51.5f == msg.getDefaultFloat());
    assertFalse(msg.hasDefaultDouble());
    assertTrue(52.0e3 == msg.getDefaultDouble());
    assertFalse(msg.hasDefaultBool());
    assertEquals(true, msg.getDefaultBool());
    assertFalse(msg.hasDefaultString());
    assertEquals("hello", msg.getDefaultString());
    assertFalse(msg.hasDefaultBytes());
    assertEquals("world", msg.getDefaultBytes().toStringUtf8());
    assertFalse(msg.hasDefaultNestedEnum());
    assertEquals(TestAllTypesMicro.BAR, msg.getDefaultNestedEnum());
    assertFalse(msg.hasDefaultForeignEnum());
    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getDefaultForeignEnum());
    assertFalse(msg.hasDefaultImportEnum());
    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getDefaultImportEnum());
  }

View Full Code Here

0 1 2 3 4

TOP

Related Classes of com.google.protobuf.micro.MicroOuterClass.TestAllTypesMicro

com.google.protobuf.MicroTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.