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 31 package com.google.protobuf; 32 33 import com.google.protobuf.micro.MicroOuterClass; 34 import com.google.protobuf.micro.MicroOuterClass.TestAllTypesMicro; 35 import com.google.protobuf.micro.RecursiveMessageMicro; 36 import com.google.protobuf.micro.SimpleMessageMicro; 37 import com.google.protobuf.micro.StringUtf8; 38 import com.google.protobuf.micro.UnittestImportMicro; 39 import com.google.protobuf.micro.ByteStringMicro; 40 import com.google.protobuf.micro.CodedInputStreamMicro; 41 42 import junit.framework.TestCase; 43 44 import java.io.ByteArrayInputStream; 45 import java.io.FilterInputStream; 46 import java.io.InputStream; 47 import java.io.IOException; 48 49 /** 50 * Test micro runtime. 51 * 52 * @author wink@google.com Wink Saville 53 */ 54 public class MicroTest extends TestCase { setUp()55 public void setUp() throws Exception { 56 } 57 testSimpleMessageMicro()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 testRecursiveMessageMicro()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 testMicroRequiredInt32()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 testMicroOptionalInt32()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 testMicroOptionalInt64()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 testMicroOptionalUint32()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 testMicroOptionalUint64()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 testMicroOptionalSint32()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 testMicroOptionalSint64()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 testMicroOptionalFixed32()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 testMicroOptionalFixed64()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 } testMicroOptionalSfixed32()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 testMicroOptionalSfixed64()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 testMicroOptionalFloat()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 testMicroOptionalDouble()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 testMicroOptionalBool()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 testMicroOptionalString()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 testMicroOptionalBytes()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 testMicroOptionalGroup()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 testMicroOptionalNestedMessage()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 testMicroOptionalForeignMessage()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 testMicroOptionalImportMessage()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 testMicroOptionalNestedEnum()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 testMicroOptionalForeignEnum()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 testMicroOptionalImportEnum()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 testMicroOptionalStringPiece()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 testMicroOptionalCord()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 testMicroRepeatedInt32()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 testMicroRepeatedInt64()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 testMicroRepeatedUint32()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 testMicroRepeatedUint64()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 testMicroRepeatedSint32()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 testMicroRepeatedSint64()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 testMicroRepeatedFixed32()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 testMicroRepeatedFixed64()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 testMicroRepeatedSfixed32()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 testMicroRepeatedSfixed64()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 testMicroRepeatedFloat()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 testMicroRepeatedDouble()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 testMicroRepeatedBool()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 testMicroRepeatedString()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 testMicroRepeatedBytes()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 testMicroRepeatedGroup()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 testMicroRepeatedNestedMessage()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 testMicroRepeatedForeignMessage()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 testMicroRepeatedImportMessage()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 testMicroRepeatedNestedEnum()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 testMicroRepeatedForeignEnum()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 testMicroRepeatedImportEnum()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 testMicroRepeatedStringPiece()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 testMicroRepeatedCord()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 testMicroDefaults()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 */ testSkipRawBytesBug()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 */ testSkipRawBytesPastEndOfBufferWithLimit()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 SmallBlockInputStream(byte[] data, int blockSize)2187 public SmallBlockInputStream(byte[] data, int blockSize) { 2188 this(new ByteArrayInputStream(data), blockSize); 2189 } 2190 SmallBlockInputStream(InputStream in, int blockSize)2191 public SmallBlockInputStream(InputStream in, int blockSize) { 2192 super(in); 2193 this.blockSize = blockSize; 2194 } 2195 read(byte[] b)2196 public int read(byte[] b) throws IOException { 2197 return super.read(b, 0, Math.min(b.length, blockSize)); 2198 } 2199 read(byte[] b, int off, int len)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