Lines Matching refs:msg
66 SimpleMessageMicro msg = new SimpleMessageMicro();
67 assertFalse(msg.hasD());
68 assertEquals(123, msg.getD());
69 assertFalse(msg.hasNestedMsg());
70 assertEquals(null, msg.getNestedMsg());
71 assertFalse(msg.hasDefaultNestedEnum());
72 assertEquals(SimpleMessageMicro.BAZ, msg.getDefaultNestedEnum());
74 msg.setD(456);
75 assertTrue(msg.hasD());
76 assertEquals(456, msg.getD());
77 msg.clearD()
79 assertTrue(msg.hasD());
85 msg.setNestedMsg(nestedMsg);
86 assertTrue(msg.hasNestedMsg());
87 assertEquals(2, msg.getNestedMsg().getBb());
89 msg.setDefaultNestedEnum(SimpleMessageMicro.BAR);
90 assertTrue(msg.hasDefaultNestedEnum());
91 assertEquals(SimpleMessageMicro.BAR, msg.getDefaultNestedEnum());
93 byte [] result = msg.toByteArray();
94 int msgSerializedSize = msg.getSerializedSize();
104 assertEquals(2, msg.getNestedMsg().getBb());
105 assertEquals(SimpleMessageMicro.BAR, msg.getDefaultNestedEnum());
109 RecursiveMessageMicro msg = new RecursiveMessageMicro();
110 assertFalse(msg.hasId());
111 assertFalse(msg.hasNestedMessage());
112 assertFalse(msg.hasOptionalRecursiveMessageMicro());
113 assertEquals(0, msg.getRepeatedRecursiveMessageMicroCount());
127 msg.setId(0);
128 msg.setNestedMessage(nestedMsg);
129 msg.setOptionalRecursiveMessageMicro(msg2);
130 msg.addRepeatedRecursiveMessageMicro(msg3);
132 byte [] result = msg.toByteArray();
133 int msgSerializedSize = msg.getSerializedSize();
151 TestAllTypesMicro msg = new TestAllTypesMicro();
152 assertFalse(msg.hasId());
153 assertFalse(msg.isInitialized());
154 msg.setId(123);
155 assertTrue(msg.hasId());
156 assertTrue(msg.isInitialized());
157 assertEquals(123, msg.getId());
158 msg.clearId();
159 assertFalse(msg.hasId());
160 assertFalse(msg.isInitialized());
161 msg.clearId()
163 assertTrue(msg.hasId());
164 msg.clear();
165 assertFalse(msg.hasId());
166 assertFalse(msg.isInitialized());
168 msg.setId(123);
169 byte [] result = msg.toByteArray();
170 int msgSerializedSize = msg.getSerializedSize();
182 TestAllTypesMicro msg = new TestAllTypesMicro();
183 assertFalse(msg.hasOptionalInt32());
184 msg.setOptionalInt32(123);
185 assertTrue(msg.hasOptionalInt32());
186 assertEquals(123, msg.getOptionalInt32());
187 msg.clearOptionalInt32();
188 assertFalse(msg.hasOptionalInt32());
189 msg.clearOptionalInt32()
191 assertTrue(msg.hasOptionalInt32());
192 msg.clear();
193 assertFalse(msg.hasOptionalInt32());
195 msg.setOptionalInt32(123);
196 byte [] result = msg.toByteArray();
197 int msgSerializedSize = msg.getSerializedSize();
208 TestAllTypesMicro msg = new TestAllTypesMicro();
209 assertFalse(msg.hasOptionalInt64());
210 msg.setOptionalInt64(123);
211 assertTrue(msg.hasOptionalInt64());
212 assertEquals(123, msg.getOptionalInt64());
213 msg.clearOptionalInt64();
214 assertFalse(msg.hasOptionalInt64());
215 msg.clearOptionalInt64()
217 assertTrue(msg.hasOptionalInt64());
218 msg.clear();
219 assertFalse(msg.hasOptionalInt64());
221 msg.setOptionalInt64(123);
222 byte [] result = msg.toByteArray();
223 int msgSerializedSize = msg.getSerializedSize();
234 TestAllTypesMicro msg = new TestAllTypesMicro();
235 assertFalse(msg.hasOptionalUint32());
236 msg.setOptionalUint32(123);
237 assertTrue(msg.hasOptionalUint32());
238 assertEquals(123, msg.getOptionalUint32());
239 msg.clearOptionalUint32();
240 assertFalse(msg.hasOptionalUint32());
241 msg.clearOptionalUint32()
243 assertTrue(msg.hasOptionalUint32());
244 msg.clear();
245 assertFalse(msg.hasOptionalUint32());
247 msg.setOptionalUint32(123);
248 byte [] result = msg.toByteArray();
249 int msgSerializedSize = msg.getSerializedSize();
260 TestAllTypesMicro msg = new TestAllTypesMicro();
261 assertFalse(msg.hasOptionalUint64());
262 msg.setOptionalUint64(123);
263 assertTrue(msg.hasOptionalUint64());
264 assertEquals(123, msg.getOptionalUint64());
265 msg.clearOptionalUint64();
266 assertFalse(msg.hasOptionalUint64());
267 msg.clearOptionalUint64()
269 assertTrue(msg.hasOptionalUint64());
270 msg.clear();
271 assertFalse(msg.hasOptionalUint64());
273 msg.setOptionalUint64(123);
274 byte [] result = msg.toByteArray();
275 int msgSerializedSize = msg.getSerializedSize();
286 TestAllTypesMicro msg = new TestAllTypesMicro();
287 assertFalse(msg.hasOptionalSint32());
288 msg.setOptionalSint32(123);
289 assertTrue(msg.hasOptionalSint32());
290 assertEquals(123, msg.getOptionalSint32());
291 msg.clearOptionalSint32();
292 assertFalse(msg.hasOptionalSint32());
293 msg.clearOptionalSint32()
295 assertTrue(msg.hasOptionalSint32());
296 msg.clear();
297 assertFalse(msg.hasOptionalSint32());
299 msg.setOptionalSint32(-123);
300 byte [] result = msg.toByteArray();
301 int msgSerializedSize = msg.getSerializedSize();
312 TestAllTypesMicro msg = new TestAllTypesMicro();
313 assertFalse(msg.hasOptionalSint64());
314 msg.setOptionalSint64(123);
315 assertTrue(msg.hasOptionalSint64());
316 assertEquals(123, msg.getOptionalSint64());
317 msg.clearOptionalSint64();
318 assertFalse(msg.hasOptionalSint64());
319 msg.clearOptionalSint64()
321 assertTrue(msg.hasOptionalSint64());
322 msg.clear();
323 assertFalse(msg.hasOptionalSint64());
325 msg.setOptionalSint64(-123);
326 byte [] result = msg.toByteArray();
327 int msgSerializedSize = msg.getSerializedSize();
338 TestAllTypesMicro msg = new TestAllTypesMicro();
339 assertFalse(msg.hasOptionalFixed32());
340 msg.setOptionalFixed32(123);
341 assertTrue(msg.hasOptionalFixed32());
342 assertEquals(123, msg.getOptionalFixed32());
343 msg.clearOptionalFixed32();
344 assertFalse(msg.hasOptionalFixed32());
345 msg.clearOptionalFixed32()
347 assertTrue(msg.hasOptionalFixed32());
348 msg.clear();
349 assertFalse(msg.hasOptionalFixed32());
351 msg.setOptionalFixed32(123);
352 byte [] result = msg.toByteArray();
353 int msgSerializedSize = msg.getSerializedSize();
364 TestAllTypesMicro msg = new TestAllTypesMicro();
365 assertFalse(msg.hasOptionalFixed64());
366 msg.setOptionalFixed64(123);
367 assertTrue(msg.hasOptionalFixed64());
368 assertEquals(123, msg.getOptionalFixed64());
369 msg.clearOptionalFixed64();
370 assertFalse(msg.hasOptionalFixed64());
371 msg.clearOptionalFixed64()
373 assertTrue(msg.hasOptionalFixed64());
374 msg.clear();
375 assertFalse(msg.hasOptionalFixed64());
377 msg.setOptionalFixed64(123);
378 byte [] result = msg.toByteArray();
379 int msgSerializedSize = msg.getSerializedSize();
389 TestAllTypesMicro msg = new TestAllTypesMicro();
390 assertFalse(msg.hasOptionalSfixed32());
391 msg.setOptionalSfixed32(123);
392 assertTrue(msg.hasOptionalSfixed32());
393 assertEquals(123, msg.getOptionalSfixed32());
394 msg.clearOptionalSfixed32();
395 assertFalse(msg.hasOptionalSfixed32());
396 msg.clearOptionalSfixed32()
398 assertTrue(msg.hasOptionalSfixed32());
399 msg.clear();
400 assertFalse(msg.hasOptionalSfixed32());
402 msg.setOptionalSfixed32(123);
403 byte [] result = msg.toByteArray();
404 int msgSerializedSize = msg.getSerializedSize();
415 TestAllTypesMicro msg = new TestAllTypesMicro();
416 assertFalse(msg.hasOptionalSfixed64());
417 msg.setOptionalSfixed64(123);
418 assertTrue(msg.hasOptionalSfixed64());
419 assertEquals(123, msg.getOptionalSfixed64());
420 msg.clearOptionalSfixed64();
421 assertFalse(msg.hasOptionalSfixed64());
422 msg.clearOptionalSfixed64()
424 assertTrue(msg.hasOptionalSfixed64());
425 msg.clear();
426 assertFalse(msg.hasOptionalSfixed64());
428 msg.setOptionalSfixed64(-123);
429 byte [] result = msg.toByteArray();
430 int msgSerializedSize = msg.getSerializedSize();
441 TestAllTypesMicro msg = new TestAllTypesMicro();
442 assertFalse(msg.hasOptionalFloat());
443 msg.setOptionalFloat(123f);
444 assertTrue(msg.hasOptionalFloat());
445 assertTrue(123.0f == msg.getOptionalFloat());
446 msg.clearOptionalFloat();
447 assertFalse(msg.hasOptionalFloat());
448 msg.clearOptionalFloat()
450 assertTrue(msg.hasOptionalFloat());
451 msg.clear();
452 assertFalse(msg.hasOptionalFloat());
454 msg.setOptionalFloat(-123.456f);
455 byte [] result = msg.toByteArray();
456 int msgSerializedSize = msg.getSerializedSize();
467 TestAllTypesMicro msg = new TestAllTypesMicro();
468 assertFalse(msg.hasOptionalDouble());
469 msg.setOptionalDouble(123);
470 assertTrue(msg.hasOptionalDouble());
471 assertTrue(123.0 == msg.getOptionalDouble());
472 msg.clearOptionalDouble();
473 assertFalse(msg.hasOptionalDouble());
474 msg.clearOptionalDouble()
476 assertTrue(msg.hasOptionalDouble());
477 msg.clear();
478 assertFalse(msg.hasOptionalDouble());
480 msg.setOptionalDouble(-123.456);
481 byte [] result = msg.toByteArray();
482 int msgSerializedSize = msg.getSerializedSize();
493 TestAllTypesMicro msg = new TestAllTypesMicro();
494 assertFalse(msg.hasOptionalBool());
495 msg.setOptionalBool(true);
496 assertTrue(msg.hasOptionalBool());
497 assertEquals(true, msg.getOptionalBool());
498 msg.clearOptionalBool();
499 assertFalse(msg.hasOptionalBool());
500 msg.clearOptionalBool()
502 assertTrue(msg.hasOptionalBool());
503 msg.clear();
504 assertFalse(msg.hasOptionalBool());
506 msg.setOptionalBool(false);
507 byte [] result = msg.toByteArray();
508 int msgSerializedSize = msg.getSerializedSize();
519 TestAllTypesMicro msg = new TestAllTypesMicro();
520 assertFalse(msg.hasOptionalString());
521 msg.setOptionalString("hello");
522 assertTrue(msg.hasOptionalString());
523 assertEquals("hello", msg.getOptionalString());
524 msg.clearOptionalString();
525 assertFalse(msg.hasOptionalString());
526 msg.clearOptionalString()
528 assertTrue(msg.hasOptionalString());
529 msg.clear();
530 assertFalse(msg.hasOptionalString());
532 msg.setOptionalString("bye");
533 byte [] result = msg.toByteArray();
534 int msgSerializedSize = msg.getSerializedSize();
545 TestAllTypesMicro msg = new TestAllTypesMicro();
546 assertFalse(msg.hasOptionalBytes());
547 msg.setOptionalBytes(ByteStringMicro.copyFromUtf8("hello"));
548 assertTrue(msg.hasOptionalBytes());
549 assertEquals("hello", msg.getOptionalBytes().toStringUtf8());
550 msg.clearOptionalBytes();
551 assertFalse(msg.hasOptionalBytes());
552 msg.clearOptionalBytes()
554 assertTrue(msg.hasOptionalBytes());
555 msg.clear();
556 assertFalse(msg.hasOptionalBytes());
558 msg.setOptionalBytes(ByteStringMicro.copyFromUtf8("bye"));
559 byte [] result = msg.toByteArray();
560 int msgSerializedSize = msg.getSerializedSize();
571 TestAllTypesMicro msg = new TestAllTypesMicro();
574 assertFalse(msg.hasOptionalGroup());
575 msg.setOptionalGroup(grp);
576 assertTrue(msg.hasOptionalGroup());
577 assertEquals(1, msg.getOptionalGroup().getA());
578 msg.clearOptionalGroup();
579 assertFalse(msg.hasOptionalGroup());
580 msg.clearOptionalGroup()
582 assertTrue(msg.hasOptionalGroup());
583 msg.clear();
584 assertFalse(msg.hasOptionalGroup());
586 msg.setOptionalGroup(grp);
587 byte [] result = msg.toByteArray();
588 int msgSerializedSize = msg.getSerializedSize();
599 TestAllTypesMicro msg = new TestAllTypesMicro();
602 assertFalse(msg.hasOptionalNestedMessage());
603 msg.setOptionalNestedMessage(nestedMsg);
604 assertTrue(msg.hasOptionalNestedMessage());
605 assertEquals(1, msg.getOptionalNestedMessage().getBb());
606 msg.clearOptionalNestedMessage();
607 assertFalse(msg.hasOptionalNestedMessage());
608 msg.clearOptionalNestedMessage()
610 assertTrue(msg.hasOptionalNestedMessage());
611 msg.clear();
612 assertFalse(msg.hasOptionalNestedMessage());
614 msg.setOptionalNestedMessage(nestedMsg);
615 byte [] result = msg.toByteArray();
616 int msgSerializedSize = msg.getSerializedSize();
627 TestAllTypesMicro msg = new TestAllTypesMicro();
633 assertFalse(msg.hasOptionalForeignMessage());
634 msg.setOptionalForeignMessage(foreignMsg);
635 assertTrue(msg.hasOptionalForeignMessage());
636 assertEquals(1, msg.getOptionalForeignMessage().getC());
637 msg.clearOptionalForeignMessage();
638 assertFalse(msg.hasOptionalForeignMessage());
639 msg.clearOptionalForeignMessage()
641 assertTrue(msg.hasOptionalForeignMessage());
642 msg.clear();
643 assertFalse(msg.hasOptionalForeignMessage());
645 msg.setOptionalForeignMessage(foreignMsg);
646 byte [] result = msg.toByteArray();
647 int msgSerializedSize = msg.getSerializedSize();
658 TestAllTypesMicro msg = new TestAllTypesMicro();
664 assertFalse(msg.hasOptionalImportMessage());
665 msg.setOptionalImportMessage(importMsg);
666 assertTrue(msg.hasOptionalImportMessage());
667 assertEquals(1, msg.getOptionalImportMessage().getD());
668 msg.clearOptionalImportMessage();
669 assertFalse(msg.hasOptionalImportMessage());
670 msg.clearOptionalImportMessage()
672 assertTrue(msg.hasOptionalImportMessage());
673 msg.clear();
674 assertFalse(msg.hasOptionalImportMessage());
676 msg.setOptionalImportMessage(importMsg);
677 byte [] result = msg.toByteArray();
678 int msgSerializedSize = msg.getSerializedSize();
689 TestAllTypesMicro msg = new TestAllTypesMicro();
690 msg.setOptionalNestedEnum(TestAllTypesMicro.BAR);
691 assertTrue(msg.hasOptionalNestedEnum());
692 assertEquals(TestAllTypesMicro.BAR, msg.getOptionalNestedEnum());
693 msg.clearOptionalNestedEnum();
694 assertFalse(msg.hasOptionalNestedEnum());
695 msg.clearOptionalNestedEnum()
697 assertTrue(msg.hasOptionalNestedEnum());
698 msg.clear();
699 assertFalse(msg.hasOptionalNestedEnum());
701 msg.setOptionalNestedEnum(TestAllTypesMicro.BAR);
702 byte [] result = msg.toByteArray();
703 int msgSerializedSize = msg.getSerializedSize();
714 TestAllTypesMicro msg = new TestAllTypesMicro();
715 msg.setOptionalForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
716 assertTrue(msg.hasOptionalForeignEnum());
718 msg.getOptionalForeignEnum());
719 msg.clearOptionalForeignEnum();
720 assertFalse(msg.hasOptionalForeignEnum());
721 msg.clearOptionalForeignEnum()
723 assertTrue(msg.hasOptionalForeignEnum());
724 msg.clear();
725 assertFalse(msg.hasOptionalForeignEnum());
727 msg.setOptionalForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
728 byte [] result = msg.toByteArray();
729 int msgSerializedSize = msg.getSerializedSize();
741 TestAllTypesMicro msg = new TestAllTypesMicro();
742 msg.setOptionalImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
743 assertTrue(msg.hasOptionalImportEnum());
745 msg.getOptionalImportEnum());
746 msg.clearOptionalImportEnum();
747 assertFalse(msg.hasOptionalImportEnum());
748 msg.clearOptionalImportEnum()
750 assertTrue(msg.hasOptionalImportEnum());
751 msg.clear();
752 assertFalse(msg.hasOptionalImportEnum());
754 msg.setOptionalImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
755 byte [] result = msg.toByteArray();
756 int msgSerializedSize = msg.getSerializedSize();
768 TestAllTypesMicro msg = new TestAllTypesMicro();
769 assertFalse(msg.hasOptionalStringPiece());
770 msg.setOptionalStringPiece("hello");
771 assertTrue(msg.hasOptionalStringPiece());
772 assertEquals("hello", msg.getOptionalStringPiece());
773 msg.clearOptionalStringPiece();
774 assertFalse(msg.hasOptionalStringPiece());
775 msg.clearOptionalStringPiece()
777 assertTrue(msg.hasOptionalStringPiece());
778 msg.clear();
779 assertFalse(msg.hasOptionalStringPiece());
781 msg.setOptionalStringPiece("bye");
782 byte [] result = msg.toByteArray();
783 int msgSerializedSize = msg.getSerializedSize();
794 TestAllTypesMicro msg = new TestAllTypesMicro();
795 assertFalse(msg.hasOptionalCord());
796 msg.setOptionalCord("hello");
797 assertTrue(msg.hasOptionalCord());
798 assertEquals("hello", msg.getOptionalCord());
799 msg.clearOptionalCord();
800 assertFalse(msg.hasOptionalCord());
801 msg.clearOptionalCord()
803 assertTrue(msg.hasOptionalCord());
804 msg.clear();
805 assertFalse(msg.hasOptionalCord());
807 msg.setOptionalCord("bye");
808 byte [] result = msg.toByteArray();
809 int msgSerializedSize = msg.getSerializedSize();
820 TestAllTypesMicro msg = new TestAllTypesMicro();
821 assertEquals(0, msg.getRepeatedInt32Count());
822 msg.addRepeatedInt32(123);
823 assertEquals(1, msg.getRepeatedInt32Count());
824 assertEquals(123, msg.getRepeatedInt32(0));
825 msg.addRepeatedInt32(456);
826 assertEquals(2, msg.getRepeatedInt32Count());
827 assertEquals(123, msg.getRepeatedInt32(0));
828 assertEquals(456, msg.getRepeatedInt32(1));
829 msg.setRepeatedInt32(0, 789);
830 assertEquals(2, msg.getRepeatedInt32Count());
831 assertEquals(789, msg.getRepeatedInt32(0));
832 assertEquals(456, msg.getRepeatedInt32(1));
833 msg.clearRepeatedInt32();
834 assertEquals(0, msg.getRepeatedInt32Count());
835 msg.clearRepeatedInt32()
837 assertEquals(1, msg.getRepeatedInt32Count());
838 assertEquals(456, msg.getRepeatedInt32(0));
839 msg.clear();
840 assertEquals(0, msg.getRepeatedInt32Count());
843 msg.clear()
845 assertEquals(1, msg.getRepeatedInt32Count());
846 byte [] result = msg.toByteArray();
847 int msgSerializedSize = msg.getSerializedSize();
856 msg.clear()
859 assertEquals(2, msg.getRepeatedInt32Count());
860 result = msg.toByteArray();
861 msgSerializedSize = msg.getSerializedSize();
873 TestAllTypesMicro msg = new TestAllTypesMicro();
874 assertEquals(0, msg.getRepeatedInt64Count());
875 msg.addRepeatedInt64(123);
876 assertEquals(1, msg.getRepeatedInt64Count());
877 assertEquals(123, msg.getRepeatedInt64(0));
878 msg.addRepeatedInt64(456);
879 assertEquals(2, msg.getRepeatedInt64Count());
880 assertEquals(123, msg.getRepeatedInt64(0));
881 assertEquals(456, msg.getRepeatedInt64(1));
882 msg.setRepeatedInt64(0, 789);
883 assertEquals(2, msg.getRepeatedInt64Count());
884 assertEquals(789, msg.getRepeatedInt64(0));
885 assertEquals(456, msg.getRepeatedInt64(1));
886 msg.clearRepeatedInt64();
887 assertEquals(0, msg.getRepeatedInt64Count());
888 msg.clearRepeatedInt64()
890 assertEquals(1, msg.getRepeatedInt64Count());
891 assertEquals(456, msg.getRepeatedInt64(0));
892 msg.clear();
893 assertEquals(0, msg.getRepeatedInt64Count());
896 msg.clear()
898 assertEquals(1, msg.getRepeatedInt64Count());
899 byte [] result = msg.toByteArray();
900 int msgSerializedSize = msg.getSerializedSize();
909 msg.clear()
912 assertEquals(2, msg.getRepeatedInt64Count());
913 result = msg.toByteArray();
914 msgSerializedSize = msg.getSerializedSize();
926 TestAllTypesMicro msg = new TestAllTypesMicro();
927 assertEquals(0, msg.getRepeatedUint32Count());
928 msg.addRepeatedUint32(123);
929 assertEquals(1, msg.getRepeatedUint32Count());
930 assertEquals(123, msg.getRepeatedUint32(0));
931 msg.addRepeatedUint32(456);
932 assertEquals(2, msg.getRepeatedUint32Count());
933 assertEquals(123, msg.getRepeatedUint32(0));
934 assertEquals(456, msg.getRepeatedUint32(1));
935 msg.setRepeatedUint32(0, 789);
936 assertEquals(2, msg.getRepeatedUint32Count());
937 assertEquals(789, msg.getRepeatedUint32(0));
938 assertEquals(456, msg.getRepeatedUint32(1));
939 msg.clearRepeatedUint32();
940 assertEquals(0, msg.getRepeatedUint32Count());
941 msg.clearRepeatedUint32()
943 assertEquals(1, msg.getRepeatedUint32Count());
944 assertEquals(456, msg.getRepeatedUint32(0));
945 msg.clear();
946 assertEquals(0, msg.getRepeatedUint32Count());
949 msg.clear()
951 assertEquals(1, msg.getRepeatedUint32Count());
952 byte [] result = msg.toByteArray();
953 int msgSerializedSize = msg.getSerializedSize();
962 msg.clear()
965 assertEquals(2, msg.getRepeatedUint32Count());
966 result = msg.toByteArray();
967 msgSerializedSize = msg.getSerializedSize();
979 TestAllTypesMicro msg = new TestAllTypesMicro();
980 assertEquals(0, msg.getRepeatedUint64Count());
981 msg.addRepeatedUint64(123);
982 assertEquals(1, msg.getRepeatedUint64Count());
983 assertEquals(123, msg.getRepeatedUint64(0));
984 msg.addRepeatedUint64(456);
985 assertEquals(2, msg.getRepeatedUint64Count());
986 assertEquals(123, msg.getRepeatedUint64(0));
987 assertEquals(456, msg.getRepeatedUint64(1));
988 msg.setRepeatedUint64(0, 789);
989 assertEquals(2, msg.getRepeatedUint64Count());
990 assertEquals(789, msg.getRepeatedUint64(0));
991 assertEquals(456, msg.getRepeatedUint64(1));
992 msg.clearRepeatedUint64();
993 assertEquals(0, msg.getRepeatedUint64Count());
994 msg.clearRepeatedUint64()
996 assertEquals(1, msg.getRepeatedUint64Count());
997 assertEquals(456, msg.getRepeatedUint64(0));
998 msg.clear();
999 assertEquals(0, msg.getRepeatedUint64Count());
1002 msg.clear()
1004 assertEquals(1, msg.getRepeatedUint64Count());
1005 byte [] result = msg.toByteArray();
1006 int msgSerializedSize = msg.getSerializedSize();
1015 msg.clear()
1018 assertEquals(2, msg.getRepeatedUint64Count());
1019 result = msg.toByteArray();
1020 msgSerializedSize = msg.getSerializedSize();
1032 TestAllTypesMicro msg = new TestAllTypesMicro();
1033 assertEquals(0, msg.getRepeatedSint32Count());
1034 msg.addRepeatedSint32(123);
1035 assertEquals(1, msg.getRepeatedSint32Count());
1036 assertEquals(123, msg.getRepeatedSint32(0));
1037 msg.addRepeatedSint32(456);
1038 assertEquals(2, msg.getRepeatedSint32Count());
1039 assertEquals(123, msg.getRepeatedSint32(0));
1040 assertEquals(456, msg.getRepeatedSint32(1));
1041 msg.setRepeatedSint32(0, 789);
1042 assertEquals(2, msg.getRepeatedSint32Count());
1043 assertEquals(789, msg.getRepeatedSint32(0));
1044 assertEquals(456, msg.getRepeatedSint32(1));
1045 msg.clearRepeatedSint32();
1046 assertEquals(0, msg.getRepeatedSint32Count());
1047 msg.clearRepeatedSint32()
1049 assertEquals(1, msg.getRepeatedSint32Count());
1050 assertEquals(456, msg.getRepeatedSint32(0));
1051 msg.clear();
1052 assertEquals(0, msg.getRepeatedSint32Count());
1055 msg.clear()
1057 assertEquals(1, msg.getRepeatedSint32Count());
1058 byte [] result = msg.toByteArray();
1059 int msgSerializedSize = msg.getSerializedSize();
1068 msg.clear()
1071 assertEquals(2, msg.getRepeatedSint32Count());
1072 result = msg.toByteArray();
1073 msgSerializedSize = msg.getSerializedSize();
1085 TestAllTypesMicro msg = new TestAllTypesMicro();
1086 assertEquals(0, msg.getRepeatedSint64Count());
1087 msg.addRepeatedSint64(123);
1088 assertEquals(1, msg.getRepeatedSint64Count());
1089 assertEquals(123, msg.getRepeatedSint64(0));
1090 msg.addRepeatedSint64(456);
1091 assertEquals(2, msg.getRepeatedSint64Count());
1092 assertEquals(123, msg.getRepeatedSint64(0));
1093 assertEquals(456, msg.getRepeatedSint64(1));
1094 msg.setRepeatedSint64(0, 789);
1095 assertEquals(2, msg.getRepeatedSint64Count());
1096 assertEquals(789, msg.getRepeatedSint64(0));
1097 assertEquals(456, msg.getRepeatedSint64(1));
1098 msg.clearRepeatedSint64();
1099 assertEquals(0, msg.getRepeatedSint64Count());
1100 msg.clearRepeatedSint64()
1102 assertEquals(1, msg.getRepeatedSint64Count());
1103 assertEquals(456, msg.getRepeatedSint64(0));
1104 msg.clear();
1105 assertEquals(0, msg.getRepeatedSint64Count());
1108 msg.clear()
1110 assertEquals(1, msg.getRepeatedSint64Count());
1111 byte [] result = msg.toByteArray();
1112 int msgSerializedSize = msg.getSerializedSize();
1121 msg.clear()
1124 assertEquals(2, msg.getRepeatedSint64Count());
1125 result = msg.toByteArray();
1126 msgSerializedSize = msg.getSerializedSize();
1138 TestAllTypesMicro msg = new TestAllTypesMicro();
1139 assertEquals(0, msg.getRepeatedFixed32Count());
1140 msg.addRepeatedFixed32(123);
1141 assertEquals(1, msg.getRepeatedFixed32Count());
1142 assertEquals(123, msg.getRepeatedFixed32(0));
1143 msg.addRepeatedFixed32(456);
1144 assertEquals(2, msg.getRepeatedFixed32Count());
1145 assertEquals(123, msg.getRepeatedFixed32(0));
1146 assertEquals(456, msg.getRepeatedFixed32(1));
1147 msg.setRepeatedFixed32(0, 789);
1148 assertEquals(2, msg.getRepeatedFixed32Count());
1149 assertEquals(789, msg.getRepeatedFixed32(0));
1150 assertEquals(456, msg.getRepeatedFixed32(1));
1151 msg.clearRepeatedFixed32();
1152 assertEquals(0, msg.getRepeatedFixed32Count());
1153 msg.clearRepeatedFixed32()
1155 assertEquals(1, msg.getRepeatedFixed32Count());
1156 assertEquals(456, msg.getRepeatedFixed32(0));
1157 msg.clear();
1158 assertEquals(0, msg.getRepeatedFixed32Count());
1161 msg.clear()
1163 assertEquals(1, msg.getRepeatedFixed32Count());
1164 byte [] result = msg.toByteArray();
1165 int msgSerializedSize = msg.getSerializedSize();
1174 msg.clear()
1177 assertEquals(2, msg.getRepeatedFixed32Count());
1178 result = msg.toByteArray();
1179 msgSerializedSize = msg.getSerializedSize();
1191 TestAllTypesMicro msg = new TestAllTypesMicro();
1192 assertEquals(0, msg.getRepeatedFixed64Count());
1193 msg.addRepeatedFixed64(123);
1194 assertEquals(1, msg.getRepeatedFixed64Count());
1195 assertEquals(123, msg.getRepeatedFixed64(0));
1196 msg.addRepeatedFixed64(456);
1197 assertEquals(2, msg.getRepeatedFixed64Count());
1198 assertEquals(123, msg.getRepeatedFixed64(0));
1199 assertEquals(456, msg.getRepeatedFixed64(1));
1200 msg.setRepeatedFixed64(0, 789);
1201 assertEquals(2, msg.getRepeatedFixed64Count());
1202 assertEquals(789, msg.getRepeatedFixed64(0));
1203 assertEquals(456, msg.getRepeatedFixed64(1));
1204 msg.clearRepeatedFixed64();
1205 assertEquals(0, msg.getRepeatedFixed64Count());
1206 msg.clearRepeatedFixed64()
1208 assertEquals(1, msg.getRepeatedFixed64Count());
1209 assertEquals(456, msg.getRepeatedFixed64(0));
1210 msg.clear();
1211 assertEquals(0, msg.getRepeatedFixed64Count());
1214 msg.clear()
1216 assertEquals(1, msg.getRepeatedFixed64Count());
1217 byte [] result = msg.toByteArray();
1218 int msgSerializedSize = msg.getSerializedSize();
1227 msg.clear()
1230 assertEquals(2, msg.getRepeatedFixed64Count());
1231 result = msg.toByteArray();
1232 msgSerializedSize = msg.getSerializedSize();
1244 TestAllTypesMicro msg = new TestAllTypesMicro();
1245 assertEquals(0, msg.getRepeatedSfixed32Count());
1246 msg.addRepeatedSfixed32(123);
1247 assertEquals(1, msg.getRepeatedSfixed32Count());
1248 assertEquals(123, msg.getRepeatedSfixed32(0));
1249 msg.addRepeatedSfixed32(456);
1250 assertEquals(2, msg.getRepeatedSfixed32Count());
1251 assertEquals(123, msg.getRepeatedSfixed32(0));
1252 assertEquals(456, msg.getRepeatedSfixed32(1));
1253 msg.setRepeatedSfixed32(0, 789);
1254 assertEquals(2, msg.getRepeatedSfixed32Count());
1255 assertEquals(789, msg.getRepeatedSfixed32(0));
1256 assertEquals(456, msg.getRepeatedSfixed32(1));
1257 msg.clearRepeatedSfixed32();
1258 assertEquals(0, msg.getRepeatedSfixed32Count());
1259 msg.clearRepeatedSfixed32()
1261 assertEquals(1, msg.getRepeatedSfixed32Count());
1262 assertEquals(456, msg.getRepeatedSfixed32(0));
1263 msg.clear();
1264 assertEquals(0, msg.getRepeatedSfixed32Count());
1267 msg.clear()
1269 assertEquals(1, msg.getRepeatedSfixed32Count());
1270 byte [] result = msg.toByteArray();
1271 int msgSerializedSize = msg.getSerializedSize();
1280 msg.clear()
1283 assertEquals(2, msg.getRepeatedSfixed32Count());
1284 result = msg.toByteArray();
1285 msgSerializedSize = msg.getSerializedSize();
1297 TestAllTypesMicro msg = new TestAllTypesMicro();
1298 assertEquals(0, msg.getRepeatedSfixed64Count());
1299 msg.addRepeatedSfixed64(123);
1300 assertEquals(1, msg.getRepeatedSfixed64Count());
1301 assertEquals(123, msg.getRepeatedSfixed64(0));
1302 msg.addRepeatedSfixed64(456);
1303 assertEquals(2, msg.getRepeatedSfixed64Count());
1304 assertEquals(123, msg.getRepeatedSfixed64(0));
1305 assertEquals(456, msg.getRepeatedSfixed64(1));
1306 msg.setRepeatedSfixed64(0, 789);
1307 assertEquals(2, msg.getRepeatedSfixed64Count());
1308 assertEquals(789, msg.getRepeatedSfixed64(0));
1309 assertEquals(456, msg.getRepeatedSfixed64(1));
1310 msg.clearRepeatedSfixed64();
1311 assertEquals(0, msg.getRepeatedSfixed64Count());
1312 msg.clearRepeatedSfixed64()
1314 assertEquals(1, msg.getRepeatedSfixed64Count());
1315 assertEquals(456, msg.getRepeatedSfixed64(0));
1316 msg.clear();
1317 assertEquals(0, msg.getRepeatedSfixed64Count());
1320 msg.clear()
1322 assertEquals(1, msg.getRepeatedSfixed64Count());
1323 byte [] result = msg.toByteArray();
1324 int msgSerializedSize = msg.getSerializedSize();
1333 msg.clear()
1336 assertEquals(2, msg.getRepeatedSfixed64Count());
1337 result = msg.toByteArray();
1338 msgSerializedSize = msg.getSerializedSize();
1350 TestAllTypesMicro msg = new TestAllTypesMicro();
1351 assertEquals(0, msg.getRepeatedFloatCount());
1352 msg.addRepeatedFloat(123f);
1353 assertEquals(1, msg.getRepeatedFloatCount());
1354 assertTrue(123f == msg.getRepeatedFloat(0));
1355 msg.addRepeatedFloat(456f);
1356 assertEquals(2, msg.getRepeatedFloatCount());
1357 assertTrue(123f == msg.getRepeatedFloat(0));
1358 assertTrue(456f == msg.getRepeatedFloat(1));
1359 msg.setRepeatedFloat(0, 789f);
1360 assertEquals(2, msg.getRepeatedFloatCount());
1361 assertTrue(789f == msg.getRepeatedFloat(0));
1362 assertTrue(456f == msg.getRepeatedFloat(1));
1363 msg.clearRepeatedFloat();
1364 assertEquals(0, msg.getRepeatedFloatCount());
1365 msg.clearRepeatedFloat()
1367 assertEquals(1, msg.getRepeatedFloatCount());
1368 assertTrue(456f == msg.getRepeatedFloat(0));
1369 msg.clear();
1370 assertEquals(0, msg.getRepeatedFloatCount());
1373 msg.clear()
1375 assertEquals(1, msg.getRepeatedFloatCount());
1376 byte [] result = msg.toByteArray();
1377 int msgSerializedSize = msg.getSerializedSize();
1386 msg.clear()
1389 assertEquals(2, msg.getRepeatedFloatCount());
1390 result = msg.toByteArray();
1391 msgSerializedSize = msg.getSerializedSize();
1403 TestAllTypesMicro msg = new TestAllTypesMicro();
1404 assertEquals(0, msg.getRepeatedDoubleCount());
1405 msg.addRepeatedDouble(123.0);
1406 assertEquals(1, msg.getRepeatedDoubleCount());
1407 assertTrue(123.0 == msg.getRepeatedDouble(0));
1408 msg.addRepeatedDouble(456.0);
1409 assertEquals(2, msg.getRepeatedDoubleCount());
1410 assertTrue(123.0 == msg.getRepeatedDouble(0));
1411 assertTrue(456.0 == msg.getRepeatedDouble(1));
1412 msg.setRepeatedDouble(0, 789.0);
1413 assertEquals(2, msg.getRepeatedDoubleCount());
1414 assertTrue(789.0 == msg.getRepeatedDouble(0));
1415 assertTrue(456.0 == msg.getRepeatedDouble(1));
1416 msg.clearRepeatedDouble();
1417 assertEquals(0, msg.getRepeatedDoubleCount());
1418 msg.clearRepeatedDouble()
1420 assertEquals(1, msg.getRepeatedDoubleCount());
1421 assertTrue(456.0 == msg.getRepeatedDouble(0));
1422 msg.clear();
1423 assertEquals(0, msg.getRepeatedDoubleCount());
1426 msg.clear()
1428 assertEquals(1, msg.getRepeatedDoubleCount());
1429 byte [] result = msg.toByteArray();
1430 int msgSerializedSize = msg.getSerializedSize();
1439 msg.clear()
1442 assertEquals(2, msg.getRepeatedDoubleCount());
1443 result = msg.toByteArray();
1444 msgSerializedSize = msg.getSerializedSize();
1456 TestAllTypesMicro msg = new TestAllTypesMicro();
1457 assertEquals(0, msg.getRepeatedBoolCount());
1458 msg.addRepeatedBool(true);
1459 assertEquals(1, msg.getRepeatedBoolCount());
1460 assertEquals(true, msg.getRepeatedBool(0));
1461 msg.addRepeatedBool(false);
1462 assertEquals(2, msg.getRepeatedBoolCount());
1463 assertEquals(true, msg.getRepeatedBool(0));
1464 assertEquals(false, msg.getRepeatedBool(1));
1465 msg.setRepeatedBool(0, false);
1466 assertEquals(2, msg.getRepeatedBoolCount());
1467 assertEquals(false, msg.getRepeatedBool(0));
1468 assertEquals(false, msg.getRepeatedBool(1));
1469 msg.clearRepeatedBool();
1470 assertEquals(0, msg.getRepeatedBoolCount());
1471 msg.clearRepeatedBool()
1473 assertEquals(1, msg.getRepeatedBoolCount());
1474 assertEquals(true, msg.getRepeatedBool(0));
1475 msg.clear();
1476 assertEquals(0, msg.getRepeatedBoolCount());
1479 msg.clear()
1481 assertEquals(1, msg.getRepeatedBoolCount());
1482 byte [] result = msg.toByteArray();
1483 int msgSerializedSize = msg.getSerializedSize();
1492 msg.clear()
1495 assertEquals(2, msg.getRepeatedBoolCount());
1496 result = msg.toByteArray();
1497 msgSerializedSize = msg.getSerializedSize();
1509 TestAllTypesMicro msg = new TestAllTypesMicro();
1510 assertEquals(0, msg.getRepeatedStringCount());
1511 msg.addRepeatedString("hello");
1512 assertEquals(1, msg.getRepeatedStringCount());
1513 assertEquals("hello", msg.getRepeatedString(0));
1514 msg.addRepeatedString("bye");
1515 assertEquals(2, msg.getRepeatedStringCount());
1516 assertEquals("hello", msg.getRepeatedString(0));
1517 assertEquals("bye", msg.getRepeatedString(1));
1518 msg.setRepeatedString(0, "boo");
1519 assertEquals(2, msg.getRepeatedStringCount());
1520 assertEquals("boo", msg.getRepeatedString(0));
1521 assertEquals("bye", msg.getRepeatedString(1));
1522 msg.clearRepeatedString();
1523 assertEquals(0, msg.getRepeatedStringCount());
1524 msg.clearRepeatedString()
1526 assertEquals(1, msg.getRepeatedStringCount());
1527 assertEquals("hello", msg.getRepeatedString(0));
1528 msg.clear();
1529 assertEquals(0, msg.getRepeatedStringCount());
1532 msg.clear()
1534 assertEquals(1, msg.getRepeatedStringCount());
1535 byte [] result = msg.toByteArray();
1536 int msgSerializedSize = msg.getSerializedSize();
1545 msg.clear()
1548 assertEquals(2, msg.getRepeatedStringCount());
1549 result = msg.toByteArray();
1550 msgSerializedSize = msg.getSerializedSize();
1562 TestAllTypesMicro msg = new TestAllTypesMicro();
1563 assertEquals(0, msg.getRepeatedBytesCount());
1564 msg.addRepeatedBytes(ByteStringMicro.copyFromUtf8("hello"));
1565 assertEquals(1, msg.getRepeatedBytesCount());
1566 assertEquals("hello", msg.getRepeatedBytes(0).toStringUtf8());
1567 msg.addRepeatedBytes(ByteStringMicro.copyFromUtf8("bye"));
1568 assertEquals(2, msg.getRepeatedBytesCount());
1569 assertEquals("hello", msg.getRepeatedBytes(0).toStringUtf8());
1570 assertEquals("bye", msg.getRepeatedBytes(1).toStringUtf8());
1571 msg.setRepeatedBytes(0, ByteStringMicro.copyFromUtf8("boo"));
1572 assertEquals(2, msg.getRepeatedBytesCount());
1573 assertEquals("boo", msg.getRepeatedBytes(0).toStringUtf8());
1574 assertEquals("bye", msg.getRepeatedBytes(1).toStringUtf8());
1575 msg.clearRepeatedBytes();
1576 assertEquals(0, msg.getRepeatedBytesCount());
1577 msg.clearRepeatedBytes()
1579 assertEquals(1, msg.getRepeatedBytesCount());
1580 assertEquals("hello", msg.getRepeatedBytes(0).toStringUtf8());
1581 msg.clear();
1582 assertEquals(0, msg.getRepeatedBytesCount());
1585 msg.clear()
1587 assertEquals(1, msg.getRepeatedBytesCount());
1588 assertEquals("", msg.getRepeatedBytes(0).toStringUtf8());
1589 byte [] result = msg.toByteArray();
1590 int msgSerializedSize = msg.getSerializedSize();
1599 msg.clear()
1602 assertEquals(2, msg.getRepeatedBytesCount());
1603 result = msg.toByteArray();
1604 msgSerializedSize = msg.getSerializedSize();
1616 TestAllTypesMicro msg = new TestAllTypesMicro();
1624 msg.addRepeatedGroup(group0);
1625 assertEquals(1, msg.getRepeatedGroupCount());
1626 assertEquals(0, msg.getRepeatedGroup(0).getA());
1627 msg.addRepeatedGroup(group1);
1628 assertEquals(2, msg.getRepeatedGroupCount());
1629 assertEquals(0, msg.getRepeatedGroup(0).getA());
1630 assertEquals(1, msg.getRepeatedGroup(1).getA());
1631 msg.setRepeatedGroup(0, group2);
1632 assertEquals(2, msg.getRepeatedGroupCount());
1633 assertEquals(2, msg.getRepeatedGroup(0).getA());
1634 assertEquals(1, msg.getRepeatedGroup(1).getA());
1635 msg.clearRepeatedGroup();
1636 assertEquals(0, msg.getRepeatedGroupCount());
1637 msg.clearRepeatedGroup()
1639 assertEquals(1, msg.getRepeatedGroupCount());
1640 assertEquals(1, msg.getRepeatedGroup(0).getA());
1641 msg.clear();
1642 assertEquals(0, msg.getRepeatedGroupCount());
1645 msg.clear()
1647 assertEquals(1, msg.getRepeatedGroupCount());
1648 byte [] result = msg.toByteArray();
1649 int msgSerializedSize = msg.getSerializedSize();
1658 msg.clear()
1661 assertEquals(2, msg.getRepeatedGroupCount());
1662 result = msg.toByteArray();
1663 msgSerializedSize = msg.getSerializedSize();
1676 TestAllTypesMicro msg = new TestAllTypesMicro();
1684 msg.addRepeatedNestedMessage(nestedMsg0);
1685 assertEquals(1, msg.getRepeatedNestedMessageCount());
1686 assertEquals(0, msg.getRepeatedNestedMessage(0).getBb());
1687 msg.addRepeatedNestedMessage(nestedMsg1);
1688 assertEquals(2, msg.getRepeatedNestedMessageCount());
1689 assertEquals(0, msg.getRepeatedNestedMessage(0).getBb());
1690 assertEquals(1, msg.getRepeatedNestedMessage(1).getBb());
1691 msg.setRepeatedNestedMessage(0, nestedMsg2);
1692 assertEquals(2, msg.getRepeatedNestedMessageCount());
1693 assertEquals(2, msg.getRepeatedNestedMessage(0).getBb());
1694 assertEquals(1, msg.getRepeatedNestedMessage(1).getBb());
1695 msg.clearRepeatedNestedMessage();
1696 assertEquals(0, msg.getRepeatedNestedMessageCount());
1697 msg.clearRepeatedNestedMessage()
1699 assertEquals(1, msg.getRepeatedNestedMessageCount());
1700 assertEquals(1, msg.getRepeatedNestedMessage(0).getBb());
1701 msg.clear();
1702 assertEquals(0, msg.getRepeatedNestedMessageCount());
1705 msg.clear()
1707 assertEquals(1, msg.getRepeatedNestedMessageCount());
1708 byte [] result = msg.toByteArray();
1709 int msgSerializedSize = msg.getSerializedSize();
1718 msg.clear()
1721 assertEquals(2, msg.getRepeatedNestedMessageCount());
1722 result = msg.toByteArray();
1723 msgSerializedSize = msg.getSerializedSize();
1735 TestAllTypesMicro msg = new TestAllTypesMicro();
1743 msg.addRepeatedForeignMessage(foreignMsg0);
1744 assertEquals(1, msg.getRepeatedForeignMessageCount());
1745 assertEquals(0, msg.getRepeatedForeignMessage(0).getC());
1746 msg.addRepeatedForeignMessage(foreignMsg1);
1747 assertEquals(2, msg.getRepeatedForeignMessageCount());
1748 assertEquals(0, msg.getRepeatedForeignMessage(0).getC());
1749 assertEquals(1, msg.getRepeatedForeignMessage(1).getC());
1750 msg.setRepeatedForeignMessage(0, foreignMsg2);
1751 assertEquals(2, msg.getRepeatedForeignMessageCount());
1752 assertEquals(2, msg.getRepeatedForeignMessage(0).getC());
1753 assertEquals(1, msg.getRepeatedForeignMessage(1).getC());
1754 msg.clearRepeatedForeignMessage();
1755 assertEquals(0, msg.getRepeatedForeignMessageCount());
1756 msg.clearRepeatedForeignMessage()
1758 assertEquals(1, msg.getRepeatedForeignMessageCount());
1759 assertEquals(1, msg.getRepeatedForeignMessage(0).getC());
1760 msg.clear();
1761 assertEquals(0, msg.getRepeatedForeignMessageCount());
1764 msg.clear()
1766 assertEquals(1, msg.getRepeatedForeignMessageCount());
1767 byte [] result = msg.toByteArray();
1768 int msgSerializedSize = msg.getSerializedSize();
1777 msg.clear()
1780 assertEquals(2, msg.getRepeatedForeignMessageCount());
1781 result = msg.toByteArray();
1782 msgSerializedSize = msg.getSerializedSize();
1794 TestAllTypesMicro msg = new TestAllTypesMicro();
1802 msg.addRepeatedImportMessage(importMsg0);
1803 assertEquals(1, msg.getRepeatedImportMessageCount());
1804 assertEquals(0, msg.getRepeatedImportMessage(0).getD());
1805 msg.addRepeatedImportMessage(importMsg1);
1806 assertEquals(2, msg.getRepeatedImportMessageCount());
1807 assertEquals(0, msg.getRepeatedImportMessage(0).getD());
1808 assertEquals(1, msg.getRepeatedImportMessage(1).getD());
1809 msg.setRepeatedImportMessage(0, importMsg2);
1810 assertEquals(2, msg.getRepeatedImportMessageCount());
1811 assertEquals(2, msg.getRepeatedImportMessage(0).getD());
1812 assertEquals(1, msg.getRepeatedImportMessage(1).getD());
1813 msg.clearRepeatedImportMessage();
1814 assertEquals(0, msg.getRepeatedImportMessageCount());
1815 msg.clearRepeatedImportMessage()
1817 assertEquals(1, msg.getRepeatedImportMessageCount());
1818 assertEquals(1, msg.getRepeatedImportMessage(0).getD());
1819 msg.clear();
1820 assertEquals(0, msg.getRepeatedImportMessageCount());
1823 msg.clear()
1825 assertEquals(1, msg.getRepeatedImportMessageCount());
1826 byte [] result = msg.toByteArray();
1827 int msgSerializedSize = msg.getSerializedSize();
1836 msg.clear()
1839 assertEquals(2, msg.getRepeatedImportMessageCount());
1840 result = msg.toByteArray();
1841 msgSerializedSize = msg.getSerializedSize();
1853 TestAllTypesMicro msg = new TestAllTypesMicro();
1854 msg.addRepeatedNestedEnum(TestAllTypesMicro.FOO);
1855 assertEquals(1, msg.getRepeatedNestedEnumCount());
1856 assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
1857 msg.addRepeatedNestedEnum(TestAllTypesMicro.BAR);
1858 assertEquals(2, msg.getRepeatedNestedEnumCount());
1859 assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
1860 assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
1861 msg.setRepeatedNestedEnum(0, TestAllTypesMicro.BAZ);
1862 assertEquals(2, msg.getRepeatedNestedEnumCount());
1863 assertEquals(TestAllTypesMicro.BAZ, msg.getRepeatedNestedEnum(0));
1864 assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
1865 msg.clearRepeatedNestedEnum();
1866 assertEquals(0, msg.getRepeatedNestedEnumCount());
1867 msg.clearRepeatedNestedEnum()
1869 assertEquals(1, msg.getRepeatedNestedEnumCount());
1870 assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(0));
1871 msg.clear();
1872 assertEquals(0, msg.getRepeatedNestedEnumCount());
1875 msg.clear()
1877 byte [] result = msg.toByteArray();
1878 int msgSerializedSize = msg.getSerializedSize();
1884 assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
1887 msg.clear()
1890 assertEquals(2, msg.getRepeatedNestedEnumCount());
1891 result = msg.toByteArray();
1892 msgSerializedSize = msg.getSerializedSize();
1899 assertEquals(TestAllTypesMicro.FOO, msg.getRepeatedNestedEnum(0));
1900 assertEquals(TestAllTypesMicro.BAR, msg.getRepeatedNestedEnum(1));
1904 TestAllTypesMicro msg = new TestAllTypesMicro();
1905 msg.addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_FOO);
1906 assertEquals(1, msg.getRepeatedForeignEnumCount());
1907 assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
1908 msg.addRepeatedForeignEnum(MicroOuterClass.FOREIGN_MICRO_BAR);
1909 assertEquals(2, msg.getRepeatedForeignEnumCount());
1910 assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
1911 assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
1912 msg.setRepeatedForeignEnum(0, MicroOuterClass.FOREIGN_MICRO_BAZ);
1913 assertEquals(2, msg.getRepeatedForeignEnumCount());
1914 assertEquals(MicroOuterClass.FOREIGN_MICRO_BAZ, msg.getRepeatedForeignEnum(0));
1915 assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
1916 msg.clearRepeatedForeignEnum();
1917 assertEquals(0, msg.getRepeatedForeignEnumCount());
1918 msg.clearRepeatedForeignEnum()
1920 assertEquals(1, msg.getRepeatedForeignEnumCount());
1921 assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(0));
1922 msg.clear();
1923 assertEquals(0, msg.getRepeatedForeignEnumCount());
1926 msg.clear()
1928 byte [] result = msg.toByteArray();
1929 int msgSerializedSize = msg.getSerializedSize();
1935 assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
1938 msg.clear()
1941 assertEquals(2, msg.getRepeatedForeignEnumCount());
1942 result = msg.toByteArray();
1943 msgSerializedSize = msg.getSerializedSize();
1950 assertEquals(MicroOuterClass.FOREIGN_MICRO_FOO, msg.getRepeatedForeignEnum(0));
1951 assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getRepeatedForeignEnum(1));
1955 TestAllTypesMicro msg = new TestAllTypesMicro();
1956 msg.addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_FOO);
1957 assertEquals(1, msg.getRepeatedImportEnumCount());
1958 assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
1959 msg.addRepeatedImportEnum(UnittestImportMicro.IMPORT_MICRO_BAR);
1960 assertEquals(2, msg.getRepeatedImportEnumCount());
1961 assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
1962 assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
1963 msg.setRepeatedImportEnum(0, UnittestImportMicro.IMPORT_MICRO_BAZ);
1964 assertEquals(2, msg.getRepeatedImportEnumCount());
1965 assertEquals(UnittestImportMicro.IMPORT_MICRO_BAZ, msg.getRepeatedImportEnum(0));
1966 assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
1967 msg.clearRepeatedImportEnum();
1968 assertEquals(0, msg.getRepeatedImportEnumCount());
1969 msg.clearRepeatedImportEnum()
1971 assertEquals(1, msg.getRepeatedImportEnumCount());
1972 assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(0));
1973 msg.clear();
1974 assertEquals(0, msg.getRepeatedImportEnumCount());
1977 msg.clear()
1979 byte [] result = msg.toByteArray();
1980 int msgSerializedSize = msg.getSerializedSize();
1986 assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
1989 msg.clear()
1992 assertEquals(2, msg.getRepeatedImportEnumCount());
1993 result = msg.toByteArray();
1994 msgSerializedSize = msg.getSerializedSize();
2001 assertEquals(UnittestImportMicro.IMPORT_MICRO_FOO, msg.getRepeatedImportEnum(0));
2002 assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getRepeatedImportEnum(1));
2006 TestAllTypesMicro msg = new TestAllTypesMicro();
2007 assertEquals(0, msg.getRepeatedStringPieceCount());
2008 msg.addRepeatedStringPiece("hello");
2009 assertEquals(1, msg.getRepeatedStringPieceCount());
2010 assertEquals("hello", msg.getRepeatedStringPiece(0));
2011 msg.addRepeatedStringPiece("bye");
2012 assertEquals(2, msg.getRepeatedStringPieceCount());
2013 assertEquals("hello", msg.getRepeatedStringPiece(0));
2014 assertEquals("bye", msg.getRepeatedStringPiece(1));
2015 msg.setRepeatedStringPiece(0, "boo");
2016 assertEquals(2, msg.getRepeatedStringPieceCount());
2017 assertEquals("boo", msg.getRepeatedStringPiece(0));
2018 assertEquals("bye", msg.getRepeatedStringPiece(1));
2019 msg.clearRepeatedStringPiece();
2020 assertEquals(0, msg.getRepeatedStringPieceCount());
2021 msg.clearRepeatedStringPiece()
2023 assertEquals(1, msg.getRepeatedStringPieceCount());
2024 assertEquals("hello", msg.getRepeatedStringPiece(0));
2025 msg.clear();
2026 assertEquals(0, msg.getRepeatedStringPieceCount());
2029 msg.clear()
2031 assertEquals(1, msg.getRepeatedStringPieceCount());
2032 byte [] result = msg.toByteArray();
2033 int msgSerializedSize = msg.getSerializedSize();
2042 msg.clear()
2045 assertEquals(2, msg.getRepeatedStringPieceCount());
2046 result = msg.toByteArray();
2047 msgSerializedSize = msg.getSerializedSize();
2059 TestAllTypesMicro msg = new TestAllTypesMicro();
2060 assertEquals(0, msg.getRepeatedCordCount());
2061 msg.addRepeatedCord("hello");
2062 assertEquals(1, msg.getRepeatedCordCount());
2063 assertEquals("hello", msg.getRepeatedCord(0));
2064 msg.addRepeatedCord("bye");
2065 assertEquals(2, msg.getRepeatedCordCount());
2066 assertEquals("hello", msg.getRepeatedCord(0));
2067 assertEquals("bye", msg.getRepeatedCord(1));
2068 msg.setRepeatedCord(0, "boo");
2069 assertEquals(2, msg.getRepeatedCordCount());
2070 assertEquals("boo", msg.getRepeatedCord(0));
2071 assertEquals("bye", msg.getRepeatedCord(1));
2072 msg.clearRepeatedCord();
2073 assertEquals(0, msg.getRepeatedCordCount());
2074 msg.clearRepeatedCord()
2076 assertEquals(1, msg.getRepeatedCordCount());
2077 assertEquals("hello", msg.getRepeatedCord(0));
2078 msg.clear();
2079 assertEquals(0, msg.getRepeatedCordCount());
2082 msg.clear()
2084 assertEquals(1, msg.getRepeatedCordCount());
2085 byte [] result = msg.toByteArray();
2086 int msgSerializedSize = msg.getSerializedSize();
2095 msg.clear()
2098 assertEquals(2, msg.getRepeatedCordCount());
2099 result = msg.toByteArray();
2100 msgSerializedSize = msg.getSerializedSize();
2118 SingleMessageMicro msg = new SingleMessageMicro();
2130 MultipleNameClashMicro msg = new MultipleNameClashMicro();
2131 msg.setField(0);
2162 TestAllTypesMicro msg = new TestAllTypesMicro();
2163 assertFalse(msg.hasDefaultInt32());
2164 assertEquals(41, msg.getDefaultInt32());
2165 assertFalse(msg.hasDefaultInt64());
2166 assertEquals(42, msg.getDefaultInt64());
2167 assertFalse(msg.hasDefaultUint32());
2168 assertEquals(43, msg.getDefaultUint32());
2169 assertFalse(msg.hasDefaultUint64());
2170 assertEquals(44, msg.getDefaultUint64());
2171 assertFalse(msg.hasDefaultSint32());
2172 assertEquals(-45, msg.getDefaultSint32());
2173 assertFalse(msg.hasDefaultSint64());
2174 assertEquals(46, msg.getDefaultSint64());
2175 assertFalse(msg.hasDefaultFixed32());
2176 assertEquals(47, msg.getDefaultFixed32());
2177 assertFalse(msg.hasDefaultFixed64());
2178 assertEquals(48, msg.getDefaultFixed64());
2179 assertFalse(msg.hasDefaultSfixed32());
2180 assertEquals(49, msg.getDefaultSfixed32());
2181 assertFalse(msg.hasDefaultSfixed64());
2182 assertEquals(-50, msg.getDefaultSfixed64());
2183 assertFalse(msg.hasDefaultFloat());
2184 assertTrue(51.5f == msg.getDefaultFloat());
2185 assertFalse(msg.hasDefaultDouble());
2186 assertTrue(52.0e3 == msg.getDefaultDouble());
2187 assertFalse(msg.hasDefaultBool());
2188 assertEquals(true, msg.getDefaultBool());
2189 assertFalse(msg.hasDefaultString());
2190 assertEquals("hello", msg.getDefaultString());
2191 assertFalse(msg.hasDefaultBytes());
2192 assertEquals("world", msg.getDefaultBytes().toStringUtf8());
2193 assertFalse(msg.hasDefaultNestedEnum());
2194 assertEquals(TestAllTypesMicro.BAR, msg.getDefaultNestedEnum());
2195 assertFalse(msg.hasDefaultForeignEnum());
2196 assertEquals(MicroOuterClass.FOREIGN_MICRO_BAR, msg.getDefaultForeignEnum());
2197 assertFalse(msg.hasDefaultImportEnum());
2198 assertEquals(UnittestImportMicro.IMPORT_MICRO_BAR, msg.getDefaultImportEnum());
2199 assertFalse(msg.hasDefaultFloatInf());
2200 assertEquals(Float.POSITIVE_INFINITY, msg.getDefaultFloatInf());
2201 assertFalse(msg.hasDefaultFloatNegInf());
2202 assertEquals(Float.NEGATIVE_INFINITY, msg.getDefaultFloatNegInf());
2203 assertFalse(msg.hasDefaultFloatNan());
2204 assertEquals(Float.NaN, msg.getDefaultFloatNan());
2205 assertFalse(msg.hasDefaultDoubleInf());
2206 assertEquals(Double.POSITIVE_INFINITY, msg.getDefaultDoubleInf());
2207 assertFalse(msg.hasDefaultDoubleNegInf());
2208 assertEquals(Double.NEGATIVE_INFINITY, msg.getDefaultDoubleNegInf());
2209 assertFalse(msg.hasDefaultDoubleNan());
2210 assertEquals(Double.NaN, msg.getDefaultDoubleNan());