| OLD | NEW |
|---|
| (Empty) |
| 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.test; | |
| 32 import com.google.protobuf.*; | |
| 33 | |
| 34 import protobuf_unittest.UnittestProto; | |
| 35 | |
| 36 // The static imports are to avoid 100+ char lines. The following is roughly eq
uivalent to | |
| 37 // import static protobuf_unittest.UnittestProto.*; | |
| 38 import static protobuf_unittest.UnittestProto.defaultInt32Extension; | |
| 39 import static protobuf_unittest.UnittestProto.defaultInt64Extension; | |
| 40 import static protobuf_unittest.UnittestProto.defaultUint32Extension; | |
| 41 import static protobuf_unittest.UnittestProto.defaultUint64Extension; | |
| 42 import static protobuf_unittest.UnittestProto.defaultSint32Extension; | |
| 43 import static protobuf_unittest.UnittestProto.defaultSint64Extension; | |
| 44 import static protobuf_unittest.UnittestProto.defaultFixed32Extension; | |
| 45 import static protobuf_unittest.UnittestProto.defaultFixed64Extension; | |
| 46 import static protobuf_unittest.UnittestProto.defaultSfixed32Extension; | |
| 47 import static protobuf_unittest.UnittestProto.defaultSfixed64Extension; | |
| 48 import static protobuf_unittest.UnittestProto.defaultFloatExtension; | |
| 49 import static protobuf_unittest.UnittestProto.defaultDoubleExtension; | |
| 50 import static protobuf_unittest.UnittestProto.defaultBoolExtension; | |
| 51 import static protobuf_unittest.UnittestProto.defaultStringExtension; | |
| 52 import static protobuf_unittest.UnittestProto.defaultBytesExtension; | |
| 53 import static protobuf_unittest.UnittestProto.defaultNestedEnumExtension; | |
| 54 import static protobuf_unittest.UnittestProto.defaultForeignEnumExtension; | |
| 55 import static protobuf_unittest.UnittestProto.defaultImportEnumExtension; | |
| 56 import static protobuf_unittest.UnittestProto.defaultStringPieceExtension; | |
| 57 import static protobuf_unittest.UnittestProto.defaultCordExtension; | |
| 58 | |
| 59 import static protobuf_unittest.UnittestProto.optionalInt32Extension; | |
| 60 import static protobuf_unittest.UnittestProto.optionalInt64Extension; | |
| 61 import static protobuf_unittest.UnittestProto.optionalUint32Extension; | |
| 62 import static protobuf_unittest.UnittestProto.optionalUint64Extension; | |
| 63 import static protobuf_unittest.UnittestProto.optionalSint32Extension; | |
| 64 import static protobuf_unittest.UnittestProto.optionalSint64Extension; | |
| 65 import static protobuf_unittest.UnittestProto.optionalFixed32Extension; | |
| 66 import static protobuf_unittest.UnittestProto.optionalFixed64Extension; | |
| 67 import static protobuf_unittest.UnittestProto.optionalSfixed32Extension; | |
| 68 import static protobuf_unittest.UnittestProto.optionalSfixed64Extension; | |
| 69 import static protobuf_unittest.UnittestProto.optionalFloatExtension; | |
| 70 import static protobuf_unittest.UnittestProto.optionalDoubleExtension; | |
| 71 import static protobuf_unittest.UnittestProto.optionalBoolExtension; | |
| 72 import static protobuf_unittest.UnittestProto.optionalStringExtension; | |
| 73 import static protobuf_unittest.UnittestProto.optionalBytesExtension; | |
| 74 import static protobuf_unittest.UnittestProto.optionalGroupExtension; | |
| 75 import static protobuf_unittest.UnittestProto.optionalCordExtension; | |
| 76 import static protobuf_unittest.UnittestProto.optionalForeignEnumExtension; | |
| 77 import static protobuf_unittest.UnittestProto.optionalForeignMessageExtension; | |
| 78 import static protobuf_unittest.UnittestProto.optionalImportEnumExtension; | |
| 79 import static protobuf_unittest.UnittestProto.optionalImportMessageExtension; | |
| 80 import static protobuf_unittest.UnittestProto.optionalNestedEnumExtension; | |
| 81 import static protobuf_unittest.UnittestProto.optionalNestedMessageExtension; | |
| 82 import static protobuf_unittest.UnittestProto.optionalPublicImportMessageExtensi
on; | |
| 83 import static protobuf_unittest.UnittestProto.optionalLazyMessageExtension; | |
| 84 import static protobuf_unittest.UnittestProto.optionalStringPieceExtension; | |
| 85 | |
| 86 import static protobuf_unittest.UnittestProto.repeatedInt32Extension; | |
| 87 import static protobuf_unittest.UnittestProto.repeatedInt64Extension; | |
| 88 import static protobuf_unittest.UnittestProto.repeatedUint32Extension; | |
| 89 import static protobuf_unittest.UnittestProto.repeatedUint64Extension; | |
| 90 import static protobuf_unittest.UnittestProto.repeatedSint32Extension; | |
| 91 import static protobuf_unittest.UnittestProto.repeatedSint64Extension; | |
| 92 import static protobuf_unittest.UnittestProto.repeatedFixed32Extension; | |
| 93 import static protobuf_unittest.UnittestProto.repeatedFixed64Extension; | |
| 94 import static protobuf_unittest.UnittestProto.repeatedSfixed32Extension; | |
| 95 import static protobuf_unittest.UnittestProto.repeatedSfixed64Extension; | |
| 96 import static protobuf_unittest.UnittestProto.repeatedFloatExtension; | |
| 97 import static protobuf_unittest.UnittestProto.repeatedDoubleExtension; | |
| 98 import static protobuf_unittest.UnittestProto.repeatedBoolExtension; | |
| 99 import static protobuf_unittest.UnittestProto.repeatedStringExtension; | |
| 100 import static protobuf_unittest.UnittestProto.repeatedBytesExtension; | |
| 101 import static protobuf_unittest.UnittestProto.repeatedGroupExtension; | |
| 102 import static protobuf_unittest.UnittestProto.repeatedNestedMessageExtension; | |
| 103 import static protobuf_unittest.UnittestProto.repeatedForeignMessageExtension; | |
| 104 import static protobuf_unittest.UnittestProto.repeatedImportMessageExtension; | |
| 105 import static protobuf_unittest.UnittestProto.repeatedLazyMessageExtension; | |
| 106 import static protobuf_unittest.UnittestProto.repeatedNestedEnumExtension; | |
| 107 import static protobuf_unittest.UnittestProto.repeatedForeignEnumExtension; | |
| 108 import static protobuf_unittest.UnittestProto.repeatedImportEnumExtension; | |
| 109 import static protobuf_unittest.UnittestProto.repeatedStringPieceExtension; | |
| 110 import static protobuf_unittest.UnittestProto.repeatedCordExtension; | |
| 111 | |
| 112 import static protobuf_unittest.UnittestProto.OptionalGroup_extension; | |
| 113 import static protobuf_unittest.UnittestProto.RepeatedGroup_extension; | |
| 114 | |
| 115 import static protobuf_unittest.UnittestProto.packedInt32Extension; | |
| 116 import static protobuf_unittest.UnittestProto.packedInt64Extension; | |
| 117 import static protobuf_unittest.UnittestProto.packedUint32Extension; | |
| 118 import static protobuf_unittest.UnittestProto.packedUint64Extension; | |
| 119 import static protobuf_unittest.UnittestProto.packedSint32Extension; | |
| 120 import static protobuf_unittest.UnittestProto.packedSint64Extension; | |
| 121 import static protobuf_unittest.UnittestProto.packedFixed32Extension; | |
| 122 import static protobuf_unittest.UnittestProto.packedFixed64Extension; | |
| 123 import static protobuf_unittest.UnittestProto.packedSfixed32Extension; | |
| 124 import static protobuf_unittest.UnittestProto.packedSfixed64Extension; | |
| 125 import static protobuf_unittest.UnittestProto.packedFloatExtension; | |
| 126 import static protobuf_unittest.UnittestProto.packedDoubleExtension; | |
| 127 import static protobuf_unittest.UnittestProto.packedBoolExtension; | |
| 128 import static protobuf_unittest.UnittestProto.packedEnumExtension; | |
| 129 | |
| 130 | |
| 131 import protobuf_unittest.UnittestProto.TestAllExtensions; | |
| 132 import protobuf_unittest.UnittestProto.TestAllExtensionsOrBuilder; | |
| 133 import protobuf_unittest.UnittestProto.TestAllTypes; | |
| 134 import protobuf_unittest.UnittestProto.TestAllTypesOrBuilder; | |
| 135 import protobuf_unittest.UnittestProto.TestPackedExtensions; | |
| 136 import protobuf_unittest.UnittestProto.TestPackedTypes; | |
| 137 import protobuf_unittest.UnittestProto.TestUnpackedTypes; | |
| 138 import protobuf_unittest.UnittestProto.ForeignMessage; | |
| 139 import protobuf_unittest.UnittestProto.ForeignEnum; | |
| 140 import com.google.protobuf.test.UnittestImport.ImportEnum; | |
| 141 import com.google.protobuf.test.UnittestImport.ImportMessage; | |
| 142 import com.google.protobuf.test.UnittestImportPublic.PublicImportMessage; | |
| 143 | |
| 144 import junit.framework.Assert; | |
| 145 | |
| 146 import java.io.File; | |
| 147 import java.io.IOException; | |
| 148 import java.io.RandomAccessFile; | |
| 149 | |
| 150 /** | |
| 151 * Contains methods for setting all fields of {@code TestAllTypes} to | |
| 152 * some values as well as checking that all the fields are set to those values. | |
| 153 * These are useful for testing various protocol message features, e.g. | |
| 154 * set all fields of a message, serialize it, parse it, and check that all | |
| 155 * fields are set. | |
| 156 * | |
| 157 * <p>This code is not to be used outside of {@code com.google.protobuf} and | |
| 158 * subpackages. | |
| 159 * | |
| 160 * @author kenton@google.com Kenton Varda | |
| 161 */ | |
| 162 public final class TestUtil { | |
| 163 private TestUtil() {} | |
| 164 | |
| 165 /** Helper to convert a String to ByteString. */ | |
| 166 static ByteString toBytes(String str) { | |
| 167 try { | |
| 168 return ByteString.copyFrom(str.getBytes("UTF-8")); | |
| 169 } catch(java.io.UnsupportedEncodingException e) { | |
| 170 throw new RuntimeException("UTF-8 not supported.", e); | |
| 171 } | |
| 172 } | |
| 173 | |
| 174 /** | |
| 175 * Get a {@code TestAllTypes} with all fields set as they would be by | |
| 176 * {@link #setAllFields(TestAllTypes.Builder)}. | |
| 177 */ | |
| 178 public static TestAllTypes getAllSet() { | |
| 179 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); | |
| 180 setAllFields(builder); | |
| 181 return builder.build(); | |
| 182 } | |
| 183 | |
| 184 /** | |
| 185 * Get a {@code TestAllTypes.Builder} with all fields set as they would be by | |
| 186 * {@link #setAllFields(TestAllTypes.Builder)}. | |
| 187 */ | |
| 188 public static TestAllTypes.Builder getAllSetBuilder() { | |
| 189 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); | |
| 190 setAllFields(builder); | |
| 191 return builder; | |
| 192 } | |
| 193 | |
| 194 /** | |
| 195 * Get a {@code TestAllExtensions} with all fields set as they would be by | |
| 196 * {@link #setAllExtensions(TestAllExtensions.Builder)}. | |
| 197 */ | |
| 198 public static TestAllExtensions getAllExtensionsSet() { | |
| 199 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); | |
| 200 setAllExtensions(builder); | |
| 201 return builder.build(); | |
| 202 } | |
| 203 | |
| 204 public static TestPackedTypes getPackedSet() { | |
| 205 TestPackedTypes.Builder builder = TestPackedTypes.newBuilder(); | |
| 206 setPackedFields(builder); | |
| 207 return builder.build(); | |
| 208 } | |
| 209 | |
| 210 public static TestUnpackedTypes getUnpackedSet() { | |
| 211 TestUnpackedTypes.Builder builder = TestUnpackedTypes.newBuilder(); | |
| 212 setUnpackedFields(builder); | |
| 213 return builder.build(); | |
| 214 } | |
| 215 | |
| 216 public static TestPackedExtensions getPackedExtensionsSet() { | |
| 217 TestPackedExtensions.Builder builder = TestPackedExtensions.newBuilder(); | |
| 218 setPackedExtensions(builder); | |
| 219 return builder.build(); | |
| 220 } | |
| 221 | |
| 222 /** | |
| 223 * Set every field of {@code message} to the values expected by | |
| 224 * {@code assertAllFieldsSet()}. | |
| 225 */ | |
| 226 public static void setAllFields(TestAllTypes.Builder message) { | |
| 227 message.setOptionalInt32 (101); | |
| 228 message.setOptionalInt64 (102); | |
| 229 message.setOptionalUint32 (103); | |
| 230 message.setOptionalUint64 (104); | |
| 231 message.setOptionalSint32 (105); | |
| 232 message.setOptionalSint64 (106); | |
| 233 message.setOptionalFixed32 (107); | |
| 234 message.setOptionalFixed64 (108); | |
| 235 message.setOptionalSfixed32(109); | |
| 236 message.setOptionalSfixed64(110); | |
| 237 message.setOptionalFloat (111); | |
| 238 message.setOptionalDouble (112); | |
| 239 message.setOptionalBool (true); | |
| 240 message.setOptionalString ("115"); | |
| 241 message.setOptionalBytes (toBytes("116")); | |
| 242 | |
| 243 message.setOptionalGroup( | |
| 244 TestAllTypes.OptionalGroup.newBuilder().setA(117).build()); | |
| 245 message.setOptionalNestedMessage( | |
| 246 TestAllTypes.NestedMessage.newBuilder().setBb(118).build()); | |
| 247 message.setOptionalForeignMessage( | |
| 248 ForeignMessage.newBuilder().setC(119).build()); | |
| 249 message.setOptionalImportMessage( | |
| 250 ImportMessage.newBuilder().setD(120).build()); | |
| 251 message.setOptionalPublicImportMessage( | |
| 252 PublicImportMessage.newBuilder().setE(126).build()); | |
| 253 message.setOptionalLazyMessage( | |
| 254 TestAllTypes.NestedMessage.newBuilder().setBb(127).build()); | |
| 255 | |
| 256 message.setOptionalNestedEnum (TestAllTypes.NestedEnum.BAZ); | |
| 257 message.setOptionalForeignEnum(ForeignEnum.FOREIGN_BAZ); | |
| 258 message.setOptionalImportEnum (ImportEnum.IMPORT_BAZ); | |
| 259 | |
| 260 message.setOptionalStringPiece("124"); | |
| 261 message.setOptionalCord("125"); | |
| 262 | |
| 263 // ----------------------------------------------------------------- | |
| 264 | |
| 265 message.addRepeatedInt32 (201); | |
| 266 message.addRepeatedInt64 (202); | |
| 267 message.addRepeatedUint32 (203); | |
| 268 message.addRepeatedUint64 (204); | |
| 269 message.addRepeatedSint32 (205); | |
| 270 message.addRepeatedSint64 (206); | |
| 271 message.addRepeatedFixed32 (207); | |
| 272 message.addRepeatedFixed64 (208); | |
| 273 message.addRepeatedSfixed32(209); | |
| 274 message.addRepeatedSfixed64(210); | |
| 275 message.addRepeatedFloat (211); | |
| 276 message.addRepeatedDouble (212); | |
| 277 message.addRepeatedBool (true); | |
| 278 message.addRepeatedString ("215"); | |
| 279 message.addRepeatedBytes (toBytes("216")); | |
| 280 | |
| 281 message.addRepeatedGroup( | |
| 282 TestAllTypes.RepeatedGroup.newBuilder().setA(217).build()); | |
| 283 message.addRepeatedNestedMessage( | |
| 284 TestAllTypes.NestedMessage.newBuilder().setBb(218).build()); | |
| 285 message.addRepeatedForeignMessage( | |
| 286 ForeignMessage.newBuilder().setC(219).build()); | |
| 287 message.addRepeatedImportMessage( | |
| 288 ImportMessage.newBuilder().setD(220).build()); | |
| 289 message.addRepeatedLazyMessage( | |
| 290 TestAllTypes.NestedMessage.newBuilder().setBb(227).build()); | |
| 291 | |
| 292 message.addRepeatedNestedEnum (TestAllTypes.NestedEnum.BAR); | |
| 293 message.addRepeatedForeignEnum(ForeignEnum.FOREIGN_BAR); | |
| 294 message.addRepeatedImportEnum (ImportEnum.IMPORT_BAR); | |
| 295 | |
| 296 message.addRepeatedStringPiece("224"); | |
| 297 message.addRepeatedCord("225"); | |
| 298 | |
| 299 // Add a second one of each field. | |
| 300 message.addRepeatedInt32 (301); | |
| 301 message.addRepeatedInt64 (302); | |
| 302 message.addRepeatedUint32 (303); | |
| 303 message.addRepeatedUint64 (304); | |
| 304 message.addRepeatedSint32 (305); | |
| 305 message.addRepeatedSint64 (306); | |
| 306 message.addRepeatedFixed32 (307); | |
| 307 message.addRepeatedFixed64 (308); | |
| 308 message.addRepeatedSfixed32(309); | |
| 309 message.addRepeatedSfixed64(310); | |
| 310 message.addRepeatedFloat (311); | |
| 311 message.addRepeatedDouble (312); | |
| 312 message.addRepeatedBool (false); | |
| 313 message.addRepeatedString ("315"); | |
| 314 message.addRepeatedBytes (toBytes("316")); | |
| 315 | |
| 316 message.addRepeatedGroup( | |
| 317 TestAllTypes.RepeatedGroup.newBuilder().setA(317).build()); | |
| 318 message.addRepeatedNestedMessage( | |
| 319 TestAllTypes.NestedMessage.newBuilder().setBb(318).build()); | |
| 320 message.addRepeatedForeignMessage( | |
| 321 ForeignMessage.newBuilder().setC(319).build()); | |
| 322 message.addRepeatedImportMessage( | |
| 323 ImportMessage.newBuilder().setD(320).build()); | |
| 324 message.addRepeatedLazyMessage( | |
| 325 TestAllTypes.NestedMessage.newBuilder().setBb(327).build()); | |
| 326 | |
| 327 message.addRepeatedNestedEnum (TestAllTypes.NestedEnum.BAZ); | |
| 328 message.addRepeatedForeignEnum(ForeignEnum.FOREIGN_BAZ); | |
| 329 message.addRepeatedImportEnum (ImportEnum.IMPORT_BAZ); | |
| 330 | |
| 331 message.addRepeatedStringPiece("324"); | |
| 332 message.addRepeatedCord("325"); | |
| 333 | |
| 334 // ----------------------------------------------------------------- | |
| 335 | |
| 336 message.setDefaultInt32 (401); | |
| 337 message.setDefaultInt64 (402); | |
| 338 message.setDefaultUint32 (403); | |
| 339 message.setDefaultUint64 (404); | |
| 340 message.setDefaultSint32 (405); | |
| 341 message.setDefaultSint64 (406); | |
| 342 message.setDefaultFixed32 (407); | |
| 343 message.setDefaultFixed64 (408); | |
| 344 message.setDefaultSfixed32(409); | |
| 345 message.setDefaultSfixed64(410); | |
| 346 message.setDefaultFloat (411); | |
| 347 message.setDefaultDouble (412); | |
| 348 message.setDefaultBool (false); | |
| 349 message.setDefaultString ("415"); | |
| 350 message.setDefaultBytes (toBytes("416")); | |
| 351 | |
| 352 message.setDefaultNestedEnum (TestAllTypes.NestedEnum.FOO); | |
| 353 message.setDefaultForeignEnum(ForeignEnum.FOREIGN_FOO); | |
| 354 message.setDefaultImportEnum (ImportEnum.IMPORT_FOO); | |
| 355 | |
| 356 message.setDefaultStringPiece("424"); | |
| 357 message.setDefaultCord("425"); | |
| 358 } | |
| 359 | |
| 360 // ------------------------------------------------------------------- | |
| 361 | |
| 362 /** | |
| 363 * Modify the repeated fields of {@code message} to contain the values | |
| 364 * expected by {@code assertRepeatedFieldsModified()}. | |
| 365 */ | |
| 366 public static void modifyRepeatedFields(TestAllTypes.Builder message) { | |
| 367 message.setRepeatedInt32 (1, 501); | |
| 368 message.setRepeatedInt64 (1, 502); | |
| 369 message.setRepeatedUint32 (1, 503); | |
| 370 message.setRepeatedUint64 (1, 504); | |
| 371 message.setRepeatedSint32 (1, 505); | |
| 372 message.setRepeatedSint64 (1, 506); | |
| 373 message.setRepeatedFixed32 (1, 507); | |
| 374 message.setRepeatedFixed64 (1, 508); | |
| 375 message.setRepeatedSfixed32(1, 509); | |
| 376 message.setRepeatedSfixed64(1, 510); | |
| 377 message.setRepeatedFloat (1, 511); | |
| 378 message.setRepeatedDouble (1, 512); | |
| 379 message.setRepeatedBool (1, true); | |
| 380 message.setRepeatedString (1, "515"); | |
| 381 message.setRepeatedBytes (1, toBytes("516")); | |
| 382 | |
| 383 message.setRepeatedGroup(1, | |
| 384 TestAllTypes.RepeatedGroup.newBuilder().setA(517).build()); | |
| 385 message.setRepeatedNestedMessage(1, | |
| 386 TestAllTypes.NestedMessage.newBuilder().setBb(518).build()); | |
| 387 message.setRepeatedForeignMessage(1, | |
| 388 ForeignMessage.newBuilder().setC(519).build()); | |
| 389 message.setRepeatedImportMessage(1, | |
| 390 ImportMessage.newBuilder().setD(520).build()); | |
| 391 message.setRepeatedLazyMessage(1, | |
| 392 TestAllTypes.NestedMessage.newBuilder().setBb(527).build()); | |
| 393 | |
| 394 message.setRepeatedNestedEnum (1, TestAllTypes.NestedEnum.FOO); | |
| 395 message.setRepeatedForeignEnum(1, ForeignEnum.FOREIGN_FOO); | |
| 396 message.setRepeatedImportEnum (1, ImportEnum.IMPORT_FOO); | |
| 397 | |
| 398 message.setRepeatedStringPiece(1, "524"); | |
| 399 message.setRepeatedCord(1, "525"); | |
| 400 } | |
| 401 | |
| 402 // ------------------------------------------------------------------- | |
| 403 | |
| 404 /** | |
| 405 * Assert (using {@code junit.framework.Assert}} that all fields of | |
| 406 * {@code message} are set to the values assigned by {@code setAllFields}. | |
| 407 */ | |
| 408 public static void assertAllFieldsSet(TestAllTypesOrBuilder message) { | |
| 409 Assert.assertTrue(message.hasOptionalInt32 ()); | |
| 410 Assert.assertTrue(message.hasOptionalInt64 ()); | |
| 411 Assert.assertTrue(message.hasOptionalUint32 ()); | |
| 412 Assert.assertTrue(message.hasOptionalUint64 ()); | |
| 413 Assert.assertTrue(message.hasOptionalSint32 ()); | |
| 414 Assert.assertTrue(message.hasOptionalSint64 ()); | |
| 415 Assert.assertTrue(message.hasOptionalFixed32 ()); | |
| 416 Assert.assertTrue(message.hasOptionalFixed64 ()); | |
| 417 Assert.assertTrue(message.hasOptionalSfixed32()); | |
| 418 Assert.assertTrue(message.hasOptionalSfixed64()); | |
| 419 Assert.assertTrue(message.hasOptionalFloat ()); | |
| 420 Assert.assertTrue(message.hasOptionalDouble ()); | |
| 421 Assert.assertTrue(message.hasOptionalBool ()); | |
| 422 Assert.assertTrue(message.hasOptionalString ()); | |
| 423 Assert.assertTrue(message.hasOptionalBytes ()); | |
| 424 | |
| 425 Assert.assertTrue(message.hasOptionalGroup ()); | |
| 426 Assert.assertTrue(message.hasOptionalNestedMessage ()); | |
| 427 Assert.assertTrue(message.hasOptionalForeignMessage()); | |
| 428 Assert.assertTrue(message.hasOptionalImportMessage ()); | |
| 429 | |
| 430 Assert.assertTrue(message.getOptionalGroup ().hasA()); | |
| 431 Assert.assertTrue(message.getOptionalNestedMessage ().hasBb()); | |
| 432 Assert.assertTrue(message.getOptionalForeignMessage().hasC()); | |
| 433 Assert.assertTrue(message.getOptionalImportMessage ().hasD()); | |
| 434 | |
| 435 Assert.assertTrue(message.hasOptionalNestedEnum ()); | |
| 436 Assert.assertTrue(message.hasOptionalForeignEnum()); | |
| 437 Assert.assertTrue(message.hasOptionalImportEnum ()); | |
| 438 | |
| 439 Assert.assertTrue(message.hasOptionalStringPiece()); | |
| 440 Assert.assertTrue(message.hasOptionalCord()); | |
| 441 | |
| 442 Assert.assertEquals(101 , message.getOptionalInt32 ()); | |
| 443 Assert.assertEquals(102 , message.getOptionalInt64 ()); | |
| 444 Assert.assertEquals(103 , message.getOptionalUint32 ()); | |
| 445 Assert.assertEquals(104 , message.getOptionalUint64 ()); | |
| 446 Assert.assertEquals(105 , message.getOptionalSint32 ()); | |
| 447 Assert.assertEquals(106 , message.getOptionalSint64 ()); | |
| 448 Assert.assertEquals(107 , message.getOptionalFixed32 ()); | |
| 449 Assert.assertEquals(108 , message.getOptionalFixed64 ()); | |
| 450 Assert.assertEquals(109 , message.getOptionalSfixed32()); | |
| 451 Assert.assertEquals(110 , message.getOptionalSfixed64()); | |
| 452 Assert.assertEquals(111 , message.getOptionalFloat (), 0.0); | |
| 453 Assert.assertEquals(112 , message.getOptionalDouble (), 0.0); | |
| 454 Assert.assertEquals(true , message.getOptionalBool ()); | |
| 455 Assert.assertEquals("115", message.getOptionalString ()); | |
| 456 Assert.assertEquals(toBytes("116"), message.getOptionalBytes()); | |
| 457 | |
| 458 Assert.assertEquals(117, message.getOptionalGroup ().getA()); | |
| 459 Assert.assertEquals(118, message.getOptionalNestedMessage ().getBb()); | |
| 460 Assert.assertEquals(119, message.getOptionalForeignMessage ().getC()); | |
| 461 Assert.assertEquals(120, message.getOptionalImportMessage ().getD()); | |
| 462 Assert.assertEquals(126, message.getOptionalPublicImportMessage().getE()); | |
| 463 Assert.assertEquals(127, message.getOptionalLazyMessage ().getBb()); | |
| 464 | |
| 465 Assert.assertEquals(TestAllTypes.NestedEnum.BAZ, message.getOptionalNestedEn
um()); | |
| 466 Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getOptionalForeignEnum(
)); | |
| 467 Assert.assertEquals(ImportEnum.IMPORT_BAZ, message.getOptionalImportEnum()); | |
| 468 | |
| 469 Assert.assertEquals("124", message.getOptionalStringPiece()); | |
| 470 Assert.assertEquals("125", message.getOptionalCord()); | |
| 471 | |
| 472 // ----------------------------------------------------------------- | |
| 473 | |
| 474 Assert.assertEquals(2, message.getRepeatedInt32Count ()); | |
| 475 Assert.assertEquals(2, message.getRepeatedInt64Count ()); | |
| 476 Assert.assertEquals(2, message.getRepeatedUint32Count ()); | |
| 477 Assert.assertEquals(2, message.getRepeatedUint64Count ()); | |
| 478 Assert.assertEquals(2, message.getRepeatedSint32Count ()); | |
| 479 Assert.assertEquals(2, message.getRepeatedSint64Count ()); | |
| 480 Assert.assertEquals(2, message.getRepeatedFixed32Count ()); | |
| 481 Assert.assertEquals(2, message.getRepeatedFixed64Count ()); | |
| 482 Assert.assertEquals(2, message.getRepeatedSfixed32Count()); | |
| 483 Assert.assertEquals(2, message.getRepeatedSfixed64Count()); | |
| 484 Assert.assertEquals(2, message.getRepeatedFloatCount ()); | |
| 485 Assert.assertEquals(2, message.getRepeatedDoubleCount ()); | |
| 486 Assert.assertEquals(2, message.getRepeatedBoolCount ()); | |
| 487 Assert.assertEquals(2, message.getRepeatedStringCount ()); | |
| 488 Assert.assertEquals(2, message.getRepeatedBytesCount ()); | |
| 489 | |
| 490 Assert.assertEquals(2, message.getRepeatedGroupCount ()); | |
| 491 Assert.assertEquals(2, message.getRepeatedNestedMessageCount ()); | |
| 492 Assert.assertEquals(2, message.getRepeatedForeignMessageCount()); | |
| 493 Assert.assertEquals(2, message.getRepeatedImportMessageCount ()); | |
| 494 Assert.assertEquals(2, message.getRepeatedLazyMessageCount ()); | |
| 495 Assert.assertEquals(2, message.getRepeatedNestedEnumCount ()); | |
| 496 Assert.assertEquals(2, message.getRepeatedForeignEnumCount ()); | |
| 497 Assert.assertEquals(2, message.getRepeatedImportEnumCount ()); | |
| 498 | |
| 499 Assert.assertEquals(2, message.getRepeatedStringPieceCount()); | |
| 500 Assert.assertEquals(2, message.getRepeatedCordCount()); | |
| 501 | |
| 502 Assert.assertEquals(201 , message.getRepeatedInt32 (0)); | |
| 503 Assert.assertEquals(202 , message.getRepeatedInt64 (0)); | |
| 504 Assert.assertEquals(203 , message.getRepeatedUint32 (0)); | |
| 505 Assert.assertEquals(204 , message.getRepeatedUint64 (0)); | |
| 506 Assert.assertEquals(205 , message.getRepeatedSint32 (0)); | |
| 507 Assert.assertEquals(206 , message.getRepeatedSint64 (0)); | |
| 508 Assert.assertEquals(207 , message.getRepeatedFixed32 (0)); | |
| 509 Assert.assertEquals(208 , message.getRepeatedFixed64 (0)); | |
| 510 Assert.assertEquals(209 , message.getRepeatedSfixed32(0)); | |
| 511 Assert.assertEquals(210 , message.getRepeatedSfixed64(0)); | |
| 512 Assert.assertEquals(211 , message.getRepeatedFloat (0), 0.0); | |
| 513 Assert.assertEquals(212 , message.getRepeatedDouble (0), 0.0); | |
| 514 Assert.assertEquals(true , message.getRepeatedBool (0)); | |
| 515 Assert.assertEquals("215", message.getRepeatedString (0)); | |
| 516 Assert.assertEquals(toBytes("216"), message.getRepeatedBytes(0)); | |
| 517 | |
| 518 Assert.assertEquals(217, message.getRepeatedGroup (0).getA()); | |
| 519 Assert.assertEquals(218, message.getRepeatedNestedMessage (0).getBb()); | |
| 520 Assert.assertEquals(219, message.getRepeatedForeignMessage(0).getC()); | |
| 521 Assert.assertEquals(220, message.getRepeatedImportMessage (0).getD()); | |
| 522 Assert.assertEquals(227, message.getRepeatedLazyMessage (0).getBb()); | |
| 523 | |
| 524 Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getRepeatedNestedEn
um (0)); | |
| 525 Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getRepeatedForeignEnum(
0)); | |
| 526 Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getRepeatedImportEnum(0))
; | |
| 527 | |
| 528 Assert.assertEquals("224", message.getRepeatedStringPiece(0)); | |
| 529 Assert.assertEquals("225", message.getRepeatedCord(0)); | |
| 530 | |
| 531 Assert.assertEquals(301 , message.getRepeatedInt32 (1)); | |
| 532 Assert.assertEquals(302 , message.getRepeatedInt64 (1)); | |
| 533 Assert.assertEquals(303 , message.getRepeatedUint32 (1)); | |
| 534 Assert.assertEquals(304 , message.getRepeatedUint64 (1)); | |
| 535 Assert.assertEquals(305 , message.getRepeatedSint32 (1)); | |
| 536 Assert.assertEquals(306 , message.getRepeatedSint64 (1)); | |
| 537 Assert.assertEquals(307 , message.getRepeatedFixed32 (1)); | |
| 538 Assert.assertEquals(308 , message.getRepeatedFixed64 (1)); | |
| 539 Assert.assertEquals(309 , message.getRepeatedSfixed32(1)); | |
| 540 Assert.assertEquals(310 , message.getRepeatedSfixed64(1)); | |
| 541 Assert.assertEquals(311 , message.getRepeatedFloat (1), 0.0); | |
| 542 Assert.assertEquals(312 , message.getRepeatedDouble (1), 0.0); | |
| 543 Assert.assertEquals(false, message.getRepeatedBool (1)); | |
| 544 Assert.assertEquals("315", message.getRepeatedString (1)); | |
| 545 Assert.assertEquals(toBytes("316"), message.getRepeatedBytes(1)); | |
| 546 | |
| 547 Assert.assertEquals(317, message.getRepeatedGroup (1).getA()); | |
| 548 Assert.assertEquals(318, message.getRepeatedNestedMessage (1).getBb()); | |
| 549 Assert.assertEquals(319, message.getRepeatedForeignMessage(1).getC()); | |
| 550 Assert.assertEquals(320, message.getRepeatedImportMessage (1).getD()); | |
| 551 Assert.assertEquals(327, message.getRepeatedLazyMessage (1).getBb()); | |
| 552 | |
| 553 Assert.assertEquals(TestAllTypes.NestedEnum.BAZ, message.getRepeatedNestedEn
um (1)); | |
| 554 Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getRepeatedForeignEnum(
1)); | |
| 555 Assert.assertEquals(ImportEnum.IMPORT_BAZ, message.getRepeatedImportEnum(1))
; | |
| 556 | |
| 557 Assert.assertEquals("324", message.getRepeatedStringPiece(1)); | |
| 558 Assert.assertEquals("325", message.getRepeatedCord(1)); | |
| 559 | |
| 560 // ----------------------------------------------------------------- | |
| 561 | |
| 562 Assert.assertTrue(message.hasDefaultInt32 ()); | |
| 563 Assert.assertTrue(message.hasDefaultInt64 ()); | |
| 564 Assert.assertTrue(message.hasDefaultUint32 ()); | |
| 565 Assert.assertTrue(message.hasDefaultUint64 ()); | |
| 566 Assert.assertTrue(message.hasDefaultSint32 ()); | |
| 567 Assert.assertTrue(message.hasDefaultSint64 ()); | |
| 568 Assert.assertTrue(message.hasDefaultFixed32 ()); | |
| 569 Assert.assertTrue(message.hasDefaultFixed64 ()); | |
| 570 Assert.assertTrue(message.hasDefaultSfixed32()); | |
| 571 Assert.assertTrue(message.hasDefaultSfixed64()); | |
| 572 Assert.assertTrue(message.hasDefaultFloat ()); | |
| 573 Assert.assertTrue(message.hasDefaultDouble ()); | |
| 574 Assert.assertTrue(message.hasDefaultBool ()); | |
| 575 Assert.assertTrue(message.hasDefaultString ()); | |
| 576 Assert.assertTrue(message.hasDefaultBytes ()); | |
| 577 | |
| 578 Assert.assertTrue(message.hasDefaultNestedEnum ()); | |
| 579 Assert.assertTrue(message.hasDefaultForeignEnum()); | |
| 580 Assert.assertTrue(message.hasDefaultImportEnum ()); | |
| 581 | |
| 582 Assert.assertTrue(message.hasDefaultStringPiece()); | |
| 583 Assert.assertTrue(message.hasDefaultCord()); | |
| 584 | |
| 585 Assert.assertEquals(401 , message.getDefaultInt32 ()); | |
| 586 Assert.assertEquals(402 , message.getDefaultInt64 ()); | |
| 587 Assert.assertEquals(403 , message.getDefaultUint32 ()); | |
| 588 Assert.assertEquals(404 , message.getDefaultUint64 ()); | |
| 589 Assert.assertEquals(405 , message.getDefaultSint32 ()); | |
| 590 Assert.assertEquals(406 , message.getDefaultSint64 ()); | |
| 591 Assert.assertEquals(407 , message.getDefaultFixed32 ()); | |
| 592 Assert.assertEquals(408 , message.getDefaultFixed64 ()); | |
| 593 Assert.assertEquals(409 , message.getDefaultSfixed32()); | |
| 594 Assert.assertEquals(410 , message.getDefaultSfixed64()); | |
| 595 Assert.assertEquals(411 , message.getDefaultFloat (), 0.0); | |
| 596 Assert.assertEquals(412 , message.getDefaultDouble (), 0.0); | |
| 597 Assert.assertEquals(false, message.getDefaultBool ()); | |
| 598 Assert.assertEquals("415", message.getDefaultString ()); | |
| 599 Assert.assertEquals(toBytes("416"), message.getDefaultBytes()); | |
| 600 | |
| 601 Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getDefaultNestedEnu
m ()); | |
| 602 Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getDefaultForeignEnum()
); | |
| 603 Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getDefaultImportEnum()); | |
| 604 | |
| 605 Assert.assertEquals("424", message.getDefaultStringPiece()); | |
| 606 Assert.assertEquals("425", message.getDefaultCord()); | |
| 607 } | |
| 608 | |
| 609 // ------------------------------------------------------------------- | |
| 610 /** | |
| 611 * Assert (using {@code junit.framework.Assert}} that all fields of | |
| 612 * {@code message} are cleared, and that getting the fields returns their | |
| 613 * default values. | |
| 614 */ | |
| 615 public static void assertClear(TestAllTypesOrBuilder message) { | |
| 616 // hasBlah() should initially be false for all optional fields. | |
| 617 Assert.assertFalse(message.hasOptionalInt32 ()); | |
| 618 Assert.assertFalse(message.hasOptionalInt64 ()); | |
| 619 Assert.assertFalse(message.hasOptionalUint32 ()); | |
| 620 Assert.assertFalse(message.hasOptionalUint64 ()); | |
| 621 Assert.assertFalse(message.hasOptionalSint32 ()); | |
| 622 Assert.assertFalse(message.hasOptionalSint64 ()); | |
| 623 Assert.assertFalse(message.hasOptionalFixed32 ()); | |
| 624 Assert.assertFalse(message.hasOptionalFixed64 ()); | |
| 625 Assert.assertFalse(message.hasOptionalSfixed32()); | |
| 626 Assert.assertFalse(message.hasOptionalSfixed64()); | |
| 627 Assert.assertFalse(message.hasOptionalFloat ()); | |
| 628 Assert.assertFalse(message.hasOptionalDouble ()); | |
| 629 Assert.assertFalse(message.hasOptionalBool ()); | |
| 630 Assert.assertFalse(message.hasOptionalString ()); | |
| 631 Assert.assertFalse(message.hasOptionalBytes ()); | |
| 632 | |
| 633 Assert.assertFalse(message.hasOptionalGroup ()); | |
| 634 Assert.assertFalse(message.hasOptionalNestedMessage ()); | |
| 635 Assert.assertFalse(message.hasOptionalForeignMessage()); | |
| 636 Assert.assertFalse(message.hasOptionalImportMessage ()); | |
| 637 | |
| 638 Assert.assertFalse(message.hasOptionalNestedEnum ()); | |
| 639 Assert.assertFalse(message.hasOptionalForeignEnum()); | |
| 640 Assert.assertFalse(message.hasOptionalImportEnum ()); | |
| 641 | |
| 642 Assert.assertFalse(message.hasOptionalStringPiece()); | |
| 643 Assert.assertFalse(message.hasOptionalCord()); | |
| 644 | |
| 645 // Optional fields without defaults are set to zero or something like it. | |
| 646 Assert.assertEquals(0 , message.getOptionalInt32 ()); | |
| 647 Assert.assertEquals(0 , message.getOptionalInt64 ()); | |
| 648 Assert.assertEquals(0 , message.getOptionalUint32 ()); | |
| 649 Assert.assertEquals(0 , message.getOptionalUint64 ()); | |
| 650 Assert.assertEquals(0 , message.getOptionalSint32 ()); | |
| 651 Assert.assertEquals(0 , message.getOptionalSint64 ()); | |
| 652 Assert.assertEquals(0 , message.getOptionalFixed32 ()); | |
| 653 Assert.assertEquals(0 , message.getOptionalFixed64 ()); | |
| 654 Assert.assertEquals(0 , message.getOptionalSfixed32()); | |
| 655 Assert.assertEquals(0 , message.getOptionalSfixed64()); | |
| 656 Assert.assertEquals(0 , message.getOptionalFloat (), 0.0); | |
| 657 Assert.assertEquals(0 , message.getOptionalDouble (), 0.0); | |
| 658 Assert.assertEquals(false, message.getOptionalBool ()); | |
| 659 Assert.assertEquals("" , message.getOptionalString ()); | |
| 660 Assert.assertEquals(ByteString.EMPTY, message.getOptionalBytes()); | |
| 661 | |
| 662 // Embedded messages should also be clear. | |
| 663 Assert.assertFalse(message.getOptionalGroup ().hasA()); | |
| 664 Assert.assertFalse(message.getOptionalNestedMessage ().hasBb()); | |
| 665 Assert.assertFalse(message.getOptionalForeignMessage ().hasC()); | |
| 666 Assert.assertFalse(message.getOptionalImportMessage ().hasD()); | |
| 667 Assert.assertFalse(message.getOptionalPublicImportMessage().hasE()); | |
| 668 Assert.assertFalse(message.getOptionalLazyMessage ().hasBb()); | |
| 669 | |
| 670 Assert.assertEquals(0, message.getOptionalGroup ().getA()); | |
| 671 Assert.assertEquals(0, message.getOptionalNestedMessage ().getBb()); | |
| 672 Assert.assertEquals(0, message.getOptionalForeignMessage ().getC()); | |
| 673 Assert.assertEquals(0, message.getOptionalImportMessage ().getD()); | |
| 674 Assert.assertEquals(0, message.getOptionalPublicImportMessage().getE()); | |
| 675 Assert.assertEquals(0, message.getOptionalLazyMessage ().getBb()); | |
| 676 | |
| 677 // Enums without defaults are set to the first value in the enum. | |
| 678 Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getOptionalNestedEn
um ()); | |
| 679 Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getOptionalForeignEnum(
)); | |
| 680 Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getOptionalImportEnum()); | |
| 681 | |
| 682 Assert.assertEquals("", message.getOptionalStringPiece()); | |
| 683 Assert.assertEquals("", message.getOptionalCord()); | |
| 684 | |
| 685 // Repeated fields are empty. | |
| 686 Assert.assertEquals(0, message.getRepeatedInt32Count ()); | |
| 687 Assert.assertEquals(0, message.getRepeatedInt64Count ()); | |
| 688 Assert.assertEquals(0, message.getRepeatedUint32Count ()); | |
| 689 Assert.assertEquals(0, message.getRepeatedUint64Count ()); | |
| 690 Assert.assertEquals(0, message.getRepeatedSint32Count ()); | |
| 691 Assert.assertEquals(0, message.getRepeatedSint64Count ()); | |
| 692 Assert.assertEquals(0, message.getRepeatedFixed32Count ()); | |
| 693 Assert.assertEquals(0, message.getRepeatedFixed64Count ()); | |
| 694 Assert.assertEquals(0, message.getRepeatedSfixed32Count()); | |
| 695 Assert.assertEquals(0, message.getRepeatedSfixed64Count()); | |
| 696 Assert.assertEquals(0, message.getRepeatedFloatCount ()); | |
| 697 Assert.assertEquals(0, message.getRepeatedDoubleCount ()); | |
| 698 Assert.assertEquals(0, message.getRepeatedBoolCount ()); | |
| 699 Assert.assertEquals(0, message.getRepeatedStringCount ()); | |
| 700 Assert.assertEquals(0, message.getRepeatedBytesCount ()); | |
| 701 | |
| 702 Assert.assertEquals(0, message.getRepeatedGroupCount ()); | |
| 703 Assert.assertEquals(0, message.getRepeatedNestedMessageCount ()); | |
| 704 Assert.assertEquals(0, message.getRepeatedForeignMessageCount()); | |
| 705 Assert.assertEquals(0, message.getRepeatedImportMessageCount ()); | |
| 706 Assert.assertEquals(0, message.getRepeatedLazyMessageCount ()); | |
| 707 Assert.assertEquals(0, message.getRepeatedNestedEnumCount ()); | |
| 708 Assert.assertEquals(0, message.getRepeatedForeignEnumCount ()); | |
| 709 Assert.assertEquals(0, message.getRepeatedImportEnumCount ()); | |
| 710 | |
| 711 Assert.assertEquals(0, message.getRepeatedStringPieceCount()); | |
| 712 Assert.assertEquals(0, message.getRepeatedCordCount()); | |
| 713 | |
| 714 // hasBlah() should also be false for all default fields. | |
| 715 Assert.assertFalse(message.hasDefaultInt32 ()); | |
| 716 Assert.assertFalse(message.hasDefaultInt64 ()); | |
| 717 Assert.assertFalse(message.hasDefaultUint32 ()); | |
| 718 Assert.assertFalse(message.hasDefaultUint64 ()); | |
| 719 Assert.assertFalse(message.hasDefaultSint32 ()); | |
| 720 Assert.assertFalse(message.hasDefaultSint64 ()); | |
| 721 Assert.assertFalse(message.hasDefaultFixed32 ()); | |
| 722 Assert.assertFalse(message.hasDefaultFixed64 ()); | |
| 723 Assert.assertFalse(message.hasDefaultSfixed32()); | |
| 724 Assert.assertFalse(message.hasDefaultSfixed64()); | |
| 725 Assert.assertFalse(message.hasDefaultFloat ()); | |
| 726 Assert.assertFalse(message.hasDefaultDouble ()); | |
| 727 Assert.assertFalse(message.hasDefaultBool ()); | |
| 728 Assert.assertFalse(message.hasDefaultString ()); | |
| 729 Assert.assertFalse(message.hasDefaultBytes ()); | |
| 730 | |
| 731 Assert.assertFalse(message.hasDefaultNestedEnum ()); | |
| 732 Assert.assertFalse(message.hasDefaultForeignEnum()); | |
| 733 Assert.assertFalse(message.hasDefaultImportEnum ()); | |
| 734 | |
| 735 Assert.assertFalse(message.hasDefaultStringPiece()); | |
| 736 Assert.assertFalse(message.hasDefaultCord()); | |
| 737 | |
| 738 // Fields with defaults have their default values (duh). | |
| 739 Assert.assertEquals( 41 , message.getDefaultInt32 ()); | |
| 740 Assert.assertEquals( 42 , message.getDefaultInt64 ()); | |
| 741 Assert.assertEquals( 43 , message.getDefaultUint32 ()); | |
| 742 Assert.assertEquals( 44 , message.getDefaultUint64 ()); | |
| 743 Assert.assertEquals(-45 , message.getDefaultSint32 ()); | |
| 744 Assert.assertEquals( 46 , message.getDefaultSint64 ()); | |
| 745 Assert.assertEquals( 47 , message.getDefaultFixed32 ()); | |
| 746 Assert.assertEquals( 48 , message.getDefaultFixed64 ()); | |
| 747 Assert.assertEquals( 49 , message.getDefaultSfixed32()); | |
| 748 Assert.assertEquals(-50 , message.getDefaultSfixed64()); | |
| 749 Assert.assertEquals( 51.5 , message.getDefaultFloat (), 0.0); | |
| 750 Assert.assertEquals( 52e3 , message.getDefaultDouble (), 0.0); | |
| 751 Assert.assertEquals(true , message.getDefaultBool ()); | |
| 752 Assert.assertEquals("hello", message.getDefaultString ()); | |
| 753 Assert.assertEquals(toBytes("world"), message.getDefaultBytes()); | |
| 754 | |
| 755 Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getDefaultNestedEnu
m ()); | |
| 756 Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getDefaultForeignEnum()
); | |
| 757 Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getDefaultImportEnum()); | |
| 758 | |
| 759 Assert.assertEquals("abc", message.getDefaultStringPiece()); | |
| 760 Assert.assertEquals("123", message.getDefaultCord()); | |
| 761 } | |
| 762 | |
| 763 // ------------------------------------------------------------------- | |
| 764 | |
| 765 /** | |
| 766 * Assert (using {@code junit.framework.Assert}} that all fields of | |
| 767 * {@code message} are set to the values assigned by {@code setAllFields} | |
| 768 * followed by {@code modifyRepeatedFields}. | |
| 769 */ | |
| 770 public static void assertRepeatedFieldsModified( | |
| 771 TestAllTypesOrBuilder message) { | |
| 772 // ModifyRepeatedFields only sets the second repeated element of each | |
| 773 // field. In addition to verifying this, we also verify that the first | |
| 774 // element and size were *not* modified. | |
| 775 Assert.assertEquals(2, message.getRepeatedInt32Count ()); | |
| 776 Assert.assertEquals(2, message.getRepeatedInt64Count ()); | |
| 777 Assert.assertEquals(2, message.getRepeatedUint32Count ()); | |
| 778 Assert.assertEquals(2, message.getRepeatedUint64Count ()); | |
| 779 Assert.assertEquals(2, message.getRepeatedSint32Count ()); | |
| 780 Assert.assertEquals(2, message.getRepeatedSint64Count ()); | |
| 781 Assert.assertEquals(2, message.getRepeatedFixed32Count ()); | |
| 782 Assert.assertEquals(2, message.getRepeatedFixed64Count ()); | |
| 783 Assert.assertEquals(2, message.getRepeatedSfixed32Count()); | |
| 784 Assert.assertEquals(2, message.getRepeatedSfixed64Count()); | |
| 785 Assert.assertEquals(2, message.getRepeatedFloatCount ()); | |
| 786 Assert.assertEquals(2, message.getRepeatedDoubleCount ()); | |
| 787 Assert.assertEquals(2, message.getRepeatedBoolCount ()); | |
| 788 Assert.assertEquals(2, message.getRepeatedStringCount ()); | |
| 789 Assert.assertEquals(2, message.getRepeatedBytesCount ()); | |
| 790 | |
| 791 Assert.assertEquals(2, message.getRepeatedGroupCount ()); | |
| 792 Assert.assertEquals(2, message.getRepeatedNestedMessageCount ()); | |
| 793 Assert.assertEquals(2, message.getRepeatedForeignMessageCount()); | |
| 794 Assert.assertEquals(2, message.getRepeatedImportMessageCount ()); | |
| 795 Assert.assertEquals(2, message.getRepeatedLazyMessageCount ()); | |
| 796 Assert.assertEquals(2, message.getRepeatedNestedEnumCount ()); | |
| 797 Assert.assertEquals(2, message.getRepeatedForeignEnumCount ()); | |
| 798 Assert.assertEquals(2, message.getRepeatedImportEnumCount ()); | |
| 799 | |
| 800 Assert.assertEquals(2, message.getRepeatedStringPieceCount()); | |
| 801 Assert.assertEquals(2, message.getRepeatedCordCount()); | |
| 802 | |
| 803 Assert.assertEquals(201 , message.getRepeatedInt32 (0)); | |
| 804 Assert.assertEquals(202L , message.getRepeatedInt64 (0)); | |
| 805 Assert.assertEquals(203 , message.getRepeatedUint32 (0)); | |
| 806 Assert.assertEquals(204L , message.getRepeatedUint64 (0)); | |
| 807 Assert.assertEquals(205 , message.getRepeatedSint32 (0)); | |
| 808 Assert.assertEquals(206L , message.getRepeatedSint64 (0)); | |
| 809 Assert.assertEquals(207 , message.getRepeatedFixed32 (0)); | |
| 810 Assert.assertEquals(208L , message.getRepeatedFixed64 (0)); | |
| 811 Assert.assertEquals(209 , message.getRepeatedSfixed32(0)); | |
| 812 Assert.assertEquals(210L , message.getRepeatedSfixed64(0)); | |
| 813 Assert.assertEquals(211F , message.getRepeatedFloat (0)); | |
| 814 Assert.assertEquals(212D , message.getRepeatedDouble (0)); | |
| 815 Assert.assertEquals(true , message.getRepeatedBool (0)); | |
| 816 Assert.assertEquals("215", message.getRepeatedString (0)); | |
| 817 Assert.assertEquals(toBytes("216"), message.getRepeatedBytes(0)); | |
| 818 | |
| 819 Assert.assertEquals(217, message.getRepeatedGroup (0).getA()); | |
| 820 Assert.assertEquals(218, message.getRepeatedNestedMessage (0).getBb()); | |
| 821 Assert.assertEquals(219, message.getRepeatedForeignMessage(0).getC()); | |
| 822 Assert.assertEquals(220, message.getRepeatedImportMessage (0).getD()); | |
| 823 Assert.assertEquals(227, message.getRepeatedLazyMessage (0).getBb()); | |
| 824 | |
| 825 Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getRepeatedNestedEn
um (0)); | |
| 826 Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getRepeatedForeignEnum(
0)); | |
| 827 Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getRepeatedImportEnum(0))
; | |
| 828 | |
| 829 Assert.assertEquals("224", message.getRepeatedStringPiece(0)); | |
| 830 Assert.assertEquals("225", message.getRepeatedCord(0)); | |
| 831 | |
| 832 // Actually verify the second (modified) elements now. | |
| 833 Assert.assertEquals(501 , message.getRepeatedInt32 (1)); | |
| 834 Assert.assertEquals(502L , message.getRepeatedInt64 (1)); | |
| 835 Assert.assertEquals(503 , message.getRepeatedUint32 (1)); | |
| 836 Assert.assertEquals(504L , message.getRepeatedUint64 (1)); | |
| 837 Assert.assertEquals(505 , message.getRepeatedSint32 (1)); | |
| 838 Assert.assertEquals(506L , message.getRepeatedSint64 (1)); | |
| 839 Assert.assertEquals(507 , message.getRepeatedFixed32 (1)); | |
| 840 Assert.assertEquals(508L , message.getRepeatedFixed64 (1)); | |
| 841 Assert.assertEquals(509 , message.getRepeatedSfixed32(1)); | |
| 842 Assert.assertEquals(510L , message.getRepeatedSfixed64(1)); | |
| 843 Assert.assertEquals(511F , message.getRepeatedFloat (1)); | |
| 844 Assert.assertEquals(512D , message.getRepeatedDouble (1)); | |
| 845 Assert.assertEquals(true , message.getRepeatedBool (1)); | |
| 846 Assert.assertEquals("515", message.getRepeatedString (1)); | |
| 847 Assert.assertEquals(toBytes("516"), message.getRepeatedBytes(1)); | |
| 848 | |
| 849 Assert.assertEquals(517, message.getRepeatedGroup (1).getA()); | |
| 850 Assert.assertEquals(518, message.getRepeatedNestedMessage (1).getBb()); | |
| 851 Assert.assertEquals(519, message.getRepeatedForeignMessage(1).getC()); | |
| 852 Assert.assertEquals(520, message.getRepeatedImportMessage (1).getD()); | |
| 853 Assert.assertEquals(527, message.getRepeatedLazyMessage (1).getBb()); | |
| 854 | |
| 855 Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getRepeatedNestedEn
um (1)); | |
| 856 Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getRepeatedForeignEnum(
1)); | |
| 857 Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getRepeatedImportEnum(1))
; | |
| 858 | |
| 859 Assert.assertEquals("524", message.getRepeatedStringPiece(1)); | |
| 860 Assert.assertEquals("525", message.getRepeatedCord(1)); | |
| 861 } | |
| 862 | |
| 863 /** | |
| 864 * Set every field of {@code message} to a unique value. | |
| 865 */ | |
| 866 public static void setPackedFields(TestPackedTypes.Builder message) { | |
| 867 message.addPackedInt32 (601); | |
| 868 message.addPackedInt64 (602); | |
| 869 message.addPackedUint32 (603); | |
| 870 message.addPackedUint64 (604); | |
| 871 message.addPackedSint32 (605); | |
| 872 message.addPackedSint64 (606); | |
| 873 message.addPackedFixed32 (607); | |
| 874 message.addPackedFixed64 (608); | |
| 875 message.addPackedSfixed32(609); | |
| 876 message.addPackedSfixed64(610); | |
| 877 message.addPackedFloat (611); | |
| 878 message.addPackedDouble (612); | |
| 879 message.addPackedBool (true); | |
| 880 message.addPackedEnum (ForeignEnum.FOREIGN_BAR); | |
| 881 // Add a second one of each field. | |
| 882 message.addPackedInt32 (701); | |
| 883 message.addPackedInt64 (702); | |
| 884 message.addPackedUint32 (703); | |
| 885 message.addPackedUint64 (704); | |
| 886 message.addPackedSint32 (705); | |
| 887 message.addPackedSint64 (706); | |
| 888 message.addPackedFixed32 (707); | |
| 889 message.addPackedFixed64 (708); | |
| 890 message.addPackedSfixed32(709); | |
| 891 message.addPackedSfixed64(710); | |
| 892 message.addPackedFloat (711); | |
| 893 message.addPackedDouble (712); | |
| 894 message.addPackedBool (false); | |
| 895 message.addPackedEnum (ForeignEnum.FOREIGN_BAZ); | |
| 896 } | |
| 897 | |
| 898 /** | |
| 899 * Set every field of {@code message} to a unique value. Must correspond with | |
| 900 * the values applied by {@code setPackedFields}. | |
| 901 */ | |
| 902 public static void setUnpackedFields(TestUnpackedTypes.Builder message) { | |
| 903 message.addUnpackedInt32 (601); | |
| 904 message.addUnpackedInt64 (602); | |
| 905 message.addUnpackedUint32 (603); | |
| 906 message.addUnpackedUint64 (604); | |
| 907 message.addUnpackedSint32 (605); | |
| 908 message.addUnpackedSint64 (606); | |
| 909 message.addUnpackedFixed32 (607); | |
| 910 message.addUnpackedFixed64 (608); | |
| 911 message.addUnpackedSfixed32(609); | |
| 912 message.addUnpackedSfixed64(610); | |
| 913 message.addUnpackedFloat (611); | |
| 914 message.addUnpackedDouble (612); | |
| 915 message.addUnpackedBool (true); | |
| 916 message.addUnpackedEnum (ForeignEnum.FOREIGN_BAR); | |
| 917 // Add a second one of each field. | |
| 918 message.addUnpackedInt32 (701); | |
| 919 message.addUnpackedInt64 (702); | |
| 920 message.addUnpackedUint32 (703); | |
| 921 message.addUnpackedUint64 (704); | |
| 922 message.addUnpackedSint32 (705); | |
| 923 message.addUnpackedSint64 (706); | |
| 924 message.addUnpackedFixed32 (707); | |
| 925 message.addUnpackedFixed64 (708); | |
| 926 message.addUnpackedSfixed32(709); | |
| 927 message.addUnpackedSfixed64(710); | |
| 928 message.addUnpackedFloat (711); | |
| 929 message.addUnpackedDouble (712); | |
| 930 message.addUnpackedBool (false); | |
| 931 message.addUnpackedEnum (ForeignEnum.FOREIGN_BAZ); | |
| 932 } | |
| 933 | |
| 934 /** | |
| 935 * Assert (using {@code junit.framework.Assert}} that all fields of | |
| 936 * {@code message} are set to the values assigned by {@code setPackedFields}. | |
| 937 */ | |
| 938 public static void assertPackedFieldsSet(TestPackedTypes message) { | |
| 939 Assert.assertEquals(2, message.getPackedInt32Count ()); | |
| 940 Assert.assertEquals(2, message.getPackedInt64Count ()); | |
| 941 Assert.assertEquals(2, message.getPackedUint32Count ()); | |
| 942 Assert.assertEquals(2, message.getPackedUint64Count ()); | |
| 943 Assert.assertEquals(2, message.getPackedSint32Count ()); | |
| 944 Assert.assertEquals(2, message.getPackedSint64Count ()); | |
| 945 Assert.assertEquals(2, message.getPackedFixed32Count ()); | |
| 946 Assert.assertEquals(2, message.getPackedFixed64Count ()); | |
| 947 Assert.assertEquals(2, message.getPackedSfixed32Count()); | |
| 948 Assert.assertEquals(2, message.getPackedSfixed64Count()); | |
| 949 Assert.assertEquals(2, message.getPackedFloatCount ()); | |
| 950 Assert.assertEquals(2, message.getPackedDoubleCount ()); | |
| 951 Assert.assertEquals(2, message.getPackedBoolCount ()); | |
| 952 Assert.assertEquals(2, message.getPackedEnumCount ()); | |
| 953 Assert.assertEquals(601 , message.getPackedInt32 (0)); | |
| 954 Assert.assertEquals(602 , message.getPackedInt64 (0)); | |
| 955 Assert.assertEquals(603 , message.getPackedUint32 (0)); | |
| 956 Assert.assertEquals(604 , message.getPackedUint64 (0)); | |
| 957 Assert.assertEquals(605 , message.getPackedSint32 (0)); | |
| 958 Assert.assertEquals(606 , message.getPackedSint64 (0)); | |
| 959 Assert.assertEquals(607 , message.getPackedFixed32 (0)); | |
| 960 Assert.assertEquals(608 , message.getPackedFixed64 (0)); | |
| 961 Assert.assertEquals(609 , message.getPackedSfixed32(0)); | |
| 962 Assert.assertEquals(610 , message.getPackedSfixed64(0)); | |
| 963 Assert.assertEquals(611 , message.getPackedFloat (0), 0.0); | |
| 964 Assert.assertEquals(612 , message.getPackedDouble (0), 0.0); | |
| 965 Assert.assertEquals(true , message.getPackedBool (0)); | |
| 966 Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getPackedEnum(0)); | |
| 967 Assert.assertEquals(701 , message.getPackedInt32 (1)); | |
| 968 Assert.assertEquals(702 , message.getPackedInt64 (1)); | |
| 969 Assert.assertEquals(703 , message.getPackedUint32 (1)); | |
| 970 Assert.assertEquals(704 , message.getPackedUint64 (1)); | |
| 971 Assert.assertEquals(705 , message.getPackedSint32 (1)); | |
| 972 Assert.assertEquals(706 , message.getPackedSint64 (1)); | |
| 973 Assert.assertEquals(707 , message.getPackedFixed32 (1)); | |
| 974 Assert.assertEquals(708 , message.getPackedFixed64 (1)); | |
| 975 Assert.assertEquals(709 , message.getPackedSfixed32(1)); | |
| 976 Assert.assertEquals(710 , message.getPackedSfixed64(1)); | |
| 977 Assert.assertEquals(711 , message.getPackedFloat (1), 0.0); | |
| 978 Assert.assertEquals(712 , message.getPackedDouble (1), 0.0); | |
| 979 Assert.assertEquals(false, message.getPackedBool (1)); | |
| 980 Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getPackedEnum(1)); | |
| 981 } | |
| 982 | |
| 983 /** | |
| 984 * Assert (using {@code junit.framework.Assert}} that all fields of | |
| 985 * {@code message} are set to the values assigned by {@code setUnpackedFields}
. | |
| 986 */ | |
| 987 public static void assertUnpackedFieldsSet(TestUnpackedTypes message) { | |
| 988 Assert.assertEquals(2, message.getUnpackedInt32Count ()); | |
| 989 Assert.assertEquals(2, message.getUnpackedInt64Count ()); | |
| 990 Assert.assertEquals(2, message.getUnpackedUint32Count ()); | |
| 991 Assert.assertEquals(2, message.getUnpackedUint64Count ()); | |
| 992 Assert.assertEquals(2, message.getUnpackedSint32Count ()); | |
| 993 Assert.assertEquals(2, message.getUnpackedSint64Count ()); | |
| 994 Assert.assertEquals(2, message.getUnpackedFixed32Count ()); | |
| 995 Assert.assertEquals(2, message.getUnpackedFixed64Count ()); | |
| 996 Assert.assertEquals(2, message.getUnpackedSfixed32Count()); | |
| 997 Assert.assertEquals(2, message.getUnpackedSfixed64Count()); | |
| 998 Assert.assertEquals(2, message.getUnpackedFloatCount ()); | |
| 999 Assert.assertEquals(2, message.getUnpackedDoubleCount ()); | |
| 1000 Assert.assertEquals(2, message.getUnpackedBoolCount ()); | |
| 1001 Assert.assertEquals(2, message.getUnpackedEnumCount ()); | |
| 1002 Assert.assertEquals(601 , message.getUnpackedInt32 (0)); | |
| 1003 Assert.assertEquals(602 , message.getUnpackedInt64 (0)); | |
| 1004 Assert.assertEquals(603 , message.getUnpackedUint32 (0)); | |
| 1005 Assert.assertEquals(604 , message.getUnpackedUint64 (0)); | |
| 1006 Assert.assertEquals(605 , message.getUnpackedSint32 (0)); | |
| 1007 Assert.assertEquals(606 , message.getUnpackedSint64 (0)); | |
| 1008 Assert.assertEquals(607 , message.getUnpackedFixed32 (0)); | |
| 1009 Assert.assertEquals(608 , message.getUnpackedFixed64 (0)); | |
| 1010 Assert.assertEquals(609 , message.getUnpackedSfixed32(0)); | |
| 1011 Assert.assertEquals(610 , message.getUnpackedSfixed64(0)); | |
| 1012 Assert.assertEquals(611 , message.getUnpackedFloat (0), 0.0); | |
| 1013 Assert.assertEquals(612 , message.getUnpackedDouble (0), 0.0); | |
| 1014 Assert.assertEquals(true , message.getUnpackedBool (0)); | |
| 1015 Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getUnpackedEnum(0)); | |
| 1016 Assert.assertEquals(701 , message.getUnpackedInt32 (1)); | |
| 1017 Assert.assertEquals(702 , message.getUnpackedInt64 (1)); | |
| 1018 Assert.assertEquals(703 , message.getUnpackedUint32 (1)); | |
| 1019 Assert.assertEquals(704 , message.getUnpackedUint64 (1)); | |
| 1020 Assert.assertEquals(705 , message.getUnpackedSint32 (1)); | |
| 1021 Assert.assertEquals(706 , message.getUnpackedSint64 (1)); | |
| 1022 Assert.assertEquals(707 , message.getUnpackedFixed32 (1)); | |
| 1023 Assert.assertEquals(708 , message.getUnpackedFixed64 (1)); | |
| 1024 Assert.assertEquals(709 , message.getUnpackedSfixed32(1)); | |
| 1025 Assert.assertEquals(710 , message.getUnpackedSfixed64(1)); | |
| 1026 Assert.assertEquals(711 , message.getUnpackedFloat (1), 0.0); | |
| 1027 Assert.assertEquals(712 , message.getUnpackedDouble (1), 0.0); | |
| 1028 Assert.assertEquals(false, message.getUnpackedBool (1)); | |
| 1029 Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getUnpackedEnum(1)); | |
| 1030 } | |
| 1031 | |
| 1032 // =================================================================== | |
| 1033 // Like above, but for extensions | |
| 1034 | |
| 1035 // Java gets confused with things like assertEquals(int, Integer): it can't | |
| 1036 // decide whether to call assertEquals(int, int) or assertEquals(Object, | |
| 1037 // Object). So we define these methods to help it. | |
| 1038 private static void assertEqualsExactType(int a, int b) { | |
| 1039 Assert.assertEquals(a, b); | |
| 1040 } | |
| 1041 private static void assertEqualsExactType(long a, long b) { | |
| 1042 Assert.assertEquals(a, b); | |
| 1043 } | |
| 1044 private static void assertEqualsExactType(float a, float b) { | |
| 1045 Assert.assertEquals(a, b, 0.0); | |
| 1046 } | |
| 1047 private static void assertEqualsExactType(double a, double b) { | |
| 1048 Assert.assertEquals(a, b, 0.0); | |
| 1049 } | |
| 1050 private static void assertEqualsExactType(boolean a, boolean b) { | |
| 1051 Assert.assertEquals(a, b); | |
| 1052 } | |
| 1053 private static void assertEqualsExactType(String a, String b) { | |
| 1054 Assert.assertEquals(a, b); | |
| 1055 } | |
| 1056 private static void assertEqualsExactType(ByteString a, ByteString b) { | |
| 1057 Assert.assertEquals(a, b); | |
| 1058 } | |
| 1059 private static void assertEqualsExactType(TestAllTypes.NestedEnum a, | |
| 1060 TestAllTypes.NestedEnum b) { | |
| 1061 Assert.assertEquals(a, b); | |
| 1062 } | |
| 1063 private static void assertEqualsExactType(ForeignEnum a, ForeignEnum b) { | |
| 1064 Assert.assertEquals(a, b); | |
| 1065 } | |
| 1066 private static void assertEqualsExactType(ImportEnum a, ImportEnum b) { | |
| 1067 Assert.assertEquals(a, b); | |
| 1068 } | |
| 1069 /** | |
| 1070 * Get an unmodifiable {@link ExtensionRegistry} containing all the | |
| 1071 * extensions of {@code TestAllExtensions}. | |
| 1072 */ | |
| 1073 public static ExtensionRegistry getExtensionRegistry() { | |
| 1074 ExtensionRegistry registry = ExtensionRegistry.newInstance(); | |
| 1075 registerAllExtensions(registry); | |
| 1076 return registry.getUnmodifiable(); | |
| 1077 } | |
| 1078 | |
| 1079 | |
| 1080 /** | |
| 1081 * Register all of {@code TestAllExtensions}'s extensions with the | |
| 1082 * given {@link ExtensionRegistry}. | |
| 1083 */ | |
| 1084 public static void registerAllExtensions(ExtensionRegistry registry) { | |
| 1085 UnittestProto.registerAllExtensions(registry); | |
| 1086 } | |
| 1087 | |
| 1088 | |
| 1089 /** | |
| 1090 * Set every field of {@code message} to the values expected by | |
| 1091 * {@code assertAllExtensionsSet()}. | |
| 1092 */ | |
| 1093 public static void setAllExtensions(TestAllExtensions.Builder message) { | |
| 1094 message.setExtension(optionalInt32Extension , 101); | |
| 1095 message.setExtension(optionalInt64Extension , 102L); | |
| 1096 message.setExtension(optionalUint32Extension , 103); | |
| 1097 message.setExtension(optionalUint64Extension , 104L); | |
| 1098 message.setExtension(optionalSint32Extension , 105); | |
| 1099 message.setExtension(optionalSint64Extension , 106L); | |
| 1100 message.setExtension(optionalFixed32Extension , 107); | |
| 1101 message.setExtension(optionalFixed64Extension , 108L); | |
| 1102 message.setExtension(optionalSfixed32Extension, 109); | |
| 1103 message.setExtension(optionalSfixed64Extension, 110L); | |
| 1104 message.setExtension(optionalFloatExtension , 111F); | |
| 1105 message.setExtension(optionalDoubleExtension , 112D); | |
| 1106 message.setExtension(optionalBoolExtension , true); | |
| 1107 message.setExtension(optionalStringExtension , "115"); | |
| 1108 message.setExtension(optionalBytesExtension , toBytes("116")); | |
| 1109 | |
| 1110 message.setExtension(optionalGroupExtension, | |
| 1111 OptionalGroup_extension.newBuilder().setA(117).build()); | |
| 1112 message.setExtension(optionalNestedMessageExtension, | |
| 1113 TestAllTypes.NestedMessage.newBuilder().setBb(118).build()); | |
| 1114 message.setExtension(optionalForeignMessageExtension, | |
| 1115 ForeignMessage.newBuilder().setC(119).build()); | |
| 1116 message.setExtension(optionalImportMessageExtension, | |
| 1117 ImportMessage.newBuilder().setD(120).build()); | |
| 1118 message.setExtension(optionalPublicImportMessageExtension, | |
| 1119 PublicImportMessage.newBuilder().setE(126).build()); | |
| 1120 message.setExtension(optionalLazyMessageExtension, | |
| 1121 TestAllTypes.NestedMessage.newBuilder().setBb(127).build()); | |
| 1122 | |
| 1123 message.setExtension(optionalNestedEnumExtension, TestAllTypes.NestedEnum.BA
Z); | |
| 1124 message.setExtension(optionalForeignEnumExtension, ForeignEnum.FOREIGN_BAZ); | |
| 1125 message.setExtension(optionalImportEnumExtension, ImportEnum.IMPORT_BAZ); | |
| 1126 | |
| 1127 message.setExtension(optionalStringPieceExtension, "124"); | |
| 1128 message.setExtension(optionalCordExtension, "125"); | |
| 1129 | |
| 1130 // ----------------------------------------------------------------- | |
| 1131 | |
| 1132 message.addExtension(repeatedInt32Extension , 201); | |
| 1133 message.addExtension(repeatedInt64Extension , 202L); | |
| 1134 message.addExtension(repeatedUint32Extension , 203); | |
| 1135 message.addExtension(repeatedUint64Extension , 204L); | |
| 1136 message.addExtension(repeatedSint32Extension , 205); | |
| 1137 message.addExtension(repeatedSint64Extension , 206L); | |
| 1138 message.addExtension(repeatedFixed32Extension , 207); | |
| 1139 message.addExtension(repeatedFixed64Extension , 208L); | |
| 1140 message.addExtension(repeatedSfixed32Extension, 209); | |
| 1141 message.addExtension(repeatedSfixed64Extension, 210L); | |
| 1142 message.addExtension(repeatedFloatExtension , 211F); | |
| 1143 message.addExtension(repeatedDoubleExtension , 212D); | |
| 1144 message.addExtension(repeatedBoolExtension , true); | |
| 1145 message.addExtension(repeatedStringExtension , "215"); | |
| 1146 message.addExtension(repeatedBytesExtension , toBytes("216")); | |
| 1147 | |
| 1148 message.addExtension(repeatedGroupExtension, | |
| 1149 RepeatedGroup_extension.newBuilder().setA(217).build()); | |
| 1150 message.addExtension(repeatedNestedMessageExtension, | |
| 1151 TestAllTypes.NestedMessage.newBuilder().setBb(218).build()); | |
| 1152 message.addExtension(repeatedForeignMessageExtension, | |
| 1153 ForeignMessage.newBuilder().setC(219).build()); | |
| 1154 message.addExtension(repeatedImportMessageExtension, | |
| 1155 ImportMessage.newBuilder().setD(220).build()); | |
| 1156 message.addExtension(repeatedLazyMessageExtension, | |
| 1157 TestAllTypes.NestedMessage.newBuilder().setBb(227).build()); | |
| 1158 | |
| 1159 message.addExtension(repeatedNestedEnumExtension, TestAllTypes.NestedEnum.BA
R); | |
| 1160 message.addExtension(repeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAR); | |
| 1161 message.addExtension(repeatedImportEnumExtension, ImportEnum.IMPORT_BAR); | |
| 1162 | |
| 1163 message.addExtension(repeatedStringPieceExtension, "224"); | |
| 1164 message.addExtension(repeatedCordExtension, "225"); | |
| 1165 | |
| 1166 // Add a second one of each field. | |
| 1167 message.addExtension(repeatedInt32Extension , 301); | |
| 1168 message.addExtension(repeatedInt64Extension , 302L); | |
| 1169 message.addExtension(repeatedUint32Extension , 303); | |
| 1170 message.addExtension(repeatedUint64Extension , 304L); | |
| 1171 message.addExtension(repeatedSint32Extension , 305); | |
| 1172 message.addExtension(repeatedSint64Extension , 306L); | |
| 1173 message.addExtension(repeatedFixed32Extension , 307); | |
| 1174 message.addExtension(repeatedFixed64Extension , 308L); | |
| 1175 message.addExtension(repeatedSfixed32Extension, 309); | |
| 1176 message.addExtension(repeatedSfixed64Extension, 310L); | |
| 1177 message.addExtension(repeatedFloatExtension , 311F); | |
| 1178 message.addExtension(repeatedDoubleExtension , 312D); | |
| 1179 message.addExtension(repeatedBoolExtension , false); | |
| 1180 message.addExtension(repeatedStringExtension , "315"); | |
| 1181 message.addExtension(repeatedBytesExtension , toBytes("316")); | |
| 1182 | |
| 1183 message.addExtension(repeatedGroupExtension, | |
| 1184 RepeatedGroup_extension.newBuilder().setA(317).build()); | |
| 1185 message.addExtension(repeatedNestedMessageExtension, | |
| 1186 TestAllTypes.NestedMessage.newBuilder().setBb(318).build()); | |
| 1187 message.addExtension(repeatedForeignMessageExtension, | |
| 1188 ForeignMessage.newBuilder().setC(319).build()); | |
| 1189 message.addExtension(repeatedImportMessageExtension, | |
| 1190 ImportMessage.newBuilder().setD(320).build()); | |
| 1191 message.addExtension(repeatedLazyMessageExtension, | |
| 1192 TestAllTypes.NestedMessage.newBuilder().setBb(327).build()); | |
| 1193 | |
| 1194 message.addExtension(repeatedNestedEnumExtension, TestAllTypes.NestedEnum.BA
Z); | |
| 1195 message.addExtension(repeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAZ); | |
| 1196 message.addExtension(repeatedImportEnumExtension, ImportEnum.IMPORT_BAZ); | |
| 1197 | |
| 1198 message.addExtension(repeatedStringPieceExtension, "324"); | |
| 1199 message.addExtension(repeatedCordExtension, "325"); | |
| 1200 | |
| 1201 // ----------------------------------------------------------------- | |
| 1202 | |
| 1203 message.setExtension(defaultInt32Extension , 401); | |
| 1204 message.setExtension(defaultInt64Extension , 402L); | |
| 1205 message.setExtension(defaultUint32Extension , 403); | |
| 1206 message.setExtension(defaultUint64Extension , 404L); | |
| 1207 message.setExtension(defaultSint32Extension , 405); | |
| 1208 message.setExtension(defaultSint64Extension , 406L); | |
| 1209 message.setExtension(defaultFixed32Extension , 407); | |
| 1210 message.setExtension(defaultFixed64Extension , 408L); | |
| 1211 message.setExtension(defaultSfixed32Extension, 409); | |
| 1212 message.setExtension(defaultSfixed64Extension, 410L); | |
| 1213 message.setExtension(defaultFloatExtension , 411F); | |
| 1214 message.setExtension(defaultDoubleExtension , 412D); | |
| 1215 message.setExtension(defaultBoolExtension , false); | |
| 1216 message.setExtension(defaultStringExtension , "415"); | |
| 1217 message.setExtension(defaultBytesExtension , toBytes("416")); | |
| 1218 | |
| 1219 message.setExtension(defaultNestedEnumExtension, TestAllTypes.NestedEnum.FOO
); | |
| 1220 message.setExtension(defaultForeignEnumExtension, ForeignEnum.FOREIGN_FOO); | |
| 1221 message.setExtension(defaultImportEnumExtension, ImportEnum.IMPORT_FOO); | |
| 1222 | |
| 1223 message.setExtension(defaultStringPieceExtension, "424"); | |
| 1224 message.setExtension(defaultCordExtension, "425"); | |
| 1225 } | |
| 1226 | |
| 1227 // ------------------------------------------------------------------- | |
| 1228 | |
| 1229 /** | |
| 1230 * Modify the repeated extensions of {@code message} to contain the values | |
| 1231 * expected by {@code assertRepeatedExtensionsModified()}. | |
| 1232 */ | |
| 1233 public static void modifyRepeatedExtensions( | |
| 1234 TestAllExtensions.Builder message) { | |
| 1235 message.setExtension(repeatedInt32Extension , 1, 501); | |
| 1236 message.setExtension(repeatedInt64Extension , 1, 502L); | |
| 1237 message.setExtension(repeatedUint32Extension , 1, 503); | |
| 1238 message.setExtension(repeatedUint64Extension , 1, 504L); | |
| 1239 message.setExtension(repeatedSint32Extension , 1, 505); | |
| 1240 message.setExtension(repeatedSint64Extension , 1, 506L); | |
| 1241 message.setExtension(repeatedFixed32Extension , 1, 507); | |
| 1242 message.setExtension(repeatedFixed64Extension , 1, 508L); | |
| 1243 message.setExtension(repeatedSfixed32Extension, 1, 509); | |
| 1244 message.setExtension(repeatedSfixed64Extension, 1, 510L); | |
| 1245 message.setExtension(repeatedFloatExtension , 1, 511F); | |
| 1246 message.setExtension(repeatedDoubleExtension , 1, 512D); | |
| 1247 message.setExtension(repeatedBoolExtension , 1, true); | |
| 1248 message.setExtension(repeatedStringExtension , 1, "515"); | |
| 1249 message.setExtension(repeatedBytesExtension , 1, toBytes("516")); | |
| 1250 | |
| 1251 message.setExtension(repeatedGroupExtension, 1, | |
| 1252 RepeatedGroup_extension.newBuilder().setA(517).build()); | |
| 1253 message.setExtension(repeatedNestedMessageExtension, 1, | |
| 1254 TestAllTypes.NestedMessage.newBuilder().setBb(518).build()); | |
| 1255 message.setExtension(repeatedForeignMessageExtension, 1, | |
| 1256 ForeignMessage.newBuilder().setC(519).build()); | |
| 1257 message.setExtension(repeatedImportMessageExtension, 1, | |
| 1258 ImportMessage.newBuilder().setD(520).build()); | |
| 1259 message.setExtension(repeatedLazyMessageExtension, 1, | |
| 1260 TestAllTypes.NestedMessage.newBuilder().setBb(527).build()); | |
| 1261 | |
| 1262 message.setExtension(repeatedNestedEnumExtension , 1, TestAllTypes.NestedEnu
m.FOO); | |
| 1263 message.setExtension(repeatedForeignEnumExtension, 1, ForeignEnum.FOREIGN_FO
O); | |
| 1264 message.setExtension(repeatedImportEnumExtension , 1, ImportEnum.IMPORT_FOO)
; | |
| 1265 | |
| 1266 message.setExtension(repeatedStringPieceExtension, 1, "524"); | |
| 1267 message.setExtension(repeatedCordExtension, 1, "525"); | |
| 1268 } | |
| 1269 | |
| 1270 // ------------------------------------------------------------------- | |
| 1271 | |
| 1272 /** | |
| 1273 * Assert (using {@code junit.framework.Assert}} that all extensions of | |
| 1274 * {@code message} are set to the values assigned by {@code setAllExtensions}. | |
| 1275 */ | |
| 1276 public static void assertAllExtensionsSet( | |
| 1277 TestAllExtensionsOrBuilder message) { | |
| 1278 Assert.assertTrue(message.hasExtension(optionalInt32Extension )); | |
| 1279 Assert.assertTrue(message.hasExtension(optionalInt64Extension )); | |
| 1280 Assert.assertTrue(message.hasExtension(optionalUint32Extension )); | |
| 1281 Assert.assertTrue(message.hasExtension(optionalUint64Extension )); | |
| 1282 Assert.assertTrue(message.hasExtension(optionalSint32Extension )); | |
| 1283 Assert.assertTrue(message.hasExtension(optionalSint64Extension )); | |
| 1284 Assert.assertTrue(message.hasExtension(optionalFixed32Extension )); | |
| 1285 Assert.assertTrue(message.hasExtension(optionalFixed64Extension )); | |
| 1286 Assert.assertTrue(message.hasExtension(optionalSfixed32Extension)); | |
| 1287 Assert.assertTrue(message.hasExtension(optionalSfixed64Extension)); | |
| 1288 Assert.assertTrue(message.hasExtension(optionalFloatExtension )); | |
| 1289 Assert.assertTrue(message.hasExtension(optionalDoubleExtension )); | |
| 1290 Assert.assertTrue(message.hasExtension(optionalBoolExtension )); | |
| 1291 Assert.assertTrue(message.hasExtension(optionalStringExtension )); | |
| 1292 Assert.assertTrue(message.hasExtension(optionalBytesExtension )); | |
| 1293 | |
| 1294 Assert.assertTrue(message.hasExtension(optionalGroupExtension )); | |
| 1295 Assert.assertTrue(message.hasExtension(optionalNestedMessageExtension )); | |
| 1296 Assert.assertTrue(message.hasExtension(optionalForeignMessageExtension)); | |
| 1297 Assert.assertTrue(message.hasExtension(optionalImportMessageExtension )); | |
| 1298 | |
| 1299 Assert.assertTrue(message.getExtension(optionalGroupExtension ).hasA
()); | |
| 1300 Assert.assertTrue(message.getExtension(optionalNestedMessageExtension ).hasB
b()); | |
| 1301 Assert.assertTrue(message.getExtension(optionalForeignMessageExtension).hasC
()); | |
| 1302 Assert.assertTrue(message.getExtension(optionalImportMessageExtension ).hasD
()); | |
| 1303 | |
| 1304 Assert.assertTrue(message.hasExtension(optionalNestedEnumExtension )); | |
| 1305 Assert.assertTrue(message.hasExtension(optionalForeignEnumExtension)); | |
| 1306 Assert.assertTrue(message.hasExtension(optionalImportEnumExtension )); | |
| 1307 | |
| 1308 Assert.assertTrue(message.hasExtension(optionalStringPieceExtension)); | |
| 1309 Assert.assertTrue(message.hasExtension(optionalCordExtension)); | |
| 1310 | |
| 1311 assertEqualsExactType(101 , message.getExtension(optionalInt32Extension )
); | |
| 1312 assertEqualsExactType(102L , message.getExtension(optionalInt64Extension )
); | |
| 1313 assertEqualsExactType(103 , message.getExtension(optionalUint32Extension )
); | |
| 1314 assertEqualsExactType(104L , message.getExtension(optionalUint64Extension )
); | |
| 1315 assertEqualsExactType(105 , message.getExtension(optionalSint32Extension )
); | |
| 1316 assertEqualsExactType(106L , message.getExtension(optionalSint64Extension )
); | |
| 1317 assertEqualsExactType(107 , message.getExtension(optionalFixed32Extension )
); | |
| 1318 assertEqualsExactType(108L , message.getExtension(optionalFixed64Extension )
); | |
| 1319 assertEqualsExactType(109 , message.getExtension(optionalSfixed32Extension)
); | |
| 1320 assertEqualsExactType(110L , message.getExtension(optionalSfixed64Extension)
); | |
| 1321 assertEqualsExactType(111F , message.getExtension(optionalFloatExtension )
); | |
| 1322 assertEqualsExactType(112D , message.getExtension(optionalDoubleExtension )
); | |
| 1323 assertEqualsExactType(true , message.getExtension(optionalBoolExtension )
); | |
| 1324 assertEqualsExactType("115", message.getExtension(optionalStringExtension )
); | |
| 1325 assertEqualsExactType(toBytes("116"), message.getExtension(optionalBytesExte
nsion)); | |
| 1326 | |
| 1327 assertEqualsExactType(117, message.getExtension(optionalGroupExtension
).getA()); | |
| 1328 assertEqualsExactType(118, message.getExtension(optionalNestedMessageExtensi
on ).getBb()); | |
| 1329 assertEqualsExactType(119, message.getExtension(optionalForeignMessageExtens
ion ).getC()); | |
| 1330 assertEqualsExactType(120, message.getExtension(optionalImportMessageExtensi
on ).getD()); | |
| 1331 assertEqualsExactType(126, message.getExtension(optionalPublicImportMessageE
xtension).getE()); | |
| 1332 assertEqualsExactType(127, message.getExtension(optionalLazyMessageExtension
).getBb()); | |
| 1333 | |
| 1334 assertEqualsExactType(TestAllTypes.NestedEnum.BAZ, | |
| 1335 message.getExtension(optionalNestedEnumExtension)); | |
| 1336 assertEqualsExactType(ForeignEnum.FOREIGN_BAZ, | |
| 1337 message.getExtension(optionalForeignEnumExtension)); | |
| 1338 assertEqualsExactType(ImportEnum.IMPORT_BAZ, | |
| 1339 message.getExtension(optionalImportEnumExtension)); | |
| 1340 | |
| 1341 assertEqualsExactType("124", message.getExtension(optionalStringPieceExtensi
on)); | |
| 1342 assertEqualsExactType("125", message.getExtension(optionalCordExtension)); | |
| 1343 | |
| 1344 // ----------------------------------------------------------------- | |
| 1345 | |
| 1346 Assert.assertEquals(2, message.getExtensionCount(repeatedInt32Extension ))
; | |
| 1347 Assert.assertEquals(2, message.getExtensionCount(repeatedInt64Extension ))
; | |
| 1348 Assert.assertEquals(2, message.getExtensionCount(repeatedUint32Extension ))
; | |
| 1349 Assert.assertEquals(2, message.getExtensionCount(repeatedUint64Extension ))
; | |
| 1350 Assert.assertEquals(2, message.getExtensionCount(repeatedSint32Extension ))
; | |
| 1351 Assert.assertEquals(2, message.getExtensionCount(repeatedSint64Extension ))
; | |
| 1352 Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32Extension ))
; | |
| 1353 Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64Extension ))
; | |
| 1354 Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32Extension))
; | |
| 1355 Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64Extension))
; | |
| 1356 Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtension ))
; | |
| 1357 Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtension ))
; | |
| 1358 Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtension ))
; | |
| 1359 Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtension ))
; | |
| 1360 Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtension ))
; | |
| 1361 | |
| 1362 Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtension
)); | |
| 1363 Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtens
ion )); | |
| 1364 Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExten
sion)); | |
| 1365 Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtens
ion )); | |
| 1366 Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtensio
n )); | |
| 1367 Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension
)); | |
| 1368 Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtensio
n )); | |
| 1369 Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension
)); | |
| 1370 | |
| 1371 Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtensio
n)); | |
| 1372 Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtension)); | |
| 1373 | |
| 1374 assertEqualsExactType(201 , message.getExtension(repeatedInt32Extension ,
0)); | |
| 1375 assertEqualsExactType(202L , message.getExtension(repeatedInt64Extension ,
0)); | |
| 1376 assertEqualsExactType(203 , message.getExtension(repeatedUint32Extension ,
0)); | |
| 1377 assertEqualsExactType(204L , message.getExtension(repeatedUint64Extension ,
0)); | |
| 1378 assertEqualsExactType(205 , message.getExtension(repeatedSint32Extension ,
0)); | |
| 1379 assertEqualsExactType(206L , message.getExtension(repeatedSint64Extension ,
0)); | |
| 1380 assertEqualsExactType(207 , message.getExtension(repeatedFixed32Extension ,
0)); | |
| 1381 assertEqualsExactType(208L , message.getExtension(repeatedFixed64Extension ,
0)); | |
| 1382 assertEqualsExactType(209 , message.getExtension(repeatedSfixed32Extension,
0)); | |
| 1383 assertEqualsExactType(210L , message.getExtension(repeatedSfixed64Extension,
0)); | |
| 1384 assertEqualsExactType(211F , message.getExtension(repeatedFloatExtension ,
0)); | |
| 1385 assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtension ,
0)); | |
| 1386 assertEqualsExactType(true , message.getExtension(repeatedBoolExtension ,
0)); | |
| 1387 assertEqualsExactType("215", message.getExtension(repeatedStringExtension ,
0)); | |
| 1388 assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExte
nsion, 0)); | |
| 1389 | |
| 1390 assertEqualsExactType(217, message.getExtension(repeatedGroupExtension
, 0).getA()); | |
| 1391 assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtensi
on , 0).getBb()); | |
| 1392 assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtens
ion, 0).getC()); | |
| 1393 assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtensi
on , 0).getD()); | |
| 1394 assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtension
, 0).getBb()); | |
| 1395 | |
| 1396 assertEqualsExactType(TestAllTypes.NestedEnum.BAR, | |
| 1397 message.getExtension(repeatedNestedEnumExtension, 0)); | |
| 1398 assertEqualsExactType(ForeignEnum.FOREIGN_BAR, | |
| 1399 message.getExtension(repeatedForeignEnumExtension, 0)); | |
| 1400 assertEqualsExactType(ImportEnum.IMPORT_BAR, | |
| 1401 message.getExtension(repeatedImportEnumExtension, 0)); | |
| 1402 | |
| 1403 assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtensi
on, 0)); | |
| 1404 assertEqualsExactType("225", message.getExtension(repeatedCordExtension, 0))
; | |
| 1405 | |
| 1406 assertEqualsExactType(301 , message.getExtension(repeatedInt32Extension ,
1)); | |
| 1407 assertEqualsExactType(302L , message.getExtension(repeatedInt64Extension ,
1)); | |
| 1408 assertEqualsExactType(303 , message.getExtension(repeatedUint32Extension ,
1)); | |
| 1409 assertEqualsExactType(304L , message.getExtension(repeatedUint64Extension ,
1)); | |
| 1410 assertEqualsExactType(305 , message.getExtension(repeatedSint32Extension ,
1)); | |
| 1411 assertEqualsExactType(306L , message.getExtension(repeatedSint64Extension ,
1)); | |
| 1412 assertEqualsExactType(307 , message.getExtension(repeatedFixed32Extension ,
1)); | |
| 1413 assertEqualsExactType(308L , message.getExtension(repeatedFixed64Extension ,
1)); | |
| 1414 assertEqualsExactType(309 , message.getExtension(repeatedSfixed32Extension,
1)); | |
| 1415 assertEqualsExactType(310L , message.getExtension(repeatedSfixed64Extension,
1)); | |
| 1416 assertEqualsExactType(311F , message.getExtension(repeatedFloatExtension ,
1)); | |
| 1417 assertEqualsExactType(312D , message.getExtension(repeatedDoubleExtension ,
1)); | |
| 1418 assertEqualsExactType(false, message.getExtension(repeatedBoolExtension ,
1)); | |
| 1419 assertEqualsExactType("315", message.getExtension(repeatedStringExtension ,
1)); | |
| 1420 assertEqualsExactType(toBytes("316"), message.getExtension(repeatedBytesExte
nsion, 1)); | |
| 1421 | |
| 1422 assertEqualsExactType(317, message.getExtension(repeatedGroupExtension
, 1).getA()); | |
| 1423 assertEqualsExactType(318, message.getExtension(repeatedNestedMessageExtensi
on , 1).getBb()); | |
| 1424 assertEqualsExactType(319, message.getExtension(repeatedForeignMessageExtens
ion, 1).getC()); | |
| 1425 assertEqualsExactType(320, message.getExtension(repeatedImportMessageExtensi
on , 1).getD()); | |
| 1426 assertEqualsExactType(327, message.getExtension(repeatedLazyMessageExtension
, 1).getBb()); | |
| 1427 | |
| 1428 assertEqualsExactType(TestAllTypes.NestedEnum.BAZ, | |
| 1429 message.getExtension(repeatedNestedEnumExtension, 1)); | |
| 1430 assertEqualsExactType(ForeignEnum.FOREIGN_BAZ, | |
| 1431 message.getExtension(repeatedForeignEnumExtension, 1)); | |
| 1432 assertEqualsExactType(ImportEnum.IMPORT_BAZ, | |
| 1433 message.getExtension(repeatedImportEnumExtension, 1)); | |
| 1434 | |
| 1435 assertEqualsExactType("324", message.getExtension(repeatedStringPieceExtensi
on, 1)); | |
| 1436 assertEqualsExactType("325", message.getExtension(repeatedCordExtension, 1))
; | |
| 1437 | |
| 1438 // ----------------------------------------------------------------- | |
| 1439 | |
| 1440 Assert.assertTrue(message.hasExtension(defaultInt32Extension )); | |
| 1441 Assert.assertTrue(message.hasExtension(defaultInt64Extension )); | |
| 1442 Assert.assertTrue(message.hasExtension(defaultUint32Extension )); | |
| 1443 Assert.assertTrue(message.hasExtension(defaultUint64Extension )); | |
| 1444 Assert.assertTrue(message.hasExtension(defaultSint32Extension )); | |
| 1445 Assert.assertTrue(message.hasExtension(defaultSint64Extension )); | |
| 1446 Assert.assertTrue(message.hasExtension(defaultFixed32Extension )); | |
| 1447 Assert.assertTrue(message.hasExtension(defaultFixed64Extension )); | |
| 1448 Assert.assertTrue(message.hasExtension(defaultSfixed32Extension)); | |
| 1449 Assert.assertTrue(message.hasExtension(defaultSfixed64Extension)); | |
| 1450 Assert.assertTrue(message.hasExtension(defaultFloatExtension )); | |
| 1451 Assert.assertTrue(message.hasExtension(defaultDoubleExtension )); | |
| 1452 Assert.assertTrue(message.hasExtension(defaultBoolExtension )); | |
| 1453 Assert.assertTrue(message.hasExtension(defaultStringExtension )); | |
| 1454 Assert.assertTrue(message.hasExtension(defaultBytesExtension )); | |
| 1455 | |
| 1456 Assert.assertTrue(message.hasExtension(defaultNestedEnumExtension )); | |
| 1457 Assert.assertTrue(message.hasExtension(defaultForeignEnumExtension)); | |
| 1458 Assert.assertTrue(message.hasExtension(defaultImportEnumExtension )); | |
| 1459 | |
| 1460 Assert.assertTrue(message.hasExtension(defaultStringPieceExtension)); | |
| 1461 Assert.assertTrue(message.hasExtension(defaultCordExtension)); | |
| 1462 | |
| 1463 assertEqualsExactType(401 , message.getExtension(defaultInt32Extension ))
; | |
| 1464 assertEqualsExactType(402L , message.getExtension(defaultInt64Extension ))
; | |
| 1465 assertEqualsExactType(403 , message.getExtension(defaultUint32Extension ))
; | |
| 1466 assertEqualsExactType(404L , message.getExtension(defaultUint64Extension ))
; | |
| 1467 assertEqualsExactType(405 , message.getExtension(defaultSint32Extension ))
; | |
| 1468 assertEqualsExactType(406L , message.getExtension(defaultSint64Extension ))
; | |
| 1469 assertEqualsExactType(407 , message.getExtension(defaultFixed32Extension ))
; | |
| 1470 assertEqualsExactType(408L , message.getExtension(defaultFixed64Extension ))
; | |
| 1471 assertEqualsExactType(409 , message.getExtension(defaultSfixed32Extension))
; | |
| 1472 assertEqualsExactType(410L , message.getExtension(defaultSfixed64Extension))
; | |
| 1473 assertEqualsExactType(411F , message.getExtension(defaultFloatExtension ))
; | |
| 1474 assertEqualsExactType(412D , message.getExtension(defaultDoubleExtension ))
; | |
| 1475 assertEqualsExactType(false, message.getExtension(defaultBoolExtension ))
; | |
| 1476 assertEqualsExactType("415", message.getExtension(defaultStringExtension ))
; | |
| 1477 assertEqualsExactType(toBytes("416"), message.getExtension(defaultBytesExten
sion)); | |
| 1478 | |
| 1479 assertEqualsExactType(TestAllTypes.NestedEnum.FOO, | |
| 1480 message.getExtension(defaultNestedEnumExtension )); | |
| 1481 assertEqualsExactType(ForeignEnum.FOREIGN_FOO, | |
| 1482 message.getExtension(defaultForeignEnumExtension)); | |
| 1483 assertEqualsExactType(ImportEnum.IMPORT_FOO, | |
| 1484 message.getExtension(defaultImportEnumExtension)); | |
| 1485 | |
| 1486 assertEqualsExactType("424", message.getExtension(defaultStringPieceExtensio
n)); | |
| 1487 assertEqualsExactType("425", message.getExtension(defaultCordExtension)); | |
| 1488 } | |
| 1489 | |
| 1490 // ------------------------------------------------------------------- | |
| 1491 | |
| 1492 /** | |
| 1493 * Assert (using {@code junit.framework.Assert}} that all extensions of | |
| 1494 * {@code message} are cleared, and that getting the extensions returns their | |
| 1495 * default values. | |
| 1496 */ | |
| 1497 public static void assertExtensionsClear(TestAllExtensionsOrBuilder message) { | |
| 1498 // hasBlah() should initially be false for all optional fields. | |
| 1499 Assert.assertFalse(message.hasExtension(optionalInt32Extension )); | |
| 1500 Assert.assertFalse(message.hasExtension(optionalInt64Extension )); | |
| 1501 Assert.assertFalse(message.hasExtension(optionalUint32Extension )); | |
| 1502 Assert.assertFalse(message.hasExtension(optionalUint64Extension )); | |
| 1503 Assert.assertFalse(message.hasExtension(optionalSint32Extension )); | |
| 1504 Assert.assertFalse(message.hasExtension(optionalSint64Extension )); | |
| 1505 Assert.assertFalse(message.hasExtension(optionalFixed32Extension )); | |
| 1506 Assert.assertFalse(message.hasExtension(optionalFixed64Extension )); | |
| 1507 Assert.assertFalse(message.hasExtension(optionalSfixed32Extension)); | |
| 1508 Assert.assertFalse(message.hasExtension(optionalSfixed64Extension)); | |
| 1509 Assert.assertFalse(message.hasExtension(optionalFloatExtension )); | |
| 1510 Assert.assertFalse(message.hasExtension(optionalDoubleExtension )); | |
| 1511 Assert.assertFalse(message.hasExtension(optionalBoolExtension )); | |
| 1512 Assert.assertFalse(message.hasExtension(optionalStringExtension )); | |
| 1513 Assert.assertFalse(message.hasExtension(optionalBytesExtension )); | |
| 1514 | |
| 1515 Assert.assertFalse(message.hasExtension(optionalGroupExtension )); | |
| 1516 Assert.assertFalse(message.hasExtension(optionalNestedMessageExtension )); | |
| 1517 Assert.assertFalse(message.hasExtension(optionalForeignMessageExtension)); | |
| 1518 Assert.assertFalse(message.hasExtension(optionalImportMessageExtension )); | |
| 1519 | |
| 1520 Assert.assertFalse(message.hasExtension(optionalNestedEnumExtension )); | |
| 1521 Assert.assertFalse(message.hasExtension(optionalForeignEnumExtension)); | |
| 1522 Assert.assertFalse(message.hasExtension(optionalImportEnumExtension )); | |
| 1523 | |
| 1524 Assert.assertFalse(message.hasExtension(optionalStringPieceExtension)); | |
| 1525 Assert.assertFalse(message.hasExtension(optionalCordExtension)); | |
| 1526 | |
| 1527 // Optional fields without defaults are set to zero or something like it. | |
| 1528 assertEqualsExactType(0 , message.getExtension(optionalInt32Extension )
); | |
| 1529 assertEqualsExactType(0L , message.getExtension(optionalInt64Extension )
); | |
| 1530 assertEqualsExactType(0 , message.getExtension(optionalUint32Extension )
); | |
| 1531 assertEqualsExactType(0L , message.getExtension(optionalUint64Extension )
); | |
| 1532 assertEqualsExactType(0 , message.getExtension(optionalSint32Extension )
); | |
| 1533 assertEqualsExactType(0L , message.getExtension(optionalSint64Extension )
); | |
| 1534 assertEqualsExactType(0 , message.getExtension(optionalFixed32Extension )
); | |
| 1535 assertEqualsExactType(0L , message.getExtension(optionalFixed64Extension )
); | |
| 1536 assertEqualsExactType(0 , message.getExtension(optionalSfixed32Extension)
); | |
| 1537 assertEqualsExactType(0L , message.getExtension(optionalSfixed64Extension)
); | |
| 1538 assertEqualsExactType(0F , message.getExtension(optionalFloatExtension )
); | |
| 1539 assertEqualsExactType(0D , message.getExtension(optionalDoubleExtension )
); | |
| 1540 assertEqualsExactType(false, message.getExtension(optionalBoolExtension )
); | |
| 1541 assertEqualsExactType("" , message.getExtension(optionalStringExtension )
); | |
| 1542 assertEqualsExactType(ByteString.EMPTY, message.getExtension(optionalBytesEx
tension)); | |
| 1543 | |
| 1544 // Embedded messages should also be clear. | |
| 1545 Assert.assertFalse(message.getExtension(optionalGroupExtension ).has
A()); | |
| 1546 Assert.assertFalse(message.getExtension(optionalNestedMessageExtension ).has
Bb()); | |
| 1547 Assert.assertFalse(message.getExtension(optionalForeignMessageExtension).has
C()); | |
| 1548 Assert.assertFalse(message.getExtension(optionalImportMessageExtension ).has
D()); | |
| 1549 | |
| 1550 assertEqualsExactType(0, message.getExtension(optionalGroupExtension
).getA()); | |
| 1551 assertEqualsExactType(0, message.getExtension(optionalNestedMessageExtension
).getBb()); | |
| 1552 assertEqualsExactType(0, message.getExtension(optionalForeignMessageExtensio
n).getC()); | |
| 1553 assertEqualsExactType(0, message.getExtension(optionalImportMessageExtension
).getD()); | |
| 1554 | |
| 1555 // Enums without defaults are set to the first value in the enum. | |
| 1556 assertEqualsExactType(TestAllTypes.NestedEnum.FOO, | |
| 1557 message.getExtension(optionalNestedEnumExtension )); | |
| 1558 assertEqualsExactType(ForeignEnum.FOREIGN_FOO, | |
| 1559 message.getExtension(optionalForeignEnumExtension)); | |
| 1560 assertEqualsExactType(ImportEnum.IMPORT_FOO, | |
| 1561 message.getExtension(optionalImportEnumExtension)); | |
| 1562 | |
| 1563 assertEqualsExactType("", message.getExtension(optionalStringPieceExtension)
); | |
| 1564 assertEqualsExactType("", message.getExtension(optionalCordExtension)); | |
| 1565 | |
| 1566 // Repeated fields are empty. | |
| 1567 Assert.assertEquals(0, message.getExtensionCount(repeatedInt32Extension ))
; | |
| 1568 Assert.assertEquals(0, message.getExtensionCount(repeatedInt64Extension ))
; | |
| 1569 Assert.assertEquals(0, message.getExtensionCount(repeatedUint32Extension ))
; | |
| 1570 Assert.assertEquals(0, message.getExtensionCount(repeatedUint64Extension ))
; | |
| 1571 Assert.assertEquals(0, message.getExtensionCount(repeatedSint32Extension ))
; | |
| 1572 Assert.assertEquals(0, message.getExtensionCount(repeatedSint64Extension ))
; | |
| 1573 Assert.assertEquals(0, message.getExtensionCount(repeatedFixed32Extension ))
; | |
| 1574 Assert.assertEquals(0, message.getExtensionCount(repeatedFixed64Extension ))
; | |
| 1575 Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed32Extension))
; | |
| 1576 Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed64Extension))
; | |
| 1577 Assert.assertEquals(0, message.getExtensionCount(repeatedFloatExtension ))
; | |
| 1578 Assert.assertEquals(0, message.getExtensionCount(repeatedDoubleExtension ))
; | |
| 1579 Assert.assertEquals(0, message.getExtensionCount(repeatedBoolExtension ))
; | |
| 1580 Assert.assertEquals(0, message.getExtensionCount(repeatedStringExtension ))
; | |
| 1581 Assert.assertEquals(0, message.getExtensionCount(repeatedBytesExtension ))
; | |
| 1582 | |
| 1583 Assert.assertEquals(0, message.getExtensionCount(repeatedGroupExtension
)); | |
| 1584 Assert.assertEquals(0, message.getExtensionCount(repeatedNestedMessageExtens
ion )); | |
| 1585 Assert.assertEquals(0, message.getExtensionCount(repeatedForeignMessageExten
sion)); | |
| 1586 Assert.assertEquals(0, message.getExtensionCount(repeatedImportMessageExtens
ion )); | |
| 1587 Assert.assertEquals(0, message.getExtensionCount(repeatedLazyMessageExtensio
n )); | |
| 1588 Assert.assertEquals(0, message.getExtensionCount(repeatedNestedEnumExtension
)); | |
| 1589 Assert.assertEquals(0, message.getExtensionCount(repeatedForeignEnumExtensio
n )); | |
| 1590 Assert.assertEquals(0, message.getExtensionCount(repeatedImportEnumExtension
)); | |
| 1591 | |
| 1592 Assert.assertEquals(0, message.getExtensionCount(repeatedStringPieceExtensio
n)); | |
| 1593 Assert.assertEquals(0, message.getExtensionCount(repeatedCordExtension)); | |
| 1594 | |
| 1595 // Repeated fields are empty via getExtension().size(). | |
| 1596 Assert.assertEquals(0, message.getExtension(repeatedInt32Extension ).size(
)); | |
| 1597 Assert.assertEquals(0, message.getExtension(repeatedInt64Extension ).size(
)); | |
| 1598 Assert.assertEquals(0, message.getExtension(repeatedUint32Extension ).size(
)); | |
| 1599 Assert.assertEquals(0, message.getExtension(repeatedUint64Extension ).size(
)); | |
| 1600 Assert.assertEquals(0, message.getExtension(repeatedSint32Extension ).size(
)); | |
| 1601 Assert.assertEquals(0, message.getExtension(repeatedSint64Extension ).size(
)); | |
| 1602 Assert.assertEquals(0, message.getExtension(repeatedFixed32Extension ).size(
)); | |
| 1603 Assert.assertEquals(0, message.getExtension(repeatedFixed64Extension ).size(
)); | |
| 1604 Assert.assertEquals(0, message.getExtension(repeatedSfixed32Extension).size(
)); | |
| 1605 Assert.assertEquals(0, message.getExtension(repeatedSfixed64Extension).size(
)); | |
| 1606 Assert.assertEquals(0, message.getExtension(repeatedFloatExtension ).size(
)); | |
| 1607 Assert.assertEquals(0, message.getExtension(repeatedDoubleExtension ).size(
)); | |
| 1608 Assert.assertEquals(0, message.getExtension(repeatedBoolExtension ).size(
)); | |
| 1609 Assert.assertEquals(0, message.getExtension(repeatedStringExtension ).size(
)); | |
| 1610 Assert.assertEquals(0, message.getExtension(repeatedBytesExtension ).size(
)); | |
| 1611 | |
| 1612 Assert.assertEquals(0, message.getExtension(repeatedGroupExtension )
.size()); | |
| 1613 Assert.assertEquals(0, message.getExtension(repeatedNestedMessageExtension )
.size()); | |
| 1614 Assert.assertEquals(0, message.getExtension(repeatedForeignMessageExtension)
.size()); | |
| 1615 Assert.assertEquals(0, message.getExtension(repeatedImportMessageExtension )
.size()); | |
| 1616 Assert.assertEquals(0, message.getExtension(repeatedLazyMessageExtension )
.size()); | |
| 1617 Assert.assertEquals(0, message.getExtension(repeatedNestedEnumExtension )
.size()); | |
| 1618 Assert.assertEquals(0, message.getExtension(repeatedForeignEnumExtension )
.size()); | |
| 1619 Assert.assertEquals(0, message.getExtension(repeatedImportEnumExtension )
.size()); | |
| 1620 | |
| 1621 Assert.assertEquals(0, message.getExtension(repeatedStringPieceExtension).si
ze()); | |
| 1622 Assert.assertEquals(0, message.getExtension(repeatedCordExtension).size()); | |
| 1623 | |
| 1624 // hasBlah() should also be false for all default fields. | |
| 1625 Assert.assertFalse(message.hasExtension(defaultInt32Extension )); | |
| 1626 Assert.assertFalse(message.hasExtension(defaultInt64Extension )); | |
| 1627 Assert.assertFalse(message.hasExtension(defaultUint32Extension )); | |
| 1628 Assert.assertFalse(message.hasExtension(defaultUint64Extension )); | |
| 1629 Assert.assertFalse(message.hasExtension(defaultSint32Extension )); | |
| 1630 Assert.assertFalse(message.hasExtension(defaultSint64Extension )); | |
| 1631 Assert.assertFalse(message.hasExtension(defaultFixed32Extension )); | |
| 1632 Assert.assertFalse(message.hasExtension(defaultFixed64Extension )); | |
| 1633 Assert.assertFalse(message.hasExtension(defaultSfixed32Extension)); | |
| 1634 Assert.assertFalse(message.hasExtension(defaultSfixed64Extension)); | |
| 1635 Assert.assertFalse(message.hasExtension(defaultFloatExtension )); | |
| 1636 Assert.assertFalse(message.hasExtension(defaultDoubleExtension )); | |
| 1637 Assert.assertFalse(message.hasExtension(defaultBoolExtension )); | |
| 1638 Assert.assertFalse(message.hasExtension(defaultStringExtension )); | |
| 1639 Assert.assertFalse(message.hasExtension(defaultBytesExtension )); | |
| 1640 | |
| 1641 Assert.assertFalse(message.hasExtension(defaultNestedEnumExtension )); | |
| 1642 Assert.assertFalse(message.hasExtension(defaultForeignEnumExtension)); | |
| 1643 Assert.assertFalse(message.hasExtension(defaultImportEnumExtension )); | |
| 1644 | |
| 1645 Assert.assertFalse(message.hasExtension(defaultStringPieceExtension)); | |
| 1646 Assert.assertFalse(message.hasExtension(defaultCordExtension)); | |
| 1647 | |
| 1648 // Fields with defaults have their default values (duh). | |
| 1649 assertEqualsExactType( 41 , message.getExtension(defaultInt32Extension
)); | |
| 1650 assertEqualsExactType( 42L , message.getExtension(defaultInt64Extension
)); | |
| 1651 assertEqualsExactType( 43 , message.getExtension(defaultUint32Extension
)); | |
| 1652 assertEqualsExactType( 44L , message.getExtension(defaultUint64Extension
)); | |
| 1653 assertEqualsExactType(-45 , message.getExtension(defaultSint32Extension
)); | |
| 1654 assertEqualsExactType( 46L , message.getExtension(defaultSint64Extension
)); | |
| 1655 assertEqualsExactType( 47 , message.getExtension(defaultFixed32Extension
)); | |
| 1656 assertEqualsExactType( 48L , message.getExtension(defaultFixed64Extension
)); | |
| 1657 assertEqualsExactType( 49 , message.getExtension(defaultSfixed32Extension
)); | |
| 1658 assertEqualsExactType(-50L , message.getExtension(defaultSfixed64Extension
)); | |
| 1659 assertEqualsExactType( 51.5F , message.getExtension(defaultFloatExtension
)); | |
| 1660 assertEqualsExactType( 52e3D , message.getExtension(defaultDoubleExtension
)); | |
| 1661 assertEqualsExactType(true , message.getExtension(defaultBoolExtension
)); | |
| 1662 assertEqualsExactType("hello", message.getExtension(defaultStringExtension
)); | |
| 1663 assertEqualsExactType(toBytes("world"), message.getExtension(defaultBytesExt
ension)); | |
| 1664 | |
| 1665 assertEqualsExactType(TestAllTypes.NestedEnum.BAR, | |
| 1666 message.getExtension(defaultNestedEnumExtension )); | |
| 1667 assertEqualsExactType(ForeignEnum.FOREIGN_BAR, | |
| 1668 message.getExtension(defaultForeignEnumExtension)); | |
| 1669 assertEqualsExactType(ImportEnum.IMPORT_BAR, | |
| 1670 message.getExtension(defaultImportEnumExtension)); | |
| 1671 | |
| 1672 assertEqualsExactType("abc", message.getExtension(defaultStringPieceExtensio
n)); | |
| 1673 assertEqualsExactType("123", message.getExtension(defaultCordExtension)); | |
| 1674 } | |
| 1675 | |
| 1676 // ------------------------------------------------------------------- | |
| 1677 | |
| 1678 /** | |
| 1679 * Assert (using {@code junit.framework.Assert}} that all extensions of | |
| 1680 * {@code message} are set to the values assigned by {@code setAllExtensions} | |
| 1681 * followed by {@code modifyRepeatedExtensions}. | |
| 1682 */ | |
| 1683 public static void assertRepeatedExtensionsModified( | |
| 1684 TestAllExtensionsOrBuilder message) { | |
| 1685 // ModifyRepeatedFields only sets the second repeated element of each | |
| 1686 // field. In addition to verifying this, we also verify that the first | |
| 1687 // element and size were *not* modified. | |
| 1688 Assert.assertEquals(2, message.getExtensionCount(repeatedInt32Extension ))
; | |
| 1689 Assert.assertEquals(2, message.getExtensionCount(repeatedInt64Extension ))
; | |
| 1690 Assert.assertEquals(2, message.getExtensionCount(repeatedUint32Extension ))
; | |
| 1691 Assert.assertEquals(2, message.getExtensionCount(repeatedUint64Extension ))
; | |
| 1692 Assert.assertEquals(2, message.getExtensionCount(repeatedSint32Extension ))
; | |
| 1693 Assert.assertEquals(2, message.getExtensionCount(repeatedSint64Extension ))
; | |
| 1694 Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32Extension ))
; | |
| 1695 Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64Extension ))
; | |
| 1696 Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32Extension))
; | |
| 1697 Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64Extension))
; | |
| 1698 Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtension ))
; | |
| 1699 Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtension ))
; | |
| 1700 Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtension ))
; | |
| 1701 Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtension ))
; | |
| 1702 Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtension ))
; | |
| 1703 | |
| 1704 Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtension
)); | |
| 1705 Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtens
ion )); | |
| 1706 Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExten
sion)); | |
| 1707 Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtens
ion )); | |
| 1708 Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtensio
n )); | |
| 1709 Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension
)); | |
| 1710 Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtensio
n )); | |
| 1711 Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension
)); | |
| 1712 | |
| 1713 Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtensio
n)); | |
| 1714 Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtension)); | |
| 1715 | |
| 1716 assertEqualsExactType(201 , message.getExtension(repeatedInt32Extension ,
0)); | |
| 1717 assertEqualsExactType(202L , message.getExtension(repeatedInt64Extension ,
0)); | |
| 1718 assertEqualsExactType(203 , message.getExtension(repeatedUint32Extension ,
0)); | |
| 1719 assertEqualsExactType(204L , message.getExtension(repeatedUint64Extension ,
0)); | |
| 1720 assertEqualsExactType(205 , message.getExtension(repeatedSint32Extension ,
0)); | |
| 1721 assertEqualsExactType(206L , message.getExtension(repeatedSint64Extension ,
0)); | |
| 1722 assertEqualsExactType(207 , message.getExtension(repeatedFixed32Extension ,
0)); | |
| 1723 assertEqualsExactType(208L , message.getExtension(repeatedFixed64Extension ,
0)); | |
| 1724 assertEqualsExactType(209 , message.getExtension(repeatedSfixed32Extension,
0)); | |
| 1725 assertEqualsExactType(210L , message.getExtension(repeatedSfixed64Extension,
0)); | |
| 1726 assertEqualsExactType(211F , message.getExtension(repeatedFloatExtension ,
0)); | |
| 1727 assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtension ,
0)); | |
| 1728 assertEqualsExactType(true , message.getExtension(repeatedBoolExtension ,
0)); | |
| 1729 assertEqualsExactType("215", message.getExtension(repeatedStringExtension ,
0)); | |
| 1730 assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExte
nsion, 0)); | |
| 1731 | |
| 1732 assertEqualsExactType(217, message.getExtension(repeatedGroupExtension
, 0).getA()); | |
| 1733 assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtensi
on , 0).getBb()); | |
| 1734 assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtens
ion, 0).getC()); | |
| 1735 assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtensi
on , 0).getD()); | |
| 1736 assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtension
, 0).getBb()); | |
| 1737 | |
| 1738 assertEqualsExactType(TestAllTypes.NestedEnum.BAR, | |
| 1739 message.getExtension(repeatedNestedEnumExtension, 0)); | |
| 1740 assertEqualsExactType(ForeignEnum.FOREIGN_BAR, | |
| 1741 message.getExtension(repeatedForeignEnumExtension, 0)); | |
| 1742 assertEqualsExactType(ImportEnum.IMPORT_BAR, | |
| 1743 message.getExtension(repeatedImportEnumExtension, 0)); | |
| 1744 | |
| 1745 assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtensi
on, 0)); | |
| 1746 assertEqualsExactType("225", message.getExtension(repeatedCordExtension, 0))
; | |
| 1747 | |
| 1748 // Actually verify the second (modified) elements now. | |
| 1749 assertEqualsExactType(501 , message.getExtension(repeatedInt32Extension ,
1)); | |
| 1750 assertEqualsExactType(502L , message.getExtension(repeatedInt64Extension ,
1)); | |
| 1751 assertEqualsExactType(503 , message.getExtension(repeatedUint32Extension ,
1)); | |
| 1752 assertEqualsExactType(504L , message.getExtension(repeatedUint64Extension ,
1)); | |
| 1753 assertEqualsExactType(505 , message.getExtension(repeatedSint32Extension ,
1)); | |
| 1754 assertEqualsExactType(506L , message.getExtension(repeatedSint64Extension ,
1)); | |
| 1755 assertEqualsExactType(507 , message.getExtension(repeatedFixed32Extension ,
1)); | |
| 1756 assertEqualsExactType(508L , message.getExtension(repeatedFixed64Extension ,
1)); | |
| 1757 assertEqualsExactType(509 , message.getExtension(repeatedSfixed32Extension,
1)); | |
| 1758 assertEqualsExactType(510L , message.getExtension(repeatedSfixed64Extension,
1)); | |
| 1759 assertEqualsExactType(511F , message.getExtension(repeatedFloatExtension ,
1)); | |
| 1760 assertEqualsExactType(512D , message.getExtension(repeatedDoubleExtension ,
1)); | |
| 1761 assertEqualsExactType(true , message.getExtension(repeatedBoolExtension ,
1)); | |
| 1762 assertEqualsExactType("515", message.getExtension(repeatedStringExtension ,
1)); | |
| 1763 assertEqualsExactType(toBytes("516"), message.getExtension(repeatedBytesExte
nsion, 1)); | |
| 1764 | |
| 1765 assertEqualsExactType(517, message.getExtension(repeatedGroupExtension
, 1).getA()); | |
| 1766 assertEqualsExactType(518, message.getExtension(repeatedNestedMessageExtensi
on , 1).getBb()); | |
| 1767 assertEqualsExactType(519, message.getExtension(repeatedForeignMessageExtens
ion, 1).getC()); | |
| 1768 assertEqualsExactType(520, message.getExtension(repeatedImportMessageExtensi
on , 1).getD()); | |
| 1769 assertEqualsExactType(527, message.getExtension(repeatedLazyMessageExtension
, 1).getBb()); | |
| 1770 | |
| 1771 assertEqualsExactType(TestAllTypes.NestedEnum.FOO, | |
| 1772 message.getExtension(repeatedNestedEnumExtension, 1)); | |
| 1773 assertEqualsExactType(ForeignEnum.FOREIGN_FOO, | |
| 1774 message.getExtension(repeatedForeignEnumExtension, 1)); | |
| 1775 assertEqualsExactType(ImportEnum.IMPORT_FOO, | |
| 1776 message.getExtension(repeatedImportEnumExtension, 1)); | |
| 1777 | |
| 1778 assertEqualsExactType("524", message.getExtension(repeatedStringPieceExtensi
on, 1)); | |
| 1779 assertEqualsExactType("525", message.getExtension(repeatedCordExtension, 1))
; | |
| 1780 } | |
| 1781 | |
| 1782 public static void setPackedExtensions(TestPackedExtensions.Builder message) { | |
| 1783 message.addExtension(packedInt32Extension , 601); | |
| 1784 message.addExtension(packedInt64Extension , 602L); | |
| 1785 message.addExtension(packedUint32Extension , 603); | |
| 1786 message.addExtension(packedUint64Extension , 604L); | |
| 1787 message.addExtension(packedSint32Extension , 605); | |
| 1788 message.addExtension(packedSint64Extension , 606L); | |
| 1789 message.addExtension(packedFixed32Extension , 607); | |
| 1790 message.addExtension(packedFixed64Extension , 608L); | |
| 1791 message.addExtension(packedSfixed32Extension, 609); | |
| 1792 message.addExtension(packedSfixed64Extension, 610L); | |
| 1793 message.addExtension(packedFloatExtension , 611F); | |
| 1794 message.addExtension(packedDoubleExtension , 612D); | |
| 1795 message.addExtension(packedBoolExtension , true); | |
| 1796 message.addExtension(packedEnumExtension, ForeignEnum.FOREIGN_BAR); | |
| 1797 // Add a second one of each field. | |
| 1798 message.addExtension(packedInt32Extension , 701); | |
| 1799 message.addExtension(packedInt64Extension , 702L); | |
| 1800 message.addExtension(packedUint32Extension , 703); | |
| 1801 message.addExtension(packedUint64Extension , 704L); | |
| 1802 message.addExtension(packedSint32Extension , 705); | |
| 1803 message.addExtension(packedSint64Extension , 706L); | |
| 1804 message.addExtension(packedFixed32Extension , 707); | |
| 1805 message.addExtension(packedFixed64Extension , 708L); | |
| 1806 message.addExtension(packedSfixed32Extension, 709); | |
| 1807 message.addExtension(packedSfixed64Extension, 710L); | |
| 1808 message.addExtension(packedFloatExtension , 711F); | |
| 1809 message.addExtension(packedDoubleExtension , 712D); | |
| 1810 message.addExtension(packedBoolExtension , false); | |
| 1811 message.addExtension(packedEnumExtension, ForeignEnum.FOREIGN_BAZ); | |
| 1812 } | |
| 1813 | |
| 1814 public static void assertPackedExtensionsSet(TestPackedExtensions message) { | |
| 1815 Assert.assertEquals(2, message.getExtensionCount(packedInt32Extension )); | |
| 1816 Assert.assertEquals(2, message.getExtensionCount(packedInt64Extension )); | |
| 1817 Assert.assertEquals(2, message.getExtensionCount(packedUint32Extension )); | |
| 1818 Assert.assertEquals(2, message.getExtensionCount(packedUint64Extension )); | |
| 1819 Assert.assertEquals(2, message.getExtensionCount(packedSint32Extension )); | |
| 1820 Assert.assertEquals(2, message.getExtensionCount(packedSint64Extension )); | |
| 1821 Assert.assertEquals(2, message.getExtensionCount(packedFixed32Extension )); | |
| 1822 Assert.assertEquals(2, message.getExtensionCount(packedFixed64Extension )); | |
| 1823 Assert.assertEquals(2, message.getExtensionCount(packedSfixed32Extension)); | |
| 1824 Assert.assertEquals(2, message.getExtensionCount(packedSfixed64Extension)); | |
| 1825 Assert.assertEquals(2, message.getExtensionCount(packedFloatExtension )); | |
| 1826 Assert.assertEquals(2, message.getExtensionCount(packedDoubleExtension )); | |
| 1827 Assert.assertEquals(2, message.getExtensionCount(packedBoolExtension )); | |
| 1828 Assert.assertEquals(2, message.getExtensionCount(packedEnumExtension)); | |
| 1829 assertEqualsExactType(601 , message.getExtension(packedInt32Extension , 0
)); | |
| 1830 assertEqualsExactType(602L , message.getExtension(packedInt64Extension , 0
)); | |
| 1831 assertEqualsExactType(603 , message.getExtension(packedUint32Extension , 0
)); | |
| 1832 assertEqualsExactType(604L , message.getExtension(packedUint64Extension , 0
)); | |
| 1833 assertEqualsExactType(605 , message.getExtension(packedSint32Extension , 0
)); | |
| 1834 assertEqualsExactType(606L , message.getExtension(packedSint64Extension , 0
)); | |
| 1835 assertEqualsExactType(607 , message.getExtension(packedFixed32Extension , 0
)); | |
| 1836 assertEqualsExactType(608L , message.getExtension(packedFixed64Extension , 0
)); | |
| 1837 assertEqualsExactType(609 , message.getExtension(packedSfixed32Extension, 0
)); | |
| 1838 assertEqualsExactType(610L , message.getExtension(packedSfixed64Extension, 0
)); | |
| 1839 assertEqualsExactType(611F , message.getExtension(packedFloatExtension , 0
)); | |
| 1840 assertEqualsExactType(612D , message.getExtension(packedDoubleExtension , 0
)); | |
| 1841 assertEqualsExactType(true , message.getExtension(packedBoolExtension , 0
)); | |
| 1842 assertEqualsExactType(ForeignEnum.FOREIGN_BAR, | |
| 1843 message.getExtension(packedEnumExtension, 0)); | |
| 1844 assertEqualsExactType(701 , message.getExtension(packedInt32Extension , 1
)); | |
| 1845 assertEqualsExactType(702L , message.getExtension(packedInt64Extension , 1
)); | |
| 1846 assertEqualsExactType(703 , message.getExtension(packedUint32Extension , 1
)); | |
| 1847 assertEqualsExactType(704L , message.getExtension(packedUint64Extension , 1
)); | |
| 1848 assertEqualsExactType(705 , message.getExtension(packedSint32Extension , 1
)); | |
| 1849 assertEqualsExactType(706L , message.getExtension(packedSint64Extension , 1
)); | |
| 1850 assertEqualsExactType(707 , message.getExtension(packedFixed32Extension , 1
)); | |
| 1851 assertEqualsExactType(708L , message.getExtension(packedFixed64Extension , 1
)); | |
| 1852 assertEqualsExactType(709 , message.getExtension(packedSfixed32Extension, 1
)); | |
| 1853 assertEqualsExactType(710L , message.getExtension(packedSfixed64Extension, 1
)); | |
| 1854 assertEqualsExactType(711F , message.getExtension(packedFloatExtension , 1
)); | |
| 1855 assertEqualsExactType(712D , message.getExtension(packedDoubleExtension , 1
)); | |
| 1856 assertEqualsExactType(false, message.getExtension(packedBoolExtension , 1
)); | |
| 1857 assertEqualsExactType(ForeignEnum.FOREIGN_BAZ, | |
| 1858 message.getExtension(packedEnumExtension, 1)); | |
| 1859 } | |
| 1860 | |
| 1861 // ================================================================= | |
| 1862 | |
| 1863 /** | |
| 1864 * Performs the same things that the methods of {@code TestUtil} do, but | |
| 1865 * via the reflection interface. This is its own class because it needs | |
| 1866 * to know what descriptor to use. | |
| 1867 */ | |
| 1868 public static class ReflectionTester { | |
| 1869 private final Descriptors.Descriptor baseDescriptor; | |
| 1870 private final ExtensionRegistry extensionRegistry; | |
| 1871 | |
| 1872 private final Descriptors.FileDescriptor file; | |
| 1873 private final Descriptors.FileDescriptor importFile; | |
| 1874 private final Descriptors.FileDescriptor publicImportFile; | |
| 1875 | |
| 1876 private final Descriptors.Descriptor optionalGroup; | |
| 1877 private final Descriptors.Descriptor repeatedGroup; | |
| 1878 private final Descriptors.Descriptor nestedMessage; | |
| 1879 private final Descriptors.Descriptor foreignMessage; | |
| 1880 private final Descriptors.Descriptor importMessage; | |
| 1881 private final Descriptors.Descriptor publicImportMessage; | |
| 1882 | |
| 1883 private final Descriptors.FieldDescriptor groupA; | |
| 1884 private final Descriptors.FieldDescriptor repeatedGroupA; | |
| 1885 private final Descriptors.FieldDescriptor nestedB; | |
| 1886 private final Descriptors.FieldDescriptor foreignC; | |
| 1887 private final Descriptors.FieldDescriptor importD; | |
| 1888 private final Descriptors.FieldDescriptor importE; | |
| 1889 | |
| 1890 private final Descriptors.EnumDescriptor nestedEnum; | |
| 1891 private final Descriptors.EnumDescriptor foreignEnum; | |
| 1892 private final Descriptors.EnumDescriptor importEnum; | |
| 1893 | |
| 1894 private final Descriptors.EnumValueDescriptor nestedFoo; | |
| 1895 private final Descriptors.EnumValueDescriptor nestedBar; | |
| 1896 private final Descriptors.EnumValueDescriptor nestedBaz; | |
| 1897 private final Descriptors.EnumValueDescriptor foreignFoo; | |
| 1898 private final Descriptors.EnumValueDescriptor foreignBar; | |
| 1899 private final Descriptors.EnumValueDescriptor foreignBaz; | |
| 1900 private final Descriptors.EnumValueDescriptor importFoo; | |
| 1901 private final Descriptors.EnumValueDescriptor importBar; | |
| 1902 private final Descriptors.EnumValueDescriptor importBaz; | |
| 1903 | |
| 1904 /** | |
| 1905 * Construct a {@code ReflectionTester} that will expect messages using | |
| 1906 * the given descriptor. | |
| 1907 * | |
| 1908 * Normally {@code baseDescriptor} should be a descriptor for the type | |
| 1909 * {@code TestAllTypes}, defined in | |
| 1910 * {@code google/protobuf/unittest.proto}. However, if | |
| 1911 * {@code extensionRegistry} is non-null, then {@code baseDescriptor} should | |
| 1912 * be for {@code TestAllExtensions} instead, and instead of reading and | |
| 1913 * writing normal fields, the tester will read and write extensions. | |
| 1914 * All of {@code TestAllExtensions}' extensions must be registered in the | |
| 1915 * registry. | |
| 1916 */ | |
| 1917 public ReflectionTester(Descriptors.Descriptor baseDescriptor, | |
| 1918 ExtensionRegistry extensionRegistry) { | |
| 1919 this.baseDescriptor = baseDescriptor; | |
| 1920 this.extensionRegistry = extensionRegistry; | |
| 1921 | |
| 1922 this.file = baseDescriptor.getFile(); | |
| 1923 Assert.assertEquals(1, file.getDependencies().size()); | |
| 1924 this.importFile = file.getDependencies().get(0); | |
| 1925 this.publicImportFile = importFile.getDependencies().get(0); | |
| 1926 | |
| 1927 Descriptors.Descriptor testAllTypes; | |
| 1928 if (baseDescriptor.getName() == "TestAllTypes") { | |
| 1929 testAllTypes = baseDescriptor; | |
| 1930 } else { | |
| 1931 testAllTypes = file.findMessageTypeByName("TestAllTypes"); | |
| 1932 Assert.assertNotNull(testAllTypes); | |
| 1933 } | |
| 1934 | |
| 1935 if (extensionRegistry == null) { | |
| 1936 // Use testAllTypes, rather than baseDescriptor, to allow | |
| 1937 // initialization using TestPackedTypes descriptors. These objects | |
| 1938 // won't be used by the methods for packed fields. | |
| 1939 this.optionalGroup = | |
| 1940 testAllTypes.findNestedTypeByName("OptionalGroup"); | |
| 1941 this.repeatedGroup = | |
| 1942 testAllTypes.findNestedTypeByName("RepeatedGroup"); | |
| 1943 } else { | |
| 1944 this.optionalGroup = | |
| 1945 file.findMessageTypeByName("OptionalGroup_extension"); | |
| 1946 this.repeatedGroup = | |
| 1947 file.findMessageTypeByName("RepeatedGroup_extension"); | |
| 1948 } | |
| 1949 this.nestedMessage = testAllTypes.findNestedTypeByName("NestedMessage"); | |
| 1950 this.foreignMessage = file.findMessageTypeByName("ForeignMessage"); | |
| 1951 this.importMessage = importFile.findMessageTypeByName("ImportMessage"); | |
| 1952 this.publicImportMessage = publicImportFile.findMessageTypeByName( | |
| 1953 "PublicImportMessage"); | |
| 1954 | |
| 1955 this.nestedEnum = testAllTypes.findEnumTypeByName("NestedEnum"); | |
| 1956 this.foreignEnum = file.findEnumTypeByName("ForeignEnum"); | |
| 1957 this.importEnum = importFile.findEnumTypeByName("ImportEnum"); | |
| 1958 | |
| 1959 Assert.assertNotNull(optionalGroup ); | |
| 1960 Assert.assertNotNull(repeatedGroup ); | |
| 1961 Assert.assertNotNull(nestedMessage ); | |
| 1962 Assert.assertNotNull(foreignMessage); | |
| 1963 Assert.assertNotNull(importMessage ); | |
| 1964 Assert.assertNotNull(nestedEnum ); | |
| 1965 Assert.assertNotNull(foreignEnum ); | |
| 1966 Assert.assertNotNull(importEnum ); | |
| 1967 | |
| 1968 this.nestedB = nestedMessage .findFieldByName("bb"); | |
| 1969 this.foreignC = foreignMessage.findFieldByName("c"); | |
| 1970 this.importD = importMessage .findFieldByName("d"); | |
| 1971 this.importE = publicImportMessage.findFieldByName("e"); | |
| 1972 this.nestedFoo = nestedEnum.findValueByName("FOO"); | |
| 1973 this.nestedBar = nestedEnum.findValueByName("BAR"); | |
| 1974 this.nestedBaz = nestedEnum.findValueByName("BAZ"); | |
| 1975 this.foreignFoo = foreignEnum.findValueByName("FOREIGN_FOO"); | |
| 1976 this.foreignBar = foreignEnum.findValueByName("FOREIGN_BAR"); | |
| 1977 this.foreignBaz = foreignEnum.findValueByName("FOREIGN_BAZ"); | |
| 1978 this.importFoo = importEnum.findValueByName("IMPORT_FOO"); | |
| 1979 this.importBar = importEnum.findValueByName("IMPORT_BAR"); | |
| 1980 this.importBaz = importEnum.findValueByName("IMPORT_BAZ"); | |
| 1981 | |
| 1982 this.groupA = optionalGroup.findFieldByName("a"); | |
| 1983 this.repeatedGroupA = repeatedGroup.findFieldByName("a"); | |
| 1984 | |
| 1985 Assert.assertNotNull(groupA ); | |
| 1986 Assert.assertNotNull(repeatedGroupA); | |
| 1987 Assert.assertNotNull(nestedB ); | |
| 1988 Assert.assertNotNull(foreignC ); | |
| 1989 Assert.assertNotNull(importD ); | |
| 1990 Assert.assertNotNull(importE ); | |
| 1991 Assert.assertNotNull(nestedFoo ); | |
| 1992 Assert.assertNotNull(nestedBar ); | |
| 1993 Assert.assertNotNull(nestedBaz ); | |
| 1994 Assert.assertNotNull(foreignFoo ); | |
| 1995 Assert.assertNotNull(foreignBar ); | |
| 1996 Assert.assertNotNull(foreignBaz ); | |
| 1997 Assert.assertNotNull(importFoo ); | |
| 1998 Assert.assertNotNull(importBar ); | |
| 1999 Assert.assertNotNull(importBaz ); | |
| 2000 } | |
| 2001 | |
| 2002 /** | |
| 2003 * Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes. | |
| 2004 */ | |
| 2005 private Descriptors.FieldDescriptor f(String name) { | |
| 2006 Descriptors.FieldDescriptor result; | |
| 2007 if (extensionRegistry == null) { | |
| 2008 result = baseDescriptor.findFieldByName(name); | |
| 2009 } else { | |
| 2010 result = file.findExtensionByName(name + "_extension"); | |
| 2011 } | |
| 2012 Assert.assertNotNull(result); | |
| 2013 return result; | |
| 2014 } | |
| 2015 | |
| 2016 /** | |
| 2017 * Calls {@code parent.newBuilderForField()} or uses the | |
| 2018 * {@code ExtensionRegistry} to find an appropriate builder, depending | |
| 2019 * on what type is being tested. | |
| 2020 */ | |
| 2021 private Message.Builder newBuilderForField( | |
| 2022 Message.Builder parent, Descriptors.FieldDescriptor field) { | |
| 2023 if (extensionRegistry == null) { | |
| 2024 return parent.newBuilderForField(field); | |
| 2025 } else { | |
| 2026 ExtensionRegistry.ExtensionInfo extension = | |
| 2027 extensionRegistry.findExtensionByNumber(field.getContainingType(), | |
| 2028 field.getNumber()); | |
| 2029 Assert.assertNotNull(extension); | |
| 2030 Assert.assertNotNull(extension.defaultInstance); | |
| 2031 return extension.defaultInstance.newBuilderForType(); | |
| 2032 } | |
| 2033 } | |
| 2034 | |
| 2035 // ------------------------------------------------------------------- | |
| 2036 | |
| 2037 /** | |
| 2038 * Set every field of {@code message} to the values expected by | |
| 2039 * {@code assertAllFieldsSet()}, using the {@link Message.Builder} | |
| 2040 * reflection interface. | |
| 2041 */ | |
| 2042 void setAllFieldsViaReflection(Message.Builder message) { | |
| 2043 message.setField(f("optional_int32" ), 101 ); | |
| 2044 message.setField(f("optional_int64" ), 102L); | |
| 2045 message.setField(f("optional_uint32" ), 103 ); | |
| 2046 message.setField(f("optional_uint64" ), 104L); | |
| 2047 message.setField(f("optional_sint32" ), 105 ); | |
| 2048 message.setField(f("optional_sint64" ), 106L); | |
| 2049 message.setField(f("optional_fixed32" ), 107 ); | |
| 2050 message.setField(f("optional_fixed64" ), 108L); | |
| 2051 message.setField(f("optional_sfixed32"), 109 ); | |
| 2052 message.setField(f("optional_sfixed64"), 110L); | |
| 2053 message.setField(f("optional_float" ), 111F); | |
| 2054 message.setField(f("optional_double" ), 112D); | |
| 2055 message.setField(f("optional_bool" ), true); | |
| 2056 message.setField(f("optional_string" ), "115"); | |
| 2057 message.setField(f("optional_bytes" ), toBytes("116")); | |
| 2058 | |
| 2059 message.setField(f("optionalgroup"), | |
| 2060 newBuilderForField(message, f("optionalgroup")) | |
| 2061 .setField(groupA, 117).build()); | |
| 2062 message.setField(f("optional_nested_message"), | |
| 2063 newBuilderForField(message, f("optional_nested_message")) | |
| 2064 .setField(nestedB, 118).build()); | |
| 2065 message.setField(f("optional_foreign_message"), | |
| 2066 newBuilderForField(message, f("optional_foreign_message")) | |
| 2067 .setField(foreignC, 119).build()); | |
| 2068 message.setField(f("optional_import_message"), | |
| 2069 newBuilderForField(message, f("optional_import_message")) | |
| 2070 .setField(importD, 120).build()); | |
| 2071 message.setField(f("optional_public_import_message"), | |
| 2072 newBuilderForField(message, f("optional_public_import_message")) | |
| 2073 .setField(importE, 126).build()); | |
| 2074 message.setField(f("optional_lazy_message"), | |
| 2075 newBuilderForField(message, f("optional_lazy_message")) | |
| 2076 .setField(nestedB, 127).build()); | |
| 2077 | |
| 2078 message.setField(f("optional_nested_enum" ), nestedBaz); | |
| 2079 message.setField(f("optional_foreign_enum"), foreignBaz); | |
| 2080 message.setField(f("optional_import_enum" ), importBaz); | |
| 2081 | |
| 2082 message.setField(f("optional_string_piece" ), "124"); | |
| 2083 message.setField(f("optional_cord" ), "125"); | |
| 2084 | |
| 2085 // ----------------------------------------------------------------- | |
| 2086 | |
| 2087 message.addRepeatedField(f("repeated_int32" ), 201 ); | |
| 2088 message.addRepeatedField(f("repeated_int64" ), 202L); | |
| 2089 message.addRepeatedField(f("repeated_uint32" ), 203 ); | |
| 2090 message.addRepeatedField(f("repeated_uint64" ), 204L); | |
| 2091 message.addRepeatedField(f("repeated_sint32" ), 205 ); | |
| 2092 message.addRepeatedField(f("repeated_sint64" ), 206L); | |
| 2093 message.addRepeatedField(f("repeated_fixed32" ), 207 ); | |
| 2094 message.addRepeatedField(f("repeated_fixed64" ), 208L); | |
| 2095 message.addRepeatedField(f("repeated_sfixed32"), 209 ); | |
| 2096 message.addRepeatedField(f("repeated_sfixed64"), 210L); | |
| 2097 message.addRepeatedField(f("repeated_float" ), 211F); | |
| 2098 message.addRepeatedField(f("repeated_double" ), 212D); | |
| 2099 message.addRepeatedField(f("repeated_bool" ), true); | |
| 2100 message.addRepeatedField(f("repeated_string" ), "215"); | |
| 2101 message.addRepeatedField(f("repeated_bytes" ), toBytes("216")); | |
| 2102 | |
| 2103 message.addRepeatedField(f("repeatedgroup"), | |
| 2104 newBuilderForField(message, f("repeatedgroup")) | |
| 2105 .setField(repeatedGroupA, 217).build()); | |
| 2106 message.addRepeatedField(f("repeated_nested_message"), | |
| 2107 newBuilderForField(message, f("repeated_nested_message")) | |
| 2108 .setField(nestedB, 218).build()); | |
| 2109 message.addRepeatedField(f("repeated_foreign_message"), | |
| 2110 newBuilderForField(message, f("repeated_foreign_message")) | |
| 2111 .setField(foreignC, 219).build()); | |
| 2112 message.addRepeatedField(f("repeated_import_message"), | |
| 2113 newBuilderForField(message, f("repeated_import_message")) | |
| 2114 .setField(importD, 220).build()); | |
| 2115 message.addRepeatedField(f("repeated_lazy_message"), | |
| 2116 newBuilderForField(message, f("repeated_lazy_message")) | |
| 2117 .setField(nestedB, 227).build()); | |
| 2118 | |
| 2119 message.addRepeatedField(f("repeated_nested_enum" ), nestedBar); | |
| 2120 message.addRepeatedField(f("repeated_foreign_enum"), foreignBar); | |
| 2121 message.addRepeatedField(f("repeated_import_enum" ), importBar); | |
| 2122 | |
| 2123 message.addRepeatedField(f("repeated_string_piece" ), "224"); | |
| 2124 message.addRepeatedField(f("repeated_cord" ), "225"); | |
| 2125 | |
| 2126 // Add a second one of each field. | |
| 2127 message.addRepeatedField(f("repeated_int32" ), 301 ); | |
| 2128 message.addRepeatedField(f("repeated_int64" ), 302L); | |
| 2129 message.addRepeatedField(f("repeated_uint32" ), 303 ); | |
| 2130 message.addRepeatedField(f("repeated_uint64" ), 304L); | |
| 2131 message.addRepeatedField(f("repeated_sint32" ), 305 ); | |
| 2132 message.addRepeatedField(f("repeated_sint64" ), 306L); | |
| 2133 message.addRepeatedField(f("repeated_fixed32" ), 307 ); | |
| 2134 message.addRepeatedField(f("repeated_fixed64" ), 308L); | |
| 2135 message.addRepeatedField(f("repeated_sfixed32"), 309 ); | |
| 2136 message.addRepeatedField(f("repeated_sfixed64"), 310L); | |
| 2137 message.addRepeatedField(f("repeated_float" ), 311F); | |
| 2138 message.addRepeatedField(f("repeated_double" ), 312D); | |
| 2139 message.addRepeatedField(f("repeated_bool" ), false); | |
| 2140 message.addRepeatedField(f("repeated_string" ), "315"); | |
| 2141 message.addRepeatedField(f("repeated_bytes" ), toBytes("316")); | |
| 2142 | |
| 2143 message.addRepeatedField(f("repeatedgroup"), | |
| 2144 newBuilderForField(message, f("repeatedgroup")) | |
| 2145 .setField(repeatedGroupA, 317).build()); | |
| 2146 message.addRepeatedField(f("repeated_nested_message"), | |
| 2147 newBuilderForField(message, f("repeated_nested_message")) | |
| 2148 .setField(nestedB, 318).build()); | |
| 2149 message.addRepeatedField(f("repeated_foreign_message"), | |
| 2150 newBuilderForField(message, f("repeated_foreign_message")) | |
| 2151 .setField(foreignC, 319).build()); | |
| 2152 message.addRepeatedField(f("repeated_import_message"), | |
| 2153 newBuilderForField(message, f("repeated_import_message")) | |
| 2154 .setField(importD, 320).build()); | |
| 2155 message.addRepeatedField(f("repeated_lazy_message"), | |
| 2156 newBuilderForField(message, f("repeated_lazy_message")) | |
| 2157 .setField(nestedB, 327).build()); | |
| 2158 | |
| 2159 message.addRepeatedField(f("repeated_nested_enum" ), nestedBaz); | |
| 2160 message.addRepeatedField(f("repeated_foreign_enum"), foreignBaz); | |
| 2161 message.addRepeatedField(f("repeated_import_enum" ), importBaz); | |
| 2162 | |
| 2163 message.addRepeatedField(f("repeated_string_piece" ), "324"); | |
| 2164 message.addRepeatedField(f("repeated_cord" ), "325"); | |
| 2165 | |
| 2166 // ----------------------------------------------------------------- | |
| 2167 | |
| 2168 message.setField(f("default_int32" ), 401 ); | |
| 2169 message.setField(f("default_int64" ), 402L); | |
| 2170 message.setField(f("default_uint32" ), 403 ); | |
| 2171 message.setField(f("default_uint64" ), 404L); | |
| 2172 message.setField(f("default_sint32" ), 405 ); | |
| 2173 message.setField(f("default_sint64" ), 406L); | |
| 2174 message.setField(f("default_fixed32" ), 407 ); | |
| 2175 message.setField(f("default_fixed64" ), 408L); | |
| 2176 message.setField(f("default_sfixed32"), 409 ); | |
| 2177 message.setField(f("default_sfixed64"), 410L); | |
| 2178 message.setField(f("default_float" ), 411F); | |
| 2179 message.setField(f("default_double" ), 412D); | |
| 2180 message.setField(f("default_bool" ), false); | |
| 2181 message.setField(f("default_string" ), "415"); | |
| 2182 message.setField(f("default_bytes" ), toBytes("416")); | |
| 2183 | |
| 2184 message.setField(f("default_nested_enum" ), nestedFoo); | |
| 2185 message.setField(f("default_foreign_enum"), foreignFoo); | |
| 2186 message.setField(f("default_import_enum" ), importFoo); | |
| 2187 | |
| 2188 message.setField(f("default_string_piece" ), "424"); | |
| 2189 message.setField(f("default_cord" ), "425"); | |
| 2190 } | |
| 2191 | |
| 2192 // ------------------------------------------------------------------- | |
| 2193 | |
| 2194 /** | |
| 2195 * Modify the repeated fields of {@code message} to contain the values | |
| 2196 * expected by {@code assertRepeatedFieldsModified()}, using the | |
| 2197 * {@link Message.Builder} reflection interface. | |
| 2198 */ | |
| 2199 void modifyRepeatedFieldsViaReflection(Message.Builder message) { | |
| 2200 message.setRepeatedField(f("repeated_int32" ), 1, 501 ); | |
| 2201 message.setRepeatedField(f("repeated_int64" ), 1, 502L); | |
| 2202 message.setRepeatedField(f("repeated_uint32" ), 1, 503 ); | |
| 2203 message.setRepeatedField(f("repeated_uint64" ), 1, 504L); | |
| 2204 message.setRepeatedField(f("repeated_sint32" ), 1, 505 ); | |
| 2205 message.setRepeatedField(f("repeated_sint64" ), 1, 506L); | |
| 2206 message.setRepeatedField(f("repeated_fixed32" ), 1, 507 ); | |
| 2207 message.setRepeatedField(f("repeated_fixed64" ), 1, 508L); | |
| 2208 message.setRepeatedField(f("repeated_sfixed32"), 1, 509 ); | |
| 2209 message.setRepeatedField(f("repeated_sfixed64"), 1, 510L); | |
| 2210 message.setRepeatedField(f("repeated_float" ), 1, 511F); | |
| 2211 message.setRepeatedField(f("repeated_double" ), 1, 512D); | |
| 2212 message.setRepeatedField(f("repeated_bool" ), 1, true); | |
| 2213 message.setRepeatedField(f("repeated_string" ), 1, "515"); | |
| 2214 message.setRepeatedField(f("repeated_bytes" ), 1, toBytes("516")); | |
| 2215 | |
| 2216 message.setRepeatedField(f("repeatedgroup"), 1, | |
| 2217 newBuilderForField(message, f("repeatedgroup")) | |
| 2218 .setField(repeatedGroupA, 517).build()); | |
| 2219 message.setRepeatedField(f("repeated_nested_message"), 1, | |
| 2220 newBuilderForField(message, f("repeated_nested_message")) | |
| 2221 .setField(nestedB, 518).build()); | |
| 2222 message.setRepeatedField(f("repeated_foreign_message"), 1, | |
| 2223 newBuilderForField(message, f("repeated_foreign_message")) | |
| 2224 .setField(foreignC, 519).build()); | |
| 2225 message.setRepeatedField(f("repeated_import_message"), 1, | |
| 2226 newBuilderForField(message, f("repeated_import_message")) | |
| 2227 .setField(importD, 520).build()); | |
| 2228 message.setRepeatedField(f("repeated_lazy_message"), 1, | |
| 2229 newBuilderForField(message, f("repeated_lazy_message")) | |
| 2230 .setField(nestedB, 527).build()); | |
| 2231 | |
| 2232 message.setRepeatedField(f("repeated_nested_enum" ), 1, nestedFoo); | |
| 2233 message.setRepeatedField(f("repeated_foreign_enum"), 1, foreignFoo); | |
| 2234 message.setRepeatedField(f("repeated_import_enum" ), 1, importFoo); | |
| 2235 | |
| 2236 message.setRepeatedField(f("repeated_string_piece"), 1, "524"); | |
| 2237 message.setRepeatedField(f("repeated_cord"), 1, "525"); | |
| 2238 } | |
| 2239 | |
| 2240 // ------------------------------------------------------------------- | |
| 2241 | |
| 2242 /** | |
| 2243 * Assert (using {@code junit.framework.Assert}} that all fields of | |
| 2244 * {@code message} are set to the values assigned by {@code setAllFields}, | |
| 2245 * using the {@link Message} reflection interface. | |
| 2246 */ | |
| 2247 public void assertAllFieldsSetViaReflection(MessageOrBuilder message) { | |
| 2248 Assert.assertTrue(message.hasField(f("optional_int32" ))); | |
| 2249 Assert.assertTrue(message.hasField(f("optional_int64" ))); | |
| 2250 Assert.assertTrue(message.hasField(f("optional_uint32" ))); | |
| 2251 Assert.assertTrue(message.hasField(f("optional_uint64" ))); | |
| 2252 Assert.assertTrue(message.hasField(f("optional_sint32" ))); | |
| 2253 Assert.assertTrue(message.hasField(f("optional_sint64" ))); | |
| 2254 Assert.assertTrue(message.hasField(f("optional_fixed32" ))); | |
| 2255 Assert.assertTrue(message.hasField(f("optional_fixed64" ))); | |
| 2256 Assert.assertTrue(message.hasField(f("optional_sfixed32"))); | |
| 2257 Assert.assertTrue(message.hasField(f("optional_sfixed64"))); | |
| 2258 Assert.assertTrue(message.hasField(f("optional_float" ))); | |
| 2259 Assert.assertTrue(message.hasField(f("optional_double" ))); | |
| 2260 Assert.assertTrue(message.hasField(f("optional_bool" ))); | |
| 2261 Assert.assertTrue(message.hasField(f("optional_string" ))); | |
| 2262 Assert.assertTrue(message.hasField(f("optional_bytes" ))); | |
| 2263 | |
| 2264 Assert.assertTrue(message.hasField(f("optionalgroup" ))); | |
| 2265 Assert.assertTrue(message.hasField(f("optional_nested_message" ))); | |
| 2266 Assert.assertTrue(message.hasField(f("optional_foreign_message"))); | |
| 2267 Assert.assertTrue(message.hasField(f("optional_import_message" ))); | |
| 2268 | |
| 2269 Assert.assertTrue( | |
| 2270 ((Message)message.getField(f("optionalgroup"))).hasField(groupA)); | |
| 2271 Assert.assertTrue( | |
| 2272 ((Message)message.getField(f("optional_nested_message"))) | |
| 2273 .hasField(nestedB)); | |
| 2274 Assert.assertTrue( | |
| 2275 ((Message)message.getField(f("optional_foreign_message"))) | |
| 2276 .hasField(foreignC)); | |
| 2277 Assert.assertTrue( | |
| 2278 ((Message)message.getField(f("optional_import_message"))) | |
| 2279 .hasField(importD)); | |
| 2280 | |
| 2281 Assert.assertTrue(message.hasField(f("optional_nested_enum" ))); | |
| 2282 Assert.assertTrue(message.hasField(f("optional_foreign_enum"))); | |
| 2283 Assert.assertTrue(message.hasField(f("optional_import_enum" ))); | |
| 2284 | |
| 2285 Assert.assertTrue(message.hasField(f("optional_string_piece"))); | |
| 2286 Assert.assertTrue(message.hasField(f("optional_cord"))); | |
| 2287 | |
| 2288 Assert.assertEquals(101 , message.getField(f("optional_int32" ))); | |
| 2289 Assert.assertEquals(102L , message.getField(f("optional_int64" ))); | |
| 2290 Assert.assertEquals(103 , message.getField(f("optional_uint32" ))); | |
| 2291 Assert.assertEquals(104L , message.getField(f("optional_uint64" ))); | |
| 2292 Assert.assertEquals(105 , message.getField(f("optional_sint32" ))); | |
| 2293 Assert.assertEquals(106L , message.getField(f("optional_sint64" ))); | |
| 2294 Assert.assertEquals(107 , message.getField(f("optional_fixed32" ))); | |
| 2295 Assert.assertEquals(108L , message.getField(f("optional_fixed64" ))); | |
| 2296 Assert.assertEquals(109 , message.getField(f("optional_sfixed32"))); | |
| 2297 Assert.assertEquals(110L , message.getField(f("optional_sfixed64"))); | |
| 2298 Assert.assertEquals(111F , message.getField(f("optional_float" ))); | |
| 2299 Assert.assertEquals(112D , message.getField(f("optional_double" ))); | |
| 2300 Assert.assertEquals(true , message.getField(f("optional_bool" ))); | |
| 2301 Assert.assertEquals("115", message.getField(f("optional_string" ))); | |
| 2302 Assert.assertEquals(toBytes("116"), message.getField(f("optional_bytes")))
; | |
| 2303 | |
| 2304 Assert.assertEquals(117, | |
| 2305 ((Message)message.getField(f("optionalgroup"))).getField(groupA)); | |
| 2306 Assert.assertEquals(118, | |
| 2307 ((Message)message.getField(f("optional_nested_message"))) | |
| 2308 .getField(nestedB)); | |
| 2309 Assert.assertEquals(119, | |
| 2310 ((Message)message.getField(f("optional_foreign_message"))) | |
| 2311 .getField(foreignC)); | |
| 2312 Assert.assertEquals(120, | |
| 2313 ((Message)message.getField(f("optional_import_message"))) | |
| 2314 .getField(importD)); | |
| 2315 Assert.assertEquals(126, | |
| 2316 ((Message)message.getField(f("optional_public_import_message"))) | |
| 2317 .getField(importE)); | |
| 2318 Assert.assertEquals(127, | |
| 2319 ((Message)message.getField(f("optional_lazy_message"))) | |
| 2320 .getField(nestedB)); | |
| 2321 | |
| 2322 Assert.assertEquals( nestedBaz, message.getField(f("optional_nested_enum"
))); | |
| 2323 Assert.assertEquals(foreignBaz, message.getField(f("optional_foreign_enum"
))); | |
| 2324 Assert.assertEquals( importBaz, message.getField(f("optional_import_enum"
))); | |
| 2325 | |
| 2326 Assert.assertEquals("124", message.getField(f("optional_string_piece"))); | |
| 2327 Assert.assertEquals("125", message.getField(f("optional_cord"))); | |
| 2328 | |
| 2329 // ----------------------------------------------------------------- | |
| 2330 | |
| 2331 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_int32"
))); | |
| 2332 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_int64"
))); | |
| 2333 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_uint32"
))); | |
| 2334 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_uint64"
))); | |
| 2335 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sint32"
))); | |
| 2336 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sint64"
))); | |
| 2337 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_fixed32"
))); | |
| 2338 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_fixed64"
))); | |
| 2339 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sfixed32"
))); | |
| 2340 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sfixed64"
))); | |
| 2341 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_float"
))); | |
| 2342 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_double"
))); | |
| 2343 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_bool"
))); | |
| 2344 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_string"
))); | |
| 2345 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_bytes"
))); | |
| 2346 | |
| 2347 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeatedgroup"
))); | |
| 2348 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_me
ssage" ))); | |
| 2349 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_m
essage"))); | |
| 2350 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_me
ssage" ))); | |
| 2351 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_lazy_mess
age" ))); | |
| 2352 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_en
um" ))); | |
| 2353 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_e
num" ))); | |
| 2354 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_en
um" ))); | |
| 2355 | |
| 2356 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_string_pi
ece"))); | |
| 2357 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_cord"))); | |
| 2358 | |
| 2359 Assert.assertEquals(201 , message.getRepeatedField(f("repeated_int32" )
, 0)); | |
| 2360 Assert.assertEquals(202L , message.getRepeatedField(f("repeated_int64" )
, 0)); | |
| 2361 Assert.assertEquals(203 , message.getRepeatedField(f("repeated_uint32" )
, 0)); | |
| 2362 Assert.assertEquals(204L , message.getRepeatedField(f("repeated_uint64" )
, 0)); | |
| 2363 Assert.assertEquals(205 , message.getRepeatedField(f("repeated_sint32" )
, 0)); | |
| 2364 Assert.assertEquals(206L , message.getRepeatedField(f("repeated_sint64" )
, 0)); | |
| 2365 Assert.assertEquals(207 , message.getRepeatedField(f("repeated_fixed32" )
, 0)); | |
| 2366 Assert.assertEquals(208L , message.getRepeatedField(f("repeated_fixed64" )
, 0)); | |
| 2367 Assert.assertEquals(209 , message.getRepeatedField(f("repeated_sfixed32")
, 0)); | |
| 2368 Assert.assertEquals(210L , message.getRepeatedField(f("repeated_sfixed64")
, 0)); | |
| 2369 Assert.assertEquals(211F , message.getRepeatedField(f("repeated_float" )
, 0)); | |
| 2370 Assert.assertEquals(212D , message.getRepeatedField(f("repeated_double" )
, 0)); | |
| 2371 Assert.assertEquals(true , message.getRepeatedField(f("repeated_bool" )
, 0)); | |
| 2372 Assert.assertEquals("215", message.getRepeatedField(f("repeated_string" )
, 0)); | |
| 2373 Assert.assertEquals(toBytes("216"), message.getRepeatedField(f("repeated_b
ytes"), 0)); | |
| 2374 | |
| 2375 Assert.assertEquals(217, | |
| 2376 ((Message)message.getRepeatedField(f("repeatedgroup"), 0)) | |
| 2377 .getField(repeatedGroupA)); | |
| 2378 Assert.assertEquals(218, | |
| 2379 ((Message)message.getRepeatedField(f("repeated_nested_message"), 0)) | |
| 2380 .getField(nestedB)); | |
| 2381 Assert.assertEquals(219, | |
| 2382 ((Message)message.getRepeatedField(f("repeated_foreign_message"), 0)) | |
| 2383 .getField(foreignC)); | |
| 2384 Assert.assertEquals(220, | |
| 2385 ((Message)message.getRepeatedField(f("repeated_import_message"), 0)) | |
| 2386 .getField(importD)); | |
| 2387 Assert.assertEquals(227, | |
| 2388 ((Message)message.getRepeatedField(f("repeated_lazy_message"), 0)) | |
| 2389 .getField(nestedB)); | |
| 2390 | |
| 2391 Assert.assertEquals( nestedBar, message.getRepeatedField(f("repeated_neste
d_enum" ),0)); | |
| 2392 Assert.assertEquals(foreignBar, message.getRepeatedField(f("repeated_forei
gn_enum"),0)); | |
| 2393 Assert.assertEquals( importBar, message.getRepeatedField(f("repeated_impor
t_enum" ),0)); | |
| 2394 | |
| 2395 Assert.assertEquals("224", message.getRepeatedField(f("repeated_string_pie
ce"), 0)); | |
| 2396 Assert.assertEquals("225", message.getRepeatedField(f("repeated_cord"), 0)
); | |
| 2397 | |
| 2398 Assert.assertEquals(301 , message.getRepeatedField(f("repeated_int32" )
, 1)); | |
| 2399 Assert.assertEquals(302L , message.getRepeatedField(f("repeated_int64" )
, 1)); | |
| 2400 Assert.assertEquals(303 , message.getRepeatedField(f("repeated_uint32" )
, 1)); | |
| 2401 Assert.assertEquals(304L , message.getRepeatedField(f("repeated_uint64" )
, 1)); | |
| 2402 Assert.assertEquals(305 , message.getRepeatedField(f("repeated_sint32" )
, 1)); | |
| 2403 Assert.assertEquals(306L , message.getRepeatedField(f("repeated_sint64" )
, 1)); | |
| 2404 Assert.assertEquals(307 , message.getRepeatedField(f("repeated_fixed32" )
, 1)); | |
| 2405 Assert.assertEquals(308L , message.getRepeatedField(f("repeated_fixed64" )
, 1)); | |
| 2406 Assert.assertEquals(309 , message.getRepeatedField(f("repeated_sfixed32")
, 1)); | |
| 2407 Assert.assertEquals(310L , message.getRepeatedField(f("repeated_sfixed64")
, 1)); | |
| 2408 Assert.assertEquals(311F , message.getRepeatedField(f("repeated_float" )
, 1)); | |
| 2409 Assert.assertEquals(312D , message.getRepeatedField(f("repeated_double" )
, 1)); | |
| 2410 Assert.assertEquals(false, message.getRepeatedField(f("repeated_bool" )
, 1)); | |
| 2411 Assert.assertEquals("315", message.getRepeatedField(f("repeated_string" )
, 1)); | |
| 2412 Assert.assertEquals(toBytes("316"), message.getRepeatedField(f("repeated_b
ytes"), 1)); | |
| 2413 | |
| 2414 Assert.assertEquals(317, | |
| 2415 ((Message)message.getRepeatedField(f("repeatedgroup"), 1)) | |
| 2416 .getField(repeatedGroupA)); | |
| 2417 Assert.assertEquals(318, | |
| 2418 ((Message)message.getRepeatedField(f("repeated_nested_message"), 1)) | |
| 2419 .getField(nestedB)); | |
| 2420 Assert.assertEquals(319, | |
| 2421 ((Message)message.getRepeatedField(f("repeated_foreign_message"), 1)) | |
| 2422 .getField(foreignC)); | |
| 2423 Assert.assertEquals(320, | |
| 2424 ((Message)message.getRepeatedField(f("repeated_import_message"), 1)) | |
| 2425 .getField(importD)); | |
| 2426 Assert.assertEquals(327, | |
| 2427 ((Message)message.getRepeatedField(f("repeated_lazy_message"), 1)) | |
| 2428 .getField(nestedB)); | |
| 2429 | |
| 2430 Assert.assertEquals( nestedBaz, message.getRepeatedField(f("repeated_neste
d_enum" ),1)); | |
| 2431 Assert.assertEquals(foreignBaz, message.getRepeatedField(f("repeated_forei
gn_enum"),1)); | |
| 2432 Assert.assertEquals( importBaz, message.getRepeatedField(f("repeated_impor
t_enum" ),1)); | |
| 2433 | |
| 2434 Assert.assertEquals("324", message.getRepeatedField(f("repeated_string_pie
ce"), 1)); | |
| 2435 Assert.assertEquals("325", message.getRepeatedField(f("repeated_cord"), 1)
); | |
| 2436 | |
| 2437 // ----------------------------------------------------------------- | |
| 2438 | |
| 2439 Assert.assertTrue(message.hasField(f("default_int32" ))); | |
| 2440 Assert.assertTrue(message.hasField(f("default_int64" ))); | |
| 2441 Assert.assertTrue(message.hasField(f("default_uint32" ))); | |
| 2442 Assert.assertTrue(message.hasField(f("default_uint64" ))); | |
| 2443 Assert.assertTrue(message.hasField(f("default_sint32" ))); | |
| 2444 Assert.assertTrue(message.hasField(f("default_sint64" ))); | |
| 2445 Assert.assertTrue(message.hasField(f("default_fixed32" ))); | |
| 2446 Assert.assertTrue(message.hasField(f("default_fixed64" ))); | |
| 2447 Assert.assertTrue(message.hasField(f("default_sfixed32"))); | |
| 2448 Assert.assertTrue(message.hasField(f("default_sfixed64"))); | |
| 2449 Assert.assertTrue(message.hasField(f("default_float" ))); | |
| 2450 Assert.assertTrue(message.hasField(f("default_double" ))); | |
| 2451 Assert.assertTrue(message.hasField(f("default_bool" ))); | |
| 2452 Assert.assertTrue(message.hasField(f("default_string" ))); | |
| 2453 Assert.assertTrue(message.hasField(f("default_bytes" ))); | |
| 2454 | |
| 2455 Assert.assertTrue(message.hasField(f("default_nested_enum" ))); | |
| 2456 Assert.assertTrue(message.hasField(f("default_foreign_enum"))); | |
| 2457 Assert.assertTrue(message.hasField(f("default_import_enum" ))); | |
| 2458 | |
| 2459 Assert.assertTrue(message.hasField(f("default_string_piece"))); | |
| 2460 Assert.assertTrue(message.hasField(f("default_cord"))); | |
| 2461 | |
| 2462 Assert.assertEquals(401 , message.getField(f("default_int32" ))); | |
| 2463 Assert.assertEquals(402L , message.getField(f("default_int64" ))); | |
| 2464 Assert.assertEquals(403 , message.getField(f("default_uint32" ))); | |
| 2465 Assert.assertEquals(404L , message.getField(f("default_uint64" ))); | |
| 2466 Assert.assertEquals(405 , message.getField(f("default_sint32" ))); | |
| 2467 Assert.assertEquals(406L , message.getField(f("default_sint64" ))); | |
| 2468 Assert.assertEquals(407 , message.getField(f("default_fixed32" ))); | |
| 2469 Assert.assertEquals(408L , message.getField(f("default_fixed64" ))); | |
| 2470 Assert.assertEquals(409 , message.getField(f("default_sfixed32"))); | |
| 2471 Assert.assertEquals(410L , message.getField(f("default_sfixed64"))); | |
| 2472 Assert.assertEquals(411F , message.getField(f("default_float" ))); | |
| 2473 Assert.assertEquals(412D , message.getField(f("default_double" ))); | |
| 2474 Assert.assertEquals(false, message.getField(f("default_bool" ))); | |
| 2475 Assert.assertEquals("415", message.getField(f("default_string" ))); | |
| 2476 Assert.assertEquals(toBytes("416"), message.getField(f("default_bytes"))); | |
| 2477 | |
| 2478 Assert.assertEquals( nestedFoo, message.getField(f("default_nested_enum" )
)); | |
| 2479 Assert.assertEquals(foreignFoo, message.getField(f("default_foreign_enum")
)); | |
| 2480 Assert.assertEquals( importFoo, message.getField(f("default_import_enum" )
)); | |
| 2481 | |
| 2482 Assert.assertEquals("424", message.getField(f("default_string_piece"))); | |
| 2483 Assert.assertEquals("425", message.getField(f("default_cord"))); | |
| 2484 } | |
| 2485 | |
| 2486 // ------------------------------------------------------------------- | |
| 2487 | |
| 2488 /** | |
| 2489 * Assert (using {@code junit.framework.Assert}} that all fields of | |
| 2490 * {@code message} are cleared, and that getting the fields returns their | |
| 2491 * default values, using the {@link Message} reflection interface. | |
| 2492 */ | |
| 2493 public void assertClearViaReflection(MessageOrBuilder message) { | |
| 2494 // has_blah() should initially be false for all optional fields. | |
| 2495 Assert.assertFalse(message.hasField(f("optional_int32" ))); | |
| 2496 Assert.assertFalse(message.hasField(f("optional_int64" ))); | |
| 2497 Assert.assertFalse(message.hasField(f("optional_uint32" ))); | |
| 2498 Assert.assertFalse(message.hasField(f("optional_uint64" ))); | |
| 2499 Assert.assertFalse(message.hasField(f("optional_sint32" ))); | |
| 2500 Assert.assertFalse(message.hasField(f("optional_sint64" ))); | |
| 2501 Assert.assertFalse(message.hasField(f("optional_fixed32" ))); | |
| 2502 Assert.assertFalse(message.hasField(f("optional_fixed64" ))); | |
| 2503 Assert.assertFalse(message.hasField(f("optional_sfixed32"))); | |
| 2504 Assert.assertFalse(message.hasField(f("optional_sfixed64"))); | |
| 2505 Assert.assertFalse(message.hasField(f("optional_float" ))); | |
| 2506 Assert.assertFalse(message.hasField(f("optional_double" ))); | |
| 2507 Assert.assertFalse(message.hasField(f("optional_bool" ))); | |
| 2508 Assert.assertFalse(message.hasField(f("optional_string" ))); | |
| 2509 Assert.assertFalse(message.hasField(f("optional_bytes" ))); | |
| 2510 | |
| 2511 Assert.assertFalse(message.hasField(f("optionalgroup" ))); | |
| 2512 Assert.assertFalse(message.hasField(f("optional_nested_message" ))); | |
| 2513 Assert.assertFalse(message.hasField(f("optional_foreign_message"))); | |
| 2514 Assert.assertFalse(message.hasField(f("optional_import_message" ))); | |
| 2515 | |
| 2516 Assert.assertFalse(message.hasField(f("optional_nested_enum" ))); | |
| 2517 Assert.assertFalse(message.hasField(f("optional_foreign_enum"))); | |
| 2518 Assert.assertFalse(message.hasField(f("optional_import_enum" ))); | |
| 2519 | |
| 2520 Assert.assertFalse(message.hasField(f("optional_string_piece"))); | |
| 2521 Assert.assertFalse(message.hasField(f("optional_cord"))); | |
| 2522 | |
| 2523 // Optional fields without defaults are set to zero or something like it. | |
| 2524 Assert.assertEquals(0 , message.getField(f("optional_int32" ))); | |
| 2525 Assert.assertEquals(0L , message.getField(f("optional_int64" ))); | |
| 2526 Assert.assertEquals(0 , message.getField(f("optional_uint32" ))); | |
| 2527 Assert.assertEquals(0L , message.getField(f("optional_uint64" ))); | |
| 2528 Assert.assertEquals(0 , message.getField(f("optional_sint32" ))); | |
| 2529 Assert.assertEquals(0L , message.getField(f("optional_sint64" ))); | |
| 2530 Assert.assertEquals(0 , message.getField(f("optional_fixed32" ))); | |
| 2531 Assert.assertEquals(0L , message.getField(f("optional_fixed64" ))); | |
| 2532 Assert.assertEquals(0 , message.getField(f("optional_sfixed32"))); | |
| 2533 Assert.assertEquals(0L , message.getField(f("optional_sfixed64"))); | |
| 2534 Assert.assertEquals(0F , message.getField(f("optional_float" ))); | |
| 2535 Assert.assertEquals(0D , message.getField(f("optional_double" ))); | |
| 2536 Assert.assertEquals(false, message.getField(f("optional_bool" ))); | |
| 2537 Assert.assertEquals("" , message.getField(f("optional_string" ))); | |
| 2538 Assert.assertEquals(ByteString.EMPTY, message.getField(f("optional_bytes")
)); | |
| 2539 | |
| 2540 // Embedded messages should also be clear. | |
| 2541 Assert.assertFalse( | |
| 2542 ((Message)message.getField(f("optionalgroup"))).hasField(groupA)); | |
| 2543 Assert.assertFalse( | |
| 2544 ((Message)message.getField(f("optional_nested_message"))) | |
| 2545 .hasField(nestedB)); | |
| 2546 Assert.assertFalse( | |
| 2547 ((Message)message.getField(f("optional_foreign_message"))) | |
| 2548 .hasField(foreignC)); | |
| 2549 Assert.assertFalse( | |
| 2550 ((Message)message.getField(f("optional_import_message"))) | |
| 2551 .hasField(importD)); | |
| 2552 Assert.assertFalse( | |
| 2553 ((Message)message.getField(f("optional_public_import_message"))) | |
| 2554 .hasField(importE)); | |
| 2555 Assert.assertFalse( | |
| 2556 ((Message)message.getField(f("optional_lazy_message"))) | |
| 2557 .hasField(nestedB)); | |
| 2558 | |
| 2559 Assert.assertEquals(0, | |
| 2560 ((Message)message.getField(f("optionalgroup"))).getField(groupA)); | |
| 2561 Assert.assertEquals(0, | |
| 2562 ((Message)message.getField(f("optional_nested_message"))) | |
| 2563 .getField(nestedB)); | |
| 2564 Assert.assertEquals(0, | |
| 2565 ((Message)message.getField(f("optional_foreign_message"))) | |
| 2566 .getField(foreignC)); | |
| 2567 Assert.assertEquals(0, | |
| 2568 ((Message)message.getField(f("optional_import_message"))) | |
| 2569 .getField(importD)); | |
| 2570 Assert.assertEquals(0, | |
| 2571 ((Message)message.getField(f("optional_public_import_message"))) | |
| 2572 .getField(importE)); | |
| 2573 Assert.assertEquals(0, | |
| 2574 ((Message)message.getField(f("optional_lazy_message"))) | |
| 2575 .getField(nestedB)); | |
| 2576 | |
| 2577 // Enums without defaults are set to the first value in the enum. | |
| 2578 Assert.assertEquals( nestedFoo, message.getField(f("optional_nested_enum"
))); | |
| 2579 Assert.assertEquals(foreignFoo, message.getField(f("optional_foreign_enum"
))); | |
| 2580 Assert.assertEquals( importFoo, message.getField(f("optional_import_enum"
))); | |
| 2581 | |
| 2582 Assert.assertEquals("", message.getField(f("optional_string_piece"))); | |
| 2583 Assert.assertEquals("", message.getField(f("optional_cord"))); | |
| 2584 | |
| 2585 // Repeated fields are empty. | |
| 2586 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_int32"
))); | |
| 2587 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_int64"
))); | |
| 2588 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_uint32"
))); | |
| 2589 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_uint64"
))); | |
| 2590 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_sint32"
))); | |
| 2591 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_sint64"
))); | |
| 2592 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_fixed32"
))); | |
| 2593 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_fixed64"
))); | |
| 2594 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_sfixed32"
))); | |
| 2595 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_sfixed64"
))); | |
| 2596 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_float"
))); | |
| 2597 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_double"
))); | |
| 2598 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_bool"
))); | |
| 2599 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_string"
))); | |
| 2600 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_bytes"
))); | |
| 2601 | |
| 2602 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeatedgroup"
))); | |
| 2603 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_nested_me
ssage" ))); | |
| 2604 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_foreign_m
essage"))); | |
| 2605 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_import_me
ssage" ))); | |
| 2606 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_lazy_mess
age" ))); | |
| 2607 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_nested_en
um" ))); | |
| 2608 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_foreign_e
num" ))); | |
| 2609 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_import_en
um" ))); | |
| 2610 | |
| 2611 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_string_pi
ece"))); | |
| 2612 Assert.assertEquals(0, message.getRepeatedFieldCount(f("repeated_cord"))); | |
| 2613 | |
| 2614 // has_blah() should also be false for all default fields. | |
| 2615 Assert.assertFalse(message.hasField(f("default_int32" ))); | |
| 2616 Assert.assertFalse(message.hasField(f("default_int64" ))); | |
| 2617 Assert.assertFalse(message.hasField(f("default_uint32" ))); | |
| 2618 Assert.assertFalse(message.hasField(f("default_uint64" ))); | |
| 2619 Assert.assertFalse(message.hasField(f("default_sint32" ))); | |
| 2620 Assert.assertFalse(message.hasField(f("default_sint64" ))); | |
| 2621 Assert.assertFalse(message.hasField(f("default_fixed32" ))); | |
| 2622 Assert.assertFalse(message.hasField(f("default_fixed64" ))); | |
| 2623 Assert.assertFalse(message.hasField(f("default_sfixed32"))); | |
| 2624 Assert.assertFalse(message.hasField(f("default_sfixed64"))); | |
| 2625 Assert.assertFalse(message.hasField(f("default_float" ))); | |
| 2626 Assert.assertFalse(message.hasField(f("default_double" ))); | |
| 2627 Assert.assertFalse(message.hasField(f("default_bool" ))); | |
| 2628 Assert.assertFalse(message.hasField(f("default_string" ))); | |
| 2629 Assert.assertFalse(message.hasField(f("default_bytes" ))); | |
| 2630 | |
| 2631 Assert.assertFalse(message.hasField(f("default_nested_enum" ))); | |
| 2632 Assert.assertFalse(message.hasField(f("default_foreign_enum"))); | |
| 2633 Assert.assertFalse(message.hasField(f("default_import_enum" ))); | |
| 2634 | |
| 2635 Assert.assertFalse(message.hasField(f("default_string_piece" ))); | |
| 2636 Assert.assertFalse(message.hasField(f("default_cord" ))); | |
| 2637 | |
| 2638 // Fields with defaults have their default values (duh). | |
| 2639 Assert.assertEquals( 41 , message.getField(f("default_int32" ))); | |
| 2640 Assert.assertEquals( 42L , message.getField(f("default_int64" ))); | |
| 2641 Assert.assertEquals( 43 , message.getField(f("default_uint32" ))); | |
| 2642 Assert.assertEquals( 44L , message.getField(f("default_uint64" ))); | |
| 2643 Assert.assertEquals(-45 , message.getField(f("default_sint32" ))); | |
| 2644 Assert.assertEquals( 46L , message.getField(f("default_sint64" ))); | |
| 2645 Assert.assertEquals( 47 , message.getField(f("default_fixed32" ))); | |
| 2646 Assert.assertEquals( 48L , message.getField(f("default_fixed64" ))); | |
| 2647 Assert.assertEquals( 49 , message.getField(f("default_sfixed32"))); | |
| 2648 Assert.assertEquals(-50L , message.getField(f("default_sfixed64"))); | |
| 2649 Assert.assertEquals( 51.5F , message.getField(f("default_float" ))); | |
| 2650 Assert.assertEquals( 52e3D , message.getField(f("default_double" ))); | |
| 2651 Assert.assertEquals(true , message.getField(f("default_bool" ))); | |
| 2652 Assert.assertEquals("hello", message.getField(f("default_string" ))); | |
| 2653 Assert.assertEquals(toBytes("world"), message.getField(f("default_bytes"))
); | |
| 2654 | |
| 2655 Assert.assertEquals( nestedBar, message.getField(f("default_nested_enum" )
)); | |
| 2656 Assert.assertEquals(foreignBar, message.getField(f("default_foreign_enum")
)); | |
| 2657 Assert.assertEquals( importBar, message.getField(f("default_import_enum" )
)); | |
| 2658 | |
| 2659 Assert.assertEquals("abc", message.getField(f("default_string_piece"))); | |
| 2660 Assert.assertEquals("123", message.getField(f("default_cord"))); | |
| 2661 } | |
| 2662 | |
| 2663 | |
| 2664 // --------------------------------------------------------------- | |
| 2665 | |
| 2666 public void assertRepeatedFieldsModifiedViaReflection( | |
| 2667 MessageOrBuilder message) { | |
| 2668 // ModifyRepeatedFields only sets the second repeated element of each | |
| 2669 // field. In addition to verifying this, we also verify that the first | |
| 2670 // element and size were *not* modified. | |
| 2671 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_int32"
))); | |
| 2672 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_int64"
))); | |
| 2673 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_uint32"
))); | |
| 2674 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_uint64"
))); | |
| 2675 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sint32"
))); | |
| 2676 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sint64"
))); | |
| 2677 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_fixed32"
))); | |
| 2678 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_fixed64"
))); | |
| 2679 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sfixed32"
))); | |
| 2680 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_sfixed64"
))); | |
| 2681 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_float"
))); | |
| 2682 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_double"
))); | |
| 2683 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_bool"
))); | |
| 2684 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_string"
))); | |
| 2685 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_bytes"
))); | |
| 2686 | |
| 2687 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeatedgroup"
))); | |
| 2688 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_me
ssage" ))); | |
| 2689 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_m
essage"))); | |
| 2690 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_me
ssage" ))); | |
| 2691 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_lazy_mess
age" ))); | |
| 2692 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_nested_en
um" ))); | |
| 2693 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_foreign_e
num" ))); | |
| 2694 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_import_en
um" ))); | |
| 2695 | |
| 2696 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_string_pi
ece"))); | |
| 2697 Assert.assertEquals(2, message.getRepeatedFieldCount(f("repeated_cord"))); | |
| 2698 | |
| 2699 Assert.assertEquals(201 , message.getRepeatedField(f("repeated_int32" )
, 0)); | |
| 2700 Assert.assertEquals(202L , message.getRepeatedField(f("repeated_int64" )
, 0)); | |
| 2701 Assert.assertEquals(203 , message.getRepeatedField(f("repeated_uint32" )
, 0)); | |
| 2702 Assert.assertEquals(204L , message.getRepeatedField(f("repeated_uint64" )
, 0)); | |
| 2703 Assert.assertEquals(205 , message.getRepeatedField(f("repeated_sint32" )
, 0)); | |
| 2704 Assert.assertEquals(206L , message.getRepeatedField(f("repeated_sint64" )
, 0)); | |
| 2705 Assert.assertEquals(207 , message.getRepeatedField(f("repeated_fixed32" )
, 0)); | |
| 2706 Assert.assertEquals(208L , message.getRepeatedField(f("repeated_fixed64" )
, 0)); | |
| 2707 Assert.assertEquals(209 , message.getRepeatedField(f("repeated_sfixed32")
, 0)); | |
| 2708 Assert.assertEquals(210L , message.getRepeatedField(f("repeated_sfixed64")
, 0)); | |
| 2709 Assert.assertEquals(211F , message.getRepeatedField(f("repeated_float" )
, 0)); | |
| 2710 Assert.assertEquals(212D , message.getRepeatedField(f("repeated_double" )
, 0)); | |
| 2711 Assert.assertEquals(true , message.getRepeatedField(f("repeated_bool" )
, 0)); | |
| 2712 Assert.assertEquals("215", message.getRepeatedField(f("repeated_string" )
, 0)); | |
| 2713 Assert.assertEquals(toBytes("216"), message.getRepeatedField(f("repeated_b
ytes"), 0)); | |
| 2714 | |
| 2715 Assert.assertEquals(217, | |
| 2716 ((Message)message.getRepeatedField(f("repeatedgroup"), 0)) | |
| 2717 .getField(repeatedGroupA)); | |
| 2718 Assert.assertEquals(218, | |
| 2719 ((Message)message.getRepeatedField(f("repeated_nested_message"), 0)) | |
| 2720 .getField(nestedB)); | |
| 2721 Assert.assertEquals(219, | |
| 2722 ((Message)message.getRepeatedField(f("repeated_foreign_message"), 0)) | |
| 2723 .getField(foreignC)); | |
| 2724 Assert.assertEquals(220, | |
| 2725 ((Message)message.getRepeatedField(f("repeated_import_message"), 0)) | |
| 2726 .getField(importD)); | |
| 2727 Assert.assertEquals(227, | |
| 2728 ((Message)message.getRepeatedField(f("repeated_lazy_message"), 0)) | |
| 2729 .getField(nestedB)); | |
| 2730 | |
| 2731 Assert.assertEquals( nestedBar, message.getRepeatedField(f("repeated_neste
d_enum" ),0)); | |
| 2732 Assert.assertEquals(foreignBar, message.getRepeatedField(f("repeated_forei
gn_enum"),0)); | |
| 2733 Assert.assertEquals( importBar, message.getRepeatedField(f("repeated_impor
t_enum" ),0)); | |
| 2734 | |
| 2735 Assert.assertEquals("224", message.getRepeatedField(f("repeated_string_pie
ce"), 0)); | |
| 2736 Assert.assertEquals("225", message.getRepeatedField(f("repeated_cord"), 0)
); | |
| 2737 | |
| 2738 Assert.assertEquals(501 , message.getRepeatedField(f("repeated_int32" )
, 1)); | |
| 2739 Assert.assertEquals(502L , message.getRepeatedField(f("repeated_int64" )
, 1)); | |
| 2740 Assert.assertEquals(503 , message.getRepeatedField(f("repeated_uint32" )
, 1)); | |
| 2741 Assert.assertEquals(504L , message.getRepeatedField(f("repeated_uint64" )
, 1)); | |
| 2742 Assert.assertEquals(505 , message.getRepeatedField(f("repeated_sint32" )
, 1)); | |
| 2743 Assert.assertEquals(506L , message.getRepeatedField(f("repeated_sint64" )
, 1)); | |
| 2744 Assert.assertEquals(507 , message.getRepeatedField(f("repeated_fixed32" )
, 1)); | |
| 2745 Assert.assertEquals(508L , message.getRepeatedField(f("repeated_fixed64" )
, 1)); | |
| 2746 Assert.assertEquals(509 , message.getRepeatedField(f("repeated_sfixed32")
, 1)); | |
| 2747 Assert.assertEquals(510L , message.getRepeatedField(f("repeated_sfixed64")
, 1)); | |
| 2748 Assert.assertEquals(511F , message.getRepeatedField(f("repeated_float" )
, 1)); | |
| 2749 Assert.assertEquals(512D , message.getRepeatedField(f("repeated_double" )
, 1)); | |
| 2750 Assert.assertEquals(true , message.getRepeatedField(f("repeated_bool" )
, 1)); | |
| 2751 Assert.assertEquals("515", message.getRepeatedField(f("repeated_string" )
, 1)); | |
| 2752 Assert.assertEquals(toBytes("516"), message.getRepeatedField(f("repeated_b
ytes"), 1)); | |
| 2753 | |
| 2754 Assert.assertEquals(517, | |
| 2755 ((Message)message.getRepeatedField(f("repeatedgroup"), 1)) | |
| 2756 .getField(repeatedGroupA)); | |
| 2757 Assert.assertEquals(518, | |
| 2758 ((Message)message.getRepeatedField(f("repeated_nested_message"), 1)) | |
| 2759 .getField(nestedB)); | |
| 2760 Assert.assertEquals(519, | |
| 2761 ((Message)message.getRepeatedField(f("repeated_foreign_message"), 1)) | |
| 2762 .getField(foreignC)); | |
| 2763 Assert.assertEquals(520, | |
| 2764 ((Message)message.getRepeatedField(f("repeated_import_message"), 1)) | |
| 2765 .getField(importD)); | |
| 2766 Assert.assertEquals(527, | |
| 2767 ((Message)message.getRepeatedField(f("repeated_lazy_message"), 1)) | |
| 2768 .getField(nestedB)); | |
| 2769 | |
| 2770 Assert.assertEquals( nestedFoo, message.getRepeatedField(f("repeated_neste
d_enum" ),1)); | |
| 2771 Assert.assertEquals(foreignFoo, message.getRepeatedField(f("repeated_forei
gn_enum"),1)); | |
| 2772 Assert.assertEquals( importFoo, message.getRepeatedField(f("repeated_impor
t_enum" ),1)); | |
| 2773 | |
| 2774 Assert.assertEquals("524", message.getRepeatedField(f("repeated_string_pie
ce"), 1)); | |
| 2775 Assert.assertEquals("525", message.getRepeatedField(f("repeated_cord"), 1)
); | |
| 2776 } | |
| 2777 | |
| 2778 public void setPackedFieldsViaReflection(Message.Builder message) { | |
| 2779 message.addRepeatedField(f("packed_int32" ), 601 ); | |
| 2780 message.addRepeatedField(f("packed_int64" ), 602L); | |
| 2781 message.addRepeatedField(f("packed_uint32" ), 603 ); | |
| 2782 message.addRepeatedField(f("packed_uint64" ), 604L); | |
| 2783 message.addRepeatedField(f("packed_sint32" ), 605 ); | |
| 2784 message.addRepeatedField(f("packed_sint64" ), 606L); | |
| 2785 message.addRepeatedField(f("packed_fixed32" ), 607 ); | |
| 2786 message.addRepeatedField(f("packed_fixed64" ), 608L); | |
| 2787 message.addRepeatedField(f("packed_sfixed32"), 609 ); | |
| 2788 message.addRepeatedField(f("packed_sfixed64"), 610L); | |
| 2789 message.addRepeatedField(f("packed_float" ), 611F); | |
| 2790 message.addRepeatedField(f("packed_double" ), 612D); | |
| 2791 message.addRepeatedField(f("packed_bool" ), true); | |
| 2792 message.addRepeatedField(f("packed_enum" ), foreignBar); | |
| 2793 // Add a second one of each field. | |
| 2794 message.addRepeatedField(f("packed_int32" ), 701 ); | |
| 2795 message.addRepeatedField(f("packed_int64" ), 702L); | |
| 2796 message.addRepeatedField(f("packed_uint32" ), 703 ); | |
| 2797 message.addRepeatedField(f("packed_uint64" ), 704L); | |
| 2798 message.addRepeatedField(f("packed_sint32" ), 705 ); | |
| 2799 message.addRepeatedField(f("packed_sint64" ), 706L); | |
| 2800 message.addRepeatedField(f("packed_fixed32" ), 707 ); | |
| 2801 message.addRepeatedField(f("packed_fixed64" ), 708L); | |
| 2802 message.addRepeatedField(f("packed_sfixed32"), 709 ); | |
| 2803 message.addRepeatedField(f("packed_sfixed64"), 710L); | |
| 2804 message.addRepeatedField(f("packed_float" ), 711F); | |
| 2805 message.addRepeatedField(f("packed_double" ), 712D); | |
| 2806 message.addRepeatedField(f("packed_bool" ), false); | |
| 2807 message.addRepeatedField(f("packed_enum" ), foreignBaz); | |
| 2808 } | |
| 2809 | |
| 2810 public void assertPackedFieldsSetViaReflection(MessageOrBuilder message) { | |
| 2811 Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_int32" ))
); | |
| 2812 Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_int64" ))
); | |
| 2813 Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_uint32" ))
); | |
| 2814 Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_uint64" ))
); | |
| 2815 Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sint32" ))
); | |
| 2816 Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sint64" ))
); | |
| 2817 Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_fixed32" ))
); | |
| 2818 Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_fixed64" ))
); | |
| 2819 Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sfixed32"))
); | |
| 2820 Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_sfixed64"))
); | |
| 2821 Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_float" ))
); | |
| 2822 Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_double" ))
); | |
| 2823 Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_bool" ))
); | |
| 2824 Assert.assertEquals(2, message.getRepeatedFieldCount(f("packed_enum" )))
; | |
| 2825 Assert.assertEquals(601 , message.getRepeatedField(f("packed_int32" ),
0)); | |
| 2826 Assert.assertEquals(602L , message.getRepeatedField(f("packed_int64" ),
0)); | |
| 2827 Assert.assertEquals(603 , message.getRepeatedField(f("packed_uint32" ),
0)); | |
| 2828 Assert.assertEquals(604L , message.getRepeatedField(f("packed_uint64" ),
0)); | |
| 2829 Assert.assertEquals(605 , message.getRepeatedField(f("packed_sint32" ),
0)); | |
| 2830 Assert.assertEquals(606L , message.getRepeatedField(f("packed_sint64" ),
0)); | |
| 2831 Assert.assertEquals(607 , message.getRepeatedField(f("packed_fixed32" ),
0)); | |
| 2832 Assert.assertEquals(608L , message.getRepeatedField(f("packed_fixed64" ),
0)); | |
| 2833 Assert.assertEquals(609 , message.getRepeatedField(f("packed_sfixed32"),
0)); | |
| 2834 Assert.assertEquals(610L , message.getRepeatedField(f("packed_sfixed64"),
0)); | |
| 2835 Assert.assertEquals(611F , message.getRepeatedField(f("packed_float" ),
0)); | |
| 2836 Assert.assertEquals(612D , message.getRepeatedField(f("packed_double" ),
0)); | |
| 2837 Assert.assertEquals(true , message.getRepeatedField(f("packed_bool" ),
0)); | |
| 2838 Assert.assertEquals(foreignBar, message.getRepeatedField(f("packed_enum" )
,0)); | |
| 2839 Assert.assertEquals(701 , message.getRepeatedField(f("packed_int32" ),
1)); | |
| 2840 Assert.assertEquals(702L , message.getRepeatedField(f("packed_int64" ),
1)); | |
| 2841 Assert.assertEquals(703 , message.getRepeatedField(f("packed_uint32" ),
1)); | |
| 2842 Assert.assertEquals(704L , message.getRepeatedField(f("packed_uint64" ),
1)); | |
| 2843 Assert.assertEquals(705 , message.getRepeatedField(f("packed_sint32" ),
1)); | |
| 2844 Assert.assertEquals(706L , message.getRepeatedField(f("packed_sint64" ),
1)); | |
| 2845 Assert.assertEquals(707 , message.getRepeatedField(f("packed_fixed32" ),
1)); | |
| 2846 Assert.assertEquals(708L , message.getRepeatedField(f("packed_fixed64" ),
1)); | |
| 2847 Assert.assertEquals(709 , message.getRepeatedField(f("packed_sfixed32"),
1)); | |
| 2848 Assert.assertEquals(710L , message.getRepeatedField(f("packed_sfixed64"),
1)); | |
| 2849 Assert.assertEquals(711F , message.getRepeatedField(f("packed_float" ),
1)); | |
| 2850 Assert.assertEquals(712D , message.getRepeatedField(f("packed_double" ),
1)); | |
| 2851 Assert.assertEquals(false, message.getRepeatedField(f("packed_bool" ),
1)); | |
| 2852 Assert.assertEquals(foreignBaz, message.getRepeatedField(f("packed_enum" )
,1)); | |
| 2853 } | |
| 2854 | |
| 2855 /** | |
| 2856 * Verifies that the reflection setters for the given.Builder object throw a | |
| 2857 * NullPointerException if they are passed a null value. Uses Assert to thr
ow an | |
| 2858 * appropriate assertion failure, if the condition is not verified. | |
| 2859 */ | |
| 2860 public void assertReflectionSettersRejectNull(Message.Builder builder) | |
| 2861 throws Exception { | |
| 2862 try { | |
| 2863 builder.setField(f("optional_string"), null); | |
| 2864 Assert.fail("Exception was not thrown"); | |
| 2865 } catch (NullPointerException e) { | |
| 2866 // We expect this exception. | |
| 2867 } | |
| 2868 try { | |
| 2869 builder.setField(f("optional_bytes"), null); | |
| 2870 Assert.fail("Exception was not thrown"); | |
| 2871 } catch (NullPointerException e) { | |
| 2872 // We expect this exception. | |
| 2873 } | |
| 2874 try { | |
| 2875 builder.setField(f("optional_nested_enum"), null); | |
| 2876 Assert.fail("Exception was not thrown"); | |
| 2877 } catch (NullPointerException e) { | |
| 2878 // We expect this exception. | |
| 2879 } | |
| 2880 try { | |
| 2881 builder.setField(f("optional_nested_message"), | |
| 2882 (TestAllTypes.NestedMessage) null); | |
| 2883 Assert.fail("Exception was not thrown"); | |
| 2884 } catch (NullPointerException e) { | |
| 2885 // We expect this exception. | |
| 2886 } | |
| 2887 try { | |
| 2888 builder.setField(f("optional_nested_message"), | |
| 2889 (TestAllTypes.NestedMessage.Builder) null); | |
| 2890 Assert.fail("Exception was not thrown"); | |
| 2891 } catch (NullPointerException e) { | |
| 2892 // We expect this exception. | |
| 2893 } | |
| 2894 | |
| 2895 try { | |
| 2896 builder.addRepeatedField(f("repeated_string"), null); | |
| 2897 Assert.fail("Exception was not thrown"); | |
| 2898 } catch (NullPointerException e) { | |
| 2899 // We expect this exception. | |
| 2900 } | |
| 2901 try { | |
| 2902 builder.addRepeatedField(f("repeated_bytes"), null); | |
| 2903 Assert.fail("Exception was not thrown"); | |
| 2904 } catch (NullPointerException e) { | |
| 2905 // We expect this exception. | |
| 2906 } | |
| 2907 try { | |
| 2908 builder.addRepeatedField(f("repeated_nested_enum"), null); | |
| 2909 Assert.fail("Exception was not thrown"); | |
| 2910 } catch (NullPointerException e) { | |
| 2911 // We expect this exception. | |
| 2912 } | |
| 2913 try { | |
| 2914 builder.addRepeatedField(f("repeated_nested_message"), null); | |
| 2915 Assert.fail("Exception was not thrown"); | |
| 2916 } catch (NullPointerException e) { | |
| 2917 // We expect this exception. | |
| 2918 } | |
| 2919 } | |
| 2920 | |
| 2921 /** | |
| 2922 * Verifies that the reflection repeated setters for the given Builder objec
t throw a | |
| 2923 * NullPointerException if they are passed a null value. Uses Assert to thr
ow an appropriate | |
| 2924 * assertion failure, if the condition is not verified. | |
| 2925 */ | |
| 2926 public void assertReflectionRepeatedSettersRejectNull(Message.Builder builde
r) | |
| 2927 throws Exception { | |
| 2928 builder.addRepeatedField(f("repeated_string"), "one"); | |
| 2929 try { | |
| 2930 builder.setRepeatedField(f("repeated_string"), 0, null); | |
| 2931 Assert.fail("Exception was not thrown"); | |
| 2932 } catch (NullPointerException e) { | |
| 2933 // We expect this exception. | |
| 2934 } | |
| 2935 | |
| 2936 builder.addRepeatedField(f("repeated_bytes"), toBytes("one")); | |
| 2937 try { | |
| 2938 builder.setRepeatedField(f("repeated_bytes"), 0, null); | |
| 2939 Assert.fail("Exception was not thrown"); | |
| 2940 } catch (NullPointerException e) { | |
| 2941 // We expect this exception. | |
| 2942 } | |
| 2943 | |
| 2944 builder.addRepeatedField(f("repeated_nested_enum"), nestedBaz); | |
| 2945 try { | |
| 2946 builder.setRepeatedField(f("repeated_nested_enum"), 0, null); | |
| 2947 Assert.fail("Exception was not thrown"); | |
| 2948 } catch (NullPointerException e) { | |
| 2949 // We expect this exception. | |
| 2950 } | |
| 2951 | |
| 2952 builder.addRepeatedField( | |
| 2953 f("repeated_nested_message"), | |
| 2954 TestAllTypes.NestedMessage.newBuilder().setBb(218).build()); | |
| 2955 try { | |
| 2956 builder.setRepeatedField(f("repeated_nested_message"), 0, null); | |
| 2957 Assert.fail("Exception was not thrown"); | |
| 2958 } catch (NullPointerException e) { | |
| 2959 // We expect this exception. | |
| 2960 } | |
| 2961 } | |
| 2962 } | |
| 2963 | |
| 2964 /** | |
| 2965 * @param filePath The path relative to | |
| 2966 * {@link #getTestDataDir}. | |
| 2967 */ | |
| 2968 public static String readTextFromFile(String filePath) { | |
| 2969 return readBytesFromFile(filePath).toStringUtf8(); | |
| 2970 } | |
| 2971 | |
| 2972 private static File getTestDataDir() { | |
| 2973 // Search each parent directory looking for "src/google/protobuf". | |
| 2974 File ancestor = new File("."); | |
| 2975 try { | |
| 2976 ancestor = ancestor.getCanonicalFile(); | |
| 2977 } catch (IOException e) { | |
| 2978 throw new RuntimeException( | |
| 2979 "Couldn't get canonical name of working directory.", e); | |
| 2980 } | |
| 2981 while (ancestor != null && ancestor.exists()) { | |
| 2982 if (new File(ancestor, "src/google/protobuf").exists()) { | |
| 2983 return new File(ancestor, "src/google/protobuf/testdata"); | |
| 2984 } | |
| 2985 ancestor = ancestor.getParentFile(); | |
| 2986 } | |
| 2987 | |
| 2988 throw new RuntimeException( | |
| 2989 "Could not find golden files. This test must be run from within the " + | |
| 2990 "protobuf source package so that it can read test data files from the " + | |
| 2991 "C++ source tree: " + new File(".").getAbsolutePath()); | |
| 2992 } | |
| 2993 | |
| 2994 /** | |
| 2995 * @param filename The path relative to | |
| 2996 * {@link #getTestDataDir}. | |
| 2997 */ | |
| 2998 public static ByteString readBytesFromFile(String filename) { | |
| 2999 File fullPath = new File(getTestDataDir(), filename); | |
| 3000 try { | |
| 3001 RandomAccessFile file = new RandomAccessFile(fullPath, "r"); | |
| 3002 byte[] content = new byte[(int) file.length()]; | |
| 3003 file.readFully(content); | |
| 3004 return ByteString.copyFrom(content); | |
| 3005 } catch (IOException e) { | |
| 3006 // Throw a RuntimeException here so that we can call this function from | |
| 3007 // static initializers. | |
| 3008 throw new IllegalArgumentException( | |
| 3009 "Couldn't read file: " + fullPath.getPath(), e); | |
| 3010 } | |
| 3011 } | |
| 3012 | |
| 3013 /** | |
| 3014 * Get the bytes of the "golden message". This is a serialized TestAllTypes | |
| 3015 * with all fields set as they would be by | |
| 3016 * {@link #setAllFields(TestAllTypes.Builder)}, but it is loaded from a file | |
| 3017 * on disk rather than generated dynamically. The file is actually generated | |
| 3018 * by C++ code, so testing against it verifies compatibility with C++. | |
| 3019 */ | |
| 3020 public static ByteString getGoldenMessage() { | |
| 3021 if (goldenMessage == null) { | |
| 3022 goldenMessage = readBytesFromFile("golden_message"); | |
| 3023 } | |
| 3024 return goldenMessage; | |
| 3025 } | |
| 3026 private static ByteString goldenMessage = null; | |
| 3027 | |
| 3028 /** | |
| 3029 * Get the bytes of the "golden packed fields message". This is a serialized | |
| 3030 * TestPackedTypes with all fields set as they would be by | |
| 3031 * {@link #setPackedFields(TestPackedTypes.Builder)}, but it is loaded from a | |
| 3032 * file on disk rather than generated dynamically. The file is actually | |
| 3033 * generated by C++ code, so testing against it verifies compatibility with | |
| 3034 * C++. | |
| 3035 */ | |
| 3036 public static ByteString getGoldenPackedFieldsMessage() { | |
| 3037 if (goldenPackedFieldsMessage == null) { | |
| 3038 goldenPackedFieldsMessage = | |
| 3039 readBytesFromFile("golden_packed_fields_message"); | |
| 3040 } | |
| 3041 return goldenPackedFieldsMessage; | |
| 3042 } | |
| 3043 private static ByteString goldenPackedFieldsMessage = null; | |
| 3044 | |
| 3045 public static abstract class HackMessage extends GeneratedMessage { | |
| 3046 public interface MyInterface extends BuilderParent { | |
| 3047 } | |
| 3048 } | |
| 3049 /** | |
| 3050 * Mock implementation of {@link GeneratedMessage.BuilderParent} for testing. | |
| 3051 * | |
| 3052 * @author jonp@google.com (Jon Perlow) | |
| 3053 */ | |
| 3054 public static class MockBuilderParent | |
| 3055 implements HackMessage.MyInterface { | |
| 3056 | |
| 3057 private int invalidations; | |
| 3058 | |
| 3059 //@Override (Java 1.6 override semantics, but we must support 1.5) | |
| 3060 public void markDirty() { | |
| 3061 invalidations++; | |
| 3062 } | |
| 3063 | |
| 3064 public int getInvalidationCount() { | |
| 3065 return invalidations; | |
| 3066 } | |
| 3067 } | |
| 3068 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2590803003:
Revert "third_party/protobuf: Update to HEAD (83d681ee2c)" (Closed)
