1// Protocol Buffers - Google's data interchange format
2// Copyright 2008 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.micro.ByteStringMicro;
34import com.google.protobuf.micro.CodedInputStreamMicro;
35import com.google.protobuf.micro.FileScopeEnumRefMicro;
36import com.google.protobuf.micro.MessageScopeEnumRefMicro;
37import com.google.protobuf.micro.MicroOuterClass;
38import com.google.protobuf.micro.MicroOuterClass.TestAllTypesMicro;
39import com.google.protobuf.micro.MultipleImportingNonMultipleMicro1;
40import com.google.protobuf.micro.MultipleImportingNonMultipleMicro2;
41import com.google.protobuf.micro.MultipleNameClashMicro;
42import com.google.protobuf.micro.UnittestImportMicro;
43import com.google.protobuf.micro.UnittestMultipleMicro;
44import com.google.protobuf.micro.UnittestRecursiveMicro.RecursiveMessageMicro;
45import com.google.protobuf.micro.UnittestSimpleMicro.SimpleMessageMicro;
46import com.google.protobuf.micro.UnittestSingleMicro.SingleMessageMicro;
47import com.google.protobuf.micro.UnittestStringutf8Micro.StringUtf8;
48
49import junit.framework.TestCase;
50
51import java.io.ByteArrayInputStream;
52import java.io.FilterInputStream;
53import java.io.InputStream;
54import java.io.IOException;
55
56/**
57 * Test micro runtime.
58 *
59 * @author wink@google.com Wink Saville
60 */
61public class MicroTest extends TestCase {
62  public void setUp() throws Exception {
63  }
64
65  public void testSimpleMessageMicro() throws Exception {
66    SimpleMessageMicro msg = new SimpleMessageMicro();
67    assertFalse(msg.hasD());
68    assertEquals(123, msg.getD());
69    assertFalse(msg.hasNestedMsg());
70    assertEquals(null, msg.getNestedMsg());
71    assertFalse(msg.hasDefaultNestedEnum());
72    assertEquals(SimpleMessageMicro.BAZ, msg.getDefaultNestedEnum());
73
74    msg.setD(456);
75    assertTrue(msg.hasD());
76    assertEquals(456, msg.getD());
77    msg.clearD()
78       .setD(456);
79    assertTrue(msg.hasD());
80
81    SimpleMessageMicro.NestedMessage nestedMsg = new SimpleMessageMicro.NestedMessage()
82      .setBb(2);
83    assertTrue(nestedMsg.hasBb());
84    assertEquals(2, nestedMsg.getBb());
85    msg.setNestedMsg(nestedMsg);
86    assertTrue(msg.hasNestedMsg());
87    assertEquals(2, msg.getNestedMsg().getBb());
88
89    msg.setDefaultNestedEnum(SimpleMessageMicro.BAR);
90    assertTrue(msg.hasDefaultNestedEnum());
91    assertEquals(SimpleMessageMicro.BAR, msg.getDefaultNestedEnum());
92
93    byte [] result = msg.toByteArray();
94    int msgSerializedSize = msg.getSerializedSize();
95    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
96    assertTrue(msgSerializedSize == 9);
97    assertEquals(result.length, msgSerializedSize);
98
99    SimpleMessageMicro newMsg = SimpleMessageMicro.parseFrom(result);
100    assertTrue(newMsg.hasD());
101    assertTrue(newMsg.hasNestedMsg());
102    assertTrue(newMsg.hasDefaultNestedEnum());
103    assertEquals(456, newMsg.getD());
104    assertEquals(2, msg.getNestedMsg().getBb());
105    assertEquals(SimpleMessageMicro.BAR, msg.getDefaultNestedEnum());
106  }
107
108  public void testRecursiveMessageMicro() throws Exception {
109    RecursiveMessageMicro msg = new RecursiveMessageMicro();
110    assertFalse(msg.hasId());
111    assertFalse(msg.hasNestedMessage());
112    assertFalse(msg.hasOptionalRecursiveMessageMicro());
113    assertEquals(0, msg.getRepeatedRecursiveMessageMicroCount());
114
115    RecursiveMessageMicro msg1 = new RecursiveMessageMicro();
116    msg1.setId(1);
117    assertEquals(1, msg1.getId());
118    RecursiveMessageMicro msg2 = new RecursiveMessageMicro();
119    msg2.setId(2);
120    RecursiveMessageMicro msg3 = new RecursiveMessageMicro();
121    msg3.setId(3);
122
123    RecursiveMessageMicro.NestedMessage nestedMsg = new RecursiveMessageMicro.NestedMessage();
124    nestedMsg.setA(msg1);
125    assertEquals(1, nestedMsg.getA().getId());
126
127    msg.setId(0);
128    msg.setNestedMessage(nestedMsg);
129    msg.setOptionalRecursiveMessageMicro(msg2);
130    msg.addRepeatedRecursiveMessageMicro(msg3);
131
132    byte [] result = msg.toByteArray();
133    int msgSerializedSize = msg.getSerializedSize();
134    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
135    assertTrue(msgSerializedSize == 16);
136    assertEquals(result.length, msgSerializedSize);
137
138    RecursiveMessageMicro newMsg = RecursiveMessageMicro.parseFrom(result);
139    assertTrue(newMsg.hasId());
140    assertTrue(newMsg.hasNestedMessage());
141    assertTrue(newMsg.hasOptionalRecursiveMessageMicro());
142    assertEquals(1, newMsg.getRepeatedRecursiveMessageMicroCount());
143
144    assertEquals(0, newMsg.getId());
145    assertEquals(1, newMsg.getNestedMessage().getA().getId());
146    assertEquals(2, newMsg.getOptionalRecursiveMessageMicro().getId());
147    assertEquals(3, newMsg.getRepeatedRecursiveMessageMicro(0).getId());
148  }
149
150  public void testMicroRequiredInt32() throws Exception {
151    TestAllTypesMicro msg = new TestAllTypesMicro();
152    assertFalse(msg.hasId());
153    assertFalse(msg.isInitialized());
154    msg.setId(123);
155    assertTrue(msg.hasId());
156    assertTrue(msg.isInitialized());
157    assertEquals(123, msg.getId());
158    msg.clearId();
159    assertFalse(msg.hasId());
160    assertFalse(msg.isInitialized());
161    msg.clearId()
162       .setId(456);
163    assertTrue(msg.hasId());
164    msg.clear();
165    assertFalse(msg.hasId());
166    assertFalse(msg.isInitialized());
167
168    msg.setId(123);
169    byte [] result = msg.toByteArray();
170    int msgSerializedSize = msg.getSerializedSize();
171    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
172    assertTrue(msgSerializedSize == 3);
173    assertEquals(result.length, msgSerializedSize);
174
175    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
176    assertTrue(newMsg.hasId());
177    assertTrue(newMsg.isInitialized());
178    assertEquals(123, newMsg.getId());
179  }
180
181  public void testMicroOptionalInt32() throws Exception {
182    TestAllTypesMicro msg = new TestAllTypesMicro();
183    assertFalse(msg.hasOptionalInt32());
184    msg.setOptionalInt32(123);
185    assertTrue(msg.hasOptionalInt32());
186    assertEquals(123, msg.getOptionalInt32());
187    msg.clearOptionalInt32();
188    assertFalse(msg.hasOptionalInt32());
189    msg.clearOptionalInt32()
190       .setOptionalInt32(456);
191    assertTrue(msg.hasOptionalInt32());
192    msg.clear();
193    assertFalse(msg.hasOptionalInt32());
194
195    msg.setOptionalInt32(123);
196    byte [] result = msg.toByteArray();
197    int msgSerializedSize = msg.getSerializedSize();
198    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
199    assertTrue(msgSerializedSize == 2);
200    assertEquals(result.length, msgSerializedSize);
201
202    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
203    assertTrue(newMsg.hasOptionalInt32());
204    assertEquals(123, newMsg.getOptionalInt32());
205  }
206
207  public void testMicroOptionalInt64() throws Exception {
208    TestAllTypesMicro msg = new TestAllTypesMicro();
209    assertFalse(msg.hasOptionalInt64());
210    msg.setOptionalInt64(123);
211    assertTrue(msg.hasOptionalInt64());
212    assertEquals(123, msg.getOptionalInt64());
213    msg.clearOptionalInt64();
214    assertFalse(msg.hasOptionalInt64());
215    msg.clearOptionalInt64()
216       .setOptionalInt64(456);
217    assertTrue(msg.hasOptionalInt64());
218    msg.clear();
219    assertFalse(msg.hasOptionalInt64());
220
221    msg.setOptionalInt64(123);
222    byte [] result = msg.toByteArray();
223    int msgSerializedSize = msg.getSerializedSize();
224    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
225    assertTrue(msgSerializedSize == 2);
226    assertEquals(result.length, msgSerializedSize);
227
228    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
229    assertTrue(newMsg.hasOptionalInt64());
230    assertEquals(123, newMsg.getOptionalInt64());
231  }
232
233  public void testMicroOptionalUint32() throws Exception {
234    TestAllTypesMicro msg = new TestAllTypesMicro();
235    assertFalse(msg.hasOptionalUint32());
236    msg.setOptionalUint32(123);
237    assertTrue(msg.hasOptionalUint32());
238    assertEquals(123, msg.getOptionalUint32());
239    msg.clearOptionalUint32();
240    assertFalse(msg.hasOptionalUint32());
241    msg.clearOptionalUint32()
242       .setOptionalUint32(456);
243    assertTrue(msg.hasOptionalUint32());
244    msg.clear();
245    assertFalse(msg.hasOptionalUint32());
246
247    msg.setOptionalUint32(123);
248    byte [] result = msg.toByteArray();
249    int msgSerializedSize = msg.getSerializedSize();
250    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
251    assertTrue(msgSerializedSize == 2);
252    assertEquals(result.length, msgSerializedSize);
253
254    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
255    assertTrue(newMsg.hasOptionalUint32());
256    assertEquals(123, newMsg.getOptionalUint32());
257  }
258
259  public void testMicroOptionalUint64() throws Exception {
260    TestAllTypesMicro msg = new TestAllTypesMicro();
261    assertFalse(msg.hasOptionalUint64());
262    msg.setOptionalUint64(123);
263    assertTrue(msg.hasOptionalUint64());
264    assertEquals(123, msg.getOptionalUint64());
265    msg.clearOptionalUint64();
266    assertFalse(msg.hasOptionalUint64());
267    msg.clearOptionalUint64()
268       .setOptionalUint64(456);
269    assertTrue(msg.hasOptionalUint64());
270    msg.clear();
271    assertFalse(msg.hasOptionalUint64());
272
273    msg.setOptionalUint64(123);
274    byte [] result = msg.toByteArray();
275    int msgSerializedSize = msg.getSerializedSize();
276    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
277    assertTrue(msgSerializedSize == 2);
278    assertEquals(result.length, msgSerializedSize);
279
280    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
281    assertTrue(newMsg.hasOptionalUint64());
282    assertEquals(123, newMsg.getOptionalUint64());
283  }
284
285  public void testMicroOptionalSint32() throws Exception {
286    TestAllTypesMicro msg = new TestAllTypesMicro();
287    assertFalse(msg.hasOptionalSint32());
288    msg.setOptionalSint32(123);
289    assertTrue(msg.hasOptionalSint32());
290    assertEquals(123, msg.getOptionalSint32());
291    msg.clearOptionalSint32();
292    assertFalse(msg.hasOptionalSint32());
293    msg.clearOptionalSint32()
294       .setOptionalSint32(456);
295    assertTrue(msg.hasOptionalSint32());
296    msg.clear();
297    assertFalse(msg.hasOptionalSint32());
298
299    msg.setOptionalSint32(-123);
300    byte [] result = msg.toByteArray();
301    int msgSerializedSize = msg.getSerializedSize();
302    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
303    assertTrue(msgSerializedSize == 3);
304    assertEquals(result.length, msgSerializedSize);
305
306    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
307    assertTrue(newMsg.hasOptionalSint32());
308    assertEquals(-123, newMsg.getOptionalSint32());
309  }
310
311  public void testMicroOptionalSint64() throws Exception {
312    TestAllTypesMicro msg = new TestAllTypesMicro();
313    assertFalse(msg.hasOptionalSint64());
314    msg.setOptionalSint64(123);
315    assertTrue(msg.hasOptionalSint64());
316    assertEquals(123, msg.getOptionalSint64());
317    msg.clearOptionalSint64();
318    assertFalse(msg.hasOptionalSint64());
319    msg.clearOptionalSint64()
320       .setOptionalSint64(456);
321    assertTrue(msg.hasOptionalSint64());
322    msg.clear();
323    assertFalse(msg.hasOptionalSint64());
324
325    msg.setOptionalSint64(-123);
326    byte [] result = msg.toByteArray();
327    int msgSerializedSize = msg.getSerializedSize();
328    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
329    assertTrue(msgSerializedSize == 3);
330    assertEquals(result.length, msgSerializedSize);
331
332    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
333    assertTrue(newMsg.hasOptionalSint64());
334    assertEquals(-123, newMsg.getOptionalSint64());
335  }
336
337  public void testMicroOptionalFixed32() throws Exception {
338    TestAllTypesMicro msg = new TestAllTypesMicro();
339    assertFalse(msg.hasOptionalFixed32());
340    msg.setOptionalFixed32(123);
341    assertTrue(msg.hasOptionalFixed32());
342    assertEquals(123, msg.getOptionalFixed32());
343    msg.clearOptionalFixed32();
344    assertFalse(msg.hasOptionalFixed32());
345    msg.clearOptionalFixed32()
346       .setOptionalFixed32(456);
347    assertTrue(msg.hasOptionalFixed32());
348    msg.clear();
349    assertFalse(msg.hasOptionalFixed32());
350
351    msg.setOptionalFixed32(123);
352    byte [] result = msg.toByteArray();
353    int msgSerializedSize = msg.getSerializedSize();
354    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
355    assertTrue(msgSerializedSize == 5);
356    assertEquals(result.length, msgSerializedSize);
357
358    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
359    assertTrue(newMsg.hasOptionalFixed32());
360    assertEquals(123, newMsg.getOptionalFixed32());
361  }
362
363  public void testMicroOptionalFixed64() throws Exception {
364    TestAllTypesMicro msg = new TestAllTypesMicro();
365    assertFalse(msg.hasOptionalFixed64());
366    msg.setOptionalFixed64(123);
367    assertTrue(msg.hasOptionalFixed64());
368    assertEquals(123, msg.getOptionalFixed64());
369    msg.clearOptionalFixed64();
370    assertFalse(msg.hasOptionalFixed64());
371    msg.clearOptionalFixed64()
372       .setOptionalFixed64(456);
373    assertTrue(msg.hasOptionalFixed64());
374    msg.clear();
375    assertFalse(msg.hasOptionalFixed64());
376
377    msg.setOptionalFixed64(123);
378    byte [] result = msg.toByteArray();
379    int msgSerializedSize = msg.getSerializedSize();
380    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
381    assertTrue(msgSerializedSize == 9);
382    assertEquals(result.length, msgSerializedSize);
383
384    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
385    assertTrue(newMsg.hasOptionalFixed64());
386    assertEquals(123, newMsg.getOptionalFixed64());
387  }
388  public void testMicroOptionalSfixed32() throws Exception {
389    TestAllTypesMicro msg = new TestAllTypesMicro();
390    assertFalse(msg.hasOptionalSfixed32());
391    msg.setOptionalSfixed32(123);
392    assertTrue(msg.hasOptionalSfixed32());
393    assertEquals(123, msg.getOptionalSfixed32());
394    msg.clearOptionalSfixed32();
395    assertFalse(msg.hasOptionalSfixed32());
396    msg.clearOptionalSfixed32()
397       .setOptionalSfixed32(456);
398    assertTrue(msg.hasOptionalSfixed32());
399    msg.clear();
400    assertFalse(msg.hasOptionalSfixed32());
401
402    msg.setOptionalSfixed32(123);
403    byte [] result = msg.toByteArray();
404    int msgSerializedSize = msg.getSerializedSize();
405    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
406    assertTrue(msgSerializedSize == 5);
407    assertEquals(result.length, msgSerializedSize);
408
409    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
410    assertTrue(newMsg.hasOptionalSfixed32());
411    assertEquals(123, newMsg.getOptionalSfixed32());
412  }
413
414  public void testMicroOptionalSfixed64() throws Exception {
415    TestAllTypesMicro msg = new TestAllTypesMicro();
416    assertFalse(msg.hasOptionalSfixed64());
417    msg.setOptionalSfixed64(123);
418    assertTrue(msg.hasOptionalSfixed64());
419    assertEquals(123, msg.getOptionalSfixed64());
420    msg.clearOptionalSfixed64();
421    assertFalse(msg.hasOptionalSfixed64());
422    msg.clearOptionalSfixed64()
423       .setOptionalSfixed64(456);
424    assertTrue(msg.hasOptionalSfixed64());
425    msg.clear();
426    assertFalse(msg.hasOptionalSfixed64());
427
428    msg.setOptionalSfixed64(-123);
429    byte [] result = msg.toByteArray();
430    int msgSerializedSize = msg.getSerializedSize();
431    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
432    assertTrue(msgSerializedSize == 9);
433    assertEquals(result.length, msgSerializedSize);
434
435    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
436    assertTrue(newMsg.hasOptionalSfixed64());
437    assertEquals(-123, newMsg.getOptionalSfixed64());
438  }
439
440  public void testMicroOptionalFloat() throws Exception {
441    TestAllTypesMicro msg = new TestAllTypesMicro();
442    assertFalse(msg.hasOptionalFloat());
443    msg.setOptionalFloat(123f);
444    assertTrue(msg.hasOptionalFloat());
445    assertTrue(123.0f == msg.getOptionalFloat());
446    msg.clearOptionalFloat();
447    assertFalse(msg.hasOptionalFloat());
448    msg.clearOptionalFloat()
449       .setOptionalFloat(456.0f);
450    assertTrue(msg.hasOptionalFloat());
451    msg.clear();
452    assertFalse(msg.hasOptionalFloat());
453
454    msg.setOptionalFloat(-123.456f);
455    byte [] result = msg.toByteArray();
456    int msgSerializedSize = msg.getSerializedSize();
457    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
458    assertTrue(msgSerializedSize == 5);
459    assertEquals(result.length, msgSerializedSize);
460
461    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
462    assertTrue(newMsg.hasOptionalFloat());
463    assertTrue(-123.456f == newMsg.getOptionalFloat());
464  }
465
466  public void testMicroOptionalDouble() throws Exception {
467    TestAllTypesMicro msg = new TestAllTypesMicro();
468    assertFalse(msg.hasOptionalDouble());
469    msg.setOptionalDouble(123);
470    assertTrue(msg.hasOptionalDouble());
471    assertTrue(123.0 == msg.getOptionalDouble());
472    msg.clearOptionalDouble();
473    assertFalse(msg.hasOptionalDouble());
474    msg.clearOptionalDouble()
475       .setOptionalDouble(456.0);
476    assertTrue(msg.hasOptionalDouble());
477    msg.clear();
478    assertFalse(msg.hasOptionalDouble());
479
480    msg.setOptionalDouble(-123.456);
481    byte [] result = msg.toByteArray();
482    int msgSerializedSize = msg.getSerializedSize();
483    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
484    assertTrue(msgSerializedSize == 9);
485    assertEquals(result.length, msgSerializedSize);
486
487    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
488    assertTrue(newMsg.hasOptionalDouble());
489    assertTrue(-123.456 == newMsg.getOptionalDouble());
490  }
491
492  public void testMicroOptionalBool() throws Exception {
493    TestAllTypesMicro msg = new TestAllTypesMicro();
494    assertFalse(msg.hasOptionalBool());
495    msg.setOptionalBool(true);
496    assertTrue(msg.hasOptionalBool());
497    assertEquals(true, msg.getOptionalBool());
498    msg.clearOptionalBool();
499    assertFalse(msg.hasOptionalBool());
500    msg.clearOptionalBool()
501       .setOptionalBool(true);
502    assertTrue(msg.hasOptionalBool());
503    msg.clear();
504    assertFalse(msg.hasOptionalBool());
505
506    msg.setOptionalBool(false);
507    byte [] result = msg.toByteArray();
508    int msgSerializedSize = msg.getSerializedSize();
509    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
510    assertTrue(msgSerializedSize == 2);
511    assertEquals(result.length, msgSerializedSize);
512
513    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
514    assertTrue(newMsg.hasOptionalBool());
515    assertEquals(false, newMsg.getOptionalBool());
516  }
517
518  public void testMicroOptionalString() throws Exception {
519    TestAllTypesMicro msg = new TestAllTypesMicro();
520    assertFalse(msg.hasOptionalString());
521    msg.setOptionalString("hello");
522    assertTrue(msg.hasOptionalString());
523    assertEquals("hello", msg.getOptionalString());
524    msg.clearOptionalString();
525    assertFalse(msg.hasOptionalString());
526    msg.clearOptionalString()
527       .setOptionalString("hello");
528    assertTrue(msg.hasOptionalString());
529    msg.clear();
530    assertFalse(msg.hasOptionalString());
531
532    msg.setOptionalString("bye");
533    byte [] result = msg.toByteArray();
534    int msgSerializedSize = msg.getSerializedSize();
535    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
536    assertTrue(msgSerializedSize == 5);
537    assertEquals(result.length, msgSerializedSize);
538
539    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
540    assertTrue(newMsg.hasOptionalString());
541    assertEquals("bye", newMsg.getOptionalString());
542  }
543
544  public void testMicroOptionalBytes() throws Exception {
545    TestAllTypesMicro msg = new TestAllTypesMicro();
546    assertFalse(msg.hasOptionalBytes());
547    msg.setOptionalBytes(ByteStringMicro.copyFromUtf8("hello"));
548    assertTrue(msg.hasOptionalBytes());
549    assertEquals("hello", msg.getOptionalBytes().toStringUtf8());
550    msg.clearOptionalBytes();
551    assertFalse(msg.hasOptionalBytes());
552    msg.clearOptionalBytes()
553       .setOptionalBytes(ByteStringMicro.copyFromUtf8("hello"));
554    assertTrue(msg.hasOptionalBytes());
555    msg.clear();
556    assertFalse(msg.hasOptionalBytes());
557
558    msg.setOptionalBytes(ByteStringMicro.copyFromUtf8("bye"));
559    byte [] result = msg.toByteArray();
560    int msgSerializedSize = msg.getSerializedSize();
561    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
562    assertTrue(msgSerializedSize == 5);
563    assertEquals(result.length, msgSerializedSize);
564
565    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
566    assertTrue(newMsg.hasOptionalBytes());
567    assertEquals("bye", newMsg.getOptionalBytes().toStringUtf8());
568  }
569
570  public void testMicroOptionalGroup() throws Exception {
571    TestAllTypesMicro msg = new TestAllTypesMicro();
572    TestAllTypesMicro.OptionalGroup grp = new TestAllTypesMicro.OptionalGroup();
573    grp.setA(1);
574    assertFalse(msg.hasOptionalGroup());
575    msg.setOptionalGroup(grp);
576    assertTrue(msg.hasOptionalGroup());
577    assertEquals(1, msg.getOptionalGroup().getA());
578    msg.clearOptionalGroup();
579    assertFalse(msg.hasOptionalGroup());
580    msg.clearOptionalGroup()
581       .setOptionalGroup(new TestAllTypesMicro.OptionalGroup().setA(2));
582    assertTrue(msg.hasOptionalGroup());
583    msg.clear();
584    assertFalse(msg.hasOptionalGroup());
585
586    msg.setOptionalGroup(grp);
587    byte [] result = msg.toByteArray();
588    int msgSerializedSize = msg.getSerializedSize();
589    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
590    assertTrue(msgSerializedSize == 7);
591    assertEquals(result.length, msgSerializedSize);
592
593    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
594    assertTrue(newMsg.hasOptionalGroup());
595    assertEquals(1, newMsg.getOptionalGroup().getA());
596  }
597
598  public void testMicroOptionalNestedMessage() throws Exception {
599    TestAllTypesMicro msg = new TestAllTypesMicro();
600    TestAllTypesMicro.NestedMessage nestedMsg = new TestAllTypesMicro.NestedMessage();
601    nestedMsg.setBb(1);
602    assertFalse(msg.hasOptionalNestedMessage());
603    msg.setOptionalNestedMessage(nestedMsg);
604    assertTrue(msg.hasOptionalNestedMessage());
605    assertEquals(1, msg.getOptionalNestedMessage().getBb());
606    msg.clearOptionalNestedMessage();
607    assertFalse(msg.hasOptionalNestedMessage());
608    msg.clearOptionalNestedMessage()
609       .setOptionalNestedMessage(new TestAllTypesMicro.NestedMessage().setBb(2));
610    assertTrue(msg.hasOptionalNestedMessage());
611    msg.clear();
612    assertFalse(msg.hasOptionalNestedMessage());
613
614    msg.setOptionalNestedMessage(nestedMsg);
615    byte [] result = msg.toByteArray();
616    int msgSerializedSize = msg.getSerializedSize();
617    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
618    assertTrue(msgSerializedSize == 5);
619    assertEquals(result.length, msgSerializedSize);
620
621    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
622    assertTrue(newMsg.hasOptionalNestedMessage());
623    assertEquals(1, newMsg.getOptionalNestedMessage().getBb());
624  }
625
626  public void testMicroOptionalForeignMessage() throws Exception {
627    TestAllTypesMicro msg = new TestAllTypesMicro();
628    MicroOuterClass.ForeignMessageMicro foreignMsg =
629        new MicroOuterClass.ForeignMessageMicro();
630    assertFalse(foreignMsg.hasC());
631    foreignMsg.setC(1);
632    assertTrue(foreignMsg.hasC());
633    assertFalse(msg.hasOptionalForeignMessage());
634    msg.setOptionalForeignMessage(foreignMsg);
635    assertTrue(msg.hasOptionalForeignMessage());
636    assertEquals(1, msg.getOptionalForeignMessage().getC());
637    msg.clearOptionalForeignMessage();
638    assertFalse(msg.hasOptionalForeignMessage());
639    msg.clearOptionalForeignMessage()
640       .setOptionalForeignMessage(new MicroOuterClass.ForeignMessageMicro().setC(2));
641    assertTrue(msg.hasOptionalForeignMessage());
642    msg.clear();
643    assertFalse(msg.hasOptionalForeignMessage());
644
645    msg.setOptionalForeignMessage(foreignMsg);
646    byte [] result = msg.toByteArray();
647    int msgSerializedSize = msg.getSerializedSize();
648    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
649    assertTrue(msgSerializedSize == 5);
650    assertEquals(result.length, msgSerializedSize);
651
652    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
653    assertTrue(newMsg.hasOptionalForeignMessage());
654    assertEquals(1, newMsg.getOptionalForeignMessage().getC());
655  }
656
657  public void testMicroOptionalImportMessage() throws Exception {
658    TestAllTypesMicro msg = new TestAllTypesMicro();
659    UnittestImportMicro.ImportMessageMicro importMsg =
660        new UnittestImportMicro.ImportMessageMicro();
661    assertFalse(importMsg.hasD());
662    importMsg.setD(1);
663    assertTrue(importMsg.hasD());
664    assertFalse(msg.hasOptionalImportMessage());
665    msg.setOptionalImportMessage(importMsg);
666    assertTrue(msg.hasOptionalImportMessage());
667    assertEquals(1, msg.getOptionalImportMessage().getD());
668    msg.clearOptionalImportMessage();
669    assertFalse(msg.hasOptionalImportMessage());
670    msg.clearOptionalImportMessage()
671       .setOptionalImportMessage(new UnittestImportMicro.ImportMessageMicro().setD(2));
672    assertTrue(msg.hasOptionalImportMessage());
673    msg.clear();
674    assertFalse(msg.hasOptionalImportMessage());
675
676    msg.setOptionalImportMessage(importMsg);
677    byte [] result = msg.toByteArray();
678    int msgSerializedSize = msg.getSerializedSize();
679    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
680    assertTrue(msgSerializedSize == 5);
681    assertEquals(result.length, msgSerializedSize);
682
683    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
684    assertTrue(newMsg.hasOptionalImportMessage());
685    assertEquals(1, newMsg.getOptionalImportMessage().getD());
686  }
687
688  public void testMicroOptionalNestedEnum() throws Exception {
689    TestAllTypesMicro msg = new TestAllTypesMicro();
690    msg.setOptionalNestedEnum(TestAllTypesMicro.BAR);
691    assertTrue(msg.hasOptionalNestedEnum());
692    assertEquals(TestAllTypesMicro.BAR, msg.getOptionalNestedEnum());
693    msg.clearOptionalNestedEnum();
694    assertFalse(msg.hasOptionalNestedEnum());
695    msg.clearOptionalNestedEnum()
696       .setOptionalNestedEnum(TestAllTypesMicro.BAZ);
697    assertTrue(msg.hasOptionalNestedEnum());
698    msg.clear();
699    assertFalse(msg.hasOptionalNestedEnum());
700
701    msg.setOptionalNestedEnum(TestAllTypesMicro.BAR);
702    byte [] result = msg.toByteArray();
703    int msgSerializedSize = msg.getSerializedSize();
704    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
705    assertTrue(msgSerializedSize == 3);
706    assertEquals(result.length, msgSerializedSize);
707
708    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
709    assertTrue(newMsg.hasOptionalNestedEnum());
710    assertEquals(TestAllTypesMicro.BAR, newMsg.getOptionalNestedEnum());
711  }
712
713  public void testMicroOptionalForeignEnum() throws Exception {
714    TestAllTypesMicro msg = new TestAllTypesMicro();
715    msg.setOptionalForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
716    assertTrue(msg.hasOptionalForeignEnum());
717    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR,
718        msg.getOptionalForeignEnum());
719    msg.clearOptionalForeignEnum();
720    assertFalse(msg.hasOptionalForeignEnum());
721    msg.clearOptionalForeignEnum()
722       .setOptionalForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAZ);
723    assertTrue(msg.hasOptionalForeignEnum());
724    msg.clear();
725    assertFalse(msg.hasOptionalForeignEnum());
726
727    msg.setOptionalForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
728    byte [] result = msg.toByteArray();
729    int msgSerializedSize = msg.getSerializedSize();
730    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
731    assertTrue(msgSerializedSize == 3);
732    assertEquals(result.length, msgSerializedSize);
733
734    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
735    assertTrue(newMsg.hasOptionalForeignEnum());
736    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR,
737        newMsg.getOptionalForeignEnum());
738  }
739
740  public void testMicroOptionalImportEnum() throws Exception {
741    TestAllTypesMicro msg = new TestAllTypesMicro();
742    msg.setOptionalImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
743    assertTrue(msg.hasOptionalImportEnum());
744    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR,
745        msg.getOptionalImportEnum());
746    msg.clearOptionalImportEnum();
747    assertFalse(msg.hasOptionalImportEnum());
748    msg.clearOptionalImportEnum()
749       .setOptionalImportEnum(UnittestImportMicro.IMPORT_MICRO_BAZ);
750    assertTrue(msg.hasOptionalImportEnum());
751    msg.clear();
752    assertFalse(msg.hasOptionalImportEnum());
753
754    msg.setOptionalImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
755    byte [] result = msg.toByteArray();
756    int msgSerializedSize = msg.getSerializedSize();
757    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
758    assertTrue(msgSerializedSize == 3);
759    assertEquals(result.length, msgSerializedSize);
760
761    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
762    assertTrue(newMsg.hasOptionalImportEnum());
763    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR,
764        newMsg.getOptionalImportEnum());
765  }
766
767  public void testMicroOptionalStringPiece() throws Exception {
768    TestAllTypesMicro msg = new TestAllTypesMicro();
769    assertFalse(msg.hasOptionalStringPiece());
770    msg.setOptionalStringPiece("hello");
771    assertTrue(msg.hasOptionalStringPiece());
772    assertEquals("hello", msg.getOptionalStringPiece());
773    msg.clearOptionalStringPiece();
774    assertFalse(msg.hasOptionalStringPiece());
775    msg.clearOptionalStringPiece()
776       .setOptionalStringPiece("hello");
777    assertTrue(msg.hasOptionalStringPiece());
778    msg.clear();
779    assertFalse(msg.hasOptionalStringPiece());
780
781    msg.setOptionalStringPiece("bye");
782    byte [] result = msg.toByteArray();
783    int msgSerializedSize = msg.getSerializedSize();
784    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
785    assertTrue(msgSerializedSize == 6);
786    assertEquals(result.length, msgSerializedSize);
787
788    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
789    assertTrue(newMsg.hasOptionalStringPiece());
790    assertEquals("bye", newMsg.getOptionalStringPiece());
791  }
792
793  public void testMicroOptionalCord() throws Exception {
794    TestAllTypesMicro msg = new TestAllTypesMicro();
795    assertFalse(msg.hasOptionalCord());
796    msg.setOptionalCord("hello");
797    assertTrue(msg.hasOptionalCord());
798    assertEquals("hello", msg.getOptionalCord());
799    msg.clearOptionalCord();
800    assertFalse(msg.hasOptionalCord());
801    msg.clearOptionalCord()
802      .setOptionalCord("hello");
803    assertTrue(msg.hasOptionalCord());
804    msg.clear();
805    assertFalse(msg.hasOptionalCord());
806
807    msg.setOptionalCord("bye");
808    byte [] result = msg.toByteArray();
809    int msgSerializedSize = msg.getSerializedSize();
810    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
811    assertTrue(msgSerializedSize == 6);
812    assertEquals(result.length, msgSerializedSize);
813
814    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
815    assertTrue(newMsg.hasOptionalCord());
816    assertEquals("bye", newMsg.getOptionalCord());
817  }
818
819  public void testMicroRepeatedInt32() throws Exception {
820    TestAllTypesMicro msg = new TestAllTypesMicro();
821    assertEquals(0, msg.getRepeatedInt32Count());
822    msg.addRepeatedInt32(123);
823    assertEquals(1, msg.getRepeatedInt32Count());
824    assertEquals(123, msg.getRepeatedInt32(0));
825    msg.addRepeatedInt32(456);
826    assertEquals(2, msg.getRepeatedInt32Count());
827    assertEquals(123, msg.getRepeatedInt32(0));
828    assertEquals(456, msg.getRepeatedInt32(1));
829    msg.setRepeatedInt32(0, 789);
830    assertEquals(2, msg.getRepeatedInt32Count());
831    assertEquals(789, msg.getRepeatedInt32(0));
832    assertEquals(456, msg.getRepeatedInt32(1));
833    msg.clearRepeatedInt32();
834    assertEquals(0, msg.getRepeatedInt32Count());
835    msg.clearRepeatedInt32()
836       .addRepeatedInt32(456);
837    assertEquals(1, msg.getRepeatedInt32Count());
838    assertEquals(456, msg.getRepeatedInt32(0));
839    msg.clear();
840    assertEquals(0, msg.getRepeatedInt32Count());
841
842    // Test 1 entry
843    msg.clear()
844       .addRepeatedInt32(123);
845    assertEquals(1, msg.getRepeatedInt32Count());
846    byte [] result = msg.toByteArray();
847    int msgSerializedSize = msg.getSerializedSize();
848    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
849    assertTrue(msgSerializedSize == 3);
850    assertEquals(result.length, msgSerializedSize);
851    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
852    assertEquals(1, newMsg.getRepeatedInt32Count());
853    assertEquals(123, newMsg.getRepeatedInt32(0));
854
855    // Test 2 entries
856    msg.clear()
857       .addRepeatedInt32(123)
858       .addRepeatedInt32(456);
859    assertEquals(2, msg.getRepeatedInt32Count());
860    result = msg.toByteArray();
861    msgSerializedSize = msg.getSerializedSize();
862    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
863    assertTrue(msgSerializedSize == 7);
864    assertEquals(result.length, msgSerializedSize);
865
866    newMsg = TestAllTypesMicro.parseFrom(result);
867    assertEquals(2, newMsg.getRepeatedInt32Count());
868    assertEquals(123, newMsg.getRepeatedInt32(0));
869    assertEquals(456, newMsg.getRepeatedInt32(1));
870  }
871
872  public void testMicroRepeatedInt64() throws Exception {
873    TestAllTypesMicro msg = new TestAllTypesMicro();
874    assertEquals(0, msg.getRepeatedInt64Count());
875    msg.addRepeatedInt64(123);
876    assertEquals(1, msg.getRepeatedInt64Count());
877    assertEquals(123, msg.getRepeatedInt64(0));
878    msg.addRepeatedInt64(456);
879    assertEquals(2, msg.getRepeatedInt64Count());
880    assertEquals(123, msg.getRepeatedInt64(0));
881    assertEquals(456, msg.getRepeatedInt64(1));
882    msg.setRepeatedInt64(0, 789);
883    assertEquals(2, msg.getRepeatedInt64Count());
884    assertEquals(789, msg.getRepeatedInt64(0));
885    assertEquals(456, msg.getRepeatedInt64(1));
886    msg.clearRepeatedInt64();
887    assertEquals(0, msg.getRepeatedInt64Count());
888    msg.clearRepeatedInt64()
889       .addRepeatedInt64(456);
890    assertEquals(1, msg.getRepeatedInt64Count());
891    assertEquals(456, msg.getRepeatedInt64(0));
892    msg.clear();
893    assertEquals(0, msg.getRepeatedInt64Count());
894
895    // Test 1 entry
896    msg.clear()
897       .addRepeatedInt64(123);
898    assertEquals(1, msg.getRepeatedInt64Count());
899    byte [] result = msg.toByteArray();
900    int msgSerializedSize = msg.getSerializedSize();
901    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
902    assertTrue(msgSerializedSize == 3);
903    assertEquals(result.length, msgSerializedSize);
904    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
905    assertEquals(1, newMsg.getRepeatedInt64Count());
906    assertEquals(123, newMsg.getRepeatedInt64(0));
907
908    // Test 2 entries
909    msg.clear()
910       .addRepeatedInt64(123)
911       .addRepeatedInt64(456);
912    assertEquals(2, msg.getRepeatedInt64Count());
913    result = msg.toByteArray();
914    msgSerializedSize = msg.getSerializedSize();
915    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
916    assertTrue(msgSerializedSize == 7);
917    assertEquals(result.length, msgSerializedSize);
918
919    newMsg = TestAllTypesMicro.parseFrom(result);
920    assertEquals(2, newMsg.getRepeatedInt64Count());
921    assertEquals(123, newMsg.getRepeatedInt64(0));
922    assertEquals(456, newMsg.getRepeatedInt64(1));
923  }
924
925  public void testMicroRepeatedUint32() throws Exception {
926    TestAllTypesMicro msg = new TestAllTypesMicro();
927    assertEquals(0, msg.getRepeatedUint32Count());
928    msg.addRepeatedUint32(123);
929    assertEquals(1, msg.getRepeatedUint32Count());
930    assertEquals(123, msg.getRepeatedUint32(0));
931    msg.addRepeatedUint32(456);
932    assertEquals(2, msg.getRepeatedUint32Count());
933    assertEquals(123, msg.getRepeatedUint32(0));
934    assertEquals(456, msg.getRepeatedUint32(1));
935    msg.setRepeatedUint32(0, 789);
936    assertEquals(2, msg.getRepeatedUint32Count());
937    assertEquals(789, msg.getRepeatedUint32(0));
938    assertEquals(456, msg.getRepeatedUint32(1));
939    msg.clearRepeatedUint32();
940    assertEquals(0, msg.getRepeatedUint32Count());
941    msg.clearRepeatedUint32()
942       .addRepeatedUint32(456);
943    assertEquals(1, msg.getRepeatedUint32Count());
944    assertEquals(456, msg.getRepeatedUint32(0));
945    msg.clear();
946    assertEquals(0, msg.getRepeatedUint32Count());
947
948    // Test 1 entry
949    msg.clear()
950       .addRepeatedUint32(123);
951    assertEquals(1, msg.getRepeatedUint32Count());
952    byte [] result = msg.toByteArray();
953    int msgSerializedSize = msg.getSerializedSize();
954    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
955    assertTrue(msgSerializedSize == 3);
956    assertEquals(result.length, msgSerializedSize);
957    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
958    assertEquals(1, newMsg.getRepeatedUint32Count());
959    assertEquals(123, newMsg.getRepeatedUint32(0));
960
961    // Test 2 entries
962    msg.clear()
963       .addRepeatedUint32(123)
964       .addRepeatedUint32(456);
965    assertEquals(2, msg.getRepeatedUint32Count());
966    result = msg.toByteArray();
967    msgSerializedSize = msg.getSerializedSize();
968    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
969    assertTrue(msgSerializedSize == 7);
970    assertEquals(result.length, msgSerializedSize);
971
972    newMsg = TestAllTypesMicro.parseFrom(result);
973    assertEquals(2, newMsg.getRepeatedUint32Count());
974    assertEquals(123, newMsg.getRepeatedUint32(0));
975    assertEquals(456, newMsg.getRepeatedUint32(1));
976  }
977
978  public void testMicroRepeatedUint64() throws Exception {
979    TestAllTypesMicro msg = new TestAllTypesMicro();
980    assertEquals(0, msg.getRepeatedUint64Count());
981    msg.addRepeatedUint64(123);
982    assertEquals(1, msg.getRepeatedUint64Count());
983    assertEquals(123, msg.getRepeatedUint64(0));
984    msg.addRepeatedUint64(456);
985    assertEquals(2, msg.getRepeatedUint64Count());
986    assertEquals(123, msg.getRepeatedUint64(0));
987    assertEquals(456, msg.getRepeatedUint64(1));
988    msg.setRepeatedUint64(0, 789);
989    assertEquals(2, msg.getRepeatedUint64Count());
990    assertEquals(789, msg.getRepeatedUint64(0));
991    assertEquals(456, msg.getRepeatedUint64(1));
992    msg.clearRepeatedUint64();
993    assertEquals(0, msg.getRepeatedUint64Count());
994    msg.clearRepeatedUint64()
995       .addRepeatedUint64(456);
996    assertEquals(1, msg.getRepeatedUint64Count());
997    assertEquals(456, msg.getRepeatedUint64(0));
998    msg.clear();
999    assertEquals(0, msg.getRepeatedUint64Count());
1000
1001    // Test 1 entry
1002    msg.clear()
1003       .addRepeatedUint64(123);
1004    assertEquals(1, msg.getRepeatedUint64Count());
1005    byte [] result = msg.toByteArray();
1006    int msgSerializedSize = msg.getSerializedSize();
1007    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1008    assertTrue(msgSerializedSize == 3);
1009    assertEquals(result.length, msgSerializedSize);
1010    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1011    assertEquals(1, newMsg.getRepeatedUint64Count());
1012    assertEquals(123, newMsg.getRepeatedUint64(0));
1013
1014    // Test 2 entries
1015    msg.clear()
1016       .addRepeatedUint64(123)
1017       .addRepeatedUint64(456);
1018    assertEquals(2, msg.getRepeatedUint64Count());
1019    result = msg.toByteArray();
1020    msgSerializedSize = msg.getSerializedSize();
1021    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1022    assertTrue(msgSerializedSize == 7);
1023    assertEquals(result.length, msgSerializedSize);
1024
1025    newMsg = TestAllTypesMicro.parseFrom(result);
1026    assertEquals(2, newMsg.getRepeatedUint64Count());
1027    assertEquals(123, newMsg.getRepeatedUint64(0));
1028    assertEquals(456, newMsg.getRepeatedUint64(1));
1029  }
1030
1031  public void testMicroRepeatedSint32() throws Exception {
1032    TestAllTypesMicro msg = new TestAllTypesMicro();
1033    assertEquals(0, msg.getRepeatedSint32Count());
1034    msg.addRepeatedSint32(123);
1035    assertEquals(1, msg.getRepeatedSint32Count());
1036    assertEquals(123, msg.getRepeatedSint32(0));
1037    msg.addRepeatedSint32(456);
1038    assertEquals(2, msg.getRepeatedSint32Count());
1039    assertEquals(123, msg.getRepeatedSint32(0));
1040    assertEquals(456, msg.getRepeatedSint32(1));
1041    msg.setRepeatedSint32(0, 789);
1042    assertEquals(2, msg.getRepeatedSint32Count());
1043    assertEquals(789, msg.getRepeatedSint32(0));
1044    assertEquals(456, msg.getRepeatedSint32(1));
1045    msg.clearRepeatedSint32();
1046    assertEquals(0, msg.getRepeatedSint32Count());
1047    msg.clearRepeatedSint32()
1048       .addRepeatedSint32(456);
1049    assertEquals(1, msg.getRepeatedSint32Count());
1050    assertEquals(456, msg.getRepeatedSint32(0));
1051    msg.clear();
1052    assertEquals(0, msg.getRepeatedSint32Count());
1053
1054    // Test 1 entry
1055    msg.clear()
1056       .addRepeatedSint32(123);
1057    assertEquals(1, msg.getRepeatedSint32Count());
1058    byte [] result = msg.toByteArray();
1059    int msgSerializedSize = msg.getSerializedSize();
1060    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1061    assertTrue(msgSerializedSize == 4);
1062    assertEquals(result.length, msgSerializedSize);
1063    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1064    assertEquals(1, newMsg.getRepeatedSint32Count());
1065    assertEquals(123, newMsg.getRepeatedSint32(0));
1066
1067    // Test 2 entries
1068    msg.clear()
1069       .addRepeatedSint32(123)
1070       .addRepeatedSint32(456);
1071    assertEquals(2, msg.getRepeatedSint32Count());
1072    result = msg.toByteArray();
1073    msgSerializedSize = msg.getSerializedSize();
1074    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1075    assertTrue(msgSerializedSize == 8);
1076    assertEquals(result.length, msgSerializedSize);
1077
1078    newMsg = TestAllTypesMicro.parseFrom(result);
1079    assertEquals(2, newMsg.getRepeatedSint32Count());
1080    assertEquals(123, newMsg.getRepeatedSint32(0));
1081    assertEquals(456, newMsg.getRepeatedSint32(1));
1082  }
1083
1084  public void testMicroRepeatedSint64() throws Exception {
1085    TestAllTypesMicro msg = new TestAllTypesMicro();
1086    assertEquals(0, msg.getRepeatedSint64Count());
1087    msg.addRepeatedSint64(123);
1088    assertEquals(1, msg.getRepeatedSint64Count());
1089    assertEquals(123, msg.getRepeatedSint64(0));
1090    msg.addRepeatedSint64(456);
1091    assertEquals(2, msg.getRepeatedSint64Count());
1092    assertEquals(123, msg.getRepeatedSint64(0));
1093    assertEquals(456, msg.getRepeatedSint64(1));
1094    msg.setRepeatedSint64(0, 789);
1095    assertEquals(2, msg.getRepeatedSint64Count());
1096    assertEquals(789, msg.getRepeatedSint64(0));
1097    assertEquals(456, msg.getRepeatedSint64(1));
1098    msg.clearRepeatedSint64();
1099    assertEquals(0, msg.getRepeatedSint64Count());
1100    msg.clearRepeatedSint64()
1101       .addRepeatedSint64(456);
1102    assertEquals(1, msg.getRepeatedSint64Count());
1103    assertEquals(456, msg.getRepeatedSint64(0));
1104    msg.clear();
1105    assertEquals(0, msg.getRepeatedSint64Count());
1106
1107    // Test 1 entry
1108    msg.clear()
1109       .addRepeatedSint64(123);
1110    assertEquals(1, msg.getRepeatedSint64Count());
1111    byte [] result = msg.toByteArray();
1112    int msgSerializedSize = msg.getSerializedSize();
1113    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1114    assertTrue(msgSerializedSize == 4);
1115    assertEquals(result.length, msgSerializedSize);
1116    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1117    assertEquals(1, newMsg.getRepeatedSint64Count());
1118    assertEquals(123, newMsg.getRepeatedSint64(0));
1119
1120    // Test 2 entries
1121    msg.clear()
1122       .addRepeatedSint64(123)
1123       .addRepeatedSint64(456);
1124    assertEquals(2, msg.getRepeatedSint64Count());
1125    result = msg.toByteArray();
1126    msgSerializedSize = msg.getSerializedSize();
1127    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1128    assertTrue(msgSerializedSize == 8);
1129    assertEquals(result.length, msgSerializedSize);
1130
1131    newMsg = TestAllTypesMicro.parseFrom(result);
1132    assertEquals(2, newMsg.getRepeatedSint64Count());
1133    assertEquals(123, newMsg.getRepeatedSint64(0));
1134    assertEquals(456, newMsg.getRepeatedSint64(1));
1135  }
1136
1137  public void testMicroRepeatedFixed32() throws Exception {
1138    TestAllTypesMicro msg = new TestAllTypesMicro();
1139    assertEquals(0, msg.getRepeatedFixed32Count());
1140    msg.addRepeatedFixed32(123);
1141    assertEquals(1, msg.getRepeatedFixed32Count());
1142    assertEquals(123, msg.getRepeatedFixed32(0));
1143    msg.addRepeatedFixed32(456);
1144    assertEquals(2, msg.getRepeatedFixed32Count());
1145    assertEquals(123, msg.getRepeatedFixed32(0));
1146    assertEquals(456, msg.getRepeatedFixed32(1));
1147    msg.setRepeatedFixed32(0, 789);
1148    assertEquals(2, msg.getRepeatedFixed32Count());
1149    assertEquals(789, msg.getRepeatedFixed32(0));
1150    assertEquals(456, msg.getRepeatedFixed32(1));
1151    msg.clearRepeatedFixed32();
1152    assertEquals(0, msg.getRepeatedFixed32Count());
1153    msg.clearRepeatedFixed32()
1154       .addRepeatedFixed32(456);
1155    assertEquals(1, msg.getRepeatedFixed32Count());
1156    assertEquals(456, msg.getRepeatedFixed32(0));
1157    msg.clear();
1158    assertEquals(0, msg.getRepeatedFixed32Count());
1159
1160    // Test 1 entry
1161    msg.clear()
1162       .addRepeatedFixed32(123);
1163    assertEquals(1, msg.getRepeatedFixed32Count());
1164    byte [] result = msg.toByteArray();
1165    int msgSerializedSize = msg.getSerializedSize();
1166    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1167    assertTrue(msgSerializedSize == 6);
1168    assertEquals(result.length, msgSerializedSize);
1169    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1170    assertEquals(1, newMsg.getRepeatedFixed32Count());
1171    assertEquals(123, newMsg.getRepeatedFixed32(0));
1172
1173    // Test 2 entries
1174    msg.clear()
1175       .addRepeatedFixed32(123)
1176       .addRepeatedFixed32(456);
1177    assertEquals(2, msg.getRepeatedFixed32Count());
1178    result = msg.toByteArray();
1179    msgSerializedSize = msg.getSerializedSize();
1180    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1181    assertTrue(msgSerializedSize == 12);
1182    assertEquals(result.length, msgSerializedSize);
1183
1184    newMsg = TestAllTypesMicro.parseFrom(result);
1185    assertEquals(2, newMsg.getRepeatedFixed32Count());
1186    assertEquals(123, newMsg.getRepeatedFixed32(0));
1187    assertEquals(456, newMsg.getRepeatedFixed32(1));
1188  }
1189
1190  public void testMicroRepeatedFixed64() throws Exception {
1191    TestAllTypesMicro msg = new TestAllTypesMicro();
1192    assertEquals(0, msg.getRepeatedFixed64Count());
1193    msg.addRepeatedFixed64(123);
1194    assertEquals(1, msg.getRepeatedFixed64Count());
1195    assertEquals(123, msg.getRepeatedFixed64(0));
1196    msg.addRepeatedFixed64(456);
1197    assertEquals(2, msg.getRepeatedFixed64Count());
1198    assertEquals(123, msg.getRepeatedFixed64(0));
1199    assertEquals(456, msg.getRepeatedFixed64(1));
1200    msg.setRepeatedFixed64(0, 789);
1201    assertEquals(2, msg.getRepeatedFixed64Count());
1202    assertEquals(789, msg.getRepeatedFixed64(0));
1203    assertEquals(456, msg.getRepeatedFixed64(1));
1204    msg.clearRepeatedFixed64();
1205    assertEquals(0, msg.getRepeatedFixed64Count());
1206    msg.clearRepeatedFixed64()
1207       .addRepeatedFixed64(456);
1208    assertEquals(1, msg.getRepeatedFixed64Count());
1209    assertEquals(456, msg.getRepeatedFixed64(0));
1210    msg.clear();
1211    assertEquals(0, msg.getRepeatedFixed64Count());
1212
1213    // Test 1 entry
1214    msg.clear()
1215       .addRepeatedFixed64(123);
1216    assertEquals(1, msg.getRepeatedFixed64Count());
1217    byte [] result = msg.toByteArray();
1218    int msgSerializedSize = msg.getSerializedSize();
1219    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1220    assertTrue(msgSerializedSize == 10);
1221    assertEquals(result.length, msgSerializedSize);
1222    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1223    assertEquals(1, newMsg.getRepeatedFixed64Count());
1224    assertEquals(123, newMsg.getRepeatedFixed64(0));
1225
1226    // Test 2 entries
1227    msg.clear()
1228       .addRepeatedFixed64(123)
1229       .addRepeatedFixed64(456);
1230    assertEquals(2, msg.getRepeatedFixed64Count());
1231    result = msg.toByteArray();
1232    msgSerializedSize = msg.getSerializedSize();
1233    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1234    assertTrue(msgSerializedSize == 20);
1235    assertEquals(result.length, msgSerializedSize);
1236
1237    newMsg = TestAllTypesMicro.parseFrom(result);
1238    assertEquals(2, newMsg.getRepeatedFixed64Count());
1239    assertEquals(123, newMsg.getRepeatedFixed64(0));
1240    assertEquals(456, newMsg.getRepeatedFixed64(1));
1241  }
1242
1243  public void testMicroRepeatedSfixed32() throws Exception {
1244    TestAllTypesMicro msg = new TestAllTypesMicro();
1245    assertEquals(0, msg.getRepeatedSfixed32Count());
1246    msg.addRepeatedSfixed32(123);
1247    assertEquals(1, msg.getRepeatedSfixed32Count());
1248    assertEquals(123, msg.getRepeatedSfixed32(0));
1249    msg.addRepeatedSfixed32(456);
1250    assertEquals(2, msg.getRepeatedSfixed32Count());
1251    assertEquals(123, msg.getRepeatedSfixed32(0));
1252    assertEquals(456, msg.getRepeatedSfixed32(1));
1253    msg.setRepeatedSfixed32(0, 789);
1254    assertEquals(2, msg.getRepeatedSfixed32Count());
1255    assertEquals(789, msg.getRepeatedSfixed32(0));
1256    assertEquals(456, msg.getRepeatedSfixed32(1));
1257    msg.clearRepeatedSfixed32();
1258    assertEquals(0, msg.getRepeatedSfixed32Count());
1259    msg.clearRepeatedSfixed32()
1260       .addRepeatedSfixed32(456);
1261    assertEquals(1, msg.getRepeatedSfixed32Count());
1262    assertEquals(456, msg.getRepeatedSfixed32(0));
1263    msg.clear();
1264    assertEquals(0, msg.getRepeatedSfixed32Count());
1265
1266    // Test 1 entry
1267    msg.clear()
1268       .addRepeatedSfixed32(123);
1269    assertEquals(1, msg.getRepeatedSfixed32Count());
1270    byte [] result = msg.toByteArray();
1271    int msgSerializedSize = msg.getSerializedSize();
1272    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1273    assertTrue(msgSerializedSize == 6);
1274    assertEquals(result.length, msgSerializedSize);
1275    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1276    assertEquals(1, newMsg.getRepeatedSfixed32Count());
1277    assertEquals(123, newMsg.getRepeatedSfixed32(0));
1278
1279    // Test 2 entries
1280    msg.clear()
1281       .addRepeatedSfixed32(123)
1282       .addRepeatedSfixed32(456);
1283    assertEquals(2, msg.getRepeatedSfixed32Count());
1284    result = msg.toByteArray();
1285    msgSerializedSize = msg.getSerializedSize();
1286    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1287    assertTrue(msgSerializedSize == 12);
1288    assertEquals(result.length, msgSerializedSize);
1289
1290    newMsg = TestAllTypesMicro.parseFrom(result);
1291    assertEquals(2, newMsg.getRepeatedSfixed32Count());
1292    assertEquals(123, newMsg.getRepeatedSfixed32(0));
1293    assertEquals(456, newMsg.getRepeatedSfixed32(1));
1294  }
1295
1296  public void testMicroRepeatedSfixed64() throws Exception {
1297    TestAllTypesMicro msg = new TestAllTypesMicro();
1298    assertEquals(0, msg.getRepeatedSfixed64Count());
1299    msg.addRepeatedSfixed64(123);
1300    assertEquals(1, msg.getRepeatedSfixed64Count());
1301    assertEquals(123, msg.getRepeatedSfixed64(0));
1302    msg.addRepeatedSfixed64(456);
1303    assertEquals(2, msg.getRepeatedSfixed64Count());
1304    assertEquals(123, msg.getRepeatedSfixed64(0));
1305    assertEquals(456, msg.getRepeatedSfixed64(1));
1306    msg.setRepeatedSfixed64(0, 789);
1307    assertEquals(2, msg.getRepeatedSfixed64Count());
1308    assertEquals(789, msg.getRepeatedSfixed64(0));
1309    assertEquals(456, msg.getRepeatedSfixed64(1));
1310    msg.clearRepeatedSfixed64();
1311    assertEquals(0, msg.getRepeatedSfixed64Count());
1312    msg.clearRepeatedSfixed64()
1313       .addRepeatedSfixed64(456);
1314    assertEquals(1, msg.getRepeatedSfixed64Count());
1315    assertEquals(456, msg.getRepeatedSfixed64(0));
1316    msg.clear();
1317    assertEquals(0, msg.getRepeatedSfixed64Count());
1318
1319    // Test 1 entry
1320    msg.clear()
1321       .addRepeatedSfixed64(123);
1322    assertEquals(1, msg.getRepeatedSfixed64Count());
1323    byte [] result = msg.toByteArray();
1324    int msgSerializedSize = msg.getSerializedSize();
1325    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1326    assertTrue(msgSerializedSize == 10);
1327    assertEquals(result.length, msgSerializedSize);
1328    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1329    assertEquals(1, newMsg.getRepeatedSfixed64Count());
1330    assertEquals(123, newMsg.getRepeatedSfixed64(0));
1331
1332    // Test 2 entries
1333    msg.clear()
1334       .addRepeatedSfixed64(123)
1335       .addRepeatedSfixed64(456);
1336    assertEquals(2, msg.getRepeatedSfixed64Count());
1337    result = msg.toByteArray();
1338    msgSerializedSize = msg.getSerializedSize();
1339    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1340    assertTrue(msgSerializedSize == 20);
1341    assertEquals(result.length, msgSerializedSize);
1342
1343    newMsg = TestAllTypesMicro.parseFrom(result);
1344    assertEquals(2, newMsg.getRepeatedSfixed64Count());
1345    assertEquals(123, newMsg.getRepeatedSfixed64(0));
1346    assertEquals(456, newMsg.getRepeatedSfixed64(1));
1347  }
1348
1349  public void testMicroRepeatedFloat() throws Exception {
1350    TestAllTypesMicro msg = new TestAllTypesMicro();
1351    assertEquals(0, msg.getRepeatedFloatCount());
1352    msg.addRepeatedFloat(123f);
1353    assertEquals(1, msg.getRepeatedFloatCount());
1354    assertTrue(123f == msg.getRepeatedFloat(0));
1355    msg.addRepeatedFloat(456f);
1356    assertEquals(2, msg.getRepeatedFloatCount());
1357    assertTrue(123f == msg.getRepeatedFloat(0));
1358    assertTrue(456f == msg.getRepeatedFloat(1));
1359    msg.setRepeatedFloat(0, 789f);
1360    assertEquals(2, msg.getRepeatedFloatCount());
1361    assertTrue(789f == msg.getRepeatedFloat(0));
1362    assertTrue(456f == msg.getRepeatedFloat(1));
1363    msg.clearRepeatedFloat();
1364    assertEquals(0, msg.getRepeatedFloatCount());
1365    msg.clearRepeatedFloat()
1366       .addRepeatedFloat(456f);
1367    assertEquals(1, msg.getRepeatedFloatCount());
1368    assertTrue(456f == msg.getRepeatedFloat(0));
1369    msg.clear();
1370    assertEquals(0, msg.getRepeatedFloatCount());
1371
1372    // Test 1 entry
1373    msg.clear()
1374       .addRepeatedFloat(123f);
1375    assertEquals(1, msg.getRepeatedFloatCount());
1376    byte [] result = msg.toByteArray();
1377    int msgSerializedSize = msg.getSerializedSize();
1378    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1379    assertTrue(msgSerializedSize == 6);
1380    assertEquals(result.length, msgSerializedSize);
1381    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1382    assertEquals(1, newMsg.getRepeatedFloatCount());
1383    assertTrue(123f == newMsg.getRepeatedFloat(0));
1384
1385    // Test 2 entries
1386    msg.clear()
1387       .addRepeatedFloat(123f)
1388       .addRepeatedFloat(456f);
1389    assertEquals(2, msg.getRepeatedFloatCount());
1390    result = msg.toByteArray();
1391    msgSerializedSize = msg.getSerializedSize();
1392    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1393    assertTrue(msgSerializedSize == 12);
1394    assertEquals(result.length, msgSerializedSize);
1395
1396    newMsg = TestAllTypesMicro.parseFrom(result);
1397    assertEquals(2, newMsg.getRepeatedFloatCount());
1398    assertTrue(123f == newMsg.getRepeatedFloat(0));
1399    assertTrue(456f == newMsg.getRepeatedFloat(1));
1400  }
1401
1402  public void testMicroRepeatedDouble() throws Exception {
1403    TestAllTypesMicro msg = new TestAllTypesMicro();
1404    assertEquals(0, msg.getRepeatedDoubleCount());
1405    msg.addRepeatedDouble(123.0);
1406    assertEquals(1, msg.getRepeatedDoubleCount());
1407    assertTrue(123.0 == msg.getRepeatedDouble(0));
1408    msg.addRepeatedDouble(456.0);
1409    assertEquals(2, msg.getRepeatedDoubleCount());
1410    assertTrue(123.0 == msg.getRepeatedDouble(0));
1411    assertTrue(456.0 == msg.getRepeatedDouble(1));
1412    msg.setRepeatedDouble(0, 789.0);
1413    assertEquals(2, msg.getRepeatedDoubleCount());
1414    assertTrue(789.0 == msg.getRepeatedDouble(0));
1415    assertTrue(456.0 == msg.getRepeatedDouble(1));
1416    msg.clearRepeatedDouble();
1417    assertEquals(0, msg.getRepeatedDoubleCount());
1418    msg.clearRepeatedDouble()
1419       .addRepeatedDouble(456.0);
1420    assertEquals(1, msg.getRepeatedDoubleCount());
1421    assertTrue(456.0 == msg.getRepeatedDouble(0));
1422    msg.clear();
1423    assertEquals(0, msg.getRepeatedDoubleCount());
1424
1425    // Test 1 entry
1426    msg.clear()
1427       .addRepeatedDouble(123.0);
1428    assertEquals(1, msg.getRepeatedDoubleCount());
1429    byte [] result = msg.toByteArray();
1430    int msgSerializedSize = msg.getSerializedSize();
1431    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1432    assertTrue(msgSerializedSize == 10);
1433    assertEquals(result.length, msgSerializedSize);
1434    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1435    assertEquals(1, newMsg.getRepeatedDoubleCount());
1436    assertTrue(123.0 == newMsg.getRepeatedDouble(0));
1437
1438    // Test 2 entries
1439    msg.clear()
1440       .addRepeatedDouble(123.0)
1441       .addRepeatedDouble(456.0);
1442    assertEquals(2, msg.getRepeatedDoubleCount());
1443    result = msg.toByteArray();
1444    msgSerializedSize = msg.getSerializedSize();
1445    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1446    assertTrue(msgSerializedSize == 20);
1447    assertEquals(result.length, msgSerializedSize);
1448
1449    newMsg = TestAllTypesMicro.parseFrom(result);
1450    assertEquals(2, newMsg.getRepeatedDoubleCount());
1451    assertTrue(123.0 == newMsg.getRepeatedDouble(0));
1452    assertTrue(456.0 == newMsg.getRepeatedDouble(1));
1453  }
1454
1455  public void testMicroRepeatedBool() throws Exception {
1456    TestAllTypesMicro msg = new TestAllTypesMicro();
1457    assertEquals(0, msg.getRepeatedBoolCount());
1458    msg.addRepeatedBool(true);
1459    assertEquals(1, msg.getRepeatedBoolCount());
1460    assertEquals(true, msg.getRepeatedBool(0));
1461    msg.addRepeatedBool(false);
1462    assertEquals(2, msg.getRepeatedBoolCount());
1463    assertEquals(true, msg.getRepeatedBool(0));
1464    assertEquals(false, msg.getRepeatedBool(1));
1465    msg.setRepeatedBool(0, false);
1466    assertEquals(2, msg.getRepeatedBoolCount());
1467    assertEquals(false, msg.getRepeatedBool(0));
1468    assertEquals(false, msg.getRepeatedBool(1));
1469    msg.clearRepeatedBool();
1470    assertEquals(0, msg.getRepeatedBoolCount());
1471    msg.clearRepeatedBool()
1472       .addRepeatedBool(true);
1473    assertEquals(1, msg.getRepeatedBoolCount());
1474    assertEquals(true, msg.getRepeatedBool(0));
1475    msg.clear();
1476    assertEquals(0, msg.getRepeatedBoolCount());
1477
1478    // Test 1 entry
1479    msg.clear()
1480       .addRepeatedBool(false);
1481    assertEquals(1, msg.getRepeatedBoolCount());
1482    byte [] result = msg.toByteArray();
1483    int msgSerializedSize = msg.getSerializedSize();
1484    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1485    assertTrue(msgSerializedSize == 3);
1486    assertEquals(result.length, msgSerializedSize);
1487    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1488    assertEquals(1, newMsg.getRepeatedBoolCount());
1489    assertEquals(false, newMsg.getRepeatedBool(0));
1490
1491    // Test 2 entries
1492    msg.clear()
1493       .addRepeatedBool(true)
1494       .addRepeatedBool(false);
1495    assertEquals(2, msg.getRepeatedBoolCount());
1496    result = msg.toByteArray();
1497    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
1502    newMsg = TestAllTypesMicro.parseFrom(result);
1503    assertEquals(2, newMsg.getRepeatedBoolCount());
1504    assertEquals(true, newMsg.getRepeatedBool(0));
1505    assertEquals(false, newMsg.getRepeatedBool(1));
1506  }
1507
1508  public void testMicroRepeatedString() throws Exception {
1509    TestAllTypesMicro msg = new TestAllTypesMicro();
1510    assertEquals(0, msg.getRepeatedStringCount());
1511    msg.addRepeatedString("hello");
1512    assertEquals(1, msg.getRepeatedStringCount());
1513    assertEquals("hello", msg.getRepeatedString(0));
1514    msg.addRepeatedString("bye");
1515    assertEquals(2, msg.getRepeatedStringCount());
1516    assertEquals("hello", msg.getRepeatedString(0));
1517    assertEquals("bye", msg.getRepeatedString(1));
1518    msg.setRepeatedString(0, "boo");
1519    assertEquals(2, msg.getRepeatedStringCount());
1520    assertEquals("boo", msg.getRepeatedString(0));
1521    assertEquals("bye", msg.getRepeatedString(1));
1522    msg.clearRepeatedString();
1523    assertEquals(0, msg.getRepeatedStringCount());
1524    msg.clearRepeatedString()
1525       .addRepeatedString("hello");
1526    assertEquals(1, msg.getRepeatedStringCount());
1527    assertEquals("hello", msg.getRepeatedString(0));
1528    msg.clear();
1529    assertEquals(0, msg.getRepeatedStringCount());
1530
1531    // Test 1 entry and an empty string
1532    msg.clear()
1533       .addRepeatedString("");
1534    assertEquals(1, msg.getRepeatedStringCount());
1535    byte [] result = msg.toByteArray();
1536    int msgSerializedSize = msg.getSerializedSize();
1537    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1538    assertTrue(msgSerializedSize == 3);
1539    assertEquals(result.length, msgSerializedSize);
1540    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1541    assertEquals(1, newMsg.getRepeatedStringCount());
1542    assertEquals("", newMsg.getRepeatedString(0));
1543
1544    // Test 2 entries
1545    msg.clear()
1546       .addRepeatedString("hello")
1547       .addRepeatedString("world");
1548    assertEquals(2, msg.getRepeatedStringCount());
1549    result = msg.toByteArray();
1550    msgSerializedSize = msg.getSerializedSize();
1551    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1552    assertTrue(msgSerializedSize == 16);
1553    assertEquals(result.length, msgSerializedSize);
1554
1555    newMsg = TestAllTypesMicro.parseFrom(result);
1556    assertEquals(2, newMsg.getRepeatedStringCount());
1557    assertEquals("hello", newMsg.getRepeatedString(0));
1558    assertEquals("world", newMsg.getRepeatedString(1));
1559  }
1560
1561  public void testMicroRepeatedBytes() throws Exception {
1562    TestAllTypesMicro msg = new TestAllTypesMicro();
1563    assertEquals(0, msg.getRepeatedBytesCount());
1564    msg.addRepeatedBytes(ByteStringMicro.copyFromUtf8("hello"));
1565    assertEquals(1, msg.getRepeatedBytesCount());
1566    assertEquals("hello", msg.getRepeatedBytes(0).toStringUtf8());
1567    msg.addRepeatedBytes(ByteStringMicro.copyFromUtf8("bye"));
1568    assertEquals(2, msg.getRepeatedBytesCount());
1569    assertEquals("hello", msg.getRepeatedBytes(0).toStringUtf8());
1570    assertEquals("bye", msg.getRepeatedBytes(1).toStringUtf8());
1571    msg.setRepeatedBytes(0, ByteStringMicro.copyFromUtf8("boo"));
1572    assertEquals(2, msg.getRepeatedBytesCount());
1573    assertEquals("boo", msg.getRepeatedBytes(0).toStringUtf8());
1574    assertEquals("bye", msg.getRepeatedBytes(1).toStringUtf8());
1575    msg.clearRepeatedBytes();
1576    assertEquals(0, msg.getRepeatedBytesCount());
1577    msg.clearRepeatedBytes()
1578       .addRepeatedBytes(ByteStringMicro.copyFromUtf8("hello"));
1579    assertEquals(1, msg.getRepeatedBytesCount());
1580    assertEquals("hello", msg.getRepeatedBytes(0).toStringUtf8());
1581    msg.clear();
1582    assertEquals(0, msg.getRepeatedBytesCount());
1583
1584    // Test 1 entry and an empty byte array can be serialized
1585    msg.clear()
1586       .addRepeatedBytes(ByteStringMicro.copyFromUtf8(""));
1587    assertEquals(1, msg.getRepeatedBytesCount());
1588    assertEquals("", msg.getRepeatedBytes(0).toStringUtf8());
1589    byte [] result = msg.toByteArray();
1590    int msgSerializedSize = msg.getSerializedSize();
1591    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1592    assertTrue(msgSerializedSize == 3);
1593    assertEquals(result.length, msgSerializedSize);
1594    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1595    assertEquals(1, newMsg.getRepeatedBytesCount());
1596    assertEquals("", newMsg.getRepeatedBytes(0).toStringUtf8());
1597
1598    // Test 2 entries
1599    msg.clear()
1600       .addRepeatedBytes(ByteStringMicro.copyFromUtf8("hello"))
1601       .addRepeatedBytes(ByteStringMicro.copyFromUtf8("world"));
1602    assertEquals(2, msg.getRepeatedBytesCount());
1603    result = msg.toByteArray();
1604    msgSerializedSize = msg.getSerializedSize();
1605    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1606    assertTrue(msgSerializedSize == 16);
1607    assertEquals(result.length, msgSerializedSize);
1608
1609    newMsg = TestAllTypesMicro.parseFrom(result);
1610    assertEquals(2, newMsg.getRepeatedBytesCount());
1611    assertEquals("hello", newMsg.getRepeatedBytes(0).toStringUtf8());
1612    assertEquals("world", newMsg.getRepeatedBytes(1).toStringUtf8());
1613  }
1614
1615  public void testMicroRepeatedGroup() throws Exception {
1616    TestAllTypesMicro msg = new TestAllTypesMicro();
1617    TestAllTypesMicro.RepeatedGroup group0 =
1618      new TestAllTypesMicro.RepeatedGroup().setA(0);
1619    TestAllTypesMicro.RepeatedGroup group1 =
1620      new TestAllTypesMicro.RepeatedGroup().setA(1);
1621    TestAllTypesMicro.RepeatedGroup group2 =
1622      new TestAllTypesMicro.RepeatedGroup().setA(2);
1623
1624    msg.addRepeatedGroup(group0);
1625    assertEquals(1, msg.getRepeatedGroupCount());
1626    assertEquals(0, msg.getRepeatedGroup(0).getA());
1627    msg.addRepeatedGroup(group1);
1628    assertEquals(2, msg.getRepeatedGroupCount());
1629    assertEquals(0, msg.getRepeatedGroup(0).getA());
1630    assertEquals(1, msg.getRepeatedGroup(1).getA());
1631    msg.setRepeatedGroup(0, group2);
1632    assertEquals(2, msg.getRepeatedGroupCount());
1633    assertEquals(2, msg.getRepeatedGroup(0).getA());
1634    assertEquals(1, msg.getRepeatedGroup(1).getA());
1635    msg.clearRepeatedGroup();
1636    assertEquals(0, msg.getRepeatedGroupCount());
1637    msg.clearRepeatedGroup()
1638       .addRepeatedGroup(group1);
1639    assertEquals(1, msg.getRepeatedGroupCount());
1640    assertEquals(1, msg.getRepeatedGroup(0).getA());
1641    msg.clear();
1642    assertEquals(0, msg.getRepeatedGroupCount());
1643
1644    // Test 1 entry
1645    msg.clear()
1646       .addRepeatedGroup(group0);
1647    assertEquals(1, msg.getRepeatedGroupCount());
1648    byte [] result = msg.toByteArray();
1649    int msgSerializedSize = msg.getSerializedSize();
1650    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1651    assertTrue(msgSerializedSize == 7);
1652    assertEquals(result.length, msgSerializedSize);
1653    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1654    assertEquals(1, newMsg.getRepeatedGroupCount());
1655    assertEquals(0, newMsg.getRepeatedGroup(0).getA());
1656
1657    // Test 2 entries
1658    msg.clear()
1659       .addRepeatedGroup(group0)
1660       .addRepeatedGroup(group1);
1661    assertEquals(2, msg.getRepeatedGroupCount());
1662    result = msg.toByteArray();
1663    msgSerializedSize = msg.getSerializedSize();
1664    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1665    assertTrue(msgSerializedSize == 14);
1666    assertEquals(result.length, msgSerializedSize);
1667
1668    newMsg = TestAllTypesMicro.parseFrom(result);
1669    assertEquals(2, newMsg.getRepeatedGroupCount());
1670    assertEquals(0, newMsg.getRepeatedGroup(0).getA());
1671    assertEquals(1, newMsg.getRepeatedGroup(1).getA());
1672  }
1673
1674
1675  public void testMicroRepeatedNestedMessage() throws Exception {
1676    TestAllTypesMicro msg = new TestAllTypesMicro();
1677    TestAllTypesMicro.NestedMessage nestedMsg0 =
1678      new TestAllTypesMicro.NestedMessage().setBb(0);
1679    TestAllTypesMicro.NestedMessage nestedMsg1 =
1680      new TestAllTypesMicro.NestedMessage().setBb(1);
1681    TestAllTypesMicro.NestedMessage nestedMsg2 =
1682      new TestAllTypesMicro.NestedMessage().setBb(2);
1683
1684    msg.addRepeatedNestedMessage(nestedMsg0);
1685    assertEquals(1, msg.getRepeatedNestedMessageCount());
1686    assertEquals(0, msg.getRepeatedNestedMessage(0).getBb());
1687    msg.addRepeatedNestedMessage(nestedMsg1);
1688    assertEquals(2, msg.getRepeatedNestedMessageCount());
1689    assertEquals(0, msg.getRepeatedNestedMessage(0).getBb());
1690    assertEquals(1, msg.getRepeatedNestedMessage(1).getBb());
1691    msg.setRepeatedNestedMessage(0, nestedMsg2);
1692    assertEquals(2, msg.getRepeatedNestedMessageCount());
1693    assertEquals(2, msg.getRepeatedNestedMessage(0).getBb());
1694    assertEquals(1, msg.getRepeatedNestedMessage(1).getBb());
1695    msg.clearRepeatedNestedMessage();
1696    assertEquals(0, msg.getRepeatedNestedMessageCount());
1697    msg.clearRepeatedNestedMessage()
1698       .addRepeatedNestedMessage(nestedMsg1);
1699    assertEquals(1, msg.getRepeatedNestedMessageCount());
1700    assertEquals(1, msg.getRepeatedNestedMessage(0).getBb());
1701    msg.clear();
1702    assertEquals(0, msg.getRepeatedNestedMessageCount());
1703
1704    // Test 1 entry
1705    msg.clear()
1706       .addRepeatedNestedMessage(nestedMsg0);
1707    assertEquals(1, msg.getRepeatedNestedMessageCount());
1708    byte [] result = msg.toByteArray();
1709    int msgSerializedSize = msg.getSerializedSize();
1710    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1711    assertTrue(msgSerializedSize == 5);
1712    assertEquals(result.length, msgSerializedSize);
1713    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1714    assertEquals(1, newMsg.getRepeatedNestedMessageCount());
1715    assertEquals(0, newMsg.getRepeatedNestedMessage(0).getBb());
1716
1717    // Test 2 entries
1718    msg.clear()
1719       .addRepeatedNestedMessage(nestedMsg0)
1720       .addRepeatedNestedMessage(nestedMsg1);
1721    assertEquals(2, msg.getRepeatedNestedMessageCount());
1722    result = msg.toByteArray();
1723    msgSerializedSize = msg.getSerializedSize();
1724    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1725    assertTrue(msgSerializedSize == 10);
1726    assertEquals(result.length, msgSerializedSize);
1727
1728    newMsg = TestAllTypesMicro.parseFrom(result);
1729    assertEquals(2, newMsg.getRepeatedNestedMessageCount());
1730    assertEquals(0, newMsg.getRepeatedNestedMessage(0).getBb());
1731    assertEquals(1, newMsg.getRepeatedNestedMessage(1).getBb());
1732  }
1733
1734  public void testMicroRepeatedForeignMessage() throws Exception {
1735    TestAllTypesMicro msg = new TestAllTypesMicro();
1736    MicroOuterClass.ForeignMessageMicro foreignMsg0 =
1737      new MicroOuterClass.ForeignMessageMicro().setC(0);
1738    MicroOuterClass.ForeignMessageMicro foreignMsg1 =
1739      new MicroOuterClass.ForeignMessageMicro().setC(1);
1740    MicroOuterClass.ForeignMessageMicro foreignMsg2 =
1741      new MicroOuterClass.ForeignMessageMicro().setC(2);
1742
1743    msg.addRepeatedForeignMessage(foreignMsg0);
1744    assertEquals(1, msg.getRepeatedForeignMessageCount());
1745    assertEquals(0, msg.getRepeatedForeignMessage(0).getC());
1746    msg.addRepeatedForeignMessage(foreignMsg1);
1747    assertEquals(2, msg.getRepeatedForeignMessageCount());
1748    assertEquals(0, msg.getRepeatedForeignMessage(0).getC());
1749    assertEquals(1, msg.getRepeatedForeignMessage(1).getC());
1750    msg.setRepeatedForeignMessage(0, foreignMsg2);
1751    assertEquals(2, msg.getRepeatedForeignMessageCount());
1752    assertEquals(2, msg.getRepeatedForeignMessage(0).getC());
1753    assertEquals(1, msg.getRepeatedForeignMessage(1).getC());
1754    msg.clearRepeatedForeignMessage();
1755    assertEquals(0, msg.getRepeatedForeignMessageCount());
1756    msg.clearRepeatedForeignMessage()
1757       .addRepeatedForeignMessage(foreignMsg1);
1758    assertEquals(1, msg.getRepeatedForeignMessageCount());
1759    assertEquals(1, msg.getRepeatedForeignMessage(0).getC());
1760    msg.clear();
1761    assertEquals(0, msg.getRepeatedForeignMessageCount());
1762
1763    // Test 1 entry
1764    msg.clear()
1765       .addRepeatedForeignMessage(foreignMsg0);
1766    assertEquals(1, msg.getRepeatedForeignMessageCount());
1767    byte [] result = msg.toByteArray();
1768    int msgSerializedSize = msg.getSerializedSize();
1769    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1770    assertTrue(msgSerializedSize == 5);
1771    assertEquals(result.length, msgSerializedSize);
1772    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1773    assertEquals(1, newMsg.getRepeatedForeignMessageCount());
1774    assertEquals(0, newMsg.getRepeatedForeignMessage(0).getC());
1775
1776    // Test 2 entries
1777    msg.clear()
1778       .addRepeatedForeignMessage(foreignMsg0)
1779       .addRepeatedForeignMessage(foreignMsg1);
1780    assertEquals(2, msg.getRepeatedForeignMessageCount());
1781    result = msg.toByteArray();
1782    msgSerializedSize = msg.getSerializedSize();
1783    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1784    assertTrue(msgSerializedSize == 10);
1785    assertEquals(result.length, msgSerializedSize);
1786
1787    newMsg = TestAllTypesMicro.parseFrom(result);
1788    assertEquals(2, newMsg.getRepeatedForeignMessageCount());
1789    assertEquals(0, newMsg.getRepeatedForeignMessage(0).getC());
1790    assertEquals(1, newMsg.getRepeatedForeignMessage(1).getC());
1791  }
1792
1793  public void testMicroRepeatedImportMessage() throws Exception {
1794    TestAllTypesMicro msg = new TestAllTypesMicro();
1795    UnittestImportMicro.ImportMessageMicro importMsg0 =
1796      new UnittestImportMicro.ImportMessageMicro().setD(0);
1797    UnittestImportMicro.ImportMessageMicro importMsg1 =
1798      new UnittestImportMicro.ImportMessageMicro().setD(1);
1799    UnittestImportMicro.ImportMessageMicro importMsg2 =
1800      new UnittestImportMicro.ImportMessageMicro().setD(2);
1801
1802    msg.addRepeatedImportMessage(importMsg0);
1803    assertEquals(1, msg.getRepeatedImportMessageCount());
1804    assertEquals(0, msg.getRepeatedImportMessage(0).getD());
1805    msg.addRepeatedImportMessage(importMsg1);
1806    assertEquals(2, msg.getRepeatedImportMessageCount());
1807    assertEquals(0, msg.getRepeatedImportMessage(0).getD());
1808    assertEquals(1, msg.getRepeatedImportMessage(1).getD());
1809    msg.setRepeatedImportMessage(0, importMsg2);
1810    assertEquals(2, msg.getRepeatedImportMessageCount());
1811    assertEquals(2, msg.getRepeatedImportMessage(0).getD());
1812    assertEquals(1, msg.getRepeatedImportMessage(1).getD());
1813    msg.clearRepeatedImportMessage();
1814    assertEquals(0, msg.getRepeatedImportMessageCount());
1815    msg.clearRepeatedImportMessage()
1816       .addRepeatedImportMessage(importMsg1);
1817    assertEquals(1, msg.getRepeatedImportMessageCount());
1818    assertEquals(1, msg.getRepeatedImportMessage(0).getD());
1819    msg.clear();
1820    assertEquals(0, msg.getRepeatedImportMessageCount());
1821
1822    // Test 1 entry
1823    msg.clear()
1824       .addRepeatedImportMessage(importMsg0);
1825    assertEquals(1, msg.getRepeatedImportMessageCount());
1826    byte [] result = msg.toByteArray();
1827    int msgSerializedSize = msg.getSerializedSize();
1828    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1829    assertTrue(msgSerializedSize == 5);
1830    assertEquals(result.length, msgSerializedSize);
1831    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1832    assertEquals(1, newMsg.getRepeatedImportMessageCount());
1833    assertEquals(0, newMsg.getRepeatedImportMessage(0).getD());
1834
1835    // Test 2 entries
1836    msg.clear()
1837       .addRepeatedImportMessage(importMsg0)
1838       .addRepeatedImportMessage(importMsg1);
1839    assertEquals(2, msg.getRepeatedImportMessageCount());
1840    result = msg.toByteArray();
1841    msgSerializedSize = msg.getSerializedSize();
1842    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1843    assertTrue(msgSerializedSize == 10);
1844    assertEquals(result.length, msgSerializedSize);
1845
1846    newMsg = TestAllTypesMicro.parseFrom(result);
1847    assertEquals(2, newMsg.getRepeatedImportMessageCount());
1848    assertEquals(0, newMsg.getRepeatedImportMessage(0).getD());
1849    assertEquals(1, newMsg.getRepeatedImportMessage(1).getD());
1850  }
1851
1852  public void testMicroRepeatedNestedEnum() throws Exception {
1853    TestAllTypesMicro msg = new TestAllTypesMicro();
1854    msg.addRepeatedNestedEnum(TestAllTypesMicro.FOO);
1855    assertEquals(1, msg.getRepeatedNestedEnumCount());
1856    assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
1857    msg.addRepeatedNestedEnum(TestAllTypesMicro.BAR);
1858    assertEquals(2, msg.getRepeatedNestedEnumCount());
1859    assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
1860    assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
1861    msg.setRepeatedNestedEnum(0, TestAllTypesMicro.BAZ);
1862    assertEquals(2, msg.getRepeatedNestedEnumCount());
1863    assertEquals(TestAllTypesMicro.BAZ, msg.getRepeatedNestedEnum(0));
1864    assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
1865    msg.clearRepeatedNestedEnum();
1866    assertEquals(0, msg.getRepeatedNestedEnumCount());
1867    msg.clearRepeatedNestedEnum()
1868       .addRepeatedNestedEnum(TestAllTypesMicro.BAR);
1869    assertEquals(1, msg.getRepeatedNestedEnumCount());
1870    assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(0));
1871    msg.clear();
1872    assertEquals(0, msg.getRepeatedNestedEnumCount());
1873
1874    // Test 1 entry
1875    msg.clear()
1876       .addRepeatedNestedEnum(TestAllTypesMicro.FOO);
1877    byte [] result = msg.toByteArray();
1878    int msgSerializedSize = msg.getSerializedSize();
1879    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1880    assertTrue(msgSerializedSize == 3);
1881    assertEquals(result.length, msgSerializedSize);
1882    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1883    assertEquals(1, newMsg.getRepeatedNestedEnumCount());
1884    assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
1885
1886    // Test 2 entries
1887    msg.clear()
1888       .addRepeatedNestedEnum(TestAllTypesMicro.FOO)
1889       .addRepeatedNestedEnum(TestAllTypesMicro.BAR);
1890    assertEquals(2, msg.getRepeatedNestedEnumCount());
1891    result = msg.toByteArray();
1892    msgSerializedSize = msg.getSerializedSize();
1893    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1894    assertTrue(msgSerializedSize == 6);
1895    assertEquals(result.length, msgSerializedSize);
1896
1897    newMsg = TestAllTypesMicro.parseFrom(result);
1898    assertEquals(2, newMsg.getRepeatedNestedEnumCount());
1899    assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
1900    assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
1901  }
1902
1903  public void testMicroRepeatedForeignEnum() throws Exception {
1904    TestAllTypesMicro msg = new TestAllTypesMicro();
1905    msg.addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_FOO);
1906    assertEquals(1, msg.getRepeatedForeignEnumCount());
1907    assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
1908    msg.addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
1909    assertEquals(2, msg.getRepeatedForeignEnumCount());
1910    assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
1911    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
1912    msg.setRepeatedForeignEnum(0, MicroOuterClass.FOREIGN_MICRO_BAZ);
1913    assertEquals(2, msg.getRepeatedForeignEnumCount());
1914    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAZ, msg.getRepeatedForeignEnum(0));
1915    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
1916    msg.clearRepeatedForeignEnum();
1917    assertEquals(0, msg.getRepeatedForeignEnumCount());
1918    msg.clearRepeatedForeignEnum()
1919       .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
1920    assertEquals(1, msg.getRepeatedForeignEnumCount());
1921    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(0));
1922    msg.clear();
1923    assertEquals(0, msg.getRepeatedForeignEnumCount());
1924
1925    // Test 1 entry
1926    msg.clear()
1927       .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_FOO);
1928    byte [] result = msg.toByteArray();
1929    int msgSerializedSize = msg.getSerializedSize();
1930    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1931    assertTrue(msgSerializedSize == 3);
1932    assertEquals(result.length, msgSerializedSize);
1933    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1934    assertEquals(1, newMsg.getRepeatedForeignEnumCount());
1935    assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
1936
1937    // Test 2 entries
1938    msg.clear()
1939       .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_FOO)
1940       .addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
1941    assertEquals(2, msg.getRepeatedForeignEnumCount());
1942    result = msg.toByteArray();
1943    msgSerializedSize = msg.getSerializedSize();
1944    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1945    assertTrue(msgSerializedSize == 6);
1946    assertEquals(result.length, msgSerializedSize);
1947
1948    newMsg = TestAllTypesMicro.parseFrom(result);
1949    assertEquals(2, newMsg.getRepeatedForeignEnumCount());
1950    assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
1951    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
1952  }
1953
1954  public void testMicroRepeatedImportEnum() throws Exception {
1955    TestAllTypesMicro msg = new TestAllTypesMicro();
1956    msg.addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_FOO);
1957    assertEquals(1, msg.getRepeatedImportEnumCount());
1958    assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
1959    msg.addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
1960    assertEquals(2, msg.getRepeatedImportEnumCount());
1961    assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
1962    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
1963    msg.setRepeatedImportEnum(0, UnittestImportMicro.IMPORT_MICRO_BAZ);
1964    assertEquals(2, msg.getRepeatedImportEnumCount());
1965    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAZ, msg.getRepeatedImportEnum(0));
1966    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
1967    msg.clearRepeatedImportEnum();
1968    assertEquals(0, msg.getRepeatedImportEnumCount());
1969    msg.clearRepeatedImportEnum()
1970       .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
1971    assertEquals(1, msg.getRepeatedImportEnumCount());
1972    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(0));
1973    msg.clear();
1974    assertEquals(0, msg.getRepeatedImportEnumCount());
1975
1976    // Test 1 entry
1977    msg.clear()
1978       .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_FOO);
1979    byte [] result = msg.toByteArray();
1980    int msgSerializedSize = msg.getSerializedSize();
1981    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1982    assertTrue(msgSerializedSize == 3);
1983    assertEquals(result.length, msgSerializedSize);
1984    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
1985    assertEquals(1, newMsg.getRepeatedImportEnumCount());
1986    assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
1987
1988    // Test 2 entries
1989    msg.clear()
1990       .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_FOO)
1991       .addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
1992    assertEquals(2, msg.getRepeatedImportEnumCount());
1993    result = msg.toByteArray();
1994    msgSerializedSize = msg.getSerializedSize();
1995    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
1996    assertTrue(msgSerializedSize == 6);
1997    assertEquals(result.length, msgSerializedSize);
1998
1999    newMsg = TestAllTypesMicro.parseFrom(result);
2000    assertEquals(2, newMsg.getRepeatedImportEnumCount());
2001    assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
2002    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
2003  }
2004
2005  public void testMicroRepeatedStringPiece() throws Exception {
2006    TestAllTypesMicro msg = new TestAllTypesMicro();
2007    assertEquals(0, msg.getRepeatedStringPieceCount());
2008    msg.addRepeatedStringPiece("hello");
2009    assertEquals(1, msg.getRepeatedStringPieceCount());
2010    assertEquals("hello", msg.getRepeatedStringPiece(0));
2011    msg.addRepeatedStringPiece("bye");
2012    assertEquals(2, msg.getRepeatedStringPieceCount());
2013    assertEquals("hello", msg.getRepeatedStringPiece(0));
2014    assertEquals("bye", msg.getRepeatedStringPiece(1));
2015    msg.setRepeatedStringPiece(0, "boo");
2016    assertEquals(2, msg.getRepeatedStringPieceCount());
2017    assertEquals("boo", msg.getRepeatedStringPiece(0));
2018    assertEquals("bye", msg.getRepeatedStringPiece(1));
2019    msg.clearRepeatedStringPiece();
2020    assertEquals(0, msg.getRepeatedStringPieceCount());
2021    msg.clearRepeatedStringPiece()
2022       .addRepeatedStringPiece("hello");
2023    assertEquals(1, msg.getRepeatedStringPieceCount());
2024    assertEquals("hello", msg.getRepeatedStringPiece(0));
2025    msg.clear();
2026    assertEquals(0, msg.getRepeatedStringPieceCount());
2027
2028    // Test 1 entry and an empty string
2029    msg.clear()
2030       .addRepeatedStringPiece("");
2031    assertEquals(1, msg.getRepeatedStringPieceCount());
2032    byte [] result = msg.toByteArray();
2033    int msgSerializedSize = msg.getSerializedSize();
2034    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
2035    assertTrue(msgSerializedSize == 3);
2036    assertEquals(result.length, msgSerializedSize);
2037    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
2038    assertEquals(1, newMsg.getRepeatedStringPieceCount());
2039    assertEquals("", newMsg.getRepeatedStringPiece(0));
2040
2041    // Test 2 entries
2042    msg.clear()
2043       .addRepeatedStringPiece("hello")
2044       .addRepeatedStringPiece("world");
2045    assertEquals(2, msg.getRepeatedStringPieceCount());
2046    result = msg.toByteArray();
2047    msgSerializedSize = msg.getSerializedSize();
2048    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
2049    assertTrue(msgSerializedSize == 16);
2050    assertEquals(result.length, msgSerializedSize);
2051
2052    newMsg = TestAllTypesMicro.parseFrom(result);
2053    assertEquals(2, newMsg.getRepeatedStringPieceCount());
2054    assertEquals("hello", newMsg.getRepeatedStringPiece(0));
2055    assertEquals("world", newMsg.getRepeatedStringPiece(1));
2056  }
2057
2058  public void testMicroRepeatedCord() throws Exception {
2059    TestAllTypesMicro msg = new TestAllTypesMicro();
2060    assertEquals(0, msg.getRepeatedCordCount());
2061    msg.addRepeatedCord("hello");
2062    assertEquals(1, msg.getRepeatedCordCount());
2063    assertEquals("hello", msg.getRepeatedCord(0));
2064    msg.addRepeatedCord("bye");
2065    assertEquals(2, msg.getRepeatedCordCount());
2066    assertEquals("hello", msg.getRepeatedCord(0));
2067    assertEquals("bye", msg.getRepeatedCord(1));
2068    msg.setRepeatedCord(0, "boo");
2069    assertEquals(2, msg.getRepeatedCordCount());
2070    assertEquals("boo", msg.getRepeatedCord(0));
2071    assertEquals("bye", msg.getRepeatedCord(1));
2072    msg.clearRepeatedCord();
2073    assertEquals(0, msg.getRepeatedCordCount());
2074    msg.clearRepeatedCord()
2075       .addRepeatedCord("hello");
2076    assertEquals(1, msg.getRepeatedCordCount());
2077    assertEquals("hello", msg.getRepeatedCord(0));
2078    msg.clear();
2079    assertEquals(0, msg.getRepeatedCordCount());
2080
2081    // Test 1 entry and an empty string
2082    msg.clear()
2083       .addRepeatedCord("");
2084    assertEquals(1, msg.getRepeatedCordCount());
2085    byte [] result = msg.toByteArray();
2086    int msgSerializedSize = msg.getSerializedSize();
2087    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
2088    assertTrue(msgSerializedSize == 3);
2089    assertEquals(result.length, msgSerializedSize);
2090    TestAllTypesMicro newMsg = TestAllTypesMicro.parseFrom(result);
2091    assertEquals(1, newMsg.getRepeatedCordCount());
2092    assertEquals("", newMsg.getRepeatedCord(0));
2093
2094    // Test 2 entries
2095    msg.clear()
2096       .addRepeatedCord("hello")
2097       .addRepeatedCord("world");
2098    assertEquals(2, msg.getRepeatedCordCount());
2099    result = msg.toByteArray();
2100    msgSerializedSize = msg.getSerializedSize();
2101    //System.out.printf("mss=%d result.length=%d\n", msgSerializedSize, result.length);
2102    assertTrue(msgSerializedSize == 16);
2103    assertEquals(result.length, msgSerializedSize);
2104
2105    newMsg = TestAllTypesMicro.parseFrom(result);
2106    assertEquals(2, newMsg.getRepeatedCordCount());
2107    assertEquals("hello", newMsg.getRepeatedCord(0));
2108    assertEquals("world", newMsg.getRepeatedCord(1));
2109  }
2110
2111  /**
2112   * Tests that code generation correctly wraps a single message into its outer
2113   * class. The class {@code SingleMessageMicro} is imported from the outer
2114   * class {@code UnittestSingleMicro}, whose name is implicit. Any error would
2115   * cause this method to fail compilation.
2116   */
2117  public void testMicroSingle() throws Exception {
2118    SingleMessageMicro msg = new SingleMessageMicro();
2119  }
2120
2121  /**
2122   * Tests that code generation correctly skips generating the outer class if
2123   * unnecessary, letting a file-scope entity have the same name. The class
2124   * {@code MultipleNameClashMicro} shares the same name with the file's outer
2125   * class defined explicitly, but the file contains no other entities and has
2126   * java_multiple_files set. Any error would cause this method to fail
2127   * compilation.
2128   */
2129  public void testMicroMultipleNameClash() throws Exception {
2130    MultipleNameClashMicro msg = new MultipleNameClashMicro();
2131    msg.setField(0);
2132  }
2133
2134  /**
2135   * Tests that code generation correctly handles enums in different scopes in
2136   * a source file with the option java_multiple_files set to true. Any error
2137   * would cause this method to fail compilation.
2138   */
2139  public void testMicroMultipleEnumScoping() throws Exception {
2140    FileScopeEnumRefMicro msg1 = new FileScopeEnumRefMicro();
2141    msg1.setEnumField(UnittestMultipleMicro.ONE);
2142    MessageScopeEnumRefMicro msg2 = new MessageScopeEnumRefMicro();
2143    msg2.setEnumField(MessageScopeEnumRefMicro.TWO);
2144  }
2145
2146  /**
2147   * Tests that code generation with mixed values of the java_multiple_files
2148   * options between the main source file and the imported source files would
2149   * generate correct references. Any error would cause this method to fail
2150   * compilation.
2151   */
2152  public void testMicroMultipleImportingNonMultiple() throws Exception {
2153    UnittestImportMicro.ImportMessageMicro importMsg =
2154        new UnittestImportMicro.ImportMessageMicro();
2155    MultipleImportingNonMultipleMicro1 micro1 = new MultipleImportingNonMultipleMicro1();
2156    micro1.setField(importMsg);
2157    MultipleImportingNonMultipleMicro2 micro2 = new MultipleImportingNonMultipleMicro2();
2158    micro2.setMicro1(micro1);
2159  }
2160
2161  public void testMicroDefaults() throws Exception {
2162    TestAllTypesMicro msg = new TestAllTypesMicro();
2163    assertFalse(msg.hasDefaultInt32());
2164    assertEquals(41, msg.getDefaultInt32());
2165    assertFalse(msg.hasDefaultInt64());
2166    assertEquals(42, msg.getDefaultInt64());
2167    assertFalse(msg.hasDefaultUint32());
2168    assertEquals(43, msg.getDefaultUint32());
2169    assertFalse(msg.hasDefaultUint64());
2170    assertEquals(44, msg.getDefaultUint64());
2171    assertFalse(msg.hasDefaultSint32());
2172    assertEquals(-45, msg.getDefaultSint32());
2173    assertFalse(msg.hasDefaultSint64());
2174    assertEquals(46, msg.getDefaultSint64());
2175    assertFalse(msg.hasDefaultFixed32());
2176    assertEquals(47, msg.getDefaultFixed32());
2177    assertFalse(msg.hasDefaultFixed64());
2178    assertEquals(48, msg.getDefaultFixed64());
2179    assertFalse(msg.hasDefaultSfixed32());
2180    assertEquals(49, msg.getDefaultSfixed32());
2181    assertFalse(msg.hasDefaultSfixed64());
2182    assertEquals(-50, msg.getDefaultSfixed64());
2183    assertFalse(msg.hasDefaultFloat());
2184    assertTrue(51.5f == msg.getDefaultFloat());
2185    assertFalse(msg.hasDefaultDouble());
2186    assertTrue(52.0e3 == msg.getDefaultDouble());
2187    assertFalse(msg.hasDefaultBool());
2188    assertEquals(true, msg.getDefaultBool());
2189    assertFalse(msg.hasDefaultString());
2190    assertEquals("hello", msg.getDefaultString());
2191    assertFalse(msg.hasDefaultBytes());
2192    assertEquals("world", msg.getDefaultBytes().toStringUtf8());
2193    assertFalse(msg.hasDefaultNestedEnum());
2194    assertEquals(TestAllTypesMicro.BAR, msg.getDefaultNestedEnum());
2195    assertFalse(msg.hasDefaultForeignEnum());
2196    assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getDefaultForeignEnum());
2197    assertFalse(msg.hasDefaultImportEnum());
2198    assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getDefaultImportEnum());
2199    assertFalse(msg.hasDefaultFloatInf());
2200    assertEquals(Float.POSITIVE_INFINITY, msg.getDefaultFloatInf());
2201    assertFalse(msg.hasDefaultFloatNegInf());
2202    assertEquals(Float.NEGATIVE_INFINITY, msg.getDefaultFloatNegInf());
2203    assertFalse(msg.hasDefaultFloatNan());
2204    assertEquals(Float.NaN, msg.getDefaultFloatNan());
2205    assertFalse(msg.hasDefaultDoubleInf());
2206    assertEquals(Double.POSITIVE_INFINITY, msg.getDefaultDoubleInf());
2207    assertFalse(msg.hasDefaultDoubleNegInf());
2208    assertEquals(Double.NEGATIVE_INFINITY, msg.getDefaultDoubleNegInf());
2209    assertFalse(msg.hasDefaultDoubleNan());
2210    assertEquals(Double.NaN, msg.getDefaultDoubleNan());
2211  }
2212
2213  /**
2214   * Test that a bug in skipRawBytes() has been fixed:  if the skip skips
2215   * exactly up to a limit, this should not break things.
2216   */
2217  public void testSkipRawBytesBug() throws Exception {
2218    byte[] rawBytes = new byte[] { 1, 2 };
2219    CodedInputStreamMicro input = CodedInputStreamMicro.newInstance(rawBytes);
2220
2221    int limit = input.pushLimit(1);
2222    input.skipRawBytes(1);
2223    input.popLimit(limit);
2224    assertEquals(2, input.readRawByte());
2225  }
2226
2227  /**
2228   * Test that a bug in skipRawBytes() has been fixed:  if the skip skips
2229   * past the end of a buffer with a limit that has been set past the end of
2230   * that buffer, this should not break things.
2231   */
2232  public void testSkipRawBytesPastEndOfBufferWithLimit() throws Exception {
2233    byte[] rawBytes = new byte[] { 1, 2, 3, 4, 5 };
2234    CodedInputStreamMicro input = CodedInputStreamMicro.newInstance(
2235        new SmallBlockInputStream(rawBytes, 3));
2236
2237    int limit = input.pushLimit(4);
2238    // In order to expose the bug we need to read at least one byte to prime the
2239    // buffer inside the CodedInputStream.
2240    assertEquals(1, input.readRawByte());
2241    // Skip to the end of the limit.
2242    input.skipRawBytes(3);
2243    assertTrue(input.isAtEnd());
2244    input.popLimit(limit);
2245    assertEquals(5, input.readRawByte());
2246  }
2247
2248  /**
2249   * An InputStream which limits the number of bytes it reads at a time.
2250   * We use this to make sure that CodedInputStream doesn't screw up when
2251   * reading in small blocks.
2252   */
2253  private static final class SmallBlockInputStream extends FilterInputStream {
2254    private final int blockSize;
2255
2256    public SmallBlockInputStream(byte[] data, int blockSize) {
2257      this(new ByteArrayInputStream(data), blockSize);
2258    }
2259
2260    public SmallBlockInputStream(InputStream in, int blockSize) {
2261      super(in);
2262      this.blockSize = blockSize;
2263    }
2264
2265    public int read(byte[] b) throws IOException {
2266      return super.read(b, 0, Math.min(b.length, blockSize));
2267    }
2268
2269    public int read(byte[] b, int off, int len) throws IOException {
2270      return super.read(b, off, Math.min(len, blockSize));
2271    }
2272  }
2273}
2274