Revert "third_party/protobuf: Update to HEAD (83d681ee2c)"

third_party/protobuf/objectivec/Tests/GPBMessageTests+Serialization.m

 // Protocol Buffers - Google's data interchange format
 // Copyright 2015 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 863 matching lines @@
   XCTAssertEqualObjects(fieldsParse, fieldsOrig);
 
   TestUnpackedExtensions *extsParse =
       [TestUnpackedExtensions parseFromData:fieldsData
                           extensionRegistry:[UnittestRoot extensionRegistry]
                                       error:NULL];
   XCTAssertNotNil(extsParse);
   XCTAssertEqualObjects(extsParse, extsOrig);
 }
 
-- (void)testErrorSubsectionInvalidLimit {
-  NSData *data = DataFromCStr(
-      "\x0A\x08\x0A\x07\x12\x04\x72\x02\x4B\x50\x12\x04\x72\x02\x4B\x50");
-  NSError *error = nil;
-  NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data
-                                                        error:&error];
-  XCTAssertNil(msg);
-  XCTAssertNotNil(error);
-  XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain);
-  XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidSubsectionLimit);
-}
-
-- (void)testErrorSubsectionLimitReached {
-  NSData *data = DataFromCStr("\x0A\x06\x12\x03\x72\x02\x4B\x50");
-  NSError *error = nil;
-  NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data
-                                                        error:&error];
-  XCTAssertNil(msg);
-  XCTAssertNotNil(error);
-  XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain);
-  XCTAssertEqual(error.code, GPBCodedInputStreamErrorSubsectionLimitReached);
-}
-
-- (void)testErrorInvalidVarint {
-  NSData *data = DataFromCStr("\x72\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
-  NSError *error = nil;
-  TestAllTypes *msg = [TestAllTypes parseFromData:data error:&error];
-  XCTAssertNil(msg);
-  XCTAssertNotNil(error);
-  XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain);
-  XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidVarInt);
-}
-
-- (void)testErrorInvalidUTF8 {
-  NSData *data = DataFromCStr("\x72\x04\xF4\xFF\xFF\xFF");
-  NSError *error = nil;
-  TestAllTypes *msg = [TestAllTypes parseFromData:data error:&error];
-  XCTAssertNil(msg);
-  XCTAssertNotNil(error);
-  XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain);
-  XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidUTF8);
-}
-
-- (void)testErrorInvalidSize {
-  NSData *data = DataFromCStr("\x72\x03\x4B\x50");
-  NSError *error = nil;
-  NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data
-                                                        error:&error];
-  XCTAssertNil(msg);
-  XCTAssertNotNil(error);
-  XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain);
-  XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidSize);
-}
-
-- (void)testErrorInvalidTag {
-  NSData *data = DataFromCStr("\x0F");
-  NSError *error = nil;
-  NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data
-                                                        error:&error];
-  XCTAssertNil(msg);
-  XCTAssertNotNil(error);
-  XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain);
-  XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidTag);
-}
-
-- (void)testErrorRecursionDepthReached {
-  NSData *data = DataFromCStr(
-      "\x0A\x86\x01\x0A\x83\x01\x0A\x80\x01\x0A\x7E\x0A\x7C\x0A\x7A\x0A\x78"
-      "\x0A\x76\x0A\x74\x0A\x72\x0A\x70\x0A\x6E\x0A\x6C\x0A\x6A\x0A\x68"
-      "\x0A\x66\x0A\x64\x0A\x62\x0A\x60\x0A\x5E\x0A\x5C\x0A\x5A\x0A\x58"
-      "\x0A\x56\x0A\x54\x0A\x52\x0A\x50\x0A\x4E\x0A\x4C\x0A\x4A\x0A\x48"
-      "\x0A\x46\x0A\x44\x0A\x42\x0A\x40\x0A\x3E\x0A\x3C\x0A\x3A\x0A\x38"
-      "\x0A\x36\x0A\x34\x0A\x32\x0A\x30\x0A\x2E\x0A\x2C\x0A\x2A\x0A\x28"
-      "\x0A\x26\x0A\x24\x0A\x22\x0A\x20\x0A\x1E\x0A\x1C\x0A\x1A\x0A\x18"
-      "\x0A\x16\x0A\x14\x0A\x12\x0A\x10\x0A\x0E\x0A\x0C\x0A\x0A\x0A\x08"
-      "\x0A\x06\x12\x04\x72\x02\x4B\x50");
-  NSError *error = nil;
-  NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data
-                                                        error:&error];
-  XCTAssertNil(msg);
-  XCTAssertNotNil(error);
-  XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain);
-  XCTAssertEqual(error.code, GPBCodedInputStreamErrorRecursionDepthExceeded);
-}
-
-#ifdef DEBUG
-- (void)testErrorMissingRequiredField {
-  NSData *data = DataFromCStr("");
-  NSError *error = nil;
-  TestRequired *msg = [TestRequired parseFromData:data error:&error];
-  XCTAssertNil(msg);
-  XCTAssertNotNil(error);
-  XCTAssertEqualObjects(error.domain, GPBMessageErrorDomain);
-  XCTAssertEqual(error.code, GPBMessageErrorCodeMissingRequiredField);
-}
-#endif
-
 #pragma mark - Subset from from map_tests.cc
 
 // TEST(GeneratedMapFieldTest, StandardWireFormat)
 - (void)testMap_StandardWireFormat {
   NSData *data = DataFromCStr("\x0A\x04\x08\x01\x10\x01");
 
   TestMap *msg = [[TestMap alloc] initWithData:data error:NULL];
   XCTAssertEqual(msg.mapInt32Int32.count, 1U);
   int32_t val = 666;
-  XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:1]);
+  XCTAssertTrue([msg.mapInt32Int32 valueForKey:1 value:&val]);
   XCTAssertEqual(val, 1);
 
   [msg release];
 }
 
 // TEST(GeneratedMapFieldTest, UnorderedWireFormat)
 - (void)testMap_UnorderedWireFormat {
   // put value before key in wire format
   NSData *data = DataFromCStr("\x0A\x04\x10\x01\x08\x02");
 
   TestMap *msg = [[TestMap alloc] initWithData:data error:NULL];
   XCTAssertEqual(msg.mapInt32Int32.count, 1U);
   int32_t val = 666;
-  XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:2]);
+  XCTAssertTrue([msg.mapInt32Int32 valueForKey:2 value:&val]);
   XCTAssertEqual(val, 1);
 
   [msg release];
 }
 
 // TEST(GeneratedMapFieldTest, DuplicatedKeyWireFormat)
 - (void)testMap_DuplicatedKeyWireFormat {
   // Two key fields in wire format
   NSData *data = DataFromCStr("\x0A\x06\x08\x01\x08\x02\x10\x01");
 
   TestMap *msg = [[TestMap alloc] initWithData:data error:NULL];
   XCTAssertEqual(msg.mapInt32Int32.count, 1U);
   int32_t val = 666;
-  XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:2]);
+  XCTAssertTrue([msg.mapInt32Int32 valueForKey:2 value:&val]);
   XCTAssertEqual(val, 1);
 
   [msg release];
 }
 
 // TEST(GeneratedMapFieldTest, DuplicatedValueWireFormat)
 - (void)testMap_DuplicatedValueWireFormat {
   // Two value fields in wire format
   NSData *data = DataFromCStr("\x0A\x06\x08\x01\x10\x01\x10\x02");
 
   TestMap *msg = [[TestMap alloc] initWithData:data error:NULL];
   XCTAssertEqual(msg.mapInt32Int32.count, 1U);
   int32_t val = 666;
-  XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:1]);
+  XCTAssertTrue([msg.mapInt32Int32 valueForKey:1 value:&val]);
   XCTAssertEqual(val, 2);
 
   [msg release];
 }
 
 // TEST(GeneratedMapFieldTest, MissedKeyWireFormat)
 - (void)testMap_MissedKeyWireFormat {
   // No key field in wire format
   NSData *data = DataFromCStr("\x0A\x02\x10\x01");
 
   TestMap *msg = [[TestMap alloc] initWithData:data error:NULL];
   XCTAssertEqual(msg.mapInt32Int32.count, 1U);
   int32_t val = 666;
-  XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:0]);
+  XCTAssertTrue([msg.mapInt32Int32 valueForKey:0 value:&val]);
   XCTAssertEqual(val, 1);
 
   [msg release];
 }
 
 // TEST(GeneratedMapFieldTest, MissedValueWireFormat)
 - (void)testMap_MissedValueWireFormat {
   // No value field in wire format
   NSData *data = DataFromCStr("\x0A\x02\x08\x01");
 
   TestMap *msg = [[TestMap alloc] initWithData:data error:NULL];
   XCTAssertEqual(msg.mapInt32Int32.count, 1U);
   int32_t val = 666;
-  XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:1]);
+  XCTAssertTrue([msg.mapInt32Int32 valueForKey:1 value:&val]);
   XCTAssertEqual(val, 0);
 
   [msg release];
 }
 
 // TEST(GeneratedMapFieldTest, UnknownFieldWireFormat)
 - (void)testMap_UnknownFieldWireFormat {
   // Unknown field in wire format
   NSData *data = DataFromCStr("\x0A\x06\x08\x02\x10\x03\x18\x01");
 
   TestMap *msg = [[TestMap alloc] initWithData:data error:NULL];
   XCTAssertEqual(msg.mapInt32Int32.count, 1U);
   int32_t val = 666;
-  XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:2]);
+  XCTAssertTrue([msg.mapInt32Int32 valueForKey:2 value:&val]);
   XCTAssertEqual(val, 3);
 
   [msg release];
 }
 
 // TEST(GeneratedMapFieldTest, CorruptedWireFormat)
 - (void)testMap_CorruptedWireFormat {
   // corrupted data in wire format
   NSData *data = DataFromCStr("\x0A\x06\x08\x02\x11\x03");
 
   NSError *error = nil;
   TestMap *msg = [TestMap parseFromData:data error:&error];
   XCTAssertNil(msg);
   XCTAssertNotNil(error);
-  XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain);
-  XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidSubsectionLimit);
+  XCTAssertEqualObjects(error.domain, GPBMessageErrorDomain);
+  XCTAssertEqual(error.code, GPBMessageErrorCodeMalformedData);
 }
 
 // TEST(GeneratedMapFieldTest, Proto2UnknownEnum)
 - (void)testMap_Proto2UnknownEnum {
   TestEnumMapPlusExtra *orig = [[TestEnumMapPlusExtra alloc] init];
 
   orig.knownMapField = [GPBInt32EnumDictionary
       dictionaryWithValidationFunction:Proto2MapEnumPlusExtra_IsValidValue];
   orig.unknownMapField = [GPBInt32EnumDictionary
       dictionaryWithValidationFunction:Proto2MapEnumPlusExtra_IsValidValue];
-  [orig.knownMapField setEnum:Proto2MapEnumPlusExtra_EProto2MapEnumFoo
-                       forKey:0];
-  [orig.unknownMapField setEnum:Proto2MapEnumPlusExtra_EProto2MapEnumExtra
-                         forKey:0];
+  [orig.knownMapField setValue:Proto2MapEnumPlusExtra_EProto2MapEnumFoo
+                        forKey:0];
+  [orig.unknownMapField setValue:Proto2MapEnumPlusExtra_EProto2MapEnumExtra
+                          forKey:0];
 
   NSData *data = [orig data];
   XCTAssertNotNil(data);
   TestEnumMap *msg1 = [TestEnumMap parseFromData:data error:NULL];
   XCTAssertEqual(msg1.knownMapField.count, 1U);
   int32_t val = -1;
-  XCTAssertTrue([msg1.knownMapField getEnum:&val forKey:0]);
+  XCTAssertTrue([msg1.knownMapField valueForKey:0 value:&val]);
   XCTAssertEqual(val, Proto2MapEnum_Proto2MapEnumFoo);
   XCTAssertEqual(msg1.unknownFields.countOfFields, 1U);
 
   data = [msg1 data];
   TestEnumMapPlusExtra *msg2 =
       [TestEnumMapPlusExtra parseFromData:data error:NULL];
   val = -1;
   XCTAssertEqual(msg2.knownMapField.count, 1U);
-  XCTAssertTrue([msg2.knownMapField getEnum:&val forKey:0]);
+  XCTAssertTrue([msg2.knownMapField valueForKey:0 value:&val]);
   XCTAssertEqual(val, Proto2MapEnumPlusExtra_EProto2MapEnumFoo);
   val = -1;
   XCTAssertEqual(msg2.unknownMapField.count, 1U);
-  XCTAssertTrue([msg2.unknownMapField getEnum:&val forKey:0]);
+  XCTAssertTrue([msg2.unknownMapField valueForKey:0 value:&val]);
   XCTAssertEqual(val, Proto2MapEnumPlusExtra_EProto2MapEnumExtra);
   XCTAssertEqual(msg2.unknownFields.countOfFields, 0U);
 
   XCTAssertEqualObjects(orig, msg2);
 
   [orig release];
 }
 
 #pragma mark - Map Round Tripping
 
 - (void)testProto2MapRoundTripping {
   Message2 *msg = [[Message2 alloc] init];
 
   // Key/Value data should result in different byte lengths on wire to ensure
   // everything is right.
-  [msg.mapInt32Int32 setInt32:1000 forKey:200];
-  [msg.mapInt32Int32 setInt32:101 forKey:2001];
-  [msg.mapInt64Int64 setInt64:1002 forKey:202];
-  [msg.mapInt64Int64 setInt64:103 forKey:2003];
-  [msg.mapUint32Uint32 setUInt32:1004 forKey:204];
-  [msg.mapUint32Uint32 setUInt32:105 forKey:2005];
-  [msg.mapUint64Uint64 setUInt64:1006 forKey:206];
-  [msg.mapUint64Uint64 setUInt64:107 forKey:2007];
-  [msg.mapSint32Sint32 setInt32:1008 forKey:208];
-  [msg.mapSint32Sint32 setInt32:109 forKey:2009];
-  [msg.mapSint64Sint64 setInt64:1010 forKey:210];
-  [msg.mapSint64Sint64 setInt64:111 forKey:2011];
-  [msg.mapFixed32Fixed32 setUInt32:1012 forKey:212];
-  [msg.mapFixed32Fixed32 setUInt32:113 forKey:2013];
-  [msg.mapFixed64Fixed64 setUInt64:1014 forKey:214];
-  [msg.mapFixed64Fixed64 setUInt64:115 forKey:2015];
-  [msg.mapSfixed32Sfixed32 setInt32:1016 forKey:216];
-  [msg.mapSfixed32Sfixed32 setInt32:117 forKey:2017];
-  [msg.mapSfixed64Sfixed64 setInt64:1018 forKey:218];
-  [msg.mapSfixed64Sfixed64 setInt64:119 forKey:2019];
-  [msg.mapInt32Float setFloat:1020.f forKey:220];
-  [msg.mapInt32Float setFloat:121.f forKey:2021];
-  [msg.mapInt32Double setDouble:1022. forKey:222];
-  [msg.mapInt32Double setDouble:123. forKey:2023];
-  [msg.mapBoolBool setBool:false forKey:true];
-  [msg.mapBoolBool setBool:true forKey:false];
+  [msg.mapInt32Int32 setValue:1000 forKey:200];
+  [msg.mapInt32Int32 setValue:101 forKey:2001];
+  [msg.mapInt64Int64 setValue:1002 forKey:202];
+  [msg.mapInt64Int64 setValue:103 forKey:2003];
+  [msg.mapUint32Uint32 setValue:1004 forKey:204];
+  [msg.mapUint32Uint32 setValue:105 forKey:2005];
+  [msg.mapUint64Uint64 setValue:1006 forKey:206];
+  [msg.mapUint64Uint64 setValue:107 forKey:2007];
+  [msg.mapSint32Sint32 setValue:1008 forKey:208];
+  [msg.mapSint32Sint32 setValue:109 forKey:2009];
+  [msg.mapSint64Sint64 setValue:1010 forKey:210];
+  [msg.mapSint64Sint64 setValue:111 forKey:2011];
+  [msg.mapFixed32Fixed32 setValue:1012 forKey:212];
+  [msg.mapFixed32Fixed32 setValue:113 forKey:2013];
+  [msg.mapFixed64Fixed64 setValue:1014 forKey:214];
+  [msg.mapFixed64Fixed64 setValue:115 forKey:2015];
+  [msg.mapSfixed32Sfixed32 setValue:1016 forKey:216];
+  [msg.mapSfixed32Sfixed32 setValue:117 forKey:2017];
+  [msg.mapSfixed64Sfixed64 setValue:1018 forKey:218];
+  [msg.mapSfixed64Sfixed64 setValue:119 forKey:2019];
+  [msg.mapInt32Float setValue:1020.f forKey:220];
+  [msg.mapInt32Float setValue:121.f forKey:2021];
+  [msg.mapInt32Double setValue:1022. forKey:222];
+  [msg.mapInt32Double setValue:123. forKey:2023];
+  [msg.mapBoolBool setValue:false forKey:true];
+  [msg.mapBoolBool setValue:true forKey:false];
   msg.mapStringString[@"224"] = @"1024";
   msg.mapStringString[@"2025"] = @"125";
   msg.mapStringBytes[@"226"] = DataFromCStr("1026");
   msg.mapStringBytes[@"2027"] = DataFromCStr("127");
   Message2 *val1 = [[Message2 alloc] init];
   val1.optionalInt32 = 1028;
   Message2 *val2 = [[Message2 alloc] init];
   val2.optionalInt32 = 129;
-  [msg.mapStringMessage setObject:val1 forKey:@"228"];
-  [msg.mapStringMessage setObject:val2 forKey:@"2029"];
+  [msg.mapStringMessage setValue:val1 forKey:@"228"];
+  [msg.mapStringMessage setValue:val2 forKey:@"2029"];
   [msg.mapInt32Bytes setObject:DataFromCStr("1030 bytes") forKey:230];
   [msg.mapInt32Bytes setObject:DataFromCStr("131") forKey:2031];
-  [msg.mapInt32Enum setEnum:Message2_Enum_Bar forKey:232];
-  [msg.mapInt32Enum setEnum:Message2_Enum_Baz forKey:2033];
+  [msg.mapInt32Enum setValue:Message2_Enum_Bar forKey:232];
+  [msg.mapInt32Enum setValue:Message2_Enum_Baz forKey:2033];
   Message2 *val3 = [[Message2 alloc] init];
   val3.optionalInt32 = 1034;
   Message2 *val4 = [[Message2 alloc] init];
   val4.optionalInt32 = 135;
   [msg.mapInt32Message setObject:val3 forKey:234];
   [msg.mapInt32Message setObject:val4 forKey:2035];
 
   NSData *data = [msg data];
   XCTAssertNotNil(data);
   Message2 *msg2 = [[Message2 alloc] initWithData:data error:NULL];
 
   XCTAssertNotEqual(msg2, msg);  // Pointer comparison
   XCTAssertEqualObjects(msg2, msg);
 
   [val4 release];
   [val3 release];
   [val2 release];
   [val1 release];
   [msg2 release];
   [msg release];
 }
 
 @end