| 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.TestAllTypes; | |
| 35 import protobuf_unittest.UnittestProto.TestAllExtensions; | |
| 36 import protobuf_unittest.UnittestProto.TestRequired; | |
| 37 import protobuf_unittest.UnittestProto.TestRequiredForeign; | |
| 38 import protobuf_unittest.UnittestProto.ForeignMessage; | |
| 39 | |
| 40 import junit.framework.TestCase; | |
| 41 | |
| 42 import java.util.List; | |
| 43 | |
| 44 /** | |
| 45 * Misc. unit tests for message operations that apply to both generated | |
| 46 * and dynamic messages. | |
| 47 * | |
| 48 * @author kenton@google.com Kenton Varda | |
| 49 */ | |
| 50 public class MessageTest extends TestCase { | |
| 51 // ================================================================= | |
| 52 // Message-merging tests. | |
| 53 | |
| 54 static final TestAllTypes MERGE_SOURCE = | |
| 55 TestAllTypes.newBuilder() | |
| 56 .setOptionalInt32(1) | |
| 57 .setOptionalString("foo") | |
| 58 .setOptionalForeignMessage(ForeignMessage.getDefaultInstance()) | |
| 59 .addRepeatedString("bar") | |
| 60 .build(); | |
| 61 | |
| 62 static final TestAllTypes MERGE_DEST = | |
| 63 TestAllTypes.newBuilder() | |
| 64 .setOptionalInt64(2) | |
| 65 .setOptionalString("baz") | |
| 66 .setOptionalForeignMessage(ForeignMessage.newBuilder().setC(3).build()) | |
| 67 .addRepeatedString("qux") | |
| 68 .build(); | |
| 69 | |
| 70 static final String MERGE_RESULT_TEXT = | |
| 71 "optional_int32: 1\n" + | |
| 72 "optional_int64: 2\n" + | |
| 73 "optional_string: \"foo\"\n" + | |
| 74 "optional_foreign_message {\n" + | |
| 75 " c: 3\n" + | |
| 76 "}\n" + | |
| 77 "repeated_string: \"qux\"\n" + | |
| 78 "repeated_string: \"bar\"\n"; | |
| 79 | |
| 80 public void testMergeFrom() throws Exception { | |
| 81 TestAllTypes result = | |
| 82 TestAllTypes.newBuilder(MERGE_DEST) | |
| 83 .mergeFrom(MERGE_SOURCE).build(); | |
| 84 | |
| 85 assertEquals(MERGE_RESULT_TEXT, result.toString()); | |
| 86 } | |
| 87 | |
| 88 /** | |
| 89 * Test merging a DynamicMessage into a GeneratedMessage. As long as they | |
| 90 * have the same descriptor, this should work, but it is an entirely different | |
| 91 * code path. | |
| 92 */ | |
| 93 public void testMergeFromDynamic() throws Exception { | |
| 94 TestAllTypes result = | |
| 95 TestAllTypes.newBuilder(MERGE_DEST) | |
| 96 .mergeFrom(DynamicMessage.newBuilder(MERGE_SOURCE).build()) | |
| 97 .build(); | |
| 98 | |
| 99 assertEquals(MERGE_RESULT_TEXT, result.toString()); | |
| 100 } | |
| 101 | |
| 102 /** Test merging two DynamicMessages. */ | |
| 103 public void testDynamicMergeFrom() throws Exception { | |
| 104 DynamicMessage result = | |
| 105 DynamicMessage.newBuilder(MERGE_DEST) | |
| 106 .mergeFrom(DynamicMessage.newBuilder(MERGE_SOURCE).build()) | |
| 107 .build(); | |
| 108 | |
| 109 assertEquals(MERGE_RESULT_TEXT, result.toString()); | |
| 110 } | |
| 111 | |
| 112 // ================================================================= | |
| 113 // Required-field-related tests. | |
| 114 | |
| 115 private static final TestRequired TEST_REQUIRED_UNINITIALIZED = | |
| 116 TestRequired.getDefaultInstance(); | |
| 117 private static final TestRequired TEST_REQUIRED_INITIALIZED = | |
| 118 TestRequired.newBuilder().setA(1).setB(2).setC(3).build(); | |
| 119 | |
| 120 public void testRequired() throws Exception { | |
| 121 TestRequired.Builder builder = TestRequired.newBuilder(); | |
| 122 | |
| 123 assertFalse(builder.isInitialized()); | |
| 124 builder.setA(1); | |
| 125 assertFalse(builder.isInitialized()); | |
| 126 builder.setB(1); | |
| 127 assertFalse(builder.isInitialized()); | |
| 128 builder.setC(1); | |
| 129 assertTrue(builder.isInitialized()); | |
| 130 } | |
| 131 | |
| 132 public void testRequiredForeign() throws Exception { | |
| 133 TestRequiredForeign.Builder builder = TestRequiredForeign.newBuilder(); | |
| 134 | |
| 135 assertTrue(builder.isInitialized()); | |
| 136 | |
| 137 builder.setOptionalMessage(TEST_REQUIRED_UNINITIALIZED); | |
| 138 assertFalse(builder.isInitialized()); | |
| 139 | |
| 140 builder.setOptionalMessage(TEST_REQUIRED_INITIALIZED); | |
| 141 assertTrue(builder.isInitialized()); | |
| 142 | |
| 143 builder.addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED); | |
| 144 assertFalse(builder.isInitialized()); | |
| 145 | |
| 146 builder.setRepeatedMessage(0, TEST_REQUIRED_INITIALIZED); | |
| 147 assertTrue(builder.isInitialized()); | |
| 148 } | |
| 149 | |
| 150 public void testRequiredExtension() throws Exception { | |
| 151 TestAllExtensions.Builder builder = TestAllExtensions.newBuilder(); | |
| 152 | |
| 153 assertTrue(builder.isInitialized()); | |
| 154 | |
| 155 builder.setExtension(TestRequired.single, TEST_REQUIRED_UNINITIALIZED); | |
| 156 assertFalse(builder.isInitialized()); | |
| 157 | |
| 158 builder.setExtension(TestRequired.single, TEST_REQUIRED_INITIALIZED); | |
| 159 assertTrue(builder.isInitialized()); | |
| 160 | |
| 161 builder.addExtension(TestRequired.multi, TEST_REQUIRED_UNINITIALIZED); | |
| 162 assertFalse(builder.isInitialized()); | |
| 163 | |
| 164 builder.setExtension(TestRequired.multi, 0, TEST_REQUIRED_INITIALIZED); | |
| 165 assertTrue(builder.isInitialized()); | |
| 166 } | |
| 167 | |
| 168 public void testRequiredDynamic() throws Exception { | |
| 169 Descriptors.Descriptor descriptor = TestRequired.getDescriptor(); | |
| 170 DynamicMessage.Builder builder = DynamicMessage.newBuilder(descriptor); | |
| 171 | |
| 172 assertFalse(builder.isInitialized()); | |
| 173 builder.setField(descriptor.findFieldByName("a"), 1); | |
| 174 assertFalse(builder.isInitialized()); | |
| 175 builder.setField(descriptor.findFieldByName("b"), 1); | |
| 176 assertFalse(builder.isInitialized()); | |
| 177 builder.setField(descriptor.findFieldByName("c"), 1); | |
| 178 assertTrue(builder.isInitialized()); | |
| 179 } | |
| 180 | |
| 181 public void testRequiredDynamicForeign() throws Exception { | |
| 182 Descriptors.Descriptor descriptor = TestRequiredForeign.getDescriptor(); | |
| 183 DynamicMessage.Builder builder = DynamicMessage.newBuilder(descriptor); | |
| 184 | |
| 185 assertTrue(builder.isInitialized()); | |
| 186 | |
| 187 builder.setField(descriptor.findFieldByName("optional_message"), | |
| 188 TEST_REQUIRED_UNINITIALIZED); | |
| 189 assertFalse(builder.isInitialized()); | |
| 190 | |
| 191 builder.setField(descriptor.findFieldByName("optional_message"), | |
| 192 TEST_REQUIRED_INITIALIZED); | |
| 193 assertTrue(builder.isInitialized()); | |
| 194 | |
| 195 builder.addRepeatedField(descriptor.findFieldByName("repeated_message"), | |
| 196 TEST_REQUIRED_UNINITIALIZED); | |
| 197 assertFalse(builder.isInitialized()); | |
| 198 | |
| 199 builder.setRepeatedField(descriptor.findFieldByName("repeated_message"), 0, | |
| 200 TEST_REQUIRED_INITIALIZED); | |
| 201 assertTrue(builder.isInitialized()); | |
| 202 } | |
| 203 | |
| 204 public void testUninitializedException() throws Exception { | |
| 205 try { | |
| 206 TestRequired.newBuilder().build(); | |
| 207 fail("Should have thrown an exception."); | |
| 208 } catch (UninitializedMessageException e) { | |
| 209 assertEquals("Message missing required fields: a, b, c", e.getMessage()); | |
| 210 } | |
| 211 } | |
| 212 | |
| 213 public void testBuildPartial() throws Exception { | |
| 214 // We're mostly testing that no exception is thrown. | |
| 215 TestRequired message = TestRequired.newBuilder().buildPartial(); | |
| 216 assertFalse(message.isInitialized()); | |
| 217 } | |
| 218 | |
| 219 public void testNestedUninitializedException() throws Exception { | |
| 220 try { | |
| 221 TestRequiredForeign.newBuilder() | |
| 222 .setOptionalMessage(TEST_REQUIRED_UNINITIALIZED) | |
| 223 .addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED) | |
| 224 .addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED) | |
| 225 .build(); | |
| 226 fail("Should have thrown an exception."); | |
| 227 } catch (UninitializedMessageException e) { | |
| 228 assertEquals( | |
| 229 "Message missing required fields: " + | |
| 230 "optional_message.a, " + | |
| 231 "optional_message.b, " + | |
| 232 "optional_message.c, " + | |
| 233 "repeated_message[0].a, " + | |
| 234 "repeated_message[0].b, " + | |
| 235 "repeated_message[0].c, " + | |
| 236 "repeated_message[1].a, " + | |
| 237 "repeated_message[1].b, " + | |
| 238 "repeated_message[1].c", | |
| 239 e.getMessage()); | |
| 240 } | |
| 241 } | |
| 242 | |
| 243 public void testBuildNestedPartial() throws Exception { | |
| 244 // We're mostly testing that no exception is thrown. | |
| 245 TestRequiredForeign message = | |
| 246 TestRequiredForeign.newBuilder() | |
| 247 .setOptionalMessage(TEST_REQUIRED_UNINITIALIZED) | |
| 248 .addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED) | |
| 249 .addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED) | |
| 250 .buildPartial(); | |
| 251 assertFalse(message.isInitialized()); | |
| 252 } | |
| 253 | |
| 254 public void testParseUnititialized() throws Exception { | |
| 255 try { | |
| 256 TestRequired.parseFrom(ByteString.EMPTY); | |
| 257 fail("Should have thrown an exception."); | |
| 258 } catch (InvalidProtocolBufferException e) { | |
| 259 assertEquals("Message missing required fields: a, b, c", e.getMessage()); | |
| 260 } | |
| 261 } | |
| 262 | |
| 263 public void testParseNestedUnititialized() throws Exception { | |
| 264 ByteString data = | |
| 265 TestRequiredForeign.newBuilder() | |
| 266 .setOptionalMessage(TEST_REQUIRED_UNINITIALIZED) | |
| 267 .addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED) | |
| 268 .addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED) | |
| 269 .buildPartial().toByteString(); | |
| 270 | |
| 271 try { | |
| 272 TestRequiredForeign.parseFrom(data); | |
| 273 fail("Should have thrown an exception."); | |
| 274 } catch (InvalidProtocolBufferException e) { | |
| 275 assertEquals( | |
| 276 "Message missing required fields: " + | |
| 277 "optional_message.a, " + | |
| 278 "optional_message.b, " + | |
| 279 "optional_message.c, " + | |
| 280 "repeated_message[0].a, " + | |
| 281 "repeated_message[0].b, " + | |
| 282 "repeated_message[0].c, " + | |
| 283 "repeated_message[1].a, " + | |
| 284 "repeated_message[1].b, " + | |
| 285 "repeated_message[1].c", | |
| 286 e.getMessage()); | |
| 287 } | |
| 288 } | |
| 289 | |
| 290 public void testDynamicUninitializedException() throws Exception { | |
| 291 try { | |
| 292 DynamicMessage.newBuilder(TestRequired.getDescriptor()).build(); | |
| 293 fail("Should have thrown an exception."); | |
| 294 } catch (UninitializedMessageException e) { | |
| 295 assertEquals("Message missing required fields: a, b, c", e.getMessage()); | |
| 296 } | |
| 297 } | |
| 298 | |
| 299 public void testDynamicBuildPartial() throws Exception { | |
| 300 // We're mostly testing that no exception is thrown. | |
| 301 DynamicMessage message = | |
| 302 DynamicMessage.newBuilder(TestRequired.getDescriptor()) | |
| 303 .buildPartial(); | |
| 304 assertFalse(message.isInitialized()); | |
| 305 } | |
| 306 | |
| 307 public void testDynamicParseUnititialized() throws Exception { | |
| 308 try { | |
| 309 Descriptors.Descriptor descriptor = TestRequired.getDescriptor(); | |
| 310 DynamicMessage.parseFrom(descriptor, ByteString.EMPTY); | |
| 311 fail("Should have thrown an exception."); | |
| 312 } catch (InvalidProtocolBufferException e) { | |
| 313 assertEquals("Message missing required fields: a, b, c", e.getMessage()); | |
| 314 } | |
| 315 } | |
| 316 | |
| 317 /** Test reading unset repeated message from DynamicMessage. */ | |
| 318 public void testDynamicRepeatedMessageNull() throws Exception { | |
| 319 Descriptors.Descriptor descriptor = TestRequired.getDescriptor(); | |
| 320 DynamicMessage result = | |
| 321 DynamicMessage.newBuilder(TestAllTypes.getDescriptor()) | |
| 322 .mergeFrom(DynamicMessage.newBuilder(MERGE_SOURCE).build()) | |
| 323 .build(); | |
| 324 | |
| 325 assertTrue(result.getField(result.getDescriptorForType() | |
| 326 .findFieldByName("repeated_foreign_message")) instanceof List<?>); | |
| 327 assertEquals(result.getRepeatedFieldCount(result.getDescriptorForType() | |
| 328 .findFieldByName("repeated_foreign_message")), 0); | |
| 329 } | |
| 330 | |
| 331 /** Test reading repeated message from DynamicMessage. */ | |
| 332 public void testDynamicRepeatedMessageNotNull() throws Exception { | |
| 333 | |
| 334 TestAllTypes REPEATED_NESTED = | |
| 335 TestAllTypes.newBuilder() | |
| 336 .setOptionalInt32(1) | |
| 337 .setOptionalString("foo") | |
| 338 .setOptionalForeignMessage(ForeignMessage.getDefaultInstance()) | |
| 339 .addRepeatedString("bar") | |
| 340 .addRepeatedForeignMessage(ForeignMessage.getDefaultInstance()) | |
| 341 .addRepeatedForeignMessage(ForeignMessage.getDefaultInstance()) | |
| 342 .build(); | |
| 343 Descriptors.Descriptor descriptor = TestRequired.getDescriptor(); | |
| 344 DynamicMessage result = | |
| 345 DynamicMessage.newBuilder(TestAllTypes.getDescriptor()) | |
| 346 .mergeFrom(DynamicMessage.newBuilder(REPEATED_NESTED).build()) | |
| 347 .build(); | |
| 348 | |
| 349 assertTrue(result.getField(result.getDescriptorForType() | |
| 350 .findFieldByName("repeated_foreign_message")) instanceof List<?>); | |
| 351 assertEquals(result.getRepeatedFieldCount(result.getDescriptorForType() | |
| 352 .findFieldByName("repeated_foreign_message")), 2); | |
| 353 } | |
| 354 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2600753002:
Reverts third_party/protobuf: Update to HEAD (f52e188fe4) (Closed)
