Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(53)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/protobuf/objectivec/Tests/GPBMessageTests+Runtime.m

Issue 1322483002: Revert https://codereview.chromium.org/1291903002 (protobuf roll). (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « third_party/protobuf/objectivec/Tests/GPBMessageTests+Merge.m ('k') | third_party/protobuf/objectivec/Tests/GPBMessageTests+Serialization.m » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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/UnittestObjcStartup.pbobjc.h"
40 #import "google/protobuf/UnittestRuntimeProto2.pbobjc.h"
41 #import "google/protobuf/UnittestRuntimeProto3.pbobjc.h"
42
43 @interface MessageRuntimeTests : GPBTestCase
44 @end
45
46 @implementation MessageRuntimeTests
47
48 // TODO(thomasvl): Pull tests over from GPBMessageTests that are runtime
49 // specific.
50
51 - (void)testStartupOrdering {
52 // Just have to create a message. Nothing else uses the classes from
53 // this file, so the first selector invoked on the class will initialize
54 // it, which also initializes the root.
55 TestObjCStartupMessage *message = [TestObjCStartupMessage message];
56 XCTAssertNotNil(message);
57 }
58
59 - (void)testProto2HasMethodSupport {
60 NSArray *names = @[
61 @"Int32",
62 @"Int64",
63 @"Uint32",
64 @"Uint64",
65 @"Sint32",
66 @"Sint64",
67 @"Fixed32",
68 @"Fixed64",
69 @"Sfixed32",
70 @"Sfixed64",
71 @"Float",
72 @"Double",
73 @"Bool",
74 @"String",
75 @"Bytes",
76 @"Group",
77 @"Message",
78 @"Enum",
79 ];
80
81 // Proto2 gets:
82
83 // Single fields - has*/setHas* is valid.
84
85 for (NSString *name in names) {
86 // build the selector, i.e. - hasOptionalInt32/setHasOptionalInt32:
87 SEL hasSel = NSSelectorFromString(
88 [NSString stringWithFormat:@"hasOptional%@", name]);
89 SEL setHasSel = NSSelectorFromString(
90 [NSString stringWithFormat:@"setHasOptional%@:", name]);
91 XCTAssertTrue([Message2 instancesRespondToSelector:hasSel], @"field: %@",
92 name);
93 XCTAssertTrue([Message2 instancesRespondToSelector:setHasSel], @"field: %@",
94 name);
95 }
96
97 // Repeated fields
98 // - no has*/setHas*
99 // - *Count
100
101 for (NSString *name in names) {
102 // build the selector, i.e. - hasRepeatedInt32Array/setHasRepeatedInt32Array :
103 SEL hasSel = NSSelectorFromString(
104 [NSString stringWithFormat:@"hasRepeated%@Array", name]);
105 SEL setHasSel = NSSelectorFromString(
106 [NSString stringWithFormat:@"setHasRepeated%@Array:", name]);
107 XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@",
108 name);
109 XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel],
110 @"field: %@", name);
111 // build the selector, i.e. - repeatedInt32Array_Count
112 SEL countSel = NSSelectorFromString(
113 [NSString stringWithFormat:@"repeated%@Array_Count", name]);
114 XCTAssertTrue([Message2 instancesRespondToSelector:countSel], @"field: %@",
115 name);
116 }
117
118 // OneOf fields - no has*/setHas*
119
120 for (NSString *name in names) {
121 // build the selector, i.e. - hasOneofInt32/setHasOneofInt32:
122 SEL hasSel =
123 NSSelectorFromString([NSString stringWithFormat:@"hasOneof%@", name]);
124 SEL setHasSel = NSSelectorFromString(
125 [NSString stringWithFormat:@"setHasOneof%@:", name]);
126 XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@",
127 name);
128 XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel],
129 @"field: %@", name);
130 }
131
132 // map<> fields
133 // - no has*/setHas*
134 // - *Count
135
136 NSArray *mapNames = @[
137 @"Int32Int32",
138 @"Int64Int64",
139 @"Uint32Uint32",
140 @"Uint64Uint64",
141 @"Sint32Sint32",
142 @"Sint64Sint64",
143 @"Fixed32Fixed32",
144 @"Fixed64Fixed64",
145 @"Sfixed32Sfixed32",
146 @"Sfixed64Sfixed64",
147 @"Int32Float",
148 @"Int32Double",
149 @"BoolBool",
150 @"StringString",
151 @"StringBytes",
152 @"StringMessage",
153 @"Int32Bytes",
154 @"Int32Enum",
155 @"Int32Message",
156 ];
157
158 for (NSString *name in mapNames) {
159 // build the selector, i.e. - hasMapInt32Int32/setHasMapInt32Int32:
160 SEL hasSel = NSSelectorFromString(
161 [NSString stringWithFormat:@"hasMap%@", name]);
162 SEL setHasSel = NSSelectorFromString(
163 [NSString stringWithFormat:@"setHasMap%@:", name]);
164 XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@",
165 name);
166 XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel],
167 @"field: %@", name);
168 // build the selector, i.e. - mapInt32Int32Count
169 SEL countSel = NSSelectorFromString(
170 [NSString stringWithFormat:@"map%@_Count", name]);
171 XCTAssertTrue([Message2 instancesRespondToSelector:countSel], @"field: %@",
172 name);
173 }
174
175 }
176
177 - (void)testProto3HasMethodSupport {
178 NSArray *names = @[
179 @"Int32",
180 @"Int64",
181 @"Uint32",
182 @"Uint64",
183 @"Sint32",
184 @"Sint64",
185 @"Fixed32",
186 @"Fixed64",
187 @"Sfixed32",
188 @"Sfixed64",
189 @"Float",
190 @"Double",
191 @"Bool",
192 @"String",
193 @"Bytes",
194 @"Message",
195 @"Enum",
196 ];
197
198 // Proto3 gets:
199
200 // Single fields
201 // - has*/setHas* invalid for primative types.
202 // - has*/setHas* valid for Message.
203
204 for (NSString *name in names) {
205 // build the selector, i.e. - hasOptionalInt32/setHasOptionalInt32:
206 SEL hasSel = NSSelectorFromString(
207 [NSString stringWithFormat:@"hasOptional%@", name]);
208 SEL setHasSel = NSSelectorFromString(
209 [NSString stringWithFormat:@"setHasOptional%@:", name]);
210 if ([name isEqual:@"Message"]) {
211 // Sub messages/groups are the exception.
212 XCTAssertTrue([Message3 instancesRespondToSelector:hasSel], @"field: %@",
213 name);
214 XCTAssertTrue([Message3 instancesRespondToSelector:setHasSel],
215 @"field: %@", name);
216 } else {
217 XCTAssertFalse([Message3 instancesRespondToSelector:hasSel], @"field: %@",
218 name);
219 XCTAssertFalse([Message3 instancesRespondToSelector:setHasSel],
220 @"field: %@", name);
221 }
222 }
223
224 // Repeated fields
225 // - no has*/setHas*
226 // - *Count
227
228 for (NSString *name in names) {
229 // build the selector, i.e. - hasRepeatedInt32Array/setHasRepeatedInt32Array :
230 SEL hasSel = NSSelectorFromString(
231 [NSString stringWithFormat:@"hasRepeated%@Array", name]);
232 SEL setHasSel = NSSelectorFromString(
233 [NSString stringWithFormat:@"setHasRepeated%@Array:", name]);
234 XCTAssertFalse([Message3 instancesRespondToSelector:hasSel], @"field: %@",
235 name);
236 XCTAssertFalse([Message3 instancesRespondToSelector:setHasSel],
237 @"field: %@", name);
238 // build the selector, i.e. - repeatedInt32Array_Count
239 SEL countSel = NSSelectorFromString(
240 [NSString stringWithFormat:@"repeated%@Array_Count", name]);
241 XCTAssertTrue([Message2 instancesRespondToSelector:countSel], @"field: %@",
242 name);
243 }
244
245 // OneOf fields - no has*/setHas*
246
247 for (NSString *name in names) {
248 // build the selector, i.e. - hasOneofInt32/setHasOneofInt32:
249 SEL hasSel =
250 NSSelectorFromString([NSString stringWithFormat:@"hasOneof%@", name]);
251 SEL setHasSel = NSSelectorFromString(
252 [NSString stringWithFormat:@"setHasOneof%@:", name]);
253 XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@",
254 name);
255 XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel],
256 @"field: %@", name);
257 }
258
259 // map<> fields
260 // - no has*/setHas*
261 // - *Count
262
263 NSArray *mapNames = @[
264 @"Int32Int32",
265 @"Int64Int64",
266 @"Uint32Uint32",
267 @"Uint64Uint64",
268 @"Sint32Sint32",
269 @"Sint64Sint64",
270 @"Fixed32Fixed32",
271 @"Fixed64Fixed64",
272 @"Sfixed32Sfixed32",
273 @"Sfixed64Sfixed64",
274 @"Int32Float",
275 @"Int32Double",
276 @"BoolBool",
277 @"StringString",
278 @"StringBytes",
279 @"StringMessage",
280 @"Int32Bytes",
281 @"Int32Enum",
282 @"Int32Message",
283 ];
284
285 for (NSString *name in mapNames) {
286 // build the selector, i.e. - hasMapInt32Int32/setHasMapInt32Int32:
287 SEL hasSel = NSSelectorFromString(
288 [NSString stringWithFormat:@"hasMap%@", name]);
289 SEL setHasSel = NSSelectorFromString(
290 [NSString stringWithFormat:@"setHasMap%@:", name]);
291 XCTAssertFalse([Message2 instancesRespondToSelector:hasSel], @"field: %@",
292 name);
293 XCTAssertFalse([Message2 instancesRespondToSelector:setHasSel],
294 @"field: %@", name);
295 // build the selector, i.e. - mapInt32Int32Count
296 SEL countSel = NSSelectorFromString(
297 [NSString stringWithFormat:@"map%@_Count", name]);
298 XCTAssertTrue([Message2 instancesRespondToSelector:countSel], @"field: %@",
299 name);
300 }
301 }
302
303 - (void)testProto2SingleFieldHasBehavior {
304 //
305 // Setting to any value including the default value (0) should result has*
306 // being true.
307 //
308
309 //%PDDM-DEFINE PROTO2_TEST_HAS_FIELD(FIELD, NON_ZERO_VALUE, ZERO_VALUE)
310 //% { // optional##FIELD :: NON_ZERO_VALUE
311 //% Message2 *msg = [[Message2 alloc] init];
312 //% XCTAssertFalse(msg.hasOptional##FIELD);
313 //% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Opti onal##FIELD));
314 //% msg.optional##FIELD = NON_ZERO_VALUE;
315 //% XCTAssertTrue(msg.hasOptional##FIELD);
316 //% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optio nal##FIELD));
317 //% [msg release];
318 //% }
319 //% { // optional##FIELD :: ZERO_VALUE
320 //% Message2 *msg = [[Message2 alloc] init];
321 //% XCTAssertFalse(msg.hasOptional##FIELD);
322 //% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Opti onal##FIELD));
323 //% msg.optional##FIELD = ZERO_VALUE;
324 //% XCTAssertTrue(msg.hasOptional##FIELD);
325 //% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optio nal##FIELD));
326 //% [msg release];
327 //% }
328 //%
329 //%PDDM-DEFINE PROTO2_TEST_HAS_FIELDS()
330 //%PROTO2_TEST_HAS_FIELD(Int32, 1, 0)
331 //%PROTO2_TEST_HAS_FIELD(Int64, 1, 0)
332 //%PROTO2_TEST_HAS_FIELD(Uint32, 1, 0)
333 //%PROTO2_TEST_HAS_FIELD(Uint64, 1, 0)
334 //%PROTO2_TEST_HAS_FIELD(Sint32, 1, 0)
335 //%PROTO2_TEST_HAS_FIELD(Sint64, 1, 0)
336 //%PROTO2_TEST_HAS_FIELD(Fixed32, 1, 0)
337 //%PROTO2_TEST_HAS_FIELD(Fixed64, 1, 0)
338 //%PROTO2_TEST_HAS_FIELD(Sfixed32, 1, 0)
339 //%PROTO2_TEST_HAS_FIELD(Sfixed64, 1, 0)
340 //%PROTO2_TEST_HAS_FIELD(Float, 1.0f, 0.0f)
341 //%PROTO2_TEST_HAS_FIELD(Double, 1.0, 0.0)
342 //%PROTO2_TEST_HAS_FIELD(Bool, YES, NO)
343 //%PROTO2_TEST_HAS_FIELD(String, @"foo", @"")
344 //%PROTO2_TEST_HAS_FIELD(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding], [NSData data])
345 //% //
346 //% // Test doesn't apply to optionalGroup/optionalMessage.
347 //% //
348 //%
349 //%PROTO2_TEST_HAS_FIELD(Enum, Message2_Enum_Bar, Message2_Enum_Foo)
350 //%PDDM-EXPAND PROTO2_TEST_HAS_FIELDS()
351 // This block of code is generated, do not edit it directly.
352
353 { // optionalInt32 :: 1
354 Message2 *msg = [[Message2 alloc] init];
355 XCTAssertFalse(msg.hasOptionalInt32);
356 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lInt32));
357 msg.optionalInt32 = 1;
358 XCTAssertTrue(msg.hasOptionalInt32);
359 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Int32));
360 [msg release];
361 }
362 { // optionalInt32 :: 0
363 Message2 *msg = [[Message2 alloc] init];
364 XCTAssertFalse(msg.hasOptionalInt32);
365 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lInt32));
366 msg.optionalInt32 = 0;
367 XCTAssertTrue(msg.hasOptionalInt32);
368 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Int32));
369 [msg release];
370 }
371
372 { // optionalInt64 :: 1
373 Message2 *msg = [[Message2 alloc] init];
374 XCTAssertFalse(msg.hasOptionalInt64);
375 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lInt64));
376 msg.optionalInt64 = 1;
377 XCTAssertTrue(msg.hasOptionalInt64);
378 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Int64));
379 [msg release];
380 }
381 { // optionalInt64 :: 0
382 Message2 *msg = [[Message2 alloc] init];
383 XCTAssertFalse(msg.hasOptionalInt64);
384 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lInt64));
385 msg.optionalInt64 = 0;
386 XCTAssertTrue(msg.hasOptionalInt64);
387 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Int64));
388 [msg release];
389 }
390
391 { // optionalUint32 :: 1
392 Message2 *msg = [[Message2 alloc] init];
393 XCTAssertFalse(msg.hasOptionalUint32);
394 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lUint32));
395 msg.optionalUint32 = 1;
396 XCTAssertTrue(msg.hasOptionalUint32);
397 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Uint32));
398 [msg release];
399 }
400 { // optionalUint32 :: 0
401 Message2 *msg = [[Message2 alloc] init];
402 XCTAssertFalse(msg.hasOptionalUint32);
403 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lUint32));
404 msg.optionalUint32 = 0;
405 XCTAssertTrue(msg.hasOptionalUint32);
406 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Uint32));
407 [msg release];
408 }
409
410 { // optionalUint64 :: 1
411 Message2 *msg = [[Message2 alloc] init];
412 XCTAssertFalse(msg.hasOptionalUint64);
413 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lUint64));
414 msg.optionalUint64 = 1;
415 XCTAssertTrue(msg.hasOptionalUint64);
416 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Uint64));
417 [msg release];
418 }
419 { // optionalUint64 :: 0
420 Message2 *msg = [[Message2 alloc] init];
421 XCTAssertFalse(msg.hasOptionalUint64);
422 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lUint64));
423 msg.optionalUint64 = 0;
424 XCTAssertTrue(msg.hasOptionalUint64);
425 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Uint64));
426 [msg release];
427 }
428
429 { // optionalSint32 :: 1
430 Message2 *msg = [[Message2 alloc] init];
431 XCTAssertFalse(msg.hasOptionalSint32);
432 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lSint32));
433 msg.optionalSint32 = 1;
434 XCTAssertTrue(msg.hasOptionalSint32);
435 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Sint32));
436 [msg release];
437 }
438 { // optionalSint32 :: 0
439 Message2 *msg = [[Message2 alloc] init];
440 XCTAssertFalse(msg.hasOptionalSint32);
441 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lSint32));
442 msg.optionalSint32 = 0;
443 XCTAssertTrue(msg.hasOptionalSint32);
444 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Sint32));
445 [msg release];
446 }
447
448 { // optionalSint64 :: 1
449 Message2 *msg = [[Message2 alloc] init];
450 XCTAssertFalse(msg.hasOptionalSint64);
451 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lSint64));
452 msg.optionalSint64 = 1;
453 XCTAssertTrue(msg.hasOptionalSint64);
454 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Sint64));
455 [msg release];
456 }
457 { // optionalSint64 :: 0
458 Message2 *msg = [[Message2 alloc] init];
459 XCTAssertFalse(msg.hasOptionalSint64);
460 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lSint64));
461 msg.optionalSint64 = 0;
462 XCTAssertTrue(msg.hasOptionalSint64);
463 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Sint64));
464 [msg release];
465 }
466
467 { // optionalFixed32 :: 1
468 Message2 *msg = [[Message2 alloc] init];
469 XCTAssertFalse(msg.hasOptionalFixed32);
470 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lFixed32));
471 msg.optionalFixed32 = 1;
472 XCTAssertTrue(msg.hasOptionalFixed32);
473 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Fixed32));
474 [msg release];
475 }
476 { // optionalFixed32 :: 0
477 Message2 *msg = [[Message2 alloc] init];
478 XCTAssertFalse(msg.hasOptionalFixed32);
479 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lFixed32));
480 msg.optionalFixed32 = 0;
481 XCTAssertTrue(msg.hasOptionalFixed32);
482 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Fixed32));
483 [msg release];
484 }
485
486 { // optionalFixed64 :: 1
487 Message2 *msg = [[Message2 alloc] init];
488 XCTAssertFalse(msg.hasOptionalFixed64);
489 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lFixed64));
490 msg.optionalFixed64 = 1;
491 XCTAssertTrue(msg.hasOptionalFixed64);
492 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Fixed64));
493 [msg release];
494 }
495 { // optionalFixed64 :: 0
496 Message2 *msg = [[Message2 alloc] init];
497 XCTAssertFalse(msg.hasOptionalFixed64);
498 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lFixed64));
499 msg.optionalFixed64 = 0;
500 XCTAssertTrue(msg.hasOptionalFixed64);
501 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Fixed64));
502 [msg release];
503 }
504
505 { // optionalSfixed32 :: 1
506 Message2 *msg = [[Message2 alloc] init];
507 XCTAssertFalse(msg.hasOptionalSfixed32);
508 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lSfixed32));
509 msg.optionalSfixed32 = 1;
510 XCTAssertTrue(msg.hasOptionalSfixed32);
511 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Sfixed32));
512 [msg release];
513 }
514 { // optionalSfixed32 :: 0
515 Message2 *msg = [[Message2 alloc] init];
516 XCTAssertFalse(msg.hasOptionalSfixed32);
517 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lSfixed32));
518 msg.optionalSfixed32 = 0;
519 XCTAssertTrue(msg.hasOptionalSfixed32);
520 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Sfixed32));
521 [msg release];
522 }
523
524 { // optionalSfixed64 :: 1
525 Message2 *msg = [[Message2 alloc] init];
526 XCTAssertFalse(msg.hasOptionalSfixed64);
527 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lSfixed64));
528 msg.optionalSfixed64 = 1;
529 XCTAssertTrue(msg.hasOptionalSfixed64);
530 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Sfixed64));
531 [msg release];
532 }
533 { // optionalSfixed64 :: 0
534 Message2 *msg = [[Message2 alloc] init];
535 XCTAssertFalse(msg.hasOptionalSfixed64);
536 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lSfixed64));
537 msg.optionalSfixed64 = 0;
538 XCTAssertTrue(msg.hasOptionalSfixed64);
539 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Sfixed64));
540 [msg release];
541 }
542
543 { // optionalFloat :: 1.0f
544 Message2 *msg = [[Message2 alloc] init];
545 XCTAssertFalse(msg.hasOptionalFloat);
546 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lFloat));
547 msg.optionalFloat = 1.0f;
548 XCTAssertTrue(msg.hasOptionalFloat);
549 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Float));
550 [msg release];
551 }
552 { // optionalFloat :: 0.0f
553 Message2 *msg = [[Message2 alloc] init];
554 XCTAssertFalse(msg.hasOptionalFloat);
555 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lFloat));
556 msg.optionalFloat = 0.0f;
557 XCTAssertTrue(msg.hasOptionalFloat);
558 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Float));
559 [msg release];
560 }
561
562 { // optionalDouble :: 1.0
563 Message2 *msg = [[Message2 alloc] init];
564 XCTAssertFalse(msg.hasOptionalDouble);
565 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lDouble));
566 msg.optionalDouble = 1.0;
567 XCTAssertTrue(msg.hasOptionalDouble);
568 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Double));
569 [msg release];
570 }
571 { // optionalDouble :: 0.0
572 Message2 *msg = [[Message2 alloc] init];
573 XCTAssertFalse(msg.hasOptionalDouble);
574 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lDouble));
575 msg.optionalDouble = 0.0;
576 XCTAssertTrue(msg.hasOptionalDouble);
577 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Double));
578 [msg release];
579 }
580
581 { // optionalBool :: YES
582 Message2 *msg = [[Message2 alloc] init];
583 XCTAssertFalse(msg.hasOptionalBool);
584 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lBool));
585 msg.optionalBool = YES;
586 XCTAssertTrue(msg.hasOptionalBool);
587 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Bool));
588 [msg release];
589 }
590 { // optionalBool :: NO
591 Message2 *msg = [[Message2 alloc] init];
592 XCTAssertFalse(msg.hasOptionalBool);
593 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lBool));
594 msg.optionalBool = NO;
595 XCTAssertTrue(msg.hasOptionalBool);
596 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Bool));
597 [msg release];
598 }
599
600 { // optionalString :: @"foo"
601 Message2 *msg = [[Message2 alloc] init];
602 XCTAssertFalse(msg.hasOptionalString);
603 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lString));
604 msg.optionalString = @"foo";
605 XCTAssertTrue(msg.hasOptionalString);
606 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional String));
607 [msg release];
608 }
609 { // optionalString :: @""
610 Message2 *msg = [[Message2 alloc] init];
611 XCTAssertFalse(msg.hasOptionalString);
612 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lString));
613 msg.optionalString = @"";
614 XCTAssertTrue(msg.hasOptionalString);
615 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional String));
616 [msg release];
617 }
618
619 { // optionalBytes :: [@"foo" dataUsingEncoding:NSUTF8StringEncoding]
620 Message2 *msg = [[Message2 alloc] init];
621 XCTAssertFalse(msg.hasOptionalBytes);
622 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lBytes));
623 msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding];
624 XCTAssertTrue(msg.hasOptionalBytes);
625 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Bytes));
626 [msg release];
627 }
628 { // optionalBytes :: [NSData data]
629 Message2 *msg = [[Message2 alloc] init];
630 XCTAssertFalse(msg.hasOptionalBytes);
631 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lBytes));
632 msg.optionalBytes = [NSData data];
633 XCTAssertTrue(msg.hasOptionalBytes);
634 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Bytes));
635 [msg release];
636 }
637
638 //
639 // Test doesn't apply to optionalGroup/optionalMessage.
640 //
641
642 { // optionalEnum :: Message2_Enum_Bar
643 Message2 *msg = [[Message2 alloc] init];
644 XCTAssertFalse(msg.hasOptionalEnum);
645 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lEnum));
646 msg.optionalEnum = Message2_Enum_Bar;
647 XCTAssertTrue(msg.hasOptionalEnum);
648 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Enum));
649 [msg release];
650 }
651 { // optionalEnum :: Message2_Enum_Foo
652 Message2 *msg = [[Message2 alloc] init];
653 XCTAssertFalse(msg.hasOptionalEnum);
654 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optiona lEnum));
655 msg.optionalEnum = Message2_Enum_Foo;
656 XCTAssertTrue(msg.hasOptionalEnum);
657 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message2_FieldNumber_Optional Enum));
658 [msg release];
659 }
660
661 //%PDDM-EXPAND-END PROTO2_TEST_HAS_FIELDS()
662 }
663
664 - (void)testProto3SingleFieldHasBehavior {
665 //
666 // Setting to any value including the default value (0) should result has*
667 // being true.
668 //
669
670 //%PDDM-DEFINE PROTO3_TEST_HAS_FIELD(FIELD, NON_ZERO_VALUE, ZERO_VALUE)
671 //% { // optional##FIELD
672 //% Message3 *msg = [[Message3 alloc] init];
673 //% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Opti onal##FIELD));
674 //% msg.optional##FIELD = NON_ZERO_VALUE;
675 //% XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optio nal##FIELD));
676 //% msg.optional##FIELD = ZERO_VALUE;
677 //% XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Opti onal##FIELD));
678 //% [msg release];
679 //% }
680 //%
681 //%PDDM-DEFINE PROTO3_TEST_HAS_FIELDS()
682 //%PROTO3_TEST_HAS_FIELD(Int32, 1, 0)
683 //%PROTO3_TEST_HAS_FIELD(Int64, 1, 0)
684 //%PROTO3_TEST_HAS_FIELD(Uint32, 1, 0)
685 //%PROTO3_TEST_HAS_FIELD(Uint64, 1, 0)
686 //%PROTO3_TEST_HAS_FIELD(Sint32, 1, 0)
687 //%PROTO3_TEST_HAS_FIELD(Sint64, 1, 0)
688 //%PROTO3_TEST_HAS_FIELD(Fixed32, 1, 0)
689 //%PROTO3_TEST_HAS_FIELD(Fixed64, 1, 0)
690 //%PROTO3_TEST_HAS_FIELD(Sfixed32, 1, 0)
691 //%PROTO3_TEST_HAS_FIELD(Sfixed64, 1, 0)
692 //%PROTO3_TEST_HAS_FIELD(Float, 1.0f, 0.0f)
693 //%PROTO3_TEST_HAS_FIELD(Double, 1.0, 0.0)
694 //%PROTO3_TEST_HAS_FIELD(Bool, YES, NO)
695 //%PROTO3_TEST_HAS_FIELD(String, @"foo", @"")
696 //%PROTO3_TEST_HAS_FIELD(Bytes, [@"foo" dataUsingEncoding:NSUTF8StringEncoding], [NSData data])
697 //% //
698 //% // Test doesn't apply to optionalGroup/optionalMessage.
699 //% //
700 //%
701 //%PROTO3_TEST_HAS_FIELD(Enum, Message3_Enum_Bar, Message3_Enum_Foo)
702 //%PDDM-EXPAND PROTO3_TEST_HAS_FIELDS()
703 // This block of code is generated, do not edit it directly.
704
705 { // optionalInt32
706 Message3 *msg = [[Message3 alloc] init];
707 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lInt32));
708 msg.optionalInt32 = 1;
709 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Int32));
710 msg.optionalInt32 = 0;
711 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lInt32));
712 [msg release];
713 }
714
715 { // optionalInt64
716 Message3 *msg = [[Message3 alloc] init];
717 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lInt64));
718 msg.optionalInt64 = 1;
719 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Int64));
720 msg.optionalInt64 = 0;
721 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lInt64));
722 [msg release];
723 }
724
725 { // optionalUint32
726 Message3 *msg = [[Message3 alloc] init];
727 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lUint32));
728 msg.optionalUint32 = 1;
729 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Uint32));
730 msg.optionalUint32 = 0;
731 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lUint32));
732 [msg release];
733 }
734
735 { // optionalUint64
736 Message3 *msg = [[Message3 alloc] init];
737 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lUint64));
738 msg.optionalUint64 = 1;
739 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Uint64));
740 msg.optionalUint64 = 0;
741 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lUint64));
742 [msg release];
743 }
744
745 { // optionalSint32
746 Message3 *msg = [[Message3 alloc] init];
747 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lSint32));
748 msg.optionalSint32 = 1;
749 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Sint32));
750 msg.optionalSint32 = 0;
751 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lSint32));
752 [msg release];
753 }
754
755 { // optionalSint64
756 Message3 *msg = [[Message3 alloc] init];
757 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lSint64));
758 msg.optionalSint64 = 1;
759 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Sint64));
760 msg.optionalSint64 = 0;
761 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lSint64));
762 [msg release];
763 }
764
765 { // optionalFixed32
766 Message3 *msg = [[Message3 alloc] init];
767 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lFixed32));
768 msg.optionalFixed32 = 1;
769 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Fixed32));
770 msg.optionalFixed32 = 0;
771 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lFixed32));
772 [msg release];
773 }
774
775 { // optionalFixed64
776 Message3 *msg = [[Message3 alloc] init];
777 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lFixed64));
778 msg.optionalFixed64 = 1;
779 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Fixed64));
780 msg.optionalFixed64 = 0;
781 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lFixed64));
782 [msg release];
783 }
784
785 { // optionalSfixed32
786 Message3 *msg = [[Message3 alloc] init];
787 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lSfixed32));
788 msg.optionalSfixed32 = 1;
789 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Sfixed32));
790 msg.optionalSfixed32 = 0;
791 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lSfixed32));
792 [msg release];
793 }
794
795 { // optionalSfixed64
796 Message3 *msg = [[Message3 alloc] init];
797 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lSfixed64));
798 msg.optionalSfixed64 = 1;
799 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Sfixed64));
800 msg.optionalSfixed64 = 0;
801 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lSfixed64));
802 [msg release];
803 }
804
805 { // optionalFloat
806 Message3 *msg = [[Message3 alloc] init];
807 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lFloat));
808 msg.optionalFloat = 1.0f;
809 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Float));
810 msg.optionalFloat = 0.0f;
811 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lFloat));
812 [msg release];
813 }
814
815 { // optionalDouble
816 Message3 *msg = [[Message3 alloc] init];
817 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lDouble));
818 msg.optionalDouble = 1.0;
819 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Double));
820 msg.optionalDouble = 0.0;
821 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lDouble));
822 [msg release];
823 }
824
825 { // optionalBool
826 Message3 *msg = [[Message3 alloc] init];
827 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lBool));
828 msg.optionalBool = YES;
829 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Bool));
830 msg.optionalBool = NO;
831 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lBool));
832 [msg release];
833 }
834
835 { // optionalString
836 Message3 *msg = [[Message3 alloc] init];
837 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lString));
838 msg.optionalString = @"foo";
839 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional String));
840 msg.optionalString = @"";
841 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lString));
842 [msg release];
843 }
844
845 { // optionalBytes
846 Message3 *msg = [[Message3 alloc] init];
847 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lBytes));
848 msg.optionalBytes = [@"foo" dataUsingEncoding:NSUTF8StringEncoding];
849 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Bytes));
850 msg.optionalBytes = [NSData data];
851 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lBytes));
852 [msg release];
853 }
854
855 //
856 // Test doesn't apply to optionalGroup/optionalMessage.
857 //
858
859 { // optionalEnum
860 Message3 *msg = [[Message3 alloc] init];
861 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lEnum));
862 msg.optionalEnum = Message3_Enum_Bar;
863 XCTAssertTrue(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optional Enum));
864 msg.optionalEnum = Message3_Enum_Foo;
865 XCTAssertFalse(GPBMessageHasFieldNumberSet(msg, Message3_FieldNumber_Optiona lEnum));
866 [msg release];
867 }
868
869 //%PDDM-EXPAND-END PROTO3_TEST_HAS_FIELDS()
870 }
871
872 - (void)testAccessingProto2UnknownEnumValues {
873 Message2 *msg = [[Message2 alloc] init];
874
875 // Set it to something non zero, try and confirm it doesn't change.
876
877 msg.optionalEnum = Message2_Enum_Bar;
878 XCTAssertThrowsSpecificNamed(msg.optionalEnum = 666, NSException,
879 NSInvalidArgumentException);
880 XCTAssertEqual(msg.optionalEnum, Message2_Enum_Bar);
881
882 msg.oneofEnum = Message2_Enum_Bar;
883 XCTAssertThrowsSpecificNamed(msg.oneofEnum = 666, NSException,
884 NSInvalidArgumentException);
885 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Bar);
886
887 [msg release];
888 }
889
890 - (void)testAccessingProto3UnknownEnumValues {
891 Message3 *msg = [[Message3 alloc] init];
892
893 // Set it to something non zero, try and confirm it doesn't change.
894
895 msg.optionalEnum = Message3_Enum_Bar;
896 XCTAssertThrowsSpecificNamed(msg.optionalEnum = 666, NSException,
897 NSInvalidArgumentException);
898 XCTAssertEqual(msg.optionalEnum, Message3_Enum_Bar);
899
900 msg.oneofEnum = Message3_Enum_Bar;
901 XCTAssertThrowsSpecificNamed(msg.oneofEnum = 666, NSException,
902 NSInvalidArgumentException);
903 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Bar);
904
905 // Set via raw api to confirm it works.
906
907 SetMessage3_OptionalEnum_RawValue(msg, 666);
908 XCTAssertEqual(msg.optionalEnum,
909 Message3_Enum_GPBUnrecognizedEnumeratorValue);
910 XCTAssertEqual(Message3_OptionalEnum_RawValue(msg), 666);
911
912 SetMessage3_OneofEnum_RawValue(msg, 666);
913 XCTAssertEqual(msg.oneofEnum, Message3_Enum_GPBUnrecognizedEnumeratorValue);
914 XCTAssertEqual(Message3_OneofEnum_RawValue(msg), 666);
915
916 [msg release];
917 }
918
919 - (void)testProto2OneofBasicBehaviors {
920 Message2 *msg = [[Message2 alloc] init];
921
922 NSString *oneofStringDefault = @"string";
923 NSData *oneofBytesDefault = [@"data" dataUsingEncoding:NSUTF8StringEncoding];
924
925 // Nothing set.
926 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase);
927 XCTAssertEqual(msg.oneofInt32, 100);
928 XCTAssertEqual(msg.oneofInt64, 101);
929 XCTAssertEqual(msg.oneofUint32, 102U);
930 XCTAssertEqual(msg.oneofUint64, 103U);
931 XCTAssertEqual(msg.oneofSint32, 104);
932 XCTAssertEqual(msg.oneofSint64, 105);
933 XCTAssertEqual(msg.oneofFixed32, 106U);
934 XCTAssertEqual(msg.oneofFixed64, 107U);
935 XCTAssertEqual(msg.oneofSfixed32, 108);
936 XCTAssertEqual(msg.oneofSfixed64, 109);
937 XCTAssertEqual(msg.oneofFloat, 110.0f);
938 XCTAssertEqual(msg.oneofDouble, 111.0);
939 XCTAssertEqual(msg.oneofBool, YES);
940 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
941 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
942 XCTAssertNotNil(msg.oneofGroup);
943 XCTAssertNotNil(msg.oneofMessage);
944 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
945
946 // Set, check the case, check everyone has default but the one, confirm case
947 // didn't change.
948
949 msg.oneofInt32 = 1;
950 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt32);
951 XCTAssertEqual(msg.oneofInt32, 1);
952 XCTAssertEqual(msg.oneofInt64, 101);
953 XCTAssertEqual(msg.oneofUint32, 102U);
954 XCTAssertEqual(msg.oneofUint64, 103U);
955 XCTAssertEqual(msg.oneofSint32, 104);
956 XCTAssertEqual(msg.oneofSint64, 105);
957 XCTAssertEqual(msg.oneofFixed32, 106U);
958 XCTAssertEqual(msg.oneofFixed64, 107U);
959 XCTAssertEqual(msg.oneofSfixed32, 108);
960 XCTAssertEqual(msg.oneofSfixed64, 109);
961 XCTAssertEqual(msg.oneofFloat, 110.0f);
962 XCTAssertEqual(msg.oneofDouble, 111.0);
963 XCTAssertEqual(msg.oneofBool, YES);
964 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
965 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
966 XCTAssertNotNil(msg.oneofGroup);
967 XCTAssertNotNil(msg.oneofMessage);
968 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
969 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt32);
970
971 msg.oneofInt64 = 2;
972 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt64);
973 XCTAssertEqual(msg.oneofInt32, 100);
974 XCTAssertEqual(msg.oneofInt64, 2);
975 XCTAssertEqual(msg.oneofUint32, 102U);
976 XCTAssertEqual(msg.oneofUint64, 103U);
977 XCTAssertEqual(msg.oneofSint32, 104);
978 XCTAssertEqual(msg.oneofSint64, 105);
979 XCTAssertEqual(msg.oneofFixed32, 106U);
980 XCTAssertEqual(msg.oneofFixed64, 107U);
981 XCTAssertEqual(msg.oneofSfixed32, 108);
982 XCTAssertEqual(msg.oneofSfixed64, 109);
983 XCTAssertEqual(msg.oneofFloat, 110.0f);
984 XCTAssertEqual(msg.oneofDouble, 111.0);
985 XCTAssertEqual(msg.oneofBool, YES);
986 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
987 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
988 XCTAssertNotNil(msg.oneofGroup);
989 XCTAssertNotNil(msg.oneofMessage);
990 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
991 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofInt64);
992
993 msg.oneofUint32 = 3;
994 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint32);
995 XCTAssertEqual(msg.oneofInt32, 100);
996 XCTAssertEqual(msg.oneofInt64, 101);
997 XCTAssertEqual(msg.oneofUint32, 3U);
998 XCTAssertEqual(msg.oneofUint64, 103U);
999 XCTAssertEqual(msg.oneofSint32, 104);
1000 XCTAssertEqual(msg.oneofSint64, 105);
1001 XCTAssertEqual(msg.oneofFixed32, 106U);
1002 XCTAssertEqual(msg.oneofFixed64, 107U);
1003 XCTAssertEqual(msg.oneofSfixed32, 108);
1004 XCTAssertEqual(msg.oneofSfixed64, 109);
1005 XCTAssertEqual(msg.oneofFloat, 110.0f);
1006 XCTAssertEqual(msg.oneofDouble, 111.0);
1007 XCTAssertEqual(msg.oneofBool, YES);
1008 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1009 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1010 XCTAssertNotNil(msg.oneofGroup);
1011 XCTAssertNotNil(msg.oneofMessage);
1012 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1013 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint32);
1014
1015 msg.oneofUint64 = 4;
1016 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint64);
1017 XCTAssertEqual(msg.oneofInt32, 100);
1018 XCTAssertEqual(msg.oneofInt64, 101);
1019 XCTAssertEqual(msg.oneofUint32, 102U);
1020 XCTAssertEqual(msg.oneofUint64, 4U);
1021 XCTAssertEqual(msg.oneofSint32, 104);
1022 XCTAssertEqual(msg.oneofSint64, 105);
1023 XCTAssertEqual(msg.oneofFixed32, 106U);
1024 XCTAssertEqual(msg.oneofFixed64, 107U);
1025 XCTAssertEqual(msg.oneofSfixed32, 108);
1026 XCTAssertEqual(msg.oneofSfixed64, 109);
1027 XCTAssertEqual(msg.oneofFloat, 110.0f);
1028 XCTAssertEqual(msg.oneofDouble, 111.0);
1029 XCTAssertEqual(msg.oneofBool, YES);
1030 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1031 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1032 XCTAssertNotNil(msg.oneofGroup);
1033 XCTAssertNotNil(msg.oneofMessage);
1034 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1035 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofUint64);
1036
1037 msg.oneofSint32 = 5;
1038 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint32);
1039 XCTAssertEqual(msg.oneofInt32, 100);
1040 XCTAssertEqual(msg.oneofInt64, 101);
1041 XCTAssertEqual(msg.oneofUint32, 102U);
1042 XCTAssertEqual(msg.oneofUint64, 103U);
1043 XCTAssertEqual(msg.oneofSint32, 5);
1044 XCTAssertEqual(msg.oneofSint64, 105);
1045 XCTAssertEqual(msg.oneofFixed32, 106U);
1046 XCTAssertEqual(msg.oneofFixed64, 107U);
1047 XCTAssertEqual(msg.oneofSfixed32, 108);
1048 XCTAssertEqual(msg.oneofSfixed64, 109);
1049 XCTAssertEqual(msg.oneofFloat, 110.0f);
1050 XCTAssertEqual(msg.oneofDouble, 111.0);
1051 XCTAssertEqual(msg.oneofBool, YES);
1052 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1053 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1054 XCTAssertNotNil(msg.oneofGroup);
1055 XCTAssertNotNil(msg.oneofMessage);
1056 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1057 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint32);
1058
1059 msg.oneofSint64 = 6;
1060 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint64);
1061 XCTAssertEqual(msg.oneofInt32, 100);
1062 XCTAssertEqual(msg.oneofInt64, 101);
1063 XCTAssertEqual(msg.oneofUint32, 102U);
1064 XCTAssertEqual(msg.oneofUint64, 103U);
1065 XCTAssertEqual(msg.oneofSint32, 104);
1066 XCTAssertEqual(msg.oneofSint64, 6);
1067 XCTAssertEqual(msg.oneofFixed32, 106U);
1068 XCTAssertEqual(msg.oneofFixed64, 107U);
1069 XCTAssertEqual(msg.oneofSfixed32, 108);
1070 XCTAssertEqual(msg.oneofSfixed64, 109);
1071 XCTAssertEqual(msg.oneofFloat, 110.0f);
1072 XCTAssertEqual(msg.oneofDouble, 111.0);
1073 XCTAssertEqual(msg.oneofBool, YES);
1074 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1075 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1076 XCTAssertNotNil(msg.oneofGroup);
1077 XCTAssertNotNil(msg.oneofMessage);
1078 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1079 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSint64);
1080
1081 msg.oneofFixed32 = 7;
1082 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed32);
1083 XCTAssertEqual(msg.oneofInt32, 100);
1084 XCTAssertEqual(msg.oneofInt64, 101);
1085 XCTAssertEqual(msg.oneofUint32, 102U);
1086 XCTAssertEqual(msg.oneofUint64, 103U);
1087 XCTAssertEqual(msg.oneofSint32, 104);
1088 XCTAssertEqual(msg.oneofSint64, 105);
1089 XCTAssertEqual(msg.oneofFixed32, 7U);
1090 XCTAssertEqual(msg.oneofFixed64, 107U);
1091 XCTAssertEqual(msg.oneofSfixed32, 108);
1092 XCTAssertEqual(msg.oneofSfixed64, 109);
1093 XCTAssertEqual(msg.oneofFloat, 110.0f);
1094 XCTAssertEqual(msg.oneofDouble, 111.0);
1095 XCTAssertEqual(msg.oneofBool, YES);
1096 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1097 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1098 XCTAssertNotNil(msg.oneofGroup);
1099 XCTAssertNotNil(msg.oneofMessage);
1100 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1101 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed32);
1102
1103 msg.oneofFixed64 = 8;
1104 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed64);
1105 XCTAssertEqual(msg.oneofInt32, 100);
1106 XCTAssertEqual(msg.oneofInt64, 101);
1107 XCTAssertEqual(msg.oneofUint32, 102U);
1108 XCTAssertEqual(msg.oneofUint64, 103U);
1109 XCTAssertEqual(msg.oneofSint32, 104);
1110 XCTAssertEqual(msg.oneofSint64, 105);
1111 XCTAssertEqual(msg.oneofFixed32, 106U);
1112 XCTAssertEqual(msg.oneofFixed64, 8U);
1113 XCTAssertEqual(msg.oneofSfixed32, 108);
1114 XCTAssertEqual(msg.oneofSfixed64, 109);
1115 XCTAssertEqual(msg.oneofFloat, 110.0f);
1116 XCTAssertEqual(msg.oneofDouble, 111.0);
1117 XCTAssertEqual(msg.oneofBool, YES);
1118 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1119 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1120 XCTAssertNotNil(msg.oneofGroup);
1121 XCTAssertNotNil(msg.oneofMessage);
1122 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1123 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFixed64);
1124
1125 msg.oneofSfixed32 = 9;
1126 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed32);
1127 XCTAssertEqual(msg.oneofInt32, 100);
1128 XCTAssertEqual(msg.oneofInt64, 101);
1129 XCTAssertEqual(msg.oneofUint32, 102U);
1130 XCTAssertEqual(msg.oneofUint64, 103U);
1131 XCTAssertEqual(msg.oneofSint32, 104);
1132 XCTAssertEqual(msg.oneofSint64, 105);
1133 XCTAssertEqual(msg.oneofFixed32, 106U);
1134 XCTAssertEqual(msg.oneofFixed64, 107U);
1135 XCTAssertEqual(msg.oneofSfixed32, 9);
1136 XCTAssertEqual(msg.oneofSfixed64, 109);
1137 XCTAssertEqual(msg.oneofFloat, 110.0f);
1138 XCTAssertEqual(msg.oneofDouble, 111.0);
1139 XCTAssertEqual(msg.oneofBool, YES);
1140 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1141 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1142 XCTAssertNotNil(msg.oneofGroup);
1143 XCTAssertNotNil(msg.oneofMessage);
1144 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1145 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed32);
1146
1147 msg.oneofSfixed64 = 10;
1148 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed64);
1149 XCTAssertEqual(msg.oneofInt32, 100);
1150 XCTAssertEqual(msg.oneofInt64, 101);
1151 XCTAssertEqual(msg.oneofUint32, 102U);
1152 XCTAssertEqual(msg.oneofUint64, 103U);
1153 XCTAssertEqual(msg.oneofSint32, 104);
1154 XCTAssertEqual(msg.oneofSint64, 105);
1155 XCTAssertEqual(msg.oneofFixed32, 106U);
1156 XCTAssertEqual(msg.oneofFixed64, 107U);
1157 XCTAssertEqual(msg.oneofSfixed32, 108);
1158 XCTAssertEqual(msg.oneofSfixed64, 10);
1159 XCTAssertEqual(msg.oneofFloat, 110.0f);
1160 XCTAssertEqual(msg.oneofDouble, 111.0);
1161 XCTAssertEqual(msg.oneofBool, YES);
1162 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1163 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1164 XCTAssertNotNil(msg.oneofGroup);
1165 XCTAssertNotNil(msg.oneofMessage);
1166 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1167 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofSfixed64);
1168
1169 msg.oneofFloat = 11.0f;
1170 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFloat);
1171 XCTAssertEqual(msg.oneofInt32, 100);
1172 XCTAssertEqual(msg.oneofInt64, 101);
1173 XCTAssertEqual(msg.oneofUint32, 102U);
1174 XCTAssertEqual(msg.oneofUint64, 103U);
1175 XCTAssertEqual(msg.oneofSint32, 104);
1176 XCTAssertEqual(msg.oneofSint64, 105);
1177 XCTAssertEqual(msg.oneofFixed32, 106U);
1178 XCTAssertEqual(msg.oneofFixed64, 107U);
1179 XCTAssertEqual(msg.oneofSfixed32, 108);
1180 XCTAssertEqual(msg.oneofSfixed64, 109);
1181 XCTAssertEqual(msg.oneofFloat, 11.0f);
1182 XCTAssertEqual(msg.oneofDouble, 111.0);
1183 XCTAssertEqual(msg.oneofBool, YES);
1184 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1185 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1186 XCTAssertNotNil(msg.oneofGroup);
1187 XCTAssertNotNil(msg.oneofMessage);
1188 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1189 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofFloat);
1190
1191 msg.oneofDouble = 12.0;
1192 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofDouble);
1193 XCTAssertEqual(msg.oneofInt32, 100);
1194 XCTAssertEqual(msg.oneofInt64, 101);
1195 XCTAssertEqual(msg.oneofUint32, 102U);
1196 XCTAssertEqual(msg.oneofUint64, 103U);
1197 XCTAssertEqual(msg.oneofSint32, 104);
1198 XCTAssertEqual(msg.oneofSint64, 105);
1199 XCTAssertEqual(msg.oneofFixed32, 106U);
1200 XCTAssertEqual(msg.oneofFixed64, 107U);
1201 XCTAssertEqual(msg.oneofSfixed32, 108);
1202 XCTAssertEqual(msg.oneofSfixed64, 109);
1203 XCTAssertEqual(msg.oneofFloat, 110.0f);
1204 XCTAssertEqual(msg.oneofDouble, 12.0);
1205 XCTAssertEqual(msg.oneofBool, YES);
1206 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1207 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1208 XCTAssertNotNil(msg.oneofGroup);
1209 XCTAssertNotNil(msg.oneofMessage);
1210 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1211 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofDouble);
1212
1213 msg.oneofBool = NO;
1214 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBool);
1215 XCTAssertEqual(msg.oneofInt32, 100);
1216 XCTAssertEqual(msg.oneofInt64, 101);
1217 XCTAssertEqual(msg.oneofUint32, 102U);
1218 XCTAssertEqual(msg.oneofUint64, 103U);
1219 XCTAssertEqual(msg.oneofSint32, 104);
1220 XCTAssertEqual(msg.oneofSint64, 105);
1221 XCTAssertEqual(msg.oneofFixed32, 106U);
1222 XCTAssertEqual(msg.oneofFixed64, 107U);
1223 XCTAssertEqual(msg.oneofSfixed32, 108);
1224 XCTAssertEqual(msg.oneofSfixed64, 109);
1225 XCTAssertEqual(msg.oneofFloat, 110.0f);
1226 XCTAssertEqual(msg.oneofDouble, 111.0);
1227 XCTAssertEqual(msg.oneofBool, NO);
1228 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1229 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1230 XCTAssertNotNil(msg.oneofGroup);
1231 XCTAssertNotNil(msg.oneofMessage);
1232 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1233 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBool);
1234
1235 msg.oneofString = @"foo";
1236 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofString);
1237 XCTAssertEqual(msg.oneofInt32, 100);
1238 XCTAssertEqual(msg.oneofInt64, 101);
1239 XCTAssertEqual(msg.oneofUint32, 102U);
1240 XCTAssertEqual(msg.oneofUint64, 103U);
1241 XCTAssertEqual(msg.oneofSint32, 104);
1242 XCTAssertEqual(msg.oneofSint64, 105);
1243 XCTAssertEqual(msg.oneofFixed32, 106U);
1244 XCTAssertEqual(msg.oneofFixed64, 107U);
1245 XCTAssertEqual(msg.oneofSfixed32, 108);
1246 XCTAssertEqual(msg.oneofSfixed64, 109);
1247 XCTAssertEqual(msg.oneofFloat, 110.0f);
1248 XCTAssertEqual(msg.oneofDouble, 111.0);
1249 XCTAssertEqual(msg.oneofBool, YES);
1250 XCTAssertEqualObjects(msg.oneofString, @"foo");
1251 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1252 XCTAssertNotNil(msg.oneofGroup);
1253 XCTAssertNotNil(msg.oneofMessage);
1254 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1255 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofString);
1256
1257 msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding];
1258 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBytes);
1259 XCTAssertEqual(msg.oneofInt32, 100);
1260 XCTAssertEqual(msg.oneofInt64, 101);
1261 XCTAssertEqual(msg.oneofUint32, 102U);
1262 XCTAssertEqual(msg.oneofUint64, 103U);
1263 XCTAssertEqual(msg.oneofSint32, 104);
1264 XCTAssertEqual(msg.oneofSint64, 105);
1265 XCTAssertEqual(msg.oneofFixed32, 106U);
1266 XCTAssertEqual(msg.oneofFixed64, 107U);
1267 XCTAssertEqual(msg.oneofSfixed32, 108);
1268 XCTAssertEqual(msg.oneofSfixed64, 109);
1269 XCTAssertEqual(msg.oneofFloat, 110.0f);
1270 XCTAssertEqual(msg.oneofDouble, 111.0);
1271 XCTAssertEqual(msg.oneofBool, YES);
1272 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1273 XCTAssertEqualObjects(msg.oneofBytes,
1274 [@"bar" dataUsingEncoding:NSUTF8StringEncoding]);
1275 XCTAssertNotNil(msg.oneofGroup);
1276 XCTAssertNotNil(msg.oneofMessage);
1277 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1278 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofBytes);
1279
1280 Message2_OneofGroup *group = [Message2_OneofGroup message];
1281 msg.oneofGroup = group;
1282 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofGroup);
1283 XCTAssertEqual(msg.oneofInt32, 100);
1284 XCTAssertEqual(msg.oneofInt64, 101);
1285 XCTAssertEqual(msg.oneofUint32, 102U);
1286 XCTAssertEqual(msg.oneofUint64, 103U);
1287 XCTAssertEqual(msg.oneofSint32, 104);
1288 XCTAssertEqual(msg.oneofSint64, 105);
1289 XCTAssertEqual(msg.oneofFixed32, 106U);
1290 XCTAssertEqual(msg.oneofFixed64, 107U);
1291 XCTAssertEqual(msg.oneofSfixed32, 108);
1292 XCTAssertEqual(msg.oneofSfixed64, 109);
1293 XCTAssertEqual(msg.oneofFloat, 110.0f);
1294 XCTAssertEqual(msg.oneofDouble, 111.0);
1295 XCTAssertEqual(msg.oneofBool, YES);
1296 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1297 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1298 XCTAssertEqual(msg.oneofGroup, group); // Pointer compare.
1299 XCTAssertNotNil(msg.oneofMessage);
1300 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1301 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofGroup);
1302
1303 Message2 *subMessage = [Message2 message];
1304 msg.oneofMessage = subMessage;
1305 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofMessage);
1306 XCTAssertEqual(msg.oneofInt32, 100);
1307 XCTAssertEqual(msg.oneofInt64, 101);
1308 XCTAssertEqual(msg.oneofUint32, 102U);
1309 XCTAssertEqual(msg.oneofUint64, 103U);
1310 XCTAssertEqual(msg.oneofSint32, 104);
1311 XCTAssertEqual(msg.oneofSint64, 105);
1312 XCTAssertEqual(msg.oneofFixed32, 106U);
1313 XCTAssertEqual(msg.oneofFixed64, 107U);
1314 XCTAssertEqual(msg.oneofSfixed32, 108);
1315 XCTAssertEqual(msg.oneofSfixed64, 109);
1316 XCTAssertEqual(msg.oneofFloat, 110.0f);
1317 XCTAssertEqual(msg.oneofDouble, 111.0);
1318 XCTAssertEqual(msg.oneofBool, YES);
1319 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1320 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1321 XCTAssertNotNil(msg.oneofGroup);
1322 XCTAssertNotEqual(msg.oneofGroup, group); // Pointer compare.
1323 XCTAssertEqual(msg.oneofMessage, subMessage); // Pointer compare.
1324 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz);
1325 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofMessage);
1326
1327 msg.oneofEnum = Message2_Enum_Bar;
1328 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofEnum);
1329 XCTAssertEqual(msg.oneofInt32, 100);
1330 XCTAssertEqual(msg.oneofInt64, 101);
1331 XCTAssertEqual(msg.oneofUint32, 102U);
1332 XCTAssertEqual(msg.oneofUint64, 103U);
1333 XCTAssertEqual(msg.oneofSint32, 104);
1334 XCTAssertEqual(msg.oneofSint64, 105);
1335 XCTAssertEqual(msg.oneofFixed32, 106U);
1336 XCTAssertEqual(msg.oneofFixed64, 107U);
1337 XCTAssertEqual(msg.oneofSfixed32, 108);
1338 XCTAssertEqual(msg.oneofSfixed64, 109);
1339 XCTAssertEqual(msg.oneofFloat, 110.0f);
1340 XCTAssertEqual(msg.oneofDouble, 111.0);
1341 XCTAssertEqual(msg.oneofBool, YES);
1342 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1343 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1344 XCTAssertNotNil(msg.oneofGroup);
1345 XCTAssertNotEqual(msg.oneofGroup, group); // Pointer compare.
1346 XCTAssertNotNil(msg.oneofMessage);
1347 XCTAssertNotEqual(msg.oneofMessage, subMessage); // Pointer compare.
1348 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Bar);
1349 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_OneofEnum);
1350
1351 // Test setting/calling clear clearing.
1352
1353 [msg release];
1354 msg = [[Message2 alloc] init];
1355
1356 uint32_t values[] = {
1357 Message2_O_OneOfCase_OneofInt32,
1358 Message2_O_OneOfCase_OneofInt64,
1359 Message2_O_OneOfCase_OneofUint32,
1360 Message2_O_OneOfCase_OneofUint64,
1361 Message2_O_OneOfCase_OneofSint32,
1362 Message2_O_OneOfCase_OneofSint64,
1363 Message2_O_OneOfCase_OneofFixed32,
1364 Message2_O_OneOfCase_OneofFixed64,
1365 Message2_O_OneOfCase_OneofSfixed32,
1366 Message2_O_OneOfCase_OneofSfixed64,
1367 Message2_O_OneOfCase_OneofFloat,
1368 Message2_O_OneOfCase_OneofDouble,
1369 Message2_O_OneOfCase_OneofBool,
1370 Message2_O_OneOfCase_OneofString,
1371 Message2_O_OneOfCase_OneofBytes,
1372 Message2_O_OneOfCase_OneofGroup,
1373 Message2_O_OneOfCase_OneofMessage,
1374 Message2_O_OneOfCase_OneofEnum,
1375 };
1376
1377 for (size_t i = 0; i < GPBARRAYSIZE(values); ++i) {
1378 switch (values[i]) {
1379 case Message2_O_OneOfCase_OneofInt32:
1380 msg.oneofInt32 = 1;
1381 break;
1382 case Message2_O_OneOfCase_OneofInt64:
1383 msg.oneofInt64 = 2;
1384 break;
1385 case Message2_O_OneOfCase_OneofUint32:
1386 msg.oneofUint32 = 3;
1387 break;
1388 case Message2_O_OneOfCase_OneofUint64:
1389 msg.oneofUint64 = 4;
1390 break;
1391 case Message2_O_OneOfCase_OneofSint32:
1392 msg.oneofSint32 = 5;
1393 break;
1394 case Message2_O_OneOfCase_OneofSint64:
1395 msg.oneofSint64 = 6;
1396 break;
1397 case Message2_O_OneOfCase_OneofFixed32:
1398 msg.oneofFixed32 = 7;
1399 break;
1400 case Message2_O_OneOfCase_OneofFixed64:
1401 msg.oneofFixed64 = 8;
1402 break;
1403 case Message2_O_OneOfCase_OneofSfixed32:
1404 msg.oneofSfixed32 = 9;
1405 break;
1406 case Message2_O_OneOfCase_OneofSfixed64:
1407 msg.oneofSfixed64 = 10;
1408 break;
1409 case Message2_O_OneOfCase_OneofFloat:
1410 msg.oneofFloat = 11.0f;
1411 break;
1412 case Message2_O_OneOfCase_OneofDouble:
1413 msg.oneofDouble = 12.0;
1414 break;
1415 case Message2_O_OneOfCase_OneofBool:
1416 msg.oneofBool = YES;
1417 break;
1418 case Message2_O_OneOfCase_OneofString:
1419 msg.oneofString = @"foo";
1420 break;
1421 case Message2_O_OneOfCase_OneofBytes:
1422 msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding];
1423 break;
1424 case Message2_O_OneOfCase_OneofGroup:
1425 msg.oneofGroup = group;
1426 break;
1427 case Message2_O_OneOfCase_OneofMessage:
1428 msg.oneofMessage = subMessage;
1429 break;
1430 case Message2_O_OneOfCase_OneofEnum:
1431 msg.oneofEnum = Message2_Enum_Bar;
1432 break;
1433 default:
1434 XCTFail(@"shouldn't happen, loop: %zd, value: %d", i, values[i]);
1435 break;
1436 }
1437
1438 XCTAssertEqual(msg.oOneOfCase, values[i], "Loop: %zd", i);
1439 // No need to check the value was set, the above tests did that.
1440 Message2_ClearOOneOfCase(msg);
1441 // Nothing in the case.
1442 XCTAssertEqual(msg.oOneOfCase, Message2_O_OneOfCase_GPBUnsetOneOfCase,
1443 "Loop: %zd", i);
1444 // Confirm everything is back to defaults after a clear.
1445 XCTAssertEqual(msg.oneofInt32, 100, "Loop: %zd", i);
1446 XCTAssertEqual(msg.oneofInt64, 101, "Loop: %zd", i);
1447 XCTAssertEqual(msg.oneofUint32, 102U, "Loop: %zd", i);
1448 XCTAssertEqual(msg.oneofUint64, 103U, "Loop: %zd", i);
1449 XCTAssertEqual(msg.oneofSint32, 104, "Loop: %zd", i);
1450 XCTAssertEqual(msg.oneofSint64, 105, "Loop: %zd", i);
1451 XCTAssertEqual(msg.oneofFixed32, 106U, "Loop: %zd", i);
1452 XCTAssertEqual(msg.oneofFixed64, 107U, "Loop: %zd", i);
1453 XCTAssertEqual(msg.oneofSfixed32, 108, "Loop: %zd", i);
1454 XCTAssertEqual(msg.oneofSfixed64, 109, "Loop: %zd", i);
1455 XCTAssertEqual(msg.oneofFloat, 110.0f, "Loop: %zd", i);
1456 XCTAssertEqual(msg.oneofDouble, 111.0, "Loop: %zd", i);
1457 XCTAssertEqual(msg.oneofBool, YES, "Loop: %zd", i);
1458 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault, "Loop: %zd", i);
1459 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault, "Loop: %zd", i);
1460 XCTAssertNotNil(msg.oneofGroup, "Loop: %zd", i);
1461 XCTAssertNotEqual(msg.oneofGroup, group, "Loop: %zd",
1462 i); // Pointer compare.
1463 XCTAssertNotNil(msg.oneofMessage, "Loop: %zd", i);
1464 XCTAssertNotEqual(msg.oneofMessage, subMessage, "Loop: %zd",
1465 i); // Pointer compare.
1466 XCTAssertEqual(msg.oneofEnum, Message2_Enum_Baz, "Loop: %zd", i);
1467 }
1468
1469 [msg release];
1470 }
1471
1472 - (void)testProto3OneofBasicBehaviors {
1473 Message3 *msg = [[Message3 alloc] init];
1474
1475 NSString *oneofStringDefault = @"";
1476 NSData *oneofBytesDefault = [NSData data];
1477
1478 // Nothing set.
1479 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase);
1480 XCTAssertEqual(msg.oneofInt32, 0);
1481 XCTAssertEqual(msg.oneofInt64, 0);
1482 XCTAssertEqual(msg.oneofUint32, 0U);
1483 XCTAssertEqual(msg.oneofUint64, 0U);
1484 XCTAssertEqual(msg.oneofSint32, 0);
1485 XCTAssertEqual(msg.oneofSint64, 0);
1486 XCTAssertEqual(msg.oneofFixed32, 0U);
1487 XCTAssertEqual(msg.oneofFixed64, 0U);
1488 XCTAssertEqual(msg.oneofSfixed32, 0);
1489 XCTAssertEqual(msg.oneofSfixed64, 0);
1490 XCTAssertEqual(msg.oneofFloat, 0.0f);
1491 XCTAssertEqual(msg.oneofDouble, 0.0);
1492 XCTAssertEqual(msg.oneofBool, NO);
1493 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1494 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1495 XCTAssertNotNil(msg.oneofMessage);
1496 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1497
1498 // Set, check the case, check everyone has default but the one, confirm case
1499 // didn't change.
1500
1501 msg.oneofInt32 = 1;
1502 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt32);
1503 XCTAssertEqual(msg.oneofInt32, 1);
1504 XCTAssertEqual(msg.oneofInt64, 0);
1505 XCTAssertEqual(msg.oneofUint32, 0U);
1506 XCTAssertEqual(msg.oneofUint64, 0U);
1507 XCTAssertEqual(msg.oneofSint32, 0);
1508 XCTAssertEqual(msg.oneofSint64, 0);
1509 XCTAssertEqual(msg.oneofFixed32, 0U);
1510 XCTAssertEqual(msg.oneofFixed64, 0U);
1511 XCTAssertEqual(msg.oneofSfixed32, 0);
1512 XCTAssertEqual(msg.oneofSfixed64, 0);
1513 XCTAssertEqual(msg.oneofFloat, 0.0f);
1514 XCTAssertEqual(msg.oneofDouble, 0.0);
1515 XCTAssertEqual(msg.oneofBool, NO);
1516 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1517 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1518 XCTAssertNotNil(msg.oneofMessage);
1519 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1520 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt32);
1521
1522 msg.oneofInt64 = 2;
1523 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt64);
1524 XCTAssertEqual(msg.oneofInt32, 0);
1525 XCTAssertEqual(msg.oneofInt64, 2);
1526 XCTAssertEqual(msg.oneofUint32, 0U);
1527 XCTAssertEqual(msg.oneofUint64, 0U);
1528 XCTAssertEqual(msg.oneofSint32, 0);
1529 XCTAssertEqual(msg.oneofSint64, 0);
1530 XCTAssertEqual(msg.oneofFixed32, 0U);
1531 XCTAssertEqual(msg.oneofFixed64, 0U);
1532 XCTAssertEqual(msg.oneofSfixed32, 0);
1533 XCTAssertEqual(msg.oneofSfixed64, 0);
1534 XCTAssertEqual(msg.oneofFloat, 0.0f);
1535 XCTAssertEqual(msg.oneofDouble, 0.0);
1536 XCTAssertEqual(msg.oneofBool, NO);
1537 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1538 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1539 XCTAssertNotNil(msg.oneofMessage);
1540 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1541 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofInt64);
1542
1543 msg.oneofUint32 = 3;
1544 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint32);
1545 XCTAssertEqual(msg.oneofInt32, 0);
1546 XCTAssertEqual(msg.oneofInt64, 0);
1547 XCTAssertEqual(msg.oneofUint32, 3U);
1548 XCTAssertEqual(msg.oneofUint64, 0U);
1549 XCTAssertEqual(msg.oneofSint32, 0);
1550 XCTAssertEqual(msg.oneofSint64, 0);
1551 XCTAssertEqual(msg.oneofFixed32, 0U);
1552 XCTAssertEqual(msg.oneofFixed64, 0U);
1553 XCTAssertEqual(msg.oneofSfixed32, 0);
1554 XCTAssertEqual(msg.oneofSfixed64, 0);
1555 XCTAssertEqual(msg.oneofFloat, 0.0f);
1556 XCTAssertEqual(msg.oneofDouble, 0.0);
1557 XCTAssertEqual(msg.oneofBool, NO);
1558 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1559 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1560 XCTAssertNotNil(msg.oneofMessage);
1561 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1562 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint32);
1563
1564 msg.oneofUint64 = 4;
1565 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint64);
1566 XCTAssertEqual(msg.oneofInt32, 0);
1567 XCTAssertEqual(msg.oneofInt64, 0);
1568 XCTAssertEqual(msg.oneofUint32, 0U);
1569 XCTAssertEqual(msg.oneofUint64, 4U);
1570 XCTAssertEqual(msg.oneofSint32, 0);
1571 XCTAssertEqual(msg.oneofSint64, 0);
1572 XCTAssertEqual(msg.oneofFixed32, 0U);
1573 XCTAssertEqual(msg.oneofFixed64, 0U);
1574 XCTAssertEqual(msg.oneofSfixed32, 0);
1575 XCTAssertEqual(msg.oneofSfixed64, 0);
1576 XCTAssertEqual(msg.oneofFloat, 0.0f);
1577 XCTAssertEqual(msg.oneofDouble, 0.0);
1578 XCTAssertEqual(msg.oneofBool, NO);
1579 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1580 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1581 XCTAssertNotNil(msg.oneofMessage);
1582 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1583 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofUint64);
1584
1585 msg.oneofSint32 = 5;
1586 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint32);
1587 XCTAssertEqual(msg.oneofInt32, 0);
1588 XCTAssertEqual(msg.oneofInt64, 0);
1589 XCTAssertEqual(msg.oneofUint32, 0U);
1590 XCTAssertEqual(msg.oneofUint64, 0U);
1591 XCTAssertEqual(msg.oneofSint32, 5);
1592 XCTAssertEqual(msg.oneofSint64, 0);
1593 XCTAssertEqual(msg.oneofFixed32, 0U);
1594 XCTAssertEqual(msg.oneofFixed64, 0U);
1595 XCTAssertEqual(msg.oneofSfixed32, 0);
1596 XCTAssertEqual(msg.oneofSfixed64, 0);
1597 XCTAssertEqual(msg.oneofFloat, 0.0f);
1598 XCTAssertEqual(msg.oneofDouble, 0.0);
1599 XCTAssertEqual(msg.oneofBool, NO);
1600 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1601 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1602 XCTAssertNotNil(msg.oneofMessage);
1603 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1604 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint32);
1605
1606 msg.oneofSint64 = 6;
1607 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint64);
1608 XCTAssertEqual(msg.oneofInt32, 0);
1609 XCTAssertEqual(msg.oneofInt64, 0);
1610 XCTAssertEqual(msg.oneofUint32, 0U);
1611 XCTAssertEqual(msg.oneofUint64, 0U);
1612 XCTAssertEqual(msg.oneofSint32, 0);
1613 XCTAssertEqual(msg.oneofSint64, 6);
1614 XCTAssertEqual(msg.oneofFixed32, 0U);
1615 XCTAssertEqual(msg.oneofFixed64, 0U);
1616 XCTAssertEqual(msg.oneofSfixed32, 0);
1617 XCTAssertEqual(msg.oneofSfixed64, 0);
1618 XCTAssertEqual(msg.oneofFloat, 0.0f);
1619 XCTAssertEqual(msg.oneofDouble, 0.0);
1620 XCTAssertEqual(msg.oneofBool, NO);
1621 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1622 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1623 XCTAssertNotNil(msg.oneofMessage);
1624 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1625 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSint64);
1626
1627 msg.oneofFixed32 = 7;
1628 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed32);
1629 XCTAssertEqual(msg.oneofInt32, 0);
1630 XCTAssertEqual(msg.oneofInt64, 0);
1631 XCTAssertEqual(msg.oneofUint32, 0U);
1632 XCTAssertEqual(msg.oneofUint64, 0U);
1633 XCTAssertEqual(msg.oneofSint32, 0);
1634 XCTAssertEqual(msg.oneofSint64, 0);
1635 XCTAssertEqual(msg.oneofFixed32, 7U);
1636 XCTAssertEqual(msg.oneofFixed64, 0U);
1637 XCTAssertEqual(msg.oneofSfixed32, 0);
1638 XCTAssertEqual(msg.oneofSfixed64, 0);
1639 XCTAssertEqual(msg.oneofFloat, 0.0f);
1640 XCTAssertEqual(msg.oneofDouble, 0.0);
1641 XCTAssertEqual(msg.oneofBool, NO);
1642 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1643 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1644 XCTAssertNotNil(msg.oneofMessage);
1645 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1646 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed32);
1647
1648 msg.oneofFixed64 = 8;
1649 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed64);
1650 XCTAssertEqual(msg.oneofInt32, 0);
1651 XCTAssertEqual(msg.oneofInt64, 0);
1652 XCTAssertEqual(msg.oneofUint32, 0U);
1653 XCTAssertEqual(msg.oneofUint64, 0U);
1654 XCTAssertEqual(msg.oneofSint32, 0);
1655 XCTAssertEqual(msg.oneofSint64, 0);
1656 XCTAssertEqual(msg.oneofFixed32, 0U);
1657 XCTAssertEqual(msg.oneofFixed64, 8U);
1658 XCTAssertEqual(msg.oneofSfixed32, 0);
1659 XCTAssertEqual(msg.oneofSfixed64, 0);
1660 XCTAssertEqual(msg.oneofFloat, 0.0f);
1661 XCTAssertEqual(msg.oneofDouble, 0.0);
1662 XCTAssertEqual(msg.oneofBool, NO);
1663 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1664 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1665 XCTAssertNotNil(msg.oneofMessage);
1666 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1667 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFixed64);
1668
1669 msg.oneofSfixed32 = 9;
1670 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed32);
1671 XCTAssertEqual(msg.oneofInt32, 0);
1672 XCTAssertEqual(msg.oneofInt64, 0);
1673 XCTAssertEqual(msg.oneofUint32, 0U);
1674 XCTAssertEqual(msg.oneofUint64, 0U);
1675 XCTAssertEqual(msg.oneofSint32, 0);
1676 XCTAssertEqual(msg.oneofSint64, 0);
1677 XCTAssertEqual(msg.oneofFixed32, 0U);
1678 XCTAssertEqual(msg.oneofFixed64, 0U);
1679 XCTAssertEqual(msg.oneofSfixed32, 9);
1680 XCTAssertEqual(msg.oneofSfixed64, 0);
1681 XCTAssertEqual(msg.oneofFloat, 0.0f);
1682 XCTAssertEqual(msg.oneofDouble, 0.0);
1683 XCTAssertEqual(msg.oneofBool, NO);
1684 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1685 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1686 XCTAssertNotNil(msg.oneofMessage);
1687 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1688 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed32);
1689
1690 msg.oneofSfixed64 = 10;
1691 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed64);
1692 XCTAssertEqual(msg.oneofInt32, 0);
1693 XCTAssertEqual(msg.oneofInt64, 0);
1694 XCTAssertEqual(msg.oneofUint32, 0U);
1695 XCTAssertEqual(msg.oneofUint64, 0U);
1696 XCTAssertEqual(msg.oneofSint32, 0);
1697 XCTAssertEqual(msg.oneofSint64, 0);
1698 XCTAssertEqual(msg.oneofFixed32, 0U);
1699 XCTAssertEqual(msg.oneofFixed64, 0U);
1700 XCTAssertEqual(msg.oneofSfixed32, 0);
1701 XCTAssertEqual(msg.oneofSfixed64, 10);
1702 XCTAssertEqual(msg.oneofFloat, 0.0f);
1703 XCTAssertEqual(msg.oneofDouble, 0.0);
1704 XCTAssertEqual(msg.oneofBool, NO);
1705 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1706 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1707 XCTAssertNotNil(msg.oneofMessage);
1708 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1709 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofSfixed64);
1710
1711 msg.oneofFloat = 11.0f;
1712 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFloat);
1713 XCTAssertEqual(msg.oneofInt32, 0);
1714 XCTAssertEqual(msg.oneofInt64, 0);
1715 XCTAssertEqual(msg.oneofUint32, 0U);
1716 XCTAssertEqual(msg.oneofUint64, 0U);
1717 XCTAssertEqual(msg.oneofSint32, 0);
1718 XCTAssertEqual(msg.oneofSint64, 0);
1719 XCTAssertEqual(msg.oneofFixed32, 0U);
1720 XCTAssertEqual(msg.oneofFixed64, 0U);
1721 XCTAssertEqual(msg.oneofSfixed32, 0);
1722 XCTAssertEqual(msg.oneofSfixed64, 0);
1723 XCTAssertEqual(msg.oneofFloat, 11.0f);
1724 XCTAssertEqual(msg.oneofDouble, 0.0);
1725 XCTAssertEqual(msg.oneofBool, NO);
1726 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1727 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1728 XCTAssertNotNil(msg.oneofMessage);
1729 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1730 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofFloat);
1731
1732 msg.oneofDouble = 12.0;
1733 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofDouble);
1734 XCTAssertEqual(msg.oneofInt32, 0);
1735 XCTAssertEqual(msg.oneofInt64, 0);
1736 XCTAssertEqual(msg.oneofUint32, 0U);
1737 XCTAssertEqual(msg.oneofUint64, 0U);
1738 XCTAssertEqual(msg.oneofSint32, 0);
1739 XCTAssertEqual(msg.oneofSint64, 0);
1740 XCTAssertEqual(msg.oneofFixed32, 0U);
1741 XCTAssertEqual(msg.oneofFixed64, 0U);
1742 XCTAssertEqual(msg.oneofSfixed32, 0);
1743 XCTAssertEqual(msg.oneofSfixed64, 0);
1744 XCTAssertEqual(msg.oneofFloat, 0.0f);
1745 XCTAssertEqual(msg.oneofDouble, 12.0);
1746 XCTAssertEqual(msg.oneofBool, NO);
1747 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1748 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1749 XCTAssertNotNil(msg.oneofMessage);
1750 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1751 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofDouble);
1752
1753 msg.oneofBool = YES;
1754 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBool);
1755 XCTAssertEqual(msg.oneofInt32, 0);
1756 XCTAssertEqual(msg.oneofInt64, 0);
1757 XCTAssertEqual(msg.oneofUint32, 0U);
1758 XCTAssertEqual(msg.oneofUint64, 0U);
1759 XCTAssertEqual(msg.oneofSint32, 0);
1760 XCTAssertEqual(msg.oneofSint64, 0);
1761 XCTAssertEqual(msg.oneofFixed32, 0U);
1762 XCTAssertEqual(msg.oneofFixed64, 0U);
1763 XCTAssertEqual(msg.oneofSfixed32, 0);
1764 XCTAssertEqual(msg.oneofSfixed64, 0);
1765 XCTAssertEqual(msg.oneofFloat, 0.0f);
1766 XCTAssertEqual(msg.oneofDouble, 0.0);
1767 XCTAssertEqual(msg.oneofBool, YES);
1768 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1769 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1770 XCTAssertNotNil(msg.oneofMessage);
1771 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1772 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBool);
1773
1774 msg.oneofString = @"foo";
1775 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofString);
1776 XCTAssertEqual(msg.oneofInt32, 0);
1777 XCTAssertEqual(msg.oneofInt64, 0);
1778 XCTAssertEqual(msg.oneofUint32, 0U);
1779 XCTAssertEqual(msg.oneofUint64, 0U);
1780 XCTAssertEqual(msg.oneofSint32, 0);
1781 XCTAssertEqual(msg.oneofSint64, 0);
1782 XCTAssertEqual(msg.oneofFixed32, 0U);
1783 XCTAssertEqual(msg.oneofFixed64, 0U);
1784 XCTAssertEqual(msg.oneofSfixed32, 0);
1785 XCTAssertEqual(msg.oneofSfixed64, 0);
1786 XCTAssertEqual(msg.oneofFloat, 0.0f);
1787 XCTAssertEqual(msg.oneofDouble, 0.0);
1788 XCTAssertEqual(msg.oneofBool, NO);
1789 XCTAssertEqualObjects(msg.oneofString, @"foo");
1790 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1791 XCTAssertNotNil(msg.oneofMessage);
1792 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1793 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofString);
1794
1795 msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding];
1796 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBytes);
1797 XCTAssertEqual(msg.oneofInt32, 0);
1798 XCTAssertEqual(msg.oneofInt64, 0);
1799 XCTAssertEqual(msg.oneofUint32, 0U);
1800 XCTAssertEqual(msg.oneofUint64, 0U);
1801 XCTAssertEqual(msg.oneofSint32, 0);
1802 XCTAssertEqual(msg.oneofSint64, 0);
1803 XCTAssertEqual(msg.oneofFixed32, 0U);
1804 XCTAssertEqual(msg.oneofFixed64, 0U);
1805 XCTAssertEqual(msg.oneofSfixed32, 0);
1806 XCTAssertEqual(msg.oneofSfixed64, 0);
1807 XCTAssertEqual(msg.oneofFloat, 0.0f);
1808 XCTAssertEqual(msg.oneofDouble, 0.0);
1809 XCTAssertEqual(msg.oneofBool, NO);
1810 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1811 XCTAssertEqualObjects(msg.oneofBytes,
1812 [@"bar" dataUsingEncoding:NSUTF8StringEncoding]);
1813 XCTAssertNotNil(msg.oneofMessage);
1814 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1815 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofBytes);
1816
1817 Message3 *subMessage = [Message3 message];
1818 msg.oneofMessage = subMessage;
1819 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofMessage);
1820 XCTAssertEqual(msg.oneofInt32, 0);
1821 XCTAssertEqual(msg.oneofInt64, 0);
1822 XCTAssertEqual(msg.oneofUint32, 0U);
1823 XCTAssertEqual(msg.oneofUint64, 0U);
1824 XCTAssertEqual(msg.oneofSint32, 0);
1825 XCTAssertEqual(msg.oneofSint64, 0);
1826 XCTAssertEqual(msg.oneofFixed32, 0U);
1827 XCTAssertEqual(msg.oneofFixed64, 0U);
1828 XCTAssertEqual(msg.oneofSfixed32, 0);
1829 XCTAssertEqual(msg.oneofSfixed64, 0);
1830 XCTAssertEqual(msg.oneofFloat, 0.0f);
1831 XCTAssertEqual(msg.oneofDouble, 0.0);
1832 XCTAssertEqual(msg.oneofBool, NO);
1833 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1834 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1835 XCTAssertEqual(msg.oneofMessage, subMessage); // Pointer compare.
1836 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo);
1837 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofMessage);
1838
1839 msg.oneofEnum = Message3_Enum_Bar;
1840 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofEnum);
1841 XCTAssertEqual(msg.oneofInt32, 0);
1842 XCTAssertEqual(msg.oneofInt64, 0);
1843 XCTAssertEqual(msg.oneofUint32, 0U);
1844 XCTAssertEqual(msg.oneofUint64, 0U);
1845 XCTAssertEqual(msg.oneofSint32, 0);
1846 XCTAssertEqual(msg.oneofSint64, 0);
1847 XCTAssertEqual(msg.oneofFixed32, 0U);
1848 XCTAssertEqual(msg.oneofFixed64, 0U);
1849 XCTAssertEqual(msg.oneofSfixed32, 0);
1850 XCTAssertEqual(msg.oneofSfixed64, 0);
1851 XCTAssertEqual(msg.oneofFloat, 0.0f);
1852 XCTAssertEqual(msg.oneofDouble, 0.0);
1853 XCTAssertEqual(msg.oneofBool, NO);
1854 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault);
1855 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault);
1856 XCTAssertNotNil(msg.oneofMessage);
1857 XCTAssertNotEqual(msg.oneofMessage, subMessage); // Pointer compare.
1858 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Bar);
1859 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_OneofEnum);
1860
1861 // Test setting/calling clear clearing.
1862
1863 [msg release];
1864 msg = [[Message3 alloc] init];
1865
1866 uint32_t values[] = {
1867 Message3_O_OneOfCase_OneofInt32,
1868 Message3_O_OneOfCase_OneofInt64,
1869 Message3_O_OneOfCase_OneofUint32,
1870 Message3_O_OneOfCase_OneofUint64,
1871 Message3_O_OneOfCase_OneofSint32,
1872 Message3_O_OneOfCase_OneofSint64,
1873 Message3_O_OneOfCase_OneofFixed32,
1874 Message3_O_OneOfCase_OneofFixed64,
1875 Message3_O_OneOfCase_OneofSfixed32,
1876 Message3_O_OneOfCase_OneofSfixed64,
1877 Message3_O_OneOfCase_OneofFloat,
1878 Message3_O_OneOfCase_OneofDouble,
1879 Message3_O_OneOfCase_OneofBool,
1880 Message3_O_OneOfCase_OneofString,
1881 Message3_O_OneOfCase_OneofBytes,
1882 Message3_O_OneOfCase_OneofMessage,
1883 Message3_O_OneOfCase_OneofEnum,
1884 };
1885
1886 for (size_t i = 0; i < GPBARRAYSIZE(values); ++i) {
1887 switch (values[i]) {
1888 case Message3_O_OneOfCase_OneofInt32:
1889 msg.oneofInt32 = 1;
1890 break;
1891 case Message3_O_OneOfCase_OneofInt64:
1892 msg.oneofInt64 = 2;
1893 break;
1894 case Message3_O_OneOfCase_OneofUint32:
1895 msg.oneofUint32 = 3;
1896 break;
1897 case Message3_O_OneOfCase_OneofUint64:
1898 msg.oneofUint64 = 4;
1899 break;
1900 case Message3_O_OneOfCase_OneofSint32:
1901 msg.oneofSint32 = 5;
1902 break;
1903 case Message3_O_OneOfCase_OneofSint64:
1904 msg.oneofSint64 = 6;
1905 break;
1906 case Message3_O_OneOfCase_OneofFixed32:
1907 msg.oneofFixed32 = 7;
1908 break;
1909 case Message3_O_OneOfCase_OneofFixed64:
1910 msg.oneofFixed64 = 8;
1911 break;
1912 case Message3_O_OneOfCase_OneofSfixed32:
1913 msg.oneofSfixed32 = 9;
1914 break;
1915 case Message3_O_OneOfCase_OneofSfixed64:
1916 msg.oneofSfixed64 = 10;
1917 break;
1918 case Message3_O_OneOfCase_OneofFloat:
1919 msg.oneofFloat = 11.0f;
1920 break;
1921 case Message3_O_OneOfCase_OneofDouble:
1922 msg.oneofDouble = 12.0;
1923 break;
1924 case Message3_O_OneOfCase_OneofBool:
1925 msg.oneofBool = YES;
1926 break;
1927 case Message3_O_OneOfCase_OneofString:
1928 msg.oneofString = @"foo";
1929 break;
1930 case Message3_O_OneOfCase_OneofBytes:
1931 msg.oneofBytes = [@"bar" dataUsingEncoding:NSUTF8StringEncoding];
1932 break;
1933 case Message3_O_OneOfCase_OneofMessage:
1934 msg.oneofMessage = subMessage;
1935 break;
1936 case Message3_O_OneOfCase_OneofEnum:
1937 msg.oneofEnum = Message3_Enum_Baz;
1938 break;
1939 default:
1940 XCTFail(@"shouldn't happen, loop: %zd, value: %d", i, values[i]);
1941 break;
1942 }
1943
1944 XCTAssertEqual(msg.oOneOfCase, values[i], "Loop: %zd", i);
1945 // No need to check the value was set, the above tests did that.
1946 Message3_ClearOOneOfCase(msg);
1947 // Nothing in the case.
1948 XCTAssertEqual(msg.oOneOfCase, Message3_O_OneOfCase_GPBUnsetOneOfCase,
1949 "Loop: %zd", i);
1950 // Confirm everything is back to defaults after a clear.
1951 XCTAssertEqual(msg.oneofInt32, 0, "Loop: %zd", i);
1952 XCTAssertEqual(msg.oneofInt64, 0, "Loop: %zd", i);
1953 XCTAssertEqual(msg.oneofUint32, 0U, "Loop: %zd", i);
1954 XCTAssertEqual(msg.oneofUint64, 0U, "Loop: %zd", i);
1955 XCTAssertEqual(msg.oneofSint32, 0, "Loop: %zd", i);
1956 XCTAssertEqual(msg.oneofSint64, 0, "Loop: %zd", i);
1957 XCTAssertEqual(msg.oneofFixed32, 0U, "Loop: %zd", i);
1958 XCTAssertEqual(msg.oneofFixed64, 0U, "Loop: %zd", i);
1959 XCTAssertEqual(msg.oneofSfixed32, 0, "Loop: %zd", i);
1960 XCTAssertEqual(msg.oneofSfixed64, 0, "Loop: %zd", i);
1961 XCTAssertEqual(msg.oneofFloat, 0.0f, "Loop: %zd", i);
1962 XCTAssertEqual(msg.oneofDouble, 0.0, "Loop: %zd", i);
1963 XCTAssertEqual(msg.oneofBool, NO, "Loop: %zd", i);
1964 XCTAssertEqualObjects(msg.oneofString, oneofStringDefault, "Loop: %zd", i);
1965 XCTAssertEqualObjects(msg.oneofBytes, oneofBytesDefault, "Loop: %zd", i);
1966 XCTAssertNotNil(msg.oneofMessage, "Loop: %zd", i);
1967 XCTAssertNotEqual(msg.oneofMessage, subMessage, "Loop: %zd",
1968 i); // Pointer compare.
1969 XCTAssertEqual(msg.oneofEnum, Message3_Enum_Foo, "Loop: %zd", i);
1970 }
1971
1972 [msg release];
1973 }
1974
1975 - (void)testCopyingMakesUniqueObjects {
1976 const int repeatCount = 5;
1977 TestAllTypes *msg1 = [TestAllTypes message];
1978 [self setAllFields:msg1 repeatedCount:repeatCount];
1979
1980 TestAllTypes *msg2 = [[msg1 copy] autorelease];
1981
1982 XCTAssertNotEqual(msg1, msg2); // Ptr compare, new object.
1983 XCTAssertEqualObjects(msg1, msg2); // Equal values.
1984
1985 // Pointer comparisions, different objects.
1986
1987 XCTAssertNotEqual(msg1.optionalGroup, msg2.optionalGroup);
1988 XCTAssertNotEqual(msg1.optionalNestedMessage, msg2.optionalNestedMessage);
1989 XCTAssertNotEqual(msg1.optionalForeignMessage, msg2.optionalForeignMessage);
1990 XCTAssertNotEqual(msg1.optionalImportMessage, msg2.optionalImportMessage);
1991
1992 XCTAssertNotEqual(msg1.repeatedInt32Array, msg2.repeatedInt32Array);
1993 XCTAssertNotEqual(msg1.repeatedInt64Array, msg2.repeatedInt64Array);
1994 XCTAssertNotEqual(msg1.repeatedUint32Array, msg2.repeatedUint32Array);
1995 XCTAssertNotEqual(msg1.repeatedUint64Array, msg2.repeatedUint64Array);
1996 XCTAssertNotEqual(msg1.repeatedSint32Array, msg2.repeatedSint32Array);
1997 XCTAssertNotEqual(msg1.repeatedSint64Array, msg2.repeatedSint64Array);
1998 XCTAssertNotEqual(msg1.repeatedFixed32Array, msg2.repeatedFixed32Array);
1999 XCTAssertNotEqual(msg1.repeatedFixed64Array, msg2.repeatedFixed64Array);
2000 XCTAssertNotEqual(msg1.repeatedSfixed32Array, msg2.repeatedSfixed32Array);
2001 XCTAssertNotEqual(msg1.repeatedSfixed64Array, msg2.repeatedSfixed64Array);
2002 XCTAssertNotEqual(msg1.repeatedFloatArray, msg2.repeatedFloatArray);
2003 XCTAssertNotEqual(msg1.repeatedDoubleArray, msg2.repeatedDoubleArray);
2004 XCTAssertNotEqual(msg1.repeatedBoolArray, msg2.repeatedBoolArray);
2005 XCTAssertNotEqual(msg1.repeatedStringArray, msg2.repeatedStringArray);
2006 XCTAssertNotEqual(msg1.repeatedBytesArray, msg2.repeatedBytesArray);
2007 XCTAssertNotEqual(msg1.repeatedGroupArray, msg2.repeatedGroupArray);
2008 XCTAssertNotEqual(msg1.repeatedNestedMessageArray,
2009 msg2.repeatedNestedMessageArray);
2010 XCTAssertNotEqual(msg1.repeatedForeignMessageArray,
2011 msg2.repeatedForeignMessageArray);
2012 XCTAssertNotEqual(msg1.repeatedImportMessageArray,
2013 msg2.repeatedImportMessageArray);
2014 XCTAssertNotEqual(msg1.repeatedNestedEnumArray, msg2.repeatedNestedEnumArray);
2015 XCTAssertNotEqual(msg1.repeatedForeignEnumArray,
2016 msg2.repeatedForeignEnumArray);
2017 XCTAssertNotEqual(msg1.repeatedImportEnumArray, msg2.repeatedImportEnumArray);
2018 XCTAssertNotEqual(msg1.repeatedStringPieceArray,
2019 msg2.repeatedStringPieceArray);
2020 XCTAssertNotEqual(msg1.repeatedCordArray, msg2.repeatedCordArray);
2021
2022 for (int i = 0; i < repeatCount; i++) {
2023 XCTAssertNotEqual(msg1.repeatedNestedMessageArray[i],
2024 msg2.repeatedNestedMessageArray[i]);
2025 XCTAssertNotEqual(msg1.repeatedForeignMessageArray[i],
2026 msg2.repeatedForeignMessageArray[i]);
2027 XCTAssertNotEqual(msg1.repeatedImportMessageArray[i],
2028 msg2.repeatedImportMessageArray[i]);
2029 }
2030 }
2031
2032 - (void)testCopyingMapsMakesUniqueObjects {
2033 TestMap *msg1 = [TestMap message];
2034 [self setAllMapFields:msg1 numEntries:5];
2035
2036 TestMap *msg2 = [[msg1 copy] autorelease];
2037
2038 XCTAssertNotEqual(msg1, msg2); // Ptr compare, new object.
2039 XCTAssertEqualObjects(msg1, msg2); // Equal values.
2040
2041 // Pointer comparisions, different objects.
2042 XCTAssertNotEqual(msg1.mapInt32Int32, msg2.mapInt32Int32);
2043 XCTAssertNotEqual(msg1.mapInt64Int64, msg2.mapInt64Int64);
2044 XCTAssertNotEqual(msg1.mapUint32Uint32, msg2.mapUint32Uint32);
2045 XCTAssertNotEqual(msg1.mapUint64Uint64, msg2.mapUint64Uint64);
2046 XCTAssertNotEqual(msg1.mapSint32Sint32, msg2.mapSint32Sint32);
2047 XCTAssertNotEqual(msg1.mapSint64Sint64, msg2.mapSint64Sint64);
2048 XCTAssertNotEqual(msg1.mapFixed32Fixed32, msg2.mapFixed32Fixed32);
2049 XCTAssertNotEqual(msg1.mapFixed64Fixed64, msg2.mapFixed64Fixed64);
2050 XCTAssertNotEqual(msg1.mapSfixed32Sfixed32, msg2.mapSfixed32Sfixed32);
2051 XCTAssertNotEqual(msg1.mapSfixed64Sfixed64, msg2.mapSfixed64Sfixed64);
2052 XCTAssertNotEqual(msg1.mapInt32Float, msg2.mapInt32Float);
2053 XCTAssertNotEqual(msg1.mapInt32Double, msg2.mapInt32Double);
2054 XCTAssertNotEqual(msg1.mapBoolBool, msg2.mapBoolBool);
2055 XCTAssertNotEqual(msg1.mapStringString, msg2.mapStringString);
2056 XCTAssertNotEqual(msg1.mapInt32Bytes, msg2.mapInt32Bytes);
2057 XCTAssertNotEqual(msg1.mapInt32Enum, msg2.mapInt32Enum);
2058 XCTAssertNotEqual(msg1.mapInt32ForeignMessage, msg2.mapInt32ForeignMessage);
2059
2060 // Ensure the messages are unique per map.
2061 [msg1.mapInt32ForeignMessage
2062 enumerateKeysAndValuesUsingBlock:^(int32_t key, id value, BOOL *stop) {
2063 #pragma unused(stop)
2064 ForeignMessage *subMsg2 = [msg2.mapInt32ForeignMessage valueForKey:key];
2065 XCTAssertNotEqual(value, subMsg2); // Ptr compare, new object.
2066 }];
2067 }
2068
2069 #pragma mark - Subset from from map_tests.cc
2070
2071 // TEST(GeneratedMapFieldTest, IsInitialized)
2072 - (void)testMap_IsInitialized {
2073 TestRequiredMessageMap *msg = [[TestRequiredMessageMap alloc] init];
2074
2075 // Add an uninitialized message.
2076 TestRequired *subMsg = [[TestRequired alloc] init];
2077 msg.mapField = [GPBInt32ObjectDictionary dictionary];
2078 [msg.mapField setValue:subMsg forKey:0];
2079 XCTAssertFalse(msg.initialized);
2080
2081 // Initialize uninitialized message
2082 subMsg.a = 0;
2083 subMsg.b = 0;
2084 subMsg.c = 0;
2085 XCTAssertTrue(msg.initialized);
2086
2087 [subMsg release];
2088 [msg release];
2089 }
2090
2091 @end
OLDNEW
« no previous file with comments | « third_party/protobuf/objectivec/Tests/GPBMessageTests+Merge.m ('k') | third_party/protobuf/objectivec/Tests/GPBMessageTests+Serialization.m » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698