Debian Codegraph @

closure-library/closure/goog/proto2/message_test.js

raw
1 // Copyright 2010 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 goog.provide('goog.proto2.MessageTest');
16 goog.setTestOnly('goog.proto2.MessageTest');
17
18 goog.require('goog.testing.TestCase');
19 goog.require('goog.testing.jsunit');
20 goog.require('proto2.TestAllTypes');
21 goog.require('proto2.TestAllTypes.NestedEnum');
22 goog.require('proto2.TestAllTypes.NestedMessage');
23 goog.require('proto2.TestAllTypes.OptionalGroup');
24 goog.require('proto2.TestAllTypes.RepeatedGroup');
25
26 function setUp() {
27 // TODO(b/25875505): Fix unreported assertions (go/failonunreportedasserts).
28 goog.testing.TestCase.getActiveTestCase().failOnUnreportedAsserts = false;
29 }
30
31 function testEqualsWithEmptyMessages() {
32 var message1 = new proto2.TestAllTypes();
33 assertTrue('same message object', message1.equals(message1));
34 assertFalse('comparison with null', message1.equals(null));
35 assertFalse('comparison with undefined', message1.equals(undefined));
36
37 var message2 = new proto2.TestAllTypes();
38 assertTrue('two empty message objects', message1.equals(message2));
39
40 var message3 = new proto2.TestAllTypes.NestedMessage();
41 assertFalse('different message types', message3.equals(message1));
42 }
43
44 function testEqualsWithSingleInt32Field() {
45 var message1 = new proto2.TestAllTypes();
46 var message2 = new proto2.TestAllTypes();
47
48 message1.setOptionalInt32(1);
49 assertFalse('message1 has an extra int32 field', message1.equals(message2));
50
51 message2.setOptionalInt32(1);
52 assertTrue('same int32 field in both messages', message1.equals(message2));
53
54 message2.setOptionalInt32(2);
55 assertFalse('different int32 field', message1.equals(message2));
56
57 message1.clearOptionalInt32();
58 assertFalse('message2 has an extra int32 field', message1.equals(message2));
59 }
60
61 function testEqualsWithRepeatedInt32Fields() {
62 var message1 = new proto2.TestAllTypes();
63 var message2 = new proto2.TestAllTypes();
64
65 message1.addRepeatedInt32(0);
66 message2.addRepeatedInt32(0);
67 assertTrue('equal repeated int32 field', message1.equals(message2));
68
69 message1.addRepeatedInt32(1);
70 assertFalse('message1 has more items', message1.equals(message2));
71
72 message2.addRepeatedInt32(1);
73 message2.addRepeatedInt32(1);
74 assertFalse('message2 has more items', message1.equals(message2));
75
76 message1.addRepeatedInt32(2);
77 assertFalse('different int32 items', message1.equals(message2));
78 }
79
80 function testEqualsWithDefaultValue() {
81 var message1 = new proto2.TestAllTypes();
82 var message2 = new proto2.TestAllTypes();
83 message1.setOptionalInt64('1');
84
85 assertEquals(
86 'message1.getOptionalInt64OrDefault should return 1', '1',
87 message1.getOptionalInt64OrDefault());
88 assertEquals(
89 'message2.getOptionalInt64OrDefault should return 1 too', '1',
90 message2.getOptionalInt64OrDefault());
91 assertTrue(
92 'message1.hasOptionalInt64() should be true',
93 message1.hasOptionalInt64());
94 assertFalse(
95 'message2.hasOptionalInt64() should be false',
96 message2.hasOptionalInt64());
97 assertFalse('as a result they are not equal', message1.equals(message2));
98 }
99
100 function testEqualsWithOptionalGroup() {
101 var message1 = new proto2.TestAllTypes();
102 var message2 = new proto2.TestAllTypes();
103 var group1 = new proto2.TestAllTypes.OptionalGroup();
104 var group2 = new proto2.TestAllTypes.OptionalGroup();
105
106 message1.setOptionalgroup(group1);
107 assertFalse(
108 'only message1 has OptionalGroup field', message1.equals(message2));
109
110 message2.setOptionalgroup(group2);
111 assertTrue(
112 'both messages have OptionalGroup field', message1.equals(message2));
113
114 group1.setA(0);
115 group2.setA(1);
116 assertFalse(
117 'different value in the optional group', message1.equals(message2));
118
119 message1.clearOptionalgroup();
120 assertFalse(
121 'only message2 has OptionalGroup field', message1.equals(message2));
122 }
123
124 function testEqualsWithRepeatedGroup() {
125 var message1 = new proto2.TestAllTypes();
126 var message2 = new proto2.TestAllTypes();
127 var group1 = new proto2.TestAllTypes.RepeatedGroup();
128 var group2 = new proto2.TestAllTypes.RepeatedGroup();
129
130 message1.addRepeatedgroup(group1);
131 assertFalse('message1 has more RepeatedGroups', message1.equals(message2));
132
133 message2.addRepeatedgroup(group2);
134 assertTrue('both messages have one RepeatedGroup', message1.equals(message2));
135
136 group1.addA(1);
137 assertFalse(
138 'message1 has more int32s in RepeatedGroup', message1.equals(message2));
139
140 group2.addA(1);
141 assertTrue(
142 'both messages have one int32 in RepeatedGroup',
143 message1.equals(message2));
144
145 group1.addA(1);
146 group2.addA(2);
147 assertFalse(
148 'the messages have different int32s in RepeatedGroup',
149 message1.equals(message2));
150 }
151
152 function testEqualsWithNestedMessage() {
153 var message1 = new proto2.TestAllTypes();
154 var message2 = new proto2.TestAllTypes();
155 var nested1 = new proto2.TestAllTypes.NestedMessage();
156 var nested2 = new proto2.TestAllTypes.NestedMessage();
157
158 message1.setOptionalNestedMessage(nested1);
159 assertFalse('only message1 has nested message', message1.equals(message2));
160
161 message2.setOptionalNestedMessage(nested2);
162 assertTrue('both messages have nested message', message1.equals(message2));
163
164 nested1.setB(1);
165 assertFalse(
166 'different int32 in the nested messages', message1.equals(message2));
167
168 message1.clearOptionalNestedMessage();
169 assertFalse('only message2 has nested message', message1.equals(message2));
170 }
171
172 function testEqualsWithNestedEnum() {
173 var message1 = new proto2.TestAllTypes();
174 var message2 = new proto2.TestAllTypes();
175
176 message1.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
177 assertFalse('only message1 has nested enum', message1.equals(message2));
178
179 message2.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
180 assertTrue('both messages have nested enum', message1.equals(message2));
181
182 message2.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.BAR);
183 assertFalse('different enum value', message1.equals(message2));
184
185 message1.clearOptionalNestedEnum();
186 assertFalse('only message2 has nested enum', message1.equals(message2));
187 }
188
189 function testEqualsWithUnknownFields() {
190 var message1 = new proto2.TestAllTypes();
191 var message2 = new proto2.TestAllTypes();
192 message1.setUnknown(999, 'foo');
193 message1.setUnknown(999, 'bar');
194 assertTrue('unknown fields are ignored', message1.equals(message2));
195 }
196
197 function testCloneEmptyMessage() {
198 var message = new proto2.TestAllTypes();
199 var clone = message.clone();
200 assertObjectEquals('cloned empty message', message, clone);
201 }
202
203 function testCloneMessageWithSeveralFields() {
204 var message = new proto2.TestAllTypes();
205 message.setOptionalInt32(1);
206 message.addRepeatedInt32(2);
207 var optionalGroup = new proto2.TestAllTypes.OptionalGroup();
208 optionalGroup.setA(3);
209 message.setOptionalgroup(optionalGroup);
210 var repeatedGroup = new proto2.TestAllTypes.RepeatedGroup();
211 repeatedGroup.addA(4);
212 message.addRepeatedgroup(repeatedGroup);
213 var nestedMessage = new proto2.TestAllTypes.NestedMessage();
214 nestedMessage.setB(5);
215 message.setOptionalNestedMessage(nestedMessage);
216 message.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
217 message.setUnknown(999, 'foo');
218
219 var clone = message.clone();
220 assertNotEquals(
221 'different OptionalGroup instance', message.getOptionalgroup(),
222 clone.getOptionalgroup());
223 assertNotEquals(
224 'different RepeatedGroup array instance', message.repeatedgroupArray(),
225 clone.repeatedgroupArray());
226 assertNotEquals(
227 'different RepeatedGroup array item instance',
228 message.getRepeatedgroup(0), clone.getRepeatedgroup(0));
229 assertNotEquals(
230 'different NestedMessage instance', message.getOptionalNestedMessage(),
231 clone.getOptionalNestedMessage());
232 }
233
234 function testCloneWithUnknownFields() {
235 var message = new proto2.TestAllTypes();
236 message.setUnknown(999, 'foo');
237
238 var clone = message.clone();
239 assertTrue('clone.equals(message) returns true', clone.equals(message));
240 clone.forEachUnknown(function(tag, value) {
241 fail('the unknown fields should not have been cloned');
242 });
243
244 clone.setUnknown(999, 'foo');
245 assertObjectEquals(
246 'the original and the cloned message are equal except ' +
247 'for the unknown fields',
248 message, clone);
249 }
250
251 function testCopyFromSameMessage() {
252 var source = new proto2.TestAllTypes();
253 source.setOptionalInt32(32);
254 source.copyFrom(source);
255 assertEquals(32, source.getOptionalInt32());
256 }
257
258 function testCopyFromFlatMessage() {
259 // Recursive copying is implicitly tested in the testClone... methods.
260
261 var source = new proto2.TestAllTypes();
262 source.setOptionalInt32(32);
263 source.setOptionalInt64('64');
264 source.addRepeatedInt32(32);
265
266 var target = new proto2.TestAllTypes();
267 target.setOptionalInt32(33);
268 target.setOptionalUint32(33);
269 target.addRepeatedInt32(33);
270
271 target.copyFrom(source);
272 assertObjectEquals(
273 'source and target are equal after copyFrom', source, target);
274
275 target.copyFrom(source);
276 assertObjectEquals('second copyFrom call has no effect', source, target);
277
278 source.setUnknown(999, 'foo');
279 target.setUnknown(999, 'bar');
280 target.copyFrom(source);
281 assertThrows(
282 'unknown fields are not copied',
283 goog.partial(assertObjectEquals, source, target));
284 }
285
286 function testMergeFromEmptyMessage() {
287 var source = new proto2.TestAllTypes();
288 source.setOptionalInt32(32);
289 source.setOptionalInt64('64');
290 var nested = new proto2.TestAllTypes.NestedMessage();
291 nested.setB(66);
292 source.setOptionalNestedMessage(nested);
293
294 var target = new proto2.TestAllTypes();
295 target.mergeFrom(source);
296 assertObjectEquals(
297 'source and target are equal after mergeFrom', source, target);
298 }
299
300 function testMergeFromFlatMessage() {
301 var source = new proto2.TestAllTypes();
302 source.setOptionalInt32(32);
303 source.setOptionalString('foo');
304 source.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
305
306 var target = new proto2.TestAllTypes();
307 target.setOptionalInt64('64');
308 target.setOptionalString('bar');
309 target.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.BAR);
310
311 var expected = new proto2.TestAllTypes();
312 expected.setOptionalInt32(32);
313 expected.setOptionalInt64('64');
314 expected.setOptionalString('foo');
315 expected.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
316
317 target.mergeFrom(source);
318 assertObjectEquals(
319 'expected and target are equal after mergeFrom', expected, target);
320 }
321
322 function testMergeFromNestedMessage() {
323 var source = new proto2.TestAllTypes();
324 var nested = new proto2.TestAllTypes.NestedMessage();
325 nested.setB(66);
326 source.setOptionalNestedMessage(nested);
327
328 var target = new proto2.TestAllTypes();
329 nested = new proto2.TestAllTypes.NestedMessage();
330 nested.setC(77);
331 target.setOptionalNestedMessage(nested);
332
333 var expected = new proto2.TestAllTypes();
334 nested = new proto2.TestAllTypes.NestedMessage();
335 nested.setB(66);
336 nested.setC(77);
337 expected.setOptionalNestedMessage(nested);
338
339 target.mergeFrom(source);
340 assertObjectEquals(
341 'expected and target are equal after mergeFrom', expected, target);
342 }
343
344 function testMergeFromRepeatedMessage() {
345 var source = new proto2.TestAllTypes();
346 source.addRepeatedInt32(2);
347 source.addRepeatedInt32(3);
348
349 var target = new proto2.TestAllTypes();
350 target.addRepeatedInt32(1);
351
352 target.mergeFrom(source);
353 assertArrayEquals(
354 'repeated_int32 array has elements from both messages', [1, 2, 3],
355 target.repeatedInt32Array());
356 }
357
358 function testInitDefaultsWithEmptyMessage() {
359 var message = new proto2.TestAllTypes();
360 message.initDefaults(false);
361
362 assertFalse('int32 field is not set', message.hasOptionalInt32());
363 assertFalse('int64 [default=1] field is not set', message.hasOptionalInt64());
364 assertTrue('optional group field is set', message.hasOptionalgroup());
365 assertFalse(
366 'int32 inside the group is not set', message.getOptionalgroup().hasA());
367 assertObjectEquals(
368 'value of the optional group', new proto2.TestAllTypes.OptionalGroup(),
369 message.getOptionalgroup());
370 assertTrue('nested message is set', message.hasOptionalNestedMessage());
371 assertObjectEquals(
372 'value of the nested message', new proto2.TestAllTypes.NestedMessage(),
373 message.getOptionalNestedMessage());
374 assertFalse('nested enum is not set', message.hasOptionalNestedEnum());
375 assertFalse('repeated int32 is not set', message.hasRepeatedInt32());
376 assertFalse(
377 'repeated nested message is not set', message.hasRepeatedNestedMessage());
378
379 message = new proto2.TestAllTypes();
380 message.initDefaults(true);
381
382 assertTrue('int32 field is set', message.hasOptionalInt32());
383 assertEquals('value of the int32 field', 0, message.getOptionalInt32());
384 assertTrue('int64 [default=1] field is set', message.hasOptionalInt64());
385 assertEquals('value of the int64 field', '1', message.getOptionalInt64());
386 assertTrue(
387 'int32 inside nested message is set',
388 message.getOptionalNestedMessage().hasB());
389 assertEquals(
390 'value of the int32 field inside the nested message', 0,
391 message.getOptionalNestedMessage().getB());
392 }
393
394 function testInitDefaultsWithNonEmptyMessage() {
395 var message = new proto2.TestAllTypes();
396 message.setOptionalInt32(32);
397 message.setOptionalInt64('64');
398 message.setOptionalgroup(new proto2.TestAllTypes.OptionalGroup());
399 var nested1 = new proto2.TestAllTypes.NestedMessage();
400 nested1.setB(66);
401 message.setOptionalNestedMessage(nested1);
402 var nested2 = new proto2.TestAllTypes.NestedMessage();
403 message.addRepeatedNestedMessage(nested2);
404 var nested3 = new proto2.TestAllTypes.NestedMessage();
405 nested3.setB(66);
406 message.addRepeatedNestedMessage(nested3);
407
408 message.initDefaults(true);
409 assertEquals('int32 field is unchanged', 32, message.getOptionalInt32());
410 assertEquals(
411 'int64 [default=1] field is unchanged', '64', message.getOptionalInt64());
412 assertTrue('bool field is initialized', message.hasOptionalBool());
413 assertFalse('value of the bool field', message.getOptionalBool());
414 assertTrue(
415 'int32 inside the optional group is initialized',
416 message.getOptionalgroup().hasA());
417 assertEquals(
418 'value of the int32 inside the optional group', 0,
419 message.getOptionalgroup().getA());
420 assertEquals(
421 'int32 inside nested message is unchanged', 66,
422 message.getOptionalNestedMessage().getB());
423 assertTrue(
424 'int32 at index 0 of the repeated nested message is initialized',
425 message.getRepeatedNestedMessage(0).hasB());
426 assertEquals(
427 'value of int32 at index 0 of the repeated nested message', 0,
428 message.getRepeatedNestedMessage(0).getB());
429 assertEquals(
430 'int32 at index 1 of the repeated nested message is unchanged', 66,
431 message.getRepeatedNestedMessage(1).getB());
432 }
433
434 function testInitDefaultsTwice() {
435 var message = new proto2.TestAllTypes();
436 message.initDefaults(false);
437 var clone = message.clone();
438 clone.initDefaults(false);
439 assertObjectEquals(
440 'second call of initDefaults(false) has no effect', message, clone);
441
442 message = new proto2.TestAllTypes();
443 message.initDefaults(true);
444 clone = message.clone();
445 clone.initDefaults(true);
446 assertObjectEquals(
447 'second call of initDefaults(true) has no effect', message, clone);
448 }
449
450 function testInitDefaultsThenClone() {
451 var message = new proto2.TestAllTypes();
452 message.initDefaults(true);
453 assertObjectEquals('message is cloned properly', message, message.clone());
454 }
455
456 function testClassGetDescriptorEqualToInstanceGetDescriptor() {
457 var classDescriptor = proto2.TestAllTypes.getDescriptor();
458 var instanceDescriptor = new proto2.TestAllTypes().getDescriptor();
459 assertEquals(classDescriptor, instanceDescriptor);
460 }
461
462 function testGetAfterSetWithLazyDeserializer() {
463 // Test makes sure that the lazy deserializer for a field is not
464 // erroneously called when get$Value is called after set$Value.
465 var message = new proto2.TestAllTypes();
466
467 var fakeDeserializer = {}; // stub with no methods defined; fails hard
468 message.initializeForLazyDeserializer(fakeDeserializer, {} /* data */);
469 message.setOptionalBool(true);
470 assertEquals(true, message.getOptionalBool());
471 }
472
473 function testHasOnLazyDeserializer() {
474 // Test that null values for fields are treated as absent by the lazy
475 // deserializer.
476 var message = new proto2.TestAllTypes();
477
478 var fakeDeserializer = {}; // stub with no methods defined; fails hard
479 message.initializeForLazyDeserializer(
480 fakeDeserializer, {13: false} /* data */);
481 assertEquals(true, message.hasOptionalBool());
482 }
483
484 function testHasOnLazyDeserializerWithNulls() {
485 // Test that null values for fields are treated as absent by the lazy
486 // deserializer.
487 var message = new proto2.TestAllTypes();
488
489 var fakeDeserializer = {}; // stub with no methods defined; fails hard
490 message.initializeForLazyDeserializer(
491 fakeDeserializer, {13: null} /* data */);
492 assertEquals(false, message.hasOptionalBool());
493 }