NanoTest.java revision e03e9f4b5774c0ffe04140d83bbdb532863b1720
10d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// Protocol Buffers - Google's data interchange format 20d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// Copyright 2013 Google Inc. All rights reserved. 30d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// http://code.google.com/p/protobuf/ 40d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// 50d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// Redistribution and use in source and binary forms, with or without 60d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// modification, are permitted provided that the following conditions are 70d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// met: 80d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// 90d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// * Redistributions of source code must retain the above copyright 100d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// notice, this list of conditions and the following disclaimer. 110d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// * Redistributions in binary form must reproduce the above 120d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// copyright notice, this list of conditions and the following disclaimer 130d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// in the documentation and/or other materials provided with the 140d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// distribution. 150d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// * Neither the name of Google Inc. nor the names of its 160d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// contributors may be used to endorse or promote products derived from 170d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// this software without specific prior written permission. 180d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// 190d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 200d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 210d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 220d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 230d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 240d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 250d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 260d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 270d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 280d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 290d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 300d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 310d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarpackage com.google.protobuf; 320d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 330d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.CodedInputByteBufferNano; 340d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.EnumClassNanoMultiple; 350d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.EnumClassNanos; 360d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.Extensions; 370d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.Extensions.AnotherMessage; 380d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.Extensions.MessageWithGroup; 390d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.FileScopeEnumMultiple; 400d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.FileScopeEnumRefNano; 410d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.InternalNano; 420d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.MessageNano; 430d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.MessageScopeEnumRefNano; 440d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.MultipleImportingNonMultipleNano1; 450d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.MultipleImportingNonMultipleNano2; 460d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.MultipleNameClashNano; 470d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.NanoAccessorsOuterClass.TestNanoAccessors; 480d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.NanoHasOuterClass.TestAllTypesNanoHas; 490d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.NanoOuterClass; 500d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.NanoOuterClass.TestAllTypesNano; 510d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.NanoReferenceTypes; 520d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.UnittestImportNano; 530d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.UnittestMultipleNano; 540d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.UnittestRecursiveNano.RecursiveMessageNano; 550d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.UnittestSimpleNano.SimpleMessageNano; 560d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport com.google.protobuf.nano.UnittestSingleNano.SingleMessageNano; 570d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 580d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport junit.framework.TestCase; 590d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 600d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport java.util.ArrayList; 610d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport java.util.Arrays; 620d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarimport java.util.List; 630d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 640d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar/** 650d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar * Test nano runtime. 660d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar * 670d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar * @author ulas@google.com Ulas Kirazci 680d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar */ 690d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakarpublic class NanoTest extends TestCase { 700d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar @Override 710d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar public void setUp() throws Exception { 720d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar } 730d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 740d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar public void testSimpleMessageNano() throws Exception { 750d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar SimpleMessageNano msg = new SimpleMessageNano(); 760d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(123, msg.d); 770d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(null, msg.nestedMsg); 780d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(SimpleMessageNano.BAZ, msg.defaultNestedEnum); 790d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 800d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.d = 456; 810d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(456, msg.d); 820d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 830d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar SimpleMessageNano.NestedMessage nestedMsg = new SimpleMessageNano.NestedMessage(); 840d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar nestedMsg.bb = 2; 850d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(2, nestedMsg.bb); 860d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.nestedMsg = nestedMsg; 870d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(2, msg.nestedMsg.bb); 880d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 890d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.defaultNestedEnum = SimpleMessageNano.BAR; 900d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(SimpleMessageNano.BAR, msg.defaultNestedEnum); 910d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 920d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar byte [] result = MessageNano.toByteArray(msg); 930d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar int msgSerializedSize = msg.getSerializedSize(); 940d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 950d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertTrue(msgSerializedSize == 9); 960d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(result.length, msgSerializedSize); 970d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 980d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar SimpleMessageNano newMsg = SimpleMessageNano.parseFrom(result); 990d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(456, newMsg.d); 1000d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(2, msg.nestedMsg.bb); 1010d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(SimpleMessageNano.BAR, msg.defaultNestedEnum); 1020d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar } 1030d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1040d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar public void testRecursiveMessageNano() throws Exception { 1050d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar RecursiveMessageNano msg = new RecursiveMessageNano(); 1060d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertTrue(msg.repeatedRecursiveMessageNano.length == 0); 1070d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1080d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar RecursiveMessageNano msg1 = new RecursiveMessageNano(); 1090d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg1.id = 1; 1100d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(1, msg1.id); 1110d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar RecursiveMessageNano msg2 = new RecursiveMessageNano(); 1120d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg2.id = 2; 1130d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar RecursiveMessageNano msg3 = new RecursiveMessageNano(); 1140d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg3.id = 3; 1150d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1160d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar RecursiveMessageNano.NestedMessage nestedMsg = new RecursiveMessageNano.NestedMessage(); 1170d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar nestedMsg.a = msg1; 1180d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(1, nestedMsg.a.id); 1190d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1200d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.id = 0; 1210d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.nestedMessage = nestedMsg; 1220d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.optionalRecursiveMessageNano = msg2; 1230d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.repeatedRecursiveMessageNano = new RecursiveMessageNano[] { msg3 }; 1240d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1250d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar byte [] result = MessageNano.toByteArray(msg); 1260d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar int msgSerializedSize = msg.getSerializedSize(); 1270d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1280d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertTrue(msgSerializedSize == 16); 1290d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(result.length, msgSerializedSize); 1300d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1310d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar RecursiveMessageNano newMsg = RecursiveMessageNano.parseFrom(result); 1320d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(1, newMsg.repeatedRecursiveMessageNano.length); 1330d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1340d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(0, newMsg.id); 1350d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(1, newMsg.nestedMessage.a.id); 1360d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(2, newMsg.optionalRecursiveMessageNano.id); 1370d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(3, newMsg.repeatedRecursiveMessageNano[0].id); 1380d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar } 1390d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1400d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar public void testNanoRequiredInt32() throws Exception { 1410d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar TestAllTypesNano msg = new TestAllTypesNano(); 1420d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.id = 123; 1430d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(123, msg.id); 1440d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.clear().id = 456; 1450d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(456, msg.id); 1460d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.clear(); 1470d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1480d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.id = 123; 1490d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar byte [] result = MessageNano.toByteArray(msg); 1500d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar int msgSerializedSize = msg.getSerializedSize(); 1510d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1520d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertTrue(msgSerializedSize == 3); 1530d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(result.length, msgSerializedSize); 1540d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1550d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1560d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(123, newMsg.id); 1570d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar } 1580d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1590d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar public void testNanoOptionalInt32() throws Exception { 1600d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar TestAllTypesNano msg = new TestAllTypesNano(); 1610d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.optionalInt32 = 123; 1620d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(123, msg.optionalInt32); 1630d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.clear() 1640d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar .optionalInt32 = 456; 1650d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(456, msg.optionalInt32); 1660d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.clear(); 1670d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1680d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.optionalInt32 = 123; 1690d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar byte [] result = MessageNano.toByteArray(msg); 1700d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar int msgSerializedSize = msg.getSerializedSize(); 1710d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1720d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertTrue(msgSerializedSize == 5); 1730d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(result.length, msgSerializedSize); 1740d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1750d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1760d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(123, newMsg.optionalInt32); 1770d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar } 1780d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1790d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar public void testNanoOptionalInt64() throws Exception { 1800d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar TestAllTypesNano msg = new TestAllTypesNano(); 1810d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.optionalInt64 = 123; 1820d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(123, msg.optionalInt64); 1830d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.clear() 1840d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar .optionalInt64 = 456; 1850d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(456, msg.optionalInt64); 1860d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.clear(); 1870d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(0, msg.optionalInt64); 1880d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1890d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.optionalInt64 = 123; 1900d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar byte [] result = MessageNano.toByteArray(msg); 1910d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar int msgSerializedSize = msg.getSerializedSize(); 1920d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1930d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertTrue(msgSerializedSize == 5); 1940d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(result.length, msgSerializedSize); 1950d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 1960d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1970d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(123, newMsg.optionalInt64); 1980d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar } 1990d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 2000d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar public void testNanoOptionalUint32() throws Exception { 2010d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar TestAllTypesNano msg = new TestAllTypesNano(); 2020d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.optionalUint32 = 123; 2030d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(123, msg.optionalUint32); 2040d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.clear() 2050d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar .optionalUint32 = 456; 2060d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(456, msg.optionalUint32); 2070d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.clear(); 2080d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(0, msg.optionalUint32); 2090d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 2100d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.optionalUint32 = 123; 2110d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar byte [] result = MessageNano.toByteArray(msg); 2120d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar int msgSerializedSize = msg.getSerializedSize(); 2130d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 2140d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertTrue(msgSerializedSize == 5); 2150d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(result.length, msgSerializedSize); 2160d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 2170d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 2180d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(123, newMsg.optionalUint32); 2190d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar } 2200d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar 2210d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar public void testNanoOptionalUint64() throws Exception { 2220d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar TestAllTypesNano msg = new TestAllTypesNano(); 2230d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.optionalUint64 = 123; 2240d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar assertEquals(123, msg.optionalUint64); 2250d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar msg.clear() 2260d8951cef4b1a1dbf4ff5ba3e8796cf1d4503098Harish Mahendrakar .optionalUint64 = 456; 227 assertEquals(456, msg.optionalUint64); 228 msg.clear(); 229 assertEquals(0, msg.optionalUint64); 230 231 msg.optionalUint64 = 123; 232 byte [] result = MessageNano.toByteArray(msg); 233 int msgSerializedSize = msg.getSerializedSize(); 234 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 235 assertTrue(msgSerializedSize == 5); 236 assertEquals(result.length, msgSerializedSize); 237 238 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 239 assertEquals(123, newMsg.optionalUint64); 240 } 241 242 public void testNanoOptionalSint32() throws Exception { 243 TestAllTypesNano msg = new TestAllTypesNano(); 244 msg.optionalSint32 = 123; 245 assertEquals(123, msg.optionalSint32); 246 msg.clear() 247 .optionalSint32 = 456; 248 assertEquals(456, msg.optionalSint32); 249 msg.clear(); 250 assertEquals(0, msg.optionalSint32); 251 252 msg.optionalSint32 = -123; 253 byte [] result = MessageNano.toByteArray(msg); 254 int msgSerializedSize = msg.getSerializedSize(); 255 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 256 assertTrue(msgSerializedSize == 6); 257 assertEquals(result.length, msgSerializedSize); 258 259 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 260 assertEquals(-123, newMsg.optionalSint32); 261 } 262 263 public void testNanoOptionalSint64() throws Exception { 264 TestAllTypesNano msg = new TestAllTypesNano(); 265 msg.optionalSint64 = 123; 266 assertEquals(123, msg.optionalSint64); 267 msg.clear() 268 .optionalSint64 = 456; 269 assertEquals(456, msg.optionalSint64); 270 msg.clear(); 271 assertEquals(0, msg.optionalSint64); 272 273 msg.optionalSint64 = -123; 274 byte [] result = MessageNano.toByteArray(msg); 275 int msgSerializedSize = msg.getSerializedSize(); 276 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 277 assertTrue(msgSerializedSize == 6); 278 assertEquals(result.length, msgSerializedSize); 279 280 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 281 assertEquals(-123, newMsg.optionalSint64); 282 } 283 284 public void testNanoOptionalFixed32() throws Exception { 285 TestAllTypesNano msg = new TestAllTypesNano(); 286 msg.optionalFixed32 = 123; 287 assertEquals(123, msg.optionalFixed32); 288 msg.clear() 289 .optionalFixed32 = 456; 290 assertEquals(456, msg.optionalFixed32); 291 msg.clear(); 292 assertEquals(0, msg.optionalFixed32); 293 294 msg.optionalFixed32 = 123; 295 byte [] result = MessageNano.toByteArray(msg); 296 int msgSerializedSize = msg.getSerializedSize(); 297 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 298 assertTrue(msgSerializedSize == 8); 299 assertEquals(result.length, msgSerializedSize); 300 301 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 302 assertEquals(123, newMsg.optionalFixed32); 303 } 304 305 public void testNanoOptionalFixed64() throws Exception { 306 TestAllTypesNano msg = new TestAllTypesNano(); 307 msg.optionalFixed64 = 123; 308 assertEquals(123, msg.optionalFixed64); 309 msg.clear() 310 .optionalFixed64 = 456; 311 assertEquals(456, msg.optionalFixed64); 312 msg.clear(); 313 assertEquals(0, msg.optionalFixed64); 314 315 msg.optionalFixed64 = 123; 316 byte [] result = MessageNano.toByteArray(msg); 317 int msgSerializedSize = msg.getSerializedSize(); 318 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 319 assertTrue(msgSerializedSize == 12); 320 assertEquals(result.length, msgSerializedSize); 321 322 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 323 assertEquals(123, newMsg.optionalFixed64); 324 } 325 326 public void testNanoOptionalSfixed32() throws Exception { 327 TestAllTypesNano msg = new TestAllTypesNano(); 328 msg.optionalSfixed32 = 123; 329 assertEquals(123, msg.optionalSfixed32); 330 msg.clear() 331 .optionalSfixed32 = 456; 332 assertEquals(456, msg.optionalSfixed32); 333 msg.clear(); 334 assertEquals(0, msg.optionalSfixed32); 335 336 msg.optionalSfixed32 = 123; 337 byte [] result = MessageNano.toByteArray(msg); 338 int msgSerializedSize = msg.getSerializedSize(); 339 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 340 assertTrue(msgSerializedSize == 8); 341 assertEquals(result.length, msgSerializedSize); 342 343 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 344 assertEquals(123, newMsg.optionalSfixed32); 345 } 346 347 public void testNanoOptionalSfixed64() throws Exception { 348 TestAllTypesNano msg = new TestAllTypesNano(); 349 msg.optionalSfixed64 = 123; 350 assertEquals(123, msg.optionalSfixed64); 351 msg.clear() 352 .optionalSfixed64 = 456; 353 assertEquals(456, msg.optionalSfixed64); 354 msg.clear(); 355 assertEquals(0, msg.optionalSfixed64); 356 357 msg.optionalSfixed64 = -123; 358 byte [] result = MessageNano.toByteArray(msg); 359 int msgSerializedSize = msg.getSerializedSize(); 360 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 361 assertTrue(msgSerializedSize == 12); 362 assertEquals(result.length, msgSerializedSize); 363 364 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 365 assertEquals(-123, newMsg.optionalSfixed64); 366 } 367 368 public void testNanoOptionalFloat() throws Exception { 369 TestAllTypesNano msg = new TestAllTypesNano(); 370 msg.optionalFloat = 123f; 371 assertTrue(123.0f == msg.optionalFloat); 372 msg.clear() 373 .optionalFloat = 456.0f; 374 assertTrue(456.0f == msg.optionalFloat); 375 msg.clear(); 376 assertTrue(0.0f == msg.optionalFloat); 377 378 msg.optionalFloat = -123.456f; 379 byte [] result = MessageNano.toByteArray(msg); 380 int msgSerializedSize = msg.getSerializedSize(); 381 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 382 assertTrue(msgSerializedSize == 8); 383 assertEquals(result.length, msgSerializedSize); 384 385 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 386 assertTrue(-123.456f == newMsg.optionalFloat); 387 } 388 389 public void testNanoOptionalDouble() throws Exception { 390 TestAllTypesNano msg = new TestAllTypesNano(); 391 msg.optionalDouble = 123; 392 assertTrue(123.0 == msg.optionalDouble); 393 msg.clear() 394 .optionalDouble = 456.0; 395 assertTrue(456.0 == msg.optionalDouble); 396 msg.clear(); 397 assertTrue(0.0 == msg.optionalDouble); 398 399 msg.optionalDouble = -123.456; 400 byte [] result = MessageNano.toByteArray(msg); 401 int msgSerializedSize = msg.getSerializedSize(); 402 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 403 assertTrue(msgSerializedSize == 12); 404 assertEquals(result.length, msgSerializedSize); 405 406 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 407 assertTrue(-123.456 == newMsg.optionalDouble); 408 } 409 410 public void testNanoOptionalBool() throws Exception { 411 TestAllTypesNano msg = new TestAllTypesNano(); 412 msg.optionalBool = true; 413 assertTrue(msg.optionalBool); 414 msg.clear() 415 .optionalBool = true; 416 assertTrue(msg.optionalBool); 417 msg.clear(); 418 assertFalse(msg.optionalBool); 419 420 msg.optionalBool = true; 421 byte [] result = MessageNano.toByteArray(msg); 422 int msgSerializedSize = msg.getSerializedSize(); 423 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 424 assertTrue(msgSerializedSize == 5); 425 assertEquals(result.length, msgSerializedSize); 426 427 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 428 assertTrue(newMsg.optionalBool); 429 } 430 431 public void testNanoOptionalString() throws Exception { 432 TestAllTypesNano msg = new TestAllTypesNano(); 433 msg.optionalString = "hello"; 434 assertEquals("hello", msg.optionalString); 435 msg.clear(); 436 assertTrue(msg.optionalString.isEmpty()); 437 msg.clear() 438 .optionalString = "hello2"; 439 assertEquals("hello2", msg.optionalString); 440 msg.clear(); 441 assertTrue(msg.optionalString.isEmpty()); 442 443 msg.optionalString = "bye"; 444 byte [] result = MessageNano.toByteArray(msg); 445 int msgSerializedSize = msg.getSerializedSize(); 446 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 447 assertTrue(msgSerializedSize == 8); 448 assertEquals(result.length, msgSerializedSize); 449 450 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 451 assertTrue(newMsg.optionalString != null); 452 assertEquals("bye", newMsg.optionalString); 453 } 454 455 public void testNanoOptionalBytes() throws Exception { 456 TestAllTypesNano msg = new TestAllTypesNano(); 457 assertFalse(msg.optionalBytes.length > 0); 458 msg.optionalBytes = InternalNano.copyFromUtf8("hello"); 459 assertTrue(msg.optionalBytes.length > 0); 460 assertEquals("hello", new String(msg.optionalBytes, "UTF-8")); 461 msg.clear(); 462 assertFalse(msg.optionalBytes.length > 0); 463 msg.clear() 464 .optionalBytes = InternalNano.copyFromUtf8("hello"); 465 assertTrue(msg.optionalBytes.length > 0); 466 msg.clear(); 467 assertFalse(msg.optionalBytes.length > 0); 468 469 msg.optionalBytes = InternalNano.copyFromUtf8("bye"); 470 byte [] result = MessageNano.toByteArray(msg); 471 int msgSerializedSize = msg.getSerializedSize(); 472 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 473 assertTrue(msgSerializedSize == 8); 474 assertEquals(result.length, msgSerializedSize); 475 476 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 477 assertTrue(newMsg.optionalBytes.length > 0); 478 assertEquals("bye", new String(newMsg.optionalBytes, "UTF-8")); 479 } 480 481 public void testNanoOptionalGroup() throws Exception { 482 TestAllTypesNano msg = new TestAllTypesNano(); 483 TestAllTypesNano.OptionalGroup grp = new TestAllTypesNano.OptionalGroup(); 484 grp.a = 1; 485 assertFalse(msg.optionalGroup != null); 486 msg.optionalGroup = grp; 487 assertTrue(msg.optionalGroup != null); 488 assertEquals(1, msg.optionalGroup.a); 489 msg.clear(); 490 assertFalse(msg.optionalGroup != null); 491 msg.clear() 492 .optionalGroup = new TestAllTypesNano.OptionalGroup(); 493 msg.optionalGroup.a = 2; 494 assertTrue(msg.optionalGroup != null); 495 msg.clear(); 496 assertFalse(msg.optionalGroup != null); 497 498 msg.optionalGroup = grp; 499 byte [] result = MessageNano.toByteArray(msg); 500 int msgSerializedSize = msg.getSerializedSize(); 501 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 502 assertTrue(msgSerializedSize == 10); 503 assertEquals(result.length, msgSerializedSize); 504 505 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 506 assertTrue(newMsg.optionalGroup != null); 507 assertEquals(1, newMsg.optionalGroup.a); 508 } 509 510 public void testNanoOptionalGroupWithUnknownFieldsEnabled() throws Exception { 511 MessageWithGroup msg = new MessageWithGroup(); 512 MessageWithGroup.Group grp = new MessageWithGroup.Group(); 513 grp.a = 1; 514 msg.group = grp; 515 byte [] serialized = MessageNano.toByteArray(msg); 516 517 MessageWithGroup parsed = MessageWithGroup.parseFrom(serialized); 518 assertTrue(msg.group != null); 519 assertEquals(1, msg.group.a); 520 521 byte [] serialized2 = MessageNano.toByteArray(parsed); 522 assertEquals(serialized2.length, serialized.length); 523 MessageWithGroup parsed2 = MessageWithGroup.parseFrom(serialized2); 524 } 525 526 public void testNanoOptionalNestedMessage() throws Exception { 527 TestAllTypesNano msg = new TestAllTypesNano(); 528 TestAllTypesNano.NestedMessage nestedMsg = new TestAllTypesNano.NestedMessage(); 529 nestedMsg.bb = 1; 530 assertFalse(msg.optionalNestedMessage != null); 531 msg.optionalNestedMessage = nestedMsg; 532 assertTrue(msg.optionalNestedMessage != null); 533 assertEquals(1, msg.optionalNestedMessage.bb); 534 msg.clear(); 535 assertFalse(msg.optionalNestedMessage != null); 536 msg.clear() 537 .optionalNestedMessage = new TestAllTypesNano.NestedMessage(); 538 msg.optionalNestedMessage.bb = 2; 539 assertTrue(msg.optionalNestedMessage != null); 540 msg.clear(); 541 assertFalse(msg.optionalNestedMessage != null); 542 543 msg.optionalNestedMessage = nestedMsg; 544 byte [] result = MessageNano.toByteArray(msg); 545 int msgSerializedSize = msg.getSerializedSize(); 546 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 547 assertTrue(msgSerializedSize == 8); 548 assertEquals(result.length, msgSerializedSize); 549 550 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 551 assertTrue(newMsg.optionalNestedMessage != null); 552 assertEquals(1, newMsg.optionalNestedMessage.bb); 553 } 554 555 public void testNanoOptionalForeignMessage() throws Exception { 556 TestAllTypesNano msg = new TestAllTypesNano(); 557 NanoOuterClass.ForeignMessageNano nestedMsg = new NanoOuterClass.ForeignMessageNano(); 558 nestedMsg.c = 1; 559 assertFalse(msg.optionalForeignMessage != null); 560 msg.optionalForeignMessage = nestedMsg; 561 assertTrue(msg.optionalForeignMessage != null); 562 assertEquals(1, msg.optionalForeignMessage.c); 563 msg.clear(); 564 assertFalse(msg.optionalForeignMessage != null); 565 msg.clear() 566 .optionalForeignMessage = new NanoOuterClass.ForeignMessageNano(); 567 msg.optionalForeignMessage.c = 2; 568 assertTrue(msg.optionalForeignMessage != null); 569 msg.clear(); 570 assertFalse(msg.optionalForeignMessage != null); 571 572 msg.optionalForeignMessage = nestedMsg; 573 byte [] result = MessageNano.toByteArray(msg); 574 int msgSerializedSize = msg.getSerializedSize(); 575 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 576 assertTrue(msgSerializedSize == 8); 577 assertEquals(result.length, msgSerializedSize); 578 579 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 580 assertTrue(newMsg.optionalForeignMessage != null); 581 assertEquals(1, newMsg.optionalForeignMessage.c); 582 } 583 584 public void testNanoOptionalImportMessage() throws Exception { 585 TestAllTypesNano msg = new TestAllTypesNano(); 586 UnittestImportNano.ImportMessageNano nestedMsg = new UnittestImportNano.ImportMessageNano(); 587 nestedMsg.d = 1; 588 assertFalse(msg.optionalImportMessage != null); 589 msg.optionalImportMessage = nestedMsg; 590 assertTrue(msg.optionalImportMessage != null); 591 assertEquals(1, msg.optionalImportMessage.d); 592 msg.clear(); 593 assertFalse(msg.optionalImportMessage != null); 594 msg.clear() 595 .optionalImportMessage = new UnittestImportNano.ImportMessageNano(); 596 msg.optionalImportMessage.d = 2; 597 assertTrue(msg.optionalImportMessage != null); 598 msg.clear(); 599 assertFalse(msg.optionalImportMessage != null); 600 601 msg.optionalImportMessage = nestedMsg; 602 byte [] result = MessageNano.toByteArray(msg); 603 int msgSerializedSize = msg.getSerializedSize(); 604 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 605 assertTrue(msgSerializedSize == 8); 606 assertEquals(result.length, msgSerializedSize); 607 608 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 609 assertTrue(newMsg.optionalImportMessage != null); 610 assertEquals(1, newMsg.optionalImportMessage.d); 611 } 612 613 public void testNanoOptionalNestedEnum() throws Exception { 614 TestAllTypesNano msg = new TestAllTypesNano(); 615 msg.optionalNestedEnum = TestAllTypesNano.BAR; 616 assertEquals(TestAllTypesNano.BAR, msg.optionalNestedEnum); 617 msg.clear() 618 .optionalNestedEnum = TestAllTypesNano.BAZ; 619 assertEquals(TestAllTypesNano.BAZ, msg.optionalNestedEnum); 620 msg.clear(); 621 assertEquals(TestAllTypesNano.FOO, msg.optionalNestedEnum); 622 623 msg.optionalNestedEnum = TestAllTypesNano.BAR; 624 byte [] result = MessageNano.toByteArray(msg); 625 int msgSerializedSize = msg.getSerializedSize(); 626 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 627 assertTrue(msgSerializedSize == 6); 628 assertEquals(result.length, msgSerializedSize); 629 630 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 631 assertEquals(TestAllTypesNano.BAR, newMsg.optionalNestedEnum); 632 } 633 634 public void testNanoOptionalForeignEnum() throws Exception { 635 TestAllTypesNano msg = new TestAllTypesNano(); 636 msg.optionalForeignEnum = NanoOuterClass.FOREIGN_NANO_BAR; 637 assertEquals(NanoOuterClass.FOREIGN_NANO_BAR, msg.optionalForeignEnum); 638 msg.clear() 639 .optionalForeignEnum = NanoOuterClass.FOREIGN_NANO_BAZ; 640 assertEquals(NanoOuterClass.FOREIGN_NANO_BAZ, msg.optionalForeignEnum); 641 msg.clear(); 642 assertEquals(NanoOuterClass.FOREIGN_NANO_FOO, msg.optionalForeignEnum); 643 644 msg.optionalForeignEnum = NanoOuterClass.FOREIGN_NANO_BAR; 645 byte [] result = MessageNano.toByteArray(msg); 646 int msgSerializedSize = msg.getSerializedSize(); 647 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 648 assertTrue(msgSerializedSize == 6); 649 assertEquals(result.length, msgSerializedSize); 650 651 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 652 assertEquals(NanoOuterClass.FOREIGN_NANO_BAR, newMsg.optionalForeignEnum); 653 } 654 655 public void testNanoOptionalImportEnum() throws Exception { 656 TestAllTypesNano msg = new TestAllTypesNano(); 657 msg.optionalImportEnum = UnittestImportNano.IMPORT_NANO_BAR; 658 assertEquals(UnittestImportNano.IMPORT_NANO_BAR, msg.optionalImportEnum); 659 msg.clear() 660 .optionalImportEnum = UnittestImportNano.IMPORT_NANO_BAZ; 661 assertEquals(UnittestImportNano.IMPORT_NANO_BAZ, msg.optionalImportEnum); 662 msg.clear(); 663 assertEquals(UnittestImportNano.IMPORT_NANO_FOO, msg.optionalImportEnum); 664 665 msg.optionalImportEnum = UnittestImportNano.IMPORT_NANO_BAR; 666 byte [] result = MessageNano.toByteArray(msg); 667 int msgSerializedSize = msg.getSerializedSize(); 668 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 669 assertTrue(msgSerializedSize == 6); 670 assertEquals(result.length, msgSerializedSize); 671 672 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 673 assertEquals(UnittestImportNano.IMPORT_NANO_BAR, newMsg.optionalImportEnum); 674 } 675 676 public void testNanoOptionalStringPiece() throws Exception { 677 TestAllTypesNano msg = new TestAllTypesNano(); 678 msg.optionalStringPiece = "hello"; 679 assertEquals("hello", msg.optionalStringPiece); 680 msg.clear(); 681 assertTrue(msg.optionalStringPiece.isEmpty()); 682 msg.clear() 683 .optionalStringPiece = "hello2"; 684 assertEquals("hello2", msg.optionalStringPiece); 685 msg.clear(); 686 assertTrue(msg.optionalStringPiece.isEmpty()); 687 688 msg.optionalStringPiece = "bye"; 689 byte [] result = MessageNano.toByteArray(msg); 690 int msgSerializedSize = msg.getSerializedSize(); 691 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 692 assertTrue(msgSerializedSize == 9); 693 assertEquals(result.length, msgSerializedSize); 694 695 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 696 assertTrue(newMsg.optionalStringPiece != null); 697 assertEquals("bye", newMsg.optionalStringPiece); 698 } 699 700 public void testNanoOptionalCord() throws Exception { 701 TestAllTypesNano msg = new TestAllTypesNano(); 702 msg.optionalCord = "hello"; 703 assertEquals("hello", msg.optionalCord); 704 msg.clear(); 705 assertTrue(msg.optionalCord.isEmpty()); 706 msg.clear() 707 .optionalCord = "hello2"; 708 assertEquals("hello2", msg.optionalCord); 709 msg.clear(); 710 assertTrue(msg.optionalCord.isEmpty()); 711 712 msg.optionalCord = "bye"; 713 byte [] result = MessageNano.toByteArray(msg); 714 int msgSerializedSize = msg.getSerializedSize(); 715 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 716 assertTrue(msgSerializedSize == 9); 717 assertEquals(result.length, msgSerializedSize); 718 719 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 720 assertTrue(newMsg.optionalCord != null); 721 assertEquals("bye", newMsg.optionalCord); 722 } 723 724 public void testNanoRepeatedInt32() throws Exception { 725 TestAllTypesNano msg = new TestAllTypesNano(); 726 assertEquals(0, msg.repeatedInt32.length); 727 msg.repeatedInt32 = new int[] { 123, 789, 456 }; 728 assertEquals(789, msg.repeatedInt32[1]); 729 assertEquals(456, msg.repeatedInt32[2]); 730 msg.clear(); 731 assertEquals(0, msg.repeatedInt32.length); 732 msg.clear() 733 .repeatedInt32 = new int[] { 456 }; 734 assertEquals(1, msg.repeatedInt32.length); 735 assertEquals(456, msg.repeatedInt32[0]); 736 msg.clear(); 737 assertEquals(0, msg.repeatedInt32.length); 738 739 // Test 1 entry 740 msg.clear() 741 .repeatedInt32 = new int[] { 123 }; 742 assertEquals(1, msg.repeatedInt32.length); 743 byte [] result = MessageNano.toByteArray(msg); 744 int msgSerializedSize = msg.getSerializedSize(); 745 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 746 assertTrue(msgSerializedSize == 6); 747 assertEquals(result.length, msgSerializedSize); 748 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 749 assertEquals(1, newMsg.repeatedInt32.length); 750 assertEquals(123, newMsg.repeatedInt32[0]); 751 752 // Test 2 entries 753 msg.clear() 754 .repeatedInt32 = new int[] { 123, 456 }; 755 assertEquals(2, msg.repeatedInt32.length); 756 result = MessageNano.toByteArray(msg); 757 msgSerializedSize = msg.getSerializedSize(); 758 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 759 assertTrue(msgSerializedSize == 10); 760 assertEquals(result.length, msgSerializedSize); 761 762 newMsg = TestAllTypesNano.parseFrom(result); 763 assertEquals(2, newMsg.repeatedInt32.length); 764 assertEquals(123, newMsg.repeatedInt32[0]); 765 assertEquals(456, newMsg.repeatedInt32[1]); 766 } 767 768 public void testNanoRepeatedInt64() throws Exception { 769 TestAllTypesNano msg = new TestAllTypesNano(); 770 assertEquals(0, msg.repeatedInt64.length); 771 msg.repeatedInt64 = new long[] { 123, 789, 456 }; 772 assertEquals(789, msg.repeatedInt64[1]); 773 assertEquals(456, msg.repeatedInt64[2]); 774 msg.clear(); 775 assertEquals(0, msg.repeatedInt64.length); 776 msg.clear() 777 .repeatedInt64 = new long[] { 456 }; 778 assertEquals(1, msg.repeatedInt64.length); 779 assertEquals(456, msg.repeatedInt64[0]); 780 msg.clear(); 781 assertEquals(0, msg.repeatedInt64.length); 782 783 // Test 1 entry 784 msg.clear() 785 .repeatedInt64 = new long[] { 123 }; 786 assertEquals(1, msg.repeatedInt64.length); 787 byte [] result = MessageNano.toByteArray(msg); 788 int msgSerializedSize = msg.getSerializedSize(); 789 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 790 assertTrue(msgSerializedSize == 6); 791 assertEquals(result.length, msgSerializedSize); 792 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 793 assertEquals(1, newMsg.repeatedInt64.length); 794 assertEquals(123, newMsg.repeatedInt64[0]); 795 796 // Test 2 entries 797 msg.clear() 798 .repeatedInt64 = new long[] { 123, 456 }; 799 assertEquals(2, msg.repeatedInt64.length); 800 result = MessageNano.toByteArray(msg); 801 msgSerializedSize = msg.getSerializedSize(); 802 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 803 assertTrue(msgSerializedSize == 10); 804 assertEquals(result.length, msgSerializedSize); 805 806 newMsg = TestAllTypesNano.parseFrom(result); 807 assertEquals(2, newMsg.repeatedInt64.length); 808 assertEquals(123, newMsg.repeatedInt64[0]); 809 assertEquals(456, newMsg.repeatedInt64[1]); 810 } 811 812 public void testNanoRepeatedUint32() throws Exception { 813 TestAllTypesNano msg = new TestAllTypesNano(); 814 assertEquals(0, msg.repeatedUint32.length); 815 msg.repeatedUint32 = new int[] { 123, 789, 456 }; 816 assertEquals(789, msg.repeatedUint32[1]); 817 assertEquals(456, msg.repeatedUint32[2]); 818 msg.clear(); 819 assertEquals(0, msg.repeatedUint32.length); 820 msg.clear() 821 .repeatedUint32 = new int[] { 456 }; 822 assertEquals(1, msg.repeatedUint32.length); 823 assertEquals(456, msg.repeatedUint32[0]); 824 msg.clear(); 825 assertEquals(0, msg.repeatedUint32.length); 826 827 // Test 1 entry 828 msg.clear() 829 .repeatedUint32 = new int[] { 123 }; 830 assertEquals(1, msg.repeatedUint32.length); 831 byte [] result = MessageNano.toByteArray(msg); 832 int msgSerializedSize = msg.getSerializedSize(); 833 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 834 assertTrue(msgSerializedSize == 6); 835 assertEquals(result.length, msgSerializedSize); 836 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 837 assertEquals(1, newMsg.repeatedUint32.length); 838 assertEquals(123, newMsg.repeatedUint32[0]); 839 840 // Test 2 entries 841 msg.clear() 842 .repeatedUint32 = new int[] { 123, 456 }; 843 assertEquals(2, msg.repeatedUint32.length); 844 result = MessageNano.toByteArray(msg); 845 msgSerializedSize = msg.getSerializedSize(); 846 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 847 assertTrue(msgSerializedSize == 10); 848 assertEquals(result.length, msgSerializedSize); 849 850 newMsg = TestAllTypesNano.parseFrom(result); 851 assertEquals(2, newMsg.repeatedUint32.length); 852 assertEquals(123, newMsg.repeatedUint32[0]); 853 assertEquals(456, newMsg.repeatedUint32[1]); 854 } 855 856 public void testNanoRepeatedUint64() throws Exception { 857 TestAllTypesNano msg = new TestAllTypesNano(); 858 assertEquals(0, msg.repeatedUint64.length); 859 msg.repeatedUint64 = new long[] { 123, 789, 456 }; 860 assertEquals(789, msg.repeatedUint64[1]); 861 assertEquals(456, msg.repeatedUint64[2]); 862 msg.clear(); 863 assertEquals(0, msg.repeatedUint64.length); 864 msg.clear() 865 .repeatedUint64 = new long[] { 456 }; 866 assertEquals(1, msg.repeatedUint64.length); 867 assertEquals(456, msg.repeatedUint64[0]); 868 msg.clear(); 869 assertEquals(0, msg.repeatedUint64.length); 870 871 // Test 1 entry 872 msg.clear() 873 .repeatedUint64 = new long[] { 123 }; 874 assertEquals(1, msg.repeatedUint64.length); 875 byte [] result = MessageNano.toByteArray(msg); 876 int msgSerializedSize = msg.getSerializedSize(); 877 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 878 assertTrue(msgSerializedSize == 6); 879 assertEquals(result.length, msgSerializedSize); 880 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 881 assertEquals(1, newMsg.repeatedUint64.length); 882 assertEquals(123, newMsg.repeatedUint64[0]); 883 884 // Test 2 entries 885 msg.clear() 886 .repeatedUint64 = new long[] { 123, 456 }; 887 assertEquals(2, msg.repeatedUint64.length); 888 result = MessageNano.toByteArray(msg); 889 msgSerializedSize = msg.getSerializedSize(); 890 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 891 assertTrue(msgSerializedSize == 10); 892 assertEquals(result.length, msgSerializedSize); 893 894 newMsg = TestAllTypesNano.parseFrom(result); 895 assertEquals(2, newMsg.repeatedUint64.length); 896 assertEquals(123, newMsg.repeatedUint64[0]); 897 assertEquals(456, newMsg.repeatedUint64[1]); 898 } 899 900 public void testNanoRepeatedSint32() throws Exception { 901 TestAllTypesNano msg = new TestAllTypesNano(); 902 assertEquals(0, msg.repeatedSint32.length); 903 msg.repeatedSint32 = new int[] { 123, 789, 456 }; 904 assertEquals(789, msg.repeatedSint32[1]); 905 assertEquals(456, msg.repeatedSint32[2]); 906 msg.clear(); 907 assertEquals(0, msg.repeatedSint32.length); 908 msg.clear() 909 .repeatedSint32 = new int[] { 456 }; 910 assertEquals(1, msg.repeatedSint32.length); 911 assertEquals(456, msg.repeatedSint32[0]); 912 msg.clear(); 913 assertEquals(0, msg.repeatedSint32.length); 914 915 // Test 1 entry 916 msg.clear() 917 .repeatedSint32 = new int[] { 123 }; 918 assertEquals(1, msg.repeatedSint32.length); 919 byte [] result = MessageNano.toByteArray(msg); 920 int msgSerializedSize = msg.getSerializedSize(); 921 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 922 assertTrue(msgSerializedSize == 7); 923 assertEquals(result.length, msgSerializedSize); 924 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 925 assertEquals(1, newMsg.repeatedSint32.length); 926 assertEquals(123, newMsg.repeatedSint32[0]); 927 928 // Test 2 entries 929 msg.clear() 930 .repeatedSint32 = new int[] { 123, 456 }; 931 assertEquals(2, msg.repeatedSint32.length); 932 result = MessageNano.toByteArray(msg); 933 msgSerializedSize = msg.getSerializedSize(); 934 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 935 assertTrue(msgSerializedSize == 11); 936 assertEquals(result.length, msgSerializedSize); 937 938 newMsg = TestAllTypesNano.parseFrom(result); 939 assertEquals(2, newMsg.repeatedSint32.length); 940 assertEquals(123, newMsg.repeatedSint32[0]); 941 assertEquals(456, newMsg.repeatedSint32[1]); 942 } 943 944 public void testNanoRepeatedSint64() throws Exception { 945 TestAllTypesNano msg = new TestAllTypesNano(); 946 assertEquals(0, msg.repeatedSint64.length); 947 msg.repeatedSint64 = new long[] { 123, 789, 456 }; 948 assertEquals(789, msg.repeatedSint64[1]); 949 assertEquals(456, msg.repeatedSint64[2]); 950 msg.clear(); 951 assertEquals(0, msg.repeatedSint64.length); 952 msg.clear() 953 .repeatedSint64 = new long[] { 456 }; 954 assertEquals(1, msg.repeatedSint64.length); 955 assertEquals(456, msg.repeatedSint64[0]); 956 msg.clear(); 957 assertEquals(0, msg.repeatedSint64.length); 958 959 // Test 1 entry 960 msg.clear() 961 .repeatedSint64 = new long[] { 123 }; 962 assertEquals(1, msg.repeatedSint64.length); 963 byte [] result = MessageNano.toByteArray(msg); 964 int msgSerializedSize = msg.getSerializedSize(); 965 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 966 assertTrue(msgSerializedSize == 7); 967 assertEquals(result.length, msgSerializedSize); 968 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 969 assertEquals(1, newMsg.repeatedSint64.length); 970 assertEquals(123, newMsg.repeatedSint64[0]); 971 972 // Test 2 entries 973 msg.clear() 974 .repeatedSint64 = new long[] { 123, 456 }; 975 assertEquals(2, msg.repeatedSint64.length); 976 result = MessageNano.toByteArray(msg); 977 msgSerializedSize = msg.getSerializedSize(); 978 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 979 assertTrue(msgSerializedSize == 11); 980 assertEquals(result.length, msgSerializedSize); 981 982 newMsg = TestAllTypesNano.parseFrom(result); 983 assertEquals(2, newMsg.repeatedSint64.length); 984 assertEquals(123, newMsg.repeatedSint64[0]); 985 assertEquals(456, newMsg.repeatedSint64[1]); 986 } 987 988 public void testNanoRepeatedFixed32() throws Exception { 989 TestAllTypesNano msg = new TestAllTypesNano(); 990 assertEquals(0, msg.repeatedFixed32.length); 991 msg.repeatedFixed32 = new int[] { 123, 789, 456 }; 992 assertEquals(789, msg.repeatedFixed32[1]); 993 assertEquals(456, msg.repeatedFixed32[2]); 994 msg.clear(); 995 assertEquals(0, msg.repeatedFixed32.length); 996 msg.clear() 997 .repeatedFixed32 = new int[] { 456 }; 998 assertEquals(1, msg.repeatedFixed32.length); 999 assertEquals(456, msg.repeatedFixed32[0]); 1000 msg.clear(); 1001 assertEquals(0, msg.repeatedFixed32.length); 1002 1003 // Test 1 entry 1004 msg.clear() 1005 .repeatedFixed32 = new int[] { 123 }; 1006 assertEquals(1, msg.repeatedFixed32.length); 1007 byte [] result = MessageNano.toByteArray(msg); 1008 int msgSerializedSize = msg.getSerializedSize(); 1009 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1010 assertTrue(msgSerializedSize == 9); 1011 assertEquals(result.length, msgSerializedSize); 1012 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1013 assertEquals(1, newMsg.repeatedFixed32.length); 1014 assertEquals(123, newMsg.repeatedFixed32[0]); 1015 1016 // Test 2 entries 1017 msg.clear() 1018 .repeatedFixed32 = new int[] { 123, 456 }; 1019 assertEquals(2, msg.repeatedFixed32.length); 1020 result = MessageNano.toByteArray(msg); 1021 msgSerializedSize = msg.getSerializedSize(); 1022 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1023 assertTrue(msgSerializedSize == 15); 1024 assertEquals(result.length, msgSerializedSize); 1025 1026 newMsg = TestAllTypesNano.parseFrom(result); 1027 assertEquals(2, newMsg.repeatedFixed32.length); 1028 assertEquals(123, newMsg.repeatedFixed32[0]); 1029 assertEquals(456, newMsg.repeatedFixed32[1]); 1030 } 1031 1032 public void testNanoRepeatedFixed64() throws Exception { 1033 TestAllTypesNano msg = new TestAllTypesNano(); 1034 assertEquals(0, msg.repeatedFixed64.length); 1035 msg.repeatedFixed64 = new long[] { 123, 789, 456 }; 1036 assertEquals(789, msg.repeatedFixed64[1]); 1037 assertEquals(456, msg.repeatedFixed64[2]); 1038 msg.clear(); 1039 assertEquals(0, msg.repeatedFixed64.length); 1040 msg.clear() 1041 .repeatedFixed64 = new long[] { 456 }; 1042 assertEquals(1, msg.repeatedFixed64.length); 1043 assertEquals(456, msg.repeatedFixed64[0]); 1044 msg.clear(); 1045 assertEquals(0, msg.repeatedFixed64.length); 1046 1047 // Test 1 entry 1048 msg.clear() 1049 .repeatedFixed64 = new long[] { 123 }; 1050 assertEquals(1, msg.repeatedFixed64.length); 1051 byte [] result = MessageNano.toByteArray(msg); 1052 int msgSerializedSize = msg.getSerializedSize(); 1053 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1054 assertTrue(msgSerializedSize == 13); 1055 assertEquals(result.length, msgSerializedSize); 1056 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1057 assertEquals(1, newMsg.repeatedFixed64.length); 1058 assertEquals(123, newMsg.repeatedFixed64[0]); 1059 1060 // Test 2 entries 1061 msg.clear() 1062 .repeatedFixed64 = new long[] { 123, 456 }; 1063 assertEquals(2, msg.repeatedFixed64.length); 1064 result = MessageNano.toByteArray(msg); 1065 msgSerializedSize = msg.getSerializedSize(); 1066 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1067 assertTrue(msgSerializedSize == 23); 1068 assertEquals(result.length, msgSerializedSize); 1069 1070 newMsg = TestAllTypesNano.parseFrom(result); 1071 assertEquals(2, newMsg.repeatedFixed64.length); 1072 assertEquals(123, newMsg.repeatedFixed64[0]); 1073 assertEquals(456, newMsg.repeatedFixed64[1]); 1074 } 1075 1076 public void testNanoRepeatedSfixed32() throws Exception { 1077 TestAllTypesNano msg = new TestAllTypesNano(); 1078 assertEquals(0, msg.repeatedSfixed32.length); 1079 msg.repeatedSfixed32 = new int[] { 123, 789, 456 }; 1080 assertEquals(789, msg.repeatedSfixed32[1]); 1081 assertEquals(456, msg.repeatedSfixed32[2]); 1082 msg.clear(); 1083 assertEquals(0, msg.repeatedSfixed32.length); 1084 msg.clear() 1085 .repeatedSfixed32 = new int[] { 456 }; 1086 assertEquals(1, msg.repeatedSfixed32.length); 1087 assertEquals(456, msg.repeatedSfixed32[0]); 1088 msg.clear(); 1089 assertEquals(0, msg.repeatedSfixed32.length); 1090 1091 // Test 1 entry 1092 msg.clear() 1093 .repeatedSfixed32 = new int[] { 123 }; 1094 assertEquals(1, msg.repeatedSfixed32.length); 1095 byte [] result = MessageNano.toByteArray(msg); 1096 int msgSerializedSize = msg.getSerializedSize(); 1097 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1098 assertTrue(msgSerializedSize == 9); 1099 assertEquals(result.length, msgSerializedSize); 1100 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1101 assertEquals(1, newMsg.repeatedSfixed32.length); 1102 assertEquals(123, newMsg.repeatedSfixed32[0]); 1103 1104 // Test 2 entries 1105 msg.clear() 1106 .repeatedSfixed32 = new int[] { 123, 456 }; 1107 assertEquals(2, msg.repeatedSfixed32.length); 1108 result = MessageNano.toByteArray(msg); 1109 msgSerializedSize = msg.getSerializedSize(); 1110 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1111 assertTrue(msgSerializedSize == 15); 1112 assertEquals(result.length, msgSerializedSize); 1113 1114 newMsg = TestAllTypesNano.parseFrom(result); 1115 assertEquals(2, newMsg.repeatedSfixed32.length); 1116 assertEquals(123, newMsg.repeatedSfixed32[0]); 1117 assertEquals(456, newMsg.repeatedSfixed32[1]); 1118 } 1119 1120 public void testNanoRepeatedSfixed64() throws Exception { 1121 TestAllTypesNano msg = new TestAllTypesNano(); 1122 assertEquals(0, msg.repeatedSfixed64.length); 1123 msg.repeatedSfixed64 = new long[] { 123, 789, 456 }; 1124 assertEquals(789, msg.repeatedSfixed64[1]); 1125 assertEquals(456, msg.repeatedSfixed64[2]); 1126 msg.clear(); 1127 assertEquals(0, msg.repeatedSfixed64.length); 1128 msg.clear() 1129 .repeatedSfixed64 = new long[] { 456 }; 1130 assertEquals(1, msg.repeatedSfixed64.length); 1131 assertEquals(456, msg.repeatedSfixed64[0]); 1132 msg.clear(); 1133 assertEquals(0, msg.repeatedSfixed64.length); 1134 1135 // Test 1 entry 1136 msg.clear() 1137 .repeatedSfixed64 = new long[] { 123 }; 1138 assertEquals(1, msg.repeatedSfixed64.length); 1139 byte [] result = MessageNano.toByteArray(msg); 1140 int msgSerializedSize = msg.getSerializedSize(); 1141 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1142 assertTrue(msgSerializedSize == 13); 1143 assertEquals(result.length, msgSerializedSize); 1144 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1145 assertEquals(1, newMsg.repeatedSfixed64.length); 1146 assertEquals(123, newMsg.repeatedSfixed64[0]); 1147 1148 // Test 2 entries 1149 msg.clear() 1150 .repeatedSfixed64 = new long[] { 123, 456 }; 1151 assertEquals(2, msg.repeatedSfixed64.length); 1152 result = MessageNano.toByteArray(msg); 1153 msgSerializedSize = msg.getSerializedSize(); 1154 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1155 assertTrue(msgSerializedSize == 23); 1156 assertEquals(result.length, msgSerializedSize); 1157 1158 newMsg = TestAllTypesNano.parseFrom(result); 1159 assertEquals(2, newMsg.repeatedSfixed64.length); 1160 assertEquals(123, newMsg.repeatedSfixed64[0]); 1161 assertEquals(456, newMsg.repeatedSfixed64[1]); 1162 } 1163 1164 public void testNanoRepeatedFloat() throws Exception { 1165 TestAllTypesNano msg = new TestAllTypesNano(); 1166 assertEquals(0, msg.repeatedFloat.length); 1167 msg.repeatedFloat = new float[] { 123f, 789f, 456f }; 1168 assertEquals(789f, msg.repeatedFloat[1]); 1169 assertEquals(456f, msg.repeatedFloat[2]); 1170 msg.clear(); 1171 assertEquals(0, msg.repeatedFloat.length); 1172 msg.clear() 1173 .repeatedFloat = new float[] { 456f }; 1174 assertEquals(1, msg.repeatedFloat.length); 1175 assertEquals(456f, msg.repeatedFloat[0]); 1176 msg.clear(); 1177 assertEquals(0, msg.repeatedFloat.length); 1178 1179 // Test 1 entry 1180 msg.clear() 1181 .repeatedFloat = new float[] { 123f }; 1182 assertEquals(1, msg.repeatedFloat.length); 1183 byte [] result = MessageNano.toByteArray(msg); 1184 int msgSerializedSize = msg.getSerializedSize(); 1185 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1186 assertTrue(msgSerializedSize == 9); 1187 assertEquals(result.length, msgSerializedSize); 1188 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1189 assertEquals(1, newMsg.repeatedFloat.length); 1190 assertEquals(123f, newMsg.repeatedFloat[0]); 1191 1192 // Test 2 entries 1193 msg.clear() 1194 .repeatedFloat = new float[] { 123f, 456f }; 1195 assertEquals(2, msg.repeatedFloat.length); 1196 result = MessageNano.toByteArray(msg); 1197 msgSerializedSize = msg.getSerializedSize(); 1198 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1199 assertTrue(msgSerializedSize == 15); 1200 assertEquals(result.length, msgSerializedSize); 1201 1202 newMsg = TestAllTypesNano.parseFrom(result); 1203 assertEquals(2, newMsg.repeatedFloat.length); 1204 assertEquals(123f, newMsg.repeatedFloat[0]); 1205 assertEquals(456f, newMsg.repeatedFloat[1]); 1206 } 1207 1208 public void testNanoRepeatedDouble() throws Exception { 1209 TestAllTypesNano msg = new TestAllTypesNano(); 1210 assertEquals(0, msg.repeatedDouble.length); 1211 msg.repeatedDouble = new double[] { 123.0, 789.0, 456.0 }; 1212 assertEquals(789.0, msg.repeatedDouble[1]); 1213 assertEquals(456.0, msg.repeatedDouble[2]); 1214 msg.clear(); 1215 assertEquals(0, msg.repeatedDouble.length); 1216 msg.clear() 1217 .repeatedDouble = new double[] { 456.0 }; 1218 assertEquals(1, msg.repeatedDouble.length); 1219 assertEquals(456.0, msg.repeatedDouble[0]); 1220 msg.clear(); 1221 assertEquals(0, msg.repeatedDouble.length); 1222 1223 // Test 1 entry 1224 msg.clear() 1225 .repeatedDouble = new double[] { 123.0 }; 1226 assertEquals(1, msg.repeatedDouble.length); 1227 byte [] result = MessageNano.toByteArray(msg); 1228 int msgSerializedSize = msg.getSerializedSize(); 1229 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1230 assertTrue(msgSerializedSize == 13); 1231 assertEquals(result.length, msgSerializedSize); 1232 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1233 assertEquals(1, newMsg.repeatedDouble.length); 1234 assertEquals(123.0, newMsg.repeatedDouble[0]); 1235 1236 // Test 2 entries 1237 msg.clear() 1238 .repeatedDouble = new double[] { 123.0, 456.0 }; 1239 assertEquals(2, msg.repeatedDouble.length); 1240 result = MessageNano.toByteArray(msg); 1241 msgSerializedSize = msg.getSerializedSize(); 1242 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1243 assertTrue(msgSerializedSize == 23); 1244 assertEquals(result.length, msgSerializedSize); 1245 1246 newMsg = TestAllTypesNano.parseFrom(result); 1247 assertEquals(2, newMsg.repeatedDouble.length); 1248 assertEquals(123.0, newMsg.repeatedDouble[0]); 1249 assertEquals(456.0, newMsg.repeatedDouble[1]); 1250 } 1251 1252 public void testNanoRepeatedBool() throws Exception { 1253 TestAllTypesNano msg = new TestAllTypesNano(); 1254 assertEquals(0, msg.repeatedBool.length); 1255 msg.repeatedBool = new boolean[] { false, true, false }; 1256 assertTrue(msg.repeatedBool[1]); 1257 assertFalse(msg.repeatedBool[2]); 1258 msg.clear(); 1259 assertEquals(0, msg.repeatedBool.length); 1260 msg.clear() 1261 .repeatedBool = new boolean[] { true }; 1262 assertEquals(1, msg.repeatedBool.length); 1263 assertTrue(msg.repeatedBool[0]); 1264 msg.clear(); 1265 assertEquals(0, msg.repeatedBool.length); 1266 1267 // Test 1 entry 1268 msg.clear() 1269 .repeatedBool = new boolean[] { false }; 1270 assertEquals(1, msg.repeatedBool.length); 1271 byte [] result = MessageNano.toByteArray(msg); 1272 int msgSerializedSize = msg.getSerializedSize(); 1273 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1274 assertTrue(msgSerializedSize == 6); 1275 assertEquals(result.length, msgSerializedSize); 1276 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1277 assertEquals(1, newMsg.repeatedBool.length); 1278 assertFalse(newMsg.repeatedBool[0]); 1279 1280 // Test 2 entries 1281 msg.clear() 1282 .repeatedBool = new boolean[] { true, false }; 1283 assertEquals(2, msg.repeatedBool.length); 1284 result = MessageNano.toByteArray(msg); 1285 msgSerializedSize = msg.getSerializedSize(); 1286 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1287 assertTrue(msgSerializedSize == 9); 1288 assertEquals(result.length, msgSerializedSize); 1289 1290 newMsg = TestAllTypesNano.parseFrom(result); 1291 assertEquals(2, newMsg.repeatedBool.length); 1292 assertTrue(newMsg.repeatedBool[0]); 1293 assertFalse(newMsg.repeatedBool[1]); 1294 } 1295 1296 public void testNanoRepeatedString() throws Exception { 1297 TestAllTypesNano msg = new TestAllTypesNano(); 1298 assertEquals(0, msg.repeatedString.length); 1299 msg.repeatedString = new String[] { "hello", "bye", "boo" }; 1300 assertEquals("bye", msg.repeatedString[1]); 1301 assertEquals("boo", msg.repeatedString[2]); 1302 msg.clear(); 1303 assertEquals(0, msg.repeatedString.length); 1304 msg.clear() 1305 .repeatedString = new String[] { "boo" }; 1306 assertEquals(1, msg.repeatedString.length); 1307 assertEquals("boo", msg.repeatedString[0]); 1308 msg.clear(); 1309 assertEquals(0, msg.repeatedString.length); 1310 1311 // Test 1 entry 1312 msg.clear() 1313 .repeatedString = new String[] { "" }; 1314 assertEquals(1, msg.repeatedString.length); 1315 byte [] result = MessageNano.toByteArray(msg); 1316 int msgSerializedSize = msg.getSerializedSize(); 1317 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1318 assertTrue(msgSerializedSize == 6); 1319 assertEquals(result.length, msgSerializedSize); 1320 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1321 assertEquals(1, newMsg.repeatedString.length); 1322 assertTrue(newMsg.repeatedString[0].isEmpty()); 1323 1324 // Test 2 entries 1325 msg.clear() 1326 .repeatedString = new String[] { "hello", "world" }; 1327 assertEquals(2, msg.repeatedString.length); 1328 result = MessageNano.toByteArray(msg); 1329 msgSerializedSize = msg.getSerializedSize(); 1330 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1331 assertTrue(msgSerializedSize == 19); 1332 assertEquals(result.length, msgSerializedSize); 1333 1334 newMsg = TestAllTypesNano.parseFrom(result); 1335 assertEquals(2, newMsg.repeatedString.length); 1336 assertEquals("hello", newMsg.repeatedString[0]); 1337 assertEquals("world", newMsg.repeatedString[1]); 1338 } 1339 1340 public void testNanoRepeatedBytes() throws Exception { 1341 TestAllTypesNano msg = new TestAllTypesNano(); 1342 assertEquals(0, msg.repeatedBytes.length); 1343 msg.repeatedBytes = new byte[][] { 1344 InternalNano.copyFromUtf8("hello"), 1345 InternalNano.copyFromUtf8("bye"), 1346 InternalNano.copyFromUtf8("boo") 1347 }; 1348 assertEquals("bye", new String(msg.repeatedBytes[1], "UTF-8")); 1349 assertEquals("boo", new String(msg.repeatedBytes[2], "UTF-8")); 1350 msg.clear(); 1351 assertEquals(0, msg.repeatedBytes.length); 1352 msg.clear() 1353 .repeatedBytes = new byte[][] { InternalNano.copyFromUtf8("boo") }; 1354 assertEquals(1, msg.repeatedBytes.length); 1355 assertEquals("boo", new String(msg.repeatedBytes[0], "UTF-8")); 1356 msg.clear(); 1357 assertEquals(0, msg.repeatedBytes.length); 1358 1359 // Test 1 entry 1360 msg.clear() 1361 .repeatedBytes = new byte[][] { InternalNano.copyFromUtf8("") }; 1362 assertEquals(1, msg.repeatedBytes.length); 1363 byte [] result = MessageNano.toByteArray(msg); 1364 int msgSerializedSize = msg.getSerializedSize(); 1365 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1366 assertTrue(msgSerializedSize == 6); 1367 assertEquals(result.length, msgSerializedSize); 1368 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1369 assertEquals(1, newMsg.repeatedBytes.length); 1370 assertTrue(newMsg.repeatedBytes[0].length == 0); 1371 1372 // Test 2 entries 1373 msg.clear() 1374 .repeatedBytes = new byte[][] { 1375 InternalNano.copyFromUtf8("hello"), 1376 InternalNano.copyFromUtf8("world") 1377 }; 1378 assertEquals(2, msg.repeatedBytes.length); 1379 result = MessageNano.toByteArray(msg); 1380 msgSerializedSize = msg.getSerializedSize(); 1381 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1382 assertTrue(msgSerializedSize == 19); 1383 assertEquals(result.length, msgSerializedSize); 1384 1385 newMsg = TestAllTypesNano.parseFrom(result); 1386 assertEquals(2, newMsg.repeatedBytes.length); 1387 assertEquals("hello", new String(newMsg.repeatedBytes[0], "UTF-8")); 1388 assertEquals("world", new String(newMsg.repeatedBytes[1], "UTF-8")); 1389 } 1390 1391 public void testNanoRepeatedGroup() throws Exception { 1392 TestAllTypesNano msg = new TestAllTypesNano(); 1393 TestAllTypesNano.RepeatedGroup group0 = 1394 new TestAllTypesNano.RepeatedGroup(); 1395 group0.a = 0; 1396 TestAllTypesNano.RepeatedGroup group1 = 1397 new TestAllTypesNano.RepeatedGroup(); 1398 group1.a = 1; 1399 TestAllTypesNano.RepeatedGroup group2 = 1400 new TestAllTypesNano.RepeatedGroup(); 1401 group2.a = 2; 1402 1403 msg.repeatedGroup = new TestAllTypesNano.RepeatedGroup[] { group0, group1, group2 }; 1404 assertEquals(3, msg.repeatedGroup.length); 1405 assertEquals(0, msg.repeatedGroup[0].a); 1406 assertEquals(1, msg.repeatedGroup[1].a); 1407 assertEquals(2, msg.repeatedGroup[2].a); 1408 msg.clear(); 1409 assertEquals(0, msg.repeatedGroup.length); 1410 msg.clear() 1411 .repeatedGroup = new TestAllTypesNano.RepeatedGroup[] { group1 }; 1412 assertEquals(1, msg.repeatedGroup.length); 1413 assertEquals(1, msg.repeatedGroup[0].a); 1414 msg.clear(); 1415 assertEquals(0, msg.repeatedGroup.length); 1416 1417 // Test 1 entry 1418 msg.clear() 1419 .repeatedGroup = new TestAllTypesNano.RepeatedGroup[] { group0 }; 1420 assertEquals(1, msg.repeatedGroup.length); 1421 byte [] result = MessageNano.toByteArray(msg); 1422 int msgSerializedSize = msg.getSerializedSize(); 1423 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1424 assertTrue(msgSerializedSize == 7); 1425 assertEquals(result.length, msgSerializedSize); 1426 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1427 assertEquals(1, newMsg.repeatedGroup.length); 1428 assertEquals(0, newMsg.repeatedGroup[0].a); 1429 1430 // Test 2 entries 1431 msg.clear() 1432 .repeatedGroup = new TestAllTypesNano.RepeatedGroup[] { group0, group1 }; 1433 assertEquals(2, msg.repeatedGroup.length); 1434 result = MessageNano.toByteArray(msg); 1435 msgSerializedSize = msg.getSerializedSize(); 1436 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1437 assertTrue(msgSerializedSize == 14); 1438 assertEquals(result.length, msgSerializedSize); 1439 1440 newMsg = TestAllTypesNano.parseFrom(result); 1441 assertEquals(2, newMsg.repeatedGroup.length); 1442 assertEquals(0, newMsg.repeatedGroup[0].a); 1443 assertEquals(1, newMsg.repeatedGroup[1].a); 1444 } 1445 1446 public void testNanoRepeatedNestedMessage() throws Exception { 1447 TestAllTypesNano msg = new TestAllTypesNano(); 1448 TestAllTypesNano.NestedMessage nestedMsg0 = 1449 new TestAllTypesNano.NestedMessage(); 1450 nestedMsg0.bb = 0; 1451 TestAllTypesNano.NestedMessage nestedMsg1 = 1452 new TestAllTypesNano.NestedMessage(); 1453 nestedMsg1.bb = 1; 1454 TestAllTypesNano.NestedMessage nestedMsg2 = 1455 new TestAllTypesNano.NestedMessage(); 1456 nestedMsg2.bb = 2; 1457 1458 msg.repeatedNestedMessage = 1459 new TestAllTypesNano.NestedMessage[] { nestedMsg0, nestedMsg1, nestedMsg2 }; 1460 assertEquals(3, msg.repeatedNestedMessage.length); 1461 assertEquals(0, msg.repeatedNestedMessage[0].bb); 1462 assertEquals(1, msg.repeatedNestedMessage[1].bb); 1463 assertEquals(2, msg.repeatedNestedMessage[2].bb); 1464 msg.clear(); 1465 assertEquals(0, msg.repeatedNestedMessage.length); 1466 msg.clear() 1467 .repeatedNestedMessage = new TestAllTypesNano.NestedMessage[] { nestedMsg1 }; 1468 assertEquals(1, msg.repeatedNestedMessage.length); 1469 assertEquals(1, msg.repeatedNestedMessage[0].bb); 1470 msg.clear(); 1471 assertEquals(0, msg.repeatedNestedMessage.length); 1472 1473 // Test 1 entry 1474 msg.clear() 1475 .repeatedNestedMessage = new TestAllTypesNano.NestedMessage[] { nestedMsg0 }; 1476 assertEquals(1, msg.repeatedNestedMessage.length); 1477 byte [] result = MessageNano.toByteArray(msg); 1478 int msgSerializedSize = msg.getSerializedSize(); 1479 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1480 assertTrue(msgSerializedSize == 6); 1481 assertEquals(result.length, msgSerializedSize); 1482 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1483 assertEquals(1, newMsg.repeatedNestedMessage.length); 1484 assertEquals(0, newMsg.repeatedNestedMessage[0].bb); 1485 1486 // Test 2 entries 1487 msg.clear() 1488 .repeatedNestedMessage = new TestAllTypesNano.NestedMessage[] { nestedMsg0, nestedMsg1 }; 1489 assertEquals(2, msg.repeatedNestedMessage.length); 1490 result = MessageNano.toByteArray(msg); 1491 msgSerializedSize = msg.getSerializedSize(); 1492 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1493 assertTrue(msgSerializedSize == 11); 1494 assertEquals(result.length, msgSerializedSize); 1495 1496 newMsg = TestAllTypesNano.parseFrom(result); 1497 assertEquals(2, newMsg.repeatedNestedMessage.length); 1498 assertEquals(0, newMsg.repeatedNestedMessage[0].bb); 1499 assertEquals(1, newMsg.repeatedNestedMessage[1].bb); 1500 } 1501 1502 public void testNanoRepeatedForeignMessage() throws Exception { 1503 TestAllTypesNano msg = new TestAllTypesNano(); 1504 NanoOuterClass.ForeignMessageNano foreignMsg0 = 1505 new NanoOuterClass.ForeignMessageNano(); 1506 foreignMsg0.c = 0; 1507 NanoOuterClass.ForeignMessageNano foreignMsg1 = 1508 new NanoOuterClass.ForeignMessageNano(); 1509 foreignMsg1.c = 1; 1510 NanoOuterClass.ForeignMessageNano foreignMsg2 = 1511 new NanoOuterClass.ForeignMessageNano(); 1512 foreignMsg2.c = 2; 1513 1514 msg.repeatedForeignMessage = 1515 new NanoOuterClass.ForeignMessageNano[] { foreignMsg0, foreignMsg1, foreignMsg2 }; 1516 assertEquals(3, msg.repeatedForeignMessage.length); 1517 assertEquals(0, msg.repeatedForeignMessage[0].c); 1518 assertEquals(1, msg.repeatedForeignMessage[1].c); 1519 assertEquals(2, msg.repeatedForeignMessage[2].c); 1520 msg.clear(); 1521 assertEquals(0, msg.repeatedForeignMessage.length); 1522 msg.clear() 1523 .repeatedForeignMessage = new NanoOuterClass.ForeignMessageNano[] { foreignMsg1 }; 1524 assertEquals(1, msg.repeatedForeignMessage.length); 1525 assertEquals(1, msg.repeatedForeignMessage[0].c); 1526 msg.clear(); 1527 assertEquals(0, msg.repeatedForeignMessage.length); 1528 1529 // Test 1 entry 1530 msg.clear() 1531 .repeatedForeignMessage = new NanoOuterClass.ForeignMessageNano[] { foreignMsg0 }; 1532 assertEquals(1, msg.repeatedForeignMessage.length); 1533 byte [] result = MessageNano.toByteArray(msg); 1534 int msgSerializedSize = msg.getSerializedSize(); 1535 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1536 assertTrue(msgSerializedSize == 6); 1537 assertEquals(result.length, msgSerializedSize); 1538 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1539 assertEquals(1, newMsg.repeatedForeignMessage.length); 1540 assertEquals(0, newMsg.repeatedForeignMessage[0].c); 1541 1542 // Test 2 entries 1543 msg.clear() 1544 .repeatedForeignMessage = new NanoOuterClass.ForeignMessageNano[] { foreignMsg0, foreignMsg1 }; 1545 assertEquals(2, msg.repeatedForeignMessage.length); 1546 result = MessageNano.toByteArray(msg); 1547 msgSerializedSize = msg.getSerializedSize(); 1548 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1549 assertTrue(msgSerializedSize == 11); 1550 assertEquals(result.length, msgSerializedSize); 1551 1552 newMsg = TestAllTypesNano.parseFrom(result); 1553 assertEquals(2, newMsg.repeatedForeignMessage.length); 1554 assertEquals(0, newMsg.repeatedForeignMessage[0].c); 1555 assertEquals(1, newMsg.repeatedForeignMessage[1].c); 1556 } 1557 1558 public void testNanoRepeatedImportMessage() throws Exception { 1559 TestAllTypesNano msg = new TestAllTypesNano(); 1560 UnittestImportNano.ImportMessageNano foreignMsg0 = 1561 new UnittestImportNano.ImportMessageNano(); 1562 foreignMsg0.d = 0; 1563 UnittestImportNano.ImportMessageNano foreignMsg1 = 1564 new UnittestImportNano.ImportMessageNano(); 1565 foreignMsg1.d = 1; 1566 UnittestImportNano.ImportMessageNano foreignMsg2 = 1567 new UnittestImportNano.ImportMessageNano(); 1568 foreignMsg2.d = 2; 1569 1570 msg.repeatedImportMessage = 1571 new UnittestImportNano.ImportMessageNano[] { foreignMsg0, foreignMsg1, foreignMsg2 }; 1572 assertEquals(3, msg.repeatedImportMessage.length); 1573 assertEquals(0, msg.repeatedImportMessage[0].d); 1574 assertEquals(1, msg.repeatedImportMessage[1].d); 1575 assertEquals(2, msg.repeatedImportMessage[2].d); 1576 msg.clear(); 1577 assertEquals(0, msg.repeatedImportMessage.length); 1578 msg.clear() 1579 .repeatedImportMessage = new UnittestImportNano.ImportMessageNano[] { foreignMsg1 }; 1580 assertEquals(1, msg.repeatedImportMessage.length); 1581 assertEquals(1, msg.repeatedImportMessage[0].d); 1582 msg.clear(); 1583 assertEquals(0, msg.repeatedImportMessage.length); 1584 1585 // Test 1 entry 1586 msg.clear() 1587 .repeatedImportMessage = new UnittestImportNano.ImportMessageNano[] { foreignMsg0 }; 1588 assertEquals(1, msg.repeatedImportMessage.length); 1589 byte [] result = MessageNano.toByteArray(msg); 1590 int msgSerializedSize = msg.getSerializedSize(); 1591 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1592 assertTrue(msgSerializedSize == 6); 1593 assertEquals(result.length, msgSerializedSize); 1594 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1595 assertEquals(1, newMsg.repeatedImportMessage.length); 1596 assertEquals(0, newMsg.repeatedImportMessage[0].d); 1597 1598 // Test 2 entries 1599 msg.clear() 1600 .repeatedImportMessage = new UnittestImportNano.ImportMessageNano[] { foreignMsg0, foreignMsg1 }; 1601 assertEquals(2, msg.repeatedImportMessage.length); 1602 result = MessageNano.toByteArray(msg); 1603 msgSerializedSize = msg.getSerializedSize(); 1604 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1605 assertTrue(msgSerializedSize == 11); 1606 assertEquals(result.length, msgSerializedSize); 1607 1608 newMsg = TestAllTypesNano.parseFrom(result); 1609 assertEquals(2, newMsg.repeatedImportMessage.length); 1610 assertEquals(0, newMsg.repeatedImportMessage[0].d); 1611 assertEquals(1, newMsg.repeatedImportMessage[1].d); 1612 } 1613 1614 public void testNanoRepeatedNestedEnum() throws Exception { 1615 TestAllTypesNano msg = new TestAllTypesNano(); 1616 msg.repeatedNestedEnum = new int[] { 1617 TestAllTypesNano.FOO, 1618 TestAllTypesNano.BAR, 1619 TestAllTypesNano.BAZ 1620 }; 1621 assertEquals(3, msg.repeatedNestedEnum.length); 1622 assertEquals(TestAllTypesNano.FOO, msg.repeatedNestedEnum[0]); 1623 assertEquals(TestAllTypesNano.BAR, msg.repeatedNestedEnum[1]); 1624 assertEquals(TestAllTypesNano.BAZ, msg.repeatedNestedEnum[2]); 1625 msg.clear(); 1626 assertEquals(0, msg.repeatedNestedEnum.length); 1627 msg.clear() 1628 .repeatedNestedEnum = new int[] { TestAllTypesNano.BAR }; 1629 assertEquals(1, msg.repeatedNestedEnum.length); 1630 assertEquals(TestAllTypesNano.BAR, msg.repeatedNestedEnum[0]); 1631 msg.clear(); 1632 assertEquals(0, msg.repeatedNestedEnum.length); 1633 1634 // Test 1 entry 1635 msg.clear() 1636 .repeatedNestedEnum = new int[] { TestAllTypesNano.FOO }; 1637 byte [] result = MessageNano.toByteArray(msg); 1638 int msgSerializedSize = msg.getSerializedSize(); 1639 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1640 assertTrue(msgSerializedSize == 6); 1641 assertEquals(result.length, msgSerializedSize); 1642 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1643 assertEquals(1, newMsg.repeatedNestedEnum.length); 1644 assertEquals(TestAllTypesNano.FOO, msg.repeatedNestedEnum[0]); 1645 1646 // Test 2 entries 1647 msg.clear() 1648 .repeatedNestedEnum = new int[] { TestAllTypesNano.FOO, TestAllTypesNano.BAR }; 1649 assertEquals(2, msg.repeatedNestedEnum.length); 1650 result = MessageNano.toByteArray(msg); 1651 msgSerializedSize = msg.getSerializedSize(); 1652 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1653 assertTrue(msgSerializedSize == 9); 1654 assertEquals(result.length, msgSerializedSize); 1655 1656 newMsg = TestAllTypesNano.parseFrom(result); 1657 assertEquals(2, newMsg.repeatedNestedEnum.length); 1658 assertEquals(TestAllTypesNano.FOO, msg.repeatedNestedEnum[0]); 1659 assertEquals(TestAllTypesNano.BAR, msg.repeatedNestedEnum[1]); 1660 } 1661 1662 public void testNanoRepeatedForeignEnum() throws Exception { 1663 TestAllTypesNano msg = new TestAllTypesNano(); 1664 msg.repeatedForeignEnum = new int[] { 1665 NanoOuterClass.FOREIGN_NANO_FOO, 1666 NanoOuterClass.FOREIGN_NANO_BAR, 1667 NanoOuterClass.FOREIGN_NANO_BAZ 1668 }; 1669 assertEquals(3, msg.repeatedForeignEnum.length); 1670 assertEquals(NanoOuterClass.FOREIGN_NANO_FOO, msg.repeatedForeignEnum[0]); 1671 assertEquals(NanoOuterClass.FOREIGN_NANO_BAR, msg.repeatedForeignEnum[1]); 1672 assertEquals(NanoOuterClass.FOREIGN_NANO_BAZ, msg.repeatedForeignEnum[2]); 1673 msg.clear(); 1674 assertEquals(0, msg.repeatedForeignEnum.length); 1675 msg.clear() 1676 .repeatedForeignEnum = new int[] { NanoOuterClass.FOREIGN_NANO_BAR }; 1677 assertEquals(1, msg.repeatedForeignEnum.length); 1678 assertEquals(NanoOuterClass.FOREIGN_NANO_BAR, msg.repeatedForeignEnum[0]); 1679 msg.clear(); 1680 assertEquals(0, msg.repeatedForeignEnum.length); 1681 1682 // Test 1 entry 1683 msg.clear() 1684 .repeatedForeignEnum = new int[] { NanoOuterClass.FOREIGN_NANO_FOO }; 1685 byte [] result = MessageNano.toByteArray(msg); 1686 int msgSerializedSize = msg.getSerializedSize(); 1687 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1688 assertTrue(msgSerializedSize == 6); 1689 assertEquals(result.length, msgSerializedSize); 1690 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1691 assertEquals(1, newMsg.repeatedForeignEnum.length); 1692 assertEquals(NanoOuterClass.FOREIGN_NANO_FOO, msg.repeatedForeignEnum[0]); 1693 1694 // Test 2 entries 1695 msg.clear() 1696 .repeatedForeignEnum = new int[] { 1697 NanoOuterClass.FOREIGN_NANO_FOO, 1698 NanoOuterClass.FOREIGN_NANO_BAR 1699 }; 1700 assertEquals(2, msg.repeatedForeignEnum.length); 1701 result = MessageNano.toByteArray(msg); 1702 msgSerializedSize = msg.getSerializedSize(); 1703 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1704 assertTrue(msgSerializedSize == 9); 1705 assertEquals(result.length, msgSerializedSize); 1706 1707 newMsg = TestAllTypesNano.parseFrom(result); 1708 assertEquals(2, newMsg.repeatedForeignEnum.length); 1709 assertEquals(NanoOuterClass.FOREIGN_NANO_FOO, msg.repeatedForeignEnum[0]); 1710 assertEquals(NanoOuterClass.FOREIGN_NANO_BAR, msg.repeatedForeignEnum[1]); 1711 } 1712 1713 public void testNanoRepeatedImportEnum() throws Exception { 1714 TestAllTypesNano msg = new TestAllTypesNano(); 1715 msg.repeatedImportEnum = new int[] { 1716 UnittestImportNano.IMPORT_NANO_FOO, 1717 UnittestImportNano.IMPORT_NANO_BAR, 1718 UnittestImportNano.IMPORT_NANO_BAZ 1719 }; 1720 assertEquals(3, msg.repeatedImportEnum.length); 1721 assertEquals(UnittestImportNano.IMPORT_NANO_FOO, msg.repeatedImportEnum[0]); 1722 assertEquals(UnittestImportNano.IMPORT_NANO_BAR, msg.repeatedImportEnum[1]); 1723 assertEquals(UnittestImportNano.IMPORT_NANO_BAZ, msg.repeatedImportEnum[2]); 1724 msg.clear(); 1725 assertEquals(0, msg.repeatedImportEnum.length); 1726 msg.clear() 1727 .repeatedImportEnum = new int[] { UnittestImportNano.IMPORT_NANO_BAR }; 1728 assertEquals(1, msg.repeatedImportEnum.length); 1729 assertEquals(UnittestImportNano.IMPORT_NANO_BAR, msg.repeatedImportEnum[0]); 1730 msg.clear(); 1731 assertEquals(0, msg.repeatedImportEnum.length); 1732 1733 // Test 1 entry 1734 msg.clear() 1735 .repeatedImportEnum = new int[] { UnittestImportNano.IMPORT_NANO_FOO }; 1736 byte [] result = MessageNano.toByteArray(msg); 1737 int msgSerializedSize = msg.getSerializedSize(); 1738 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1739 assertTrue(msgSerializedSize == 6); 1740 assertEquals(result.length, msgSerializedSize); 1741 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1742 assertEquals(1, newMsg.repeatedImportEnum.length); 1743 assertEquals(UnittestImportNano.IMPORT_NANO_FOO, msg.repeatedImportEnum[0]); 1744 1745 // Test 2 entries 1746 msg.clear() 1747 .repeatedImportEnum = new int[] { 1748 UnittestImportNano.IMPORT_NANO_FOO, 1749 UnittestImportNano.IMPORT_NANO_BAR 1750 }; 1751 assertEquals(2, msg.repeatedImportEnum.length); 1752 result = MessageNano.toByteArray(msg); 1753 msgSerializedSize = msg.getSerializedSize(); 1754 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1755 assertTrue(msgSerializedSize == 9); 1756 assertEquals(result.length, msgSerializedSize); 1757 1758 newMsg = TestAllTypesNano.parseFrom(result); 1759 assertEquals(2, newMsg.repeatedImportEnum.length); 1760 assertEquals(UnittestImportNano.IMPORT_NANO_FOO, msg.repeatedImportEnum[0]); 1761 assertEquals(UnittestImportNano.IMPORT_NANO_BAR, msg.repeatedImportEnum[1]); 1762 } 1763 1764 public void testNanoRepeatedStringPiece() throws Exception { 1765 TestAllTypesNano msg = new TestAllTypesNano(); 1766 assertEquals(0, msg.repeatedStringPiece.length); 1767 msg.repeatedStringPiece = new String[] { "hello", "bye", "boo" }; 1768 assertEquals("bye", msg.repeatedStringPiece[1]); 1769 assertEquals("boo", msg.repeatedStringPiece[2]); 1770 msg.clear(); 1771 assertEquals(0, msg.repeatedStringPiece.length); 1772 msg.clear() 1773 .repeatedStringPiece = new String[] { "boo" }; 1774 assertEquals(1, msg.repeatedStringPiece.length); 1775 assertEquals("boo", msg.repeatedStringPiece[0]); 1776 msg.clear(); 1777 assertEquals(0, msg.repeatedStringPiece.length); 1778 1779 // Test 1 entry 1780 msg.clear() 1781 .repeatedStringPiece = new String[] { "" }; 1782 assertEquals(1, msg.repeatedStringPiece.length); 1783 byte [] result = MessageNano.toByteArray(msg); 1784 int msgSerializedSize = msg.getSerializedSize(); 1785 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1786 assertTrue(msgSerializedSize == 6); 1787 assertEquals(result.length, msgSerializedSize); 1788 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1789 assertEquals(1, newMsg.repeatedStringPiece.length); 1790 assertTrue(newMsg.repeatedStringPiece[0].isEmpty()); 1791 1792 // Test 2 entries 1793 msg.clear() 1794 .repeatedStringPiece = new String[] { "hello", "world" }; 1795 assertEquals(2, msg.repeatedStringPiece.length); 1796 result = MessageNano.toByteArray(msg); 1797 msgSerializedSize = msg.getSerializedSize(); 1798 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1799 assertTrue(msgSerializedSize == 19); 1800 assertEquals(result.length, msgSerializedSize); 1801 1802 newMsg = TestAllTypesNano.parseFrom(result); 1803 assertEquals(2, newMsg.repeatedStringPiece.length); 1804 assertEquals("hello", newMsg.repeatedStringPiece[0]); 1805 assertEquals("world", newMsg.repeatedStringPiece[1]); 1806 } 1807 1808 public void testNanoRepeatedCord() throws Exception { 1809 TestAllTypesNano msg = new TestAllTypesNano(); 1810 assertEquals(0, msg.repeatedCord.length); 1811 msg.repeatedCord = new String[] { "hello", "bye", "boo" }; 1812 assertEquals("bye", msg.repeatedCord[1]); 1813 assertEquals("boo", msg.repeatedCord[2]); 1814 msg.clear(); 1815 assertEquals(0, msg.repeatedCord.length); 1816 msg.clear() 1817 .repeatedCord = new String[] { "boo" }; 1818 assertEquals(1, msg.repeatedCord.length); 1819 assertEquals("boo", msg.repeatedCord[0]); 1820 msg.clear(); 1821 assertEquals(0, msg.repeatedCord.length); 1822 1823 // Test 1 entry 1824 msg.clear() 1825 .repeatedCord = new String[] { "" }; 1826 assertEquals(1, msg.repeatedCord.length); 1827 byte [] result = MessageNano.toByteArray(msg); 1828 int msgSerializedSize = msg.getSerializedSize(); 1829 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1830 assertTrue(msgSerializedSize == 6); 1831 assertEquals(result.length, msgSerializedSize); 1832 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1833 assertEquals(1, newMsg.repeatedCord.length); 1834 assertTrue(newMsg.repeatedCord[0].isEmpty()); 1835 1836 // Test 2 entries 1837 msg.clear() 1838 .repeatedCord = new String[] { "hello", "world" }; 1839 assertEquals(2, msg.repeatedCord.length); 1840 result = MessageNano.toByteArray(msg); 1841 msgSerializedSize = msg.getSerializedSize(); 1842 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1843 assertTrue(msgSerializedSize == 19); 1844 assertEquals(result.length, msgSerializedSize); 1845 1846 newMsg = TestAllTypesNano.parseFrom(result); 1847 assertEquals(2, newMsg.repeatedCord.length); 1848 assertEquals("hello", newMsg.repeatedCord[0]); 1849 assertEquals("world", newMsg.repeatedCord[1]); 1850 } 1851 1852 public void testNanoRepeatedPackedInt32() throws Exception { 1853 TestAllTypesNano msg = new TestAllTypesNano(); 1854 assertEquals(0, msg.repeatedPackedInt32.length); 1855 msg.repeatedPackedInt32 = new int[] { 123, 789, 456 }; 1856 assertEquals(789, msg.repeatedPackedInt32[1]); 1857 assertEquals(456, msg.repeatedPackedInt32[2]); 1858 msg.clear(); 1859 assertEquals(0, msg.repeatedPackedInt32.length); 1860 msg.clear() 1861 .repeatedPackedInt32 = new int[] { 456 }; 1862 assertEquals(1, msg.repeatedPackedInt32.length); 1863 assertEquals(456, msg.repeatedPackedInt32[0]); 1864 msg.clear(); 1865 assertEquals(0, msg.repeatedPackedInt32.length); 1866 1867 // Test 1 entry 1868 msg.clear() 1869 .repeatedPackedInt32 = new int[] { 123 }; 1870 assertEquals(1, msg.repeatedPackedInt32.length); 1871 byte [] result = MessageNano.toByteArray(msg); 1872 int msgSerializedSize = msg.getSerializedSize(); 1873 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1874 assertTrue(msgSerializedSize == 7); 1875 assertEquals(result.length, msgSerializedSize); 1876 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1877 assertEquals(1, newMsg.repeatedPackedInt32.length); 1878 assertEquals(123, newMsg.repeatedPackedInt32[0]); 1879 1880 // Test 2 entries 1881 msg.clear() 1882 .repeatedPackedInt32 = new int[] { 123, 456 }; 1883 assertEquals(2, msg.repeatedPackedInt32.length); 1884 result = MessageNano.toByteArray(msg); 1885 msgSerializedSize = msg.getSerializedSize(); 1886 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1887 assertTrue(msgSerializedSize == 9); 1888 assertEquals(result.length, msgSerializedSize); 1889 1890 newMsg = TestAllTypesNano.parseFrom(result); 1891 assertEquals(2, newMsg.repeatedPackedInt32.length); 1892 assertEquals(123, newMsg.repeatedPackedInt32[0]); 1893 assertEquals(456, newMsg.repeatedPackedInt32[1]); 1894 } 1895 1896 public void testNanoRepeatedPackedSfixed64() throws Exception { 1897 TestAllTypesNano msg = new TestAllTypesNano(); 1898 assertEquals(0, msg.repeatedPackedSfixed64.length); 1899 msg.repeatedPackedSfixed64 = new long[] { 123, 789, 456 }; 1900 assertEquals(789, msg.repeatedPackedSfixed64[1]); 1901 assertEquals(456, msg.repeatedPackedSfixed64[2]); 1902 msg.clear(); 1903 assertEquals(0, msg.repeatedPackedSfixed64.length); 1904 msg.clear() 1905 .repeatedPackedSfixed64 = new long[] { 456 }; 1906 assertEquals(1, msg.repeatedPackedSfixed64.length); 1907 assertEquals(456, msg.repeatedPackedSfixed64[0]); 1908 msg.clear(); 1909 assertEquals(0, msg.repeatedPackedSfixed64.length); 1910 1911 // Test 1 entry 1912 msg.clear() 1913 .repeatedPackedSfixed64 = new long[] { 123 }; 1914 assertEquals(1, msg.repeatedPackedSfixed64.length); 1915 byte [] result = MessageNano.toByteArray(msg); 1916 int msgSerializedSize = msg.getSerializedSize(); 1917 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1918 assertTrue(msgSerializedSize == 14); 1919 assertEquals(result.length, msgSerializedSize); 1920 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1921 assertEquals(1, newMsg.repeatedPackedSfixed64.length); 1922 assertEquals(123, newMsg.repeatedPackedSfixed64[0]); 1923 1924 // Test 2 entries 1925 msg.clear() 1926 .repeatedPackedSfixed64 = new long[] { 123, 456 }; 1927 assertEquals(2, msg.repeatedPackedSfixed64.length); 1928 result = MessageNano.toByteArray(msg); 1929 msgSerializedSize = msg.getSerializedSize(); 1930 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1931 assertTrue(msgSerializedSize == 22); 1932 assertEquals(result.length, msgSerializedSize); 1933 1934 newMsg = TestAllTypesNano.parseFrom(result); 1935 assertEquals(2, newMsg.repeatedPackedSfixed64.length); 1936 assertEquals(123, newMsg.repeatedPackedSfixed64[0]); 1937 assertEquals(456, newMsg.repeatedPackedSfixed64[1]); 1938 } 1939 1940 public void testNanoRepeatedPackedNestedEnum() throws Exception { 1941 TestAllTypesNano msg = new TestAllTypesNano(); 1942 msg.repeatedPackedNestedEnum = new int[] { 1943 TestAllTypesNano.FOO, 1944 TestAllTypesNano.BAR, 1945 TestAllTypesNano.BAZ 1946 }; 1947 assertEquals(3, msg.repeatedPackedNestedEnum.length); 1948 assertEquals(TestAllTypesNano.FOO, msg.repeatedPackedNestedEnum[0]); 1949 assertEquals(TestAllTypesNano.BAR, msg.repeatedPackedNestedEnum[1]); 1950 assertEquals(TestAllTypesNano.BAZ, msg.repeatedPackedNestedEnum[2]); 1951 msg.clear(); 1952 assertEquals(0, msg.repeatedPackedNestedEnum.length); 1953 msg.clear() 1954 .repeatedPackedNestedEnum = new int[] { TestAllTypesNano.BAR }; 1955 assertEquals(1, msg.repeatedPackedNestedEnum.length); 1956 assertEquals(TestAllTypesNano.BAR, msg.repeatedPackedNestedEnum[0]); 1957 msg.clear(); 1958 assertEquals(0, msg.repeatedPackedNestedEnum.length); 1959 1960 // Test 1 entry 1961 msg.clear() 1962 .repeatedPackedNestedEnum = new int[] { TestAllTypesNano.FOO }; 1963 byte [] result = MessageNano.toByteArray(msg); 1964 int msgSerializedSize = msg.getSerializedSize(); 1965 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1966 assertTrue(msgSerializedSize == 7); 1967 assertEquals(result.length, msgSerializedSize); 1968 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 1969 assertEquals(1, newMsg.repeatedPackedNestedEnum.length); 1970 assertEquals(TestAllTypesNano.FOO, msg.repeatedPackedNestedEnum[0]); 1971 1972 // Test 2 entries 1973 msg.clear() 1974 .repeatedPackedNestedEnum = new int[] { TestAllTypesNano.FOO, TestAllTypesNano.BAR }; 1975 assertEquals(2, msg.repeatedPackedNestedEnum.length); 1976 result = MessageNano.toByteArray(msg); 1977 msgSerializedSize = msg.getSerializedSize(); 1978 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1979 assertTrue(msgSerializedSize == 8); 1980 assertEquals(result.length, msgSerializedSize); 1981 1982 newMsg = TestAllTypesNano.parseFrom(result); 1983 assertEquals(2, newMsg.repeatedPackedNestedEnum.length); 1984 assertEquals(TestAllTypesNano.FOO, msg.repeatedPackedNestedEnum[0]); 1985 assertEquals(TestAllTypesNano.BAR, msg.repeatedPackedNestedEnum[1]); 1986 } 1987 1988 public void testNanoRepeatedPackedSerializedSize() throws Exception { 1989 TestAllTypesNano msg = new TestAllTypesNano(); 1990 msg.repeatedPackedInt32 = new int[] { 123, 789, 456 }; 1991 int msgSerializedSize = msg.getSerializedSize(); 1992 byte [] result = MessageNano.toByteArray(msg); 1993 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 1994 assertTrue(msgSerializedSize == 11); 1995 assertEquals(result.length, msgSerializedSize); 1996 TestAllTypesNano msg2 = new TestAllTypesNano(); 1997 msg2.repeatedPackedInt32 = new int[] { 123, 789, 456 }; 1998 byte [] result2 = new byte[msgSerializedSize]; 1999 MessageNano.toByteArray(msg2, result2, 0, msgSerializedSize); 2000 2001 // Check equal size and content. 2002 assertEquals(msgSerializedSize, msg2.getSerializedSize()); 2003 assertTrue(Arrays.equals(result, result2)); 2004 } 2005 2006 public void testNanoRepeatedInt32ReMerge() throws Exception { 2007 TestAllTypesNano msg = new TestAllTypesNano(); 2008 msg.repeatedInt32 = new int[] { 234 }; 2009 byte [] result1 = MessageNano.toByteArray(msg); 2010 2011 msg.clear().optionalInt32 = 789; 2012 byte [] result2 = MessageNano.toByteArray(msg); 2013 2014 msg.clear().repeatedInt32 = new int[] { 123, 456 }; 2015 byte [] result3 = MessageNano.toByteArray(msg); 2016 2017 // Concatenate the three serializations and read as one message. 2018 byte [] result = new byte[result1.length + result2.length + result3.length]; 2019 System.arraycopy(result1, 0, result, 0, result1.length); 2020 System.arraycopy(result2, 0, result, result1.length, result2.length); 2021 System.arraycopy(result3, 0, result, result1.length + result2.length, result3.length); 2022 2023 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 2024 assertEquals(789, newMsg.optionalInt32); 2025 assertEquals(3, newMsg.repeatedInt32.length); 2026 assertEquals(234, newMsg.repeatedInt32[0]); 2027 assertEquals(123, newMsg.repeatedInt32[1]); 2028 assertEquals(456, newMsg.repeatedInt32[2]); 2029 } 2030 2031 public void testNanoRepeatedNestedEnumReMerge() throws Exception { 2032 TestAllTypesNano msg = new TestAllTypesNano(); 2033 msg.repeatedNestedEnum = new int[] { TestAllTypesNano.FOO }; 2034 byte [] result1 = MessageNano.toByteArray(msg); 2035 2036 msg.clear().optionalInt32 = 789; 2037 byte [] result2 = MessageNano.toByteArray(msg); 2038 2039 msg.clear().repeatedNestedEnum = new int[] { TestAllTypesNano.BAR, TestAllTypesNano.FOO }; 2040 byte [] result3 = MessageNano.toByteArray(msg); 2041 2042 // Concatenate the three serializations and read as one message. 2043 byte [] result = new byte[result1.length + result2.length + result3.length]; 2044 System.arraycopy(result1, 0, result, 0, result1.length); 2045 System.arraycopy(result2, 0, result, result1.length, result2.length); 2046 System.arraycopy(result3, 0, result, result1.length + result2.length, result3.length); 2047 2048 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 2049 assertEquals(789, newMsg.optionalInt32); 2050 assertEquals(3, newMsg.repeatedNestedEnum.length); 2051 assertEquals(TestAllTypesNano.FOO, newMsg.repeatedNestedEnum[0]); 2052 assertEquals(TestAllTypesNano.BAR, newMsg.repeatedNestedEnum[1]); 2053 assertEquals(TestAllTypesNano.FOO, newMsg.repeatedNestedEnum[2]); 2054 } 2055 2056 public void testNanoRepeatedNestedMessageReMerge() throws Exception { 2057 TestAllTypesNano msg = new TestAllTypesNano(); 2058 TestAllTypesNano.NestedMessage nestedMsg0 = 2059 new TestAllTypesNano.NestedMessage(); 2060 nestedMsg0.bb = 0; 2061 TestAllTypesNano.NestedMessage nestedMsg1 = 2062 new TestAllTypesNano.NestedMessage(); 2063 nestedMsg1.bb = 1; 2064 TestAllTypesNano.NestedMessage nestedMsg2 = 2065 new TestAllTypesNano.NestedMessage(); 2066 nestedMsg2.bb = 2; 2067 2068 msg.repeatedNestedMessage = new TestAllTypesNano.NestedMessage[] { nestedMsg0 }; 2069 byte [] result1 = MessageNano.toByteArray(msg); 2070 2071 msg.clear().optionalInt32 = 789; 2072 byte [] result2 = MessageNano.toByteArray(msg); 2073 2074 msg.clear().repeatedNestedMessage = 2075 new TestAllTypesNano.NestedMessage[] { nestedMsg1, nestedMsg2 }; 2076 byte [] result3 = MessageNano.toByteArray(msg); 2077 2078 // Concatenate the three serializations and read as one message. 2079 byte [] result = new byte[result1.length + result2.length + result3.length]; 2080 System.arraycopy(result1, 0, result, 0, result1.length); 2081 System.arraycopy(result2, 0, result, result1.length, result2.length); 2082 System.arraycopy(result3, 0, result, result1.length + result2.length, result3.length); 2083 2084 TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result); 2085 assertEquals(789, newMsg.optionalInt32); 2086 assertEquals(3, newMsg.repeatedNestedMessage.length); 2087 assertEquals(nestedMsg0.bb, newMsg.repeatedNestedMessage[0].bb); 2088 assertEquals(nestedMsg1.bb, newMsg.repeatedNestedMessage[1].bb); 2089 assertEquals(nestedMsg2.bb, newMsg.repeatedNestedMessage[2].bb); 2090 } 2091 2092 /** 2093 * Tests that code generation correctly wraps a single message into its outer 2094 * class. The class {@code SingleMessageNano} is imported from the outer 2095 * class {@code UnittestSingleNano}, whose name is implicit. Any error would 2096 * cause this method to fail compilation. 2097 */ 2098 public void testNanoSingle() throws Exception { 2099 SingleMessageNano msg = new SingleMessageNano(); 2100 } 2101 2102 /** 2103 * Tests that code generation correctly skips generating the outer class if 2104 * unnecessary, letting a file-scope entity have the same name. The class 2105 * {@code MultipleNameClashNano} shares the same name with the file's outer 2106 * class defined explicitly, but the file contains no other entities and has 2107 * java_multiple_files set. Any error would cause this method to fail 2108 * compilation. 2109 */ 2110 public void testNanoMultipleNameClash() throws Exception { 2111 MultipleNameClashNano msg = new MultipleNameClashNano(); 2112 msg.field = 0; 2113 } 2114 2115 /** 2116 * Tests that code generation correctly handles enums in different scopes in 2117 * a source file with the option java_multiple_files set to true. Any error 2118 * would cause this method to fail compilation. 2119 */ 2120 public void testNanoMultipleEnumScoping() throws Exception { 2121 FileScopeEnumRefNano msg1 = new FileScopeEnumRefNano(); 2122 msg1.enumField = UnittestMultipleNano.ONE; 2123 MessageScopeEnumRefNano msg2 = new MessageScopeEnumRefNano(); 2124 msg2.enumField = MessageScopeEnumRefNano.TWO; 2125 } 2126 2127 /** 2128 * Tests that code generation with mixed values of the java_multiple_files 2129 * options between the main source file and the imported source files would 2130 * generate correct references. Any error would cause this method to fail 2131 * compilation. 2132 */ 2133 public void testNanoMultipleImportingNonMultiple() throws Exception { 2134 UnittestImportNano.ImportMessageNano importMsg = new UnittestImportNano.ImportMessageNano(); 2135 MultipleImportingNonMultipleNano1 nano1 = new MultipleImportingNonMultipleNano1(); 2136 nano1.field = importMsg; 2137 MultipleImportingNonMultipleNano2 nano2 = new MultipleImportingNonMultipleNano2(); 2138 nano2.nano1 = nano1; 2139 } 2140 2141 public void testNanoDefaults() throws Exception { 2142 TestAllTypesNano msg = new TestAllTypesNano(); 2143 for (int i = 0; i < 2; i++) { 2144 assertEquals(41, msg.defaultInt32); 2145 assertEquals(42, msg.defaultInt64); 2146 assertEquals(43, msg.defaultUint32); 2147 assertEquals(44, msg.defaultUint64); 2148 assertEquals(-45, msg.defaultSint32); 2149 assertEquals(46, msg.defaultSint64); 2150 assertEquals(47, msg.defaultFixed32); 2151 assertEquals(48, msg.defaultFixed64); 2152 assertEquals(49, msg.defaultSfixed32); 2153 assertEquals(-50, msg.defaultSfixed64); 2154 assertTrue(51.5f == msg.defaultFloat); 2155 assertTrue(52.0e3 == msg.defaultDouble); 2156 assertEquals(true, msg.defaultBool); 2157 assertEquals("hello", msg.defaultString); 2158 assertEquals("world", new String(msg.defaultBytes, "UTF-8")); 2159 assertEquals("dünya", msg.defaultStringNonascii); 2160 assertEquals("dünyab", new String(msg.defaultBytesNonascii, "UTF-8")); 2161 assertEquals(TestAllTypesNano.BAR, msg.defaultNestedEnum); 2162 assertEquals(NanoOuterClass.FOREIGN_NANO_BAR, msg.defaultForeignEnum); 2163 assertEquals(UnittestImportNano.IMPORT_NANO_BAR, msg.defaultImportEnum); 2164 assertEquals(Float.POSITIVE_INFINITY, msg.defaultFloatInf); 2165 assertEquals(Float.NEGATIVE_INFINITY, msg.defaultFloatNegInf); 2166 assertEquals(Float.NaN, msg.defaultFloatNan); 2167 assertEquals(Double.POSITIVE_INFINITY, msg.defaultDoubleInf); 2168 assertEquals(Double.NEGATIVE_INFINITY, msg.defaultDoubleNegInf); 2169 assertEquals(Double.NaN, msg.defaultDoubleNan); 2170 2171 // Default values are not output, except for required fields. 2172 byte [] result = MessageNano.toByteArray(msg); 2173 int msgSerializedSize = msg.getSerializedSize(); 2174 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 2175 assertTrue(msgSerializedSize == 3); 2176 assertEquals(result.length, msgSerializedSize); 2177 msg.clear(); 2178 } 2179 } 2180 2181 public void testNanoWithHasParseFrom() throws Exception { 2182 TestAllTypesNanoHas msg = null; 2183 // Test false on creation, after clear and upon empty parse. 2184 for (int i = 0; i < 3; i++) { 2185 if (i == 0) { 2186 msg = new TestAllTypesNanoHas(); 2187 } else if (i == 1) { 2188 msg.clear(); 2189 } else if (i == 2) { 2190 msg = TestAllTypesNanoHas.parseFrom(new byte[0]); 2191 } 2192 assertFalse(msg.hasOptionalInt32); 2193 assertFalse(msg.hasOptionalString); 2194 assertFalse(msg.hasOptionalBytes); 2195 assertFalse(msg.hasOptionalNestedEnum); 2196 assertFalse(msg.hasDefaultInt32); 2197 assertFalse(msg.hasDefaultString); 2198 assertFalse(msg.hasDefaultBytes); 2199 assertFalse(msg.hasDefaultFloatNan); 2200 assertFalse(msg.hasDefaultNestedEnum); 2201 assertFalse(msg.hasId); 2202 msg.optionalInt32 = 123; 2203 msg.optionalNestedMessage = new TestAllTypesNanoHas.NestedMessage(); 2204 msg.optionalNestedMessage.bb = 2; 2205 msg.optionalNestedEnum = TestAllTypesNano.BAZ; 2206 } 2207 2208 byte [] result = MessageNano.toByteArray(msg); 2209 int msgSerializedSize = msg.getSerializedSize(); 2210 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 2211 assertTrue(msgSerializedSize == 13); 2212 assertEquals(result.length, msgSerializedSize); 2213 2214 // Has fields true upon parse. 2215 TestAllTypesNanoHas newMsg = TestAllTypesNanoHas.parseFrom(result); 2216 assertEquals(123, newMsg.optionalInt32); 2217 assertTrue(newMsg.hasOptionalInt32); 2218 assertEquals(2, newMsg.optionalNestedMessage.bb); 2219 assertTrue(newMsg.optionalNestedMessage.hasBb); 2220 assertEquals(TestAllTypesNanoHas.BAZ, newMsg.optionalNestedEnum); 2221 assertTrue(newMsg.hasOptionalNestedEnum); 2222 } 2223 2224 public void testNanoWithHasSerialize() throws Exception { 2225 TestAllTypesNanoHas msg = new TestAllTypesNanoHas(); 2226 msg.hasOptionalInt32 = true; 2227 msg.hasOptionalString = true; 2228 msg.hasOptionalBytes = true; 2229 msg.optionalNestedMessage = new TestAllTypesNanoHas.NestedMessage(); 2230 msg.optionalNestedMessage.hasBb = true; 2231 msg.hasOptionalNestedEnum = true; 2232 msg.hasDefaultInt32 = true; 2233 msg.hasDefaultString = true; 2234 msg.hasDefaultBytes = true; 2235 msg.hasDefaultFloatNan = true; 2236 msg.hasDefaultNestedEnum = true; 2237 2238 byte [] result = MessageNano.toByteArray(msg); 2239 int msgSerializedSize = msg.getSerializedSize(); 2240 assertEquals(result.length, msgSerializedSize); 2241 2242 // Now deserialize and find that all fields are set and equal to their defaults. 2243 TestAllTypesNanoHas newMsg = TestAllTypesNanoHas.parseFrom(result); 2244 assertTrue(newMsg.hasOptionalInt32); 2245 assertTrue(newMsg.hasOptionalString); 2246 assertTrue(newMsg.hasOptionalBytes); 2247 assertTrue(newMsg.optionalNestedMessage.hasBb); 2248 assertTrue(newMsg.hasOptionalNestedEnum); 2249 assertTrue(newMsg.hasDefaultInt32); 2250 assertTrue(newMsg.hasDefaultString); 2251 assertTrue(newMsg.hasDefaultBytes); 2252 assertTrue(newMsg.hasDefaultFloatNan); 2253 assertTrue(newMsg.hasDefaultNestedEnum); 2254 assertTrue(newMsg.hasId); 2255 assertEquals(0, newMsg.optionalInt32); 2256 assertEquals(0, newMsg.optionalString.length()); 2257 assertEquals(0, newMsg.optionalBytes.length); 2258 assertEquals(0, newMsg.optionalNestedMessage.bb); 2259 assertEquals(TestAllTypesNanoHas.FOO, newMsg.optionalNestedEnum); 2260 assertEquals(41, newMsg.defaultInt32); 2261 assertEquals("hello", newMsg.defaultString); 2262 assertEquals("world", new String(newMsg.defaultBytes, "UTF-8")); 2263 assertEquals(TestAllTypesNanoHas.BAR, newMsg.defaultNestedEnum); 2264 assertEquals(Float.NaN, newMsg.defaultFloatNan); 2265 assertEquals(0, newMsg.id); 2266 } 2267 2268 public void testNanoWithAccessorsBasic() throws Exception { 2269 TestNanoAccessors msg = new TestNanoAccessors(); 2270 2271 // Makes sure required and repeated fields are still public fields 2272 msg.id = 3; 2273 msg.repeatedBytes = new byte[2][3]; 2274 2275 // Test accessors 2276 assertEquals(0, msg.getOptionalInt32()); 2277 assertFalse(msg.hasOptionalInt32()); 2278 msg.setOptionalInt32(135); 2279 assertEquals(135, msg.getOptionalInt32()); 2280 assertTrue(msg.hasOptionalInt32()); 2281 msg.clearOptionalInt32(); 2282 assertFalse(msg.hasOptionalInt32()); 2283 msg.setOptionalInt32(0); // default value 2284 assertTrue(msg.hasOptionalInt32()); 2285 2286 // Test NPE 2287 try { 2288 msg.setOptionalBytes(null); 2289 fail(); 2290 } catch (NullPointerException expected) {} 2291 try { 2292 msg.setOptionalString(null); 2293 fail(); 2294 } catch (NullPointerException expected) {} 2295 try { 2296 msg.setOptionalNestedMessage(null); 2297 fail(); 2298 } catch (NullPointerException expected) {} 2299 2300 // Test has bit on bytes field with defaults and clear() re-clones the default array 2301 assertFalse(msg.hasDefaultBytes()); 2302 byte[] defaultBytes = msg.getDefaultBytes(); 2303 msg.setDefaultBytes(defaultBytes); 2304 assertTrue(msg.hasDefaultBytes()); 2305 msg.clearDefaultBytes(); 2306 assertFalse(msg.hasDefaultBytes()); 2307 defaultBytes[0]++; // modify original array 2308 assertFalse(Arrays.equals(defaultBytes, msg.getDefaultBytes())); 2309 2310 // Test has bits that require additional bit fields 2311 assertFalse(msg.hasBitFieldCheck()); 2312 msg.setBitFieldCheck(0); 2313 assertTrue(msg.hasBitFieldCheck()); 2314 assertFalse(msg.hasBeforeBitFieldCheck()); // checks bit field does not leak 2315 assertFalse(msg.hasAfterBitFieldCheck()); 2316 2317 // Test clear() clears has bits 2318 msg.setOptionalString("hi"); 2319 msg.setDefaultString("there"); 2320 msg.clear(); 2321 assertFalse(msg.hasOptionalString()); 2322 assertFalse(msg.hasDefaultString()); 2323 assertFalse(msg.hasBitFieldCheck()); 2324 } 2325 2326 public void testNanoWithAccessorsParseFrom() throws Exception { 2327 TestNanoAccessors msg = null; 2328 // Test false on creation, after clear and upon empty parse. 2329 for (int i = 0; i < 3; i++) { 2330 if (i == 0) { 2331 msg = new TestNanoAccessors(); 2332 } else if (i == 1) { 2333 msg.clear(); 2334 } else if (i == 2) { 2335 msg = TestNanoAccessors.parseFrom(new byte[0]); 2336 } 2337 assertFalse(msg.hasOptionalInt32()); 2338 assertFalse(msg.hasOptionalString()); 2339 assertFalse(msg.hasOptionalBytes()); 2340 assertFalse(msg.hasOptionalNestedEnum()); 2341 assertFalse(msg.hasDefaultInt32()); 2342 assertFalse(msg.hasDefaultString()); 2343 assertFalse(msg.hasDefaultBytes()); 2344 assertFalse(msg.hasDefaultFloatNan()); 2345 assertFalse(msg.hasDefaultNestedEnum()); 2346 msg.setOptionalNestedMessage(new TestNanoAccessors.NestedMessage()); 2347 msg.getOptionalNestedMessage().setBb(2); 2348 msg.setOptionalNestedEnum(TestNanoAccessors.BAZ); 2349 msg.setDefaultInt32(msg.getDefaultInt32()); 2350 } 2351 2352 byte [] result = MessageNano.toByteArray(msg); 2353 int msgSerializedSize = msg.getSerializedSize(); 2354 //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length); 2355 assertTrue(msgSerializedSize == 14); 2356 assertEquals(result.length, msgSerializedSize); 2357 2358 // Has fields true upon parse. 2359 TestNanoAccessors newMsg = TestNanoAccessors.parseFrom(result); 2360 assertEquals(2, newMsg.getOptionalNestedMessage().getBb()); 2361 assertTrue(newMsg.getOptionalNestedMessage().hasBb()); 2362 assertEquals(TestNanoAccessors.BAZ, newMsg.getOptionalNestedEnum()); 2363 assertTrue(newMsg.hasOptionalNestedEnum()); 2364 2365 // Has field true on fields with explicit default values from wire. 2366 assertTrue(newMsg.hasDefaultInt32()); 2367 assertEquals(41, newMsg.getDefaultInt32()); 2368 } 2369 2370 public void testNanoWithAccessorsSerialize() throws Exception { 2371 TestNanoAccessors msg = new TestNanoAccessors(); 2372 msg.setOptionalInt32(msg.getOptionalInt32()); 2373 msg.setOptionalString(msg.getOptionalString()); 2374 msg.setOptionalBytes(msg.getOptionalBytes()); 2375 TestNanoAccessors.NestedMessage nestedMessage = new TestNanoAccessors.NestedMessage(); 2376 nestedMessage.setBb(nestedMessage.getBb()); 2377 msg.setOptionalNestedMessage(nestedMessage); 2378 msg.setOptionalNestedEnum(msg.getOptionalNestedEnum()); 2379 msg.setDefaultInt32(msg.getDefaultInt32()); 2380 msg.setDefaultString(msg.getDefaultString()); 2381 msg.setDefaultBytes(msg.getDefaultBytes()); 2382 msg.setDefaultFloatNan(msg.getDefaultFloatNan()); 2383 msg.setDefaultNestedEnum(msg.getDefaultNestedEnum()); 2384 2385 byte [] result = MessageNano.toByteArray(msg); 2386 int msgSerializedSize = msg.getSerializedSize(); 2387 assertEquals(result.length, msgSerializedSize); 2388 2389 // Now deserialize and find that all fields are set and equal to their defaults. 2390 TestNanoAccessors newMsg = TestNanoAccessors.parseFrom(result); 2391 assertTrue(newMsg.hasOptionalInt32()); 2392 assertTrue(newMsg.hasOptionalString()); 2393 assertTrue(newMsg.hasOptionalBytes()); 2394 assertTrue(newMsg.hasOptionalNestedMessage()); 2395 assertTrue(newMsg.getOptionalNestedMessage().hasBb()); 2396 assertTrue(newMsg.hasOptionalNestedEnum()); 2397 assertTrue(newMsg.hasDefaultInt32()); 2398 assertTrue(newMsg.hasDefaultString()); 2399 assertTrue(newMsg.hasDefaultBytes()); 2400 assertTrue(newMsg.hasDefaultFloatNan()); 2401 assertTrue(newMsg.hasDefaultNestedEnum()); 2402 assertEquals(0, newMsg.getOptionalInt32()); 2403 assertEquals(0, newMsg.getOptionalString().length()); 2404 assertEquals(0, newMsg.getOptionalBytes().length); 2405 assertEquals(0, newMsg.getOptionalNestedMessage().getBb()); 2406 assertEquals(TestNanoAccessors.FOO, newMsg.getOptionalNestedEnum()); 2407 assertEquals(41, newMsg.getDefaultInt32()); 2408 assertEquals("hello", newMsg.getDefaultString()); 2409 assertEquals("world", new String(newMsg.getDefaultBytes(), "UTF-8")); 2410 assertEquals(TestNanoAccessors.BAR, newMsg.getDefaultNestedEnum()); 2411 assertEquals(Float.NaN, newMsg.getDefaultFloatNan()); 2412 assertEquals(0, newMsg.id); 2413 } 2414 2415 public void testNanoJavaEnumStyle() throws Exception { 2416 EnumClassNanos.EnumClassNano msg = new EnumClassNanos.EnumClassNano(); 2417 assertEquals(EnumClassNanos.FileScopeEnum.ONE, msg.one); 2418 assertEquals(EnumClassNanos.EnumClassNano.MessageScopeEnum.TWO, msg.two); 2419 2420 EnumClassNanoMultiple msg2 = new EnumClassNanoMultiple(); 2421 assertEquals(FileScopeEnumMultiple.THREE, msg2.three); 2422 assertEquals(EnumClassNanoMultiple.MessageScopeEnumMultiple.FOUR, msg2.four); 2423 } 2424 2425 /** 2426 * Tests that fields with a default value of NaN are not serialized when 2427 * set to NaN. This is a special case as NaN != NaN, so normal equality 2428 * checks don't work. 2429 */ 2430 public void testNanoNotANumberDefaults() throws Exception { 2431 TestAllTypesNano msg = new TestAllTypesNano(); 2432 msg.defaultDoubleNan = 0; 2433 msg.defaultFloatNan = 0; 2434 byte[] result = MessageNano.toByteArray(msg); 2435 int msgSerializedSize = msg.getSerializedSize(); 2436 assertTrue(msgSerializedSize > 3); 2437 2438 msg.defaultDoubleNan = Double.NaN; 2439 msg.defaultFloatNan = Float.NaN; 2440 result = MessageNano.toByteArray(msg); 2441 msgSerializedSize = msg.getSerializedSize(); 2442 assertEquals(3, msgSerializedSize); 2443 } 2444 2445 /** 2446 * Test that a bug in skipRawBytes() has been fixed: if the skip skips 2447 * exactly up to a limit, this should not break things. 2448 */ 2449 public void testSkipRawBytesBug() throws Exception { 2450 byte[] rawBytes = new byte[] { 1, 2 }; 2451 CodedInputByteBufferNano input = CodedInputByteBufferNano.newInstance(rawBytes); 2452 2453 int limit = input.pushLimit(1); 2454 input.skipRawBytes(1); 2455 input.popLimit(limit); 2456 assertEquals(2, input.readRawByte()); 2457 } 2458 2459 /** 2460 * Test that a bug in skipRawBytes() has been fixed: if the skip skips 2461 * past the end of a buffer with a limit that has been set past the end of 2462 * that buffer, this should not break things. 2463 */ 2464 public void testSkipRawBytesPastEndOfBufferWithLimit() throws Exception { 2465 byte[] rawBytes = new byte[] { 1, 2, 3, 4, 5 }; 2466 CodedInputByteBufferNano input = CodedInputByteBufferNano.newInstance(rawBytes); 2467 2468 int limit = input.pushLimit(4); 2469 // In order to expose the bug we need to read at least one byte to prime the 2470 // buffer inside the CodedInputStream. 2471 assertEquals(1, input.readRawByte()); 2472 // Skip to the end of the limit. 2473 input.skipRawBytes(3); 2474 assertTrue(input.isAtEnd()); 2475 input.popLimit(limit); 2476 assertEquals(5, input.readRawByte()); 2477 } 2478 2479 // Test a smattering of various proto types for printing 2480 public void testMessageNanoPrinter() { 2481 TestAllTypesNano msg = new TestAllTypesNano(); 2482 msg.optionalInt32 = 14; 2483 msg.optionalFloat = 42.3f; 2484 msg.optionalString = "String \"with' both quotes"; 2485 msg.optionalBytes = new byte[5]; 2486 msg.optionalGroup = new TestAllTypesNano.OptionalGroup(); 2487 msg.optionalGroup.a = 15; 2488 msg.repeatedInt64 = new long[2]; 2489 msg.repeatedInt64[0] = 1L; 2490 msg.repeatedInt64[1] = -1L; 2491 msg.repeatedBytes = new byte[2][]; 2492 msg.repeatedBytes[1] = new byte[5]; 2493 msg.repeatedGroup = new TestAllTypesNano.RepeatedGroup[2]; 2494 msg.repeatedGroup[0] = new TestAllTypesNano.RepeatedGroup(); 2495 msg.repeatedGroup[0].a = -27; 2496 msg.repeatedGroup[1] = new TestAllTypesNano.RepeatedGroup(); 2497 msg.repeatedGroup[1].a = -72; 2498 msg.optionalNestedMessage = new TestAllTypesNano.NestedMessage(); 2499 msg.optionalNestedMessage.bb = 7; 2500 msg.repeatedNestedMessage = new TestAllTypesNano.NestedMessage[2]; 2501 msg.repeatedNestedMessage[0] = new TestAllTypesNano.NestedMessage(); 2502 msg.repeatedNestedMessage[0].bb = 77; 2503 msg.repeatedNestedMessage[1] = new TestAllTypesNano.NestedMessage(); 2504 msg.repeatedNestedMessage[1].bb = 88; 2505 msg.optionalNestedEnum = TestAllTypesNano.BAZ; 2506 msg.repeatedNestedEnum = new int[2]; 2507 msg.repeatedNestedEnum[0] = TestAllTypesNano.BAR; 2508 msg.repeatedNestedEnum[1] = TestAllTypesNano.FOO; 2509 2510 String protoPrint = msg.toString(); 2511 assertTrue(protoPrint.contains("TestAllTypesNano <")); 2512 assertTrue(protoPrint.contains(" optional_int32: 14")); 2513 assertTrue(protoPrint.contains(" optional_float: 42.3")); 2514 assertTrue(protoPrint.contains(" optional_double: 0.0")); 2515 assertTrue(protoPrint.contains(" optional_string: \"String \\u0022with\\u0027 both quotes\"")); 2516 assertTrue(protoPrint.contains(" optional_bytes: [B@")); 2517 assertTrue(protoPrint.contains(" optionalGroup <\n a: 15\n >")); 2518 2519 assertTrue(protoPrint.contains(" repeated_int64: 1")); 2520 assertTrue(protoPrint.contains(" repeated_int64: -1")); 2521 assertTrue(protoPrint.contains(" repeated_bytes: null\n repeated_bytes: [B@")); 2522 assertTrue(protoPrint.contains(" repeatedGroup <\n a: -27\n >\n" 2523 + " repeatedGroup <\n a: -72\n >")); 2524 assertTrue(protoPrint.contains(" optionalNestedMessage <\n bb: 7\n >")); 2525 assertTrue(protoPrint.contains(" repeatedNestedMessage <\n bb: 77\n >\n" 2526 + " repeatedNestedMessage <\n bb: 88\n >")); 2527 assertTrue(protoPrint.contains(" optional_nested_enum: 3")); 2528 assertTrue(protoPrint.contains(" repeated_nested_enum: 2\n repeated_nested_enum: 1")); 2529 assertTrue(protoPrint.contains(" default_int32: 41")); 2530 assertTrue(protoPrint.contains(" default_string: \"hello\"")); 2531 } 2532 2533 public void testExtensions() throws Exception { 2534 Extensions.ExtendableMessage message = new Extensions.ExtendableMessage(); 2535 message.field = 5; 2536 message.setExtension(Extensions.someString, "Hello World!"); 2537 message.setExtension(Extensions.someBool, true); 2538 message.setExtension(Extensions.someInt, 42); 2539 message.setExtension(Extensions.someLong, 124234234234L); 2540 message.setExtension(Extensions.someFloat, 42.0f); 2541 message.setExtension(Extensions.someDouble, 422222.0); 2542 message.setExtension(Extensions.someEnum, Extensions.FIRST_VALUE); 2543 AnotherMessage another = new AnotherMessage(); 2544 another.string = "Foo"; 2545 another.value = true; 2546 message.setExtension(Extensions.someMessage, another); 2547 2548 message.setExtension(Extensions.someRepeatedString, list("a", "bee", "seeya")); 2549 message.setExtension(Extensions.someRepeatedBool, list(true, false, true)); 2550 message.setExtension(Extensions.someRepeatedInt, list(4, 8, 15, 16, 23, 42)); 2551 message.setExtension(Extensions.someRepeatedLong, list(4L, 8L, 15L, 16L, 23L, 42L)); 2552 message.setExtension(Extensions.someRepeatedFloat, list(1.0f, 3.0f)); 2553 message.setExtension(Extensions.someRepeatedDouble, list(55.133, 3.14159)); 2554 message.setExtension(Extensions.someRepeatedEnum, list(Extensions.FIRST_VALUE, 2555 Extensions.SECOND_VALUE)); 2556 AnotherMessage second = new AnotherMessage(); 2557 second.string = "Whee"; 2558 second.value = false; 2559 message.setExtension(Extensions.someRepeatedMessage, list(another, second)); 2560 2561 byte[] data = MessageNano.toByteArray(message); 2562 2563 Extensions.ExtendableMessage deserialized = Extensions.ExtendableMessage.parseFrom(data); 2564 assertEquals(5, deserialized.field); 2565 assertEquals("Hello World!", deserialized.getExtension(Extensions.someString)); 2566 assertEquals(Boolean.TRUE, deserialized.getExtension(Extensions.someBool)); 2567 assertEquals(Integer.valueOf(42), deserialized.getExtension(Extensions.someInt)); 2568 assertEquals(Long.valueOf(124234234234L), deserialized.getExtension(Extensions.someLong)); 2569 assertEquals(Float.valueOf(42.0f), deserialized.getExtension(Extensions.someFloat)); 2570 assertEquals(Double.valueOf(422222.0), deserialized.getExtension(Extensions.someDouble)); 2571 assertEquals(Integer.valueOf(Extensions.FIRST_VALUE), 2572 deserialized.getExtension(Extensions.someEnum)); 2573 assertEquals(another.string, deserialized.getExtension(Extensions.someMessage).string); 2574 assertEquals(another.value, deserialized.getExtension(Extensions.someMessage).value); 2575 assertEquals(list("a", "bee", "seeya"), deserialized.getExtension(Extensions.someRepeatedString)); 2576 assertEquals(list(true, false, true), deserialized.getExtension(Extensions.someRepeatedBool)); 2577 assertEquals(list(4, 8, 15, 16, 23, 42), deserialized.getExtension(Extensions.someRepeatedInt)); 2578 assertEquals(list(4L, 8L, 15L, 16L, 23L, 42L), deserialized.getExtension(Extensions.someRepeatedLong)); 2579 assertEquals(list(1.0f, 3.0f), deserialized.getExtension(Extensions.someRepeatedFloat)); 2580 assertEquals(list(55.133, 3.14159), deserialized.getExtension(Extensions.someRepeatedDouble)); 2581 assertEquals(list(Extensions.FIRST_VALUE, 2582 Extensions.SECOND_VALUE), deserialized.getExtension(Extensions.someRepeatedEnum)); 2583 assertEquals("Foo", deserialized.getExtension(Extensions.someRepeatedMessage).get(0).string); 2584 assertEquals(true, deserialized.getExtension(Extensions.someRepeatedMessage).get(0).value); 2585 assertEquals("Whee", deserialized.getExtension(Extensions.someRepeatedMessage).get(1).string); 2586 assertEquals(false, deserialized.getExtension(Extensions.someRepeatedMessage).get(1).value); 2587 } 2588 2589 public void testUnknownFields() throws Exception { 2590 // Check that we roundtrip (serialize and deserialize) unrecognized fields. 2591 AnotherMessage message = new AnotherMessage(); 2592 message.string = "Hello World"; 2593 message.value = false; 2594 2595 byte[] bytes = MessageNano.toByteArray(message); 2596 int extraFieldSize = CodedOutputStream.computeStringSize(1001, "This is an unknown field"); 2597 byte[] newBytes = new byte[bytes.length + extraFieldSize]; 2598 System.arraycopy(bytes, 0, newBytes, 0, bytes.length); 2599 CodedOutputStream.newInstance(newBytes, bytes.length, extraFieldSize).writeString(1001, 2600 "This is an unknown field"); 2601 2602 // Deserialize with an unknown field. 2603 AnotherMessage deserialized = AnotherMessage.parseFrom(newBytes); 2604 byte[] serialized = MessageNano.toByteArray(deserialized); 2605 2606 assertEquals(newBytes.length, serialized.length); 2607 2608 // Clear, and make sure it clears everything. 2609 deserialized.clear(); 2610 assertEquals(0, MessageNano.toByteArray(deserialized).length); 2611 } 2612 2613 public void testMergeFrom() throws Exception { 2614 SimpleMessageNano message = new SimpleMessageNano(); 2615 message.d = 123; 2616 byte[] bytes = MessageNano.toByteArray(message); 2617 2618 SimpleMessageNano newMessage = MessageNano.mergeFrom(new SimpleMessageNano(), bytes); 2619 assertEquals(message.d, newMessage.d); 2620 } 2621 2622 public void testJavaKeyword() throws Exception { 2623 TestAllTypesNano msg = new TestAllTypesNano(); 2624 msg.synchronized_ = 123; 2625 assertEquals(123, msg.synchronized_); 2626 } 2627 2628 public void testReferenceTypesForPrimitives() throws Exception { 2629 NanoReferenceTypes.TestAllTypesNano message = new NanoReferenceTypes.TestAllTypesNano(); 2630 2631 // Base check - when nothing is set, we serialize nothing. 2632 assertHasWireData(message, false); 2633 2634 message.defaultBool = true; 2635 assertHasWireData(message, true); 2636 2637 message.defaultBool = false; 2638 assertHasWireData(message, true); 2639 2640 message.defaultBool = null; 2641 assertHasWireData(message, false); 2642 2643 message.defaultInt32 = 5; 2644 assertHasWireData(message, true); 2645 2646 message.defaultInt32 = null; 2647 assertHasWireData(message, false); 2648 2649 message.defaultInt64 = 123456L; 2650 assertHasWireData(message, true); 2651 2652 message.defaultInt64 = null; 2653 assertHasWireData(message, false); 2654 2655 message.defaultFloat = 1f; 2656 assertHasWireData(message, true); 2657 2658 message.defaultFloat = null; 2659 assertHasWireData(message, false); 2660 2661 message.defaultDouble = 2.1; 2662 assertHasWireData(message, true); 2663 2664 message.defaultDouble = null; 2665 assertHasWireData(message, false); 2666 2667 message.defaultString = "hello"; 2668 assertHasWireData(message, true); 2669 2670 message.defaultString = null; 2671 assertHasWireData(message, false); 2672 2673 message.defaultBytes = new byte[] { 1, 2, 3 }; 2674 assertHasWireData(message, true); 2675 2676 message.defaultBytes = null; 2677 assertHasWireData(message, false); 2678 } 2679 2680 public void testNullRepeatedFields() throws Exception { 2681 // Check that serialization after explicitly setting a repeated field 2682 // to null doesn't NPE. 2683 TestAllTypesNano message = new TestAllTypesNano(); 2684 message.repeatedInt32 = null; 2685 MessageNano.toByteArray(message); // should not NPE 2686 message.toString(); // should not NPE 2687 2688 message = new TestAllTypesNano(); 2689 message.repeatedNestedEnum = null; 2690 MessageNano.toByteArray(message); // should not NPE 2691 message.toString(); // should not NPE 2692 2693 message = new TestAllTypesNano(); 2694 message.repeatedBytes = null; 2695 MessageNano.toByteArray(message); // should not NPE 2696 message.toString(); // should not NPE 2697 2698 message = new TestAllTypesNano(); 2699 message.repeatedNestedMessage = null; 2700 MessageNano.toByteArray(message); // should not NPE 2701 message.toString(); // should not NPE 2702 2703 // Create a second message to merge into message. 2704 TestAllTypesNano secondMessage = new TestAllTypesNano(); 2705 TestAllTypesNano.NestedMessage nested = 2706 new TestAllTypesNano.NestedMessage(); 2707 nested.bb = 55; 2708 secondMessage.repeatedNestedMessage = 2709 new TestAllTypesNano.NestedMessage[] { nested }; 2710 2711 // Should not NPE 2712 message.mergeFrom(CodedInputByteBufferNano.newInstance( 2713 MessageNano.toByteArray(secondMessage))); 2714 assertEquals(55, message.repeatedNestedMessage[0].bb); 2715 } 2716 2717 private void assertHasWireData(MessageNano message, boolean expected) { 2718 byte[] bytes = MessageNano.toByteArray(message); 2719 int wireLength = bytes.length; 2720 if (expected) { 2721 assertFalse(wireLength == 0); 2722 } else { 2723 if (wireLength != 0) { 2724 fail("Expected no wire data for message \n" + message 2725 + "\nBut got:\n" 2726 + hexDump(bytes)); 2727 } 2728 } 2729 } 2730 2731 private static String hexDump(byte[] bytes) { 2732 StringBuilder sb = new StringBuilder(); 2733 for (byte b : bytes) { 2734 sb.append(String.format("%02x ", b)); 2735 } 2736 return sb.toString(); 2737 } 2738 2739 private <T> List<T> list(T first, T... remaining) { 2740 List<T> list = new ArrayList<T>(); 2741 list.add(first); 2742 for (T item : remaining) { 2743 list.add(item); 2744 } 2745 return list; 2746 } 2747} 2748