• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// 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
37#import "google/protobuf/MapUnittest.pbobjc.h"
38#import "google/protobuf/Unittest.pbobjc.h"
39#import "google/protobuf/UnittestCycle.pbobjc.h"
40#import "google/protobuf/UnittestObjcStartup.pbobjc.h"
41#import "google/protobuf/UnittestRuntimeProto2.pbobjc.h"
42#import "google/protobuf/UnittestRuntimeProto3.pbobjc.h"
43
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
52- (void)testStartupOrdering {
53  // 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
62  TestObjCStartupMessage *message = [TestObjCStartupMessage message];
63  XCTAssertNotNil(message);
64
65  CycleBaz *baz = [CycleBaz message];
66  CycleBar *bar = [CycleBar message];
67  CycleFoo *foo = [CycleFoo message];
68  XCTAssertNotNil(baz);
69  XCTAssertNotNil(bar);
70  XCTAssertNotNil(foo);
71}
72
73- (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:
96
97  // Single fields - has*/setHas* is valid.
98
99  for (NSString *name in names) {
100    // build the selector, i.e. - hasOptionalInt32/setHasOptionalInt32:
101    SEL hasSel = NSSelectorFromString(
102        [NSString stringWithFormat:@"hasOptional%@", name]);
103    SEL setHasSel = NSSelectorFromString(
104        [NSString stringWithFormat:@"setHasOptional%@:", name]);
105    XCTAssertTrue([Message2 instancesRespondToSelector:hasSel], @"field: %@",
106                  name);
107    XCTAssertTrue([Message2 instancesRespondToSelector:setHasSel], @"field: %@",
108                  name);
109  }
110
111  // Repeated fields
112  //  - no has*/setHas*
113  //  - *Count
114
115  for (NSString *name in names) {
116    // build the selector, i.e. - hasRepeatedInt32Array/setHasRepeatedInt32Array:
117    SEL hasSel = NSSelectorFromString(
118        [NSString stringWithFormat:@"hasRepeated%@Array", name]);
119    SEL setHasSel = NSSelectorFromString(
120        [NSString stringWithFormat:@"setHasRepeated%@Array:", name]);
121    XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@",
122                   name);
123    XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel],
124                   @"field: %@", name);
125    // build the selector, i.e. - repeatedInt32Array_Count
126    SEL countSel = NSSelectorFromString(
127        [NSString stringWithFormat:@"repeated%@Array_Count", name]);
128    XCTAssertTrue([Message2 instancesRespondToSelector:countSel], @"field: %@",
129                   name);
130  }
131
132  // OneOf fields - no has*/setHas*
133
134  for (NSString *name in names) {
135    // build the selector, i.e. - hasOneofInt32/setHasOneofInt32:
136    SEL hasSel =
137        NSSelectorFromString([NSString stringWithFormat:@"hasOneof%@", name]);
138    SEL setHasSel = NSSelectorFromString(
139        [NSString stringWithFormat:@"setHasOneof%@:", name]);
140    XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@",
141                   name);
142    XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel],
143                   @"field: %@", name);
144  }
145
146  // map<> fields
147  //  - no has*/setHas*
148  //  - *Count
149
150  NSArray *mapNames = @[
151    @"Int32Int32",
152    @"Int64Int64",
153    @"Uint32Uint32",
154    @"Uint64Uint64",
155    @"Sint32Sint32",
156    @"Sint64Sint64",
157    @"Fixed32Fixed32",
158    @"Fixed64Fixed64",
159    @"Sfixed32Sfixed32",
160    @"Sfixed64Sfixed64",
161    @"Int32Float",
162    @"Int32Double",
163    @"BoolBool",
164    @"StringString",
165    @"StringBytes",
166    @"StringMessage",
167    @"Int32Bytes",
168    @"Int32Enum",
169    @"Int32Message",
170  ];
171
172  for (NSString *name in mapNames) {
173    // build the selector, i.e. - hasMapInt32Int32/setHasMapInt32Int32:
174    SEL hasSel = NSSelectorFromString(
175        [NSString stringWithFormat:@"hasMap%@", name]);
176    SEL setHasSel = NSSelectorFromString(
177        [NSString stringWithFormat:@"setHasMap%@:", name]);
178    XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@",
179                   name);
180    XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel],
181                   @"field: %@", name);
182    // build the selector, i.e. - mapInt32Int32Count
183    SEL countSel = NSSelectorFromString(
184        [NSString stringWithFormat:@"map%@_Count", name]);
185    XCTAssertTrue([Message2 instancesRespondToSelector:countSel], @"field: %@",
186                   name);
187  }
188
189}
190
191- (void)testProto3HasMethodSupport {
192  NSArray *names = @[
193    @"Int32",
194    @"Int64",
195    @"Uint32",
196    @"Uint64",
197    @"Sint32",
198    @"Sint64",
199    @"Fixed32",
200    @"Fixed64",
201    @"Sfixed32",
202    @"Sfixed64",
203    @"Float",
204    @"Double",
205    @"Bool",
206    @"String",
207    @"Bytes",
208    @"Message",
209    @"Enum",
210  ];
211
212  // Proto3 gets:
213
214  // Single fields
215  //  - has*/setHas* invalid for primative types.
216  //  - has*/setHas* valid for Message.
217
218  for (NSString *name in names) {
219    // build the selector, i.e. - hasOptionalInt32/setHasOptionalInt32:
220    SEL hasSel = NSSelectorFromString(
221        [NSString stringWithFormat:@"hasOptional%@", name]);
222    SEL setHasSel = NSSelectorFromString(
223        [NSString stringWithFormat:@"setHasOptional%@:", name]);
224    if ([name isEqual:@"Message"]) {
225      // Sub messages/groups are the exception.
226      XCTAssertTrue([Message3 instancesRespondToSelector:hasSel], @"field: %@",
227                    name);
228      XCTAssertTrue([Message3 instancesRespondToSelector:setHasSel],
229                    @"field: %@", name);
230    } else {
231      XCTAssertFalse([Message3 instancesRespondToSelector:hasSel], @"field: %@",
232                     name);
233      XCTAssertFalse([Message3 instancesRespondToSelector:setHasSel],
234                     @"field: %@", name);
235    }
236  }
237
238  // Repeated fields
239  //  - no has*/setHas*
240  //  - *Count
241
242  for (NSString *name in names) {
243    // build the selector, i.e. - hasRepeatedInt32Array/setHasRepeatedInt32Array:
244    SEL hasSel = NSSelectorFromString(
245        [NSString stringWithFormat:@"hasRepeated%@Array", name]);
246    SEL setHasSel = NSSelectorFromString(
247        [NSString stringWithFormat:@"setHasRepeated%@Array:", name]);
248    XCTAssertFalse([Message3 instancesRespondToSelector:hasSel], @"field: %@",
249                   name);
250    XCTAssertFalse([Message3 instancesRespondToSelector:setHasSel],
251                   @"field: %@", name);
252    // build the selector, i.e. - repeatedInt32Array_Count
253    SEL countSel = NSSelectorFromString(
254        [NSString stringWithFormat:@"repeated%@Array_Count", name]);
255    XCTAssertTrue([Message2 instancesRespondToSelector:countSel], @"field: %@",
256                  name);
257  }
258
259  // OneOf fields - no has*/setHas*
260
261  for (NSString *name in names) {
262    // build the selector, i.e. - hasOneofInt32/setHasOneofInt32:
263    SEL hasSel =
264        NSSelectorFromString([NSString stringWithFormat:@"hasOneof%@", name]);
265    SEL setHasSel = NSSelectorFromString(
266        [NSString stringWithFormat:@"setHasOneof%@:", name]);
267    XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@",
268                   name);
269    XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel],
270                   @"field: %@", name);
271  }
272
273  // map<> fields
274  //  - no has*/setHas*
275  //  - *Count
276
277  NSArray *mapNames = @[
278    @"Int32Int32",
279    @"Int64Int64",
280    @"Uint32Uint32",
281    @"Uint64Uint64",
282    @"Sint32Sint32",
283    @"Sint64Sint64",
284    @"Fixed32Fixed32",
285    @"Fixed64Fixed64",
286    @"Sfixed32Sfixed32",
287    @"Sfixed64Sfixed64",
288    @"Int32Float",
289    @"Int32Double",
290    @"BoolBool",
291    @"StringString",
292    @"StringBytes",
293    @"StringMessage",
294    @"Int32Bytes",
295    @"Int32Enum",
296    @"Int32Message",
297  ];
298
299  for (NSString *name in mapNames) {
300    // build the selector, i.e. - hasMapInt32Int32/setHasMapInt32Int32:
301    SEL hasSel = NSSelectorFromString(
302        [NSString stringWithFormat:@"hasMap%@", name]);
303    SEL setHasSel = NSSelectorFromString(
304        [NSString stringWithFormat:@"setHasMap%@:", name]);
305    XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@",
306                   name);
307    XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel],
308                   @"field: %@", name);
309    // build the selector, i.e. - mapInt32Int32Count
310    SEL countSel = NSSelectorFromString(
311        [NSString stringWithFormat:@"map%@_Count", name]);
312    XCTAssertTrue([Message2 instancesRespondToSelector:countSel], @"field: %@",
313                   name);
314  }
315}
316
317- (void)testProto2SingleFieldHasBehavior {
318  //
319  // Setting to any value including the default value (0) should result has*
320  // being true.
321  //
322
323//%PDDM-DEFINE PROTO2_TEST_HAS_FIELD(FIELD, NON_ZERO_VALUE, ZERO_VALUE)
324//%  {  // optional##FIELD :: NON_ZERO_VALUE
325//%    Message2 *msg = [[Message2 alloc] init];
326//%    XCTAssertFalse(msg.hasOptional##FIELD);
327//%    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD));
328//%    msg.optional##FIELD = NON_ZERO_VALUE;
329//%    XCTAssertTrue(msg.hasOptional##FIELD);
330//%    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD));
331//%    [msg release];
332//%  }
333//%  {  // optional##FIELD :: ZERO_VALUE
334//%    Message2 *msg = [[Message2 alloc] init];
335//%    XCTAssertFalse(msg.hasOptional##FIELD);
336//%    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD));
337//%    msg.optional##FIELD = ZERO_VALUE;
338//%    XCTAssertTrue(msg.hasOptional##FIELD);
339//%    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD));
340//%    [msg release];
341//%  }
342//%
343//%PDDM-DEFINE PROTO2_TEST_CLEAR_FIELD_WITH_NIL(FIELD, VALUE)
344//%  {  // optional##FIELD
345//%    Message2 *msg = [[Message2 alloc] init];
346//%    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD));
347//%    msg.optional##FIELD = VALUE;
348//%    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD));
349//%    msg.optional##FIELD = nil;
350//%    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional##FIELD));
351//%    [msg release];
352//%  }
353//%
354//%PDDM-DEFINE PROTO2_TEST_HAS_FIELDS()
355//%PROTO2_TEST_HAS_FIELD(Int32, 1, 0)
356//%PROTO2_TEST_HAS_FIELD(Int64, 1, 0)
357//%PROTO2_TEST_HAS_FIELD(Uint32, 1, 0)
358//%PROTO2_TEST_HAS_FIELD(Uint64, 1, 0)
359//%PROTO2_TEST_HAS_FIELD(Sint32, 1, 0)
360//%PROTO2_TEST_HAS_FIELD(Sint64, 1, 0)
361//%PROTO2_TEST_HAS_FIELD(Fixed32, 1, 0)
362//%PROTO2_TEST_HAS_FIELD(Fixed64, 1, 0)
363//%PROTO2_TEST_HAS_FIELD(Sfixed32, 1, 0)
364//%PROTO2_TEST_HAS_FIELD(Sfixed64, 1, 0)
365//%PROTO2_TEST_HAS_FIELD(Float, 1.0f, 0.0f)
366//%PROTO2_TEST_HAS_FIELD(Double, 1.0, 0.0)
367//%PROTO2_TEST_HAS_FIELD(Bool, YES, NO)
368//%PROTO2_TEST_HAS_FIELD(String, @"foo", @"")
369//%PROTO2_TEST_HAS_FIELD(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding], [NSData data])
370//%  //
371//%  // Test doesn't apply to optionalGroup/optionalMessage.
372//%  //
373//%
374//%PROTO2_TEST_HAS_FIELD(Enum, Message2_Enum_Bar, Message2_Enum_Foo)
375//%  //
376//%  // Nil can also be used to clear strings, bytes, groups, and messages.
377//%  //
378//%
379//%PROTO2_TEST_CLEAR_FIELD_WITH_NIL(String, @"foo")
380//%PROTO2_TEST_CLEAR_FIELD_WITH_NIL(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding])
381//%PROTO2_TEST_CLEAR_FIELD_WITH_NIL(Group, [Message2_OptionalGroup message])
382//%PROTO2_TEST_CLEAR_FIELD_WITH_NIL(Message, [Message2 message])
383//%PDDM-EXPAND PROTO2_TEST_HAS_FIELDS()
384// This block of code is generated, do not edit it directly.
385
386  {  // optionalInt32 :: 1
387    Message2 *msg = [[Message2 alloc] init];
388    XCTAssertFalse(msg.hasOptionalInt32);
389    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt32));
390    msg.optionalInt32 = 1;
391    XCTAssertTrue(msg.hasOptionalInt32);
392    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt32));
393    [msg release];
394  }
395  {  // optionalInt32 :: 0
396    Message2 *msg = [[Message2 alloc] init];
397    XCTAssertFalse(msg.hasOptionalInt32);
398    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt32));
399    msg.optionalInt32 = 0;
400    XCTAssertTrue(msg.hasOptionalInt32);
401    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt32));
402    [msg release];
403  }
404
405  {  // optionalInt64 :: 1
406    Message2 *msg = [[Message2 alloc] init];
407    XCTAssertFalse(msg.hasOptionalInt64);
408    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt64));
409    msg.optionalInt64 = 1;
410    XCTAssertTrue(msg.hasOptionalInt64);
411    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt64));
412    [msg release];
413  }
414  {  // optionalInt64 :: 0
415    Message2 *msg = [[Message2 alloc] init];
416    XCTAssertFalse(msg.hasOptionalInt64);
417    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt64));
418    msg.optionalInt64 = 0;
419    XCTAssertTrue(msg.hasOptionalInt64);
420    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalInt64));
421    [msg release];
422  }
423
424  {  // optionalUint32 :: 1
425    Message2 *msg = [[Message2 alloc] init];
426    XCTAssertFalse(msg.hasOptionalUint32);
427    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint32));
428    msg.optionalUint32 = 1;
429    XCTAssertTrue(msg.hasOptionalUint32);
430    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint32));
431    [msg release];
432  }
433  {  // optionalUint32 :: 0
434    Message2 *msg = [[Message2 alloc] init];
435    XCTAssertFalse(msg.hasOptionalUint32);
436    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint32));
437    msg.optionalUint32 = 0;
438    XCTAssertTrue(msg.hasOptionalUint32);
439    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint32));
440    [msg release];
441  }
442
443  {  // optionalUint64 :: 1
444    Message2 *msg = [[Message2 alloc] init];
445    XCTAssertFalse(msg.hasOptionalUint64);
446    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint64));
447    msg.optionalUint64 = 1;
448    XCTAssertTrue(msg.hasOptionalUint64);
449    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint64));
450    [msg release];
451  }
452  {  // optionalUint64 :: 0
453    Message2 *msg = [[Message2 alloc] init];
454    XCTAssertFalse(msg.hasOptionalUint64);
455    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint64));
456    msg.optionalUint64 = 0;
457    XCTAssertTrue(msg.hasOptionalUint64);
458    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalUint64));
459    [msg release];
460  }
461
462  {  // optionalSint32 :: 1
463    Message2 *msg = [[Message2 alloc] init];
464    XCTAssertFalse(msg.hasOptionalSint32);
465    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint32));
466    msg.optionalSint32 = 1;
467    XCTAssertTrue(msg.hasOptionalSint32);
468    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint32));
469    [msg release];
470  }
471  {  // optionalSint32 :: 0
472    Message2 *msg = [[Message2 alloc] init];
473    XCTAssertFalse(msg.hasOptionalSint32);
474    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint32));
475    msg.optionalSint32 = 0;
476    XCTAssertTrue(msg.hasOptionalSint32);
477    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint32));
478    [msg release];
479  }
480
481  {  // optionalSint64 :: 1
482    Message2 *msg = [[Message2 alloc] init];
483    XCTAssertFalse(msg.hasOptionalSint64);
484    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint64));
485    msg.optionalSint64 = 1;
486    XCTAssertTrue(msg.hasOptionalSint64);
487    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint64));
488    [msg release];
489  }
490  {  // optionalSint64 :: 0
491    Message2 *msg = [[Message2 alloc] init];
492    XCTAssertFalse(msg.hasOptionalSint64);
493    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint64));
494    msg.optionalSint64 = 0;
495    XCTAssertTrue(msg.hasOptionalSint64);
496    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSint64));
497    [msg release];
498  }
499
500  {  // optionalFixed32 :: 1
501    Message2 *msg = [[Message2 alloc] init];
502    XCTAssertFalse(msg.hasOptionalFixed32);
503    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed32));
504    msg.optionalFixed32 = 1;
505    XCTAssertTrue(msg.hasOptionalFixed32);
506    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed32));
507    [msg release];
508  }
509  {  // optionalFixed32 :: 0
510    Message2 *msg = [[Message2 alloc] init];
511    XCTAssertFalse(msg.hasOptionalFixed32);
512    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed32));
513    msg.optionalFixed32 = 0;
514    XCTAssertTrue(msg.hasOptionalFixed32);
515    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed32));
516    [msg release];
517  }
518
519  {  // optionalFixed64 :: 1
520    Message2 *msg = [[Message2 alloc] init];
521    XCTAssertFalse(msg.hasOptionalFixed64);
522    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed64));
523    msg.optionalFixed64 = 1;
524    XCTAssertTrue(msg.hasOptionalFixed64);
525    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed64));
526    [msg release];
527  }
528  {  // optionalFixed64 :: 0
529    Message2 *msg = [[Message2 alloc] init];
530    XCTAssertFalse(msg.hasOptionalFixed64);
531    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed64));
532    msg.optionalFixed64 = 0;
533    XCTAssertTrue(msg.hasOptionalFixed64);
534    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFixed64));
535    [msg release];
536  }
537
538  {  // optionalSfixed32 :: 1
539    Message2 *msg = [[Message2 alloc] init];
540    XCTAssertFalse(msg.hasOptionalSfixed32);
541    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed32));
542    msg.optionalSfixed32 = 1;
543    XCTAssertTrue(msg.hasOptionalSfixed32);
544    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed32));
545    [msg release];
546  }
547  {  // optionalSfixed32 :: 0
548    Message2 *msg = [[Message2 alloc] init];
549    XCTAssertFalse(msg.hasOptionalSfixed32);
550    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed32));
551    msg.optionalSfixed32 = 0;
552    XCTAssertTrue(msg.hasOptionalSfixed32);
553    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed32));
554    [msg release];
555  }
556
557  {  // optionalSfixed64 :: 1
558    Message2 *msg = [[Message2 alloc] init];
559    XCTAssertFalse(msg.hasOptionalSfixed64);
560    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed64));
561    msg.optionalSfixed64 = 1;
562    XCTAssertTrue(msg.hasOptionalSfixed64);
563    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed64));
564    [msg release];
565  }
566  {  // optionalSfixed64 :: 0
567    Message2 *msg = [[Message2 alloc] init];
568    XCTAssertFalse(msg.hasOptionalSfixed64);
569    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed64));
570    msg.optionalSfixed64 = 0;
571    XCTAssertTrue(msg.hasOptionalSfixed64);
572    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalSfixed64));
573    [msg release];
574  }
575
576  {  // optionalFloat :: 1.0f
577    Message2 *msg = [[Message2 alloc] init];
578    XCTAssertFalse(msg.hasOptionalFloat);
579    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFloat));
580    msg.optionalFloat = 1.0f;
581    XCTAssertTrue(msg.hasOptionalFloat);
582    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFloat));
583    [msg release];
584  }
585  {  // optionalFloat :: 0.0f
586    Message2 *msg = [[Message2 alloc] init];
587    XCTAssertFalse(msg.hasOptionalFloat);
588    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFloat));
589    msg.optionalFloat = 0.0f;
590    XCTAssertTrue(msg.hasOptionalFloat);
591    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalFloat));
592    [msg release];
593  }
594
595  {  // optionalDouble :: 1.0
596    Message2 *msg = [[Message2 alloc] init];
597    XCTAssertFalse(msg.hasOptionalDouble);
598    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalDouble));
599    msg.optionalDouble = 1.0;
600    XCTAssertTrue(msg.hasOptionalDouble);
601    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalDouble));
602    [msg release];
603  }
604  {  // optionalDouble :: 0.0
605    Message2 *msg = [[Message2 alloc] init];
606    XCTAssertFalse(msg.hasOptionalDouble);
607    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalDouble));
608    msg.optionalDouble = 0.0;
609    XCTAssertTrue(msg.hasOptionalDouble);
610    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalDouble));
611    [msg release];
612  }
613
614  {  // optionalBool :: YES
615    Message2 *msg = [[Message2 alloc] init];
616    XCTAssertFalse(msg.hasOptionalBool);
617    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBool));
618    msg.optionalBool = YES;
619    XCTAssertTrue(msg.hasOptionalBool);
620    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBool));
621    [msg release];
622  }
623  {  // optionalBool :: NO
624    Message2 *msg = [[Message2 alloc] init];
625    XCTAssertFalse(msg.hasOptionalBool);
626    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBool));
627    msg.optionalBool = NO;
628    XCTAssertTrue(msg.hasOptionalBool);
629    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBool));
630    [msg release];
631  }
632
633  {  // optionalString :: @"foo"
634    Message2 *msg = [[Message2 alloc] init];
635    XCTAssertFalse(msg.hasOptionalString);
636    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString));
637    msg.optionalString = @"foo";
638    XCTAssertTrue(msg.hasOptionalString);
639    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString));
640    [msg release];
641  }
642  {  // optionalString :: @""
643    Message2 *msg = [[Message2 alloc] init];
644    XCTAssertFalse(msg.hasOptionalString);
645    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString));
646    msg.optionalString = @"";
647    XCTAssertTrue(msg.hasOptionalString);
648    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString));
649    [msg release];
650  }
651
652  {  // optionalBytes :: [@"foo" dataUsingEncoding:NSUTF8StringEncoding]
653    Message2 *msg = [[Message2 alloc] init];
654    XCTAssertFalse(msg.hasOptionalBytes);
655    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes));
656    msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding];
657    XCTAssertTrue(msg.hasOptionalBytes);
658    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes));
659    [msg release];
660  }
661  {  // optionalBytes :: [NSData data]
662    Message2 *msg = [[Message2 alloc] init];
663    XCTAssertFalse(msg.hasOptionalBytes);
664    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes));
665    msg.optionalBytes = [NSData data];
666    XCTAssertTrue(msg.hasOptionalBytes);
667    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes));
668    [msg release];
669  }
670
671  //
672  // Test doesn't apply to optionalGroup/optionalMessage.
673  //
674
675  {  // optionalEnum :: Message2_Enum_Bar
676    Message2 *msg = [[Message2 alloc] init];
677    XCTAssertFalse(msg.hasOptionalEnum);
678    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalEnum));
679    msg.optionalEnum = Message2_Enum_Bar;
680    XCTAssertTrue(msg.hasOptionalEnum);
681    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalEnum));
682    [msg release];
683  }
684  {  // optionalEnum :: Message2_Enum_Foo
685    Message2 *msg = [[Message2 alloc] init];
686    XCTAssertFalse(msg.hasOptionalEnum);
687    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalEnum));
688    msg.optionalEnum = Message2_Enum_Foo;
689    XCTAssertTrue(msg.hasOptionalEnum);
690    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalEnum));
691    [msg release];
692  }
693
694  //
695  // Nil can also be used to clear strings, bytes, groups, and messages.
696  //
697
698  {  // optionalString
699    Message2 *msg = [[Message2 alloc] init];
700    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString));
701    msg.optionalString = @"foo";
702    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString));
703    msg.optionalString = nil;
704    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalString));
705    [msg release];
706  }
707
708  {  // optionalBytes
709    Message2 *msg = [[Message2 alloc] init];
710    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes));
711    msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding];
712    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes));
713    msg.optionalBytes = nil;
714    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalBytes));
715    [msg release];
716  }
717
718  {  // optionalGroup
719    Message2 *msg = [[Message2 alloc] init];
720    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalGroup));
721    msg.optionalGroup = [Message2_OptionalGroup message];
722    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalGroup));
723    msg.optionalGroup = nil;
724    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalGroup));
725    [msg release];
726  }
727
728  {  // optionalMessage
729    Message2 *msg = [[Message2 alloc] init];
730    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalMessage));
731    msg.optionalMessage = [Message2 message];
732    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalMessage));
733    msg.optionalMessage = nil;
734    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_OptionalMessage));
735    [msg release];
736  }
737
738//%PDDM-EXPAND-END PROTO2_TEST_HAS_FIELDS()
739}
740
741- (void)testProto3SingleFieldHasBehavior {
742  //
743  // Setting to any value but the default value (0) should result has*
744  // being true.  When set to the default, shouldn't be true.
745  //
746
747//%PDDM-DEFINE PROTO3_TEST_HAS_FIELD(FIELD, NON_ZERO_VALUE, ZERO_VALUE)
748//%  {  // optional##FIELD
749//%    Message3 *msg = [[Message3 alloc] init];
750//%    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD));
751//%    msg.optional##FIELD = NON_ZERO_VALUE;
752//%    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD));
753//%    msg.optional##FIELD = ZERO_VALUE;
754//%    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD));
755//%    [msg release];
756//%  }
757//%
758//%PDDM-DEFINE PROTO3_TEST_CLEAR_FIELD_WITH_NIL(FIELD, VALUE)
759//%  {  // optional##FIELD
760//%    Message3 *msg = [[Message3 alloc] init];
761//%    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD));
762//%    msg.optional##FIELD = VALUE;
763//%    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD));
764//%    msg.optional##FIELD = nil;
765//%    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional##FIELD));
766//%    [msg release];
767//%  }
768//%
769//%PDDM-DEFINE PROTO3_TEST_HAS_FIELDS()
770//%PROTO3_TEST_HAS_FIELD(Int32, 1, 0)
771//%PROTO3_TEST_HAS_FIELD(Int64, 1, 0)
772//%PROTO3_TEST_HAS_FIELD(Uint32, 1, 0)
773//%PROTO3_TEST_HAS_FIELD(Uint64, 1, 0)
774//%PROTO3_TEST_HAS_FIELD(Sint32, 1, 0)
775//%PROTO3_TEST_HAS_FIELD(Sint64, 1, 0)
776//%PROTO3_TEST_HAS_FIELD(Fixed32, 1, 0)
777//%PROTO3_TEST_HAS_FIELD(Fixed64, 1, 0)
778//%PROTO3_TEST_HAS_FIELD(Sfixed32, 1, 0)
779//%PROTO3_TEST_HAS_FIELD(Sfixed64, 1, 0)
780//%PROTO3_TEST_HAS_FIELD(Float, 1.0f, 0.0f)
781//%PROTO3_TEST_HAS_FIELD(Double, 1.0, 0.0)
782//%PROTO3_TEST_HAS_FIELD(Bool, YES, NO)
783//%PROTO3_TEST_HAS_FIELD(String, @"foo", @"")
784//%PROTO3_TEST_HAS_FIELD(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding], [NSData data])
785//%  //
786//%  // Test doesn't apply to optionalMessage (no groups in proto3).
787//%  //
788//%
789//%PROTO3_TEST_HAS_FIELD(Enum, Message3_Enum_Bar, Message3_Enum_Foo)
790//%  //
791//%  // Nil can also be used to clear strings, bytes, and messages (no groups in proto3).
792//%  //
793//%
794//%PROTO3_TEST_CLEAR_FIELD_WITH_NIL(String, @"foo")
795//%PROTO3_TEST_CLEAR_FIELD_WITH_NIL(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding])
796//%PROTO3_TEST_CLEAR_FIELD_WITH_NIL(Message, [Message3 message])
797//%PDDM-EXPAND PROTO3_TEST_HAS_FIELDS()
798// This block of code is generated, do not edit it directly.
799
800  {  // optionalInt32
801    Message3 *msg = [[Message3 alloc] init];
802    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt32));
803    msg.optionalInt32 = 1;
804    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt32));
805    msg.optionalInt32 = 0;
806    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt32));
807    [msg release];
808  }
809
810  {  // optionalInt64
811    Message3 *msg = [[Message3 alloc] init];
812    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt64));
813    msg.optionalInt64 = 1;
814    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt64));
815    msg.optionalInt64 = 0;
816    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalInt64));
817    [msg release];
818  }
819
820  {  // optionalUint32
821    Message3 *msg = [[Message3 alloc] init];
822    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint32));
823    msg.optionalUint32 = 1;
824    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint32));
825    msg.optionalUint32 = 0;
826    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint32));
827    [msg release];
828  }
829
830  {  // optionalUint64
831    Message3 *msg = [[Message3 alloc] init];
832    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint64));
833    msg.optionalUint64 = 1;
834    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint64));
835    msg.optionalUint64 = 0;
836    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalUint64));
837    [msg release];
838  }
839
840  {  // optionalSint32
841    Message3 *msg = [[Message3 alloc] init];
842    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint32));
843    msg.optionalSint32 = 1;
844    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint32));
845    msg.optionalSint32 = 0;
846    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint32));
847    [msg release];
848  }
849
850  {  // optionalSint64
851    Message3 *msg = [[Message3 alloc] init];
852    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint64));
853    msg.optionalSint64 = 1;
854    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint64));
855    msg.optionalSint64 = 0;
856    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSint64));
857    [msg release];
858  }
859
860  {  // optionalFixed32
861    Message3 *msg = [[Message3 alloc] init];
862    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed32));
863    msg.optionalFixed32 = 1;
864    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed32));
865    msg.optionalFixed32 = 0;
866    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed32));
867    [msg release];
868  }
869
870  {  // optionalFixed64
871    Message3 *msg = [[Message3 alloc] init];
872    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed64));
873    msg.optionalFixed64 = 1;
874    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed64));
875    msg.optionalFixed64 = 0;
876    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFixed64));
877    [msg release];
878  }
879
880  {  // optionalSfixed32
881    Message3 *msg = [[Message3 alloc] init];
882    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed32));
883    msg.optionalSfixed32 = 1;
884    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed32));
885    msg.optionalSfixed32 = 0;
886    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed32));
887    [msg release];
888  }
889
890  {  // optionalSfixed64
891    Message3 *msg = [[Message3 alloc] init];
892    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed64));
893    msg.optionalSfixed64 = 1;
894    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed64));
895    msg.optionalSfixed64 = 0;
896    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalSfixed64));
897    [msg release];
898  }
899
900  {  // optionalFloat
901    Message3 *msg = [[Message3 alloc] init];
902    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFloat));
903    msg.optionalFloat = 1.0f;
904    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFloat));
905    msg.optionalFloat = 0.0f;
906    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalFloat));
907    [msg release];
908  }
909
910  {  // optionalDouble
911    Message3 *msg = [[Message3 alloc] init];
912    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalDouble));
913    msg.optionalDouble = 1.0;
914    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalDouble));
915    msg.optionalDouble = 0.0;
916    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalDouble));
917    [msg release];
918  }
919
920  {  // optionalBool
921    Message3 *msg = [[Message3 alloc] init];
922    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBool));
923    msg.optionalBool = YES;
924    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBool));
925    msg.optionalBool = NO;
926    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBool));
927    [msg release];
928  }
929
930  {  // optionalString
931    Message3 *msg = [[Message3 alloc] init];
932    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString));
933    msg.optionalString = @"foo";
934    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString));
935    msg.optionalString = @"";
936    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString));
937    [msg release];
938  }
939
940  {  // optionalBytes
941    Message3 *msg = [[Message3 alloc] init];
942    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes));
943    msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding];
944    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes));
945    msg.optionalBytes = [NSData data];
946    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes));
947    [msg release];
948  }
949
950  //
951  // Test doesn't apply to optionalMessage (no groups in proto3).
952  //
953
954  {  // optionalEnum
955    Message3 *msg = [[Message3 alloc] init];
956    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalEnum));
957    msg.optionalEnum = Message3_Enum_Bar;
958    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalEnum));
959    msg.optionalEnum = Message3_Enum_Foo;
960    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalEnum));
961    [msg release];
962  }
963
964  //
965  // Nil can also be used to clear strings, bytes, and messages (no groups in proto3).
966  //
967
968  {  // optionalString
969    Message3 *msg = [[Message3 alloc] init];
970    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString));
971    msg.optionalString = @"foo";
972    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString));
973    msg.optionalString = nil;
974    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalString));
975    [msg release];
976  }
977
978  {  // optionalBytes
979    Message3 *msg = [[Message3 alloc] init];
980    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes));
981    msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding];
982    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes));
983    msg.optionalBytes = nil;
984    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalBytes));
985    [msg release];
986  }
987
988  {  // optionalMessage
989    Message3 *msg = [[Message3 alloc] init];
990    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalMessage));
991    msg.optionalMessage = [Message3 message];
992    XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalMessage));
993    msg.optionalMessage = nil;
994    XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_OptionalMessage));
995    [msg release];
996  }
997
998//%PDDM-EXPAND-END PROTO3_TEST_HAS_FIELDS()
999}
1000
1001- (void)testAccessingProto2UnknownEnumValues {
1002  Message2 *msg = [[Message2 alloc] init];
1003
1004  // Set it to something non zero, try and confirm it doesn't change.
1005
1006  msg.optionalEnum = Message2_Enum_Bar;
1007  XCTAssertThrowsSpecificNamed(msg.optionalEnum = 666, NSException,
1008                               NSInvalidArgumentException);
1009  XCTAssertEqual(msg.optionalEnum, Message2_Enum_Bar);
1010
1011  msg.oneofEnum = Message2_Enum_Bar;
1012  XCTAssertThrowsSpecificNamed(msg.oneofEnum = 666, NSException,
1013                               NSInvalidArgumentException);
1014  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Bar);
1015
1016  [msg release];
1017}
1018
1019- (void)testAccessingProto3UnknownEnumValues {
1020  Message3 *msg = [[Message3 alloc] init];
1021
1022  // Set it to something non zero, try and confirm it doesn't change.
1023
1024  msg.optionalEnum = Message3_Enum_Bar;
1025  XCTAssertThrowsSpecificNamed(msg.optionalEnum = 666, NSException,
1026                               NSInvalidArgumentException);
1027  XCTAssertEqual(msg.optionalEnum, Message3_Enum_Bar);
1028
1029  msg.oneofEnum = Message3_Enum_Bar;
1030  XCTAssertThrowsSpecificNamed(msg.oneofEnum = 666, NSException,
1031                               NSInvalidArgumentException);
1032  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Bar);
1033
1034  // Set via raw api to confirm it works.
1035
1036  SetMessage3_OptionalEnum_RawValue(msg, 666);
1037  XCTAssertEqual(msg.optionalEnum,
1038                 Message3_Enum_GPBUnrecognizedEnumeratorValue);
1039  XCTAssertEqual(Message3_OptionalEnum_RawValue(msg), 666);
1040
1041  SetMessage3_OneofEnum_RawValue(msg, 666);
1042  XCTAssertEqual(msg.oneofEnum, Message3_Enum_GPBUnrecognizedEnumeratorValue);
1043  XCTAssertEqual(Message3_OneofEnum_RawValue(msg), 666);
1044
1045  [msg release];
1046}
1047
1048- (void)testProto2OneofBasicBehaviors {
1049  Message2 *msg = [[Message2 alloc] init];
1050
1051  NSString *oneofStringDefault = @"string";
1052  NSData *oneofBytesDefault = [@"data" dataUsingEncoding:NSUTF8StringEncoding];
1053
1054  // Nothing set.
1055  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase);
1056  XCTAssertEqual(msg.oneofInt32, 100);
1057  XCTAssertEqual(msg.oneofInt64, 101);
1058  XCTAssertEqual(msg.oneofUint32, 102U);
1059  XCTAssertEqual(msg.oneofUint64, 103U);
1060  XCTAssertEqual(msg.oneofSint32, 104);
1061  XCTAssertEqual(msg.oneofSint64, 105);
1062  XCTAssertEqual(msg.oneofFixed32, 106U);
1063  XCTAssertEqual(msg.oneofFixed64, 107U);
1064  XCTAssertEqual(msg.oneofSfixed32, 108);
1065  XCTAssertEqual(msg.oneofSfixed64, 109);
1066  XCTAssertEqual(msg.oneofFloat, 110.0f);
1067  XCTAssertEqual(msg.oneofDouble, 111.0);
1068  XCTAssertEqual(msg.oneofBool, YES);
1069  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1070  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1071  XCTAssertNotNil(msg.oneofGroup);
1072  XCTAssertNotNil(msg.oneofMessage);
1073  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1074
1075  // Set, check the case, check everyone has default but the one, confirm case
1076  // didn't change.
1077
1078  msg.oneofInt32 = 1;
1079  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt32);
1080  XCTAssertEqual(msg.oneofInt32, 1);
1081  XCTAssertEqual(msg.oneofInt64, 101);
1082  XCTAssertEqual(msg.oneofUint32, 102U);
1083  XCTAssertEqual(msg.oneofUint64, 103U);
1084  XCTAssertEqual(msg.oneofSint32, 104);
1085  XCTAssertEqual(msg.oneofSint64, 105);
1086  XCTAssertEqual(msg.oneofFixed32, 106U);
1087  XCTAssertEqual(msg.oneofFixed64, 107U);
1088  XCTAssertEqual(msg.oneofSfixed32, 108);
1089  XCTAssertEqual(msg.oneofSfixed64, 109);
1090  XCTAssertEqual(msg.oneofFloat, 110.0f);
1091  XCTAssertEqual(msg.oneofDouble, 111.0);
1092  XCTAssertEqual(msg.oneofBool, YES);
1093  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1094  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1095  XCTAssertNotNil(msg.oneofGroup);
1096  XCTAssertNotNil(msg.oneofMessage);
1097  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1098  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt32);
1099
1100  msg.oneofInt64 = 2;
1101  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt64);
1102  XCTAssertEqual(msg.oneofInt32, 100);
1103  XCTAssertEqual(msg.oneofInt64, 2);
1104  XCTAssertEqual(msg.oneofUint32, 102U);
1105  XCTAssertEqual(msg.oneofUint64, 103U);
1106  XCTAssertEqual(msg.oneofSint32, 104);
1107  XCTAssertEqual(msg.oneofSint64, 105);
1108  XCTAssertEqual(msg.oneofFixed32, 106U);
1109  XCTAssertEqual(msg.oneofFixed64, 107U);
1110  XCTAssertEqual(msg.oneofSfixed32, 108);
1111  XCTAssertEqual(msg.oneofSfixed64, 109);
1112  XCTAssertEqual(msg.oneofFloat, 110.0f);
1113  XCTAssertEqual(msg.oneofDouble, 111.0);
1114  XCTAssertEqual(msg.oneofBool, YES);
1115  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1116  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1117  XCTAssertNotNil(msg.oneofGroup);
1118  XCTAssertNotNil(msg.oneofMessage);
1119  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1120  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt64);
1121
1122  msg.oneofUint32 = 3;
1123  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint32);
1124  XCTAssertEqual(msg.oneofInt32, 100);
1125  XCTAssertEqual(msg.oneofInt64, 101);
1126  XCTAssertEqual(msg.oneofUint32, 3U);
1127  XCTAssertEqual(msg.oneofUint64, 103U);
1128  XCTAssertEqual(msg.oneofSint32, 104);
1129  XCTAssertEqual(msg.oneofSint64, 105);
1130  XCTAssertEqual(msg.oneofFixed32, 106U);
1131  XCTAssertEqual(msg.oneofFixed64, 107U);
1132  XCTAssertEqual(msg.oneofSfixed32, 108);
1133  XCTAssertEqual(msg.oneofSfixed64, 109);
1134  XCTAssertEqual(msg.oneofFloat, 110.0f);
1135  XCTAssertEqual(msg.oneofDouble, 111.0);
1136  XCTAssertEqual(msg.oneofBool, YES);
1137  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1138  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1139  XCTAssertNotNil(msg.oneofGroup);
1140  XCTAssertNotNil(msg.oneofMessage);
1141  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1142  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint32);
1143
1144  msg.oneofUint64 = 4;
1145  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint64);
1146  XCTAssertEqual(msg.oneofInt32, 100);
1147  XCTAssertEqual(msg.oneofInt64, 101);
1148  XCTAssertEqual(msg.oneofUint32, 102U);
1149  XCTAssertEqual(msg.oneofUint64, 4U);
1150  XCTAssertEqual(msg.oneofSint32, 104);
1151  XCTAssertEqual(msg.oneofSint64, 105);
1152  XCTAssertEqual(msg.oneofFixed32, 106U);
1153  XCTAssertEqual(msg.oneofFixed64, 107U);
1154  XCTAssertEqual(msg.oneofSfixed32, 108);
1155  XCTAssertEqual(msg.oneofSfixed64, 109);
1156  XCTAssertEqual(msg.oneofFloat, 110.0f);
1157  XCTAssertEqual(msg.oneofDouble, 111.0);
1158  XCTAssertEqual(msg.oneofBool, YES);
1159  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1160  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1161  XCTAssertNotNil(msg.oneofGroup);
1162  XCTAssertNotNil(msg.oneofMessage);
1163  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1164  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint64);
1165
1166  msg.oneofSint32 = 5;
1167  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint32);
1168  XCTAssertEqual(msg.oneofInt32, 100);
1169  XCTAssertEqual(msg.oneofInt64, 101);
1170  XCTAssertEqual(msg.oneofUint32, 102U);
1171  XCTAssertEqual(msg.oneofUint64, 103U);
1172  XCTAssertEqual(msg.oneofSint32, 5);
1173  XCTAssertEqual(msg.oneofSint64, 105);
1174  XCTAssertEqual(msg.oneofFixed32, 106U);
1175  XCTAssertEqual(msg.oneofFixed64, 107U);
1176  XCTAssertEqual(msg.oneofSfixed32, 108);
1177  XCTAssertEqual(msg.oneofSfixed64, 109);
1178  XCTAssertEqual(msg.oneofFloat, 110.0f);
1179  XCTAssertEqual(msg.oneofDouble, 111.0);
1180  XCTAssertEqual(msg.oneofBool, YES);
1181  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1182  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1183  XCTAssertNotNil(msg.oneofGroup);
1184  XCTAssertNotNil(msg.oneofMessage);
1185  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1186  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint32);
1187
1188  msg.oneofSint64 = 6;
1189  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint64);
1190  XCTAssertEqual(msg.oneofInt32, 100);
1191  XCTAssertEqual(msg.oneofInt64, 101);
1192  XCTAssertEqual(msg.oneofUint32, 102U);
1193  XCTAssertEqual(msg.oneofUint64, 103U);
1194  XCTAssertEqual(msg.oneofSint32, 104);
1195  XCTAssertEqual(msg.oneofSint64, 6);
1196  XCTAssertEqual(msg.oneofFixed32, 106U);
1197  XCTAssertEqual(msg.oneofFixed64, 107U);
1198  XCTAssertEqual(msg.oneofSfixed32, 108);
1199  XCTAssertEqual(msg.oneofSfixed64, 109);
1200  XCTAssertEqual(msg.oneofFloat, 110.0f);
1201  XCTAssertEqual(msg.oneofDouble, 111.0);
1202  XCTAssertEqual(msg.oneofBool, YES);
1203  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1204  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1205  XCTAssertNotNil(msg.oneofGroup);
1206  XCTAssertNotNil(msg.oneofMessage);
1207  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1208  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint64);
1209
1210  msg.oneofFixed32 = 7;
1211  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed32);
1212  XCTAssertEqual(msg.oneofInt32, 100);
1213  XCTAssertEqual(msg.oneofInt64, 101);
1214  XCTAssertEqual(msg.oneofUint32, 102U);
1215  XCTAssertEqual(msg.oneofUint64, 103U);
1216  XCTAssertEqual(msg.oneofSint32, 104);
1217  XCTAssertEqual(msg.oneofSint64, 105);
1218  XCTAssertEqual(msg.oneofFixed32, 7U);
1219  XCTAssertEqual(msg.oneofFixed64, 107U);
1220  XCTAssertEqual(msg.oneofSfixed32, 108);
1221  XCTAssertEqual(msg.oneofSfixed64, 109);
1222  XCTAssertEqual(msg.oneofFloat, 110.0f);
1223  XCTAssertEqual(msg.oneofDouble, 111.0);
1224  XCTAssertEqual(msg.oneofBool, YES);
1225  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1226  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1227  XCTAssertNotNil(msg.oneofGroup);
1228  XCTAssertNotNil(msg.oneofMessage);
1229  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1230  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed32);
1231
1232  msg.oneofFixed64 = 8;
1233  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed64);
1234  XCTAssertEqual(msg.oneofInt32, 100);
1235  XCTAssertEqual(msg.oneofInt64, 101);
1236  XCTAssertEqual(msg.oneofUint32, 102U);
1237  XCTAssertEqual(msg.oneofUint64, 103U);
1238  XCTAssertEqual(msg.oneofSint32, 104);
1239  XCTAssertEqual(msg.oneofSint64, 105);
1240  XCTAssertEqual(msg.oneofFixed32, 106U);
1241  XCTAssertEqual(msg.oneofFixed64, 8U);
1242  XCTAssertEqual(msg.oneofSfixed32, 108);
1243  XCTAssertEqual(msg.oneofSfixed64, 109);
1244  XCTAssertEqual(msg.oneofFloat, 110.0f);
1245  XCTAssertEqual(msg.oneofDouble, 111.0);
1246  XCTAssertEqual(msg.oneofBool, YES);
1247  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1248  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1249  XCTAssertNotNil(msg.oneofGroup);
1250  XCTAssertNotNil(msg.oneofMessage);
1251  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1252  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed64);
1253
1254  msg.oneofSfixed32 = 9;
1255  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed32);
1256  XCTAssertEqual(msg.oneofInt32, 100);
1257  XCTAssertEqual(msg.oneofInt64, 101);
1258  XCTAssertEqual(msg.oneofUint32, 102U);
1259  XCTAssertEqual(msg.oneofUint64, 103U);
1260  XCTAssertEqual(msg.oneofSint32, 104);
1261  XCTAssertEqual(msg.oneofSint64, 105);
1262  XCTAssertEqual(msg.oneofFixed32, 106U);
1263  XCTAssertEqual(msg.oneofFixed64, 107U);
1264  XCTAssertEqual(msg.oneofSfixed32, 9);
1265  XCTAssertEqual(msg.oneofSfixed64, 109);
1266  XCTAssertEqual(msg.oneofFloat, 110.0f);
1267  XCTAssertEqual(msg.oneofDouble, 111.0);
1268  XCTAssertEqual(msg.oneofBool, YES);
1269  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1270  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1271  XCTAssertNotNil(msg.oneofGroup);
1272  XCTAssertNotNil(msg.oneofMessage);
1273  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1274  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed32);
1275
1276  msg.oneofSfixed64 = 10;
1277  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed64);
1278  XCTAssertEqual(msg.oneofInt32, 100);
1279  XCTAssertEqual(msg.oneofInt64, 101);
1280  XCTAssertEqual(msg.oneofUint32, 102U);
1281  XCTAssertEqual(msg.oneofUint64, 103U);
1282  XCTAssertEqual(msg.oneofSint32, 104);
1283  XCTAssertEqual(msg.oneofSint64, 105);
1284  XCTAssertEqual(msg.oneofFixed32, 106U);
1285  XCTAssertEqual(msg.oneofFixed64, 107U);
1286  XCTAssertEqual(msg.oneofSfixed32, 108);
1287  XCTAssertEqual(msg.oneofSfixed64, 10);
1288  XCTAssertEqual(msg.oneofFloat, 110.0f);
1289  XCTAssertEqual(msg.oneofDouble, 111.0);
1290  XCTAssertEqual(msg.oneofBool, YES);
1291  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1292  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1293  XCTAssertNotNil(msg.oneofGroup);
1294  XCTAssertNotNil(msg.oneofMessage);
1295  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1296  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed64);
1297
1298  msg.oneofFloat = 11.0f;
1299  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFloat);
1300  XCTAssertEqual(msg.oneofInt32, 100);
1301  XCTAssertEqual(msg.oneofInt64, 101);
1302  XCTAssertEqual(msg.oneofUint32, 102U);
1303  XCTAssertEqual(msg.oneofUint64, 103U);
1304  XCTAssertEqual(msg.oneofSint32, 104);
1305  XCTAssertEqual(msg.oneofSint64, 105);
1306  XCTAssertEqual(msg.oneofFixed32, 106U);
1307  XCTAssertEqual(msg.oneofFixed64, 107U);
1308  XCTAssertEqual(msg.oneofSfixed32, 108);
1309  XCTAssertEqual(msg.oneofSfixed64, 109);
1310  XCTAssertEqual(msg.oneofFloat, 11.0f);
1311  XCTAssertEqual(msg.oneofDouble, 111.0);
1312  XCTAssertEqual(msg.oneofBool, YES);
1313  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1314  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1315  XCTAssertNotNil(msg.oneofGroup);
1316  XCTAssertNotNil(msg.oneofMessage);
1317  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1318  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFloat);
1319
1320  msg.oneofDouble = 12.0;
1321  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofDouble);
1322  XCTAssertEqual(msg.oneofInt32, 100);
1323  XCTAssertEqual(msg.oneofInt64, 101);
1324  XCTAssertEqual(msg.oneofUint32, 102U);
1325  XCTAssertEqual(msg.oneofUint64, 103U);
1326  XCTAssertEqual(msg.oneofSint32, 104);
1327  XCTAssertEqual(msg.oneofSint64, 105);
1328  XCTAssertEqual(msg.oneofFixed32, 106U);
1329  XCTAssertEqual(msg.oneofFixed64, 107U);
1330  XCTAssertEqual(msg.oneofSfixed32, 108);
1331  XCTAssertEqual(msg.oneofSfixed64, 109);
1332  XCTAssertEqual(msg.oneofFloat, 110.0f);
1333  XCTAssertEqual(msg.oneofDouble, 12.0);
1334  XCTAssertEqual(msg.oneofBool, YES);
1335  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1336  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1337  XCTAssertNotNil(msg.oneofGroup);
1338  XCTAssertNotNil(msg.oneofMessage);
1339  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1340  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofDouble);
1341
1342  msg.oneofBool = NO;
1343  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBool);
1344  XCTAssertEqual(msg.oneofInt32, 100);
1345  XCTAssertEqual(msg.oneofInt64, 101);
1346  XCTAssertEqual(msg.oneofUint32, 102U);
1347  XCTAssertEqual(msg.oneofUint64, 103U);
1348  XCTAssertEqual(msg.oneofSint32, 104);
1349  XCTAssertEqual(msg.oneofSint64, 105);
1350  XCTAssertEqual(msg.oneofFixed32, 106U);
1351  XCTAssertEqual(msg.oneofFixed64, 107U);
1352  XCTAssertEqual(msg.oneofSfixed32, 108);
1353  XCTAssertEqual(msg.oneofSfixed64, 109);
1354  XCTAssertEqual(msg.oneofFloat, 110.0f);
1355  XCTAssertEqual(msg.oneofDouble, 111.0);
1356  XCTAssertEqual(msg.oneofBool, NO);
1357  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1358  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1359  XCTAssertNotNil(msg.oneofGroup);
1360  XCTAssertNotNil(msg.oneofMessage);
1361  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1362  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBool);
1363
1364  msg.oneofString = @"foo";
1365  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofString);
1366  XCTAssertEqual(msg.oneofInt32, 100);
1367  XCTAssertEqual(msg.oneofInt64, 101);
1368  XCTAssertEqual(msg.oneofUint32, 102U);
1369  XCTAssertEqual(msg.oneofUint64, 103U);
1370  XCTAssertEqual(msg.oneofSint32, 104);
1371  XCTAssertEqual(msg.oneofSint64, 105);
1372  XCTAssertEqual(msg.oneofFixed32, 106U);
1373  XCTAssertEqual(msg.oneofFixed64, 107U);
1374  XCTAssertEqual(msg.oneofSfixed32, 108);
1375  XCTAssertEqual(msg.oneofSfixed64, 109);
1376  XCTAssertEqual(msg.oneofFloat, 110.0f);
1377  XCTAssertEqual(msg.oneofDouble, 111.0);
1378  XCTAssertEqual(msg.oneofBool, YES);
1379  XCTAssertEqualObjects(msg.oneofString, @"foo");
1380  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1381  XCTAssertNotNil(msg.oneofGroup);
1382  XCTAssertNotNil(msg.oneofMessage);
1383  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1384  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofString);
1385
1386  msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding];
1387  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBytes);
1388  XCTAssertEqual(msg.oneofInt32, 100);
1389  XCTAssertEqual(msg.oneofInt64, 101);
1390  XCTAssertEqual(msg.oneofUint32, 102U);
1391  XCTAssertEqual(msg.oneofUint64, 103U);
1392  XCTAssertEqual(msg.oneofSint32, 104);
1393  XCTAssertEqual(msg.oneofSint64, 105);
1394  XCTAssertEqual(msg.oneofFixed32, 106U);
1395  XCTAssertEqual(msg.oneofFixed64, 107U);
1396  XCTAssertEqual(msg.oneofSfixed32, 108);
1397  XCTAssertEqual(msg.oneofSfixed64, 109);
1398  XCTAssertEqual(msg.oneofFloat, 110.0f);
1399  XCTAssertEqual(msg.oneofDouble, 111.0);
1400  XCTAssertEqual(msg.oneofBool, YES);
1401  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1402  XCTAssertEqualObjects(msg.oneofBytes,
1403                        [@"bar" dataUsingEncoding:NSUTF8StringEncoding]);
1404  XCTAssertNotNil(msg.oneofGroup);
1405  XCTAssertNotNil(msg.oneofMessage);
1406  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1407  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBytes);
1408
1409  Message2_OneofGroup *group = [Message2_OneofGroup message];
1410  msg.oneofGroup = group;
1411  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofGroup);
1412  XCTAssertEqual(msg.oneofInt32, 100);
1413  XCTAssertEqual(msg.oneofInt64, 101);
1414  XCTAssertEqual(msg.oneofUint32, 102U);
1415  XCTAssertEqual(msg.oneofUint64, 103U);
1416  XCTAssertEqual(msg.oneofSint32, 104);
1417  XCTAssertEqual(msg.oneofSint64, 105);
1418  XCTAssertEqual(msg.oneofFixed32, 106U);
1419  XCTAssertEqual(msg.oneofFixed64, 107U);
1420  XCTAssertEqual(msg.oneofSfixed32, 108);
1421  XCTAssertEqual(msg.oneofSfixed64, 109);
1422  XCTAssertEqual(msg.oneofFloat, 110.0f);
1423  XCTAssertEqual(msg.oneofDouble, 111.0);
1424  XCTAssertEqual(msg.oneofBool, YES);
1425  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1426  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1427  XCTAssertEqual(msg.oneofGroup, group);  // Pointer compare.
1428  XCTAssertNotNil(msg.oneofMessage);
1429  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1430  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofGroup);
1431
1432  Message2 *subMessage = [Message2 message];
1433  msg.oneofMessage = subMessage;
1434  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofMessage);
1435  XCTAssertEqual(msg.oneofInt32, 100);
1436  XCTAssertEqual(msg.oneofInt64, 101);
1437  XCTAssertEqual(msg.oneofUint32, 102U);
1438  XCTAssertEqual(msg.oneofUint64, 103U);
1439  XCTAssertEqual(msg.oneofSint32, 104);
1440  XCTAssertEqual(msg.oneofSint64, 105);
1441  XCTAssertEqual(msg.oneofFixed32, 106U);
1442  XCTAssertEqual(msg.oneofFixed64, 107U);
1443  XCTAssertEqual(msg.oneofSfixed32, 108);
1444  XCTAssertEqual(msg.oneofSfixed64, 109);
1445  XCTAssertEqual(msg.oneofFloat, 110.0f);
1446  XCTAssertEqual(msg.oneofDouble, 111.0);
1447  XCTAssertEqual(msg.oneofBool, YES);
1448  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1449  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1450  XCTAssertNotNil(msg.oneofGroup);
1451  XCTAssertNotEqual(msg.oneofGroup, group);      // Pointer compare.
1452  XCTAssertEqual(msg.oneofMessage, subMessage);  // Pointer compare.
1453  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1454  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofMessage);
1455
1456  msg.oneofEnum = Message2_Enum_Bar;
1457  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofEnum);
1458  XCTAssertEqual(msg.oneofInt32, 100);
1459  XCTAssertEqual(msg.oneofInt64, 101);
1460  XCTAssertEqual(msg.oneofUint32, 102U);
1461  XCTAssertEqual(msg.oneofUint64, 103U);
1462  XCTAssertEqual(msg.oneofSint32, 104);
1463  XCTAssertEqual(msg.oneofSint64, 105);
1464  XCTAssertEqual(msg.oneofFixed32, 106U);
1465  XCTAssertEqual(msg.oneofFixed64, 107U);
1466  XCTAssertEqual(msg.oneofSfixed32, 108);
1467  XCTAssertEqual(msg.oneofSfixed64, 109);
1468  XCTAssertEqual(msg.oneofFloat, 110.0f);
1469  XCTAssertEqual(msg.oneofDouble, 111.0);
1470  XCTAssertEqual(msg.oneofBool, YES);
1471  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1472  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1473  XCTAssertNotNil(msg.oneofGroup);
1474  XCTAssertNotEqual(msg.oneofGroup, group);  // Pointer compare.
1475  XCTAssertNotNil(msg.oneofMessage);
1476  XCTAssertNotEqual(msg.oneofMessage, subMessage);  // Pointer compare.
1477  XCTAssertEqual(msg.oneofEnum, Message2_Enum_Bar);
1478  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofEnum);
1479
1480  // Test setting/calling clear clearing.
1481
1482  [msg release];
1483  msg = [[Message2 alloc] init];
1484
1485  int32_t values[] = {
1486    Message2_O_OneOfCase_OneofInt32,
1487    Message2_O_OneOfCase_OneofInt64,
1488    Message2_O_OneOfCase_OneofUint32,
1489    Message2_O_OneOfCase_OneofUint64,
1490    Message2_O_OneOfCase_OneofSint32,
1491    Message2_O_OneOfCase_OneofSint64,
1492    Message2_O_OneOfCase_OneofFixed32,
1493    Message2_O_OneOfCase_OneofFixed64,
1494    Message2_O_OneOfCase_OneofSfixed32,
1495    Message2_O_OneOfCase_OneofSfixed64,
1496    Message2_O_OneOfCase_OneofFloat,
1497    Message2_O_OneOfCase_OneofDouble,
1498    Message2_O_OneOfCase_OneofBool,
1499    Message2_O_OneOfCase_OneofString,
1500    Message2_O_OneOfCase_OneofBytes,
1501    Message2_O_OneOfCase_OneofGroup,
1502    Message2_O_OneOfCase_OneofMessage,
1503    Message2_O_OneOfCase_OneofEnum,
1504  };
1505
1506  for (size_t i = 0; i < GPBARRAYSIZE(values); ++i) {
1507    switch (values[i]) {
1508      case Message2_O_OneOfCase_OneofInt32:
1509        msg.oneofInt32 = 1;
1510        break;
1511      case Message2_O_OneOfCase_OneofInt64:
1512        msg.oneofInt64 = 2;
1513        break;
1514      case Message2_O_OneOfCase_OneofUint32:
1515        msg.oneofUint32 = 3;
1516        break;
1517      case Message2_O_OneOfCase_OneofUint64:
1518        msg.oneofUint64 = 4;
1519        break;
1520      case Message2_O_OneOfCase_OneofSint32:
1521        msg.oneofSint32 = 5;
1522        break;
1523      case Message2_O_OneOfCase_OneofSint64:
1524        msg.oneofSint64 = 6;
1525        break;
1526      case Message2_O_OneOfCase_OneofFixed32:
1527        msg.oneofFixed32 = 7;
1528        break;
1529      case Message2_O_OneOfCase_OneofFixed64:
1530        msg.oneofFixed64 = 8;
1531        break;
1532      case Message2_O_OneOfCase_OneofSfixed32:
1533        msg.oneofSfixed32 = 9;
1534        break;
1535      case Message2_O_OneOfCase_OneofSfixed64:
1536        msg.oneofSfixed64 = 10;
1537        break;
1538      case Message2_O_OneOfCase_OneofFloat:
1539        msg.oneofFloat = 11.0f;
1540        break;
1541      case Message2_O_OneOfCase_OneofDouble:
1542        msg.oneofDouble = 12.0;
1543        break;
1544      case Message2_O_OneOfCase_OneofBool:
1545        msg.oneofBool = YES;
1546        break;
1547      case Message2_O_OneOfCase_OneofString:
1548        msg.oneofString = @"foo";
1549        break;
1550      case Message2_O_OneOfCase_OneofBytes:
1551        msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding];
1552        break;
1553      case Message2_O_OneOfCase_OneofGroup:
1554        msg.oneofGroup = group;
1555        break;
1556      case Message2_O_OneOfCase_OneofMessage:
1557        msg.oneofMessage = subMessage;
1558        break;
1559      case Message2_O_OneOfCase_OneofEnum:
1560        msg.oneofEnum = Message2_Enum_Bar;
1561        break;
1562      default:
1563        XCTFail(@"shouldn't happen, loop: %zd, value: %d", i, values[i]);
1564        break;
1565    }
1566
1567    XCTAssertEqual(msg.oOneOfCase, values[i], "Loop: %zd", i);
1568    // No need to check the value was set, the above tests did that.
1569    Message2_ClearOOneOfCase(msg);
1570    // Nothing in the case.
1571    XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase,
1572                   "Loop: %zd", i);
1573    // Confirm everything is back to defaults after a clear.
1574    XCTAssertEqual(msg.oneofInt32, 100, "Loop: %zd", i);
1575    XCTAssertEqual(msg.oneofInt64, 101, "Loop: %zd", i);
1576    XCTAssertEqual(msg.oneofUint32, 102U, "Loop: %zd", i);
1577    XCTAssertEqual(msg.oneofUint64, 103U, "Loop: %zd", i);
1578    XCTAssertEqual(msg.oneofSint32, 104, "Loop: %zd", i);
1579    XCTAssertEqual(msg.oneofSint64, 105, "Loop: %zd", i);
1580    XCTAssertEqual(msg.oneofFixed32, 106U, "Loop: %zd", i);
1581    XCTAssertEqual(msg.oneofFixed64, 107U, "Loop: %zd", i);
1582    XCTAssertEqual(msg.oneofSfixed32, 108, "Loop: %zd", i);
1583    XCTAssertEqual(msg.oneofSfixed64, 109, "Loop: %zd", i);
1584    XCTAssertEqual(msg.oneofFloat, 110.0f, "Loop: %zd", i);
1585    XCTAssertEqual(msg.oneofDouble, 111.0, "Loop: %zd", i);
1586    XCTAssertEqual(msg.oneofBool, YES, "Loop: %zd", i);
1587    XCTAssertEqualObjects(msg.oneofString, oneofStringDefault, "Loop: %zd", i);
1588    XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault, "Loop: %zd", i);
1589    XCTAssertNotNil(msg.oneofGroup, "Loop: %zd", i);
1590    XCTAssertNotEqual(msg.oneofGroup, group, "Loop: %zd",
1591                      i);  // Pointer compare.
1592    XCTAssertNotNil(msg.oneofMessage, "Loop: %zd", i);
1593    XCTAssertNotEqual(msg.oneofMessage, subMessage, "Loop: %zd",
1594                      i);  // Pointer compare.
1595    XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz, "Loop: %zd", i);
1596  }
1597
1598  [msg release];
1599}
1600
1601- (void)testProto3OneofBasicBehaviors {
1602  Message3 *msg = [[Message3 alloc] init];
1603
1604  NSString *oneofStringDefault = @"";
1605  NSData *oneofBytesDefault = [NSData data];
1606
1607  // Nothing set.
1608  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase);
1609  XCTAssertEqual(msg.oneofInt32, 0);
1610  XCTAssertEqual(msg.oneofInt64, 0);
1611  XCTAssertEqual(msg.oneofUint32, 0U);
1612  XCTAssertEqual(msg.oneofUint64, 0U);
1613  XCTAssertEqual(msg.oneofSint32, 0);
1614  XCTAssertEqual(msg.oneofSint64, 0);
1615  XCTAssertEqual(msg.oneofFixed32, 0U);
1616  XCTAssertEqual(msg.oneofFixed64, 0U);
1617  XCTAssertEqual(msg.oneofSfixed32, 0);
1618  XCTAssertEqual(msg.oneofSfixed64, 0);
1619  XCTAssertEqual(msg.oneofFloat, 0.0f);
1620  XCTAssertEqual(msg.oneofDouble, 0.0);
1621  XCTAssertEqual(msg.oneofBool, NO);
1622  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1623  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1624  XCTAssertNotNil(msg.oneofMessage);
1625  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1626
1627  // Set, check the case, check everyone has default but the one, confirm case
1628  // didn't change.
1629
1630  msg.oneofInt32 = 1;
1631  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt32);
1632  XCTAssertEqual(msg.oneofInt32, 1);
1633  XCTAssertEqual(msg.oneofInt64, 0);
1634  XCTAssertEqual(msg.oneofUint32, 0U);
1635  XCTAssertEqual(msg.oneofUint64, 0U);
1636  XCTAssertEqual(msg.oneofSint32, 0);
1637  XCTAssertEqual(msg.oneofSint64, 0);
1638  XCTAssertEqual(msg.oneofFixed32, 0U);
1639  XCTAssertEqual(msg.oneofFixed64, 0U);
1640  XCTAssertEqual(msg.oneofSfixed32, 0);
1641  XCTAssertEqual(msg.oneofSfixed64, 0);
1642  XCTAssertEqual(msg.oneofFloat, 0.0f);
1643  XCTAssertEqual(msg.oneofDouble, 0.0);
1644  XCTAssertEqual(msg.oneofBool, NO);
1645  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1646  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1647  XCTAssertNotNil(msg.oneofMessage);
1648  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1649  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt32);
1650
1651  msg.oneofInt64 = 2;
1652  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt64);
1653  XCTAssertEqual(msg.oneofInt32, 0);
1654  XCTAssertEqual(msg.oneofInt64, 2);
1655  XCTAssertEqual(msg.oneofUint32, 0U);
1656  XCTAssertEqual(msg.oneofUint64, 0U);
1657  XCTAssertEqual(msg.oneofSint32, 0);
1658  XCTAssertEqual(msg.oneofSint64, 0);
1659  XCTAssertEqual(msg.oneofFixed32, 0U);
1660  XCTAssertEqual(msg.oneofFixed64, 0U);
1661  XCTAssertEqual(msg.oneofSfixed32, 0);
1662  XCTAssertEqual(msg.oneofSfixed64, 0);
1663  XCTAssertEqual(msg.oneofFloat, 0.0f);
1664  XCTAssertEqual(msg.oneofDouble, 0.0);
1665  XCTAssertEqual(msg.oneofBool, NO);
1666  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1667  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1668  XCTAssertNotNil(msg.oneofMessage);
1669  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1670  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt64);
1671
1672  msg.oneofUint32 = 3;
1673  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint32);
1674  XCTAssertEqual(msg.oneofInt32, 0);
1675  XCTAssertEqual(msg.oneofInt64, 0);
1676  XCTAssertEqual(msg.oneofUint32, 3U);
1677  XCTAssertEqual(msg.oneofUint64, 0U);
1678  XCTAssertEqual(msg.oneofSint32, 0);
1679  XCTAssertEqual(msg.oneofSint64, 0);
1680  XCTAssertEqual(msg.oneofFixed32, 0U);
1681  XCTAssertEqual(msg.oneofFixed64, 0U);
1682  XCTAssertEqual(msg.oneofSfixed32, 0);
1683  XCTAssertEqual(msg.oneofSfixed64, 0);
1684  XCTAssertEqual(msg.oneofFloat, 0.0f);
1685  XCTAssertEqual(msg.oneofDouble, 0.0);
1686  XCTAssertEqual(msg.oneofBool, NO);
1687  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1688  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1689  XCTAssertNotNil(msg.oneofMessage);
1690  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1691  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint32);
1692
1693  msg.oneofUint64 = 4;
1694  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint64);
1695  XCTAssertEqual(msg.oneofInt32, 0);
1696  XCTAssertEqual(msg.oneofInt64, 0);
1697  XCTAssertEqual(msg.oneofUint32, 0U);
1698  XCTAssertEqual(msg.oneofUint64, 4U);
1699  XCTAssertEqual(msg.oneofSint32, 0);
1700  XCTAssertEqual(msg.oneofSint64, 0);
1701  XCTAssertEqual(msg.oneofFixed32, 0U);
1702  XCTAssertEqual(msg.oneofFixed64, 0U);
1703  XCTAssertEqual(msg.oneofSfixed32, 0);
1704  XCTAssertEqual(msg.oneofSfixed64, 0);
1705  XCTAssertEqual(msg.oneofFloat, 0.0f);
1706  XCTAssertEqual(msg.oneofDouble, 0.0);
1707  XCTAssertEqual(msg.oneofBool, NO);
1708  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1709  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1710  XCTAssertNotNil(msg.oneofMessage);
1711  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1712  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint64);
1713
1714  msg.oneofSint32 = 5;
1715  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint32);
1716  XCTAssertEqual(msg.oneofInt32, 0);
1717  XCTAssertEqual(msg.oneofInt64, 0);
1718  XCTAssertEqual(msg.oneofUint32, 0U);
1719  XCTAssertEqual(msg.oneofUint64, 0U);
1720  XCTAssertEqual(msg.oneofSint32, 5);
1721  XCTAssertEqual(msg.oneofSint64, 0);
1722  XCTAssertEqual(msg.oneofFixed32, 0U);
1723  XCTAssertEqual(msg.oneofFixed64, 0U);
1724  XCTAssertEqual(msg.oneofSfixed32, 0);
1725  XCTAssertEqual(msg.oneofSfixed64, 0);
1726  XCTAssertEqual(msg.oneofFloat, 0.0f);
1727  XCTAssertEqual(msg.oneofDouble, 0.0);
1728  XCTAssertEqual(msg.oneofBool, NO);
1729  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1730  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1731  XCTAssertNotNil(msg.oneofMessage);
1732  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1733  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint32);
1734
1735  msg.oneofSint64 = 6;
1736  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint64);
1737  XCTAssertEqual(msg.oneofInt32, 0);
1738  XCTAssertEqual(msg.oneofInt64, 0);
1739  XCTAssertEqual(msg.oneofUint32, 0U);
1740  XCTAssertEqual(msg.oneofUint64, 0U);
1741  XCTAssertEqual(msg.oneofSint32, 0);
1742  XCTAssertEqual(msg.oneofSint64, 6);
1743  XCTAssertEqual(msg.oneofFixed32, 0U);
1744  XCTAssertEqual(msg.oneofFixed64, 0U);
1745  XCTAssertEqual(msg.oneofSfixed32, 0);
1746  XCTAssertEqual(msg.oneofSfixed64, 0);
1747  XCTAssertEqual(msg.oneofFloat, 0.0f);
1748  XCTAssertEqual(msg.oneofDouble, 0.0);
1749  XCTAssertEqual(msg.oneofBool, NO);
1750  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1751  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1752  XCTAssertNotNil(msg.oneofMessage);
1753  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1754  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint64);
1755
1756  msg.oneofFixed32 = 7;
1757  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed32);
1758  XCTAssertEqual(msg.oneofInt32, 0);
1759  XCTAssertEqual(msg.oneofInt64, 0);
1760  XCTAssertEqual(msg.oneofUint32, 0U);
1761  XCTAssertEqual(msg.oneofUint64, 0U);
1762  XCTAssertEqual(msg.oneofSint32, 0);
1763  XCTAssertEqual(msg.oneofSint64, 0);
1764  XCTAssertEqual(msg.oneofFixed32, 7U);
1765  XCTAssertEqual(msg.oneofFixed64, 0U);
1766  XCTAssertEqual(msg.oneofSfixed32, 0);
1767  XCTAssertEqual(msg.oneofSfixed64, 0);
1768  XCTAssertEqual(msg.oneofFloat, 0.0f);
1769  XCTAssertEqual(msg.oneofDouble, 0.0);
1770  XCTAssertEqual(msg.oneofBool, NO);
1771  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1772  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1773  XCTAssertNotNil(msg.oneofMessage);
1774  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1775  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed32);
1776
1777  msg.oneofFixed64 = 8;
1778  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed64);
1779  XCTAssertEqual(msg.oneofInt32, 0);
1780  XCTAssertEqual(msg.oneofInt64, 0);
1781  XCTAssertEqual(msg.oneofUint32, 0U);
1782  XCTAssertEqual(msg.oneofUint64, 0U);
1783  XCTAssertEqual(msg.oneofSint32, 0);
1784  XCTAssertEqual(msg.oneofSint64, 0);
1785  XCTAssertEqual(msg.oneofFixed32, 0U);
1786  XCTAssertEqual(msg.oneofFixed64, 8U);
1787  XCTAssertEqual(msg.oneofSfixed32, 0);
1788  XCTAssertEqual(msg.oneofSfixed64, 0);
1789  XCTAssertEqual(msg.oneofFloat, 0.0f);
1790  XCTAssertEqual(msg.oneofDouble, 0.0);
1791  XCTAssertEqual(msg.oneofBool, NO);
1792  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1793  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1794  XCTAssertNotNil(msg.oneofMessage);
1795  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1796  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed64);
1797
1798  msg.oneofSfixed32 = 9;
1799  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed32);
1800  XCTAssertEqual(msg.oneofInt32, 0);
1801  XCTAssertEqual(msg.oneofInt64, 0);
1802  XCTAssertEqual(msg.oneofUint32, 0U);
1803  XCTAssertEqual(msg.oneofUint64, 0U);
1804  XCTAssertEqual(msg.oneofSint32, 0);
1805  XCTAssertEqual(msg.oneofSint64, 0);
1806  XCTAssertEqual(msg.oneofFixed32, 0U);
1807  XCTAssertEqual(msg.oneofFixed64, 0U);
1808  XCTAssertEqual(msg.oneofSfixed32, 9);
1809  XCTAssertEqual(msg.oneofSfixed64, 0);
1810  XCTAssertEqual(msg.oneofFloat, 0.0f);
1811  XCTAssertEqual(msg.oneofDouble, 0.0);
1812  XCTAssertEqual(msg.oneofBool, NO);
1813  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1814  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1815  XCTAssertNotNil(msg.oneofMessage);
1816  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1817  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed32);
1818
1819  msg.oneofSfixed64 = 10;
1820  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed64);
1821  XCTAssertEqual(msg.oneofInt32, 0);
1822  XCTAssertEqual(msg.oneofInt64, 0);
1823  XCTAssertEqual(msg.oneofUint32, 0U);
1824  XCTAssertEqual(msg.oneofUint64, 0U);
1825  XCTAssertEqual(msg.oneofSint32, 0);
1826  XCTAssertEqual(msg.oneofSint64, 0);
1827  XCTAssertEqual(msg.oneofFixed32, 0U);
1828  XCTAssertEqual(msg.oneofFixed64, 0U);
1829  XCTAssertEqual(msg.oneofSfixed32, 0);
1830  XCTAssertEqual(msg.oneofSfixed64, 10);
1831  XCTAssertEqual(msg.oneofFloat, 0.0f);
1832  XCTAssertEqual(msg.oneofDouble, 0.0);
1833  XCTAssertEqual(msg.oneofBool, NO);
1834  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1835  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1836  XCTAssertNotNil(msg.oneofMessage);
1837  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1838  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed64);
1839
1840  msg.oneofFloat = 11.0f;
1841  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFloat);
1842  XCTAssertEqual(msg.oneofInt32, 0);
1843  XCTAssertEqual(msg.oneofInt64, 0);
1844  XCTAssertEqual(msg.oneofUint32, 0U);
1845  XCTAssertEqual(msg.oneofUint64, 0U);
1846  XCTAssertEqual(msg.oneofSint32, 0);
1847  XCTAssertEqual(msg.oneofSint64, 0);
1848  XCTAssertEqual(msg.oneofFixed32, 0U);
1849  XCTAssertEqual(msg.oneofFixed64, 0U);
1850  XCTAssertEqual(msg.oneofSfixed32, 0);
1851  XCTAssertEqual(msg.oneofSfixed64, 0);
1852  XCTAssertEqual(msg.oneofFloat, 11.0f);
1853  XCTAssertEqual(msg.oneofDouble, 0.0);
1854  XCTAssertEqual(msg.oneofBool, NO);
1855  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1856  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1857  XCTAssertNotNil(msg.oneofMessage);
1858  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1859  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFloat);
1860
1861  msg.oneofDouble = 12.0;
1862  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofDouble);
1863  XCTAssertEqual(msg.oneofInt32, 0);
1864  XCTAssertEqual(msg.oneofInt64, 0);
1865  XCTAssertEqual(msg.oneofUint32, 0U);
1866  XCTAssertEqual(msg.oneofUint64, 0U);
1867  XCTAssertEqual(msg.oneofSint32, 0);
1868  XCTAssertEqual(msg.oneofSint64, 0);
1869  XCTAssertEqual(msg.oneofFixed32, 0U);
1870  XCTAssertEqual(msg.oneofFixed64, 0U);
1871  XCTAssertEqual(msg.oneofSfixed32, 0);
1872  XCTAssertEqual(msg.oneofSfixed64, 0);
1873  XCTAssertEqual(msg.oneofFloat, 0.0f);
1874  XCTAssertEqual(msg.oneofDouble, 12.0);
1875  XCTAssertEqual(msg.oneofBool, NO);
1876  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1877  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1878  XCTAssertNotNil(msg.oneofMessage);
1879  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1880  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofDouble);
1881
1882  msg.oneofBool = YES;
1883  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBool);
1884  XCTAssertEqual(msg.oneofInt32, 0);
1885  XCTAssertEqual(msg.oneofInt64, 0);
1886  XCTAssertEqual(msg.oneofUint32, 0U);
1887  XCTAssertEqual(msg.oneofUint64, 0U);
1888  XCTAssertEqual(msg.oneofSint32, 0);
1889  XCTAssertEqual(msg.oneofSint64, 0);
1890  XCTAssertEqual(msg.oneofFixed32, 0U);
1891  XCTAssertEqual(msg.oneofFixed64, 0U);
1892  XCTAssertEqual(msg.oneofSfixed32, 0);
1893  XCTAssertEqual(msg.oneofSfixed64, 0);
1894  XCTAssertEqual(msg.oneofFloat, 0.0f);
1895  XCTAssertEqual(msg.oneofDouble, 0.0);
1896  XCTAssertEqual(msg.oneofBool, YES);
1897  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1898  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1899  XCTAssertNotNil(msg.oneofMessage);
1900  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1901  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBool);
1902
1903  msg.oneofString = @"foo";
1904  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofString);
1905  XCTAssertEqual(msg.oneofInt32, 0);
1906  XCTAssertEqual(msg.oneofInt64, 0);
1907  XCTAssertEqual(msg.oneofUint32, 0U);
1908  XCTAssertEqual(msg.oneofUint64, 0U);
1909  XCTAssertEqual(msg.oneofSint32, 0);
1910  XCTAssertEqual(msg.oneofSint64, 0);
1911  XCTAssertEqual(msg.oneofFixed32, 0U);
1912  XCTAssertEqual(msg.oneofFixed64, 0U);
1913  XCTAssertEqual(msg.oneofSfixed32, 0);
1914  XCTAssertEqual(msg.oneofSfixed64, 0);
1915  XCTAssertEqual(msg.oneofFloat, 0.0f);
1916  XCTAssertEqual(msg.oneofDouble, 0.0);
1917  XCTAssertEqual(msg.oneofBool, NO);
1918  XCTAssertEqualObjects(msg.oneofString, @"foo");
1919  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1920  XCTAssertNotNil(msg.oneofMessage);
1921  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1922  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofString);
1923
1924  msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding];
1925  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBytes);
1926  XCTAssertEqual(msg.oneofInt32, 0);
1927  XCTAssertEqual(msg.oneofInt64, 0);
1928  XCTAssertEqual(msg.oneofUint32, 0U);
1929  XCTAssertEqual(msg.oneofUint64, 0U);
1930  XCTAssertEqual(msg.oneofSint32, 0);
1931  XCTAssertEqual(msg.oneofSint64, 0);
1932  XCTAssertEqual(msg.oneofFixed32, 0U);
1933  XCTAssertEqual(msg.oneofFixed64, 0U);
1934  XCTAssertEqual(msg.oneofSfixed32, 0);
1935  XCTAssertEqual(msg.oneofSfixed64, 0);
1936  XCTAssertEqual(msg.oneofFloat, 0.0f);
1937  XCTAssertEqual(msg.oneofDouble, 0.0);
1938  XCTAssertEqual(msg.oneofBool, NO);
1939  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1940  XCTAssertEqualObjects(msg.oneofBytes,
1941                        [@"bar" dataUsingEncoding:NSUTF8StringEncoding]);
1942  XCTAssertNotNil(msg.oneofMessage);
1943  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1944  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBytes);
1945
1946  Message3 *subMessage = [Message3 message];
1947  msg.oneofMessage = subMessage;
1948  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofMessage);
1949  XCTAssertEqual(msg.oneofInt32, 0);
1950  XCTAssertEqual(msg.oneofInt64, 0);
1951  XCTAssertEqual(msg.oneofUint32, 0U);
1952  XCTAssertEqual(msg.oneofUint64, 0U);
1953  XCTAssertEqual(msg.oneofSint32, 0);
1954  XCTAssertEqual(msg.oneofSint64, 0);
1955  XCTAssertEqual(msg.oneofFixed32, 0U);
1956  XCTAssertEqual(msg.oneofFixed64, 0U);
1957  XCTAssertEqual(msg.oneofSfixed32, 0);
1958  XCTAssertEqual(msg.oneofSfixed64, 0);
1959  XCTAssertEqual(msg.oneofFloat, 0.0f);
1960  XCTAssertEqual(msg.oneofDouble, 0.0);
1961  XCTAssertEqual(msg.oneofBool, NO);
1962  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1963  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1964  XCTAssertEqual(msg.oneofMessage, subMessage);  // Pointer compare.
1965  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1966  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofMessage);
1967
1968  msg.oneofEnum = Message3_Enum_Bar;
1969  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofEnum);
1970  XCTAssertEqual(msg.oneofInt32, 0);
1971  XCTAssertEqual(msg.oneofInt64, 0);
1972  XCTAssertEqual(msg.oneofUint32, 0U);
1973  XCTAssertEqual(msg.oneofUint64, 0U);
1974  XCTAssertEqual(msg.oneofSint32, 0);
1975  XCTAssertEqual(msg.oneofSint64, 0);
1976  XCTAssertEqual(msg.oneofFixed32, 0U);
1977  XCTAssertEqual(msg.oneofFixed64, 0U);
1978  XCTAssertEqual(msg.oneofSfixed32, 0);
1979  XCTAssertEqual(msg.oneofSfixed64, 0);
1980  XCTAssertEqual(msg.oneofFloat, 0.0f);
1981  XCTAssertEqual(msg.oneofDouble, 0.0);
1982  XCTAssertEqual(msg.oneofBool, NO);
1983  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1984  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1985  XCTAssertNotNil(msg.oneofMessage);
1986  XCTAssertNotEqual(msg.oneofMessage, subMessage);  // Pointer compare.
1987  XCTAssertEqual(msg.oneofEnum, Message3_Enum_Bar);
1988  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofEnum);
1989
1990  // Test setting/calling clear clearing.
1991
1992  [msg release];
1993  msg = [[Message3 alloc] init];
1994
1995  int32_t values[] = {
1996    Message3_O_OneOfCase_OneofInt32,
1997    Message3_O_OneOfCase_OneofInt64,
1998    Message3_O_OneOfCase_OneofUint32,
1999    Message3_O_OneOfCase_OneofUint64,
2000    Message3_O_OneOfCase_OneofSint32,
2001    Message3_O_OneOfCase_OneofSint64,
2002    Message3_O_OneOfCase_OneofFixed32,
2003    Message3_O_OneOfCase_OneofFixed64,
2004    Message3_O_OneOfCase_OneofSfixed32,
2005    Message3_O_OneOfCase_OneofSfixed64,
2006    Message3_O_OneOfCase_OneofFloat,
2007    Message3_O_OneOfCase_OneofDouble,
2008    Message3_O_OneOfCase_OneofBool,
2009    Message3_O_OneOfCase_OneofString,
2010    Message3_O_OneOfCase_OneofBytes,
2011    Message3_O_OneOfCase_OneofMessage,
2012    Message3_O_OneOfCase_OneofEnum,
2013  };
2014
2015  for (size_t i = 0; i < GPBARRAYSIZE(values); ++i) {
2016    switch (values[i]) {
2017      case Message3_O_OneOfCase_OneofInt32:
2018        msg.oneofInt32 = 1;
2019        break;
2020      case Message3_O_OneOfCase_OneofInt64:
2021        msg.oneofInt64 = 2;
2022        break;
2023      case Message3_O_OneOfCase_OneofUint32:
2024        msg.oneofUint32 = 3;
2025        break;
2026      case Message3_O_OneOfCase_OneofUint64:
2027        msg.oneofUint64 = 4;
2028        break;
2029      case Message3_O_OneOfCase_OneofSint32:
2030        msg.oneofSint32 = 5;
2031        break;
2032      case Message3_O_OneOfCase_OneofSint64:
2033        msg.oneofSint64 = 6;
2034        break;
2035      case Message3_O_OneOfCase_OneofFixed32:
2036        msg.oneofFixed32 = 7;
2037        break;
2038      case Message3_O_OneOfCase_OneofFixed64:
2039        msg.oneofFixed64 = 8;
2040        break;
2041      case Message3_O_OneOfCase_OneofSfixed32:
2042        msg.oneofSfixed32 = 9;
2043        break;
2044      case Message3_O_OneOfCase_OneofSfixed64:
2045        msg.oneofSfixed64 = 10;
2046        break;
2047      case Message3_O_OneOfCase_OneofFloat:
2048        msg.oneofFloat = 11.0f;
2049        break;
2050      case Message3_O_OneOfCase_OneofDouble:
2051        msg.oneofDouble = 12.0;
2052        break;
2053      case Message3_O_OneOfCase_OneofBool:
2054        msg.oneofBool = YES;
2055        break;
2056      case Message3_O_OneOfCase_OneofString:
2057        msg.oneofString = @"foo";
2058        break;
2059      case Message3_O_OneOfCase_OneofBytes:
2060        msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding];
2061        break;
2062      case Message3_O_OneOfCase_OneofMessage:
2063        msg.oneofMessage = subMessage;
2064        break;
2065      case Message3_O_OneOfCase_OneofEnum:
2066        msg.oneofEnum = Message3_Enum_Baz;
2067        break;
2068      default:
2069        XCTFail(@"shouldn't happen, loop: %zd, value: %d", i, values[i]);
2070        break;
2071    }
2072
2073    XCTAssertEqual(msg.oOneOfCase, values[i], "Loop: %zd", i);
2074    // No need to check the value was set, the above tests did that.
2075    Message3_ClearOOneOfCase(msg);
2076    // Nothing in the case.
2077    XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase,
2078                   "Loop: %zd", i);
2079    // Confirm everything is back to defaults after a clear.
2080    XCTAssertEqual(msg.oneofInt32, 0, "Loop: %zd", i);
2081    XCTAssertEqual(msg.oneofInt64, 0, "Loop: %zd", i);
2082    XCTAssertEqual(msg.oneofUint32, 0U, "Loop: %zd", i);
2083    XCTAssertEqual(msg.oneofUint64, 0U, "Loop: %zd", i);
2084    XCTAssertEqual(msg.oneofSint32, 0, "Loop: %zd", i);
2085    XCTAssertEqual(msg.oneofSint64, 0, "Loop: %zd", i);
2086    XCTAssertEqual(msg.oneofFixed32, 0U, "Loop: %zd", i);
2087    XCTAssertEqual(msg.oneofFixed64, 0U, "Loop: %zd", i);
2088    XCTAssertEqual(msg.oneofSfixed32, 0, "Loop: %zd", i);
2089    XCTAssertEqual(msg.oneofSfixed64, 0, "Loop: %zd", i);
2090    XCTAssertEqual(msg.oneofFloat, 0.0f, "Loop: %zd", i);
2091    XCTAssertEqual(msg.oneofDouble, 0.0, "Loop: %zd", i);
2092    XCTAssertEqual(msg.oneofBool, NO, "Loop: %zd", i);
2093    XCTAssertEqualObjects(msg.oneofString, oneofStringDefault, "Loop: %zd", i);
2094    XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault, "Loop: %zd", i);
2095    XCTAssertNotNil(msg.oneofMessage, "Loop: %zd", i);
2096    XCTAssertNotEqual(msg.oneofMessage, subMessage, "Loop: %zd",
2097                      i);  // Pointer compare.
2098    XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo, "Loop: %zd", i);
2099  }
2100
2101  [msg release];
2102}
2103
2104- (void)testProto2OneofSetToDefault {
2105
2106  // proto3 doesn't normally write out zero (default) fields, but if they are
2107  // in a oneof it does.  proto2 doesn't have this special behavior, but we
2108  // still confirm setting to the explicit default does set the case to be
2109  // sure the runtime is working correctly.
2110
2111  NSString *oneofStringDefault = @"string";
2112  NSData *oneofBytesDefault = [@"data" dataUsingEncoding:NSUTF8StringEncoding];
2113
2114  Message2 *msg = [[Message2 alloc] init];
2115
2116  int32_t values[] = {
2117    Message2_O_OneOfCase_OneofInt32,
2118    Message2_O_OneOfCase_OneofInt64,
2119    Message2_O_OneOfCase_OneofUint32,
2120    Message2_O_OneOfCase_OneofUint64,
2121    Message2_O_OneOfCase_OneofSint32,
2122    Message2_O_OneOfCase_OneofSint64,
2123    Message2_O_OneOfCase_OneofFixed32,
2124    Message2_O_OneOfCase_OneofFixed64,
2125    Message2_O_OneOfCase_OneofSfixed32,
2126    Message2_O_OneOfCase_OneofSfixed64,
2127    Message2_O_OneOfCase_OneofFloat,
2128    Message2_O_OneOfCase_OneofDouble,
2129    Message2_O_OneOfCase_OneofBool,
2130    Message2_O_OneOfCase_OneofString,
2131    Message2_O_OneOfCase_OneofBytes,
2132    // Skip group
2133    // Skip message
2134    Message2_O_OneOfCase_OneofEnum,
2135  };
2136
2137  for (size_t i = 0; i < GPBARRAYSIZE(values); ++i) {
2138    switch (values[i]) {
2139      case Message2_O_OneOfCase_OneofInt32:
2140        msg.oneofInt32 = 100;
2141        break;
2142      case Message2_O_OneOfCase_OneofInt64:
2143        msg.oneofInt64 = 101;
2144        break;
2145      case Message2_O_OneOfCase_OneofUint32:
2146        msg.oneofUint32 = 102;
2147        break;
2148      case Message2_O_OneOfCase_OneofUint64:
2149        msg.oneofUint64 = 103;
2150        break;
2151      case Message2_O_OneOfCase_OneofSint32:
2152        msg.oneofSint32 = 104;
2153        break;
2154      case Message2_O_OneOfCase_OneofSint64:
2155        msg.oneofSint64 = 105;
2156        break;
2157      case Message2_O_OneOfCase_OneofFixed32:
2158        msg.oneofFixed32 = 106;
2159        break;
2160      case Message2_O_OneOfCase_OneofFixed64:
2161        msg.oneofFixed64 = 107;
2162        break;
2163      case Message2_O_OneOfCase_OneofSfixed32:
2164        msg.oneofSfixed32 = 108;
2165        break;
2166      case Message2_O_OneOfCase_OneofSfixed64:
2167        msg.oneofSfixed64 = 109;
2168        break;
2169      case Message2_O_OneOfCase_OneofFloat:
2170        msg.oneofFloat = 110.0f;
2171        break;
2172      case Message2_O_OneOfCase_OneofDouble:
2173        msg.oneofDouble = 111.0;
2174        break;
2175      case Message2_O_OneOfCase_OneofBool:
2176        msg.oneofBool = YES;
2177        break;
2178      case Message2_O_OneOfCase_OneofString:
2179        msg.oneofString = oneofStringDefault;
2180        break;
2181      case Message2_O_OneOfCase_OneofBytes:
2182        msg.oneofBytes = oneofBytesDefault;
2183        break;
2184      case Message2_O_OneOfCase_OneofEnum:
2185        msg.oneofEnum = Message3_Enum_Baz;
2186        break;
2187      default:
2188        XCTFail(@"shouldn't happen, loop: %zd, value: %d", i, values[i]);
2189        break;
2190    }
2191
2192    // Should be set to the correct case.
2193    XCTAssertEqual(msg.oOneOfCase, values[i], "Loop: %zd", i);
2194
2195    // Confirm everything is the defaults.
2196    XCTAssertEqual(msg.oneofInt32, 100, "Loop: %zd", i);
2197    XCTAssertEqual(msg.oneofInt64, 101, "Loop: %zd", i);
2198    XCTAssertEqual(msg.oneofUint32, 102U, "Loop: %zd", i);
2199    XCTAssertEqual(msg.oneofUint64, 103U, "Loop: %zd", i);
2200    XCTAssertEqual(msg.oneofSint32, 104, "Loop: %zd", i);
2201    XCTAssertEqual(msg.oneofSint64, 105, "Loop: %zd", i);
2202    XCTAssertEqual(msg.oneofFixed32, 106U, "Loop: %zd", i);
2203    XCTAssertEqual(msg.oneofFixed64, 107U, "Loop: %zd", i);
2204    XCTAssertEqual(msg.oneofSfixed32, 108, "Loop: %zd", i);
2205    XCTAssertEqual(msg.oneofSfixed64, 109, "Loop: %zd", i);
2206    XCTAssertEqual(msg.oneofFloat, 110.0f, "Loop: %zd", i);
2207    XCTAssertEqual(msg.oneofDouble, 111.0, "Loop: %zd", i);
2208    XCTAssertEqual(msg.oneofBool, YES, "Loop: %zd", i);
2209    XCTAssertEqualObjects(msg.oneofString, oneofStringDefault, "Loop: %zd", i);
2210    XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault, "Loop: %zd", i);
2211    // Skip group, no default to consider.
2212    // Skip message, no default to consider.
2213    XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz, "Loop: %zd", i);
2214  }
2215
2216  // We special case nil on string, data, group, and message, ensure they work
2217  // as expected. i.e. - it clears the case.
2218  msg.oneofString = nil;
2219  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
2220  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase);
2221  msg.oneofBytes = nil;
2222  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase);
2223  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
2224  msg.oneofGroup = nil;
2225  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase);
2226  XCTAssertNotNil(msg.oneofGroup);
2227  msg.oneofMessage = nil;
2228  XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase);
2229  XCTAssertNotNil(msg.oneofMessage);
2230
2231  [msg release];
2232}
2233
2234- (void)testProto3OneofSetToZero {
2235
2236  // Normally setting a proto3 field to the zero value should result in it being
2237  // reset/cleared.  But in a oneof, it still gets recored so it can go out
2238  // over the wire and the other side can see what was set in the oneof.
2239
2240  NSString *oneofStringDefault = @"";
2241  NSData *oneofBytesDefault = [NSData data];
2242
2243  Message3 *msg = [[Message3 alloc] init];
2244
2245  int32_t values[] = {
2246    Message3_O_OneOfCase_OneofInt32,
2247    Message3_O_OneOfCase_OneofInt64,
2248    Message3_O_OneOfCase_OneofUint32,
2249    Message3_O_OneOfCase_OneofUint64,
2250    Message3_O_OneOfCase_OneofSint32,
2251    Message3_O_OneOfCase_OneofSint64,
2252    Message3_O_OneOfCase_OneofFixed32,
2253    Message3_O_OneOfCase_OneofFixed64,
2254    Message3_O_OneOfCase_OneofSfixed32,
2255    Message3_O_OneOfCase_OneofSfixed64,
2256    Message3_O_OneOfCase_OneofFloat,
2257    Message3_O_OneOfCase_OneofDouble,
2258    Message3_O_OneOfCase_OneofBool,
2259    Message3_O_OneOfCase_OneofString,
2260    Message3_O_OneOfCase_OneofBytes,
2261    Message3_O_OneOfCase_OneofMessage,
2262    Message3_O_OneOfCase_OneofEnum,
2263  };
2264
2265  for (size_t i = 0; i < GPBARRAYSIZE(values); ++i) {
2266    switch (values[i]) {
2267      case Message3_O_OneOfCase_OneofInt32:
2268        msg.oneofInt32 = 0;
2269        break;
2270      case Message3_O_OneOfCase_OneofInt64:
2271        msg.oneofInt64 = 0;
2272        break;
2273      case Message3_O_OneOfCase_OneofUint32:
2274        msg.oneofUint32 = 0;
2275        break;
2276      case Message3_O_OneOfCase_OneofUint64:
2277        msg.oneofUint64 = 0;
2278        break;
2279      case Message3_O_OneOfCase_OneofSint32:
2280        msg.oneofSint32 = 0;
2281        break;
2282      case Message3_O_OneOfCase_OneofSint64:
2283        msg.oneofSint64 = 0;
2284        break;
2285      case Message3_O_OneOfCase_OneofFixed32:
2286        msg.oneofFixed32 = 0;
2287        break;
2288      case Message3_O_OneOfCase_OneofFixed64:
2289        msg.oneofFixed64 = 0;
2290        break;
2291      case Message3_O_OneOfCase_OneofSfixed32:
2292        msg.oneofSfixed32 = 0;
2293        break;
2294      case Message3_O_OneOfCase_OneofSfixed64:
2295        msg.oneofSfixed64 = 0;
2296        break;
2297      case Message3_O_OneOfCase_OneofFloat:
2298        msg.oneofFloat = 0.0f;
2299        break;
2300      case Message3_O_OneOfCase_OneofDouble:
2301        msg.oneofDouble = 0.0;
2302        break;
2303      case Message3_O_OneOfCase_OneofBool:
2304        msg.oneofBool = NO;
2305        break;
2306      case Message3_O_OneOfCase_OneofString:
2307        msg.oneofString = oneofStringDefault;
2308        break;
2309      case Message3_O_OneOfCase_OneofBytes:
2310        msg.oneofBytes = oneofBytesDefault;
2311        break;
2312      case Message3_O_OneOfCase_OneofMessage:
2313        msg.oneofMessage.optionalInt32 = 0;
2314        break;
2315      case Message3_O_OneOfCase_OneofEnum:
2316        msg.oneofEnum = Message3_Enum_Foo;
2317        break;
2318      default:
2319        XCTFail(@"shouldn't happen, loop: %zd, value: %d", i, values[i]);
2320        break;
2321    }
2322
2323    // Should be set to the correct case.
2324    XCTAssertEqual(msg.oOneOfCase, values[i], "Loop: %zd", i);
2325
2326    // Confirm everything is still zeros.
2327    XCTAssertEqual(msg.oneofInt32, 0, "Loop: %zd", i);
2328    XCTAssertEqual(msg.oneofInt64, 0, "Loop: %zd", i);
2329    XCTAssertEqual(msg.oneofUint32, 0U, "Loop: %zd", i);
2330    XCTAssertEqual(msg.oneofUint64, 0U, "Loop: %zd", i);
2331    XCTAssertEqual(msg.oneofSint32, 0, "Loop: %zd", i);
2332    XCTAssertEqual(msg.oneofSint64, 0, "Loop: %zd", i);
2333    XCTAssertEqual(msg.oneofFixed32, 0U, "Loop: %zd", i);
2334    XCTAssertEqual(msg.oneofFixed64, 0U, "Loop: %zd", i);
2335    XCTAssertEqual(msg.oneofSfixed32, 0, "Loop: %zd", i);
2336    XCTAssertEqual(msg.oneofSfixed64, 0, "Loop: %zd", i);
2337    XCTAssertEqual(msg.oneofFloat, 0.0f, "Loop: %zd", i);
2338    XCTAssertEqual(msg.oneofDouble, 0.0, "Loop: %zd", i);
2339    XCTAssertEqual(msg.oneofBool, NO, "Loop: %zd", i);
2340    XCTAssertEqualObjects(msg.oneofString, oneofStringDefault, "Loop: %zd", i);
2341    XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault, "Loop: %zd", i);
2342    XCTAssertNotNil(msg.oneofMessage, "Loop: %zd", i);
2343    XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo, "Loop: %zd", i);
2344  }
2345
2346  // We special case nil on string, data, message, ensure they work as expected.
2347  msg.oneofString = nil;
2348  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase);
2349  XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
2350  msg.oneofBytes = nil;
2351  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase);
2352  XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
2353  msg.oneofMessage = nil;
2354  XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase);
2355  XCTAssertNotNil(msg.oneofMessage);
2356
2357  [msg release];
2358}
2359
2360- (void)testCopyingMakesUniqueObjects {
2361  const int repeatCount = 5;
2362  TestAllTypes *msg1 = [TestAllTypes message];
2363  [self setAllFields:msg1 repeatedCount:repeatCount];
2364
2365  TestAllTypes *msg2 = [[msg1 copy] autorelease];
2366
2367  XCTAssertNotEqual(msg1, msg2);      // Ptr compare, new object.
2368  XCTAssertEqualObjects(msg1, msg2);  // Equal values.
2369
2370  // Pointer comparisions, different objects.
2371
2372  XCTAssertNotEqual(msg1.optionalGroup, msg2.optionalGroup);
2373  XCTAssertNotEqual(msg1.optionalNestedMessage, msg2.optionalNestedMessage);
2374  XCTAssertNotEqual(msg1.optionalForeignMessage, msg2.optionalForeignMessage);
2375  XCTAssertNotEqual(msg1.optionalImportMessage, msg2.optionalImportMessage);
2376
2377  XCTAssertNotEqual(msg1.repeatedInt32Array, msg2.repeatedInt32Array);
2378  XCTAssertNotEqual(msg1.repeatedInt64Array, msg2.repeatedInt64Array);
2379  XCTAssertNotEqual(msg1.repeatedUint32Array, msg2.repeatedUint32Array);
2380  XCTAssertNotEqual(msg1.repeatedUint64Array, msg2.repeatedUint64Array);
2381  XCTAssertNotEqual(msg1.repeatedSint32Array, msg2.repeatedSint32Array);
2382  XCTAssertNotEqual(msg1.repeatedSint64Array, msg2.repeatedSint64Array);
2383  XCTAssertNotEqual(msg1.repeatedFixed32Array, msg2.repeatedFixed32Array);
2384  XCTAssertNotEqual(msg1.repeatedFixed64Array, msg2.repeatedFixed64Array);
2385  XCTAssertNotEqual(msg1.repeatedSfixed32Array, msg2.repeatedSfixed32Array);
2386  XCTAssertNotEqual(msg1.repeatedSfixed64Array, msg2.repeatedSfixed64Array);
2387  XCTAssertNotEqual(msg1.repeatedFloatArray, msg2.repeatedFloatArray);
2388  XCTAssertNotEqual(msg1.repeatedDoubleArray, msg2.repeatedDoubleArray);
2389  XCTAssertNotEqual(msg1.repeatedBoolArray, msg2.repeatedBoolArray);
2390  XCTAssertNotEqual(msg1.repeatedStringArray, msg2.repeatedStringArray);
2391  XCTAssertNotEqual(msg1.repeatedBytesArray, msg2.repeatedBytesArray);
2392  XCTAssertNotEqual(msg1.repeatedGroupArray, msg2.repeatedGroupArray);
2393  XCTAssertNotEqual(msg1.repeatedNestedMessageArray,
2394                    msg2.repeatedNestedMessageArray);
2395  XCTAssertNotEqual(msg1.repeatedForeignMessageArray,
2396                    msg2.repeatedForeignMessageArray);
2397  XCTAssertNotEqual(msg1.repeatedImportMessageArray,
2398                    msg2.repeatedImportMessageArray);
2399  XCTAssertNotEqual(msg1.repeatedNestedEnumArray, msg2.repeatedNestedEnumArray);
2400  XCTAssertNotEqual(msg1.repeatedForeignEnumArray,
2401                    msg2.repeatedForeignEnumArray);
2402  XCTAssertNotEqual(msg1.repeatedImportEnumArray, msg2.repeatedImportEnumArray);
2403  XCTAssertNotEqual(msg1.repeatedStringPieceArray,
2404                    msg2.repeatedStringPieceArray);
2405  XCTAssertNotEqual(msg1.repeatedCordArray, msg2.repeatedCordArray);
2406
2407  for (int i = 0; i < repeatCount; i++) {
2408    XCTAssertNotEqual(msg1.repeatedNestedMessageArray[i],
2409                      msg2.repeatedNestedMessageArray[i]);
2410    XCTAssertNotEqual(msg1.repeatedForeignMessageArray[i],
2411                      msg2.repeatedForeignMessageArray[i]);
2412    XCTAssertNotEqual(msg1.repeatedImportMessageArray[i],
2413                      msg2.repeatedImportMessageArray[i]);
2414  }
2415}
2416
2417- (void)testCopyingMapsMakesUniqueObjects {
2418  TestMap *msg1 = [TestMap message];
2419  [self setAllMapFields:msg1 numEntries:5];
2420
2421  TestMap *msg2 = [[msg1 copy] autorelease];
2422
2423  XCTAssertNotEqual(msg1, msg2);      // Ptr compare, new object.
2424  XCTAssertEqualObjects(msg1, msg2);  // Equal values.
2425
2426  // Pointer comparisions, different objects.
2427  XCTAssertNotEqual(msg1.mapInt32Int32, msg2.mapInt32Int32);
2428  XCTAssertNotEqual(msg1.mapInt64Int64, msg2.mapInt64Int64);
2429  XCTAssertNotEqual(msg1.mapUint32Uint32, msg2.mapUint32Uint32);
2430  XCTAssertNotEqual(msg1.mapUint64Uint64, msg2.mapUint64Uint64);
2431  XCTAssertNotEqual(msg1.mapSint32Sint32, msg2.mapSint32Sint32);
2432  XCTAssertNotEqual(msg1.mapSint64Sint64, msg2.mapSint64Sint64);
2433  XCTAssertNotEqual(msg1.mapFixed32Fixed32, msg2.mapFixed32Fixed32);
2434  XCTAssertNotEqual(msg1.mapFixed64Fixed64, msg2.mapFixed64Fixed64);
2435  XCTAssertNotEqual(msg1.mapSfixed32Sfixed32, msg2.mapSfixed32Sfixed32);
2436  XCTAssertNotEqual(msg1.mapSfixed64Sfixed64, msg2.mapSfixed64Sfixed64);
2437  XCTAssertNotEqual(msg1.mapInt32Float, msg2.mapInt32Float);
2438  XCTAssertNotEqual(msg1.mapInt32Double, msg2.mapInt32Double);
2439  XCTAssertNotEqual(msg1.mapBoolBool, msg2.mapBoolBool);
2440  XCTAssertNotEqual(msg1.mapStringString, msg2.mapStringString);
2441  XCTAssertNotEqual(msg1.mapInt32Bytes, msg2.mapInt32Bytes);
2442  XCTAssertNotEqual(msg1.mapInt32Enum, msg2.mapInt32Enum);
2443  XCTAssertNotEqual(msg1.mapInt32ForeignMessage, msg2.mapInt32ForeignMessage);
2444
2445  // Ensure the messages are unique per map.
2446  [msg1.mapInt32ForeignMessage
2447      enumerateKeysAndObjectsUsingBlock:^(int32_t key, id value, BOOL *stop) {
2448#pragma unused(stop)
2449        ForeignMessage *subMsg2 = [msg2.mapInt32ForeignMessage objectForKey:key];
2450        XCTAssertNotEqual(value, subMsg2);  // Ptr compare, new object.
2451      }];
2452}
2453
2454- (void)test_GPBGetMessageRepeatedField {
2455  TestAllTypes *message = [TestAllTypes message];
2456  GPBFieldDescriptor *fieldDescriptor = [[message descriptor] fieldWithName:@"repeatedStringArray"];
2457  XCTAssertNotNil(fieldDescriptor);
2458  NSMutableArray *fieldArray = GPBGetMessageRepeatedField(message, fieldDescriptor);
2459  XCTAssertNotNil(fieldArray);  // Should have autocreated.
2460  XCTAssertTrue(fieldArray == message.repeatedStringArray);  // Same pointer
2461}
2462
2463- (void)test_GPBSetMessageRepeatedField {
2464  TestAllTypes *message = [TestAllTypes message];
2465  GPBFieldDescriptor *fieldDescriptor = [[message descriptor] fieldWithName:@"repeatedStringArray"];
2466  XCTAssertNotNil(fieldDescriptor);
2467
2468  NSMutableArray *fieldArray = [NSMutableArray arrayWithObject:@"foo"];
2469  GPBSetMessageRepeatedField(message, fieldDescriptor, fieldArray);
2470  XCTAssertTrue(fieldArray == message.repeatedStringArray);  // Same pointer
2471  XCTAssertEqualObjects(@"foo", message.repeatedStringArray.firstObject);
2472}
2473
2474- (void)test_GPBGetMessageMapField {
2475  TestMap *message = [TestMap message];
2476  GPBFieldDescriptor *fieldDescriptor = [[message descriptor] fieldWithName:@"mapStringString"];
2477  XCTAssertNotNil(fieldDescriptor);
2478  NSMutableDictionary *fieldMap = GPBGetMessageMapField(message, fieldDescriptor);
2479  XCTAssertNotNil(fieldMap);  // Should have autocreated.
2480  XCTAssertTrue(fieldMap == message.mapStringString);  // Same pointer
2481}
2482
2483- (void)test_GPBSetMessageMapField {
2484  TestMap *message = [TestMap message];
2485  GPBFieldDescriptor *fieldDescriptor = [[message descriptor] fieldWithName:@"mapStringString"];
2486  XCTAssertNotNil(fieldDescriptor);
2487
2488  NSMutableDictionary *fieldMap = [NSMutableDictionary dictionaryWithObject:@"bar" forKey:@"foo"];
2489  GPBSetMessageMapField(message, fieldDescriptor, fieldMap);
2490  XCTAssertTrue(fieldMap == message.mapStringString);  // Same pointer
2491  XCTAssertEqualObjects(@"bar", message.mapStringString[@"foo"]);
2492}
2493
2494- (void)test_StringFieldsCopy {
2495  // ObjC conventions call for NSString properites to be copy, ensure
2496  // that is done correctly and the string isn't simply retained.
2497
2498  Message2 *msg1 = [Message2 message];
2499  Message2 *msg2 = [Message2 message];
2500
2501  GPBFieldDescriptor *fieldDesc =
2502      [[Message2 descriptor] fieldWithNumber:Message2_FieldNumber_OptionalString];
2503  NSMutableString *mutableStr = [NSMutableString stringWithString:@"foo"];
2504
2505  msg1.optionalString = mutableStr;
2506  GPBSetMessageStringField(msg2, fieldDesc, mutableStr);
2507
2508  XCTAssertEqualObjects(msg1.optionalString, mutableStr);
2509  XCTAssertEqualObjects(msg1.optionalString, @"foo");
2510  XCTAssertTrue(msg1.optionalString != mutableStr);  // Ptr comparision.
2511
2512  XCTAssertEqualObjects(msg2.optionalString, mutableStr);
2513  XCTAssertEqualObjects(msg2.optionalString, @"foo");
2514  XCTAssertTrue(msg2.optionalString != mutableStr);  // Ptr comparision.
2515
2516  [mutableStr appendString:@"bar"];
2517
2518  XCTAssertNotEqualObjects(msg1.optionalString, mutableStr);
2519  XCTAssertEqualObjects(msg1.optionalString, @"foo");
2520  XCTAssertTrue(msg1.optionalString != mutableStr);  // Ptr comparision.
2521
2522  XCTAssertNotEqualObjects(msg2.optionalString, mutableStr);
2523  XCTAssertEqualObjects(msg2.optionalString, @"foo");
2524  XCTAssertTrue(msg2.optionalString != mutableStr);  // Ptr comparision.
2525}
2526
2527- (void)test_BytesFieldsCopy {
2528  // ObjC conventions call for NSData properites to be copy, ensure
2529  // that is done correctly and the data isn't simply retained.
2530
2531  Message2 *msg1 = [Message2 message];
2532  Message2 *msg2 = [Message2 message];
2533
2534  GPBFieldDescriptor *fieldDesc =
2535      [[Message2 descriptor] fieldWithNumber:Message2_FieldNumber_OptionalBytes];
2536  NSMutableData *mutableData = [NSMutableData dataWithData:DataFromCStr("abc")];
2537
2538  msg1.optionalBytes = mutableData;
2539  GPBSetMessageBytesField(msg2, fieldDesc, mutableData);
2540
2541  XCTAssertEqualObjects(msg1.optionalBytes, mutableData);
2542  XCTAssertEqualObjects(msg1.optionalBytes, DataFromCStr("abc"));
2543  XCTAssertTrue(msg1.optionalBytes != mutableData);  // Ptr comparision.
2544
2545  XCTAssertEqualObjects(msg2.optionalBytes, mutableData);
2546  XCTAssertEqualObjects(msg2.optionalBytes, DataFromCStr("abc"));
2547  XCTAssertTrue(msg2.optionalBytes != mutableData);  // Ptr comparision.
2548
2549  [mutableData appendData:DataFromCStr("123")];
2550
2551  XCTAssertNotEqualObjects(msg1.optionalBytes, mutableData);
2552  XCTAssertEqualObjects(msg1.optionalBytes, DataFromCStr("abc"));
2553  XCTAssertTrue(msg1.optionalBytes != mutableData);  // Ptr comparision.
2554
2555  XCTAssertNotEqualObjects(msg2.optionalBytes, mutableData);
2556  XCTAssertEqualObjects(msg2.optionalBytes, DataFromCStr("abc"));
2557  XCTAssertTrue(msg2.optionalBytes != mutableData);  // Ptr comparision.
2558}
2559
2560#pragma mark - Subset from from map_tests.cc
2561
2562// TEST(GeneratedMapFieldTest, IsInitialized)
2563- (void)testMap_IsInitialized {
2564  TestRequiredMessageMap *msg = [[TestRequiredMessageMap alloc] init];
2565
2566  // Add an uninitialized message.
2567  TestRequired *subMsg = [[TestRequired alloc] init];
2568  [msg.mapField setObject:subMsg forKey:0];
2569  XCTAssertFalse(msg.initialized);
2570
2571  // Initialize uninitialized message
2572  subMsg.a = 0;
2573  subMsg.b = 0;
2574  subMsg.c = 0;
2575  XCTAssertTrue(msg.initialized);
2576
2577  [subMsg release];
2578  [msg release];
2579}
2580
2581@end
2582