From 30650d81d9baa446dbc8deb784ba53794cafda5b Mon Sep 17 00:00:00 2001 From: Thomas Van Lenten Date: Fri, 1 May 2015 08:57:16 -0400 Subject: Alpha 1 drop of Google's Objective C plugin and runtime support for protobufs. --- objectivec/Tests/GPBMessageTests+Serialization.m | 838 +++++++++++++++++++++++ 1 file changed, 838 insertions(+) create mode 100644 objectivec/Tests/GPBMessageTests+Serialization.m (limited to 'objectivec/Tests/GPBMessageTests+Serialization.m') diff --git a/objectivec/Tests/GPBMessageTests+Serialization.m b/objectivec/Tests/GPBMessageTests+Serialization.m new file mode 100644 index 00000000..ddc2ae19 --- /dev/null +++ b/objectivec/Tests/GPBMessageTests+Serialization.m @@ -0,0 +1,838 @@ +// 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. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#import "GPBTestUtilities.h" + +#import + +#import "GPBMessage.h" + +#import "google/protobuf/MapProto2Unittest.pbobjc.h" +#import "google/protobuf/MapUnittest.pbobjc.h" +#import "google/protobuf/UnittestDropUnknownFields.pbobjc.h" +#import "google/protobuf/UnittestPreserveUnknownEnum.pbobjc.h" +#import "google/protobuf/UnittestRuntimeProto2.pbobjc.h" +#import "google/protobuf/UnittestRuntimeProto3.pbobjc.h" + +#ifndef GPBARRAYSIZE +#define GPBARRAYSIZE(a) ((sizeof(a) / sizeof((a[0])))) +#endif // GPBARRAYSIZE + +static NSData *DataFromCStr(const char *str) { + return [NSData dataWithBytes:str length:strlen(str)]; +} + +@interface MessageSerializationTests : GPBTestCase +@end + +@implementation MessageSerializationTests + +// TODO(thomasvl): Pull tests over from GPBMessageTests that are serialization +// specific. + +- (void)testProto3SerializationHandlingDefaults { + // Proto2 covered in other tests. + + Message3 *msg = [[Message3 alloc] init]; + + // Add defaults, no output. + + NSData *data = [msg data]; + XCTAssertEqual([data length], 0U); + + // All zeros, still nothing. + + msg.optionalInt32 = 0; + msg.optionalInt64 = 0; + msg.optionalUint32 = 0; + msg.optionalUint64 = 0; + msg.optionalSint32 = 0; + msg.optionalSint64 = 0; + msg.optionalFixed32 = 0; + msg.optionalFixed64 = 0; + msg.optionalSfixed32 = 0; + msg.optionalSfixed64 = 0; + msg.optionalFloat = 0.0f; + msg.optionalDouble = 0.0; + msg.optionalBool = NO; + msg.optionalString = @""; + msg.optionalBytes = [NSData data]; + msg.optionalEnum = Message3_Enum_Foo; // first value + + data = [msg data]; + XCTAssertEqual([data length], 0U); + + // The two that also take nil as nothing. + + msg.optionalString = nil; + msg.optionalBytes = nil; + + data = [msg data]; + XCTAssertEqual([data length], 0U); + + // Set one field... + + msg.optionalInt32 = 1; + + data = [msg data]; + const uint8_t expectedBytes[] = {0x08, 0x01}; + NSData *expected = [NSData dataWithBytes:expectedBytes length:2]; + XCTAssertEqualObjects(data, expected); + + // Back to zero... + + msg.optionalInt32 = 0; + + data = [msg data]; + XCTAssertEqual([data length], 0U); + + [msg release]; +} + +- (void)testProto3DroppingUnknownFields { + DropUnknownsFooWithExtraFields *fooWithExtras = + [[DropUnknownsFooWithExtraFields alloc] init]; + + fooWithExtras.int32Value = 1; + fooWithExtras.enumValue = DropUnknownsFooWithExtraFields_NestedEnum_Baz; + fooWithExtras.extraInt32Value = 2; + + DropUnknownsFoo *foo = [DropUnknownsFoo parseFromData:[fooWithExtras data]]; + + XCTAssertEqual(foo.int32Value, 1); + XCTAssertEqual(foo.enumValue, DropUnknownsFoo_NestedEnum_Baz); + // Nothing should end up in the unknowns. + XCTAssertEqual([foo.unknownFields countOfFields], 0U); + + [fooWithExtras release]; + fooWithExtras = [DropUnknownsFooWithExtraFields parseFromData:[foo data]]; + XCTAssertEqual(fooWithExtras.int32Value, 1); + XCTAssertEqual(fooWithExtras.enumValue, + DropUnknownsFooWithExtraFields_NestedEnum_Baz); + // And the extra value is gone (back to the default). + XCTAssertEqual(fooWithExtras.extraInt32Value, 0); + XCTAssertEqual([foo.unknownFields countOfFields], 0U); +} + +- (void)testProto2UnknownEnumToUnknownField { + Message3 *orig = [[Message3 alloc] init]; + + orig.optionalEnum = Message3_Enum_Extra3; + orig.repeatedEnumArray = + [GPBEnumArray arrayWithValidationFunction:Message3_Enum_IsValidValue + rawValue:Message3_Enum_Extra3]; + orig.repeatedPackedEnumArray = + [GPBEnumArray arrayWithValidationFunction:Message3_Enum_IsValidValue + rawValue:Message3_Enum_Extra3]; + orig.oneofEnum = Message3_Enum_Extra3; + + Message2 *msg = [[Message2 alloc] initWithData:[orig data]]; + + // None of the fields should be set. + + XCTAssertFalse(msg.hasOptionalEnum); + XCTAssertEqual(msg.repeatedEnumArray.count, 0U); + XCTAssertEqual(msg.repeatedPackedEnumArray.count, 0U); + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase); + + // All the values should be in unknown fields. + + GPBUnknownFieldSet *unknownFields = msg.unknownFields; + + XCTAssertEqual([unknownFields countOfFields], 4U); + XCTAssertTrue([unknownFields hasField:Message2_FieldNumber_OptionalEnum]); + XCTAssertTrue( + [unknownFields hasField:Message2_FieldNumber_RepeatedEnumArray]); + XCTAssertTrue( + [unknownFields hasField:Message2_FieldNumber_RepeatedPackedEnumArray]); + XCTAssertTrue([unknownFields hasField:Message2_FieldNumber_OneofEnum]); + + GPBField *field = [unknownFields getField:Message2_FieldNumber_OptionalEnum]; + XCTAssertEqual(field.varintList.count, 1U); + XCTAssertEqual([field.varintList valueAtIndex:0], + (uint64_t)Message3_Enum_Extra3); + + field = [unknownFields getField:Message2_FieldNumber_RepeatedEnumArray]; + XCTAssertEqual(field.varintList.count, 1U); + XCTAssertEqual([field.varintList valueAtIndex:0], + (uint64_t)Message3_Enum_Extra3); + + field = [unknownFields getField:Message2_FieldNumber_RepeatedPackedEnumArray]; + XCTAssertEqual(field.varintList.count, 1U); + XCTAssertEqual([field.varintList valueAtIndex:0], + (uint64_t)Message3_Enum_Extra3); + + field = [unknownFields getField:Message2_FieldNumber_OneofEnum]; + XCTAssertEqual(field.varintList.count, 1U); + XCTAssertEqual([field.varintList valueAtIndex:0], + (uint64_t)Message3_Enum_Extra3); + + [msg release]; + [orig release]; +} + +- (void)testProto3UnknownEnumPreserving { + UnknownEnumsMyMessagePlusExtra *orig = + [UnknownEnumsMyMessagePlusExtra message]; + + orig.e = UnknownEnumsMyEnumPlusExtra_EExtra; + orig.repeatedEArray = [GPBEnumArray + arrayWithValidationFunction:UnknownEnumsMyEnumPlusExtra_IsValidValue + rawValue:UnknownEnumsMyEnumPlusExtra_EExtra]; + orig.repeatedPackedEArray = [GPBEnumArray + arrayWithValidationFunction:UnknownEnumsMyEnumPlusExtra_IsValidValue + rawValue:UnknownEnumsMyEnumPlusExtra_EExtra]; + orig.oneofE1 = UnknownEnumsMyEnumPlusExtra_EExtra; + + // Everything should be there via raw values. + + UnknownEnumsMyMessage *msg = + [UnknownEnumsMyMessage parseFromData:[orig data]]; + + XCTAssertEqual(msg.e, UnknownEnumsMyEnum_GPBUnrecognizedEnumeratorValue); + XCTAssertEqual(UnknownEnumsMyMessage_E_RawValue(msg), + UnknownEnumsMyEnumPlusExtra_EExtra); + XCTAssertEqual(msg.repeatedEArray.count, 1U); + XCTAssertEqual([msg.repeatedEArray valueAtIndex:0], + UnknownEnumsMyEnum_GPBUnrecognizedEnumeratorValue); + XCTAssertEqual([msg.repeatedEArray rawValueAtIndex:0], + (UnknownEnumsMyEnum)UnknownEnumsMyEnumPlusExtra_EExtra); + XCTAssertEqual(msg.repeatedPackedEArray.count, 1U); + XCTAssertEqual([msg.repeatedPackedEArray valueAtIndex:0], + UnknownEnumsMyEnum_GPBUnrecognizedEnumeratorValue); + XCTAssertEqual([msg.repeatedPackedEArray rawValueAtIndex:0], + (UnknownEnumsMyEnum)UnknownEnumsMyEnumPlusExtra_EExtra); + XCTAssertEqual(msg.oneofE1, + UnknownEnumsMyEnum_GPBUnrecognizedEnumeratorValue); + XCTAssertEqual(UnknownEnumsMyMessage_OneofE1_RawValue(msg), + UnknownEnumsMyEnumPlusExtra_EExtra); + + // Everything should go out and come back. + + orig = [UnknownEnumsMyMessagePlusExtra parseFromData:[msg data]]; + + XCTAssertEqual(orig.e, UnknownEnumsMyEnumPlusExtra_EExtra); + XCTAssertEqual(orig.repeatedEArray.count, 1U); + XCTAssertEqual([orig.repeatedEArray valueAtIndex:0], + UnknownEnumsMyEnumPlusExtra_EExtra); + XCTAssertEqual(orig.repeatedPackedEArray.count, 1U); + XCTAssertEqual([orig.repeatedPackedEArray valueAtIndex:0], + UnknownEnumsMyEnumPlusExtra_EExtra); + XCTAssertEqual(orig.oneofE1, UnknownEnumsMyEnumPlusExtra_EExtra); +} + +//%PDDM-DEFINE TEST_ROUNDTRIP_ONEOF(MESSAGE, FIELD, VALUE) +//%TEST_ROUNDTRIP_ONEOF_ADV(MESSAGE, FIELD, VALUE, ) +//%PDDM-DEFINE TEST_ROUNDTRIP_ONEOF_ADV(MESSAGE, FIELD, VALUE, EQ_SUFFIX) +//% { // oneof##FIELD +//% MESSAGE *orig = [[MESSAGE alloc] init]; +//% orig.oneof##FIELD = VALUE; +//% XCTAssertEqual(orig.oOneOfCase, MESSAGE##_O_OneOfCase_Oneof##FIELD); +//% MESSAGE *msg = [MESSAGE parseFromData:[orig data]]; +//% XCTAssertEqual(msg.oOneOfCase, MESSAGE##_O_OneOfCase_Oneof##FIELD); +//% XCTAssertEqual##EQ_SUFFIX(msg.oneof##FIELD, VALUE); +//% [orig release]; +//% } +//% +//%PDDM-DEFINE TEST_ROUNDTRIP_ONEOFS(SYNTAX, BOOL_NON_DEFAULT) +//%- (void)testProto##SYNTAX##RoundTripOneof { +//% +//%GROUP_INIT##SYNTAX() Message##SYNTAX *subMessage = [[Message##SYNTAX alloc] init]; +//% XCTAssertNotNil(subMessage); +//% subMessage.optionalInt32 = 666; +//% +//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Int32, 1) +//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Int64, 2) +//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Uint32, 3U) +//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Uint64, 4U) +//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Sint32, 5) +//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Sint64, 6) +//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Fixed32, 7U) +//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Fixed64, 8U) +//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Sfixed32, 9) +//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Sfixed64, 10) +//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Float, 11.0f) +//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Double, 12.0) +//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Bool, BOOL_NON_DEFAULT) +//%TEST_ROUNDTRIP_ONEOF_ADV(Message##SYNTAX, String, @"foo", Objects) +//%TEST_ROUNDTRIP_ONEOF_ADV(Message##SYNTAX, Bytes, [@"bar" dataUsingEncoding:NSUTF8StringEncoding], Objects) +//%GROUP_TEST##SYNTAX()TEST_ROUNDTRIP_ONEOF_ADV(Message##SYNTAX, Message, subMessage, Objects) +//%TEST_ROUNDTRIP_ONEOF(Message##SYNTAX, Enum, Message2_Enum_Bar) +//%GROUP_CLEANUP##SYNTAX() [subMessage release]; +//%} +//% +//%PDDM-DEFINE GROUP_INIT2() +//% Message2_OneofGroup *group = [[Message2_OneofGroup alloc] init]; +//% XCTAssertNotNil(group); +//% group.a = 777; +//% +//%PDDM-DEFINE GROUP_CLEANUP2() +//% [group release]; +//% +//%PDDM-DEFINE GROUP_TEST2() +//%TEST_ROUNDTRIP_ONEOF_ADV(Message2, Group, group, Objects) +//% +//%PDDM-DEFINE GROUP_INIT3() +// Empty +//%PDDM-DEFINE GROUP_CLEANUP3() +// Empty +//%PDDM-DEFINE GROUP_TEST3() +//% // Not "group" in proto3. +//% +//% +//%PDDM-EXPAND TEST_ROUNDTRIP_ONEOFS(2, NO) +// This block of code is generated, do not edit it directly. + +- (void)testProto2RoundTripOneof { + + Message2_OneofGroup *group = [[Message2_OneofGroup alloc] init]; + XCTAssertNotNil(group); + group.a = 777; + Message2 *subMessage = [[Message2 alloc] init]; + XCTAssertNotNil(subMessage); + subMessage.optionalInt32 = 666; + + { // oneofInt32 + Message2 *orig = [[Message2 alloc] init]; + orig.oneofInt32 = 1; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofInt32); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt32); + XCTAssertEqual(msg.oneofInt32, 1); + [orig release]; + } + + { // oneofInt64 + Message2 *orig = [[Message2 alloc] init]; + orig.oneofInt64 = 2; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofInt64); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt64); + XCTAssertEqual(msg.oneofInt64, 2); + [orig release]; + } + + { // oneofUint32 + Message2 *orig = [[Message2 alloc] init]; + orig.oneofUint32 = 3U; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofUint32); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint32); + XCTAssertEqual(msg.oneofUint32, 3U); + [orig release]; + } + + { // oneofUint64 + Message2 *orig = [[Message2 alloc] init]; + orig.oneofUint64 = 4U; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofUint64); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint64); + XCTAssertEqual(msg.oneofUint64, 4U); + [orig release]; + } + + { // oneofSint32 + Message2 *orig = [[Message2 alloc] init]; + orig.oneofSint32 = 5; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofSint32); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint32); + XCTAssertEqual(msg.oneofSint32, 5); + [orig release]; + } + + { // oneofSint64 + Message2 *orig = [[Message2 alloc] init]; + orig.oneofSint64 = 6; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofSint64); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint64); + XCTAssertEqual(msg.oneofSint64, 6); + [orig release]; + } + + { // oneofFixed32 + Message2 *orig = [[Message2 alloc] init]; + orig.oneofFixed32 = 7U; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofFixed32); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed32); + XCTAssertEqual(msg.oneofFixed32, 7U); + [orig release]; + } + + { // oneofFixed64 + Message2 *orig = [[Message2 alloc] init]; + orig.oneofFixed64 = 8U; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofFixed64); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed64); + XCTAssertEqual(msg.oneofFixed64, 8U); + [orig release]; + } + + { // oneofSfixed32 + Message2 *orig = [[Message2 alloc] init]; + orig.oneofSfixed32 = 9; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofSfixed32); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed32); + XCTAssertEqual(msg.oneofSfixed32, 9); + [orig release]; + } + + { // oneofSfixed64 + Message2 *orig = [[Message2 alloc] init]; + orig.oneofSfixed64 = 10; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofSfixed64); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed64); + XCTAssertEqual(msg.oneofSfixed64, 10); + [orig release]; + } + + { // oneofFloat + Message2 *orig = [[Message2 alloc] init]; + orig.oneofFloat = 11.0f; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofFloat); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFloat); + XCTAssertEqual(msg.oneofFloat, 11.0f); + [orig release]; + } + + { // oneofDouble + Message2 *orig = [[Message2 alloc] init]; + orig.oneofDouble = 12.0; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofDouble); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofDouble); + XCTAssertEqual(msg.oneofDouble, 12.0); + [orig release]; + } + + { // oneofBool + Message2 *orig = [[Message2 alloc] init]; + orig.oneofBool = NO; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofBool); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBool); + XCTAssertEqual(msg.oneofBool, NO); + [orig release]; + } + + { // oneofString + Message2 *orig = [[Message2 alloc] init]; + orig.oneofString = @"foo"; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofString); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofString); + XCTAssertEqualObjects(msg.oneofString, @"foo"); + [orig release]; + } + + { // oneofBytes + Message2 *orig = [[Message2 alloc] init]; + orig.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding]; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofBytes); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBytes); + XCTAssertEqualObjects(msg.oneofBytes, [@"bar" dataUsingEncoding:NSUTF8StringEncoding]); + [orig release]; + } + + { // oneofGroup + Message2 *orig = [[Message2 alloc] init]; + orig.oneofGroup = group; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofGroup); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofGroup); + XCTAssertEqualObjects(msg.oneofGroup, group); + [orig release]; + } + + { // oneofMessage + Message2 *orig = [[Message2 alloc] init]; + orig.oneofMessage = subMessage; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofMessage); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofMessage); + XCTAssertEqualObjects(msg.oneofMessage, subMessage); + [orig release]; + } + + { // oneofEnum + Message2 *orig = [[Message2 alloc] init]; + orig.oneofEnum = Message2_Enum_Bar; + XCTAssertEqual(orig.oOneOfCase, Message2_O_OneOfCase_OneofEnum); + Message2 *msg = [Message2 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofEnum); + XCTAssertEqual(msg.oneofEnum, Message2_Enum_Bar); + [orig release]; + } + + [group release]; + [subMessage release]; +} + +//%PDDM-EXPAND TEST_ROUNDTRIP_ONEOFS(3, YES) +// This block of code is generated, do not edit it directly. + +- (void)testProto3RoundTripOneof { + + Message3 *subMessage = [[Message3 alloc] init]; + XCTAssertNotNil(subMessage); + subMessage.optionalInt32 = 666; + + { // oneofInt32 + Message3 *orig = [[Message3 alloc] init]; + orig.oneofInt32 = 1; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofInt32); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt32); + XCTAssertEqual(msg.oneofInt32, 1); + [orig release]; + } + + { // oneofInt64 + Message3 *orig = [[Message3 alloc] init]; + orig.oneofInt64 = 2; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofInt64); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt64); + XCTAssertEqual(msg.oneofInt64, 2); + [orig release]; + } + + { // oneofUint32 + Message3 *orig = [[Message3 alloc] init]; + orig.oneofUint32 = 3U; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofUint32); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint32); + XCTAssertEqual(msg.oneofUint32, 3U); + [orig release]; + } + + { // oneofUint64 + Message3 *orig = [[Message3 alloc] init]; + orig.oneofUint64 = 4U; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofUint64); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint64); + XCTAssertEqual(msg.oneofUint64, 4U); + [orig release]; + } + + { // oneofSint32 + Message3 *orig = [[Message3 alloc] init]; + orig.oneofSint32 = 5; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofSint32); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint32); + XCTAssertEqual(msg.oneofSint32, 5); + [orig release]; + } + + { // oneofSint64 + Message3 *orig = [[Message3 alloc] init]; + orig.oneofSint64 = 6; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofSint64); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint64); + XCTAssertEqual(msg.oneofSint64, 6); + [orig release]; + } + + { // oneofFixed32 + Message3 *orig = [[Message3 alloc] init]; + orig.oneofFixed32 = 7U; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofFixed32); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed32); + XCTAssertEqual(msg.oneofFixed32, 7U); + [orig release]; + } + + { // oneofFixed64 + Message3 *orig = [[Message3 alloc] init]; + orig.oneofFixed64 = 8U; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofFixed64); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed64); + XCTAssertEqual(msg.oneofFixed64, 8U); + [orig release]; + } + + { // oneofSfixed32 + Message3 *orig = [[Message3 alloc] init]; + orig.oneofSfixed32 = 9; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofSfixed32); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed32); + XCTAssertEqual(msg.oneofSfixed32, 9); + [orig release]; + } + + { // oneofSfixed64 + Message3 *orig = [[Message3 alloc] init]; + orig.oneofSfixed64 = 10; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofSfixed64); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed64); + XCTAssertEqual(msg.oneofSfixed64, 10); + [orig release]; + } + + { // oneofFloat + Message3 *orig = [[Message3 alloc] init]; + orig.oneofFloat = 11.0f; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofFloat); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFloat); + XCTAssertEqual(msg.oneofFloat, 11.0f); + [orig release]; + } + + { // oneofDouble + Message3 *orig = [[Message3 alloc] init]; + orig.oneofDouble = 12.0; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofDouble); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofDouble); + XCTAssertEqual(msg.oneofDouble, 12.0); + [orig release]; + } + + { // oneofBool + Message3 *orig = [[Message3 alloc] init]; + orig.oneofBool = YES; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofBool); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBool); + XCTAssertEqual(msg.oneofBool, YES); + [orig release]; + } + + { // oneofString + Message3 *orig = [[Message3 alloc] init]; + orig.oneofString = @"foo"; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofString); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofString); + XCTAssertEqualObjects(msg.oneofString, @"foo"); + [orig release]; + } + + { // oneofBytes + Message3 *orig = [[Message3 alloc] init]; + orig.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding]; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofBytes); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBytes); + XCTAssertEqualObjects(msg.oneofBytes, [@"bar" dataUsingEncoding:NSUTF8StringEncoding]); + [orig release]; + } + + // Not "group" in proto3. + + { // oneofMessage + Message3 *orig = [[Message3 alloc] init]; + orig.oneofMessage = subMessage; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofMessage); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofMessage); + XCTAssertEqualObjects(msg.oneofMessage, subMessage); + [orig release]; + } + + { // oneofEnum + Message3 *orig = [[Message3 alloc] init]; + orig.oneofEnum = Message2_Enum_Bar; + XCTAssertEqual(orig.oOneOfCase, Message3_O_OneOfCase_OneofEnum); + Message3 *msg = [Message3 parseFromData:[orig data]]; + XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofEnum); + XCTAssertEqual(msg.oneofEnum, Message2_Enum_Bar); + [orig release]; + } + + [subMessage release]; +} + +//%PDDM-EXPAND-END (2 expansions) + +#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]; + XCTAssertEqual(msg.mapInt32Int32.count, 1U); + int32_t val = 666; + 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]; + XCTAssertEqual(msg.mapInt32Int32.count, 1U); + int32_t val = 666; + 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]; + XCTAssertEqual(msg.mapInt32Int32.count, 1U); + int32_t val = 666; + 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]; + XCTAssertEqual(msg.mapInt32Int32.count, 1U); + int32_t val = 666; + 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]; + XCTAssertEqual(msg.mapInt32Int32.count, 1U); + int32_t val = 666; + 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]; + XCTAssertEqual(msg.mapInt32Int32.count, 1U); + int32_t val = 666; + 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]; + XCTAssertEqual(msg.mapInt32Int32.count, 1U); + int32_t val = 666; + 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"); + + XCTAssertThrowsSpecificNamed([TestMap parseFromData:data], NSException, + NSParseErrorException); +} + +// 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 setValue:Proto2MapEnumPlusExtra_EProto2MapEnumFoo + forKey:0]; + [orig.unknownMapField setValue:Proto2MapEnumPlusExtra_EProto2MapEnumExtra + forKey:0]; + + TestEnumMap *msg1 = [TestEnumMap parseFromData:[orig data]]; + XCTAssertEqual(msg1.knownMapField.count, 1U); + int32_t val = -1; + XCTAssertTrue([msg1.knownMapField valueForKey:0 value:&val]); + XCTAssertEqual(val, Proto2MapEnum_Proto2MapEnumFoo); + XCTAssertEqual(msg1.unknownFields.countOfFields, 1U); + + TestEnumMapPlusExtra *msg2 = [TestEnumMapPlusExtra parseFromData:[msg1 data]]; + val = -1; + XCTAssertEqual(msg2.knownMapField.count, 1U); + XCTAssertTrue([msg2.knownMapField valueForKey:0 value:&val]); + XCTAssertEqual(val, Proto2MapEnumPlusExtra_EProto2MapEnumFoo); + val = -1; + XCTAssertEqual(msg2.unknownMapField.count, 1U); + XCTAssertTrue([msg2.unknownMapField valueForKey:0 value:&val]); + XCTAssertEqual(val, Proto2MapEnumPlusExtra_EProto2MapEnumExtra); + XCTAssertEqual(msg2.unknownFields.countOfFields, 0U); + + XCTAssertEqualObjects(orig, msg2); + + [orig release]; +} + +#pragma mark - + +@end -- cgit v1.2.3