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