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