blob: 3bcfae0a772800515120018e121dbffa61d9caa8 [file] [log] [blame]
Thomas Van Lenten30650d82015-05-01 08:57:16 -04001// Protocol Buffers - Google's data interchange format
2// Copyright 2015 Google Inc. All rights reserved.
3// https://developers.google.com/protocol-buffers/
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#import "GPBTestUtilities.h"
32
33#import <objc/runtime.h>
34
35#import "GPBMessage.h"
36
Thomas Van Lenten28bc3ba2022-08-23 17:23:28 -040037#import "objectivec/Tests/MapUnittest.pbobjc.h"
38#import "objectivec/Tests/Unittest.pbobjc.h"
39#import "objectivec/Tests/UnittestCycle.pbobjc.h"
40#import "objectivec/Tests/UnittestObjcStartup.pbobjc.h"
41#import "objectivec/Tests/UnittestRuntimeProto2.pbobjc.h"
42#import "objectivec/Tests/UnittestRuntimeProto3.pbobjc.h"
Thomas Van Lenten30650d82015-05-01 08:57:16 -040043
44@interface MessageRuntimeTests : GPBTestCase
45@end
46
47@implementation MessageRuntimeTests
48
49// TODO(thomasvl): Pull tests over from GPBMessageTests that are runtime
50// specific.
51
Thomas Van Lentend846b0b2015-06-08 16:24:57 -040052- (void)testStartupOrdering {
Thomas Van Lenten13a41242016-09-01 11:45:50 -040053 // Message class/Root class initialization is a little tricky, so these just
54 // create some possible patterns that can be a problem. The messages don't
55 // have to be exercised, just creating them is enough to test. If there
56 // is a problem, the runtime should assert or hang.
57 //
58 // Note: the messages from these proto files should not be used in any other
59 // tests, that way when they are referenced here it will be the first use and
60 // initialization will take place now.
61
Thomas Van Lentend846b0b2015-06-08 16:24:57 -040062 TestObjCStartupMessage *message = [TestObjCStartupMessage message];
63 XCTAssertNotNil(message);
Thomas Van Lenten13a41242016-09-01 11:45:50 -040064
65 CycleBaz *baz = [CycleBaz message];
66 CycleBar *bar = [CycleBar message];
67 CycleFoo *foo = [CycleFoo message];
68 XCTAssertNotNil(baz);
69 XCTAssertNotNil(bar);
70 XCTAssertNotNil(foo);
Thomas Van Lentend846b0b2015-06-08 16:24:57 -040071}
72
Thomas Van Lenten30650d82015-05-01 08:57:16 -040073- (void)testProto2HasMethodSupport {
74 NSArray *names = @[
75 @"Int32",
76 @"Int64",
77 @"Uint32",
78 @"Uint64",
79 @"Sint32",
80 @"Sint64",
81 @"Fixed32",
82 @"Fixed64",
83 @"Sfixed32",
84 @"Sfixed64",
85 @"Float",
86 @"Double",
87 @"Bool",
88 @"String",
89 @"Bytes",
90 @"Group",
91 @"Message",
92 @"Enum",
93 ];
94
95 // Proto2 gets:
Thomas Van Lentend846b0b2015-06-08 16:24:57 -040096
97 // Single fields - has*/setHas* is valid.
Thomas Van Lenten30650d82015-05-01 08:57:16 -040098
99 for (NSString *name in names) {
100 // build the selector, i.e. - hasOptionalInt32/setHasOptionalInt32:
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400101 SEL hasSel = NSSelectorFromString([NSString stringWithFormat:@"hasOptional%@", name]);
102 SEL setHasSel = NSSelectorFromString([NSString stringWithFormat:@"setHasOptional%@:", name]);
103 XCTAssertTrue([Message2 instancesRespondToSelector:hasSel], @"field: %@", name);
104 XCTAssertTrue([Message2 instancesRespondToSelector:setHasSel], @"field: %@", name);
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400105 }
106
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400107 // Repeated fields
108 // - no has*/setHas*
109 // - *Count
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400110
111 for (NSString *name in names) {
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400112 // build the selector, i.e. - hasRepeatedInt32Array/setHasRepeatedInt32Array:
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400113 SEL hasSel = NSSelectorFromString([NSString stringWithFormat:@"hasRepeated%@Array", name]);
114 SEL setHasSel =
115 NSSelectorFromString([NSString stringWithFormat:@"setHasRepeated%@Array:", name]);
116 XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@", name);
117 XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel], @"field: %@", name);
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400118 // build the selector, i.e. - repeatedInt32Array_Count
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400119 SEL countSel = NSSelectorFromString([NSString stringWithFormat:@"repeated%@Array_Count", name]);
120 XCTAssertTrue([Message2 instancesRespondToSelector:countSel], @"field: %@", name);
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400121 }
122
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400123 // OneOf fields - no has*/setHas*
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400124
125 for (NSString *name in names) {
126 // build the selector, i.e. - hasOneofInt32/setHasOneofInt32:
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400127 SEL hasSel = NSSelectorFromString([NSString stringWithFormat:@"hasOneof%@", name]);
128 SEL setHasSel = NSSelectorFromString([NSString stringWithFormat:@"setHasOneof%@:", name]);
129 XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@", name);
130 XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel], @"field: %@", name);
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400131 }
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400132
133 // map<> fields
134 // - no has*/setHas*
135 // - *Count
136
137 NSArray *mapNames = @[
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400138 @"Int32Int32", @"Int64Int64", @"Uint32Uint32", @"Uint64Uint64",
139 @"Sint32Sint32", @"Sint64Sint64", @"Fixed32Fixed32", @"Fixed64Fixed64",
140 @"Sfixed32Sfixed32", @"Sfixed64Sfixed64", @"Int32Float", @"Int32Double",
141 @"BoolBool", @"StringString", @"StringBytes", @"StringMessage",
142 @"Int32Bytes", @"Int32Enum", @"Int32Message",
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400143 ];
144
145 for (NSString *name in mapNames) {
146 // build the selector, i.e. - hasMapInt32Int32/setHasMapInt32Int32:
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400147 SEL hasSel = NSSelectorFromString([NSString stringWithFormat:@"hasMap%@", name]);
148 SEL setHasSel = NSSelectorFromString([NSString stringWithFormat:@"setHasMap%@:", name]);
149 XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@", name);
150 XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel], @"field: %@", name);
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400151 // build the selector, i.e. - mapInt32Int32Count
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400152 SEL countSel = NSSelectorFromString([NSString stringWithFormat:@"map%@_Count", name]);
153 XCTAssertTrue([Message2 instancesRespondToSelector:countSel], @"field: %@", name);
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400154 }
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400155}
156
157- (void)testProto3HasMethodSupport {
158 NSArray *names = @[
159 @"Int32",
160 @"Int64",
161 @"Uint32",
162 @"Uint64",
163 @"Sint32",
164 @"Sint64",
165 @"Fixed32",
166 @"Fixed64",
167 @"Sfixed32",
168 @"Sfixed64",
169 @"Float",
170 @"Double",
171 @"Bool",
172 @"String",
173 @"Bytes",
174 @"Message",
175 @"Enum",
176 ];
177
178 // Proto3 gets:
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400179
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400180 // Single fields
Brian Wignalla104dff2020-01-08 13:18:20 -0500181 // - has*/setHas* invalid for primitive types.
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400182 // - has*/setHas* valid for Message.
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400183
184 for (NSString *name in names) {
185 // build the selector, i.e. - hasOptionalInt32/setHasOptionalInt32:
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400186 SEL hasSel = NSSelectorFromString([NSString stringWithFormat:@"hasOptional%@", name]);
187 SEL setHasSel = NSSelectorFromString([NSString stringWithFormat:@"setHasOptional%@:", name]);
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400188 if ([name isEqual:@"Message"]) {
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400189 // Sub messages/groups are the exception.
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400190 XCTAssertTrue([Message3 instancesRespondToSelector:hasSel], @"field: %@", name);
191 XCTAssertTrue([Message3 instancesRespondToSelector:setHasSel], @"field: %@", name);
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400192 } else {
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400193 XCTAssertFalse([Message3 instancesRespondToSelector:hasSel], @"field: %@", name);
194 XCTAssertFalse([Message3 instancesRespondToSelector:setHasSel], @"field: %@", name);
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400195 }
196 }
197
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400198 // Repeated fields
199 // - no has*/setHas*
200 // - *Count
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400201
202 for (NSString *name in names) {
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400203 // build the selector, i.e. - hasRepeatedInt32Array/setHasRepeatedInt32Array:
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400204 SEL hasSel = NSSelectorFromString([NSString stringWithFormat:@"hasRepeated%@Array", name]);
205 SEL setHasSel =
206 NSSelectorFromString([NSString stringWithFormat:@"setHasRepeated%@Array:", name]);
207 XCTAssertFalse([Message3 instancesRespondToSelector:hasSel], @"field: %@", name);
208 XCTAssertFalse([Message3 instancesRespondToSelector:setHasSel], @"field: %@", name);
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400209 // build the selector, i.e. - repeatedInt32Array_Count
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400210 SEL countSel = NSSelectorFromString([NSString stringWithFormat:@"repeated%@Array_Count", name]);
211 XCTAssertTrue([Message3 instancesRespondToSelector:countSel], @"field: %@", name);
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400212 }
213
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400214 // OneOf fields - no has*/setHas*
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400215
216 for (NSString *name in names) {
217 // build the selector, i.e. - hasOneofInt32/setHasOneofInt32:
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400218 SEL hasSel = NSSelectorFromString([NSString stringWithFormat:@"hasOneof%@", name]);
219 SEL setHasSel = NSSelectorFromString([NSString stringWithFormat:@"setHasOneof%@:", name]);
220 XCTAssertFalse([Message3 instancesRespondToSelector:hasSel], @"field: %@", name);
221 XCTAssertFalse([Message3 instancesRespondToSelector:setHasSel], @"field: %@", name);
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400222 }
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400223
Thomas Van Lenten7b6016e2020-04-14 11:03:14 -0400224 // Single Optional fields
225 // - has*/setHas* thanks to the optional keyword in proto3, they exist
226 // for primitive types.
227 // - has*/setHas* valid for Message.
228
229 for (NSString *name in names) {
230 // build the selector, i.e. - hasOptionalInt32/setHasOptionalInt32:
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400231 SEL hasSel = NSSelectorFromString([NSString stringWithFormat:@"hasOptional%@", name]);
232 SEL setHasSel = NSSelectorFromString([NSString stringWithFormat:@"setHasOptional%@:", name]);
233 XCTAssertTrue([Message3Optional instancesRespondToSelector:hasSel], @"field: %@", name);
234 XCTAssertTrue([Message3Optional instancesRespondToSelector:setHasSel], @"field: %@", name);
Thomas Van Lenten7b6016e2020-04-14 11:03:14 -0400235 }
236
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400237 // map<> fields
238 // - no has*/setHas*
239 // - *Count
240
241 NSArray *mapNames = @[
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400242 @"Int32Int32", @"Int64Int64", @"Uint32Uint32", @"Uint64Uint64",
243 @"Sint32Sint32", @"Sint64Sint64", @"Fixed32Fixed32", @"Fixed64Fixed64",
244 @"Sfixed32Sfixed32", @"Sfixed64Sfixed64", @"Int32Float", @"Int32Double",
245 @"BoolBool", @"StringString", @"StringBytes", @"StringMessage",
246 @"Int32Bytes", @"Int32Enum", @"Int32Message",
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400247 ];
248
249 for (NSString *name in mapNames) {
250 // build the selector, i.e. - hasMapInt32Int32/setHasMapInt32Int32:
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400251 SEL hasSel = NSSelectorFromString([NSString stringWithFormat:@"hasMap%@", name]);
252 SEL setHasSel = NSSelectorFromString([NSString stringWithFormat:@"setHasMap%@:", name]);
253 XCTAssertFalse([Message3 instancesRespondToSelector:hasSel], @"field: %@", name);
254 XCTAssertFalse([Message3 instancesRespondToSelector:setHasSel], @"field: %@", name);
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400255 // build the selector, i.e. - mapInt32Int32Count
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400256 SEL countSel = NSSelectorFromString([NSString stringWithFormat:@"map%@_Count", name]);
257 XCTAssertTrue([Message3 instancesRespondToSelector:countSel], @"field: %@", name);
Thomas Van Lentend846b0b2015-06-08 16:24:57 -0400258 }
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400259}
260
261- (void)testProto2SingleFieldHasBehavior {
262 //
263 // Setting to any value including the default value (0) should result has*
264 // being true.
265 //
266
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400267 // Disable clang-format for the macros.
268 // clang-format off
Thomas Van Lenten9e069b22022-09-19 13:34:01 -0400269
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400270//%PDDM-DEFINE PROTO2_TEST_HAS_FIELD(FIELD, NON_ZERO_VALUE, ZERO_VALUE)
271//% { // optional##FIELD :: NON_ZERO_VALUE
272//% Message2 *msg = [[Message2 alloc] init];
273//% XCTAssertFalse(msg.hasOptional##FIELD);
274//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD));
275//% msg.optional##FIELD = NON_ZERO_VALUE;
276//% XCTAssertTrue(msg.hasOptional##FIELD);
277//% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD));
278//% [msg release];
279//% }
280//% { // optional##FIELD :: ZERO_VALUE
281//% Message2 *msg = [[Message2 alloc] init];
282//% XCTAssertFalse(msg.hasOptional##FIELD);
283//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD));
284//% msg.optional##FIELD = ZERO_VALUE;
285//% XCTAssertTrue(msg.hasOptional##FIELD);
286//% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD));
287//% [msg release];
288//% }
289//%
Thomas Van Lenten17d601a2016-08-12 11:46:55 -0400290//%PDDM-DEFINE PROTO2_TEST_CLEAR_FIELD_WITH_NIL(FIELD, VALUE)
291//% { // optional##FIELD
292//% Message2 *msg = [[Message2 alloc] init];
293//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD));
294//% msg.optional##FIELD = VALUE;
295//% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD));
296//% msg.optional##FIELD = nil;
297//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD));
298//% [msg release];
299//% }
300//%
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400301//%PDDM-DEFINE PROTO2_TEST_HAS_FIELDS()
302//%PROTO2_TEST_HAS_FIELD(Int32, 1, 0)
303//%PROTO2_TEST_HAS_FIELD(Int64, 1, 0)
304//%PROTO2_TEST_HAS_FIELD(Uint32, 1, 0)
305//%PROTO2_TEST_HAS_FIELD(Uint64, 1, 0)
306//%PROTO2_TEST_HAS_FIELD(Sint32, 1, 0)
307//%PROTO2_TEST_HAS_FIELD(Sint64, 1, 0)
308//%PROTO2_TEST_HAS_FIELD(Fixed32, 1, 0)
309//%PROTO2_TEST_HAS_FIELD(Fixed64, 1, 0)
310//%PROTO2_TEST_HAS_FIELD(Sfixed32, 1, 0)
311//%PROTO2_TEST_HAS_FIELD(Sfixed64, 1, 0)
312//%PROTO2_TEST_HAS_FIELD(Float, 1.0f, 0.0f)
313//%PROTO2_TEST_HAS_FIELD(Double, 1.0, 0.0)
314//%PROTO2_TEST_HAS_FIELD(Bool, YES, NO)
315//%PROTO2_TEST_HAS_FIELD(String, @"foo", @"")
316//%PROTO2_TEST_HAS_FIELD(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding], [NSData data])
317//% //
318//% // Test doesn't apply to optionalGroup/optionalMessage.
319//% //
320//%
321//%PROTO2_TEST_HAS_FIELD(Enum, Message2_Enum_Bar, Message2_Enum_Foo)
Thomas Van Lenten17d601a2016-08-12 11:46:55 -0400322//% //
323//% // Nil can also be used to clear strings, bytes, groups, and messages.
324//% //
325//%
326//%PROTO2_TEST_CLEAR_FIELD_WITH_NIL(String, @"foo")
327//%PROTO2_TEST_CLEAR_FIELD_WITH_NIL(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding])
328//%PROTO2_TEST_CLEAR_FIELD_WITH_NIL(Group, [Message2_OptionalGroup message])
329//%PROTO2_TEST_CLEAR_FIELD_WITH_NIL(Message, [Message2 message])
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400330//%PDDM-EXPAND PROTO2_TEST_HAS_FIELDS()
331// This block of code is generated, do not edit it directly.
332
333 { // optionalInt32 :: 1
334 Message2 *msg = [[Message2 alloc] init];
335 XCTAssertFalse(msg.hasOptionalInt32);
336 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt32));
337 msg.optionalInt32 = 1;
338 XCTAssertTrue(msg.hasOptionalInt32);
339 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt32));
340 [msg release];
341 }
342 { // optionalInt32 :: 0
343 Message2 *msg = [[Message2 alloc] init];
344 XCTAssertFalse(msg.hasOptionalInt32);
345 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt32));
346 msg.optionalInt32 = 0;
347 XCTAssertTrue(msg.hasOptionalInt32);
348 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt32));
349 [msg release];
350 }
351
352 { // optionalInt64 :: 1
353 Message2 *msg = [[Message2 alloc] init];
354 XCTAssertFalse(msg.hasOptionalInt64);
355 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt64));
356 msg.optionalInt64 = 1;
357 XCTAssertTrue(msg.hasOptionalInt64);
358 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt64));
359 [msg release];
360 }
361 { // optionalInt64 :: 0
362 Message2 *msg = [[Message2 alloc] init];
363 XCTAssertFalse(msg.hasOptionalInt64);
364 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt64));
365 msg.optionalInt64 = 0;
366 XCTAssertTrue(msg.hasOptionalInt64);
367 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt64));
368 [msg release];
369 }
370
371 { // optionalUint32 :: 1
372 Message2 *msg = [[Message2 alloc] init];
373 XCTAssertFalse(msg.hasOptionalUint32);
374 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint32));
375 msg.optionalUint32 = 1;
376 XCTAssertTrue(msg.hasOptionalUint32);
377 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint32));
378 [msg release];
379 }
380 { // optionalUint32 :: 0
381 Message2 *msg = [[Message2 alloc] init];
382 XCTAssertFalse(msg.hasOptionalUint32);
383 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint32));
384 msg.optionalUint32 = 0;
385 XCTAssertTrue(msg.hasOptionalUint32);
386 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint32));
387 [msg release];
388 }
389
390 { // optionalUint64 :: 1
391 Message2 *msg = [[Message2 alloc] init];
392 XCTAssertFalse(msg.hasOptionalUint64);
393 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint64));
394 msg.optionalUint64 = 1;
395 XCTAssertTrue(msg.hasOptionalUint64);
396 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint64));
397 [msg release];
398 }
399 { // optionalUint64 :: 0
400 Message2 *msg = [[Message2 alloc] init];
401 XCTAssertFalse(msg.hasOptionalUint64);
402 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint64));
403 msg.optionalUint64 = 0;
404 XCTAssertTrue(msg.hasOptionalUint64);
405 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint64));
406 [msg release];
407 }
408
409 { // optionalSint32 :: 1
410 Message2 *msg = [[Message2 alloc] init];
411 XCTAssertFalse(msg.hasOptionalSint32);
412 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint32));
413 msg.optionalSint32 = 1;
414 XCTAssertTrue(msg.hasOptionalSint32);
415 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint32));
416 [msg release];
417 }
418 { // optionalSint32 :: 0
419 Message2 *msg = [[Message2 alloc] init];
420 XCTAssertFalse(msg.hasOptionalSint32);
421 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint32));
422 msg.optionalSint32 = 0;
423 XCTAssertTrue(msg.hasOptionalSint32);
424 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint32));
425 [msg release];
426 }
427
428 { // optionalSint64 :: 1
429 Message2 *msg = [[Message2 alloc] init];
430 XCTAssertFalse(msg.hasOptionalSint64);
431 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint64));
432 msg.optionalSint64 = 1;
433 XCTAssertTrue(msg.hasOptionalSint64);
434 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint64));
435 [msg release];
436 }
437 { // optionalSint64 :: 0
438 Message2 *msg = [[Message2 alloc] init];
439 XCTAssertFalse(msg.hasOptionalSint64);
440 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint64));
441 msg.optionalSint64 = 0;
442 XCTAssertTrue(msg.hasOptionalSint64);
443 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint64));
444 [msg release];
445 }
446
447 { // optionalFixed32 :: 1
448 Message2 *msg = [[Message2 alloc] init];
449 XCTAssertFalse(msg.hasOptionalFixed32);
450 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed32));
451 msg.optionalFixed32 = 1;
452 XCTAssertTrue(msg.hasOptionalFixed32);
453 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed32));
454 [msg release];
455 }
456 { // optionalFixed32 :: 0
457 Message2 *msg = [[Message2 alloc] init];
458 XCTAssertFalse(msg.hasOptionalFixed32);
459 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed32));
460 msg.optionalFixed32 = 0;
461 XCTAssertTrue(msg.hasOptionalFixed32);
462 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed32));
463 [msg release];
464 }
465
466 { // optionalFixed64 :: 1
467 Message2 *msg = [[Message2 alloc] init];
468 XCTAssertFalse(msg.hasOptionalFixed64);
469 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed64));
470 msg.optionalFixed64 = 1;
471 XCTAssertTrue(msg.hasOptionalFixed64);
472 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed64));
473 [msg release];
474 }
475 { // optionalFixed64 :: 0
476 Message2 *msg = [[Message2 alloc] init];
477 XCTAssertFalse(msg.hasOptionalFixed64);
478 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed64));
479 msg.optionalFixed64 = 0;
480 XCTAssertTrue(msg.hasOptionalFixed64);
481 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed64));
482 [msg release];
483 }
484
485 { // optionalSfixed32 :: 1
486 Message2 *msg = [[Message2 alloc] init];
487 XCTAssertFalse(msg.hasOptionalSfixed32);
488 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed32));
489 msg.optionalSfixed32 = 1;
490 XCTAssertTrue(msg.hasOptionalSfixed32);
491 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed32));
492 [msg release];
493 }
494 { // optionalSfixed32 :: 0
495 Message2 *msg = [[Message2 alloc] init];
496 XCTAssertFalse(msg.hasOptionalSfixed32);
497 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed32));
498 msg.optionalSfixed32 = 0;
499 XCTAssertTrue(msg.hasOptionalSfixed32);
500 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed32));
501 [msg release];
502 }
503
504 { // optionalSfixed64 :: 1
505 Message2 *msg = [[Message2 alloc] init];
506 XCTAssertFalse(msg.hasOptionalSfixed64);
507 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed64));
508 msg.optionalSfixed64 = 1;
509 XCTAssertTrue(msg.hasOptionalSfixed64);
510 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed64));
511 [msg release];
512 }
513 { // optionalSfixed64 :: 0
514 Message2 *msg = [[Message2 alloc] init];
515 XCTAssertFalse(msg.hasOptionalSfixed64);
516 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed64));
517 msg.optionalSfixed64 = 0;
518 XCTAssertTrue(msg.hasOptionalSfixed64);
519 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed64));
520 [msg release];
521 }
522
523 { // optionalFloat :: 1.0f
524 Message2 *msg = [[Message2 alloc] init];
525 XCTAssertFalse(msg.hasOptionalFloat);
526 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFloat));
527 msg.optionalFloat = 1.0f;
528 XCTAssertTrue(msg.hasOptionalFloat);
529 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFloat));
530 [msg release];
531 }
532 { // optionalFloat :: 0.0f
533 Message2 *msg = [[Message2 alloc] init];
534 XCTAssertFalse(msg.hasOptionalFloat);
535 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFloat));
536 msg.optionalFloat = 0.0f;
537 XCTAssertTrue(msg.hasOptionalFloat);
538 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFloat));
539 [msg release];
540 }
541
542 { // optionalDouble :: 1.0
543 Message2 *msg = [[Message2 alloc] init];
544 XCTAssertFalse(msg.hasOptionalDouble);
545 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalDouble));
546 msg.optionalDouble = 1.0;
547 XCTAssertTrue(msg.hasOptionalDouble);
548 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalDouble));
549 [msg release];
550 }
551 { // optionalDouble :: 0.0
552 Message2 *msg = [[Message2 alloc] init];
553 XCTAssertFalse(msg.hasOptionalDouble);
554 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalDouble));
555 msg.optionalDouble = 0.0;
556 XCTAssertTrue(msg.hasOptionalDouble);
557 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalDouble));
558 [msg release];
559 }
560
561 { // optionalBool :: YES
562 Message2 *msg = [[Message2 alloc] init];
563 XCTAssertFalse(msg.hasOptionalBool);
564 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBool));
565 msg.optionalBool = YES;
566 XCTAssertTrue(msg.hasOptionalBool);
567 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBool));
568 [msg release];
569 }
570 { // optionalBool :: NO
571 Message2 *msg = [[Message2 alloc] init];
572 XCTAssertFalse(msg.hasOptionalBool);
573 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBool));
574 msg.optionalBool = NO;
575 XCTAssertTrue(msg.hasOptionalBool);
576 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBool));
577 [msg release];
578 }
579
580 { // optionalString :: @"foo"
581 Message2 *msg = [[Message2 alloc] init];
582 XCTAssertFalse(msg.hasOptionalString);
583 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString));
584 msg.optionalString = @"foo";
585 XCTAssertTrue(msg.hasOptionalString);
586 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString));
587 [msg release];
588 }
589 { // optionalString :: @""
590 Message2 *msg = [[Message2 alloc] init];
591 XCTAssertFalse(msg.hasOptionalString);
592 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString));
593 msg.optionalString = @"";
594 XCTAssertTrue(msg.hasOptionalString);
595 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString));
596 [msg release];
597 }
598
599 { // optionalBytes :: [@"foo" dataUsingEncoding:NSUTF8StringEncoding]
600 Message2 *msg = [[Message2 alloc] init];
601 XCTAssertFalse(msg.hasOptionalBytes);
602 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes));
603 msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding];
604 XCTAssertTrue(msg.hasOptionalBytes);
605 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes));
606 [msg release];
607 }
608 { // optionalBytes :: [NSData data]
609 Message2 *msg = [[Message2 alloc] init];
610 XCTAssertFalse(msg.hasOptionalBytes);
611 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes));
612 msg.optionalBytes = [NSData data];
613 XCTAssertTrue(msg.hasOptionalBytes);
614 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes));
615 [msg release];
616 }
617
618 //
619 // Test doesn't apply to optionalGroup/optionalMessage.
620 //
621
622 { // optionalEnum :: Message2_Enum_Bar
623 Message2 *msg = [[Message2 alloc] init];
624 XCTAssertFalse(msg.hasOptionalEnum);
625 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalEnum));
626 msg.optionalEnum = Message2_Enum_Bar;
627 XCTAssertTrue(msg.hasOptionalEnum);
628 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalEnum));
629 [msg release];
630 }
631 { // optionalEnum :: Message2_Enum_Foo
632 Message2 *msg = [[Message2 alloc] init];
633 XCTAssertFalse(msg.hasOptionalEnum);
634 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalEnum));
635 msg.optionalEnum = Message2_Enum_Foo;
636 XCTAssertTrue(msg.hasOptionalEnum);
637 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalEnum));
638 [msg release];
639 }
640
Thomas Van Lenten17d601a2016-08-12 11:46:55 -0400641 //
642 // Nil can also be used to clear strings, bytes, groups, and messages.
643 //
644
645 { // optionalString
646 Message2 *msg = [[Message2 alloc] init];
647 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString));
648 msg.optionalString = @"foo";
649 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString));
650 msg.optionalString = nil;
651 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString));
652 [msg release];
653 }
654
655 { // optionalBytes
656 Message2 *msg = [[Message2 alloc] init];
657 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes));
658 msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding];
659 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes));
660 msg.optionalBytes = nil;
661 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes));
662 [msg release];
663 }
664
665 { // optionalGroup
666 Message2 *msg = [[Message2 alloc] init];
667 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalGroup));
668 msg.optionalGroup = [Message2_OptionalGroup message];
669 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalGroup));
670 msg.optionalGroup = nil;
671 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalGroup));
672 [msg release];
673 }
674
675 { // optionalMessage
676 Message2 *msg = [[Message2 alloc] init];
677 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalMessage));
678 msg.optionalMessage = [Message2 message];
679 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalMessage));
680 msg.optionalMessage = nil;
681 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalMessage));
682 [msg release];
683 }
684
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400685//%PDDM-EXPAND-END PROTO2_TEST_HAS_FIELDS()
Thomas Van Lenten9e069b22022-09-19 13:34:01 -0400686
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400687 // clang-format on
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400688}
689
690- (void)testProto3SingleFieldHasBehavior {
691 //
Thomas Van Lenten17d601a2016-08-12 11:46:55 -0400692 // Setting to any value but the default value (0) should result has*
693 // being true. When set to the default, shouldn't be true.
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400694 //
695
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400696 // Disable clang-format for the macros.
697 // clang-format off
Thomas Van Lenten9e069b22022-09-19 13:34:01 -0400698
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400699//%PDDM-DEFINE PROTO3_TEST_HAS_FIELD(FIELD, NON_ZERO_VALUE, ZERO_VALUE)
700//% { // optional##FIELD
701//% Message3 *msg = [[Message3 alloc] init];
702//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD));
703//% msg.optional##FIELD = NON_ZERO_VALUE;
704//% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD));
705//% msg.optional##FIELD = ZERO_VALUE;
706//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD));
707//% [msg release];
708//% }
709//%
Thomas Van Lenten17d601a2016-08-12 11:46:55 -0400710//%PDDM-DEFINE PROTO3_TEST_CLEAR_FIELD_WITH_NIL(FIELD, VALUE)
711//% { // optional##FIELD
712//% Message3 *msg = [[Message3 alloc] init];
713//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD));
714//% msg.optional##FIELD = VALUE;
715//% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD));
716//% msg.optional##FIELD = nil;
717//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD));
718//% [msg release];
719//% }
720//%
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400721//%PDDM-DEFINE PROTO3_TEST_HAS_FIELDS()
722//%PROTO3_TEST_HAS_FIELD(Int32, 1, 0)
723//%PROTO3_TEST_HAS_FIELD(Int64, 1, 0)
724//%PROTO3_TEST_HAS_FIELD(Uint32, 1, 0)
725//%PROTO3_TEST_HAS_FIELD(Uint64, 1, 0)
726//%PROTO3_TEST_HAS_FIELD(Sint32, 1, 0)
727//%PROTO3_TEST_HAS_FIELD(Sint64, 1, 0)
728//%PROTO3_TEST_HAS_FIELD(Fixed32, 1, 0)
729//%PROTO3_TEST_HAS_FIELD(Fixed64, 1, 0)
730//%PROTO3_TEST_HAS_FIELD(Sfixed32, 1, 0)
731//%PROTO3_TEST_HAS_FIELD(Sfixed64, 1, 0)
732//%PROTO3_TEST_HAS_FIELD(Float, 1.0f, 0.0f)
733//%PROTO3_TEST_HAS_FIELD(Double, 1.0, 0.0)
734//%PROTO3_TEST_HAS_FIELD(Bool, YES, NO)
735//%PROTO3_TEST_HAS_FIELD(String, @"foo", @"")
736//%PROTO3_TEST_HAS_FIELD(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding], [NSData data])
737//% //
Thomas Van Lenten17d601a2016-08-12 11:46:55 -0400738//% // Test doesn't apply to optionalMessage (no groups in proto3).
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400739//% //
740//%
741//%PROTO3_TEST_HAS_FIELD(Enum, Message3_Enum_Bar, Message3_Enum_Foo)
Thomas Van Lenten17d601a2016-08-12 11:46:55 -0400742//% //
743//% // Nil can also be used to clear strings, bytes, and messages (no groups in proto3).
744//% //
745//%
746//%PROTO3_TEST_CLEAR_FIELD_WITH_NIL(String, @"foo")
747//%PROTO3_TEST_CLEAR_FIELD_WITH_NIL(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding])
748//%PROTO3_TEST_CLEAR_FIELD_WITH_NIL(Message, [Message3 message])
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400749//%PDDM-EXPAND PROTO3_TEST_HAS_FIELDS()
750// This block of code is generated, do not edit it directly.
751
752 { // optionalInt32
753 Message3 *msg = [[Message3 alloc] init];
754 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt32));
755 msg.optionalInt32 = 1;
756 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt32));
757 msg.optionalInt32 = 0;
758 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt32));
759 [msg release];
760 }
761
762 { // optionalInt64
763 Message3 *msg = [[Message3 alloc] init];
764 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt64));
765 msg.optionalInt64 = 1;
766 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt64));
767 msg.optionalInt64 = 0;
768 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt64));
769 [msg release];
770 }
771
772 { // optionalUint32
773 Message3 *msg = [[Message3 alloc] init];
774 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint32));
775 msg.optionalUint32 = 1;
776 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint32));
777 msg.optionalUint32 = 0;
778 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint32));
779 [msg release];
780 }
781
782 { // optionalUint64
783 Message3 *msg = [[Message3 alloc] init];
784 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint64));
785 msg.optionalUint64 = 1;
786 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint64));
787 msg.optionalUint64 = 0;
788 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint64));
789 [msg release];
790 }
791
792 { // optionalSint32
793 Message3 *msg = [[Message3 alloc] init];
794 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint32));
795 msg.optionalSint32 = 1;
796 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint32));
797 msg.optionalSint32 = 0;
798 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint32));
799 [msg release];
800 }
801
802 { // optionalSint64
803 Message3 *msg = [[Message3 alloc] init];
804 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint64));
805 msg.optionalSint64 = 1;
806 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint64));
807 msg.optionalSint64 = 0;
808 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint64));
809 [msg release];
810 }
811
812 { // optionalFixed32
813 Message3 *msg = [[Message3 alloc] init];
814 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed32));
815 msg.optionalFixed32 = 1;
816 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed32));
817 msg.optionalFixed32 = 0;
818 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed32));
819 [msg release];
820 }
821
822 { // optionalFixed64
823 Message3 *msg = [[Message3 alloc] init];
824 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed64));
825 msg.optionalFixed64 = 1;
826 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed64));
827 msg.optionalFixed64 = 0;
828 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed64));
829 [msg release];
830 }
831
832 { // optionalSfixed32
833 Message3 *msg = [[Message3 alloc] init];
834 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed32));
835 msg.optionalSfixed32 = 1;
836 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed32));
837 msg.optionalSfixed32 = 0;
838 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed32));
839 [msg release];
840 }
841
842 { // optionalSfixed64
843 Message3 *msg = [[Message3 alloc] init];
844 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed64));
845 msg.optionalSfixed64 = 1;
846 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed64));
847 msg.optionalSfixed64 = 0;
848 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed64));
849 [msg release];
850 }
851
852 { // optionalFloat
853 Message3 *msg = [[Message3 alloc] init];
854 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFloat));
855 msg.optionalFloat = 1.0f;
856 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFloat));
857 msg.optionalFloat = 0.0f;
858 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFloat));
859 [msg release];
860 }
861
862 { // optionalDouble
863 Message3 *msg = [[Message3 alloc] init];
864 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalDouble));
865 msg.optionalDouble = 1.0;
866 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalDouble));
867 msg.optionalDouble = 0.0;
868 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalDouble));
869 [msg release];
870 }
871
872 { // optionalBool
873 Message3 *msg = [[Message3 alloc] init];
874 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBool));
875 msg.optionalBool = YES;
876 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBool));
877 msg.optionalBool = NO;
878 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBool));
879 [msg release];
880 }
881
882 { // optionalString
883 Message3 *msg = [[Message3 alloc] init];
884 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString));
885 msg.optionalString = @"foo";
886 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString));
887 msg.optionalString = @"";
888 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString));
889 [msg release];
890 }
891
892 { // optionalBytes
893 Message3 *msg = [[Message3 alloc] init];
894 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes));
895 msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding];
896 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes));
897 msg.optionalBytes = [NSData data];
898 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes));
899 [msg release];
900 }
901
902 //
Thomas Van Lenten17d601a2016-08-12 11:46:55 -0400903 // Test doesn't apply to optionalMessage (no groups in proto3).
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400904 //
905
906 { // optionalEnum
907 Message3 *msg = [[Message3 alloc] init];
908 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalEnum));
909 msg.optionalEnum = Message3_Enum_Bar;
910 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalEnum));
911 msg.optionalEnum = Message3_Enum_Foo;
912 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalEnum));
913 [msg release];
914 }
915
Thomas Van Lenten17d601a2016-08-12 11:46:55 -0400916 //
917 // Nil can also be used to clear strings, bytes, and messages (no groups in proto3).
918 //
919
920 { // optionalString
921 Message3 *msg = [[Message3 alloc] init];
922 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString));
923 msg.optionalString = @"foo";
924 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString));
925 msg.optionalString = nil;
926 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString));
927 [msg release];
928 }
929
930 { // optionalBytes
931 Message3 *msg = [[Message3 alloc] init];
932 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes));
933 msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding];
934 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes));
935 msg.optionalBytes = nil;
936 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes));
937 [msg release];
938 }
939
940 { // optionalMessage
941 Message3 *msg = [[Message3 alloc] init];
942 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalMessage));
943 msg.optionalMessage = [Message3 message];
944 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalMessage));
945 msg.optionalMessage = nil;
946 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalMessage));
947 [msg release];
948 }
949
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400950//%PDDM-EXPAND-END PROTO3_TEST_HAS_FIELDS()
Thomas Van Lenten9e069b22022-09-19 13:34:01 -0400951
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400952 // clang-format on
Thomas Van Lenten30650d82015-05-01 08:57:16 -0400953}
954
Thomas Van Lenten7b6016e2020-04-14 11:03:14 -0400955- (void)testProto3SingleOptionalFieldHasBehavior {
956 //
957 // Setting to any value including the default (0) should result in true.
958 //
959
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -0400960 // Disable clang-format for the macros.
961 // clang-format off
Thomas Van Lenten9e069b22022-09-19 13:34:01 -0400962
Thomas Van Lenten7b6016e2020-04-14 11:03:14 -0400963//%PDDM-DEFINE PROTO3_TEST_OPTIONAL_HAS_FIELD(FIELD, NON_ZERO_VALUE, ZERO_VALUE)
964//% { // optional##FIELD
965//% Message3Optional *msg = [[Message3Optional alloc] init];
966//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_Optional##FIELD));
967//% msg.optional##FIELD = NON_ZERO_VALUE;
968//% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_Optional##FIELD));
969//% msg.hasOptional##FIELD = NO;
970//% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_Optional##FIELD));
971//% msg.optional##FIELD = ZERO_VALUE;
972//% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_Optional##FIELD));
973//% [msg release];
974//% }
975//%
976//%PDDM-DEFINE PROTO3_TEST_OPTIONAL_HAS_FIELDS()
977//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Int32, 1, 0)
978//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Int64, 1, 0)
979//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Uint32, 1, 0)
980//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Uint64, 1, 0)
981//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Sint32, 1, 0)
982//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Sint64, 1, 0)
983//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Fixed32, 1, 0)
984//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Fixed64, 1, 0)
985//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Sfixed32, 1, 0)
986//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Sfixed64, 1, 0)
987//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Float, 1.0f, 0.0f)
988//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Double, 1.0, 0.0)
989//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Bool, YES, NO)
990//%PROTO3_TEST_OPTIONAL_HAS_FIELD(String, @"foo", @"")
991//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding], [NSData data])
992//% //
993//% // Test doesn't apply to optionalMessage (no groups in proto3).
994//% //
995//%
996//%PROTO3_TEST_OPTIONAL_HAS_FIELD(Enum, Message3Optional_Enum_Bar, Message3Optional_Enum_Foo)
997//%PDDM-EXPAND PROTO3_TEST_OPTIONAL_HAS_FIELDS()
998// This block of code is generated, do not edit it directly.
Thomas Van Lenten7b6016e2020-04-14 11:03:14 -0400999
1000 { // optionalInt32
1001 Message3Optional *msg = [[Message3Optional alloc] init];
1002 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt32));
1003 msg.optionalInt32 = 1;
1004 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt32));
1005 msg.hasOptionalInt32 = NO;
1006 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt32));
1007 msg.optionalInt32 = 0;
1008 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt32));
1009 [msg release];
1010 }
1011
1012 { // optionalInt64
1013 Message3Optional *msg = [[Message3Optional alloc] init];
1014 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt64));
1015 msg.optionalInt64 = 1;
1016 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt64));
1017 msg.hasOptionalInt64 = NO;
1018 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt64));
1019 msg.optionalInt64 = 0;
1020 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalInt64));
1021 [msg release];
1022 }
1023
1024 { // optionalUint32
1025 Message3Optional *msg = [[Message3Optional alloc] init];
1026 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint32));
1027 msg.optionalUint32 = 1;
1028 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint32));
1029 msg.hasOptionalUint32 = NO;
1030 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint32));
1031 msg.optionalUint32 = 0;
1032 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint32));
1033 [msg release];
1034 }
1035
1036 { // optionalUint64
1037 Message3Optional *msg = [[Message3Optional alloc] init];
1038 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint64));
1039 msg.optionalUint64 = 1;
1040 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint64));
1041 msg.hasOptionalUint64 = NO;
1042 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint64));
1043 msg.optionalUint64 = 0;
1044 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalUint64));
1045 [msg release];
1046 }
1047
1048 { // optionalSint32
1049 Message3Optional *msg = [[Message3Optional alloc] init];
1050 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint32));
1051 msg.optionalSint32 = 1;
1052 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint32));
1053 msg.hasOptionalSint32 = NO;
1054 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint32));
1055 msg.optionalSint32 = 0;
1056 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint32));
1057 [msg release];
1058 }
1059
1060 { // optionalSint64
1061 Message3Optional *msg = [[Message3Optional alloc] init];
1062 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint64));
1063 msg.optionalSint64 = 1;
1064 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint64));
1065 msg.hasOptionalSint64 = NO;
1066 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint64));
1067 msg.optionalSint64 = 0;
1068 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSint64));
1069 [msg release];
1070 }
1071
1072 { // optionalFixed32
1073 Message3Optional *msg = [[Message3Optional alloc] init];
1074 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed32));
1075 msg.optionalFixed32 = 1;
1076 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed32));
1077 msg.hasOptionalFixed32 = NO;
1078 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed32));
1079 msg.optionalFixed32 = 0;
1080 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed32));
1081 [msg release];
1082 }
1083
1084 { // optionalFixed64
1085 Message3Optional *msg = [[Message3Optional alloc] init];
1086 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed64));
1087 msg.optionalFixed64 = 1;
1088 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed64));
1089 msg.hasOptionalFixed64 = NO;
1090 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed64));
1091 msg.optionalFixed64 = 0;
1092 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFixed64));
1093 [msg release];
1094 }
1095
1096 { // optionalSfixed32
1097 Message3Optional *msg = [[Message3Optional alloc] init];
1098 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed32));
1099 msg.optionalSfixed32 = 1;
1100 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed32));
1101 msg.hasOptionalSfixed32 = NO;
1102 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed32));
1103 msg.optionalSfixed32 = 0;
1104 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed32));
1105 [msg release];
1106 }
1107
1108 { // optionalSfixed64
1109 Message3Optional *msg = [[Message3Optional alloc] init];
1110 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed64));
1111 msg.optionalSfixed64 = 1;
1112 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed64));
1113 msg.hasOptionalSfixed64 = NO;
1114 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed64));
1115 msg.optionalSfixed64 = 0;
1116 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalSfixed64));
1117 [msg release];
1118 }
1119
1120 { // optionalFloat
1121 Message3Optional *msg = [[Message3Optional alloc] init];
1122 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFloat));
1123 msg.optionalFloat = 1.0f;
1124 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFloat));
1125 msg.hasOptionalFloat = NO;
1126 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFloat));
1127 msg.optionalFloat = 0.0f;
1128 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalFloat));
1129 [msg release];
1130 }
1131
1132 { // optionalDouble
1133 Message3Optional *msg = [[Message3Optional alloc] init];
1134 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalDouble));
1135 msg.optionalDouble = 1.0;
1136 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalDouble));
1137 msg.hasOptionalDouble = NO;
1138 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalDouble));
1139 msg.optionalDouble = 0.0;
1140 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalDouble));
1141 [msg release];
1142 }
1143
1144 { // optionalBool
1145 Message3Optional *msg = [[Message3Optional alloc] init];
1146 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBool));
1147 msg.optionalBool = YES;
1148 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBool));
1149 msg.hasOptionalBool = NO;
1150 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBool));
1151 msg.optionalBool = NO;
1152 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBool));
1153 [msg release];
1154 }
1155
1156 { // optionalString
1157 Message3Optional *msg = [[Message3Optional alloc] init];
1158 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalString));
1159 msg.optionalString = @"foo";
1160 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalString));
1161 msg.hasOptionalString = NO;
1162 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalString));
1163 msg.optionalString = @"";
1164 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalString));
1165 [msg release];
1166 }
1167
1168 { // optionalBytes
1169 Message3Optional *msg = [[Message3Optional alloc] init];
1170 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBytes));
1171 msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding];
1172 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBytes));
1173 msg.hasOptionalBytes = NO;
1174 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBytes));
1175 msg.optionalBytes = [NSData data];
1176 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalBytes));
1177 [msg release];
1178 }
1179
1180 //
1181 // Test doesn't apply to optionalMessage (no groups in proto3).
1182 //
1183
1184 { // optionalEnum
1185 Message3Optional *msg = [[Message3Optional alloc] init];
1186 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalEnum));
1187 msg.optionalEnum = Message3Optional_Enum_Bar;
1188 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalEnum));
1189 msg.hasOptionalEnum = NO;
1190 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalEnum));
1191 msg.optionalEnum = Message3Optional_Enum_Foo;
1192 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3Optional_FieldNumber_OptionalEnum));
1193 [msg release];
1194 }
1195
Thomas Van Lenten7b6016e2020-04-14 11:03:14 -04001196//%PDDM-EXPAND-END PROTO3_TEST_OPTIONAL_HAS_FIELDS()
Thomas Van Lenten9e069b22022-09-19 13:34:01 -04001197
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04001198 // clang-format on
Thomas Van Lenten7b6016e2020-04-14 11:03:14 -04001199}
1200
Thomas Van Lenten30650d82015-05-01 08:57:16 -04001201- (void)testAccessingProto2UnknownEnumValues {
1202 Message2 *msg = [[Message2 alloc] init];
1203
1204 // Set it to something non zero, try and confirm it doesn't change.
1205
1206 msg.optionalEnum = Message2_Enum_Bar;
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04001207 XCTAssertThrowsSpecificNamed(msg.optionalEnum = 666, NSException, NSInvalidArgumentException);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04001208 XCTAssertEqual(msg.optionalEnum, Message2_Enum_Bar);
1209
1210 msg.oneofEnum = Message2_Enum_Bar;
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04001211 XCTAssertThrowsSpecificNamed(msg.oneofEnum = 666, NSException, NSInvalidArgumentException);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04001212 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Bar);
Thomas Van Lenten1dcc3292015-05-21 17:14:52 -04001213
1214 [msg release];
Thomas Van Lenten30650d82015-05-01 08:57:16 -04001215}
1216
1217- (void)testAccessingProto3UnknownEnumValues {
1218 Message3 *msg = [[Message3 alloc] init];
1219
1220 // Set it to something non zero, try and confirm it doesn't change.
1221
1222 msg.optionalEnum = Message3_Enum_Bar;
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04001223 XCTAssertThrowsSpecificNamed(msg.optionalEnum = 666, NSException, NSInvalidArgumentException);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04001224 XCTAssertEqual(msg.optionalEnum, Message3_Enum_Bar);
1225
1226 msg.oneofEnum = Message3_Enum_Bar;
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04001227 XCTAssertThrowsSpecificNamed(msg.oneofEnum = 666, NSException, NSInvalidArgumentException);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04001228 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Bar);
1229
1230 // Set via raw api to confirm it works.
1231
1232 SetMessage3_OptionalEnum_RawValue(msg, 666);
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04001233 XCTAssertEqual(msg.optionalEnum, Message3_Enum_GPBUnrecognizedEnumeratorValue);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04001234 XCTAssertEqual(Message3_OptionalEnum_RawValue(msg), 666);
1235
1236 SetMessage3_OneofEnum_RawValue(msg, 666);
1237 XCTAssertEqual(msg.oneofEnum, Message3_Enum_GPBUnrecognizedEnumeratorValue);
1238 XCTAssertEqual(Message3_OneofEnum_RawValue(msg), 666);
1239
1240 [msg release];
1241}
1242
1243- (void)testProto2OneofBasicBehaviors {
1244 Message2 *msg = [[Message2 alloc] init];
1245
1246 NSString *oneofStringDefault = @"string";
1247 NSData *oneofBytesDefault = [@"data" dataUsingEncoding:NSUTF8StringEncoding];
1248
1249 // Nothing set.
1250 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase);
1251 XCTAssertEqual(msg.oneofInt32, 100);
1252 XCTAssertEqual(msg.oneofInt64, 101);
1253 XCTAssertEqual(msg.oneofUint32, 102U);
1254 XCTAssertEqual(msg.oneofUint64, 103U);
1255 XCTAssertEqual(msg.oneofSint32, 104);
1256 XCTAssertEqual(msg.oneofSint64, 105);
1257 XCTAssertEqual(msg.oneofFixed32, 106U);
1258 XCTAssertEqual(msg.oneofFixed64, 107U);
1259 XCTAssertEqual(msg.oneofSfixed32, 108);
1260 XCTAssertEqual(msg.oneofSfixed64, 109);
1261 XCTAssertEqual(msg.oneofFloat, 110.0f);
1262 XCTAssertEqual(msg.oneofDouble, 111.0);
1263 XCTAssertEqual(msg.oneofBool, YES);
1264 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1265 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1266 XCTAssertNotNil(msg.oneofGroup);
1267 XCTAssertNotNil(msg.oneofMessage);
1268 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1269
1270 // Set, check the case, check everyone has default but the one, confirm case
1271 // didn't change.
1272
1273 msg.oneofInt32 = 1;
1274 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt32);
1275 XCTAssertEqual(msg.oneofInt32, 1);
1276 XCTAssertEqual(msg.oneofInt64, 101);
1277 XCTAssertEqual(msg.oneofUint32, 102U);
1278 XCTAssertEqual(msg.oneofUint64, 103U);
1279 XCTAssertEqual(msg.oneofSint32, 104);
1280 XCTAssertEqual(msg.oneofSint64, 105);
1281 XCTAssertEqual(msg.oneofFixed32, 106U);
1282 XCTAssertEqual(msg.oneofFixed64, 107U);
1283 XCTAssertEqual(msg.oneofSfixed32, 108);
1284 XCTAssertEqual(msg.oneofSfixed64, 109);
1285 XCTAssertEqual(msg.oneofFloat, 110.0f);
1286 XCTAssertEqual(msg.oneofDouble, 111.0);
1287 XCTAssertEqual(msg.oneofBool, YES);
1288 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1289 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1290 XCTAssertNotNil(msg.oneofGroup);
1291 XCTAssertNotNil(msg.oneofMessage);
1292 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1293 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt32);
1294
1295 msg.oneofInt64 = 2;
1296 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt64);
1297 XCTAssertEqual(msg.oneofInt32, 100);
1298 XCTAssertEqual(msg.oneofInt64, 2);
1299 XCTAssertEqual(msg.oneofUint32, 102U);
1300 XCTAssertEqual(msg.oneofUint64, 103U);
1301 XCTAssertEqual(msg.oneofSint32, 104);
1302 XCTAssertEqual(msg.oneofSint64, 105);
1303 XCTAssertEqual(msg.oneofFixed32, 106U);
1304 XCTAssertEqual(msg.oneofFixed64, 107U);
1305 XCTAssertEqual(msg.oneofSfixed32, 108);
1306 XCTAssertEqual(msg.oneofSfixed64, 109);
1307 XCTAssertEqual(msg.oneofFloat, 110.0f);
1308 XCTAssertEqual(msg.oneofDouble, 111.0);
1309 XCTAssertEqual(msg.oneofBool, YES);
1310 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1311 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1312 XCTAssertNotNil(msg.oneofGroup);
1313 XCTAssertNotNil(msg.oneofMessage);
1314 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1315 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt64);
1316
1317 msg.oneofUint32 = 3;
1318 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint32);
1319 XCTAssertEqual(msg.oneofInt32, 100);
1320 XCTAssertEqual(msg.oneofInt64, 101);
1321 XCTAssertEqual(msg.oneofUint32, 3U);
1322 XCTAssertEqual(msg.oneofUint64, 103U);
1323 XCTAssertEqual(msg.oneofSint32, 104);
1324 XCTAssertEqual(msg.oneofSint64, 105);
1325 XCTAssertEqual(msg.oneofFixed32, 106U);
1326 XCTAssertEqual(msg.oneofFixed64, 107U);
1327 XCTAssertEqual(msg.oneofSfixed32, 108);
1328 XCTAssertEqual(msg.oneofSfixed64, 109);
1329 XCTAssertEqual(msg.oneofFloat, 110.0f);
1330 XCTAssertEqual(msg.oneofDouble, 111.0);
1331 XCTAssertEqual(msg.oneofBool, YES);
1332 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1333 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1334 XCTAssertNotNil(msg.oneofGroup);
1335 XCTAssertNotNil(msg.oneofMessage);
1336 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1337 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint32);
1338
1339 msg.oneofUint64 = 4;
1340 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint64);
1341 XCTAssertEqual(msg.oneofInt32, 100);
1342 XCTAssertEqual(msg.oneofInt64, 101);
1343 XCTAssertEqual(msg.oneofUint32, 102U);
1344 XCTAssertEqual(msg.oneofUint64, 4U);
1345 XCTAssertEqual(msg.oneofSint32, 104);
1346 XCTAssertEqual(msg.oneofSint64, 105);
1347 XCTAssertEqual(msg.oneofFixed32, 106U);
1348 XCTAssertEqual(msg.oneofFixed64, 107U);
1349 XCTAssertEqual(msg.oneofSfixed32, 108);
1350 XCTAssertEqual(msg.oneofSfixed64, 109);
1351 XCTAssertEqual(msg.oneofFloat, 110.0f);
1352 XCTAssertEqual(msg.oneofDouble, 111.0);
1353 XCTAssertEqual(msg.oneofBool, YES);
1354 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1355 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1356 XCTAssertNotNil(msg.oneofGroup);
1357 XCTAssertNotNil(msg.oneofMessage);
1358 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1359 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint64);
1360
1361 msg.oneofSint32 = 5;
1362 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint32);
1363 XCTAssertEqual(msg.oneofInt32, 100);
1364 XCTAssertEqual(msg.oneofInt64, 101);
1365 XCTAssertEqual(msg.oneofUint32, 102U);
1366 XCTAssertEqual(msg.oneofUint64, 103U);
1367 XCTAssertEqual(msg.oneofSint32, 5);
1368 XCTAssertEqual(msg.oneofSint64, 105);
1369 XCTAssertEqual(msg.oneofFixed32, 106U);
1370 XCTAssertEqual(msg.oneofFixed64, 107U);
1371 XCTAssertEqual(msg.oneofSfixed32, 108);
1372 XCTAssertEqual(msg.oneofSfixed64, 109);
1373 XCTAssertEqual(msg.oneofFloat, 110.0f);
1374 XCTAssertEqual(msg.oneofDouble, 111.0);
1375 XCTAssertEqual(msg.oneofBool, YES);
1376 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1377 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1378 XCTAssertNotNil(msg.oneofGroup);
1379 XCTAssertNotNil(msg.oneofMessage);
1380 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1381 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint32);
1382
1383 msg.oneofSint64 = 6;
1384 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint64);
1385 XCTAssertEqual(msg.oneofInt32, 100);
1386 XCTAssertEqual(msg.oneofInt64, 101);
1387 XCTAssertEqual(msg.oneofUint32, 102U);
1388 XCTAssertEqual(msg.oneofUint64, 103U);
1389 XCTAssertEqual(msg.oneofSint32, 104);
1390 XCTAssertEqual(msg.oneofSint64, 6);
1391 XCTAssertEqual(msg.oneofFixed32, 106U);
1392 XCTAssertEqual(msg.oneofFixed64, 107U);
1393 XCTAssertEqual(msg.oneofSfixed32, 108);
1394 XCTAssertEqual(msg.oneofSfixed64, 109);
1395 XCTAssertEqual(msg.oneofFloat, 110.0f);
1396 XCTAssertEqual(msg.oneofDouble, 111.0);
1397 XCTAssertEqual(msg.oneofBool, YES);
1398 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1399 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1400 XCTAssertNotNil(msg.oneofGroup);
1401 XCTAssertNotNil(msg.oneofMessage);
1402 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1403 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint64);
1404
1405 msg.oneofFixed32 = 7;
1406 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed32);
1407 XCTAssertEqual(msg.oneofInt32, 100);
1408 XCTAssertEqual(msg.oneofInt64, 101);
1409 XCTAssertEqual(msg.oneofUint32, 102U);
1410 XCTAssertEqual(msg.oneofUint64, 103U);
1411 XCTAssertEqual(msg.oneofSint32, 104);
1412 XCTAssertEqual(msg.oneofSint64, 105);
1413 XCTAssertEqual(msg.oneofFixed32, 7U);
1414 XCTAssertEqual(msg.oneofFixed64, 107U);
1415 XCTAssertEqual(msg.oneofSfixed32, 108);
1416 XCTAssertEqual(msg.oneofSfixed64, 109);
1417 XCTAssertEqual(msg.oneofFloat, 110.0f);
1418 XCTAssertEqual(msg.oneofDouble, 111.0);
1419 XCTAssertEqual(msg.oneofBool, YES);
1420 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1421 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1422 XCTAssertNotNil(msg.oneofGroup);
1423 XCTAssertNotNil(msg.oneofMessage);
1424 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1425 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed32);
1426
1427 msg.oneofFixed64 = 8;
1428 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed64);
1429 XCTAssertEqual(msg.oneofInt32, 100);
1430 XCTAssertEqual(msg.oneofInt64, 101);
1431 XCTAssertEqual(msg.oneofUint32, 102U);
1432 XCTAssertEqual(msg.oneofUint64, 103U);
1433 XCTAssertEqual(msg.oneofSint32, 104);
1434 XCTAssertEqual(msg.oneofSint64, 105);
1435 XCTAssertEqual(msg.oneofFixed32, 106U);
1436 XCTAssertEqual(msg.oneofFixed64, 8U);
1437 XCTAssertEqual(msg.oneofSfixed32, 108);
1438 XCTAssertEqual(msg.oneofSfixed64, 109);
1439 XCTAssertEqual(msg.oneofFloat, 110.0f);
1440 XCTAssertEqual(msg.oneofDouble, 111.0);
1441 XCTAssertEqual(msg.oneofBool, YES);
1442 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1443 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1444 XCTAssertNotNil(msg.oneofGroup);
1445 XCTAssertNotNil(msg.oneofMessage);
1446 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1447 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed64);
1448
1449 msg.oneofSfixed32 = 9;
1450 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed32);
1451 XCTAssertEqual(msg.oneofInt32, 100);
1452 XCTAssertEqual(msg.oneofInt64, 101);
1453 XCTAssertEqual(msg.oneofUint32, 102U);
1454 XCTAssertEqual(msg.oneofUint64, 103U);
1455 XCTAssertEqual(msg.oneofSint32, 104);
1456 XCTAssertEqual(msg.oneofSint64, 105);
1457 XCTAssertEqual(msg.oneofFixed32, 106U);
1458 XCTAssertEqual(msg.oneofFixed64, 107U);
1459 XCTAssertEqual(msg.oneofSfixed32, 9);
1460 XCTAssertEqual(msg.oneofSfixed64, 109);
1461 XCTAssertEqual(msg.oneofFloat, 110.0f);
1462 XCTAssertEqual(msg.oneofDouble, 111.0);
1463 XCTAssertEqual(msg.oneofBool, YES);
1464 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1465 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1466 XCTAssertNotNil(msg.oneofGroup);
1467 XCTAssertNotNil(msg.oneofMessage);
1468 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1469 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed32);
1470
1471 msg.oneofSfixed64 = 10;
1472 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed64);
1473 XCTAssertEqual(msg.oneofInt32, 100);
1474 XCTAssertEqual(msg.oneofInt64, 101);
1475 XCTAssertEqual(msg.oneofUint32, 102U);
1476 XCTAssertEqual(msg.oneofUint64, 103U);
1477 XCTAssertEqual(msg.oneofSint32, 104);
1478 XCTAssertEqual(msg.oneofSint64, 105);
1479 XCTAssertEqual(msg.oneofFixed32, 106U);
1480 XCTAssertEqual(msg.oneofFixed64, 107U);
1481 XCTAssertEqual(msg.oneofSfixed32, 108);
1482 XCTAssertEqual(msg.oneofSfixed64, 10);
1483 XCTAssertEqual(msg.oneofFloat, 110.0f);
1484 XCTAssertEqual(msg.oneofDouble, 111.0);
1485 XCTAssertEqual(msg.oneofBool, YES);
1486 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1487 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1488 XCTAssertNotNil(msg.oneofGroup);
1489 XCTAssertNotNil(msg.oneofMessage);
1490 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1491 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed64);
1492
1493 msg.oneofFloat = 11.0f;
1494 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFloat);
1495 XCTAssertEqual(msg.oneofInt32, 100);
1496 XCTAssertEqual(msg.oneofInt64, 101);
1497 XCTAssertEqual(msg.oneofUint32, 102U);
1498 XCTAssertEqual(msg.oneofUint64, 103U);
1499 XCTAssertEqual(msg.oneofSint32, 104);
1500 XCTAssertEqual(msg.oneofSint64, 105);
1501 XCTAssertEqual(msg.oneofFixed32, 106U);
1502 XCTAssertEqual(msg.oneofFixed64, 107U);
1503 XCTAssertEqual(msg.oneofSfixed32, 108);
1504 XCTAssertEqual(msg.oneofSfixed64, 109);
1505 XCTAssertEqual(msg.oneofFloat, 11.0f);
1506 XCTAssertEqual(msg.oneofDouble, 111.0);
1507 XCTAssertEqual(msg.oneofBool, YES);
1508 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1509 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1510 XCTAssertNotNil(msg.oneofGroup);
1511 XCTAssertNotNil(msg.oneofMessage);
1512 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1513 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFloat);
1514
1515 msg.oneofDouble = 12.0;
1516 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofDouble);
1517 XCTAssertEqual(msg.oneofInt32, 100);
1518 XCTAssertEqual(msg.oneofInt64, 101);
1519 XCTAssertEqual(msg.oneofUint32, 102U);
1520 XCTAssertEqual(msg.oneofUint64, 103U);
1521 XCTAssertEqual(msg.oneofSint32, 104);
1522 XCTAssertEqual(msg.oneofSint64, 105);
1523 XCTAssertEqual(msg.oneofFixed32, 106U);
1524 XCTAssertEqual(msg.oneofFixed64, 107U);
1525 XCTAssertEqual(msg.oneofSfixed32, 108);
1526 XCTAssertEqual(msg.oneofSfixed64, 109);
1527 XCTAssertEqual(msg.oneofFloat, 110.0f);
1528 XCTAssertEqual(msg.oneofDouble, 12.0);
1529 XCTAssertEqual(msg.oneofBool, YES);
1530 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1531 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1532 XCTAssertNotNil(msg.oneofGroup);
1533 XCTAssertNotNil(msg.oneofMessage);
1534 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1535 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofDouble);
1536
1537 msg.oneofBool = NO;
1538 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBool);
1539 XCTAssertEqual(msg.oneofInt32, 100);
1540 XCTAssertEqual(msg.oneofInt64, 101);
1541 XCTAssertEqual(msg.oneofUint32, 102U);
1542 XCTAssertEqual(msg.oneofUint64, 103U);
1543 XCTAssertEqual(msg.oneofSint32, 104);
1544 XCTAssertEqual(msg.oneofSint64, 105);
1545 XCTAssertEqual(msg.oneofFixed32, 106U);
1546 XCTAssertEqual(msg.oneofFixed64, 107U);
1547 XCTAssertEqual(msg.oneofSfixed32, 108);
1548 XCTAssertEqual(msg.oneofSfixed64, 109);
1549 XCTAssertEqual(msg.oneofFloat, 110.0f);
1550 XCTAssertEqual(msg.oneofDouble, 111.0);
1551 XCTAssertEqual(msg.oneofBool, NO);
1552 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1553 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1554 XCTAssertNotNil(msg.oneofGroup);
1555 XCTAssertNotNil(msg.oneofMessage);
1556 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1557 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBool);
1558
1559 msg.oneofString = @"foo";
1560 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofString);
1561 XCTAssertEqual(msg.oneofInt32, 100);
1562 XCTAssertEqual(msg.oneofInt64, 101);
1563 XCTAssertEqual(msg.oneofUint32, 102U);
1564 XCTAssertEqual(msg.oneofUint64, 103U);
1565 XCTAssertEqual(msg.oneofSint32, 104);
1566 XCTAssertEqual(msg.oneofSint64, 105);
1567 XCTAssertEqual(msg.oneofFixed32, 106U);
1568 XCTAssertEqual(msg.oneofFixed64, 107U);
1569 XCTAssertEqual(msg.oneofSfixed32, 108);
1570 XCTAssertEqual(msg.oneofSfixed64, 109);
1571 XCTAssertEqual(msg.oneofFloat, 110.0f);
1572 XCTAssertEqual(msg.oneofDouble, 111.0);
1573 XCTAssertEqual(msg.oneofBool, YES);
1574 XCTAssertEqualObjects(msg.oneofString, @"foo");
1575 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1576 XCTAssertNotNil(msg.oneofGroup);
1577 XCTAssertNotNil(msg.oneofMessage);
1578 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1579 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofString);
1580
1581 msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding];
1582 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBytes);
1583 XCTAssertEqual(msg.oneofInt32, 100);
1584 XCTAssertEqual(msg.oneofInt64, 101);
1585 XCTAssertEqual(msg.oneofUint32, 102U);
1586 XCTAssertEqual(msg.oneofUint64, 103U);
1587 XCTAssertEqual(msg.oneofSint32, 104);
1588 XCTAssertEqual(msg.oneofSint64, 105);
1589 XCTAssertEqual(msg.oneofFixed32, 106U);
1590 XCTAssertEqual(msg.oneofFixed64, 107U);
1591 XCTAssertEqual(msg.oneofSfixed32, 108);
1592 XCTAssertEqual(msg.oneofSfixed64, 109);
1593 XCTAssertEqual(msg.oneofFloat, 110.0f);
1594 XCTAssertEqual(msg.oneofDouble, 111.0);
1595 XCTAssertEqual(msg.oneofBool, YES);
1596 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04001597 XCTAssertEqualObjects(msg.oneofBytes, [@"bar" dataUsingEncoding:NSUTF8StringEncoding]);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04001598 XCTAssertNotNil(msg.oneofGroup);
1599 XCTAssertNotNil(msg.oneofMessage);
1600 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1601 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBytes);
1602
1603 Message2_OneofGroup *group = [Message2_OneofGroup message];
1604 msg.oneofGroup = group;
1605 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofGroup);
1606 XCTAssertEqual(msg.oneofInt32, 100);
1607 XCTAssertEqual(msg.oneofInt64, 101);
1608 XCTAssertEqual(msg.oneofUint32, 102U);
1609 XCTAssertEqual(msg.oneofUint64, 103U);
1610 XCTAssertEqual(msg.oneofSint32, 104);
1611 XCTAssertEqual(msg.oneofSint64, 105);
1612 XCTAssertEqual(msg.oneofFixed32, 106U);
1613 XCTAssertEqual(msg.oneofFixed64, 107U);
1614 XCTAssertEqual(msg.oneofSfixed32, 108);
1615 XCTAssertEqual(msg.oneofSfixed64, 109);
1616 XCTAssertEqual(msg.oneofFloat, 110.0f);
1617 XCTAssertEqual(msg.oneofDouble, 111.0);
1618 XCTAssertEqual(msg.oneofBool, YES);
1619 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1620 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1621 XCTAssertEqual(msg.oneofGroup, group); // Pointer compare.
1622 XCTAssertNotNil(msg.oneofMessage);
1623 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1624 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofGroup);
1625
1626 Message2 *subMessage = [Message2 message];
1627 msg.oneofMessage = subMessage;
1628 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofMessage);
1629 XCTAssertEqual(msg.oneofInt32, 100);
1630 XCTAssertEqual(msg.oneofInt64, 101);
1631 XCTAssertEqual(msg.oneofUint32, 102U);
1632 XCTAssertEqual(msg.oneofUint64, 103U);
1633 XCTAssertEqual(msg.oneofSint32, 104);
1634 XCTAssertEqual(msg.oneofSint64, 105);
1635 XCTAssertEqual(msg.oneofFixed32, 106U);
1636 XCTAssertEqual(msg.oneofFixed64, 107U);
1637 XCTAssertEqual(msg.oneofSfixed32, 108);
1638 XCTAssertEqual(msg.oneofSfixed64, 109);
1639 XCTAssertEqual(msg.oneofFloat, 110.0f);
1640 XCTAssertEqual(msg.oneofDouble, 111.0);
1641 XCTAssertEqual(msg.oneofBool, YES);
1642 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1643 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1644 XCTAssertNotNil(msg.oneofGroup);
1645 XCTAssertNotEqual(msg.oneofGroup, group); // Pointer compare.
1646 XCTAssertEqual(msg.oneofMessage, subMessage); // Pointer compare.
1647 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1648 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofMessage);
1649
1650 msg.oneofEnum = Message2_Enum_Bar;
1651 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofEnum);
1652 XCTAssertEqual(msg.oneofInt32, 100);
1653 XCTAssertEqual(msg.oneofInt64, 101);
1654 XCTAssertEqual(msg.oneofUint32, 102U);
1655 XCTAssertEqual(msg.oneofUint64, 103U);
1656 XCTAssertEqual(msg.oneofSint32, 104);
1657 XCTAssertEqual(msg.oneofSint64, 105);
1658 XCTAssertEqual(msg.oneofFixed32, 106U);
1659 XCTAssertEqual(msg.oneofFixed64, 107U);
1660 XCTAssertEqual(msg.oneofSfixed32, 108);
1661 XCTAssertEqual(msg.oneofSfixed64, 109);
1662 XCTAssertEqual(msg.oneofFloat, 110.0f);
1663 XCTAssertEqual(msg.oneofDouble, 111.0);
1664 XCTAssertEqual(msg.oneofBool, YES);
1665 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1666 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1667 XCTAssertNotNil(msg.oneofGroup);
1668 XCTAssertNotEqual(msg.oneofGroup, group); // Pointer compare.
1669 XCTAssertNotNil(msg.oneofMessage);
1670 XCTAssertNotEqual(msg.oneofMessage, subMessage); // Pointer compare.
1671 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Bar);
1672 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofEnum);
1673
1674 // Test setting/calling clear clearing.
1675
1676 [msg release];
1677 msg = [[Message2 alloc] init];
1678
Thomas Van Lenten1c8a7a12019-06-06 14:25:22 -04001679 int32_t values[] = {
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04001680 Message2_O_OneOfCase_OneofInt32, Message2_O_OneOfCase_OneofInt64,
1681 Message2_O_OneOfCase_OneofUint32, Message2_O_OneOfCase_OneofUint64,
1682 Message2_O_OneOfCase_OneofSint32, Message2_O_OneOfCase_OneofSint64,
1683 Message2_O_OneOfCase_OneofFixed32, Message2_O_OneOfCase_OneofFixed64,
1684 Message2_O_OneOfCase_OneofSfixed32, Message2_O_OneOfCase_OneofSfixed64,
1685 Message2_O_OneOfCase_OneofFloat, Message2_O_OneOfCase_OneofDouble,
1686 Message2_O_OneOfCase_OneofBool, Message2_O_OneOfCase_OneofString,
1687 Message2_O_OneOfCase_OneofBytes, Message2_O_OneOfCase_OneofGroup,
1688 Message2_O_OneOfCase_OneofMessage, Message2_O_OneOfCase_OneofEnum,
Thomas Van Lenten30650d82015-05-01 08:57:16 -04001689 };
1690
Thomas Van Lenten1dcc3292015-05-21 17:14:52 -04001691 for (size_t i = 0; i < GPBARRAYSIZE(values); ++i) {
Thomas Van Lenten30650d82015-05-01 08:57:16 -04001692 switch (values[i]) {
1693 case Message2_O_OneOfCase_OneofInt32:
1694 msg.oneofInt32 = 1;
1695 break;
1696 case Message2_O_OneOfCase_OneofInt64:
1697 msg.oneofInt64 = 2;
1698 break;
1699 case Message2_O_OneOfCase_OneofUint32:
1700 msg.oneofUint32 = 3;
1701 break;
1702 case Message2_O_OneOfCase_OneofUint64:
1703 msg.oneofUint64 = 4;
1704 break;
1705 case Message2_O_OneOfCase_OneofSint32:
1706 msg.oneofSint32 = 5;
1707 break;
1708 case Message2_O_OneOfCase_OneofSint64:
1709 msg.oneofSint64 = 6;
1710 break;
1711 case Message2_O_OneOfCase_OneofFixed32:
1712 msg.oneofFixed32 = 7;
1713 break;
1714 case Message2_O_OneOfCase_OneofFixed64:
1715 msg.oneofFixed64 = 8;
1716 break;
1717 case Message2_O_OneOfCase_OneofSfixed32:
1718 msg.oneofSfixed32 = 9;
1719 break;
1720 case Message2_O_OneOfCase_OneofSfixed64:
1721 msg.oneofSfixed64 = 10;
1722 break;
1723 case Message2_O_OneOfCase_OneofFloat:
1724 msg.oneofFloat = 11.0f;
1725 break;
1726 case Message2_O_OneOfCase_OneofDouble:
1727 msg.oneofDouble = 12.0;
1728 break;
1729 case Message2_O_OneOfCase_OneofBool:
1730 msg.oneofBool = YES;
1731 break;
1732 case Message2_O_OneOfCase_OneofString:
1733 msg.oneofString = @"foo";
1734 break;
1735 case Message2_O_OneOfCase_OneofBytes:
1736 msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding];
1737 break;
1738 case Message2_O_OneOfCase_OneofGroup:
1739 msg.oneofGroup = group;
1740 break;
1741 case Message2_O_OneOfCase_OneofMessage:
1742 msg.oneofMessage = subMessage;
1743 break;
1744 case Message2_O_OneOfCase_OneofEnum:
1745 msg.oneofEnum = Message2_Enum_Bar;
1746 break;
1747 default:
Thomas Van Lenten1dcc3292015-05-21 17:14:52 -04001748 XCTFail(@"shouldn't happen, loop: %zd, value: %d", i, values[i]);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04001749 break;
1750 }
1751
1752 XCTAssertEqual(msg.oOneOfCase, values[i], "Loop: %zd", i);
1753 // No need to check the value was set, the above tests did that.
1754 Message2_ClearOOneOfCase(msg);
1755 // Nothing in the case.
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04001756 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase, "Loop: %zd", i);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04001757 // Confirm everything is back to defaults after a clear.
1758 XCTAssertEqual(msg.oneofInt32, 100, "Loop: %zd", i);
1759 XCTAssertEqual(msg.oneofInt64, 101, "Loop: %zd", i);
1760 XCTAssertEqual(msg.oneofUint32, 102U, "Loop: %zd", i);
1761 XCTAssertEqual(msg.oneofUint64, 103U, "Loop: %zd", i);
1762 XCTAssertEqual(msg.oneofSint32, 104, "Loop: %zd", i);
1763 XCTAssertEqual(msg.oneofSint64, 105, "Loop: %zd", i);
1764 XCTAssertEqual(msg.oneofFixed32, 106U, "Loop: %zd", i);
1765 XCTAssertEqual(msg.oneofFixed64, 107U, "Loop: %zd", i);
1766 XCTAssertEqual(msg.oneofSfixed32, 108, "Loop: %zd", i);
1767 XCTAssertEqual(msg.oneofSfixed64, 109, "Loop: %zd", i);
1768 XCTAssertEqual(msg.oneofFloat, 110.0f, "Loop: %zd", i);
1769 XCTAssertEqual(msg.oneofDouble, 111.0, "Loop: %zd", i);
1770 XCTAssertEqual(msg.oneofBool, YES, "Loop: %zd", i);
1771 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault, "Loop: %zd", i);
1772 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault, "Loop: %zd", i);
1773 XCTAssertNotNil(msg.oneofGroup, "Loop: %zd", i);
1774 XCTAssertNotEqual(msg.oneofGroup, group, "Loop: %zd",
1775 i); // Pointer compare.
1776 XCTAssertNotNil(msg.oneofMessage, "Loop: %zd", i);
1777 XCTAssertNotEqual(msg.oneofMessage, subMessage, "Loop: %zd",
1778 i); // Pointer compare.
1779 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz, "Loop: %zd", i);
1780 }
1781
1782 [msg release];
1783}
1784
1785- (void)testProto3OneofBasicBehaviors {
1786 Message3 *msg = [[Message3 alloc] init];
1787
1788 NSString *oneofStringDefault = @"";
1789 NSData *oneofBytesDefault = [NSData data];
1790
1791 // Nothing set.
1792 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase);
1793 XCTAssertEqual(msg.oneofInt32, 0);
1794 XCTAssertEqual(msg.oneofInt64, 0);
1795 XCTAssertEqual(msg.oneofUint32, 0U);
1796 XCTAssertEqual(msg.oneofUint64, 0U);
1797 XCTAssertEqual(msg.oneofSint32, 0);
1798 XCTAssertEqual(msg.oneofSint64, 0);
1799 XCTAssertEqual(msg.oneofFixed32, 0U);
1800 XCTAssertEqual(msg.oneofFixed64, 0U);
1801 XCTAssertEqual(msg.oneofSfixed32, 0);
1802 XCTAssertEqual(msg.oneofSfixed64, 0);
1803 XCTAssertEqual(msg.oneofFloat, 0.0f);
1804 XCTAssertEqual(msg.oneofDouble, 0.0);
1805 XCTAssertEqual(msg.oneofBool, NO);
1806 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1807 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1808 XCTAssertNotNil(msg.oneofMessage);
1809 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1810
1811 // Set, check the case, check everyone has default but the one, confirm case
1812 // didn't change.
1813
1814 msg.oneofInt32 = 1;
1815 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt32);
1816 XCTAssertEqual(msg.oneofInt32, 1);
1817 XCTAssertEqual(msg.oneofInt64, 0);
1818 XCTAssertEqual(msg.oneofUint32, 0U);
1819 XCTAssertEqual(msg.oneofUint64, 0U);
1820 XCTAssertEqual(msg.oneofSint32, 0);
1821 XCTAssertEqual(msg.oneofSint64, 0);
1822 XCTAssertEqual(msg.oneofFixed32, 0U);
1823 XCTAssertEqual(msg.oneofFixed64, 0U);
1824 XCTAssertEqual(msg.oneofSfixed32, 0);
1825 XCTAssertEqual(msg.oneofSfixed64, 0);
1826 XCTAssertEqual(msg.oneofFloat, 0.0f);
1827 XCTAssertEqual(msg.oneofDouble, 0.0);
1828 XCTAssertEqual(msg.oneofBool, NO);
1829 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1830 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1831 XCTAssertNotNil(msg.oneofMessage);
1832 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1833 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt32);
1834
1835 msg.oneofInt64 = 2;
1836 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt64);
1837 XCTAssertEqual(msg.oneofInt32, 0);
1838 XCTAssertEqual(msg.oneofInt64, 2);
1839 XCTAssertEqual(msg.oneofUint32, 0U);
1840 XCTAssertEqual(msg.oneofUint64, 0U);
1841 XCTAssertEqual(msg.oneofSint32, 0);
1842 XCTAssertEqual(msg.oneofSint64, 0);
1843 XCTAssertEqual(msg.oneofFixed32, 0U);
1844 XCTAssertEqual(msg.oneofFixed64, 0U);
1845 XCTAssertEqual(msg.oneofSfixed32, 0);
1846 XCTAssertEqual(msg.oneofSfixed64, 0);
1847 XCTAssertEqual(msg.oneofFloat, 0.0f);
1848 XCTAssertEqual(msg.oneofDouble, 0.0);
1849 XCTAssertEqual(msg.oneofBool, NO);
1850 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1851 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1852 XCTAssertNotNil(msg.oneofMessage);
1853 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1854 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt64);
1855
1856 msg.oneofUint32 = 3;
1857 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint32);
1858 XCTAssertEqual(msg.oneofInt32, 0);
1859 XCTAssertEqual(msg.oneofInt64, 0);
1860 XCTAssertEqual(msg.oneofUint32, 3U);
1861 XCTAssertEqual(msg.oneofUint64, 0U);
1862 XCTAssertEqual(msg.oneofSint32, 0);
1863 XCTAssertEqual(msg.oneofSint64, 0);
1864 XCTAssertEqual(msg.oneofFixed32, 0U);
1865 XCTAssertEqual(msg.oneofFixed64, 0U);
1866 XCTAssertEqual(msg.oneofSfixed32, 0);
1867 XCTAssertEqual(msg.oneofSfixed64, 0);
1868 XCTAssertEqual(msg.oneofFloat, 0.0f);
1869 XCTAssertEqual(msg.oneofDouble, 0.0);
1870 XCTAssertEqual(msg.oneofBool, NO);
1871 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1872 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1873 XCTAssertNotNil(msg.oneofMessage);
1874 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1875 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint32);
1876
1877 msg.oneofUint64 = 4;
1878 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint64);
1879 XCTAssertEqual(msg.oneofInt32, 0);
1880 XCTAssertEqual(msg.oneofInt64, 0);
1881 XCTAssertEqual(msg.oneofUint32, 0U);
1882 XCTAssertEqual(msg.oneofUint64, 4U);
1883 XCTAssertEqual(msg.oneofSint32, 0);
1884 XCTAssertEqual(msg.oneofSint64, 0);
1885 XCTAssertEqual(msg.oneofFixed32, 0U);
1886 XCTAssertEqual(msg.oneofFixed64, 0U);
1887 XCTAssertEqual(msg.oneofSfixed32, 0);
1888 XCTAssertEqual(msg.oneofSfixed64, 0);
1889 XCTAssertEqual(msg.oneofFloat, 0.0f);
1890 XCTAssertEqual(msg.oneofDouble, 0.0);
1891 XCTAssertEqual(msg.oneofBool, NO);
1892 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1893 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1894 XCTAssertNotNil(msg.oneofMessage);
1895 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1896 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint64);
1897
1898 msg.oneofSint32 = 5;
1899 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint32);
1900 XCTAssertEqual(msg.oneofInt32, 0);
1901 XCTAssertEqual(msg.oneofInt64, 0);
1902 XCTAssertEqual(msg.oneofUint32, 0U);
1903 XCTAssertEqual(msg.oneofUint64, 0U);
1904 XCTAssertEqual(msg.oneofSint32, 5);
1905 XCTAssertEqual(msg.oneofSint64, 0);
1906 XCTAssertEqual(msg.oneofFixed32, 0U);
1907 XCTAssertEqual(msg.oneofFixed64, 0U);
1908 XCTAssertEqual(msg.oneofSfixed32, 0);
1909 XCTAssertEqual(msg.oneofSfixed64, 0);
1910 XCTAssertEqual(msg.oneofFloat, 0.0f);
1911 XCTAssertEqual(msg.oneofDouble, 0.0);
1912 XCTAssertEqual(msg.oneofBool, NO);
1913 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1914 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1915 XCTAssertNotNil(msg.oneofMessage);
1916 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1917 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint32);
1918
1919 msg.oneofSint64 = 6;
1920 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint64);
1921 XCTAssertEqual(msg.oneofInt32, 0);
1922 XCTAssertEqual(msg.oneofInt64, 0);
1923 XCTAssertEqual(msg.oneofUint32, 0U);
1924 XCTAssertEqual(msg.oneofUint64, 0U);
1925 XCTAssertEqual(msg.oneofSint32, 0);
1926 XCTAssertEqual(msg.oneofSint64, 6);
1927 XCTAssertEqual(msg.oneofFixed32, 0U);
1928 XCTAssertEqual(msg.oneofFixed64, 0U);
1929 XCTAssertEqual(msg.oneofSfixed32, 0);
1930 XCTAssertEqual(msg.oneofSfixed64, 0);
1931 XCTAssertEqual(msg.oneofFloat, 0.0f);
1932 XCTAssertEqual(msg.oneofDouble, 0.0);
1933 XCTAssertEqual(msg.oneofBool, NO);
1934 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1935 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1936 XCTAssertNotNil(msg.oneofMessage);
1937 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1938 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint64);
1939
1940 msg.oneofFixed32 = 7;
1941 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed32);
1942 XCTAssertEqual(msg.oneofInt32, 0);
1943 XCTAssertEqual(msg.oneofInt64, 0);
1944 XCTAssertEqual(msg.oneofUint32, 0U);
1945 XCTAssertEqual(msg.oneofUint64, 0U);
1946 XCTAssertEqual(msg.oneofSint32, 0);
1947 XCTAssertEqual(msg.oneofSint64, 0);
1948 XCTAssertEqual(msg.oneofFixed32, 7U);
1949 XCTAssertEqual(msg.oneofFixed64, 0U);
1950 XCTAssertEqual(msg.oneofSfixed32, 0);
1951 XCTAssertEqual(msg.oneofSfixed64, 0);
1952 XCTAssertEqual(msg.oneofFloat, 0.0f);
1953 XCTAssertEqual(msg.oneofDouble, 0.0);
1954 XCTAssertEqual(msg.oneofBool, NO);
1955 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1956 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1957 XCTAssertNotNil(msg.oneofMessage);
1958 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1959 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed32);
1960
1961 msg.oneofFixed64 = 8;
1962 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed64);
1963 XCTAssertEqual(msg.oneofInt32, 0);
1964 XCTAssertEqual(msg.oneofInt64, 0);
1965 XCTAssertEqual(msg.oneofUint32, 0U);
1966 XCTAssertEqual(msg.oneofUint64, 0U);
1967 XCTAssertEqual(msg.oneofSint32, 0);
1968 XCTAssertEqual(msg.oneofSint64, 0);
1969 XCTAssertEqual(msg.oneofFixed32, 0U);
1970 XCTAssertEqual(msg.oneofFixed64, 8U);
1971 XCTAssertEqual(msg.oneofSfixed32, 0);
1972 XCTAssertEqual(msg.oneofSfixed64, 0);
1973 XCTAssertEqual(msg.oneofFloat, 0.0f);
1974 XCTAssertEqual(msg.oneofDouble, 0.0);
1975 XCTAssertEqual(msg.oneofBool, NO);
1976 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1977 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1978 XCTAssertNotNil(msg.oneofMessage);
1979 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1980 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed64);
1981
1982 msg.oneofSfixed32 = 9;
1983 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed32);
1984 XCTAssertEqual(msg.oneofInt32, 0);
1985 XCTAssertEqual(msg.oneofInt64, 0);
1986 XCTAssertEqual(msg.oneofUint32, 0U);
1987 XCTAssertEqual(msg.oneofUint64, 0U);
1988 XCTAssertEqual(msg.oneofSint32, 0);
1989 XCTAssertEqual(msg.oneofSint64, 0);
1990 XCTAssertEqual(msg.oneofFixed32, 0U);
1991 XCTAssertEqual(msg.oneofFixed64, 0U);
1992 XCTAssertEqual(msg.oneofSfixed32, 9);
1993 XCTAssertEqual(msg.oneofSfixed64, 0);
1994 XCTAssertEqual(msg.oneofFloat, 0.0f);
1995 XCTAssertEqual(msg.oneofDouble, 0.0);
1996 XCTAssertEqual(msg.oneofBool, NO);
1997 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1998 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1999 XCTAssertNotNil(msg.oneofMessage);
2000 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
2001 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed32);
2002
2003 msg.oneofSfixed64 = 10;
2004 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed64);
2005 XCTAssertEqual(msg.oneofInt32, 0);
2006 XCTAssertEqual(msg.oneofInt64, 0);
2007 XCTAssertEqual(msg.oneofUint32, 0U);
2008 XCTAssertEqual(msg.oneofUint64, 0U);
2009 XCTAssertEqual(msg.oneofSint32, 0);
2010 XCTAssertEqual(msg.oneofSint64, 0);
2011 XCTAssertEqual(msg.oneofFixed32, 0U);
2012 XCTAssertEqual(msg.oneofFixed64, 0U);
2013 XCTAssertEqual(msg.oneofSfixed32, 0);
2014 XCTAssertEqual(msg.oneofSfixed64, 10);
2015 XCTAssertEqual(msg.oneofFloat, 0.0f);
2016 XCTAssertEqual(msg.oneofDouble, 0.0);
2017 XCTAssertEqual(msg.oneofBool, NO);
2018 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
2019 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
2020 XCTAssertNotNil(msg.oneofMessage);
2021 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
2022 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed64);
2023
2024 msg.oneofFloat = 11.0f;
2025 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFloat);
2026 XCTAssertEqual(msg.oneofInt32, 0);
2027 XCTAssertEqual(msg.oneofInt64, 0);
2028 XCTAssertEqual(msg.oneofUint32, 0U);
2029 XCTAssertEqual(msg.oneofUint64, 0U);
2030 XCTAssertEqual(msg.oneofSint32, 0);
2031 XCTAssertEqual(msg.oneofSint64, 0);
2032 XCTAssertEqual(msg.oneofFixed32, 0U);
2033 XCTAssertEqual(msg.oneofFixed64, 0U);
2034 XCTAssertEqual(msg.oneofSfixed32, 0);
2035 XCTAssertEqual(msg.oneofSfixed64, 0);
2036 XCTAssertEqual(msg.oneofFloat, 11.0f);
2037 XCTAssertEqual(msg.oneofDouble, 0.0);
2038 XCTAssertEqual(msg.oneofBool, NO);
2039 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
2040 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
2041 XCTAssertNotNil(msg.oneofMessage);
2042 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
2043 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFloat);
2044
2045 msg.oneofDouble = 12.0;
2046 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofDouble);
2047 XCTAssertEqual(msg.oneofInt32, 0);
2048 XCTAssertEqual(msg.oneofInt64, 0);
2049 XCTAssertEqual(msg.oneofUint32, 0U);
2050 XCTAssertEqual(msg.oneofUint64, 0U);
2051 XCTAssertEqual(msg.oneofSint32, 0);
2052 XCTAssertEqual(msg.oneofSint64, 0);
2053 XCTAssertEqual(msg.oneofFixed32, 0U);
2054 XCTAssertEqual(msg.oneofFixed64, 0U);
2055 XCTAssertEqual(msg.oneofSfixed32, 0);
2056 XCTAssertEqual(msg.oneofSfixed64, 0);
2057 XCTAssertEqual(msg.oneofFloat, 0.0f);
2058 XCTAssertEqual(msg.oneofDouble, 12.0);
2059 XCTAssertEqual(msg.oneofBool, NO);
2060 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
2061 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
2062 XCTAssertNotNil(msg.oneofMessage);
2063 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
2064 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofDouble);
2065
2066 msg.oneofBool = YES;
2067 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBool);
2068 XCTAssertEqual(msg.oneofInt32, 0);
2069 XCTAssertEqual(msg.oneofInt64, 0);
2070 XCTAssertEqual(msg.oneofUint32, 0U);
2071 XCTAssertEqual(msg.oneofUint64, 0U);
2072 XCTAssertEqual(msg.oneofSint32, 0);
2073 XCTAssertEqual(msg.oneofSint64, 0);
2074 XCTAssertEqual(msg.oneofFixed32, 0U);
2075 XCTAssertEqual(msg.oneofFixed64, 0U);
2076 XCTAssertEqual(msg.oneofSfixed32, 0);
2077 XCTAssertEqual(msg.oneofSfixed64, 0);
2078 XCTAssertEqual(msg.oneofFloat, 0.0f);
2079 XCTAssertEqual(msg.oneofDouble, 0.0);
2080 XCTAssertEqual(msg.oneofBool, YES);
2081 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
2082 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
2083 XCTAssertNotNil(msg.oneofMessage);
2084 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
2085 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBool);
2086
2087 msg.oneofString = @"foo";
2088 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofString);
2089 XCTAssertEqual(msg.oneofInt32, 0);
2090 XCTAssertEqual(msg.oneofInt64, 0);
2091 XCTAssertEqual(msg.oneofUint32, 0U);
2092 XCTAssertEqual(msg.oneofUint64, 0U);
2093 XCTAssertEqual(msg.oneofSint32, 0);
2094 XCTAssertEqual(msg.oneofSint64, 0);
2095 XCTAssertEqual(msg.oneofFixed32, 0U);
2096 XCTAssertEqual(msg.oneofFixed64, 0U);
2097 XCTAssertEqual(msg.oneofSfixed32, 0);
2098 XCTAssertEqual(msg.oneofSfixed64, 0);
2099 XCTAssertEqual(msg.oneofFloat, 0.0f);
2100 XCTAssertEqual(msg.oneofDouble, 0.0);
2101 XCTAssertEqual(msg.oneofBool, NO);
2102 XCTAssertEqualObjects(msg.oneofString, @"foo");
2103 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
2104 XCTAssertNotNil(msg.oneofMessage);
2105 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
2106 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofString);
2107
2108 msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding];
2109 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBytes);
2110 XCTAssertEqual(msg.oneofInt32, 0);
2111 XCTAssertEqual(msg.oneofInt64, 0);
2112 XCTAssertEqual(msg.oneofUint32, 0U);
2113 XCTAssertEqual(msg.oneofUint64, 0U);
2114 XCTAssertEqual(msg.oneofSint32, 0);
2115 XCTAssertEqual(msg.oneofSint64, 0);
2116 XCTAssertEqual(msg.oneofFixed32, 0U);
2117 XCTAssertEqual(msg.oneofFixed64, 0U);
2118 XCTAssertEqual(msg.oneofSfixed32, 0);
2119 XCTAssertEqual(msg.oneofSfixed64, 0);
2120 XCTAssertEqual(msg.oneofFloat, 0.0f);
2121 XCTAssertEqual(msg.oneofDouble, 0.0);
2122 XCTAssertEqual(msg.oneofBool, NO);
2123 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04002124 XCTAssertEqualObjects(msg.oneofBytes, [@"bar" dataUsingEncoding:NSUTF8StringEncoding]);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002125 XCTAssertNotNil(msg.oneofMessage);
2126 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
2127 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBytes);
2128
2129 Message3 *subMessage = [Message3 message];
2130 msg.oneofMessage = subMessage;
2131 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofMessage);
2132 XCTAssertEqual(msg.oneofInt32, 0);
2133 XCTAssertEqual(msg.oneofInt64, 0);
2134 XCTAssertEqual(msg.oneofUint32, 0U);
2135 XCTAssertEqual(msg.oneofUint64, 0U);
2136 XCTAssertEqual(msg.oneofSint32, 0);
2137 XCTAssertEqual(msg.oneofSint64, 0);
2138 XCTAssertEqual(msg.oneofFixed32, 0U);
2139 XCTAssertEqual(msg.oneofFixed64, 0U);
2140 XCTAssertEqual(msg.oneofSfixed32, 0);
2141 XCTAssertEqual(msg.oneofSfixed64, 0);
2142 XCTAssertEqual(msg.oneofFloat, 0.0f);
2143 XCTAssertEqual(msg.oneofDouble, 0.0);
2144 XCTAssertEqual(msg.oneofBool, NO);
2145 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
2146 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
2147 XCTAssertEqual(msg.oneofMessage, subMessage); // Pointer compare.
2148 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
2149 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofMessage);
2150
2151 msg.oneofEnum = Message3_Enum_Bar;
2152 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofEnum);
2153 XCTAssertEqual(msg.oneofInt32, 0);
2154 XCTAssertEqual(msg.oneofInt64, 0);
2155 XCTAssertEqual(msg.oneofUint32, 0U);
2156 XCTAssertEqual(msg.oneofUint64, 0U);
2157 XCTAssertEqual(msg.oneofSint32, 0);
2158 XCTAssertEqual(msg.oneofSint64, 0);
2159 XCTAssertEqual(msg.oneofFixed32, 0U);
2160 XCTAssertEqual(msg.oneofFixed64, 0U);
2161 XCTAssertEqual(msg.oneofSfixed32, 0);
2162 XCTAssertEqual(msg.oneofSfixed64, 0);
2163 XCTAssertEqual(msg.oneofFloat, 0.0f);
2164 XCTAssertEqual(msg.oneofDouble, 0.0);
2165 XCTAssertEqual(msg.oneofBool, NO);
2166 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
2167 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
2168 XCTAssertNotNil(msg.oneofMessage);
2169 XCTAssertNotEqual(msg.oneofMessage, subMessage); // Pointer compare.
2170 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Bar);
2171 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofEnum);
2172
2173 // Test setting/calling clear clearing.
2174
2175 [msg release];
2176 msg = [[Message3 alloc] init];
2177
Thomas Van Lenten1c8a7a12019-06-06 14:25:22 -04002178 int32_t values[] = {
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04002179 Message3_O_OneOfCase_OneofInt32, Message3_O_OneOfCase_OneofInt64,
2180 Message3_O_OneOfCase_OneofUint32, Message3_O_OneOfCase_OneofUint64,
2181 Message3_O_OneOfCase_OneofSint32, Message3_O_OneOfCase_OneofSint64,
2182 Message3_O_OneOfCase_OneofFixed32, Message3_O_OneOfCase_OneofFixed64,
2183 Message3_O_OneOfCase_OneofSfixed32, Message3_O_OneOfCase_OneofSfixed64,
2184 Message3_O_OneOfCase_OneofFloat, Message3_O_OneOfCase_OneofDouble,
2185 Message3_O_OneOfCase_OneofBool, Message3_O_OneOfCase_OneofString,
2186 Message3_O_OneOfCase_OneofBytes, Message3_O_OneOfCase_OneofMessage,
2187 Message3_O_OneOfCase_OneofEnum,
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002188 };
2189
Thomas Van Lenten1dcc3292015-05-21 17:14:52 -04002190 for (size_t i = 0; i < GPBARRAYSIZE(values); ++i) {
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002191 switch (values[i]) {
2192 case Message3_O_OneOfCase_OneofInt32:
2193 msg.oneofInt32 = 1;
2194 break;
2195 case Message3_O_OneOfCase_OneofInt64:
2196 msg.oneofInt64 = 2;
2197 break;
2198 case Message3_O_OneOfCase_OneofUint32:
2199 msg.oneofUint32 = 3;
2200 break;
2201 case Message3_O_OneOfCase_OneofUint64:
2202 msg.oneofUint64 = 4;
2203 break;
2204 case Message3_O_OneOfCase_OneofSint32:
2205 msg.oneofSint32 = 5;
2206 break;
2207 case Message3_O_OneOfCase_OneofSint64:
2208 msg.oneofSint64 = 6;
2209 break;
2210 case Message3_O_OneOfCase_OneofFixed32:
2211 msg.oneofFixed32 = 7;
2212 break;
2213 case Message3_O_OneOfCase_OneofFixed64:
2214 msg.oneofFixed64 = 8;
2215 break;
2216 case Message3_O_OneOfCase_OneofSfixed32:
2217 msg.oneofSfixed32 = 9;
2218 break;
2219 case Message3_O_OneOfCase_OneofSfixed64:
2220 msg.oneofSfixed64 = 10;
2221 break;
2222 case Message3_O_OneOfCase_OneofFloat:
2223 msg.oneofFloat = 11.0f;
2224 break;
2225 case Message3_O_OneOfCase_OneofDouble:
2226 msg.oneofDouble = 12.0;
2227 break;
2228 case Message3_O_OneOfCase_OneofBool:
2229 msg.oneofBool = YES;
2230 break;
2231 case Message3_O_OneOfCase_OneofString:
2232 msg.oneofString = @"foo";
2233 break;
2234 case Message3_O_OneOfCase_OneofBytes:
2235 msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding];
2236 break;
2237 case Message3_O_OneOfCase_OneofMessage:
2238 msg.oneofMessage = subMessage;
2239 break;
2240 case Message3_O_OneOfCase_OneofEnum:
2241 msg.oneofEnum = Message3_Enum_Baz;
2242 break;
2243 default:
Thomas Van Lenten1dcc3292015-05-21 17:14:52 -04002244 XCTFail(@"shouldn't happen, loop: %zd, value: %d", i, values[i]);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002245 break;
2246 }
2247
2248 XCTAssertEqual(msg.oOneOfCase, values[i], "Loop: %zd", i);
2249 // No need to check the value was set, the above tests did that.
2250 Message3_ClearOOneOfCase(msg);
2251 // Nothing in the case.
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04002252 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase, "Loop: %zd", i);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002253 // Confirm everything is back to defaults after a clear.
2254 XCTAssertEqual(msg.oneofInt32, 0, "Loop: %zd", i);
2255 XCTAssertEqual(msg.oneofInt64, 0, "Loop: %zd", i);
2256 XCTAssertEqual(msg.oneofUint32, 0U, "Loop: %zd", i);
2257 XCTAssertEqual(msg.oneofUint64, 0U, "Loop: %zd", i);
2258 XCTAssertEqual(msg.oneofSint32, 0, "Loop: %zd", i);
2259 XCTAssertEqual(msg.oneofSint64, 0, "Loop: %zd", i);
2260 XCTAssertEqual(msg.oneofFixed32, 0U, "Loop: %zd", i);
2261 XCTAssertEqual(msg.oneofFixed64, 0U, "Loop: %zd", i);
2262 XCTAssertEqual(msg.oneofSfixed32, 0, "Loop: %zd", i);
2263 XCTAssertEqual(msg.oneofSfixed64, 0, "Loop: %zd", i);
2264 XCTAssertEqual(msg.oneofFloat, 0.0f, "Loop: %zd", i);
2265 XCTAssertEqual(msg.oneofDouble, 0.0, "Loop: %zd", i);
2266 XCTAssertEqual(msg.oneofBool, NO, "Loop: %zd", i);
2267 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault, "Loop: %zd", i);
2268 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault, "Loop: %zd", i);
2269 XCTAssertNotNil(msg.oneofMessage, "Loop: %zd", i);
2270 XCTAssertNotEqual(msg.oneofMessage, subMessage, "Loop: %zd",
2271 i); // Pointer compare.
2272 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo, "Loop: %zd", i);
2273 }
2274
2275 [msg release];
2276}
2277
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002278- (void)testProto2OneofSetToDefault {
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002279 // proto3 doesn't normally write out zero (default) fields, but if they are
2280 // in a oneof it does. proto2 doesn't have this special behavior, but we
2281 // still confirm setting to the explicit default does set the case to be
2282 // sure the runtime is working correctly.
2283
2284 NSString *oneofStringDefault = @"string";
2285 NSData *oneofBytesDefault = [@"data" dataUsingEncoding:NSUTF8StringEncoding];
2286
2287 Message2 *msg = [[Message2 alloc] init];
2288
Thomas Van Lenten1c8a7a12019-06-06 14:25:22 -04002289 int32_t values[] = {
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04002290 Message2_O_OneOfCase_OneofInt32,
2291 Message2_O_OneOfCase_OneofInt64,
2292 Message2_O_OneOfCase_OneofUint32,
2293 Message2_O_OneOfCase_OneofUint64,
2294 Message2_O_OneOfCase_OneofSint32,
2295 Message2_O_OneOfCase_OneofSint64,
2296 Message2_O_OneOfCase_OneofFixed32,
2297 Message2_O_OneOfCase_OneofFixed64,
2298 Message2_O_OneOfCase_OneofSfixed32,
2299 Message2_O_OneOfCase_OneofSfixed64,
2300 Message2_O_OneOfCase_OneofFloat,
2301 Message2_O_OneOfCase_OneofDouble,
2302 Message2_O_OneOfCase_OneofBool,
2303 Message2_O_OneOfCase_OneofString,
2304 Message2_O_OneOfCase_OneofBytes,
2305 // Skip group
2306 // Skip message
2307 Message2_O_OneOfCase_OneofEnum,
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002308 };
2309
2310 for (size_t i = 0; i < GPBARRAYSIZE(values); ++i) {
2311 switch (values[i]) {
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002312 case Message2_O_OneOfCase_OneofInt32:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002313 msg.oneofInt32 = 100;
2314 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002315 case Message2_O_OneOfCase_OneofInt64:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002316 msg.oneofInt64 = 101;
2317 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002318 case Message2_O_OneOfCase_OneofUint32:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002319 msg.oneofUint32 = 102;
2320 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002321 case Message2_O_OneOfCase_OneofUint64:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002322 msg.oneofUint64 = 103;
2323 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002324 case Message2_O_OneOfCase_OneofSint32:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002325 msg.oneofSint32 = 104;
2326 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002327 case Message2_O_OneOfCase_OneofSint64:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002328 msg.oneofSint64 = 105;
2329 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002330 case Message2_O_OneOfCase_OneofFixed32:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002331 msg.oneofFixed32 = 106;
2332 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002333 case Message2_O_OneOfCase_OneofFixed64:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002334 msg.oneofFixed64 = 107;
2335 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002336 case Message2_O_OneOfCase_OneofSfixed32:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002337 msg.oneofSfixed32 = 108;
2338 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002339 case Message2_O_OneOfCase_OneofSfixed64:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002340 msg.oneofSfixed64 = 109;
2341 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002342 case Message2_O_OneOfCase_OneofFloat:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002343 msg.oneofFloat = 110.0f;
2344 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002345 case Message2_O_OneOfCase_OneofDouble:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002346 msg.oneofDouble = 111.0;
2347 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002348 case Message2_O_OneOfCase_OneofBool:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002349 msg.oneofBool = YES;
2350 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002351 case Message2_O_OneOfCase_OneofString:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002352 msg.oneofString = oneofStringDefault;
2353 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002354 case Message2_O_OneOfCase_OneofBytes:
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002355 msg.oneofBytes = oneofBytesDefault;
2356 break;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002357 case Message2_O_OneOfCase_OneofEnum:
Thomas Van Lenten23fd8e02021-05-14 11:11:08 -04002358 msg.oneofEnum = Message2_Enum_Baz;
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002359 break;
2360 default:
2361 XCTFail(@"shouldn't happen, loop: %zd, value: %d", i, values[i]);
2362 break;
2363 }
2364
2365 // Should be set to the correct case.
2366 XCTAssertEqual(msg.oOneOfCase, values[i], "Loop: %zd", i);
2367
Thomas Van Lentenff85a172016-08-12 11:59:07 -04002368 // Confirm everything is the defaults.
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002369 XCTAssertEqual(msg.oneofInt32, 100, "Loop: %zd", i);
2370 XCTAssertEqual(msg.oneofInt64, 101, "Loop: %zd", i);
2371 XCTAssertEqual(msg.oneofUint32, 102U, "Loop: %zd", i);
2372 XCTAssertEqual(msg.oneofUint64, 103U, "Loop: %zd", i);
2373 XCTAssertEqual(msg.oneofSint32, 104, "Loop: %zd", i);
2374 XCTAssertEqual(msg.oneofSint64, 105, "Loop: %zd", i);
2375 XCTAssertEqual(msg.oneofFixed32, 106U, "Loop: %zd", i);
2376 XCTAssertEqual(msg.oneofFixed64, 107U, "Loop: %zd", i);
2377 XCTAssertEqual(msg.oneofSfixed32, 108, "Loop: %zd", i);
2378 XCTAssertEqual(msg.oneofSfixed64, 109, "Loop: %zd", i);
2379 XCTAssertEqual(msg.oneofFloat, 110.0f, "Loop: %zd", i);
2380 XCTAssertEqual(msg.oneofDouble, 111.0, "Loop: %zd", i);
2381 XCTAssertEqual(msg.oneofBool, YES, "Loop: %zd", i);
2382 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault, "Loop: %zd", i);
2383 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault, "Loop: %zd", i);
Thomas Van Lentenff85a172016-08-12 11:59:07 -04002384 // Skip group, no default to consider.
2385 // Skip message, no default to consider.
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002386 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz, "Loop: %zd", i);
2387 }
2388
Thomas Van Lentenff85a172016-08-12 11:59:07 -04002389 // We special case nil on string, data, group, and message, ensure they work
2390 // as expected. i.e. - it clears the case.
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002391 msg.oneofString = nil;
Thomas Van Lentenff85a172016-08-12 11:59:07 -04002392 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002393 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase);
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002394 msg.oneofBytes = nil;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002395 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase);
Thomas Van Lentenff85a172016-08-12 11:59:07 -04002396 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002397 msg.oneofGroup = nil;
2398 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase);
Thomas Van Lentenff85a172016-08-12 11:59:07 -04002399 XCTAssertNotNil(msg.oneofGroup);
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002400 msg.oneofMessage = nil;
Thomas Van Lentena0df6782016-08-12 11:53:04 -04002401 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase);
Thomas Van Lentenff85a172016-08-12 11:59:07 -04002402 XCTAssertNotNil(msg.oneofMessage);
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002403
2404 [msg release];
2405}
2406
2407- (void)testProto3OneofSetToZero {
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002408 // Normally setting a proto3 field to the zero value should result in it being
Brian Wignalla104dff2020-01-08 13:18:20 -05002409 // reset/cleared. But in a oneof, it still gets recorded so it can go out
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002410 // over the wire and the other side can see what was set in the oneof.
2411
2412 NSString *oneofStringDefault = @"";
2413 NSData *oneofBytesDefault = [NSData data];
2414
2415 Message3 *msg = [[Message3 alloc] init];
2416
Thomas Van Lenten1c8a7a12019-06-06 14:25:22 -04002417 int32_t values[] = {
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04002418 Message3_O_OneOfCase_OneofInt32, Message3_O_OneOfCase_OneofInt64,
2419 Message3_O_OneOfCase_OneofUint32, Message3_O_OneOfCase_OneofUint64,
2420 Message3_O_OneOfCase_OneofSint32, Message3_O_OneOfCase_OneofSint64,
2421 Message3_O_OneOfCase_OneofFixed32, Message3_O_OneOfCase_OneofFixed64,
2422 Message3_O_OneOfCase_OneofSfixed32, Message3_O_OneOfCase_OneofSfixed64,
2423 Message3_O_OneOfCase_OneofFloat, Message3_O_OneOfCase_OneofDouble,
2424 Message3_O_OneOfCase_OneofBool, Message3_O_OneOfCase_OneofString,
2425 Message3_O_OneOfCase_OneofBytes, Message3_O_OneOfCase_OneofMessage,
2426 Message3_O_OneOfCase_OneofEnum,
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002427 };
2428
2429 for (size_t i = 0; i < GPBARRAYSIZE(values); ++i) {
2430 switch (values[i]) {
2431 case Message3_O_OneOfCase_OneofInt32:
2432 msg.oneofInt32 = 0;
2433 break;
2434 case Message3_O_OneOfCase_OneofInt64:
2435 msg.oneofInt64 = 0;
2436 break;
2437 case Message3_O_OneOfCase_OneofUint32:
2438 msg.oneofUint32 = 0;
2439 break;
2440 case Message3_O_OneOfCase_OneofUint64:
2441 msg.oneofUint64 = 0;
2442 break;
2443 case Message3_O_OneOfCase_OneofSint32:
2444 msg.oneofSint32 = 0;
2445 break;
2446 case Message3_O_OneOfCase_OneofSint64:
2447 msg.oneofSint64 = 0;
2448 break;
2449 case Message3_O_OneOfCase_OneofFixed32:
2450 msg.oneofFixed32 = 0;
2451 break;
2452 case Message3_O_OneOfCase_OneofFixed64:
2453 msg.oneofFixed64 = 0;
2454 break;
2455 case Message3_O_OneOfCase_OneofSfixed32:
2456 msg.oneofSfixed32 = 0;
2457 break;
2458 case Message3_O_OneOfCase_OneofSfixed64:
2459 msg.oneofSfixed64 = 0;
2460 break;
2461 case Message3_O_OneOfCase_OneofFloat:
2462 msg.oneofFloat = 0.0f;
2463 break;
2464 case Message3_O_OneOfCase_OneofDouble:
2465 msg.oneofDouble = 0.0;
2466 break;
2467 case Message3_O_OneOfCase_OneofBool:
2468 msg.oneofBool = NO;
2469 break;
2470 case Message3_O_OneOfCase_OneofString:
2471 msg.oneofString = oneofStringDefault;
2472 break;
2473 case Message3_O_OneOfCase_OneofBytes:
2474 msg.oneofBytes = oneofBytesDefault;
2475 break;
2476 case Message3_O_OneOfCase_OneofMessage:
2477 msg.oneofMessage.optionalInt32 = 0;
2478 break;
2479 case Message3_O_OneOfCase_OneofEnum:
2480 msg.oneofEnum = Message3_Enum_Foo;
2481 break;
2482 default:
2483 XCTFail(@"shouldn't happen, loop: %zd, value: %d", i, values[i]);
2484 break;
2485 }
2486
2487 // Should be set to the correct case.
2488 XCTAssertEqual(msg.oOneOfCase, values[i], "Loop: %zd", i);
2489
2490 // Confirm everything is still zeros.
2491 XCTAssertEqual(msg.oneofInt32, 0, "Loop: %zd", i);
2492 XCTAssertEqual(msg.oneofInt64, 0, "Loop: %zd", i);
2493 XCTAssertEqual(msg.oneofUint32, 0U, "Loop: %zd", i);
2494 XCTAssertEqual(msg.oneofUint64, 0U, "Loop: %zd", i);
2495 XCTAssertEqual(msg.oneofSint32, 0, "Loop: %zd", i);
2496 XCTAssertEqual(msg.oneofSint64, 0, "Loop: %zd", i);
2497 XCTAssertEqual(msg.oneofFixed32, 0U, "Loop: %zd", i);
2498 XCTAssertEqual(msg.oneofFixed64, 0U, "Loop: %zd", i);
2499 XCTAssertEqual(msg.oneofSfixed32, 0, "Loop: %zd", i);
2500 XCTAssertEqual(msg.oneofSfixed64, 0, "Loop: %zd", i);
2501 XCTAssertEqual(msg.oneofFloat, 0.0f, "Loop: %zd", i);
2502 XCTAssertEqual(msg.oneofDouble, 0.0, "Loop: %zd", i);
2503 XCTAssertEqual(msg.oneofBool, NO, "Loop: %zd", i);
2504 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault, "Loop: %zd", i);
2505 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault, "Loop: %zd", i);
2506 XCTAssertNotNil(msg.oneofMessage, "Loop: %zd", i);
2507 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo, "Loop: %zd", i);
2508 }
2509
2510 // We special case nil on string, data, message, ensure they work as expected.
2511 msg.oneofString = nil;
2512 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase);
Thomas Van Lentenff85a172016-08-12 11:59:07 -04002513 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002514 msg.oneofBytes = nil;
2515 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase);
Thomas Van Lentenff85a172016-08-12 11:59:07 -04002516 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002517 msg.oneofMessage = nil;
2518 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase);
Thomas Van Lentenff85a172016-08-12 11:59:07 -04002519 XCTAssertNotNil(msg.oneofMessage);
Thomas Van Lentenca5b7752016-08-11 10:37:02 -04002520
2521 [msg release];
2522}
2523
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002524- (void)testCopyingMakesUniqueObjects {
2525 const int repeatCount = 5;
2526 TestAllTypes *msg1 = [TestAllTypes message];
2527 [self setAllFields:msg1 repeatedCount:repeatCount];
2528
2529 TestAllTypes *msg2 = [[msg1 copy] autorelease];
2530
2531 XCTAssertNotEqual(msg1, msg2); // Ptr compare, new object.
2532 XCTAssertEqualObjects(msg1, msg2); // Equal values.
2533
Brian Wignalla104dff2020-01-08 13:18:20 -05002534 // Pointer comparisons, different objects.
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002535
2536 XCTAssertNotEqual(msg1.optionalGroup, msg2.optionalGroup);
2537 XCTAssertNotEqual(msg1.optionalNestedMessage, msg2.optionalNestedMessage);
2538 XCTAssertNotEqual(msg1.optionalForeignMessage, msg2.optionalForeignMessage);
2539 XCTAssertNotEqual(msg1.optionalImportMessage, msg2.optionalImportMessage);
2540
2541 XCTAssertNotEqual(msg1.repeatedInt32Array, msg2.repeatedInt32Array);
2542 XCTAssertNotEqual(msg1.repeatedInt64Array, msg2.repeatedInt64Array);
2543 XCTAssertNotEqual(msg1.repeatedUint32Array, msg2.repeatedUint32Array);
2544 XCTAssertNotEqual(msg1.repeatedUint64Array, msg2.repeatedUint64Array);
2545 XCTAssertNotEqual(msg1.repeatedSint32Array, msg2.repeatedSint32Array);
2546 XCTAssertNotEqual(msg1.repeatedSint64Array, msg2.repeatedSint64Array);
2547 XCTAssertNotEqual(msg1.repeatedFixed32Array, msg2.repeatedFixed32Array);
2548 XCTAssertNotEqual(msg1.repeatedFixed64Array, msg2.repeatedFixed64Array);
2549 XCTAssertNotEqual(msg1.repeatedSfixed32Array, msg2.repeatedSfixed32Array);
2550 XCTAssertNotEqual(msg1.repeatedSfixed64Array, msg2.repeatedSfixed64Array);
2551 XCTAssertNotEqual(msg1.repeatedFloatArray, msg2.repeatedFloatArray);
2552 XCTAssertNotEqual(msg1.repeatedDoubleArray, msg2.repeatedDoubleArray);
2553 XCTAssertNotEqual(msg1.repeatedBoolArray, msg2.repeatedBoolArray);
2554 XCTAssertNotEqual(msg1.repeatedStringArray, msg2.repeatedStringArray);
2555 XCTAssertNotEqual(msg1.repeatedBytesArray, msg2.repeatedBytesArray);
2556 XCTAssertNotEqual(msg1.repeatedGroupArray, msg2.repeatedGroupArray);
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04002557 XCTAssertNotEqual(msg1.repeatedNestedMessageArray, msg2.repeatedNestedMessageArray);
2558 XCTAssertNotEqual(msg1.repeatedForeignMessageArray, msg2.repeatedForeignMessageArray);
2559 XCTAssertNotEqual(msg1.repeatedImportMessageArray, msg2.repeatedImportMessageArray);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002560 XCTAssertNotEqual(msg1.repeatedNestedEnumArray, msg2.repeatedNestedEnumArray);
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04002561 XCTAssertNotEqual(msg1.repeatedForeignEnumArray, msg2.repeatedForeignEnumArray);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002562 XCTAssertNotEqual(msg1.repeatedImportEnumArray, msg2.repeatedImportEnumArray);
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04002563 XCTAssertNotEqual(msg1.repeatedStringPieceArray, msg2.repeatedStringPieceArray);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002564 XCTAssertNotEqual(msg1.repeatedCordArray, msg2.repeatedCordArray);
2565
2566 for (int i = 0; i < repeatCount; i++) {
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04002567 XCTAssertNotEqual(msg1.repeatedNestedMessageArray[i], msg2.repeatedNestedMessageArray[i]);
2568 XCTAssertNotEqual(msg1.repeatedForeignMessageArray[i], msg2.repeatedForeignMessageArray[i]);
2569 XCTAssertNotEqual(msg1.repeatedImportMessageArray[i], msg2.repeatedImportMessageArray[i]);
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002570 }
2571}
2572
2573- (void)testCopyingMapsMakesUniqueObjects {
2574 TestMap *msg1 = [TestMap message];
2575 [self setAllMapFields:msg1 numEntries:5];
2576
2577 TestMap *msg2 = [[msg1 copy] autorelease];
2578
2579 XCTAssertNotEqual(msg1, msg2); // Ptr compare, new object.
2580 XCTAssertEqualObjects(msg1, msg2); // Equal values.
2581
Brian Wignalla104dff2020-01-08 13:18:20 -05002582 // Pointer comparisons, different objects.
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002583 XCTAssertNotEqual(msg1.mapInt32Int32, msg2.mapInt32Int32);
2584 XCTAssertNotEqual(msg1.mapInt64Int64, msg2.mapInt64Int64);
2585 XCTAssertNotEqual(msg1.mapUint32Uint32, msg2.mapUint32Uint32);
2586 XCTAssertNotEqual(msg1.mapUint64Uint64, msg2.mapUint64Uint64);
2587 XCTAssertNotEqual(msg1.mapSint32Sint32, msg2.mapSint32Sint32);
2588 XCTAssertNotEqual(msg1.mapSint64Sint64, msg2.mapSint64Sint64);
2589 XCTAssertNotEqual(msg1.mapFixed32Fixed32, msg2.mapFixed32Fixed32);
2590 XCTAssertNotEqual(msg1.mapFixed64Fixed64, msg2.mapFixed64Fixed64);
2591 XCTAssertNotEqual(msg1.mapSfixed32Sfixed32, msg2.mapSfixed32Sfixed32);
2592 XCTAssertNotEqual(msg1.mapSfixed64Sfixed64, msg2.mapSfixed64Sfixed64);
2593 XCTAssertNotEqual(msg1.mapInt32Float, msg2.mapInt32Float);
2594 XCTAssertNotEqual(msg1.mapInt32Double, msg2.mapInt32Double);
2595 XCTAssertNotEqual(msg1.mapBoolBool, msg2.mapBoolBool);
2596 XCTAssertNotEqual(msg1.mapStringString, msg2.mapStringString);
2597 XCTAssertNotEqual(msg1.mapInt32Bytes, msg2.mapInt32Bytes);
2598 XCTAssertNotEqual(msg1.mapInt32Enum, msg2.mapInt32Enum);
2599 XCTAssertNotEqual(msg1.mapInt32ForeignMessage, msg2.mapInt32ForeignMessage);
2600
2601 // Ensure the messages are unique per map.
2602 [msg1.mapInt32ForeignMessage
Thomas Van Lenten2fb33b82022-09-20 09:14:32 -04002603 enumerateKeysAndObjectsUsingBlock:^(int32_t key, id value, __unused BOOL *stop) {
Thomas Van Lenten1383d532015-09-29 11:41:53 -04002604 ForeignMessage *subMsg2 = [msg2.mapInt32ForeignMessage objectForKey:key];
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002605 XCTAssertNotEqual(value, subMsg2); // Ptr compare, new object.
2606 }];
2607}
2608
Thomas Van Lentenfc4c6172016-06-27 20:45:16 -04002609- (void)test_GPBGetMessageRepeatedField {
2610 TestAllTypes *message = [TestAllTypes message];
2611 GPBFieldDescriptor *fieldDescriptor = [[message descriptor] fieldWithName:@"repeatedStringArray"];
2612 XCTAssertNotNil(fieldDescriptor);
2613 NSMutableArray *fieldArray = GPBGetMessageRepeatedField(message, fieldDescriptor);
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04002614 XCTAssertNotNil(fieldArray); // Should have autocreated.
Thomas Van Lentenfc4c6172016-06-27 20:45:16 -04002615 XCTAssertTrue(fieldArray == message.repeatedStringArray); // Same pointer
2616}
2617
2618- (void)test_GPBSetMessageRepeatedField {
2619 TestAllTypes *message = [TestAllTypes message];
2620 GPBFieldDescriptor *fieldDescriptor = [[message descriptor] fieldWithName:@"repeatedStringArray"];
2621 XCTAssertNotNil(fieldDescriptor);
2622
2623 NSMutableArray *fieldArray = [NSMutableArray arrayWithObject:@"foo"];
2624 GPBSetMessageRepeatedField(message, fieldDescriptor, fieldArray);
2625 XCTAssertTrue(fieldArray == message.repeatedStringArray); // Same pointer
2626 XCTAssertEqualObjects(@"foo", message.repeatedStringArray.firstObject);
2627}
2628
2629- (void)test_GPBGetMessageMapField {
2630 TestMap *message = [TestMap message];
2631 GPBFieldDescriptor *fieldDescriptor = [[message descriptor] fieldWithName:@"mapStringString"];
2632 XCTAssertNotNil(fieldDescriptor);
2633 NSMutableDictionary *fieldMap = GPBGetMessageMapField(message, fieldDescriptor);
Thomas Van Lentenecd63bb2022-09-19 17:22:33 -04002634 XCTAssertNotNil(fieldMap); // Should have autocreated.
Thomas Van Lentenfc4c6172016-06-27 20:45:16 -04002635 XCTAssertTrue(fieldMap == message.mapStringString); // Same pointer
2636}
2637
2638- (void)test_GPBSetMessageMapField {
2639 TestMap *message = [TestMap message];
2640 GPBFieldDescriptor *fieldDescriptor = [[message descriptor] fieldWithName:@"mapStringString"];
2641 XCTAssertNotNil(fieldDescriptor);
2642
2643 NSMutableDictionary *fieldMap = [NSMutableDictionary dictionaryWithObject:@"bar" forKey:@"foo"];
2644 GPBSetMessageMapField(message, fieldDescriptor, fieldMap);
2645 XCTAssertTrue(fieldMap == message.mapStringString); // Same pointer
2646 XCTAssertEqualObjects(@"bar", message.mapStringString[@"foo"]);
2647}
2648
Thomas Van Lenten8c1748f2018-10-02 12:15:58 -04002649- (void)test_StringFieldsCopy {
Brian Wignalla104dff2020-01-08 13:18:20 -05002650 // ObjC conventions call for NSString properties to be copy, ensure
Thomas Van Lenten8c1748f2018-10-02 12:15:58 -04002651 // that is done correctly and the string isn't simply retained.
2652
2653 Message2 *msg1 = [Message2 message];
2654 Message2 *msg2 = [Message2 message];
2655
2656 GPBFieldDescriptor *fieldDesc =
2657 [[Message2 descriptor] fieldWithNumber:Message2_FieldNumber_OptionalString];
2658 NSMutableString *mutableStr = [NSMutableString stringWithString:@"foo"];
2659
2660 msg1.optionalString = mutableStr;
2661 GPBSetMessageStringField(msg2, fieldDesc, mutableStr);
2662
2663 XCTAssertEqualObjects(msg1.optionalString, mutableStr);
2664 XCTAssertEqualObjects(msg1.optionalString, @"foo");
Brian Wignalla104dff2020-01-08 13:18:20 -05002665 XCTAssertTrue(msg1.optionalString != mutableStr); // Ptr comparison.
Thomas Van Lenten8c1748f2018-10-02 12:15:58 -04002666
2667 XCTAssertEqualObjects(msg2.optionalString, mutableStr);
2668 XCTAssertEqualObjects(msg2.optionalString, @"foo");
Brian Wignalla104dff2020-01-08 13:18:20 -05002669 XCTAssertTrue(msg2.optionalString != mutableStr); // Ptr comparison.
Thomas Van Lenten8c1748f2018-10-02 12:15:58 -04002670
2671 [mutableStr appendString:@"bar"];
2672
2673 XCTAssertNotEqualObjects(msg1.optionalString, mutableStr);
2674 XCTAssertEqualObjects(msg1.optionalString, @"foo");
Brian Wignalla104dff2020-01-08 13:18:20 -05002675 XCTAssertTrue(msg1.optionalString != mutableStr); // Ptr comparison.
Thomas Van Lenten8c1748f2018-10-02 12:15:58 -04002676
2677 XCTAssertNotEqualObjects(msg2.optionalString, mutableStr);
2678 XCTAssertEqualObjects(msg2.optionalString, @"foo");
Brian Wignalla104dff2020-01-08 13:18:20 -05002679 XCTAssertTrue(msg2.optionalString != mutableStr); // Ptr comparison.
Thomas Van Lenten8c1748f2018-10-02 12:15:58 -04002680}
2681
2682- (void)test_BytesFieldsCopy {
Brian Wignalla104dff2020-01-08 13:18:20 -05002683 // ObjC conventions call for NSData properties to be copy, ensure
Thomas Van Lenten8c1748f2018-10-02 12:15:58 -04002684 // that is done correctly and the data isn't simply retained.
2685
2686 Message2 *msg1 = [Message2 message];
2687 Message2 *msg2 = [Message2 message];
2688
2689 GPBFieldDescriptor *fieldDesc =
2690 [[Message2 descriptor] fieldWithNumber:Message2_FieldNumber_OptionalBytes];
2691 NSMutableData *mutableData = [NSMutableData dataWithData:DataFromCStr("abc")];
2692
2693 msg1.optionalBytes = mutableData;
2694 GPBSetMessageBytesField(msg2, fieldDesc, mutableData);
2695
2696 XCTAssertEqualObjects(msg1.optionalBytes, mutableData);
2697 XCTAssertEqualObjects(msg1.optionalBytes, DataFromCStr("abc"));
Brian Wignalla104dff2020-01-08 13:18:20 -05002698 XCTAssertTrue(msg1.optionalBytes != mutableData); // Ptr comparison.
Thomas Van Lenten8c1748f2018-10-02 12:15:58 -04002699
2700 XCTAssertEqualObjects(msg2.optionalBytes, mutableData);
2701 XCTAssertEqualObjects(msg2.optionalBytes, DataFromCStr("abc"));
Brian Wignalla104dff2020-01-08 13:18:20 -05002702 XCTAssertTrue(msg2.optionalBytes != mutableData); // Ptr comparison.
Thomas Van Lenten8c1748f2018-10-02 12:15:58 -04002703
2704 [mutableData appendData:DataFromCStr("123")];
2705
2706 XCTAssertNotEqualObjects(msg1.optionalBytes, mutableData);
2707 XCTAssertEqualObjects(msg1.optionalBytes, DataFromCStr("abc"));
Brian Wignalla104dff2020-01-08 13:18:20 -05002708 XCTAssertTrue(msg1.optionalBytes != mutableData); // Ptr comparison.
Thomas Van Lenten8c1748f2018-10-02 12:15:58 -04002709
2710 XCTAssertNotEqualObjects(msg2.optionalBytes, mutableData);
2711 XCTAssertEqualObjects(msg2.optionalBytes, DataFromCStr("abc"));
Brian Wignalla104dff2020-01-08 13:18:20 -05002712 XCTAssertTrue(msg2.optionalBytes != mutableData); // Ptr comparison.
Thomas Van Lenten8c1748f2018-10-02 12:15:58 -04002713}
2714
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002715#pragma mark - Subset from from map_tests.cc
2716
2717// TEST(GeneratedMapFieldTest, IsInitialized)
2718- (void)testMap_IsInitialized {
2719 TestRequiredMessageMap *msg = [[TestRequiredMessageMap alloc] init];
2720
2721 // Add an uninitialized message.
2722 TestRequired *subMsg = [[TestRequired alloc] init];
Thomas Van Lenten1383d532015-09-29 11:41:53 -04002723 [msg.mapField setObject:subMsg forKey:0];
Thomas Van Lenten30650d82015-05-01 08:57:16 -04002724 XCTAssertFalse(msg.initialized);
2725
2726 // Initialize uninitialized message
2727 subMsg.a = 0;
2728 subMsg.b = 0;
2729 subMsg.c = 0;
2730 XCTAssertTrue(msg.initialized);
2731
2732 [subMsg release];
2733 [msg release];
2734}
2735
2736@end