NanoTest.java revision 43325653beb4e5b6923d0380a84bf7e204be5c22 
1// Protocol Buffers - Google's data interchange format
2// Copyright 2013 Google Inc.  All rights reserved.
3// http://code.google.com/p/protobuf/
4//
5// Redistribution and use in source and binary forms, with or without
6// modification, are permitted provided that the following conditions are
7// met:
8//
9//     * Redistributions of source code must retain the above copyright
10// notice, this list of conditions and the following disclaimer.
11//     * Redistributions in binary form must reproduce the above
12// copyright notice, this list of conditions and the following disclaimer
13// in the documentation and/or other materials provided with the
14// distribution.
15//     * Neither the name of Google Inc. nor the names of its
16// contributors may be used to endorse or promote products derived from
17// this software without specific prior written permission.
18//
19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31package com.google.protobuf;
32
33import com.google.protobuf.nano.InternalNano;
34import com.google.protobuf.nano.MessageNano;
35import com.google.protobuf.nano.NanoOuterClass;
36import com.google.protobuf.nano.NanoOuterClass.TestAllTypesNano;
37import com.google.protobuf.nano.RecursiveMessageNano;
38import com.google.protobuf.nano.SimpleMessageNano;
39import com.google.protobuf.nano.UnittestImportNano;
40import com.google.protobuf.nano.CodedInputByteBufferNano;
41
42import junit.framework.TestCase;
43
44/**
45 * Test nano runtime.
46 *
47 * @author ulas@google.com Ulas Kirazci
48 */
49public class NanoTest extends TestCase {
50  public void setUp() throws Exception {
51  }
52
53  public void testSimpleMessageNano() throws Exception {
54    SimpleMessageNano msg = new SimpleMessageNano();
55    assertEquals(123, msg.d);
56    assertEquals(null, msg.nestedMsg);
57    assertEquals(SimpleMessageNano.BAZ, msg.defaultNestedEnum);
58
59    msg.d = 456;
60    assertEquals(456, msg.d);
61
62    SimpleMessageNano.NestedMessage nestedMsg = new SimpleMessageNano.NestedMessage();
63    nestedMsg.bb = 2;
64    assertEquals(2, nestedMsg.bb);
65    msg.nestedMsg = nestedMsg;
66    assertEquals(2, msg.nestedMsg.bb);
67
68    msg.defaultNestedEnum = SimpleMessageNano.BAR;
69    assertEquals(SimpleMessageNano.BAR, msg.defaultNestedEnum);
70
71    byte [] result = MessageNano.toByteArray(msg);
72    int msgSerializedSize = msg.getSerializedSize();
73    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
74    assertTrue(msgSerializedSize == 9);
75    assertEquals(result.length, msgSerializedSize);
76
77    SimpleMessageNano newMsg = SimpleMessageNano.parseFrom(result);
78    assertEquals(456, newMsg.d);
79    assertEquals(2, msg.nestedMsg.bb);
80    assertEquals(SimpleMessageNano.BAR, msg.defaultNestedEnum);
81  }
82
83  public void testRecursiveMessageNano() throws Exception {
84    RecursiveMessageNano msg = new RecursiveMessageNano();
85    assertTrue(msg.repeatedRecursiveMessageNano.length == 0);
86
87    RecursiveMessageNano msg1 = new RecursiveMessageNano();
88    msg1.id = 1;
89    assertEquals(1, msg1.id);
90    RecursiveMessageNano msg2 = new RecursiveMessageNano();
91    msg2.id = 2;
92    RecursiveMessageNano msg3 = new RecursiveMessageNano();
93    msg3.id = 3;
94
95    RecursiveMessageNano.NestedMessage nestedMsg = new RecursiveMessageNano.NestedMessage();
96    nestedMsg.a = msg1;
97    assertEquals(1, nestedMsg.a.id);
98
99    msg.id = 0;
100    msg.nestedMessage = nestedMsg;
101    msg.optionalRecursiveMessageNano = msg2;
102    msg.repeatedRecursiveMessageNano = new RecursiveMessageNano[] { msg3 };
103
104    byte [] result = MessageNano.toByteArray(msg);
105    int msgSerializedSize = msg.getSerializedSize();
106    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
107    assertTrue(msgSerializedSize == 16);
108    assertEquals(result.length, msgSerializedSize);
109
110    RecursiveMessageNano newMsg = RecursiveMessageNano.parseFrom(result);
111    assertEquals(1, newMsg.repeatedRecursiveMessageNano.length);
112
113    assertEquals(0, newMsg.id);
114    assertEquals(1, newMsg.nestedMessage.a.id);
115    assertEquals(2, newMsg.optionalRecursiveMessageNano.id);
116    assertEquals(3, newMsg.repeatedRecursiveMessageNano[0].id);
117  }
118
119  public void testNanoRequiredInt32() throws Exception {
120    TestAllTypesNano msg = new TestAllTypesNano();
121    msg.id = 123;
122    assertEquals(123, msg.id);
123    msg.clear().id = 456;
124    assertEquals(456, msg.id);
125    msg.clear();
126
127    msg.id = 123;
128    byte [] result = MessageNano.toByteArray(msg);
129    int msgSerializedSize = msg.getSerializedSize();
130    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
131    assertTrue(msgSerializedSize == 3);
132    assertEquals(result.length, msgSerializedSize);
133
134    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
135    assertEquals(123, newMsg.id);
136  }
137
138  public void testNanoOptionalInt32() throws Exception {
139    TestAllTypesNano msg = new TestAllTypesNano();
140    msg.optionalInt32 = 123;
141    assertEquals(123, msg.optionalInt32);
142    msg.clear()
143       .optionalInt32 = 456;
144    assertEquals(456, msg.optionalInt32);
145    msg.clear();
146
147    msg.optionalInt32 = 123;
148    byte [] result = MessageNano.toByteArray(msg);
149    int msgSerializedSize = msg.getSerializedSize();
150    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
151    assertTrue(msgSerializedSize == 5);
152    assertEquals(result.length, msgSerializedSize);
153
154    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
155    assertEquals(123, newMsg.optionalInt32);
156  }
157
158  public void testNanoOptionalInt64() throws Exception {
159    TestAllTypesNano msg = new TestAllTypesNano();
160    msg.optionalInt64 = 123;
161    assertEquals(123, msg.optionalInt64);
162    msg.clear()
163       .optionalInt64 = 456;
164    assertEquals(456, msg.optionalInt64);
165    msg.clear();
166    assertEquals(0, msg.optionalInt64);
167
168    msg.optionalInt64 = 123;
169    byte [] result = MessageNano.toByteArray(msg);
170    int msgSerializedSize = msg.getSerializedSize();
171    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
172    assertTrue(msgSerializedSize == 5);
173    assertEquals(result.length, msgSerializedSize);
174
175    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
176    assertEquals(123, newMsg.optionalInt64);
177  }
178
179  public void testNanoOptionalUint32() throws Exception {
180    TestAllTypesNano msg = new TestAllTypesNano();
181    msg.optionalUint32 = 123;
182    assertEquals(123, msg.optionalUint32);
183    msg.clear()
184       .optionalUint32 = 456;
185    assertEquals(456, msg.optionalUint32);
186    msg.clear();
187    assertEquals(0, msg.optionalUint32);
188
189    msg.optionalUint32 = 123;
190    byte [] result = MessageNano.toByteArray(msg);
191    int msgSerializedSize = msg.getSerializedSize();
192    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
193    assertTrue(msgSerializedSize == 5);
194    assertEquals(result.length, msgSerializedSize);
195
196    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
197    assertEquals(123, newMsg.optionalUint32);
198  }
199
200  public void testNanoOptionalUint64() throws Exception {
201    TestAllTypesNano msg = new TestAllTypesNano();
202    msg.optionalUint64 = 123;
203    assertEquals(123, msg.optionalUint64);
204    msg.clear()
205       .optionalUint64 = 456;
206    assertEquals(456, msg.optionalUint64);
207    msg.clear();
208    assertEquals(0, msg.optionalUint64);
209
210    msg.optionalUint64 = 123;
211    byte [] result = MessageNano.toByteArray(msg);
212    int msgSerializedSize = msg.getSerializedSize();
213    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
214    assertTrue(msgSerializedSize == 5);
215    assertEquals(result.length, msgSerializedSize);
216
217    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
218    assertEquals(123, newMsg.optionalUint64);
219  }
220
221  public void testNanoOptionalSint32() throws Exception {
222    TestAllTypesNano msg = new TestAllTypesNano();
223    msg.optionalSint32 = 123;
224    assertEquals(123, msg.optionalSint32);
225    msg.clear()
226       .optionalSint32 = 456;
227    assertEquals(456, msg.optionalSint32);
228    msg.clear();
229    assertEquals(0, msg.optionalSint32);
230
231    msg.optionalSint32 = -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 == 6);
236    assertEquals(result.length, msgSerializedSize);
237
238    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
239    assertEquals(-123, newMsg.optionalSint32);
240  }
241
242  public void testNanoOptionalSint64() throws Exception {
243    TestAllTypesNano msg = new TestAllTypesNano();
244    msg.optionalSint64 = 123;
245    assertEquals(123, msg.optionalSint64);
246    msg.clear()
247       .optionalSint64 = 456;
248    assertEquals(456, msg.optionalSint64);
249    msg.clear();
250    assertEquals(0, msg.optionalSint64);
251
252    msg.optionalSint64 = -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.optionalSint64);
261  }
262
263  public void testNanoOptionalFixed32() throws Exception {
264    TestAllTypesNano msg = new TestAllTypesNano();
265    msg.optionalFixed32 = 123;
266    assertEquals(123, msg.optionalFixed32);
267    msg.clear()
268       .optionalFixed32 = 456;
269    assertEquals(456, msg.optionalFixed32);
270    msg.clear();
271    assertEquals(0, msg.optionalFixed32);
272
273    msg.optionalFixed32 = 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 == 8);
278    assertEquals(result.length, msgSerializedSize);
279
280    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
281    assertEquals(123, newMsg.optionalFixed32);
282  }
283
284  public void testNanoOptionalFixed64() throws Exception {
285    TestAllTypesNano msg = new TestAllTypesNano();
286    msg.optionalFixed64 = 123;
287    assertEquals(123, msg.optionalFixed64);
288    msg.clear()
289       .optionalFixed64 = 456;
290    assertEquals(456, msg.optionalFixed64);
291    msg.clear();
292    assertEquals(0, msg.optionalFixed64);
293
294    msg.optionalFixed64 = 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 == 12);
299    assertEquals(result.length, msgSerializedSize);
300
301    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
302    assertEquals(123, newMsg.optionalFixed64);
303  }
304
305  public void testNanoOptionalSfixed32() throws Exception {
306    TestAllTypesNano msg = new TestAllTypesNano();
307    msg.optionalSfixed32 = 123;
308    assertEquals(123, msg.optionalSfixed32);
309    msg.clear()
310       .optionalSfixed32 = 456;
311    assertEquals(456, msg.optionalSfixed32);
312    msg.clear();
313    assertEquals(0, msg.optionalSfixed32);
314
315    msg.optionalSfixed32 = 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 == 8);
320    assertEquals(result.length, msgSerializedSize);
321
322    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
323    assertEquals(123, newMsg.optionalSfixed32);
324  }
325
326  public void testNanoOptionalSfixed64() throws Exception {
327    TestAllTypesNano msg = new TestAllTypesNano();
328    msg.optionalSfixed64 = 123;
329    assertEquals(123, msg.optionalSfixed64);
330    msg.clear()
331       .optionalSfixed64 = 456;
332    assertEquals(456, msg.optionalSfixed64);
333    msg.clear();
334    assertEquals(0, msg.optionalSfixed64);
335
336    msg.optionalSfixed64 = -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 == 12);
341    assertEquals(result.length, msgSerializedSize);
342
343    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
344    assertEquals(-123, newMsg.optionalSfixed64);
345  }
346
347  public void testNanoOptionalFloat() throws Exception {
348    TestAllTypesNano msg = new TestAllTypesNano();
349    msg.optionalFloat = 123f;
350    assertTrue(123.0f == msg.optionalFloat);
351    msg.clear()
352       .optionalFloat = 456.0f;
353    assertTrue(456.0f == msg.optionalFloat);
354    msg.clear();
355    assertTrue(0.0f == msg.optionalFloat);
356
357    msg.optionalFloat = -123.456f;
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 == 8);
362    assertEquals(result.length, msgSerializedSize);
363
364    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
365    assertTrue(-123.456f == newMsg.optionalFloat);
366  }
367
368  public void testNanoOptionalDouble() throws Exception {
369    TestAllTypesNano msg = new TestAllTypesNano();
370    msg.optionalDouble = 123;
371    assertTrue(123.0 == msg.optionalDouble);
372    msg.clear()
373       .optionalDouble = 456.0;
374    assertTrue(456.0 == msg.optionalDouble);
375    msg.clear();
376    assertTrue(0.0 == msg.optionalDouble);
377
378    msg.optionalDouble = -123.456;
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 == 12);
383    assertEquals(result.length, msgSerializedSize);
384
385    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
386    assertTrue(-123.456 == newMsg.optionalDouble);
387  }
388
389  public void testNanoOptionalBool() throws Exception {
390    TestAllTypesNano msg = new TestAllTypesNano();
391    msg.optionalBool = true;
392    assertTrue(msg.optionalBool);
393    msg.clear()
394       .optionalBool = true;
395    assertTrue(msg.optionalBool);
396    msg.clear();
397    assertFalse(msg.optionalBool);
398
399    msg.optionalBool = true;
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 == 5);
404    assertEquals(result.length, msgSerializedSize);
405
406    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
407    assertTrue(newMsg.optionalBool);
408  }
409
410  public void testNanoOptionalString() throws Exception {
411    TestAllTypesNano msg = new TestAllTypesNano();
412    msg.optionalString = "hello";
413    assertEquals("hello", msg.optionalString);
414    msg.clear();
415    assertTrue(msg.optionalString.isEmpty());
416    msg.clear()
417       .optionalString = "hello2";
418    assertEquals("hello2", msg.optionalString);
419    msg.clear();
420    assertTrue(msg.optionalString.isEmpty());
421
422    msg.optionalString = "bye";
423    byte [] result = MessageNano.toByteArray(msg);
424    int msgSerializedSize = msg.getSerializedSize();
425    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
426    assertTrue(msgSerializedSize == 8);
427    assertEquals(result.length, msgSerializedSize);
428
429    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
430    assertTrue(newMsg.optionalString != null);
431    assertEquals("bye", newMsg.optionalString);
432  }
433
434  public void testNanoOptionalBytes() throws Exception {
435    TestAllTypesNano msg = new TestAllTypesNano();
436    assertFalse(msg.optionalBytes.length > 0);
437    msg.optionalBytes = InternalNano.copyFromUtf8("hello");
438    assertTrue(msg.optionalBytes.length > 0);
439    assertEquals("hello", new String(msg.optionalBytes, "UTF-8"));
440    msg.clear();
441    assertFalse(msg.optionalBytes.length > 0);
442    msg.clear()
443       .optionalBytes = InternalNano.copyFromUtf8("hello");
444    assertTrue(msg.optionalBytes.length > 0);
445    msg.clear();
446    assertFalse(msg.optionalBytes.length > 0);
447
448    msg.optionalBytes = InternalNano.copyFromUtf8("bye");
449    byte [] result = MessageNano.toByteArray(msg);
450    int msgSerializedSize = msg.getSerializedSize();
451    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
452    assertTrue(msgSerializedSize == 8);
453    assertEquals(result.length, msgSerializedSize);
454
455    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
456    assertTrue(newMsg.optionalBytes.length > 0);
457    assertEquals("bye", new String(newMsg.optionalBytes, "UTF-8"));
458  }
459
460  public void testNanoOptionalGroup() throws Exception {
461    TestAllTypesNano msg = new TestAllTypesNano();
462    TestAllTypesNano.OptionalGroup grp = new TestAllTypesNano.OptionalGroup();
463    grp.a = 1;
464    assertFalse(msg.optionalGroup != null);
465    msg.optionalGroup = grp;
466    assertTrue(msg.optionalGroup != null);
467    assertEquals(1, msg.optionalGroup.a);
468    msg.clear();
469    assertFalse(msg.optionalGroup != null);
470    msg.clear()
471       .optionalGroup = new TestAllTypesNano.OptionalGroup();
472    msg.optionalGroup.a = 2;
473    assertTrue(msg.optionalGroup != null);
474    msg.clear();
475    assertFalse(msg.optionalGroup != null);
476
477    msg.optionalGroup = grp;
478    byte [] result = MessageNano.toByteArray(msg);
479    int msgSerializedSize = msg.getSerializedSize();
480    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
481    assertTrue(msgSerializedSize == 10);
482    assertEquals(result.length, msgSerializedSize);
483
484    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
485    assertTrue(newMsg.optionalGroup != null);
486    assertEquals(1, newMsg.optionalGroup.a);
487  }
488
489  public void testNanoOptionalNestedMessage() throws Exception {
490    TestAllTypesNano msg = new TestAllTypesNano();
491    TestAllTypesNano.NestedMessage nestedMsg = new TestAllTypesNano.NestedMessage();
492    nestedMsg.bb = 1;
493    assertFalse(msg.optionalNestedMessage != null);
494    msg.optionalNestedMessage = nestedMsg;
495    assertTrue(msg.optionalNestedMessage != null);
496    assertEquals(1, msg.optionalNestedMessage.bb);
497    msg.clear();
498    assertFalse(msg.optionalNestedMessage != null);
499    msg.clear()
500       .optionalNestedMessage = new TestAllTypesNano.NestedMessage();
501    msg.optionalNestedMessage.bb = 2;
502    assertTrue(msg.optionalNestedMessage != null);
503    msg.clear();
504    assertFalse(msg.optionalNestedMessage != null);
505
506    msg.optionalNestedMessage = nestedMsg;
507    byte [] result = MessageNano.toByteArray(msg);
508    int msgSerializedSize = msg.getSerializedSize();
509    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
510    assertTrue(msgSerializedSize == 8);
511    assertEquals(result.length, msgSerializedSize);
512
513    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
514    assertTrue(newMsg.optionalNestedMessage != null);
515    assertEquals(1, newMsg.optionalNestedMessage.bb);
516  }
517
518  public void testNanoOptionalForeignMessage() throws Exception {
519    TestAllTypesNano msg = new TestAllTypesNano();
520    NanoOuterClass.ForeignMessageNano nestedMsg = new NanoOuterClass.ForeignMessageNano();
521    nestedMsg.c = 1;
522    assertFalse(msg.optionalForeignMessage != null);
523    msg.optionalForeignMessage = nestedMsg;
524    assertTrue(msg.optionalForeignMessage != null);
525    assertEquals(1, msg.optionalForeignMessage.c);
526    msg.clear();
527    assertFalse(msg.optionalForeignMessage != null);
528    msg.clear()
529       .optionalForeignMessage = new NanoOuterClass.ForeignMessageNano();
530    msg.optionalForeignMessage.c = 2;
531    assertTrue(msg.optionalForeignMessage != null);
532    msg.clear();
533    assertFalse(msg.optionalForeignMessage != null);
534
535    msg.optionalForeignMessage = nestedMsg;
536    byte [] result = MessageNano.toByteArray(msg);
537    int msgSerializedSize = msg.getSerializedSize();
538    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
539    assertTrue(msgSerializedSize == 8);
540    assertEquals(result.length, msgSerializedSize);
541
542    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
543    assertTrue(newMsg.optionalForeignMessage != null);
544    assertEquals(1, newMsg.optionalForeignMessage.c);
545  }
546
547  public void testNanoOptionalImportMessage() throws Exception {
548    TestAllTypesNano msg = new TestAllTypesNano();
549    UnittestImportNano.ImportMessageNano nestedMsg = new UnittestImportNano.ImportMessageNano();
550    nestedMsg.d = 1;
551    assertFalse(msg.optionalImportMessage != null);
552    msg.optionalImportMessage = nestedMsg;
553    assertTrue(msg.optionalImportMessage != null);
554    assertEquals(1, msg.optionalImportMessage.d);
555    msg.clear();
556    assertFalse(msg.optionalImportMessage != null);
557    msg.clear()
558       .optionalImportMessage = new UnittestImportNano.ImportMessageNano();
559    msg.optionalImportMessage.d = 2;
560    assertTrue(msg.optionalImportMessage != null);
561    msg.clear();
562    assertFalse(msg.optionalImportMessage != null);
563
564    msg.optionalImportMessage = nestedMsg;
565    byte [] result = MessageNano.toByteArray(msg);
566    int msgSerializedSize = msg.getSerializedSize();
567    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
568    assertTrue(msgSerializedSize == 8);
569    assertEquals(result.length, msgSerializedSize);
570
571    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
572    assertTrue(newMsg.optionalImportMessage != null);
573    assertEquals(1, newMsg.optionalImportMessage.d);
574  }
575
576  public void testNanoOptionalNestedEnum() throws Exception {
577    TestAllTypesNano msg = new TestAllTypesNano();
578    msg.optionalNestedEnum = TestAllTypesNano.BAR;
579    assertEquals(TestAllTypesNano.BAR, msg.optionalNestedEnum);
580    msg.clear()
581       .optionalNestedEnum = TestAllTypesNano.BAZ;
582    assertEquals(TestAllTypesNano.BAZ, msg.optionalNestedEnum);
583    msg.clear();
584    assertEquals(TestAllTypesNano.FOO, msg.optionalNestedEnum);
585
586    msg.optionalNestedEnum = TestAllTypesNano.BAR;
587    byte [] result = MessageNano.toByteArray(msg);
588    int msgSerializedSize = msg.getSerializedSize();
589    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
590    assertTrue(msgSerializedSize == 6);
591    assertEquals(result.length, msgSerializedSize);
592
593    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
594    assertEquals(TestAllTypesNano.BAR, newMsg.optionalNestedEnum);
595  }
596
597  public void testNanoOptionalForeignEnum() throws Exception {
598    TestAllTypesNano msg = new TestAllTypesNano();
599    msg.optionalForeignEnum = NanoOuterClass.FOREIGN_NANO_BAR;
600    assertEquals(NanoOuterClass.FOREIGN_NANO_BAR, msg.optionalForeignEnum);
601    msg.clear()
602       .optionalForeignEnum = NanoOuterClass.FOREIGN_NANO_BAZ;
603    assertEquals(NanoOuterClass.FOREIGN_NANO_BAZ, msg.optionalForeignEnum);
604    msg.clear();
605    assertEquals(NanoOuterClass.FOREIGN_NANO_FOO, msg.optionalForeignEnum);
606
607    msg.optionalForeignEnum = NanoOuterClass.FOREIGN_NANO_BAR;
608    byte [] result = MessageNano.toByteArray(msg);
609    int msgSerializedSize = msg.getSerializedSize();
610    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
611    assertTrue(msgSerializedSize == 6);
612    assertEquals(result.length, msgSerializedSize);
613
614    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
615    assertEquals(NanoOuterClass.FOREIGN_NANO_BAR, newMsg.optionalForeignEnum);
616  }
617
618  public void testNanoOptionalImportEnum() throws Exception {
619    TestAllTypesNano msg = new TestAllTypesNano();
620    msg.optionalImportEnum = UnittestImportNano.IMPORT_NANO_BAR;
621    assertEquals(UnittestImportNano.IMPORT_NANO_BAR, msg.optionalImportEnum);
622    msg.clear()
623       .optionalImportEnum = UnittestImportNano.IMPORT_NANO_BAZ;
624    assertEquals(UnittestImportNano.IMPORT_NANO_BAZ, msg.optionalImportEnum);
625    msg.clear();
626    assertEquals(UnittestImportNano.IMPORT_NANO_FOO, msg.optionalImportEnum);
627
628    msg.optionalImportEnum = UnittestImportNano.IMPORT_NANO_BAR;
629    byte [] result = MessageNano.toByteArray(msg);
630    int msgSerializedSize = msg.getSerializedSize();
631    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
632    assertTrue(msgSerializedSize == 6);
633    assertEquals(result.length, msgSerializedSize);
634
635    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
636    assertEquals(UnittestImportNano.IMPORT_NANO_BAR, newMsg.optionalImportEnum);
637  }
638
639  public void testNanoOptionalStringPiece() throws Exception {
640    TestAllTypesNano msg = new TestAllTypesNano();
641    msg.optionalStringPiece = "hello";
642    assertEquals("hello", msg.optionalStringPiece);
643    msg.clear();
644    assertTrue(msg.optionalStringPiece.isEmpty());
645    msg.clear()
646       .optionalStringPiece = "hello2";
647    assertEquals("hello2", msg.optionalStringPiece);
648    msg.clear();
649    assertTrue(msg.optionalStringPiece.isEmpty());
650
651    msg.optionalStringPiece = "bye";
652    byte [] result = MessageNano.toByteArray(msg);
653    int msgSerializedSize = msg.getSerializedSize();
654    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
655    assertTrue(msgSerializedSize == 9);
656    assertEquals(result.length, msgSerializedSize);
657
658    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
659    assertTrue(newMsg.optionalStringPiece != null);
660    assertEquals("bye", newMsg.optionalStringPiece);
661  }
662
663  public void testNanoOptionalCord() throws Exception {
664    TestAllTypesNano msg = new TestAllTypesNano();
665    msg.optionalCord = "hello";
666    assertEquals("hello", msg.optionalCord);
667    msg.clear();
668    assertTrue(msg.optionalCord.isEmpty());
669    msg.clear()
670       .optionalCord = "hello2";
671    assertEquals("hello2", msg.optionalCord);
672    msg.clear();
673    assertTrue(msg.optionalCord.isEmpty());
674
675    msg.optionalCord = "bye";
676    byte [] result = MessageNano.toByteArray(msg);
677    int msgSerializedSize = msg.getSerializedSize();
678    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
679    assertTrue(msgSerializedSize == 9);
680    assertEquals(result.length, msgSerializedSize);
681
682    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
683    assertTrue(newMsg.optionalCord != null);
684    assertEquals("bye", newMsg.optionalCord);
685  }
686
687  public void testNanoRepeatedInt32() throws Exception {
688    TestAllTypesNano msg = new TestAllTypesNano();
689    assertEquals(0, msg.repeatedInt32.length);
690    msg.repeatedInt32 = new int[] { 123, 789, 456 };
691    assertEquals(789, msg.repeatedInt32[1]);
692    assertEquals(456, msg.repeatedInt32[2]);
693    msg.clear();
694    assertEquals(0, msg.repeatedInt32.length);
695    msg.clear()
696       .repeatedInt32 = new int[] { 456 };
697    assertEquals(1, msg.repeatedInt32.length);
698    assertEquals(456, msg.repeatedInt32[0]);
699    msg.clear();
700    assertEquals(0, msg.repeatedInt32.length);
701
702    // Test 1 entry
703    msg.clear()
704       .repeatedInt32 = new int[] { 123 };
705    assertEquals(1, msg.repeatedInt32.length);
706    byte [] result = MessageNano.toByteArray(msg);
707    int msgSerializedSize = msg.getSerializedSize();
708    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
709    assertTrue(msgSerializedSize == 6);
710    assertEquals(result.length, msgSerializedSize);
711    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
712    assertEquals(1, newMsg.repeatedInt32.length);
713    assertEquals(123, newMsg.repeatedInt32[0]);
714
715    // Test 2 entries
716    msg.clear()
717       .repeatedInt32 = new int[] { 123, 456 };
718    assertEquals(2, msg.repeatedInt32.length);
719    result = MessageNano.toByteArray(msg);
720    msgSerializedSize = msg.getSerializedSize();
721    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
722    assertTrue(msgSerializedSize == 10);
723    assertEquals(result.length, msgSerializedSize);
724
725    newMsg = TestAllTypesNano.parseFrom(result);
726    assertEquals(2, newMsg.repeatedInt32.length);
727    assertEquals(123, newMsg.repeatedInt32[0]);
728    assertEquals(456, newMsg.repeatedInt32[1]);
729  }
730
731  public void testNanoRepeatedInt64() throws Exception {
732    TestAllTypesNano msg = new TestAllTypesNano();
733    assertEquals(0, msg.repeatedInt64.length);
734    msg.repeatedInt64 = new long[] { 123, 789, 456 };
735    assertEquals(789, msg.repeatedInt64[1]);
736    assertEquals(456, msg.repeatedInt64[2]);
737    msg.clear();
738    assertEquals(0, msg.repeatedInt64.length);
739    msg.clear()
740       .repeatedInt64 = new long[] { 456 };
741    assertEquals(1, msg.repeatedInt64.length);
742    assertEquals(456, msg.repeatedInt64[0]);
743    msg.clear();
744    assertEquals(0, msg.repeatedInt64.length);
745
746    // Test 1 entry
747    msg.clear()
748       .repeatedInt64 = new long[] { 123 };
749    assertEquals(1, msg.repeatedInt64.length);
750    byte [] result = MessageNano.toByteArray(msg);
751    int msgSerializedSize = msg.getSerializedSize();
752    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
753    assertTrue(msgSerializedSize == 6);
754    assertEquals(result.length, msgSerializedSize);
755    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
756    assertEquals(1, newMsg.repeatedInt64.length);
757    assertEquals(123, newMsg.repeatedInt64[0]);
758
759    // Test 2 entries
760    msg.clear()
761       .repeatedInt64 = new long[] { 123, 456 };
762    assertEquals(2, msg.repeatedInt64.length);
763    result = MessageNano.toByteArray(msg);
764    msgSerializedSize = msg.getSerializedSize();
765    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
766    assertTrue(msgSerializedSize == 10);
767    assertEquals(result.length, msgSerializedSize);
768
769    newMsg = TestAllTypesNano.parseFrom(result);
770    assertEquals(2, newMsg.repeatedInt64.length);
771    assertEquals(123, newMsg.repeatedInt64[0]);
772    assertEquals(456, newMsg.repeatedInt64[1]);
773  }
774
775  public void testNanoRepeatedUint32() throws Exception {
776    TestAllTypesNano msg = new TestAllTypesNano();
777    assertEquals(0, msg.repeatedUint32.length);
778    msg.repeatedUint32 = new int[] { 123, 789, 456 };
779    assertEquals(789, msg.repeatedUint32[1]);
780    assertEquals(456, msg.repeatedUint32[2]);
781    msg.clear();
782    assertEquals(0, msg.repeatedUint32.length);
783    msg.clear()
784       .repeatedUint32 = new int[] { 456 };
785    assertEquals(1, msg.repeatedUint32.length);
786    assertEquals(456, msg.repeatedUint32[0]);
787    msg.clear();
788    assertEquals(0, msg.repeatedUint32.length);
789
790    // Test 1 entry
791    msg.clear()
792       .repeatedUint32 = new int[] { 123 };
793    assertEquals(1, msg.repeatedUint32.length);
794    byte [] result = MessageNano.toByteArray(msg);
795    int msgSerializedSize = msg.getSerializedSize();
796    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
797    assertTrue(msgSerializedSize == 6);
798    assertEquals(result.length, msgSerializedSize);
799    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
800    assertEquals(1, newMsg.repeatedUint32.length);
801    assertEquals(123, newMsg.repeatedUint32[0]);
802
803    // Test 2 entries
804    msg.clear()
805       .repeatedUint32 = new int[] { 123, 456 };
806    assertEquals(2, msg.repeatedUint32.length);
807    result = MessageNano.toByteArray(msg);
808    msgSerializedSize = msg.getSerializedSize();
809    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
810    assertTrue(msgSerializedSize == 10);
811    assertEquals(result.length, msgSerializedSize);
812
813    newMsg = TestAllTypesNano.parseFrom(result);
814    assertEquals(2, newMsg.repeatedUint32.length);
815    assertEquals(123, newMsg.repeatedUint32[0]);
816    assertEquals(456, newMsg.repeatedUint32[1]);
817  }
818
819  public void testNanoRepeatedUint64() throws Exception {
820    TestAllTypesNano msg = new TestAllTypesNano();
821    assertEquals(0, msg.repeatedUint64.length);
822    msg.repeatedUint64 = new long[] { 123, 789, 456 };
823    assertEquals(789, msg.repeatedUint64[1]);
824    assertEquals(456, msg.repeatedUint64[2]);
825    msg.clear();
826    assertEquals(0, msg.repeatedUint64.length);
827    msg.clear()
828       .repeatedUint64 = new long[] { 456 };
829    assertEquals(1, msg.repeatedUint64.length);
830    assertEquals(456, msg.repeatedUint64[0]);
831    msg.clear();
832    assertEquals(0, msg.repeatedUint64.length);
833
834    // Test 1 entry
835    msg.clear()
836       .repeatedUint64 = new long[] { 123 };
837    assertEquals(1, msg.repeatedUint64.length);
838    byte [] result = MessageNano.toByteArray(msg);
839    int msgSerializedSize = msg.getSerializedSize();
840    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
841    assertTrue(msgSerializedSize == 6);
842    assertEquals(result.length, msgSerializedSize);
843    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
844    assertEquals(1, newMsg.repeatedUint64.length);
845    assertEquals(123, newMsg.repeatedUint64[0]);
846
847    // Test 2 entries
848    msg.clear()
849       .repeatedUint64 = new long[] { 123, 456 };
850    assertEquals(2, msg.repeatedUint64.length);
851    result = MessageNano.toByteArray(msg);
852    msgSerializedSize = msg.getSerializedSize();
853    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
854    assertTrue(msgSerializedSize == 10);
855    assertEquals(result.length, msgSerializedSize);
856
857    newMsg = TestAllTypesNano.parseFrom(result);
858    assertEquals(2, newMsg.repeatedUint64.length);
859    assertEquals(123, newMsg.repeatedUint64[0]);
860    assertEquals(456, newMsg.repeatedUint64[1]);
861  }
862
863  public void testNanoRepeatedSint32() throws Exception {
864    TestAllTypesNano msg = new TestAllTypesNano();
865    assertEquals(0, msg.repeatedSint32.length);
866    msg.repeatedSint32 = new int[] { 123, 789, 456 };
867    assertEquals(789, msg.repeatedSint32[1]);
868    assertEquals(456, msg.repeatedSint32[2]);
869    msg.clear();
870    assertEquals(0, msg.repeatedSint32.length);
871    msg.clear()
872       .repeatedSint32 = new int[] { 456 };
873    assertEquals(1, msg.repeatedSint32.length);
874    assertEquals(456, msg.repeatedSint32[0]);
875    msg.clear();
876    assertEquals(0, msg.repeatedSint32.length);
877
878    // Test 1 entry
879    msg.clear()
880       .repeatedSint32 = new int[] { 123 };
881    assertEquals(1, msg.repeatedSint32.length);
882    byte [] result = MessageNano.toByteArray(msg);
883    int msgSerializedSize = msg.getSerializedSize();
884    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
885    assertTrue(msgSerializedSize == 7);
886    assertEquals(result.length, msgSerializedSize);
887    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
888    assertEquals(1, newMsg.repeatedSint32.length);
889    assertEquals(123, newMsg.repeatedSint32[0]);
890
891    // Test 2 entries
892    msg.clear()
893       .repeatedSint32 = new int[] { 123, 456 };
894    assertEquals(2, msg.repeatedSint32.length);
895    result = MessageNano.toByteArray(msg);
896    msgSerializedSize = msg.getSerializedSize();
897    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
898    assertTrue(msgSerializedSize == 11);
899    assertEquals(result.length, msgSerializedSize);
900
901    newMsg = TestAllTypesNano.parseFrom(result);
902    assertEquals(2, newMsg.repeatedSint32.length);
903    assertEquals(123, newMsg.repeatedSint32[0]);
904    assertEquals(456, newMsg.repeatedSint32[1]);
905  }
906
907  public void testNanoRepeatedSint64() throws Exception {
908    TestAllTypesNano msg = new TestAllTypesNano();
909    assertEquals(0, msg.repeatedSint64.length);
910    msg.repeatedSint64 = new long[] { 123, 789, 456 };
911    assertEquals(789, msg.repeatedSint64[1]);
912    assertEquals(456, msg.repeatedSint64[2]);
913    msg.clear();
914    assertEquals(0, msg.repeatedSint64.length);
915    msg.clear()
916       .repeatedSint64 = new long[] { 456 };
917    assertEquals(1, msg.repeatedSint64.length);
918    assertEquals(456, msg.repeatedSint64[0]);
919    msg.clear();
920    assertEquals(0, msg.repeatedSint64.length);
921
922    // Test 1 entry
923    msg.clear()
924       .repeatedSint64 = new long[] { 123 };
925    assertEquals(1, msg.repeatedSint64.length);
926    byte [] result = MessageNano.toByteArray(msg);
927    int msgSerializedSize = msg.getSerializedSize();
928    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
929    assertTrue(msgSerializedSize == 7);
930    assertEquals(result.length, msgSerializedSize);
931    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
932    assertEquals(1, newMsg.repeatedSint64.length);
933    assertEquals(123, newMsg.repeatedSint64[0]);
934
935    // Test 2 entries
936    msg.clear()
937       .repeatedSint64 = new long[] { 123, 456 };
938    assertEquals(2, msg.repeatedSint64.length);
939    result = MessageNano.toByteArray(msg);
940    msgSerializedSize = msg.getSerializedSize();
941    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
942    assertTrue(msgSerializedSize == 11);
943    assertEquals(result.length, msgSerializedSize);
944
945    newMsg = TestAllTypesNano.parseFrom(result);
946    assertEquals(2, newMsg.repeatedSint64.length);
947    assertEquals(123, newMsg.repeatedSint64[0]);
948    assertEquals(456, newMsg.repeatedSint64[1]);
949  }
950
951  public void testNanoRepeatedFixed32() throws Exception {
952    TestAllTypesNano msg = new TestAllTypesNano();
953    assertEquals(0, msg.repeatedFixed32.length);
954    msg.repeatedFixed32 = new int[] { 123, 789, 456 };
955    assertEquals(789, msg.repeatedFixed32[1]);
956    assertEquals(456, msg.repeatedFixed32[2]);
957    msg.clear();
958    assertEquals(0, msg.repeatedFixed32.length);
959    msg.clear()
960       .repeatedFixed32 = new int[] { 456 };
961    assertEquals(1, msg.repeatedFixed32.length);
962    assertEquals(456, msg.repeatedFixed32[0]);
963    msg.clear();
964    assertEquals(0, msg.repeatedFixed32.length);
965
966    // Test 1 entry
967    msg.clear()
968       .repeatedFixed32 = new int[] { 123 };
969    assertEquals(1, msg.repeatedFixed32.length);
970    byte [] result = MessageNano.toByteArray(msg);
971    int msgSerializedSize = msg.getSerializedSize();
972    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
973    assertTrue(msgSerializedSize == 9);
974    assertEquals(result.length, msgSerializedSize);
975    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
976    assertEquals(1, newMsg.repeatedFixed32.length);
977    assertEquals(123, newMsg.repeatedFixed32[0]);
978
979    // Test 2 entries
980    msg.clear()
981       .repeatedFixed32 = new int[] { 123, 456 };
982    assertEquals(2, msg.repeatedFixed32.length);
983    result = MessageNano.toByteArray(msg);
984    msgSerializedSize = msg.getSerializedSize();
985    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
986    assertTrue(msgSerializedSize == 15);
987    assertEquals(result.length, msgSerializedSize);
988
989    newMsg = TestAllTypesNano.parseFrom(result);
990    assertEquals(2, newMsg.repeatedFixed32.length);
991    assertEquals(123, newMsg.repeatedFixed32[0]);
992    assertEquals(456, newMsg.repeatedFixed32[1]);
993  }
994
995  public void testNanoRepeatedFixed64() throws Exception {
996    TestAllTypesNano msg = new TestAllTypesNano();
997    assertEquals(0, msg.repeatedFixed64.length);
998    msg.repeatedFixed64 = new long[] { 123, 789, 456 };
999    assertEquals(789, msg.repeatedFixed64[1]);
1000    assertEquals(456, msg.repeatedFixed64[2]);
1001    msg.clear();
1002    assertEquals(0, msg.repeatedFixed64.length);
1003    msg.clear()
1004       .repeatedFixed64 = new long[] { 456 };
1005    assertEquals(1, msg.repeatedFixed64.length);
1006    assertEquals(456, msg.repeatedFixed64[0]);
1007    msg.clear();
1008    assertEquals(0, msg.repeatedFixed64.length);
1009
1010    // Test 1 entry
1011    msg.clear()
1012       .repeatedFixed64 = new long[] { 123 };
1013    assertEquals(1, msg.repeatedFixed64.length);
1014    byte [] result = MessageNano.toByteArray(msg);
1015    int msgSerializedSize = msg.getSerializedSize();
1016    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1017    assertTrue(msgSerializedSize == 13);
1018    assertEquals(result.length, msgSerializedSize);
1019    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1020    assertEquals(1, newMsg.repeatedFixed64.length);
1021    assertEquals(123, newMsg.repeatedFixed64[0]);
1022
1023    // Test 2 entries
1024    msg.clear()
1025       .repeatedFixed64 = new long[] { 123, 456 };
1026    assertEquals(2, msg.repeatedFixed64.length);
1027    result = MessageNano.toByteArray(msg);
1028    msgSerializedSize = msg.getSerializedSize();
1029    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1030    assertTrue(msgSerializedSize == 23);
1031    assertEquals(result.length, msgSerializedSize);
1032
1033    newMsg = TestAllTypesNano.parseFrom(result);
1034    assertEquals(2, newMsg.repeatedFixed64.length);
1035    assertEquals(123, newMsg.repeatedFixed64[0]);
1036    assertEquals(456, newMsg.repeatedFixed64[1]);
1037  }
1038
1039  public void testNanoRepeatedSfixed32() throws Exception {
1040    TestAllTypesNano msg = new TestAllTypesNano();
1041    assertEquals(0, msg.repeatedSfixed32.length);
1042    msg.repeatedSfixed32 = new int[] { 123, 789, 456 };
1043    assertEquals(789, msg.repeatedSfixed32[1]);
1044    assertEquals(456, msg.repeatedSfixed32[2]);
1045    msg.clear();
1046    assertEquals(0, msg.repeatedSfixed32.length);
1047    msg.clear()
1048       .repeatedSfixed32 = new int[] { 456 };
1049    assertEquals(1, msg.repeatedSfixed32.length);
1050    assertEquals(456, msg.repeatedSfixed32[0]);
1051    msg.clear();
1052    assertEquals(0, msg.repeatedSfixed32.length);
1053
1054    // Test 1 entry
1055    msg.clear()
1056       .repeatedSfixed32 = new int[] { 123 };
1057    assertEquals(1, msg.repeatedSfixed32.length);
1058    byte [] result = MessageNano.toByteArray(msg);
1059    int msgSerializedSize = msg.getSerializedSize();
1060    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1061    assertTrue(msgSerializedSize == 9);
1062    assertEquals(result.length, msgSerializedSize);
1063    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1064    assertEquals(1, newMsg.repeatedSfixed32.length);
1065    assertEquals(123, newMsg.repeatedSfixed32[0]);
1066
1067    // Test 2 entries
1068    msg.clear()
1069       .repeatedSfixed32 = new int[] { 123, 456 };
1070    assertEquals(2, msg.repeatedSfixed32.length);
1071    result = MessageNano.toByteArray(msg);
1072    msgSerializedSize = msg.getSerializedSize();
1073    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1074    assertTrue(msgSerializedSize == 15);
1075    assertEquals(result.length, msgSerializedSize);
1076
1077    newMsg = TestAllTypesNano.parseFrom(result);
1078    assertEquals(2, newMsg.repeatedSfixed32.length);
1079    assertEquals(123, newMsg.repeatedSfixed32[0]);
1080    assertEquals(456, newMsg.repeatedSfixed32[1]);
1081  }
1082
1083  public void testNanoRepeatedSfixed64() throws Exception {
1084    TestAllTypesNano msg = new TestAllTypesNano();
1085    assertEquals(0, msg.repeatedSfixed64.length);
1086    msg.repeatedSfixed64 = new long[] { 123, 789, 456 };
1087    assertEquals(789, msg.repeatedSfixed64[1]);
1088    assertEquals(456, msg.repeatedSfixed64[2]);
1089    msg.clear();
1090    assertEquals(0, msg.repeatedSfixed64.length);
1091    msg.clear()
1092       .repeatedSfixed64 = new long[] { 456 };
1093    assertEquals(1, msg.repeatedSfixed64.length);
1094    assertEquals(456, msg.repeatedSfixed64[0]);
1095    msg.clear();
1096    assertEquals(0, msg.repeatedSfixed64.length);
1097
1098    // Test 1 entry
1099    msg.clear()
1100       .repeatedSfixed64 = new long[] { 123 };
1101    assertEquals(1, msg.repeatedSfixed64.length);
1102    byte [] result = MessageNano.toByteArray(msg);
1103    int msgSerializedSize = msg.getSerializedSize();
1104    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1105    assertTrue(msgSerializedSize == 13);
1106    assertEquals(result.length, msgSerializedSize);
1107    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1108    assertEquals(1, newMsg.repeatedSfixed64.length);
1109    assertEquals(123, newMsg.repeatedSfixed64[0]);
1110
1111    // Test 2 entries
1112    msg.clear()
1113       .repeatedSfixed64 = new long[] { 123, 456 };
1114    assertEquals(2, msg.repeatedSfixed64.length);
1115    result = MessageNano.toByteArray(msg);
1116    msgSerializedSize = msg.getSerializedSize();
1117    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1118    assertTrue(msgSerializedSize == 23);
1119    assertEquals(result.length, msgSerializedSize);
1120
1121    newMsg = TestAllTypesNano.parseFrom(result);
1122    assertEquals(2, newMsg.repeatedSfixed64.length);
1123    assertEquals(123, newMsg.repeatedSfixed64[0]);
1124    assertEquals(456, newMsg.repeatedSfixed64[1]);
1125  }
1126
1127  public void testNanoRepeatedFloat() throws Exception {
1128    TestAllTypesNano msg = new TestAllTypesNano();
1129    assertEquals(0, msg.repeatedFloat.length);
1130    msg.repeatedFloat = new float[] { 123f, 789f, 456f };
1131    assertEquals(789f, msg.repeatedFloat[1]);
1132    assertEquals(456f, msg.repeatedFloat[2]);
1133    msg.clear();
1134    assertEquals(0, msg.repeatedFloat.length);
1135    msg.clear()
1136       .repeatedFloat = new float[] { 456f };
1137    assertEquals(1, msg.repeatedFloat.length);
1138    assertEquals(456f, msg.repeatedFloat[0]);
1139    msg.clear();
1140    assertEquals(0, msg.repeatedFloat.length);
1141
1142    // Test 1 entry
1143    msg.clear()
1144       .repeatedFloat = new float[] { 123f };
1145    assertEquals(1, msg.repeatedFloat.length);
1146    byte [] result = MessageNano.toByteArray(msg);
1147    int msgSerializedSize = msg.getSerializedSize();
1148    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1149    assertTrue(msgSerializedSize == 9);
1150    assertEquals(result.length, msgSerializedSize);
1151    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1152    assertEquals(1, newMsg.repeatedFloat.length);
1153    assertEquals(123f, newMsg.repeatedFloat[0]);
1154
1155    // Test 2 entries
1156    msg.clear()
1157       .repeatedFloat = new float[] { 123f, 456f };
1158    assertEquals(2, msg.repeatedFloat.length);
1159    result = MessageNano.toByteArray(msg);
1160    msgSerializedSize = msg.getSerializedSize();
1161    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1162    assertTrue(msgSerializedSize == 15);
1163    assertEquals(result.length, msgSerializedSize);
1164
1165    newMsg = TestAllTypesNano.parseFrom(result);
1166    assertEquals(2, newMsg.repeatedFloat.length);
1167    assertEquals(123f, newMsg.repeatedFloat[0]);
1168    assertEquals(456f, newMsg.repeatedFloat[1]);
1169  }
1170
1171  public void testNanoRepeatedDouble() throws Exception {
1172    TestAllTypesNano msg = new TestAllTypesNano();
1173    assertEquals(0, msg.repeatedDouble.length);
1174    msg.repeatedDouble = new double[] { 123.0, 789.0, 456.0 };
1175    assertEquals(789.0, msg.repeatedDouble[1]);
1176    assertEquals(456.0, msg.repeatedDouble[2]);
1177    msg.clear();
1178    assertEquals(0, msg.repeatedDouble.length);
1179    msg.clear()
1180       .repeatedDouble = new double[] { 456.0 };
1181    assertEquals(1, msg.repeatedDouble.length);
1182    assertEquals(456.0, msg.repeatedDouble[0]);
1183    msg.clear();
1184    assertEquals(0, msg.repeatedDouble.length);
1185
1186    // Test 1 entry
1187    msg.clear()
1188       .repeatedDouble = new double[] { 123.0 };
1189    assertEquals(1, msg.repeatedDouble.length);
1190    byte [] result = MessageNano.toByteArray(msg);
1191    int msgSerializedSize = msg.getSerializedSize();
1192    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1193    assertTrue(msgSerializedSize == 13);
1194    assertEquals(result.length, msgSerializedSize);
1195    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1196    assertEquals(1, newMsg.repeatedDouble.length);
1197    assertEquals(123.0, newMsg.repeatedDouble[0]);
1198
1199    // Test 2 entries
1200    msg.clear()
1201       .repeatedDouble = new double[] { 123.0, 456.0 };
1202    assertEquals(2, msg.repeatedDouble.length);
1203    result = MessageNano.toByteArray(msg);
1204    msgSerializedSize = msg.getSerializedSize();
1205    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1206    assertTrue(msgSerializedSize == 23);
1207    assertEquals(result.length, msgSerializedSize);
1208
1209    newMsg = TestAllTypesNano.parseFrom(result);
1210    assertEquals(2, newMsg.repeatedDouble.length);
1211    assertEquals(123.0, newMsg.repeatedDouble[0]);
1212    assertEquals(456.0, newMsg.repeatedDouble[1]);
1213  }
1214
1215  public void testNanoRepeatedBool() throws Exception {
1216    TestAllTypesNano msg = new TestAllTypesNano();
1217    assertEquals(0, msg.repeatedBool.length);
1218    msg.repeatedBool = new boolean[] { false, true, false };
1219    assertTrue(msg.repeatedBool[1]);
1220    assertFalse(msg.repeatedBool[2]);
1221    msg.clear();
1222    assertEquals(0, msg.repeatedBool.length);
1223    msg.clear()
1224       .repeatedBool = new boolean[] { true };
1225    assertEquals(1, msg.repeatedBool.length);
1226    assertTrue(msg.repeatedBool[0]);
1227    msg.clear();
1228    assertEquals(0, msg.repeatedBool.length);
1229
1230    // Test 1 entry
1231    msg.clear()
1232       .repeatedBool = new boolean[] { false };
1233    assertEquals(1, msg.repeatedBool.length);
1234    byte [] result = MessageNano.toByteArray(msg);
1235    int msgSerializedSize = msg.getSerializedSize();
1236    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1237    assertTrue(msgSerializedSize == 6);
1238    assertEquals(result.length, msgSerializedSize);
1239    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1240    assertEquals(1, newMsg.repeatedBool.length);
1241    assertFalse(newMsg.repeatedBool[0]);
1242
1243    // Test 2 entries
1244    msg.clear()
1245       .repeatedBool = new boolean[] { true, false };
1246    assertEquals(2, msg.repeatedBool.length);
1247    result = MessageNano.toByteArray(msg);
1248    msgSerializedSize = msg.getSerializedSize();
1249    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1250    assertTrue(msgSerializedSize == 9);
1251    assertEquals(result.length, msgSerializedSize);
1252
1253    newMsg = TestAllTypesNano.parseFrom(result);
1254    assertEquals(2, newMsg.repeatedBool.length);
1255    assertTrue(newMsg.repeatedBool[0]);
1256    assertFalse(newMsg.repeatedBool[1]);
1257  }
1258
1259  public void testNanoRepeatedString() throws Exception {
1260    TestAllTypesNano msg = new TestAllTypesNano();
1261    assertEquals(0, msg.repeatedString.length);
1262    msg.repeatedString = new String[] { "hello", "bye", "boo" };
1263    assertEquals("bye", msg.repeatedString[1]);
1264    assertEquals("boo", msg.repeatedString[2]);
1265    msg.clear();
1266    assertEquals(0, msg.repeatedString.length);
1267    msg.clear()
1268       .repeatedString = new String[] { "boo" };
1269    assertEquals(1, msg.repeatedString.length);
1270    assertEquals("boo", msg.repeatedString[0]);
1271    msg.clear();
1272    assertEquals(0, msg.repeatedString.length);
1273
1274    // Test 1 entry
1275    msg.clear()
1276       .repeatedString = new String[] { "" };
1277    assertEquals(1, msg.repeatedString.length);
1278    byte [] result = MessageNano.toByteArray(msg);
1279    int msgSerializedSize = msg.getSerializedSize();
1280    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1281    assertTrue(msgSerializedSize == 6);
1282    assertEquals(result.length, msgSerializedSize);
1283    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1284    assertEquals(1, newMsg.repeatedString.length);
1285    assertTrue(newMsg.repeatedString[0].isEmpty());
1286
1287    // Test 2 entries
1288    msg.clear()
1289       .repeatedString = new String[] { "hello", "world" };
1290    assertEquals(2, msg.repeatedString.length);
1291    result = MessageNano.toByteArray(msg);
1292    msgSerializedSize = msg.getSerializedSize();
1293    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1294    assertTrue(msgSerializedSize == 19);
1295    assertEquals(result.length, msgSerializedSize);
1296
1297    newMsg = TestAllTypesNano.parseFrom(result);
1298    assertEquals(2, newMsg.repeatedString.length);
1299    assertEquals("hello", newMsg.repeatedString[0]);
1300    assertEquals("world", newMsg.repeatedString[1]);
1301  }
1302
1303  public void testNanoRepeatedBytes() throws Exception {
1304    TestAllTypesNano msg = new TestAllTypesNano();
1305    assertEquals(0, msg.repeatedBytes.length);
1306    msg.repeatedBytes = new byte[][] {
1307        InternalNano.copyFromUtf8("hello"),
1308        InternalNano.copyFromUtf8("bye"),
1309        InternalNano.copyFromUtf8("boo")
1310    };
1311    assertEquals("bye", new String(msg.repeatedBytes[1], "UTF-8"));
1312    assertEquals("boo", new String(msg.repeatedBytes[2], "UTF-8"));
1313    msg.clear();
1314    assertEquals(0, msg.repeatedBytes.length);
1315    msg.clear()
1316       .repeatedBytes = new byte[][] { InternalNano.copyFromUtf8("boo") };
1317    assertEquals(1, msg.repeatedBytes.length);
1318    assertEquals("boo", new String(msg.repeatedBytes[0], "UTF-8"));
1319    msg.clear();
1320    assertEquals(0, msg.repeatedBytes.length);
1321
1322    // Test 1 entry
1323    msg.clear()
1324       .repeatedBytes = new byte[][] { InternalNano.copyFromUtf8("") };
1325    assertEquals(1, msg.repeatedBytes.length);
1326    byte [] result = MessageNano.toByteArray(msg);
1327    int msgSerializedSize = msg.getSerializedSize();
1328    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1329    assertTrue(msgSerializedSize == 6);
1330    assertEquals(result.length, msgSerializedSize);
1331    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1332    assertEquals(1, newMsg.repeatedBytes.length);
1333    assertTrue(newMsg.repeatedBytes[0].length == 0);
1334
1335    // Test 2 entries
1336    msg.clear()
1337       .repeatedBytes = new byte[][] {
1338      InternalNano.copyFromUtf8("hello"),
1339      InternalNano.copyFromUtf8("world")
1340    };
1341    assertEquals(2, msg.repeatedBytes.length);
1342    result = MessageNano.toByteArray(msg);
1343    msgSerializedSize = msg.getSerializedSize();
1344    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1345    assertTrue(msgSerializedSize == 19);
1346    assertEquals(result.length, msgSerializedSize);
1347
1348    newMsg = TestAllTypesNano.parseFrom(result);
1349    assertEquals(2, newMsg.repeatedBytes.length);
1350    assertEquals("hello", new String(newMsg.repeatedBytes[0], "UTF-8"));
1351    assertEquals("world", new String(newMsg.repeatedBytes[1], "UTF-8"));
1352  }
1353
1354  public void testNanoRepeatedGroup() throws Exception {
1355    TestAllTypesNano msg = new TestAllTypesNano();
1356    TestAllTypesNano.RepeatedGroup group0 =
1357      new TestAllTypesNano.RepeatedGroup();
1358    group0.a = 0;
1359    TestAllTypesNano.RepeatedGroup group1 =
1360      new TestAllTypesNano.RepeatedGroup();
1361    group1.a = 1;
1362    TestAllTypesNano.RepeatedGroup group2 =
1363      new TestAllTypesNano.RepeatedGroup();
1364    group2.a = 2;
1365
1366    msg.repeatedGroup = new TestAllTypesNano.RepeatedGroup[] { group0, group1, group2 };
1367    assertEquals(3, msg.repeatedGroup.length);
1368    assertEquals(0, msg.repeatedGroup[0].a);
1369    assertEquals(1, msg.repeatedGroup[1].a);
1370    assertEquals(2, msg.repeatedGroup[2].a);
1371    msg.clear();
1372    assertEquals(0, msg.repeatedGroup.length);
1373    msg.clear()
1374       .repeatedGroup = new TestAllTypesNano.RepeatedGroup[] { group1 };
1375    assertEquals(1, msg.repeatedGroup.length);
1376    assertEquals(1, msg.repeatedGroup[0].a);
1377    msg.clear();
1378    assertEquals(0, msg.repeatedGroup.length);
1379
1380    // Test 1 entry
1381    msg.clear()
1382       .repeatedGroup = new TestAllTypesNano.RepeatedGroup[] { group0 };
1383    assertEquals(1, msg.repeatedGroup.length);
1384    byte [] result = MessageNano.toByteArray(msg);
1385    int msgSerializedSize = msg.getSerializedSize();
1386    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1387    assertTrue(msgSerializedSize == 7);
1388    assertEquals(result.length, msgSerializedSize);
1389    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1390    assertEquals(1, newMsg.repeatedGroup.length);
1391    assertEquals(0, newMsg.repeatedGroup[0].a);
1392
1393    // Test 2 entries
1394    msg.clear()
1395       .repeatedGroup = new TestAllTypesNano.RepeatedGroup[] { group0, group1 };
1396    assertEquals(2, msg.repeatedGroup.length);
1397    result = MessageNano.toByteArray(msg);
1398    msgSerializedSize = msg.getSerializedSize();
1399    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1400    assertTrue(msgSerializedSize == 14);
1401    assertEquals(result.length, msgSerializedSize);
1402
1403    newMsg = TestAllTypesNano.parseFrom(result);
1404    assertEquals(2, newMsg.repeatedGroup.length);
1405    assertEquals(0, newMsg.repeatedGroup[0].a);
1406    assertEquals(1, newMsg.repeatedGroup[1].a);
1407  }
1408
1409  public void testNanoRepeatedNestedMessage() throws Exception {
1410    TestAllTypesNano msg = new TestAllTypesNano();
1411    TestAllTypesNano.NestedMessage nestedMsg0 =
1412      new TestAllTypesNano.NestedMessage();
1413    nestedMsg0.bb = 0;
1414    TestAllTypesNano.NestedMessage nestedMsg1 =
1415      new TestAllTypesNano.NestedMessage();
1416    nestedMsg1.bb = 1;
1417    TestAllTypesNano.NestedMessage nestedMsg2 =
1418      new TestAllTypesNano.NestedMessage();
1419    nestedMsg2.bb = 2;
1420
1421    msg.repeatedNestedMessage =
1422        new TestAllTypesNano.NestedMessage[] { nestedMsg0, nestedMsg1, nestedMsg2 };
1423    assertEquals(3, msg.repeatedNestedMessage.length);
1424    assertEquals(0, msg.repeatedNestedMessage[0].bb);
1425    assertEquals(1, msg.repeatedNestedMessage[1].bb);
1426    assertEquals(2, msg.repeatedNestedMessage[2].bb);
1427    msg.clear();
1428    assertEquals(0, msg.repeatedNestedMessage.length);
1429    msg.clear()
1430       .repeatedNestedMessage = new TestAllTypesNano.NestedMessage[] { nestedMsg1 };
1431    assertEquals(1, msg.repeatedNestedMessage.length);
1432    assertEquals(1, msg.repeatedNestedMessage[0].bb);
1433    msg.clear();
1434    assertEquals(0, msg.repeatedNestedMessage.length);
1435
1436    // Test 1 entry
1437    msg.clear()
1438       .repeatedNestedMessage = new TestAllTypesNano.NestedMessage[] { nestedMsg0 };
1439    assertEquals(1, msg.repeatedNestedMessage.length);
1440    byte [] result = MessageNano.toByteArray(msg);
1441    int msgSerializedSize = msg.getSerializedSize();
1442    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1443    assertTrue(msgSerializedSize == 6);
1444    assertEquals(result.length, msgSerializedSize);
1445    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1446    assertEquals(1, newMsg.repeatedNestedMessage.length);
1447    assertEquals(0, newMsg.repeatedNestedMessage[0].bb);
1448
1449    // Test 2 entries
1450    msg.clear()
1451       .repeatedNestedMessage = new TestAllTypesNano.NestedMessage[] { nestedMsg0, nestedMsg1 };
1452    assertEquals(2, msg.repeatedNestedMessage.length);
1453    result = MessageNano.toByteArray(msg);
1454    msgSerializedSize = msg.getSerializedSize();
1455    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1456    assertTrue(msgSerializedSize == 11);
1457    assertEquals(result.length, msgSerializedSize);
1458
1459    newMsg = TestAllTypesNano.parseFrom(result);
1460    assertEquals(2, newMsg.repeatedNestedMessage.length);
1461    assertEquals(0, newMsg.repeatedNestedMessage[0].bb);
1462    assertEquals(1, newMsg.repeatedNestedMessage[1].bb);
1463  }
1464
1465  public void testNanoRepeatedForeignMessage() throws Exception {
1466    TestAllTypesNano msg = new TestAllTypesNano();
1467    NanoOuterClass.ForeignMessageNano foreignMsg0 =
1468      new NanoOuterClass.ForeignMessageNano();
1469    foreignMsg0.c = 0;
1470    NanoOuterClass.ForeignMessageNano foreignMsg1 =
1471      new NanoOuterClass.ForeignMessageNano();
1472    foreignMsg1.c = 1;
1473    NanoOuterClass.ForeignMessageNano foreignMsg2 =
1474      new NanoOuterClass.ForeignMessageNano();
1475    foreignMsg2.c = 2;
1476
1477    msg.repeatedForeignMessage =
1478        new NanoOuterClass.ForeignMessageNano[] { foreignMsg0, foreignMsg1, foreignMsg2 };
1479    assertEquals(3, msg.repeatedForeignMessage.length);
1480    assertEquals(0, msg.repeatedForeignMessage[0].c);
1481    assertEquals(1, msg.repeatedForeignMessage[1].c);
1482    assertEquals(2, msg.repeatedForeignMessage[2].c);
1483    msg.clear();
1484    assertEquals(0, msg.repeatedForeignMessage.length);
1485    msg.clear()
1486       .repeatedForeignMessage = new NanoOuterClass.ForeignMessageNano[] { foreignMsg1 };
1487    assertEquals(1, msg.repeatedForeignMessage.length);
1488    assertEquals(1, msg.repeatedForeignMessage[0].c);
1489    msg.clear();
1490    assertEquals(0, msg.repeatedForeignMessage.length);
1491
1492    // Test 1 entry
1493    msg.clear()
1494       .repeatedForeignMessage = new NanoOuterClass.ForeignMessageNano[] { foreignMsg0 };
1495    assertEquals(1, msg.repeatedForeignMessage.length);
1496    byte [] result = MessageNano.toByteArray(msg);
1497    int msgSerializedSize = msg.getSerializedSize();
1498    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1499    assertTrue(msgSerializedSize == 6);
1500    assertEquals(result.length, msgSerializedSize);
1501    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1502    assertEquals(1, newMsg.repeatedForeignMessage.length);
1503    assertEquals(0, newMsg.repeatedForeignMessage[0].c);
1504
1505    // Test 2 entries
1506    msg.clear()
1507       .repeatedForeignMessage = new NanoOuterClass.ForeignMessageNano[] { foreignMsg0, foreignMsg1 };
1508    assertEquals(2, msg.repeatedForeignMessage.length);
1509    result = MessageNano.toByteArray(msg);
1510    msgSerializedSize = msg.getSerializedSize();
1511    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1512    assertTrue(msgSerializedSize == 11);
1513    assertEquals(result.length, msgSerializedSize);
1514
1515    newMsg = TestAllTypesNano.parseFrom(result);
1516    assertEquals(2, newMsg.repeatedForeignMessage.length);
1517    assertEquals(0, newMsg.repeatedForeignMessage[0].c);
1518    assertEquals(1, newMsg.repeatedForeignMessage[1].c);
1519  }
1520
1521  public void testNanoRepeatedImportMessage() throws Exception {
1522    TestAllTypesNano msg = new TestAllTypesNano();
1523    UnittestImportNano.ImportMessageNano foreignMsg0 =
1524      new UnittestImportNano.ImportMessageNano();
1525    foreignMsg0.d = 0;
1526    UnittestImportNano.ImportMessageNano foreignMsg1 =
1527      new UnittestImportNano.ImportMessageNano();
1528    foreignMsg1.d = 1;
1529    UnittestImportNano.ImportMessageNano foreignMsg2 =
1530      new UnittestImportNano.ImportMessageNano();
1531    foreignMsg2.d = 2;
1532
1533    msg.repeatedImportMessage =
1534        new UnittestImportNano.ImportMessageNano[] { foreignMsg0, foreignMsg1, foreignMsg2 };
1535    assertEquals(3, msg.repeatedImportMessage.length);
1536    assertEquals(0, msg.repeatedImportMessage[0].d);
1537    assertEquals(1, msg.repeatedImportMessage[1].d);
1538    assertEquals(2, msg.repeatedImportMessage[2].d);
1539    msg.clear();
1540    assertEquals(0, msg.repeatedImportMessage.length);
1541    msg.clear()
1542       .repeatedImportMessage = new UnittestImportNano.ImportMessageNano[] { foreignMsg1 };
1543    assertEquals(1, msg.repeatedImportMessage.length);
1544    assertEquals(1, msg.repeatedImportMessage[0].d);
1545    msg.clear();
1546    assertEquals(0, msg.repeatedImportMessage.length);
1547
1548    // Test 1 entry
1549    msg.clear()
1550       .repeatedImportMessage = new UnittestImportNano.ImportMessageNano[] { foreignMsg0 };
1551    assertEquals(1, msg.repeatedImportMessage.length);
1552    byte [] result = MessageNano.toByteArray(msg);
1553    int msgSerializedSize = msg.getSerializedSize();
1554    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1555    assertTrue(msgSerializedSize == 6);
1556    assertEquals(result.length, msgSerializedSize);
1557    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1558    assertEquals(1, newMsg.repeatedImportMessage.length);
1559    assertEquals(0, newMsg.repeatedImportMessage[0].d);
1560
1561    // Test 2 entries
1562    msg.clear()
1563       .repeatedImportMessage = new UnittestImportNano.ImportMessageNano[] { foreignMsg0, foreignMsg1 };
1564    assertEquals(2, msg.repeatedImportMessage.length);
1565    result = MessageNano.toByteArray(msg);
1566    msgSerializedSize = msg.getSerializedSize();
1567    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1568    assertTrue(msgSerializedSize == 11);
1569    assertEquals(result.length, msgSerializedSize);
1570
1571    newMsg = TestAllTypesNano.parseFrom(result);
1572    assertEquals(2, newMsg.repeatedImportMessage.length);
1573    assertEquals(0, newMsg.repeatedImportMessage[0].d);
1574    assertEquals(1, newMsg.repeatedImportMessage[1].d);
1575  }
1576
1577  public void testNanoRepeatedNestedEnum() throws Exception {
1578    TestAllTypesNano msg = new TestAllTypesNano();
1579    msg.repeatedNestedEnum = new int[] {
1580        TestAllTypesNano.FOO,
1581        TestAllTypesNano.BAR,
1582        TestAllTypesNano.BAZ
1583    };
1584    assertEquals(3, msg.repeatedNestedEnum.length);
1585    assertEquals(TestAllTypesNano.FOO, msg.repeatedNestedEnum[0]);
1586    assertEquals(TestAllTypesNano.BAR, msg.repeatedNestedEnum[1]);
1587    assertEquals(TestAllTypesNano.BAZ, msg.repeatedNestedEnum[2]);
1588    msg.clear();
1589    assertEquals(0, msg.repeatedNestedEnum.length);
1590    msg.clear()
1591       .repeatedNestedEnum = new int[] { TestAllTypesNano.BAR };
1592    assertEquals(1, msg.repeatedNestedEnum.length);
1593    assertEquals(TestAllTypesNano.BAR, msg.repeatedNestedEnum[0]);
1594    msg.clear();
1595    assertEquals(0, msg.repeatedNestedEnum.length);
1596
1597    // Test 1 entry
1598    msg.clear()
1599       .repeatedNestedEnum = new int[] { TestAllTypesNano.FOO };
1600    byte [] result = MessageNano.toByteArray(msg);
1601    int msgSerializedSize = msg.getSerializedSize();
1602    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1603    assertTrue(msgSerializedSize == 6);
1604    assertEquals(result.length, msgSerializedSize);
1605    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1606    assertEquals(1, newMsg.repeatedNestedEnum.length);
1607    assertEquals(TestAllTypesNano.FOO, msg.repeatedNestedEnum[0]);
1608
1609    // Test 2 entries
1610    msg.clear()
1611       .repeatedNestedEnum = new int[] { TestAllTypesNano.FOO, TestAllTypesNano.BAR };
1612    assertEquals(2, msg.repeatedNestedEnum.length);
1613    result = MessageNano.toByteArray(msg);
1614    msgSerializedSize = msg.getSerializedSize();
1615    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1616    assertTrue(msgSerializedSize == 9);
1617    assertEquals(result.length, msgSerializedSize);
1618
1619    newMsg = TestAllTypesNano.parseFrom(result);
1620    assertEquals(2, newMsg.repeatedNestedEnum.length);
1621    assertEquals(TestAllTypesNano.FOO, msg.repeatedNestedEnum[0]);
1622    assertEquals(TestAllTypesNano.BAR, msg.repeatedNestedEnum[1]);
1623  }
1624
1625  public void testNanoRepeatedForeignEnum() throws Exception {
1626    TestAllTypesNano msg = new TestAllTypesNano();
1627    msg.repeatedForeignEnum = new int[] {
1628        NanoOuterClass.FOREIGN_NANO_FOO,
1629        NanoOuterClass.FOREIGN_NANO_BAR,
1630        NanoOuterClass.FOREIGN_NANO_BAZ
1631    };
1632    assertEquals(3, msg.repeatedForeignEnum.length);
1633    assertEquals(NanoOuterClass.FOREIGN_NANO_FOO, msg.repeatedForeignEnum[0]);
1634    assertEquals(NanoOuterClass.FOREIGN_NANO_BAR, msg.repeatedForeignEnum[1]);
1635    assertEquals(NanoOuterClass.FOREIGN_NANO_BAZ, msg.repeatedForeignEnum[2]);
1636    msg.clear();
1637    assertEquals(0, msg.repeatedForeignEnum.length);
1638    msg.clear()
1639       .repeatedForeignEnum = new int[] { NanoOuterClass.FOREIGN_NANO_BAR };
1640    assertEquals(1, msg.repeatedForeignEnum.length);
1641    assertEquals(NanoOuterClass.FOREIGN_NANO_BAR, msg.repeatedForeignEnum[0]);
1642    msg.clear();
1643    assertEquals(0, msg.repeatedForeignEnum.length);
1644
1645    // Test 1 entry
1646    msg.clear()
1647       .repeatedForeignEnum = new int[] { NanoOuterClass.FOREIGN_NANO_FOO };
1648    byte [] result = MessageNano.toByteArray(msg);
1649    int msgSerializedSize = msg.getSerializedSize();
1650    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1651    assertTrue(msgSerializedSize == 6);
1652    assertEquals(result.length, msgSerializedSize);
1653    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1654    assertEquals(1, newMsg.repeatedForeignEnum.length);
1655    assertEquals(NanoOuterClass.FOREIGN_NANO_FOO, msg.repeatedForeignEnum[0]);
1656
1657    // Test 2 entries
1658    msg.clear()
1659       .repeatedForeignEnum = new int[] {
1660      NanoOuterClass.FOREIGN_NANO_FOO,
1661      NanoOuterClass.FOREIGN_NANO_BAR
1662    };
1663    assertEquals(2, msg.repeatedForeignEnum.length);
1664    result = MessageNano.toByteArray(msg);
1665    msgSerializedSize = msg.getSerializedSize();
1666    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1667    assertTrue(msgSerializedSize == 9);
1668    assertEquals(result.length, msgSerializedSize);
1669
1670    newMsg = TestAllTypesNano.parseFrom(result);
1671    assertEquals(2, newMsg.repeatedForeignEnum.length);
1672    assertEquals(NanoOuterClass.FOREIGN_NANO_FOO, msg.repeatedForeignEnum[0]);
1673    assertEquals(NanoOuterClass.FOREIGN_NANO_BAR, msg.repeatedForeignEnum[1]);
1674  }
1675
1676  public void testNanoRepeatedImportEnum() throws Exception {
1677    TestAllTypesNano msg = new TestAllTypesNano();
1678    msg.repeatedImportEnum = new int[] {
1679        UnittestImportNano.IMPORT_NANO_FOO,
1680        UnittestImportNano.IMPORT_NANO_BAR,
1681        UnittestImportNano.IMPORT_NANO_BAZ
1682    };
1683    assertEquals(3, msg.repeatedImportEnum.length);
1684    assertEquals(UnittestImportNano.IMPORT_NANO_FOO, msg.repeatedImportEnum[0]);
1685    assertEquals(UnittestImportNano.IMPORT_NANO_BAR, msg.repeatedImportEnum[1]);
1686    assertEquals(UnittestImportNano.IMPORT_NANO_BAZ, msg.repeatedImportEnum[2]);
1687    msg.clear();
1688    assertEquals(0, msg.repeatedImportEnum.length);
1689    msg.clear()
1690       .repeatedImportEnum = new int[] { UnittestImportNano.IMPORT_NANO_BAR };
1691    assertEquals(1, msg.repeatedImportEnum.length);
1692    assertEquals(UnittestImportNano.IMPORT_NANO_BAR, msg.repeatedImportEnum[0]);
1693    msg.clear();
1694    assertEquals(0, msg.repeatedImportEnum.length);
1695
1696    // Test 1 entry
1697    msg.clear()
1698       .repeatedImportEnum = new int[] { UnittestImportNano.IMPORT_NANO_FOO };
1699    byte [] result = MessageNano.toByteArray(msg);
1700    int msgSerializedSize = msg.getSerializedSize();
1701    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1702    assertTrue(msgSerializedSize == 6);
1703    assertEquals(result.length, msgSerializedSize);
1704    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1705    assertEquals(1, newMsg.repeatedImportEnum.length);
1706    assertEquals(UnittestImportNano.IMPORT_NANO_FOO, msg.repeatedImportEnum[0]);
1707
1708    // Test 2 entries
1709    msg.clear()
1710       .repeatedImportEnum = new int[] {
1711      UnittestImportNano.IMPORT_NANO_FOO,
1712      UnittestImportNano.IMPORT_NANO_BAR
1713    };
1714    assertEquals(2, msg.repeatedImportEnum.length);
1715    result = MessageNano.toByteArray(msg);
1716    msgSerializedSize = msg.getSerializedSize();
1717    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1718    assertTrue(msgSerializedSize == 9);
1719    assertEquals(result.length, msgSerializedSize);
1720
1721    newMsg = TestAllTypesNano.parseFrom(result);
1722    assertEquals(2, newMsg.repeatedImportEnum.length);
1723    assertEquals(UnittestImportNano.IMPORT_NANO_FOO, msg.repeatedImportEnum[0]);
1724    assertEquals(UnittestImportNano.IMPORT_NANO_BAR, msg.repeatedImportEnum[1]);
1725  }
1726
1727  public void testNanoRepeatedStringPiece() throws Exception {
1728    TestAllTypesNano msg = new TestAllTypesNano();
1729    assertEquals(0, msg.repeatedStringPiece.length);
1730    msg.repeatedStringPiece = new String[] { "hello", "bye", "boo" };
1731    assertEquals("bye", msg.repeatedStringPiece[1]);
1732    assertEquals("boo", msg.repeatedStringPiece[2]);
1733    msg.clear();
1734    assertEquals(0, msg.repeatedStringPiece.length);
1735    msg.clear()
1736       .repeatedStringPiece = new String[] { "boo" };
1737    assertEquals(1, msg.repeatedStringPiece.length);
1738    assertEquals("boo", msg.repeatedStringPiece[0]);
1739    msg.clear();
1740    assertEquals(0, msg.repeatedStringPiece.length);
1741
1742    // Test 1 entry
1743    msg.clear()
1744       .repeatedStringPiece = new String[] { "" };
1745    assertEquals(1, msg.repeatedStringPiece.length);
1746    byte [] result = MessageNano.toByteArray(msg);
1747    int msgSerializedSize = msg.getSerializedSize();
1748    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1749    assertTrue(msgSerializedSize == 6);
1750    assertEquals(result.length, msgSerializedSize);
1751    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1752    assertEquals(1, newMsg.repeatedStringPiece.length);
1753    assertTrue(newMsg.repeatedStringPiece[0].isEmpty());
1754
1755    // Test 2 entries
1756    msg.clear()
1757       .repeatedStringPiece = new String[] { "hello", "world" };
1758    assertEquals(2, msg.repeatedStringPiece.length);
1759    result = MessageNano.toByteArray(msg);
1760    msgSerializedSize = msg.getSerializedSize();
1761    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1762    assertTrue(msgSerializedSize == 19);
1763    assertEquals(result.length, msgSerializedSize);
1764
1765    newMsg = TestAllTypesNano.parseFrom(result);
1766    assertEquals(2, newMsg.repeatedStringPiece.length);
1767    assertEquals("hello", newMsg.repeatedStringPiece[0]);
1768    assertEquals("world", newMsg.repeatedStringPiece[1]);
1769  }
1770
1771  public void testNanoRepeatedCord() throws Exception {
1772    TestAllTypesNano msg = new TestAllTypesNano();
1773    assertEquals(0, msg.repeatedCord.length);
1774    msg.repeatedCord = new String[] { "hello", "bye", "boo" };
1775    assertEquals("bye", msg.repeatedCord[1]);
1776    assertEquals("boo", msg.repeatedCord[2]);
1777    msg.clear();
1778    assertEquals(0, msg.repeatedCord.length);
1779    msg.clear()
1780       .repeatedCord = new String[] { "boo" };
1781    assertEquals(1, msg.repeatedCord.length);
1782    assertEquals("boo", msg.repeatedCord[0]);
1783    msg.clear();
1784    assertEquals(0, msg.repeatedCord.length);
1785
1786    // Test 1 entry
1787    msg.clear()
1788       .repeatedCord = new String[] { "" };
1789    assertEquals(1, msg.repeatedCord.length);
1790    byte [] result = MessageNano.toByteArray(msg);
1791    int msgSerializedSize = msg.getSerializedSize();
1792    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1793    assertTrue(msgSerializedSize == 6);
1794    assertEquals(result.length, msgSerializedSize);
1795    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1796    assertEquals(1, newMsg.repeatedCord.length);
1797    assertTrue(newMsg.repeatedCord[0].isEmpty());
1798
1799    // Test 2 entries
1800    msg.clear()
1801       .repeatedCord = new String[] { "hello", "world" };
1802    assertEquals(2, msg.repeatedCord.length);
1803    result = MessageNano.toByteArray(msg);
1804    msgSerializedSize = msg.getSerializedSize();
1805    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1806    assertTrue(msgSerializedSize == 19);
1807    assertEquals(result.length, msgSerializedSize);
1808
1809    newMsg = TestAllTypesNano.parseFrom(result);
1810    assertEquals(2, newMsg.repeatedCord.length);
1811    assertEquals("hello", newMsg.repeatedCord[0]);
1812    assertEquals("world", newMsg.repeatedCord[1]);
1813  }
1814
1815  public void testNanoRepeatedPackedInt32() throws Exception {
1816    TestAllTypesNano msg = new TestAllTypesNano();
1817    assertEquals(0, msg.repeatedPackedInt32.length);
1818    msg.repeatedPackedInt32 = new int[] { 123, 789, 456 };
1819    assertEquals(789, msg.repeatedPackedInt32[1]);
1820    assertEquals(456, msg.repeatedPackedInt32[2]);
1821    msg.clear();
1822    assertEquals(0, msg.repeatedPackedInt32.length);
1823    msg.clear()
1824       .repeatedPackedInt32 = new int[] { 456 };
1825    assertEquals(1, msg.repeatedPackedInt32.length);
1826    assertEquals(456, msg.repeatedPackedInt32[0]);
1827    msg.clear();
1828    assertEquals(0, msg.repeatedPackedInt32.length);
1829
1830    // Test 1 entry
1831    msg.clear()
1832       .repeatedPackedInt32 = new int[] { 123 };
1833    assertEquals(1, msg.repeatedPackedInt32.length);
1834    byte [] result = MessageNano.toByteArray(msg);
1835    int msgSerializedSize = msg.getSerializedSize();
1836    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1837    assertTrue(msgSerializedSize == 7);
1838    assertEquals(result.length, msgSerializedSize);
1839    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1840    assertEquals(1, newMsg.repeatedPackedInt32.length);
1841    assertEquals(123, newMsg.repeatedPackedInt32[0]);
1842
1843    // Test 2 entries
1844    msg.clear()
1845       .repeatedPackedInt32 = new int[] { 123, 456 };
1846    assertEquals(2, msg.repeatedPackedInt32.length);
1847    result = MessageNano.toByteArray(msg);
1848    msgSerializedSize = msg.getSerializedSize();
1849    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1850    assertTrue(msgSerializedSize == 9);
1851    assertEquals(result.length, msgSerializedSize);
1852
1853    newMsg = TestAllTypesNano.parseFrom(result);
1854    assertEquals(2, newMsg.repeatedPackedInt32.length);
1855    assertEquals(123, newMsg.repeatedPackedInt32[0]);
1856    assertEquals(456, newMsg.repeatedPackedInt32[1]);
1857  }
1858
1859  public void testNanoRepeatedPackedSfixed64() throws Exception {
1860    TestAllTypesNano msg = new TestAllTypesNano();
1861    assertEquals(0, msg.repeatedPackedSfixed64.length);
1862    msg.repeatedPackedSfixed64 = new long[] { 123, 789, 456 };
1863    assertEquals(789, msg.repeatedPackedSfixed64[1]);
1864    assertEquals(456, msg.repeatedPackedSfixed64[2]);
1865    msg.clear();
1866    assertEquals(0, msg.repeatedPackedSfixed64.length);
1867    msg.clear()
1868       .repeatedPackedSfixed64 = new long[] { 456 };
1869    assertEquals(1, msg.repeatedPackedSfixed64.length);
1870    assertEquals(456, msg.repeatedPackedSfixed64[0]);
1871    msg.clear();
1872    assertEquals(0, msg.repeatedPackedSfixed64.length);
1873
1874    // Test 1 entry
1875    msg.clear()
1876       .repeatedPackedSfixed64 = new long[] { 123 };
1877    assertEquals(1, msg.repeatedPackedSfixed64.length);
1878    byte [] result = MessageNano.toByteArray(msg);
1879    int msgSerializedSize = msg.getSerializedSize();
1880    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1881    assertTrue(msgSerializedSize == 14);
1882    assertEquals(result.length, msgSerializedSize);
1883    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1884    assertEquals(1, newMsg.repeatedPackedSfixed64.length);
1885    assertEquals(123, newMsg.repeatedPackedSfixed64[0]);
1886
1887    // Test 2 entries
1888    msg.clear()
1889       .repeatedPackedSfixed64 = new long[] { 123, 456 };
1890    assertEquals(2, msg.repeatedPackedSfixed64.length);
1891    result = MessageNano.toByteArray(msg);
1892    msgSerializedSize = msg.getSerializedSize();
1893    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1894    assertTrue(msgSerializedSize == 22);
1895    assertEquals(result.length, msgSerializedSize);
1896
1897    newMsg = TestAllTypesNano.parseFrom(result);
1898    assertEquals(2, newMsg.repeatedPackedSfixed64.length);
1899    assertEquals(123, newMsg.repeatedPackedSfixed64[0]);
1900    assertEquals(456, newMsg.repeatedPackedSfixed64[1]);
1901  }
1902
1903  public void testNanoRepeatedPackedNestedEnum() throws Exception {
1904    TestAllTypesNano msg = new TestAllTypesNano();
1905    msg.repeatedPackedNestedEnum = new int[] {
1906        TestAllTypesNano.FOO,
1907        TestAllTypesNano.BAR,
1908        TestAllTypesNano.BAZ
1909    };
1910    assertEquals(3, msg.repeatedPackedNestedEnum.length);
1911    assertEquals(TestAllTypesNano.FOO, msg.repeatedPackedNestedEnum[0]);
1912    assertEquals(TestAllTypesNano.BAR, msg.repeatedPackedNestedEnum[1]);
1913    assertEquals(TestAllTypesNano.BAZ, msg.repeatedPackedNestedEnum[2]);
1914    msg.clear();
1915    assertEquals(0, msg.repeatedPackedNestedEnum.length);
1916    msg.clear()
1917       .repeatedPackedNestedEnum = new int[] { TestAllTypesNano.BAR };
1918    assertEquals(1, msg.repeatedPackedNestedEnum.length);
1919    assertEquals(TestAllTypesNano.BAR, msg.repeatedPackedNestedEnum[0]);
1920    msg.clear();
1921    assertEquals(0, msg.repeatedPackedNestedEnum.length);
1922
1923    // Test 1 entry
1924    msg.clear()
1925       .repeatedPackedNestedEnum = new int[] { TestAllTypesNano.FOO };
1926    byte [] result = MessageNano.toByteArray(msg);
1927    int msgSerializedSize = msg.getSerializedSize();
1928    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1929    assertTrue(msgSerializedSize == 7);
1930    assertEquals(result.length, msgSerializedSize);
1931    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1932    assertEquals(1, newMsg.repeatedPackedNestedEnum.length);
1933    assertEquals(TestAllTypesNano.FOO, msg.repeatedPackedNestedEnum[0]);
1934
1935    // Test 2 entries
1936    msg.clear()
1937       .repeatedPackedNestedEnum = new int[] { TestAllTypesNano.FOO, TestAllTypesNano.BAR };
1938    assertEquals(2, msg.repeatedPackedNestedEnum.length);
1939    result = MessageNano.toByteArray(msg);
1940    msgSerializedSize = msg.getSerializedSize();
1941    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1942    assertTrue(msgSerializedSize == 8);
1943    assertEquals(result.length, msgSerializedSize);
1944
1945    newMsg = TestAllTypesNano.parseFrom(result);
1946    assertEquals(2, newMsg.repeatedPackedNestedEnum.length);
1947    assertEquals(TestAllTypesNano.FOO, msg.repeatedPackedNestedEnum[0]);
1948    assertEquals(TestAllTypesNano.BAR, msg.repeatedPackedNestedEnum[1]);
1949  }
1950
1951  public void testNanoRepeatedInt32ReMerge() throws Exception {
1952    TestAllTypesNano msg = new TestAllTypesNano();
1953    msg.repeatedInt32 = new int[] { 234 };
1954    byte [] result1 = MessageNano.toByteArray(msg);
1955
1956    msg.clear().optionalInt32 = 789;
1957    byte [] result2 = MessageNano.toByteArray(msg);
1958
1959    msg.clear().repeatedInt32 = new int[] { 123, 456 };
1960    byte [] result3 = MessageNano.toByteArray(msg);
1961
1962    // Concatenate the three serializations and read as one message.
1963    byte [] result = new byte[result1.length + result2.length + result3.length];
1964    System.arraycopy(result1, 0, result, 0, result1.length);
1965    System.arraycopy(result2, 0, result, result1.length, result2.length);
1966    System.arraycopy(result3, 0, result, result1.length + result2.length, result3.length);
1967
1968    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1969    assertEquals(789, newMsg.optionalInt32);
1970    assertEquals(3, newMsg.repeatedInt32.length);
1971    assertEquals(234, newMsg.repeatedInt32[0]);
1972    assertEquals(123, newMsg.repeatedInt32[1]);
1973    assertEquals(456, newMsg.repeatedInt32[2]);
1974  }
1975
1976  public void testNanoRepeatedNestedEnumReMerge() throws Exception {
1977    TestAllTypesNano msg = new TestAllTypesNano();
1978    msg.repeatedNestedEnum = new int[] { TestAllTypesNano.FOO };
1979    byte [] result1 = MessageNano.toByteArray(msg);
1980
1981    msg.clear().optionalInt32 = 789;
1982    byte [] result2 = MessageNano.toByteArray(msg);
1983
1984    msg.clear().repeatedNestedEnum = new int[] { TestAllTypesNano.BAR, TestAllTypesNano.FOO };
1985    byte [] result3 = MessageNano.toByteArray(msg);
1986
1987    // Concatenate the three serializations and read as one message.
1988    byte [] result = new byte[result1.length + result2.length + result3.length];
1989    System.arraycopy(result1, 0, result, 0, result1.length);
1990    System.arraycopy(result2, 0, result, result1.length, result2.length);
1991    System.arraycopy(result3, 0, result, result1.length + result2.length, result3.length);
1992
1993    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
1994    assertEquals(789, newMsg.optionalInt32);
1995    assertEquals(3, newMsg.repeatedNestedEnum.length);
1996    assertEquals(TestAllTypesNano.FOO, newMsg.repeatedNestedEnum[0]);
1997    assertEquals(TestAllTypesNano.BAR, newMsg.repeatedNestedEnum[1]);
1998    assertEquals(TestAllTypesNano.FOO, newMsg.repeatedNestedEnum[2]);
1999  }
2000
2001  public void testNanoRepeatedNestedMessageReMerge() throws Exception {
2002    TestAllTypesNano msg = new TestAllTypesNano();
2003    TestAllTypesNano.NestedMessage nestedMsg0 =
2004      new TestAllTypesNano.NestedMessage();
2005    nestedMsg0.bb = 0;
2006    TestAllTypesNano.NestedMessage nestedMsg1 =
2007      new TestAllTypesNano.NestedMessage();
2008    nestedMsg1.bb = 1;
2009    TestAllTypesNano.NestedMessage nestedMsg2 =
2010      new TestAllTypesNano.NestedMessage();
2011    nestedMsg2.bb = 2;
2012
2013    msg.repeatedNestedMessage = new TestAllTypesNano.NestedMessage[] { nestedMsg0 };
2014    byte [] result1 = MessageNano.toByteArray(msg);
2015
2016    msg.clear().optionalInt32 = 789;
2017    byte [] result2 = MessageNano.toByteArray(msg);
2018
2019    msg.clear().repeatedNestedMessage =
2020        new TestAllTypesNano.NestedMessage[] { nestedMsg1, nestedMsg2 };
2021    byte [] result3 = MessageNano.toByteArray(msg);
2022
2023    // Concatenate the three serializations and read as one message.
2024    byte [] result = new byte[result1.length + result2.length + result3.length];
2025    System.arraycopy(result1, 0, result, 0, result1.length);
2026    System.arraycopy(result2, 0, result, result1.length, result2.length);
2027    System.arraycopy(result3, 0, result, result1.length + result2.length, result3.length);
2028
2029    TestAllTypesNano newMsg = TestAllTypesNano.parseFrom(result);
2030    assertEquals(789, newMsg.optionalInt32);
2031    assertEquals(3, newMsg.repeatedNestedMessage.length);
2032    assertEquals(nestedMsg0.bb, newMsg.repeatedNestedMessage[0].bb);
2033    assertEquals(nestedMsg1.bb, newMsg.repeatedNestedMessage[1].bb);
2034    assertEquals(nestedMsg2.bb, newMsg.repeatedNestedMessage[2].bb);
2035  }
2036
2037  public void testNanoDefaults() throws Exception {
2038    TestAllTypesNano msg = new TestAllTypesNano();
2039    for (int i = 0; i < 2; i++) {
2040      assertEquals(41, msg.defaultInt32);
2041      assertEquals(42, msg.defaultInt64);
2042      assertEquals(43, msg.defaultUint32);
2043      assertEquals(44, msg.defaultUint64);
2044      assertEquals(-45, msg.defaultSint32);
2045      assertEquals(46, msg.defaultSint64);
2046      assertEquals(47, msg.defaultFixed32);
2047      assertEquals(48, msg.defaultFixed64);
2048      assertEquals(49, msg.defaultSfixed32);
2049      assertEquals(-50, msg.defaultSfixed64);
2050      assertTrue(51.5f == msg.defaultFloat);
2051      assertTrue(52.0e3 == msg.defaultDouble);
2052      assertEquals(true, msg.defaultBool);
2053      assertEquals("hello", msg.defaultString);
2054      assertEquals("world", new String(msg.defaultBytes, "UTF-8"));
2055      assertEquals("dünya", msg.defaultStringNonascii);
2056      assertEquals("dünyab", new String(msg.defaultBytesNonascii, "UTF-8"));
2057      assertEquals(TestAllTypesNano.BAR, msg.defaultNestedEnum);
2058      assertEquals(NanoOuterClass.FOREIGN_NANO_BAR, msg.defaultForeignEnum);
2059      assertEquals(UnittestImportNano.IMPORT_NANO_BAR, msg.defaultImportEnum);
2060
2061      // Default values are not output, except for required fields.
2062      byte [] result = MessageNano.toByteArray(msg);
2063      int msgSerializedSize = msg.getSerializedSize();
2064      //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
2065      assertTrue(msgSerializedSize == 3);
2066      assertEquals(result.length, msgSerializedSize);
2067      msg.clear();
2068    }
2069  }
2070
2071  /**
2072   * Test that a bug in skipRawBytes() has been fixed:  if the skip skips
2073   * exactly up to a limit, this should not break things.
2074   */
2075  public void testSkipRawBytesBug() throws Exception {
2076    byte[] rawBytes = new byte[] { 1, 2 };
2077    CodedInputByteBufferNano input = CodedInputByteBufferNano.newInstance(rawBytes);
2078
2079    int limit = input.pushLimit(1);
2080    input.skipRawBytes(1);
2081    input.popLimit(limit);
2082    assertEquals(2, input.readRawByte());
2083  }
2084
2085  /**
2086   * Test that a bug in skipRawBytes() has been fixed:  if the skip skips
2087   * past the end of a buffer with a limit that has been set past the end of
2088   * that buffer, this should not break things.
2089   */
2090  public void testSkipRawBytesPastEndOfBufferWithLimit() throws Exception {
2091    byte[] rawBytes = new byte[] { 1, 2, 3, 4, 5 };
2092    CodedInputByteBufferNano input = CodedInputByteBufferNano.newInstance(rawBytes);
2093
2094    int limit = input.pushLimit(4);
2095    // In order to expose the bug we need to read at least one byte to prime the
2096    // buffer inside the CodedInputStream.
2097    assertEquals(1, input.readRawByte());
2098    // Skip to the end of the limit.
2099    input.skipRawBytes(3);
2100    assertTrue(input.isAtEnd());
2101    input.popLimit(limit);
2102    assertEquals(5, input.readRawByte());
2103  }
2104}
2105