| 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 junit.framework.TestCase; | |
| 35 | |
| 36 import java.io.ByteArrayInputStream; | |
| 37 import java.io.ByteArrayOutputStream; | |
| 38 import java.util.List; | |
| 39 | |
| 40 import protobuf_unittest.UnittestProto; | |
| 41 import protobuf_unittest.UnittestProto.TestAllExtensions; | |
| 42 import protobuf_unittest.UnittestProto.TestAllTypes; | |
| 43 import protobuf_unittest.UnittestProto.TestFieldOrderings; | |
| 44 import protobuf_unittest.UnittestProto.TestPackedExtensions; | |
| 45 import protobuf_unittest.UnittestProto.TestPackedTypes; | |
| 46 import protobuf_unittest.UnittestMset.TestMessageSet; | |
| 47 import protobuf_unittest.UnittestMset.RawMessageSet; | |
| 48 import protobuf_unittest.UnittestMset.TestMessageSetExtension1; | |
| 49 import protobuf_unittest.UnittestMset.TestMessageSetExtension2; | |
| 50 | |
| 51 /** | |
| 52 * Tests related to parsing and serialization. | |
| 53 * | |
| 54 * @author kenton@google.com (Kenton Varda) | |
| 55 */ | |
| 56 public class WireFormatTest extends TestCase { | |
| 57 public void testSerialization() throws Exception { | |
| 58 TestAllTypes message = TestUtil.getAllSet(); | |
| 59 | |
| 60 ByteString rawBytes = message.toByteString(); | |
| 61 assertEquals(rawBytes.size(), message.getSerializedSize()); | |
| 62 | |
| 63 TestAllTypes message2 = TestAllTypes.parseFrom(rawBytes); | |
| 64 | |
| 65 TestUtil.assertAllFieldsSet(message2); | |
| 66 } | |
| 67 | |
| 68 public void testSerializationPacked() throws Exception { | |
| 69 TestPackedTypes message = TestUtil.getPackedSet(); | |
| 70 | |
| 71 ByteString rawBytes = message.toByteString(); | |
| 72 assertEquals(rawBytes.size(), message.getSerializedSize()); | |
| 73 | |
| 74 TestPackedTypes message2 = TestPackedTypes.parseFrom(rawBytes); | |
| 75 | |
| 76 TestUtil.assertPackedFieldsSet(message2); | |
| 77 } | |
| 78 | |
| 79 public void testSerializeExtensions() throws Exception { | |
| 80 // TestAllTypes and TestAllExtensions should have compatible wire formats, | |
| 81 // so if we serialize a TestAllExtensions then parse it as TestAllTypes | |
| 82 // it should work. | |
| 83 | |
| 84 TestAllExtensions message = TestUtil.getAllExtensionsSet(); | |
| 85 ByteString rawBytes = message.toByteString(); | |
| 86 assertEquals(rawBytes.size(), message.getSerializedSize()); | |
| 87 | |
| 88 TestAllTypes message2 = TestAllTypes.parseFrom(rawBytes); | |
| 89 | |
| 90 TestUtil.assertAllFieldsSet(message2); | |
| 91 } | |
| 92 | |
| 93 public void testSerializePackedExtensions() throws Exception { | |
| 94 // TestPackedTypes and TestPackedExtensions should have compatible wire | |
| 95 // formats; check that they serialize to the same string. | |
| 96 TestPackedExtensions message = TestUtil.getPackedExtensionsSet(); | |
| 97 ByteString rawBytes = message.toByteString(); | |
| 98 | |
| 99 TestPackedTypes message2 = TestUtil.getPackedSet(); | |
| 100 ByteString rawBytes2 = message2.toByteString(); | |
| 101 | |
| 102 assertEquals(rawBytes, rawBytes2); | |
| 103 } | |
| 104 | |
| 105 public void testSerializationPackedWithoutGetSerializedSize() | |
| 106 throws Exception { | |
| 107 // Write directly to an OutputStream, without invoking getSerializedSize() | |
| 108 // This used to be a bug where the size of a packed field was incorrect, | |
| 109 // since getSerializedSize() was never invoked. | |
| 110 TestPackedTypes message = TestUtil.getPackedSet(); | |
| 111 | |
| 112 // Directly construct a CodedOutputStream around the actual OutputStream, | |
| 113 // in case writeTo(OutputStream output) invokes getSerializedSize(); | |
| 114 ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); | |
| 115 CodedOutputStream codedOutput = CodedOutputStream.newInstance(outputStream); | |
| 116 | |
| 117 message.writeTo(codedOutput); | |
| 118 | |
| 119 codedOutput.flush(); | |
| 120 | |
| 121 TestPackedTypes message2 = TestPackedTypes.parseFrom( | |
| 122 outputStream.toByteArray()); | |
| 123 | |
| 124 TestUtil.assertPackedFieldsSet(message2); | |
| 125 } | |
| 126 | |
| 127 public void testParseExtensions() throws Exception { | |
| 128 // TestAllTypes and TestAllExtensions should have compatible wire formats, | |
| 129 // so if we serialize a TestAllTypes then parse it as TestAllExtensions | |
| 130 // it should work. | |
| 131 | |
| 132 TestAllTypes message = TestUtil.getAllSet(); | |
| 133 ByteString rawBytes = message.toByteString(); | |
| 134 | |
| 135 ExtensionRegistry registry = TestUtil.getExtensionRegistry(); | |
| 136 | |
| 137 TestAllExtensions message2 = | |
| 138 TestAllExtensions.parseFrom(rawBytes, registry); | |
| 139 | |
| 140 TestUtil.assertAllExtensionsSet(message2); | |
| 141 } | |
| 142 | |
| 143 public void testParsePackedExtensions() throws Exception { | |
| 144 // Ensure that packed extensions can be properly parsed. | |
| 145 TestPackedExtensions message = TestUtil.getPackedExtensionsSet(); | |
| 146 ByteString rawBytes = message.toByteString(); | |
| 147 | |
| 148 ExtensionRegistry registry = TestUtil.getExtensionRegistry(); | |
| 149 | |
| 150 TestPackedExtensions message2 = | |
| 151 TestPackedExtensions.parseFrom(rawBytes, registry); | |
| 152 | |
| 153 TestUtil.assertPackedExtensionsSet(message2); | |
| 154 } | |
| 155 | |
| 156 public void testExtensionsSerializedSize() throws Exception { | |
| 157 assertEquals(TestUtil.getAllSet().getSerializedSize(), | |
| 158 TestUtil.getAllExtensionsSet().getSerializedSize()); | |
| 159 } | |
| 160 | |
| 161 public void testSerializeDelimited() throws Exception { | |
| 162 ByteArrayOutputStream output = new ByteArrayOutputStream(); | |
| 163 TestUtil.getAllSet().writeDelimitedTo(output); | |
| 164 output.write(12); | |
| 165 TestUtil.getPackedSet().writeDelimitedTo(output); | |
| 166 output.write(34); | |
| 167 | |
| 168 ByteArrayInputStream input = new ByteArrayInputStream(output.toByteArray()); | |
| 169 | |
| 170 TestUtil.assertAllFieldsSet(TestAllTypes.parseDelimitedFrom(input)); | |
| 171 assertEquals(12, input.read()); | |
| 172 TestUtil.assertPackedFieldsSet(TestPackedTypes.parseDelimitedFrom(input)); | |
| 173 assertEquals(34, input.read()); | |
| 174 assertEquals(-1, input.read()); | |
| 175 | |
| 176 // We're at EOF, so parsing again should return null. | |
| 177 assertTrue(TestAllTypes.parseDelimitedFrom(input) == null); | |
| 178 } | |
| 179 | |
| 180 private void assertFieldsInOrder(ByteString data) throws Exception { | |
| 181 CodedInputStream input = data.newCodedInput(); | |
| 182 int previousTag = 0; | |
| 183 | |
| 184 while (true) { | |
| 185 int tag = input.readTag(); | |
| 186 if (tag == 0) { | |
| 187 break; | |
| 188 } | |
| 189 | |
| 190 assertTrue(tag > previousTag); | |
| 191 previousTag = tag; | |
| 192 input.skipField(tag); | |
| 193 } | |
| 194 } | |
| 195 | |
| 196 public void testInterleavedFieldsAndExtensions() throws Exception { | |
| 197 // Tests that fields are written in order even when extension ranges | |
| 198 // are interleaved with field numbers. | |
| 199 ByteString data = | |
| 200 TestFieldOrderings.newBuilder() | |
| 201 .setMyInt(1) | |
| 202 .setMyString("foo") | |
| 203 .setMyFloat(1.0F) | |
| 204 .setExtension(UnittestProto.myExtensionInt, 23) | |
| 205 .setExtension(UnittestProto.myExtensionString, "bar") | |
| 206 .build().toByteString(); | |
| 207 assertFieldsInOrder(data); | |
| 208 | |
| 209 Descriptors.Descriptor descriptor = TestFieldOrderings.getDescriptor(); | |
| 210 ByteString dynamic_data = | |
| 211 DynamicMessage.newBuilder(TestFieldOrderings.getDescriptor()) | |
| 212 .setField(descriptor.findFieldByName("my_int"), 1L) | |
| 213 .setField(descriptor.findFieldByName("my_string"), "foo") | |
| 214 .setField(descriptor.findFieldByName("my_float"), 1.0F) | |
| 215 .setField(UnittestProto.myExtensionInt.getDescriptor(), 23) | |
| 216 .setField(UnittestProto.myExtensionString.getDescriptor(), "bar") | |
| 217 .build().toByteString(); | |
| 218 assertFieldsInOrder(dynamic_data); | |
| 219 } | |
| 220 | |
| 221 private ExtensionRegistry getTestFieldOrderingsRegistry() { | |
| 222 ExtensionRegistry result = ExtensionRegistry.newInstance(); | |
| 223 result.add(UnittestProto.myExtensionInt); | |
| 224 result.add(UnittestProto.myExtensionString); | |
| 225 return result; | |
| 226 } | |
| 227 | |
| 228 public void testParseMultipleExtensionRanges() throws Exception { | |
| 229 // Make sure we can parse a message that contains multiple extensions | |
| 230 // ranges. | |
| 231 TestFieldOrderings source = | |
| 232 TestFieldOrderings.newBuilder() | |
| 233 .setMyInt(1) | |
| 234 .setMyString("foo") | |
| 235 .setMyFloat(1.0F) | |
| 236 .setExtension(UnittestProto.myExtensionInt, 23) | |
| 237 .setExtension(UnittestProto.myExtensionString, "bar") | |
| 238 .build(); | |
| 239 TestFieldOrderings dest = | |
| 240 TestFieldOrderings.parseFrom(source.toByteString(), | |
| 241 getTestFieldOrderingsRegistry()); | |
| 242 assertEquals(source, dest); | |
| 243 } | |
| 244 | |
| 245 public void testParseMultipleExtensionRangesDynamic() throws Exception { | |
| 246 // Same as above except with DynamicMessage. | |
| 247 Descriptors.Descriptor descriptor = TestFieldOrderings.getDescriptor(); | |
| 248 DynamicMessage source = | |
| 249 DynamicMessage.newBuilder(TestFieldOrderings.getDescriptor()) | |
| 250 .setField(descriptor.findFieldByName("my_int"), 1L) | |
| 251 .setField(descriptor.findFieldByName("my_string"), "foo") | |
| 252 .setField(descriptor.findFieldByName("my_float"), 1.0F) | |
| 253 .setField(UnittestProto.myExtensionInt.getDescriptor(), 23) | |
| 254 .setField(UnittestProto.myExtensionString.getDescriptor(), "bar") | |
| 255 .build(); | |
| 256 DynamicMessage dest = | |
| 257 DynamicMessage.parseFrom(descriptor, source.toByteString(), | |
| 258 getTestFieldOrderingsRegistry()); | |
| 259 assertEquals(source, dest); | |
| 260 } | |
| 261 | |
| 262 private static final int UNKNOWN_TYPE_ID = 1550055; | |
| 263 private static final int TYPE_ID_1 = | |
| 264 TestMessageSetExtension1.getDescriptor().getExtensions().get(0).getNumber(); | |
| 265 private static final int TYPE_ID_2 = | |
| 266 TestMessageSetExtension2.getDescriptor().getExtensions().get(0).getNumber(); | |
| 267 | |
| 268 public void testSerializeMessageSetEagerly() throws Exception { | |
| 269 testSerializeMessageSetWithFlag(true); | |
| 270 } | |
| 271 | |
| 272 public void testSerializeMessageSetNotEagerly() throws Exception { | |
| 273 testSerializeMessageSetWithFlag(false); | |
| 274 } | |
| 275 | |
| 276 private void testSerializeMessageSetWithFlag(boolean eagerParsing) | |
| 277 throws Exception { | |
| 278 ExtensionRegistryLite.setEagerlyParseMessageSets(eagerParsing); | |
| 279 // Set up a TestMessageSet with two known messages and an unknown one. | |
| 280 TestMessageSet messageSet = | |
| 281 TestMessageSet.newBuilder() | |
| 282 .setExtension( | |
| 283 TestMessageSetExtension1.messageSetExtension, | |
| 284 TestMessageSetExtension1.newBuilder().setI(123).build()) | |
| 285 .setExtension( | |
| 286 TestMessageSetExtension2.messageSetExtension, | |
| 287 TestMessageSetExtension2.newBuilder().setStr("foo").build()) | |
| 288 .setUnknownFields( | |
| 289 UnknownFieldSet.newBuilder() | |
| 290 .addField(UNKNOWN_TYPE_ID, | |
| 291 UnknownFieldSet.Field.newBuilder() | |
| 292 .addLengthDelimited(ByteString.copyFromUtf8("bar")) | |
| 293 .build()) | |
| 294 .build()) | |
| 295 .build(); | |
| 296 | |
| 297 ByteString data = messageSet.toByteString(); | |
| 298 | |
| 299 // Parse back using RawMessageSet and check the contents. | |
| 300 RawMessageSet raw = RawMessageSet.parseFrom(data); | |
| 301 | |
| 302 assertTrue(raw.getUnknownFields().asMap().isEmpty()); | |
| 303 | |
| 304 assertEquals(3, raw.getItemCount()); | |
| 305 assertEquals(TYPE_ID_1, raw.getItem(0).getTypeId()); | |
| 306 assertEquals(TYPE_ID_2, raw.getItem(1).getTypeId()); | |
| 307 assertEquals(UNKNOWN_TYPE_ID, raw.getItem(2).getTypeId()); | |
| 308 | |
| 309 TestMessageSetExtension1 message1 = | |
| 310 TestMessageSetExtension1.parseFrom( | |
| 311 raw.getItem(0).getMessage().toByteArray()); | |
| 312 assertEquals(123, message1.getI()); | |
| 313 | |
| 314 TestMessageSetExtension2 message2 = | |
| 315 TestMessageSetExtension2.parseFrom( | |
| 316 raw.getItem(1).getMessage().toByteArray()); | |
| 317 assertEquals("foo", message2.getStr()); | |
| 318 | |
| 319 assertEquals("bar", raw.getItem(2).getMessage().toStringUtf8()); | |
| 320 } | |
| 321 | |
| 322 public void testParseMessageSetEagerly() throws Exception { | |
| 323 testParseMessageSetWithFlag(true); | |
| 324 } | |
| 325 | |
| 326 public void testParseMessageSetNotEagerly()throws Exception { | |
| 327 testParseMessageSetWithFlag(false); | |
| 328 } | |
| 329 | |
| 330 private void testParseMessageSetWithFlag(boolean eagerParsing) | |
| 331 throws Exception { | |
| 332 ExtensionRegistryLite.setEagerlyParseMessageSets(eagerParsing); | |
| 333 ExtensionRegistry extensionRegistry = ExtensionRegistry.newInstance(); | |
| 334 extensionRegistry.add(TestMessageSetExtension1.messageSetExtension); | |
| 335 extensionRegistry.add(TestMessageSetExtension2.messageSetExtension); | |
| 336 | |
| 337 // Set up a RawMessageSet with two known messages and an unknown one. | |
| 338 RawMessageSet raw = | |
| 339 RawMessageSet.newBuilder() | |
| 340 .addItem( | |
| 341 RawMessageSet.Item.newBuilder() | |
| 342 .setTypeId(TYPE_ID_1) | |
| 343 .setMessage( | |
| 344 TestMessageSetExtension1.newBuilder() | |
| 345 .setI(123) | |
| 346 .build().toByteString()) | |
| 347 .build()) | |
| 348 .addItem( | |
| 349 RawMessageSet.Item.newBuilder() | |
| 350 .setTypeId(TYPE_ID_2) | |
| 351 .setMessage( | |
| 352 TestMessageSetExtension2.newBuilder() | |
| 353 .setStr("foo") | |
| 354 .build().toByteString()) | |
| 355 .build()) | |
| 356 .addItem( | |
| 357 RawMessageSet.Item.newBuilder() | |
| 358 .setTypeId(UNKNOWN_TYPE_ID) | |
| 359 .setMessage(ByteString.copyFromUtf8("bar")) | |
| 360 .build()) | |
| 361 .build(); | |
| 362 | |
| 363 ByteString data = raw.toByteString(); | |
| 364 | |
| 365 // Parse as a TestMessageSet and check the contents. | |
| 366 TestMessageSet messageSet = | |
| 367 TestMessageSet.parseFrom(data, extensionRegistry); | |
| 368 | |
| 369 assertEquals(123, messageSet.getExtension( | |
| 370 TestMessageSetExtension1.messageSetExtension).getI()); | |
| 371 assertEquals("foo", messageSet.getExtension( | |
| 372 TestMessageSetExtension2.messageSetExtension).getStr()); | |
| 373 | |
| 374 // Check for unknown field with type LENGTH_DELIMITED, | |
| 375 // number UNKNOWN_TYPE_ID, and contents "bar". | |
| 376 UnknownFieldSet unknownFields = messageSet.getUnknownFields(); | |
| 377 assertEquals(1, unknownFields.asMap().size()); | |
| 378 assertTrue(unknownFields.hasField(UNKNOWN_TYPE_ID)); | |
| 379 | |
| 380 UnknownFieldSet.Field field = unknownFields.getField(UNKNOWN_TYPE_ID); | |
| 381 assertEquals(1, field.getLengthDelimitedList().size()); | |
| 382 assertEquals("bar", field.getLengthDelimitedList().get(0).toStringUtf8()); | |
| 383 } | |
| 384 | |
| 385 public void testParseMessageSetExtensionEagerly() throws Exception { | |
| 386 testParseMessageSetExtensionWithFlag(true); | |
| 387 } | |
| 388 | |
| 389 public void testParseMessageSetExtensionNotEagerly() throws Exception { | |
| 390 testParseMessageSetExtensionWithFlag(false); | |
| 391 } | |
| 392 | |
| 393 private void testParseMessageSetExtensionWithFlag(boolean eagerParsing) | |
| 394 throws Exception { | |
| 395 ExtensionRegistryLite.setEagerlyParseMessageSets(eagerParsing); | |
| 396 ExtensionRegistry extensionRegistry = ExtensionRegistry.newInstance(); | |
| 397 extensionRegistry.add(TestMessageSetExtension1.messageSetExtension); | |
| 398 | |
| 399 // Set up a RawMessageSet with a known messages. | |
| 400 int TYPE_ID_1 = | |
| 401 TestMessageSetExtension1 | |
| 402 .getDescriptor().getExtensions().get(0).getNumber(); | |
| 403 RawMessageSet raw = | |
| 404 RawMessageSet.newBuilder() | |
| 405 .addItem( | |
| 406 RawMessageSet.Item.newBuilder() | |
| 407 .setTypeId(TYPE_ID_1) | |
| 408 .setMessage( | |
| 409 TestMessageSetExtension1.newBuilder() | |
| 410 .setI(123) | |
| 411 .build().toByteString()) | |
| 412 .build()) | |
| 413 .build(); | |
| 414 | |
| 415 ByteString data = raw.toByteString(); | |
| 416 | |
| 417 // Parse as a TestMessageSet and check the contents. | |
| 418 TestMessageSet messageSet = | |
| 419 TestMessageSet.parseFrom(data, extensionRegistry); | |
| 420 assertEquals(123, messageSet.getExtension( | |
| 421 TestMessageSetExtension1.messageSetExtension).getI()); | |
| 422 } | |
| 423 | |
| 424 public void testMergeLazyMessageSetExtensionEagerly() throws Exception { | |
| 425 testMergeLazyMessageSetExtensionWithFlag(true); | |
| 426 } | |
| 427 | |
| 428 public void testMergeLazyMessageSetExtensionNotEagerly() throws Exception { | |
| 429 testMergeLazyMessageSetExtensionWithFlag(false); | |
| 430 } | |
| 431 | |
| 432 private void testMergeLazyMessageSetExtensionWithFlag(boolean eagerParsing) | |
| 433 throws Exception { | |
| 434 ExtensionRegistryLite.setEagerlyParseMessageSets(eagerParsing); | |
| 435 ExtensionRegistry extensionRegistry = ExtensionRegistry.newInstance(); | |
| 436 extensionRegistry.add(TestMessageSetExtension1.messageSetExtension); | |
| 437 | |
| 438 // Set up a RawMessageSet with a known messages. | |
| 439 int TYPE_ID_1 = | |
| 440 TestMessageSetExtension1 | |
| 441 .getDescriptor().getExtensions().get(0).getNumber(); | |
| 442 RawMessageSet raw = | |
| 443 RawMessageSet.newBuilder() | |
| 444 .addItem( | |
| 445 RawMessageSet.Item.newBuilder() | |
| 446 .setTypeId(TYPE_ID_1) | |
| 447 .setMessage( | |
| 448 TestMessageSetExtension1.newBuilder() | |
| 449 .setI(123) | |
| 450 .build().toByteString()) | |
| 451 .build()) | |
| 452 .build(); | |
| 453 | |
| 454 ByteString data = raw.toByteString(); | |
| 455 | |
| 456 // Parse as a TestMessageSet and store value into lazy field | |
| 457 TestMessageSet messageSet = | |
| 458 TestMessageSet.parseFrom(data, extensionRegistry); | |
| 459 // Merge lazy field check the contents. | |
| 460 messageSet = | |
| 461 messageSet.toBuilder().mergeFrom(data, extensionRegistry).build(); | |
| 462 assertEquals(123, messageSet.getExtension( | |
| 463 TestMessageSetExtension1.messageSetExtension).getI()); | |
| 464 } | |
| 465 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2590803003:
Revert "third_party/protobuf: Update to HEAD (83d681ee2c)" (Closed)
