OLD | NEW |
1 // Protocol Buffers - Google's data interchange format | 1 // Protocol Buffers - Google's data interchange format |
2 // Copyright 2015 Google Inc. All rights reserved. | 2 // Copyright 2015 Google Inc. All rights reserved. |
3 // https://developers.google.com/protocol-buffers/ | 3 // https://developers.google.com/protocol-buffers/ |
4 // | 4 // |
5 // Redistribution and use in source and binary forms, with or without | 5 // Redistribution and use in source and binary forms, with or without |
6 // modification, are permitted provided that the following conditions are | 6 // modification, are permitted provided that the following conditions are |
7 // met: | 7 // met: |
8 // | 8 // |
9 // * Redistributions of source code must retain the above copyright | 9 // * Redistributions of source code must retain the above copyright |
10 // notice, this list of conditions and the following disclaimer. | 10 // notice, this list of conditions and the following disclaimer. |
(...skipping 863 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
874 XCTAssertEqualObjects(fieldsParse, fieldsOrig); | 874 XCTAssertEqualObjects(fieldsParse, fieldsOrig); |
875 | 875 |
876 TestUnpackedExtensions *extsParse = | 876 TestUnpackedExtensions *extsParse = |
877 [TestUnpackedExtensions parseFromData:fieldsData | 877 [TestUnpackedExtensions parseFromData:fieldsData |
878 extensionRegistry:[UnittestRoot extensionRegistry] | 878 extensionRegistry:[UnittestRoot extensionRegistry] |
879 error:NULL]; | 879 error:NULL]; |
880 XCTAssertNotNil(extsParse); | 880 XCTAssertNotNil(extsParse); |
881 XCTAssertEqualObjects(extsParse, extsOrig); | 881 XCTAssertEqualObjects(extsParse, extsOrig); |
882 } | 882 } |
883 | 883 |
| 884 - (void)testErrorSubsectionInvalidLimit { |
| 885 NSData *data = DataFromCStr( |
| 886 "\x0A\x08\x0A\x07\x12\x04\x72\x02\x4B\x50\x12\x04\x72\x02\x4B\x50"); |
| 887 NSError *error = nil; |
| 888 NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data |
| 889 error:&error]; |
| 890 XCTAssertNil(msg); |
| 891 XCTAssertNotNil(error); |
| 892 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); |
| 893 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidSubsectionLimit); |
| 894 } |
| 895 |
| 896 - (void)testErrorSubsectionLimitReached { |
| 897 NSData *data = DataFromCStr("\x0A\x06\x12\x03\x72\x02\x4B\x50"); |
| 898 NSError *error = nil; |
| 899 NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data |
| 900 error:&error]; |
| 901 XCTAssertNil(msg); |
| 902 XCTAssertNotNil(error); |
| 903 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); |
| 904 XCTAssertEqual(error.code, GPBCodedInputStreamErrorSubsectionLimitReached); |
| 905 } |
| 906 |
| 907 - (void)testErrorInvalidVarint { |
| 908 NSData *data = DataFromCStr("\x72\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); |
| 909 NSError *error = nil; |
| 910 TestAllTypes *msg = [TestAllTypes parseFromData:data error:&error]; |
| 911 XCTAssertNil(msg); |
| 912 XCTAssertNotNil(error); |
| 913 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); |
| 914 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidVarInt); |
| 915 } |
| 916 |
| 917 - (void)testErrorInvalidUTF8 { |
| 918 NSData *data = DataFromCStr("\x72\x04\xF4\xFF\xFF\xFF"); |
| 919 NSError *error = nil; |
| 920 TestAllTypes *msg = [TestAllTypes parseFromData:data error:&error]; |
| 921 XCTAssertNil(msg); |
| 922 XCTAssertNotNil(error); |
| 923 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); |
| 924 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidUTF8); |
| 925 } |
| 926 |
| 927 - (void)testErrorInvalidSize { |
| 928 NSData *data = DataFromCStr("\x72\x03\x4B\x50"); |
| 929 NSError *error = nil; |
| 930 NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data |
| 931 error:&error]; |
| 932 XCTAssertNil(msg); |
| 933 XCTAssertNotNil(error); |
| 934 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); |
| 935 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidSize); |
| 936 } |
| 937 |
| 938 - (void)testErrorInvalidTag { |
| 939 NSData *data = DataFromCStr("\x0F"); |
| 940 NSError *error = nil; |
| 941 NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data |
| 942 error:&error]; |
| 943 XCTAssertNil(msg); |
| 944 XCTAssertNotNil(error); |
| 945 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); |
| 946 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidTag); |
| 947 } |
| 948 |
| 949 - (void)testErrorRecursionDepthReached { |
| 950 NSData *data = DataFromCStr( |
| 951 "\x0A\x86\x01\x0A\x83\x01\x0A\x80\x01\x0A\x7E\x0A\x7C\x0A\x7A\x0A\x78" |
| 952 "\x0A\x76\x0A\x74\x0A\x72\x0A\x70\x0A\x6E\x0A\x6C\x0A\x6A\x0A\x68" |
| 953 "\x0A\x66\x0A\x64\x0A\x62\x0A\x60\x0A\x5E\x0A\x5C\x0A\x5A\x0A\x58" |
| 954 "\x0A\x56\x0A\x54\x0A\x52\x0A\x50\x0A\x4E\x0A\x4C\x0A\x4A\x0A\x48" |
| 955 "\x0A\x46\x0A\x44\x0A\x42\x0A\x40\x0A\x3E\x0A\x3C\x0A\x3A\x0A\x38" |
| 956 "\x0A\x36\x0A\x34\x0A\x32\x0A\x30\x0A\x2E\x0A\x2C\x0A\x2A\x0A\x28" |
| 957 "\x0A\x26\x0A\x24\x0A\x22\x0A\x20\x0A\x1E\x0A\x1C\x0A\x1A\x0A\x18" |
| 958 "\x0A\x16\x0A\x14\x0A\x12\x0A\x10\x0A\x0E\x0A\x0C\x0A\x0A\x0A\x08" |
| 959 "\x0A\x06\x12\x04\x72\x02\x4B\x50"); |
| 960 NSError *error = nil; |
| 961 NestedTestAllTypes *msg = [NestedTestAllTypes parseFromData:data |
| 962 error:&error]; |
| 963 XCTAssertNil(msg); |
| 964 XCTAssertNotNil(error); |
| 965 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); |
| 966 XCTAssertEqual(error.code, GPBCodedInputStreamErrorRecursionDepthExceeded); |
| 967 } |
| 968 |
| 969 #ifdef DEBUG |
| 970 - (void)testErrorMissingRequiredField { |
| 971 NSData *data = DataFromCStr(""); |
| 972 NSError *error = nil; |
| 973 TestRequired *msg = [TestRequired parseFromData:data error:&error]; |
| 974 XCTAssertNil(msg); |
| 975 XCTAssertNotNil(error); |
| 976 XCTAssertEqualObjects(error.domain, GPBMessageErrorDomain); |
| 977 XCTAssertEqual(error.code, GPBMessageErrorCodeMissingRequiredField); |
| 978 } |
| 979 #endif |
| 980 |
884 #pragma mark - Subset from from map_tests.cc | 981 #pragma mark - Subset from from map_tests.cc |
885 | 982 |
886 // TEST(GeneratedMapFieldTest, StandardWireFormat) | 983 // TEST(GeneratedMapFieldTest, StandardWireFormat) |
887 - (void)testMap_StandardWireFormat { | 984 - (void)testMap_StandardWireFormat { |
888 NSData *data = DataFromCStr("\x0A\x04\x08\x01\x10\x01"); | 985 NSData *data = DataFromCStr("\x0A\x04\x08\x01\x10\x01"); |
889 | 986 |
890 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; | 987 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; |
891 XCTAssertEqual(msg.mapInt32Int32.count, 1U); | 988 XCTAssertEqual(msg.mapInt32Int32.count, 1U); |
892 int32_t val = 666; | 989 int32_t val = 666; |
893 XCTAssertTrue([msg.mapInt32Int32 valueForKey:1 value:&val]); | 990 XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:1]); |
894 XCTAssertEqual(val, 1); | 991 XCTAssertEqual(val, 1); |
895 | 992 |
896 [msg release]; | 993 [msg release]; |
897 } | 994 } |
898 | 995 |
899 // TEST(GeneratedMapFieldTest, UnorderedWireFormat) | 996 // TEST(GeneratedMapFieldTest, UnorderedWireFormat) |
900 - (void)testMap_UnorderedWireFormat { | 997 - (void)testMap_UnorderedWireFormat { |
901 // put value before key in wire format | 998 // put value before key in wire format |
902 NSData *data = DataFromCStr("\x0A\x04\x10\x01\x08\x02"); | 999 NSData *data = DataFromCStr("\x0A\x04\x10\x01\x08\x02"); |
903 | 1000 |
904 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; | 1001 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; |
905 XCTAssertEqual(msg.mapInt32Int32.count, 1U); | 1002 XCTAssertEqual(msg.mapInt32Int32.count, 1U); |
906 int32_t val = 666; | 1003 int32_t val = 666; |
907 XCTAssertTrue([msg.mapInt32Int32 valueForKey:2 value:&val]); | 1004 XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:2]); |
908 XCTAssertEqual(val, 1); | 1005 XCTAssertEqual(val, 1); |
909 | 1006 |
910 [msg release]; | 1007 [msg release]; |
911 } | 1008 } |
912 | 1009 |
913 // TEST(GeneratedMapFieldTest, DuplicatedKeyWireFormat) | 1010 // TEST(GeneratedMapFieldTest, DuplicatedKeyWireFormat) |
914 - (void)testMap_DuplicatedKeyWireFormat { | 1011 - (void)testMap_DuplicatedKeyWireFormat { |
915 // Two key fields in wire format | 1012 // Two key fields in wire format |
916 NSData *data = DataFromCStr("\x0A\x06\x08\x01\x08\x02\x10\x01"); | 1013 NSData *data = DataFromCStr("\x0A\x06\x08\x01\x08\x02\x10\x01"); |
917 | 1014 |
918 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; | 1015 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; |
919 XCTAssertEqual(msg.mapInt32Int32.count, 1U); | 1016 XCTAssertEqual(msg.mapInt32Int32.count, 1U); |
920 int32_t val = 666; | 1017 int32_t val = 666; |
921 XCTAssertTrue([msg.mapInt32Int32 valueForKey:2 value:&val]); | 1018 XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:2]); |
922 XCTAssertEqual(val, 1); | 1019 XCTAssertEqual(val, 1); |
923 | 1020 |
924 [msg release]; | 1021 [msg release]; |
925 } | 1022 } |
926 | 1023 |
927 // TEST(GeneratedMapFieldTest, DuplicatedValueWireFormat) | 1024 // TEST(GeneratedMapFieldTest, DuplicatedValueWireFormat) |
928 - (void)testMap_DuplicatedValueWireFormat { | 1025 - (void)testMap_DuplicatedValueWireFormat { |
929 // Two value fields in wire format | 1026 // Two value fields in wire format |
930 NSData *data = DataFromCStr("\x0A\x06\x08\x01\x10\x01\x10\x02"); | 1027 NSData *data = DataFromCStr("\x0A\x06\x08\x01\x10\x01\x10\x02"); |
931 | 1028 |
932 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; | 1029 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; |
933 XCTAssertEqual(msg.mapInt32Int32.count, 1U); | 1030 XCTAssertEqual(msg.mapInt32Int32.count, 1U); |
934 int32_t val = 666; | 1031 int32_t val = 666; |
935 XCTAssertTrue([msg.mapInt32Int32 valueForKey:1 value:&val]); | 1032 XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:1]); |
936 XCTAssertEqual(val, 2); | 1033 XCTAssertEqual(val, 2); |
937 | 1034 |
938 [msg release]; | 1035 [msg release]; |
939 } | 1036 } |
940 | 1037 |
941 // TEST(GeneratedMapFieldTest, MissedKeyWireFormat) | 1038 // TEST(GeneratedMapFieldTest, MissedKeyWireFormat) |
942 - (void)testMap_MissedKeyWireFormat { | 1039 - (void)testMap_MissedKeyWireFormat { |
943 // No key field in wire format | 1040 // No key field in wire format |
944 NSData *data = DataFromCStr("\x0A\x02\x10\x01"); | 1041 NSData *data = DataFromCStr("\x0A\x02\x10\x01"); |
945 | 1042 |
946 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; | 1043 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; |
947 XCTAssertEqual(msg.mapInt32Int32.count, 1U); | 1044 XCTAssertEqual(msg.mapInt32Int32.count, 1U); |
948 int32_t val = 666; | 1045 int32_t val = 666; |
949 XCTAssertTrue([msg.mapInt32Int32 valueForKey:0 value:&val]); | 1046 XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:0]); |
950 XCTAssertEqual(val, 1); | 1047 XCTAssertEqual(val, 1); |
951 | 1048 |
952 [msg release]; | 1049 [msg release]; |
953 } | 1050 } |
954 | 1051 |
955 // TEST(GeneratedMapFieldTest, MissedValueWireFormat) | 1052 // TEST(GeneratedMapFieldTest, MissedValueWireFormat) |
956 - (void)testMap_MissedValueWireFormat { | 1053 - (void)testMap_MissedValueWireFormat { |
957 // No value field in wire format | 1054 // No value field in wire format |
958 NSData *data = DataFromCStr("\x0A\x02\x08\x01"); | 1055 NSData *data = DataFromCStr("\x0A\x02\x08\x01"); |
959 | 1056 |
960 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; | 1057 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; |
961 XCTAssertEqual(msg.mapInt32Int32.count, 1U); | 1058 XCTAssertEqual(msg.mapInt32Int32.count, 1U); |
962 int32_t val = 666; | 1059 int32_t val = 666; |
963 XCTAssertTrue([msg.mapInt32Int32 valueForKey:1 value:&val]); | 1060 XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:1]); |
964 XCTAssertEqual(val, 0); | 1061 XCTAssertEqual(val, 0); |
965 | 1062 |
966 [msg release]; | 1063 [msg release]; |
967 } | 1064 } |
968 | 1065 |
969 // TEST(GeneratedMapFieldTest, UnknownFieldWireFormat) | 1066 // TEST(GeneratedMapFieldTest, UnknownFieldWireFormat) |
970 - (void)testMap_UnknownFieldWireFormat { | 1067 - (void)testMap_UnknownFieldWireFormat { |
971 // Unknown field in wire format | 1068 // Unknown field in wire format |
972 NSData *data = DataFromCStr("\x0A\x06\x08\x02\x10\x03\x18\x01"); | 1069 NSData *data = DataFromCStr("\x0A\x06\x08\x02\x10\x03\x18\x01"); |
973 | 1070 |
974 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; | 1071 TestMap *msg = [[TestMap alloc] initWithData:data error:NULL]; |
975 XCTAssertEqual(msg.mapInt32Int32.count, 1U); | 1072 XCTAssertEqual(msg.mapInt32Int32.count, 1U); |
976 int32_t val = 666; | 1073 int32_t val = 666; |
977 XCTAssertTrue([msg.mapInt32Int32 valueForKey:2 value:&val]); | 1074 XCTAssertTrue([msg.mapInt32Int32 getInt32:&val forKey:2]); |
978 XCTAssertEqual(val, 3); | 1075 XCTAssertEqual(val, 3); |
979 | 1076 |
980 [msg release]; | 1077 [msg release]; |
981 } | 1078 } |
982 | 1079 |
983 // TEST(GeneratedMapFieldTest, CorruptedWireFormat) | 1080 // TEST(GeneratedMapFieldTest, CorruptedWireFormat) |
984 - (void)testMap_CorruptedWireFormat { | 1081 - (void)testMap_CorruptedWireFormat { |
985 // corrupted data in wire format | 1082 // corrupted data in wire format |
986 NSData *data = DataFromCStr("\x0A\x06\x08\x02\x11\x03"); | 1083 NSData *data = DataFromCStr("\x0A\x06\x08\x02\x11\x03"); |
987 | 1084 |
988 NSError *error = nil; | 1085 NSError *error = nil; |
989 TestMap *msg = [TestMap parseFromData:data error:&error]; | 1086 TestMap *msg = [TestMap parseFromData:data error:&error]; |
990 XCTAssertNil(msg); | 1087 XCTAssertNil(msg); |
991 XCTAssertNotNil(error); | 1088 XCTAssertNotNil(error); |
992 XCTAssertEqualObjects(error.domain, GPBMessageErrorDomain); | 1089 XCTAssertEqualObjects(error.domain, GPBCodedInputStreamErrorDomain); |
993 XCTAssertEqual(error.code, GPBMessageErrorCodeMalformedData); | 1090 XCTAssertEqual(error.code, GPBCodedInputStreamErrorInvalidSubsectionLimit); |
994 } | 1091 } |
995 | 1092 |
996 // TEST(GeneratedMapFieldTest, Proto2UnknownEnum) | 1093 // TEST(GeneratedMapFieldTest, Proto2UnknownEnum) |
997 - (void)testMap_Proto2UnknownEnum { | 1094 - (void)testMap_Proto2UnknownEnum { |
998 TestEnumMapPlusExtra *orig = [[TestEnumMapPlusExtra alloc] init]; | 1095 TestEnumMapPlusExtra *orig = [[TestEnumMapPlusExtra alloc] init]; |
999 | 1096 |
1000 orig.knownMapField = [GPBInt32EnumDictionary | 1097 orig.knownMapField = [GPBInt32EnumDictionary |
1001 dictionaryWithValidationFunction:Proto2MapEnumPlusExtra_IsValidValue]; | 1098 dictionaryWithValidationFunction:Proto2MapEnumPlusExtra_IsValidValue]; |
1002 orig.unknownMapField = [GPBInt32EnumDictionary | 1099 orig.unknownMapField = [GPBInt32EnumDictionary |
1003 dictionaryWithValidationFunction:Proto2MapEnumPlusExtra_IsValidValue]; | 1100 dictionaryWithValidationFunction:Proto2MapEnumPlusExtra_IsValidValue]; |
1004 [orig.knownMapField setValue:Proto2MapEnumPlusExtra_EProto2MapEnumFoo | 1101 [orig.knownMapField setEnum:Proto2MapEnumPlusExtra_EProto2MapEnumFoo |
1005 forKey:0]; | 1102 forKey:0]; |
1006 [orig.unknownMapField setValue:Proto2MapEnumPlusExtra_EProto2MapEnumExtra | 1103 [orig.unknownMapField setEnum:Proto2MapEnumPlusExtra_EProto2MapEnumExtra |
1007 forKey:0]; | 1104 forKey:0]; |
1008 | 1105 |
1009 NSData *data = [orig data]; | 1106 NSData *data = [orig data]; |
1010 XCTAssertNotNil(data); | 1107 XCTAssertNotNil(data); |
1011 TestEnumMap *msg1 = [TestEnumMap parseFromData:data error:NULL]; | 1108 TestEnumMap *msg1 = [TestEnumMap parseFromData:data error:NULL]; |
1012 XCTAssertEqual(msg1.knownMapField.count, 1U); | 1109 XCTAssertEqual(msg1.knownMapField.count, 1U); |
1013 int32_t val = -1; | 1110 int32_t val = -1; |
1014 XCTAssertTrue([msg1.knownMapField valueForKey:0 value:&val]); | 1111 XCTAssertTrue([msg1.knownMapField getEnum:&val forKey:0]); |
1015 XCTAssertEqual(val, Proto2MapEnum_Proto2MapEnumFoo); | 1112 XCTAssertEqual(val, Proto2MapEnum_Proto2MapEnumFoo); |
1016 XCTAssertEqual(msg1.unknownFields.countOfFields, 1U); | 1113 XCTAssertEqual(msg1.unknownFields.countOfFields, 1U); |
1017 | 1114 |
1018 data = [msg1 data]; | 1115 data = [msg1 data]; |
1019 TestEnumMapPlusExtra *msg2 = | 1116 TestEnumMapPlusExtra *msg2 = |
1020 [TestEnumMapPlusExtra parseFromData:data error:NULL]; | 1117 [TestEnumMapPlusExtra parseFromData:data error:NULL]; |
1021 val = -1; | 1118 val = -1; |
1022 XCTAssertEqual(msg2.knownMapField.count, 1U); | 1119 XCTAssertEqual(msg2.knownMapField.count, 1U); |
1023 XCTAssertTrue([msg2.knownMapField valueForKey:0 value:&val]); | 1120 XCTAssertTrue([msg2.knownMapField getEnum:&val forKey:0]); |
1024 XCTAssertEqual(val, Proto2MapEnumPlusExtra_EProto2MapEnumFoo); | 1121 XCTAssertEqual(val, Proto2MapEnumPlusExtra_EProto2MapEnumFoo); |
1025 val = -1; | 1122 val = -1; |
1026 XCTAssertEqual(msg2.unknownMapField.count, 1U); | 1123 XCTAssertEqual(msg2.unknownMapField.count, 1U); |
1027 XCTAssertTrue([msg2.unknownMapField valueForKey:0 value:&val]); | 1124 XCTAssertTrue([msg2.unknownMapField getEnum:&val forKey:0]); |
1028 XCTAssertEqual(val, Proto2MapEnumPlusExtra_EProto2MapEnumExtra); | 1125 XCTAssertEqual(val, Proto2MapEnumPlusExtra_EProto2MapEnumExtra); |
1029 XCTAssertEqual(msg2.unknownFields.countOfFields, 0U); | 1126 XCTAssertEqual(msg2.unknownFields.countOfFields, 0U); |
1030 | 1127 |
1031 XCTAssertEqualObjects(orig, msg2); | 1128 XCTAssertEqualObjects(orig, msg2); |
1032 | 1129 |
1033 [orig release]; | 1130 [orig release]; |
1034 } | 1131 } |
1035 | 1132 |
1036 #pragma mark - Map Round Tripping | 1133 #pragma mark - Map Round Tripping |
1037 | 1134 |
1038 - (void)testProto2MapRoundTripping { | 1135 - (void)testProto2MapRoundTripping { |
1039 Message2 *msg = [[Message2 alloc] init]; | 1136 Message2 *msg = [[Message2 alloc] init]; |
1040 | 1137 |
1041 // Key/Value data should result in different byte lengths on wire to ensure | 1138 // Key/Value data should result in different byte lengths on wire to ensure |
1042 // everything is right. | 1139 // everything is right. |
1043 [msg.mapInt32Int32 setValue:1000 forKey:200]; | 1140 [msg.mapInt32Int32 setInt32:1000 forKey:200]; |
1044 [msg.mapInt32Int32 setValue:101 forKey:2001]; | 1141 [msg.mapInt32Int32 setInt32:101 forKey:2001]; |
1045 [msg.mapInt64Int64 setValue:1002 forKey:202]; | 1142 [msg.mapInt64Int64 setInt64:1002 forKey:202]; |
1046 [msg.mapInt64Int64 setValue:103 forKey:2003]; | 1143 [msg.mapInt64Int64 setInt64:103 forKey:2003]; |
1047 [msg.mapUint32Uint32 setValue:1004 forKey:204]; | 1144 [msg.mapUint32Uint32 setUInt32:1004 forKey:204]; |
1048 [msg.mapUint32Uint32 setValue:105 forKey:2005]; | 1145 [msg.mapUint32Uint32 setUInt32:105 forKey:2005]; |
1049 [msg.mapUint64Uint64 setValue:1006 forKey:206]; | 1146 [msg.mapUint64Uint64 setUInt64:1006 forKey:206]; |
1050 [msg.mapUint64Uint64 setValue:107 forKey:2007]; | 1147 [msg.mapUint64Uint64 setUInt64:107 forKey:2007]; |
1051 [msg.mapSint32Sint32 setValue:1008 forKey:208]; | 1148 [msg.mapSint32Sint32 setInt32:1008 forKey:208]; |
1052 [msg.mapSint32Sint32 setValue:109 forKey:2009]; | 1149 [msg.mapSint32Sint32 setInt32:109 forKey:2009]; |
1053 [msg.mapSint64Sint64 setValue:1010 forKey:210]; | 1150 [msg.mapSint64Sint64 setInt64:1010 forKey:210]; |
1054 [msg.mapSint64Sint64 setValue:111 forKey:2011]; | 1151 [msg.mapSint64Sint64 setInt64:111 forKey:2011]; |
1055 [msg.mapFixed32Fixed32 setValue:1012 forKey:212]; | 1152 [msg.mapFixed32Fixed32 setUInt32:1012 forKey:212]; |
1056 [msg.mapFixed32Fixed32 setValue:113 forKey:2013]; | 1153 [msg.mapFixed32Fixed32 setUInt32:113 forKey:2013]; |
1057 [msg.mapFixed64Fixed64 setValue:1014 forKey:214]; | 1154 [msg.mapFixed64Fixed64 setUInt64:1014 forKey:214]; |
1058 [msg.mapFixed64Fixed64 setValue:115 forKey:2015]; | 1155 [msg.mapFixed64Fixed64 setUInt64:115 forKey:2015]; |
1059 [msg.mapSfixed32Sfixed32 setValue:1016 forKey:216]; | 1156 [msg.mapSfixed32Sfixed32 setInt32:1016 forKey:216]; |
1060 [msg.mapSfixed32Sfixed32 setValue:117 forKey:2017]; | 1157 [msg.mapSfixed32Sfixed32 setInt32:117 forKey:2017]; |
1061 [msg.mapSfixed64Sfixed64 setValue:1018 forKey:218]; | 1158 [msg.mapSfixed64Sfixed64 setInt64:1018 forKey:218]; |
1062 [msg.mapSfixed64Sfixed64 setValue:119 forKey:2019]; | 1159 [msg.mapSfixed64Sfixed64 setInt64:119 forKey:2019]; |
1063 [msg.mapInt32Float setValue:1020.f forKey:220]; | 1160 [msg.mapInt32Float setFloat:1020.f forKey:220]; |
1064 [msg.mapInt32Float setValue:121.f forKey:2021]; | 1161 [msg.mapInt32Float setFloat:121.f forKey:2021]; |
1065 [msg.mapInt32Double setValue:1022. forKey:222]; | 1162 [msg.mapInt32Double setDouble:1022. forKey:222]; |
1066 [msg.mapInt32Double setValue:123. forKey:2023]; | 1163 [msg.mapInt32Double setDouble:123. forKey:2023]; |
1067 [msg.mapBoolBool setValue:false forKey:true]; | 1164 [msg.mapBoolBool setBool:false forKey:true]; |
1068 [msg.mapBoolBool setValue:true forKey:false]; | 1165 [msg.mapBoolBool setBool:true forKey:false]; |
1069 msg.mapStringString[@"224"] = @"1024"; | 1166 msg.mapStringString[@"224"] = @"1024"; |
1070 msg.mapStringString[@"2025"] = @"125"; | 1167 msg.mapStringString[@"2025"] = @"125"; |
1071 msg.mapStringBytes[@"226"] = DataFromCStr("1026"); | 1168 msg.mapStringBytes[@"226"] = DataFromCStr("1026"); |
1072 msg.mapStringBytes[@"2027"] = DataFromCStr("127"); | 1169 msg.mapStringBytes[@"2027"] = DataFromCStr("127"); |
1073 Message2 *val1 = [[Message2 alloc] init]; | 1170 Message2 *val1 = [[Message2 alloc] init]; |
1074 val1.optionalInt32 = 1028; | 1171 val1.optionalInt32 = 1028; |
1075 Message2 *val2 = [[Message2 alloc] init]; | 1172 Message2 *val2 = [[Message2 alloc] init]; |
1076 val2.optionalInt32 = 129; | 1173 val2.optionalInt32 = 129; |
1077 [msg.mapStringMessage setValue:val1 forKey:@"228"]; | 1174 [msg.mapStringMessage setObject:val1 forKey:@"228"]; |
1078 [msg.mapStringMessage setValue:val2 forKey:@"2029"]; | 1175 [msg.mapStringMessage setObject:val2 forKey:@"2029"]; |
1079 [msg.mapInt32Bytes setObject:DataFromCStr("1030 bytes") forKey:230]; | 1176 [msg.mapInt32Bytes setObject:DataFromCStr("1030 bytes") forKey:230]; |
1080 [msg.mapInt32Bytes setObject:DataFromCStr("131") forKey:2031]; | 1177 [msg.mapInt32Bytes setObject:DataFromCStr("131") forKey:2031]; |
1081 [msg.mapInt32Enum setValue:Message2_Enum_Bar forKey:232]; | 1178 [msg.mapInt32Enum setEnum:Message2_Enum_Bar forKey:232]; |
1082 [msg.mapInt32Enum setValue:Message2_Enum_Baz forKey:2033]; | 1179 [msg.mapInt32Enum setEnum:Message2_Enum_Baz forKey:2033]; |
1083 Message2 *val3 = [[Message2 alloc] init]; | 1180 Message2 *val3 = [[Message2 alloc] init]; |
1084 val3.optionalInt32 = 1034; | 1181 val3.optionalInt32 = 1034; |
1085 Message2 *val4 = [[Message2 alloc] init]; | 1182 Message2 *val4 = [[Message2 alloc] init]; |
1086 val4.optionalInt32 = 135; | 1183 val4.optionalInt32 = 135; |
1087 [msg.mapInt32Message setObject:val3 forKey:234]; | 1184 [msg.mapInt32Message setObject:val3 forKey:234]; |
1088 [msg.mapInt32Message setObject:val4 forKey:2035]; | 1185 [msg.mapInt32Message setObject:val4 forKey:2035]; |
1089 | 1186 |
1090 NSData *data = [msg data]; | 1187 NSData *data = [msg data]; |
1091 XCTAssertNotNil(data); | 1188 XCTAssertNotNil(data); |
1092 Message2 *msg2 = [[Message2 alloc] initWithData:data error:NULL]; | 1189 Message2 *msg2 = [[Message2 alloc] initWithData:data error:NULL]; |
1093 | 1190 |
1094 XCTAssertNotEqual(msg2, msg); // Pointer comparison | 1191 XCTAssertNotEqual(msg2, msg); // Pointer comparison |
1095 XCTAssertEqualObjects(msg2, msg); | 1192 XCTAssertEqualObjects(msg2, msg); |
1096 | 1193 |
1097 [val4 release]; | 1194 [val4 release]; |
1098 [val3 release]; | 1195 [val3 release]; |
1099 [val2 release]; | 1196 [val2 release]; |
1100 [val1 release]; | 1197 [val1 release]; |
1101 [msg2 release]; | 1198 [msg2 release]; |
1102 [msg release]; | 1199 [msg release]; |
1103 } | 1200 } |
1104 | 1201 |
1105 @end | 1202 @end |
OLD | NEW |