Debian Codegraph @

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

raw
1 // Copyright 2008 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.ObjectSerializerTest');
16 goog.setTestOnly('goog.proto2.ObjectSerializerTest');
17
18 goog.require('goog.proto2.ObjectSerializer');
19 goog.require('goog.proto2.Serializer');
20 goog.require('goog.testing.PropertyReplacer');
21 goog.require('goog.testing.jsunit');
22 goog.require('proto2.TestAllTypes');
23
24 var propertyReplacer = new goog.testing.PropertyReplacer();
25
26 function tearDown() {
27 propertyReplacer.reset();
28 }
29
30 function testSerialization() {
31 var message = new proto2.TestAllTypes();
32
33 // Set the fields.
34 // Singular.
35 message.setOptionalInt32(101);
36 message.setOptionalInt64('102');
37 message.setOptionalUint32(103);
38 message.setOptionalUint64('104');
39 message.setOptionalSint32(105);
40 message.setOptionalSint64('106');
41 message.setOptionalFixed32(107);
42 message.setOptionalFixed64('108');
43 message.setOptionalSfixed32(109);
44 message.setOptionalSfixed64('110');
45 message.setOptionalFloat(111.5);
46 message.setOptionalDouble(112.5);
47 message.setOptionalBool(true);
48 message.setOptionalString('test');
49 message.setOptionalBytes('abcd');
50
51 var group = new proto2.TestAllTypes.OptionalGroup();
52 group.setA(111);
53
54 message.setOptionalgroup(group);
55
56 var nestedMessage = new proto2.TestAllTypes.NestedMessage();
57 nestedMessage.setB(112);
58
59 message.setOptionalNestedMessage(nestedMessage);
60
61 message.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
62
63 // Repeated.
64 message.addRepeatedInt32(201);
65 message.addRepeatedInt32(202);
66
67 // Serialize to a simplified object.
68 var simplified = new goog.proto2.ObjectSerializer().serialize(message);
69
70 // Assert that everything serialized properly.
71 assertEquals(101, simplified[1]);
72 assertEquals('102', simplified[2]);
73 assertEquals(103, simplified[3]);
74 assertEquals('104', simplified[4]);
75 assertEquals(105, simplified[5]);
76 assertEquals('106', simplified[6]);
77 assertEquals(107, simplified[7]);
78 assertEquals('108', simplified[8]);
79 assertEquals(109, simplified[9]);
80 assertEquals('110', simplified[10]);
81 assertEquals(111.5, simplified[11]);
82 assertEquals(112.5, simplified[12]);
83 assertEquals(true, simplified[13]);
84 assertEquals('test', simplified[14]);
85 assertEquals('abcd', simplified[15]);
86
87 assertEquals(111, simplified[16][17]);
88 assertEquals(112, simplified[18][1]);
89 assertEquals(proto2.TestAllTypes.NestedEnum.FOO, simplified[21]);
90
91 assertEquals(201, simplified[31][0]);
92 assertEquals(202, simplified[31][1]);
93
94 // Serialize to a simplified object (with key as name).
95 simplified =
96 new goog.proto2
97 .ObjectSerializer(goog.proto2.ObjectSerializer.KeyOption.NAME)
98 .serialize(message);
99
100 // Assert that everything serialized properly.
101 assertEquals(101, simplified['optional_int32']);
102 assertEquals('102', simplified['optional_int64']);
103 assertEquals(103, simplified['optional_uint32']);
104 assertEquals('104', simplified['optional_uint64']);
105 assertEquals(105, simplified['optional_sint32']);
106 assertEquals('106', simplified['optional_sint64']);
107 assertEquals(107, simplified['optional_fixed32']);
108 assertEquals('108', simplified['optional_fixed64']);
109 assertEquals(109, simplified['optional_sfixed32']);
110 assertEquals('110', simplified['optional_sfixed64']);
111 assertEquals(111.5, simplified['optional_float']);
112 assertEquals(112.5, simplified['optional_double']);
113 assertEquals(true, simplified['optional_bool']);
114 assertEquals('test', simplified['optional_string']);
115 assertEquals('abcd', simplified['optional_bytes']);
116
117 assertEquals(111, simplified['optionalgroup']['a']);
118 assertEquals(112, simplified['optional_nested_message']['b']);
119
120 assertEquals(
121 proto2.TestAllTypes.NestedEnum.FOO, simplified['optional_nested_enum']);
122
123 assertEquals(201, simplified['repeated_int32'][0]);
124 assertEquals(202, simplified['repeated_int32'][1]);
125 }
126
127
128 function testSerializationOfUnknown() {
129 var message = new proto2.TestAllTypes();
130
131 // Set the fields.
132 // Known.
133 message.setOptionalInt32(101);
134 message.setOptionalInt64('102');
135 message.addRepeatedInt32(201);
136 message.addRepeatedInt32(202);
137
138 // Unknown.
139 message.setUnknown(1000, 301);
140 message.setUnknown(1001, 302);
141
142 // Serialize.
143 var simplified = new goog.proto2.ObjectSerializer().serialize(message);
144
145 assertEquals(101, simplified['1']);
146 assertEquals('102', simplified['2']);
147
148 assertEquals(201, simplified['31'][0]);
149 assertEquals(202, simplified['31'][1]);
150
151 assertEquals(301, simplified['1000']);
152 assertEquals(302, simplified['1001']);
153 }
154
155 function testDeserializationOfUnknown() {
156 var simplified = {1: 101, 2: '102', 1000: 103, 1001: 104};
157
158 var serializer = new goog.proto2.ObjectSerializer();
159
160 var message =
161 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
162
163 assertNotNull(message);
164 assertTrue(message.hasOptionalInt32());
165 assertTrue(message.hasOptionalInt64());
166
167 assertEquals(101, message.getOptionalInt32());
168 assertEquals('102', message.getOptionalInt64());
169
170 var count = 0;
171
172 message.forEachUnknown(function(tag, value) {
173 if (tag == 1000) {
174 assertEquals(103, value);
175 }
176
177 if (tag == 1001) {
178 assertEquals(104, value);
179 }
180
181 ++count;
182 });
183
184 assertEquals(2, count);
185 }
186
187 function testDeserializationRepeated() {
188 var simplified = {
189 31: [101, 102],
190 41: [201.5, 202.5, 203.5],
191 42: [],
192 43: [true, false],
193 44: ['he', 'llo'],
194 46: [{47: [101]}, {47: [102]}],
195 48: [{1: 201}, {1: 202}]
196 };
197
198 var serializer = new goog.proto2.ObjectSerializer();
199
200 var message =
201 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
202
203 assertNotNull(message);
204
205 // Ensure the fields are set as expected.
206 assertTrue(message.hasRepeatedInt32());
207 assertTrue(message.hasRepeatedFloat());
208
209 assertFalse(message.hasRepeatedDouble());
210
211 assertTrue(message.hasRepeatedBool());
212 assertTrue(message.hasRepeatedgroup());
213 assertTrue(message.hasRepeatedNestedMessage());
214
215 // Ensure the counts match.
216 assertEquals(2, message.repeatedInt32Count());
217 assertEquals(3, message.repeatedFloatCount());
218
219 assertEquals(0, message.repeatedDoubleCount());
220
221 assertEquals(2, message.repeatedBoolCount());
222 assertEquals(2, message.repeatedStringCount());
223 assertEquals(2, message.repeatedgroupCount());
224 assertEquals(2, message.repeatedNestedMessageCount());
225
226 // Ensure the values match.
227 assertEquals(101, message.getRepeatedInt32(0));
228 assertEquals(102, message.getRepeatedInt32(1));
229
230 assertEquals(201.5, message.getRepeatedFloat(0));
231 assertEquals(202.5, message.getRepeatedFloat(1));
232 assertEquals(203.5, message.getRepeatedFloat(2));
233
234 assertEquals(true, message.getRepeatedBool(0));
235 assertEquals(false, message.getRepeatedBool(1));
236
237 assertEquals('he', message.getRepeatedString(0));
238 assertEquals('llo', message.getRepeatedString(1));
239
240 assertEquals(101, message.getRepeatedgroup(0).getA(0));
241 assertEquals(102, message.getRepeatedgroup(1).getA(0));
242
243 assertEquals(201, message.getRepeatedNestedMessage(0).getB());
244 assertEquals(202, message.getRepeatedNestedMessage(1).getB());
245 }
246
247 function testDeserialization() {
248 var simplified = {
249 1: 101,
250 2: '102',
251 3: 103,
252 4: '104',
253 5: 105,
254 6: '106',
255 7: 107,
256 8: '108',
257 9: 109,
258 10: '110',
259 11: 111.5,
260 12: 112.5,
261 13: true,
262 14: 'test',
263 15: 'abcd',
264 16: {17: 113},
265 18: {1: 114},
266 21: proto2.TestAllTypes.NestedEnum.FOO
267 };
268
269 var serializer = new goog.proto2.ObjectSerializer();
270
271 var message =
272 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
273
274 assertNotNull(message);
275
276 assertTrue(message.hasOptionalInt32());
277 assertTrue(message.hasOptionalInt64());
278 assertTrue(message.hasOptionalUint32());
279 assertTrue(message.hasOptionalUint64());
280 assertTrue(message.hasOptionalSint32());
281 assertTrue(message.hasOptionalSint64());
282 assertTrue(message.hasOptionalFixed32());
283 assertTrue(message.hasOptionalFixed64());
284 assertTrue(message.hasOptionalSfixed32());
285 assertTrue(message.hasOptionalSfixed64());
286 assertTrue(message.hasOptionalFloat());
287 assertTrue(message.hasOptionalDouble());
288 assertTrue(message.hasOptionalBool());
289 assertTrue(message.hasOptionalString());
290 assertTrue(message.hasOptionalBytes());
291 assertTrue(message.hasOptionalgroup());
292 assertTrue(message.hasOptionalNestedMessage());
293 assertTrue(message.hasOptionalNestedEnum());
294
295 assertEquals(1, message.optionalInt32Count());
296 assertEquals(1, message.optionalInt64Count());
297 assertEquals(1, message.optionalUint32Count());
298 assertEquals(1, message.optionalUint64Count());
299 assertEquals(1, message.optionalSint32Count());
300 assertEquals(1, message.optionalSint64Count());
301 assertEquals(1, message.optionalFixed32Count());
302 assertEquals(1, message.optionalFixed64Count());
303 assertEquals(1, message.optionalSfixed32Count());
304 assertEquals(1, message.optionalSfixed64Count());
305 assertEquals(1, message.optionalFloatCount());
306 assertEquals(1, message.optionalDoubleCount());
307 assertEquals(1, message.optionalBoolCount());
308 assertEquals(1, message.optionalStringCount());
309 assertEquals(1, message.optionalBytesCount());
310 assertEquals(1, message.optionalgroupCount());
311 assertEquals(1, message.optionalNestedMessageCount());
312 assertEquals(1, message.optionalNestedEnumCount());
313
314 assertEquals(101, message.getOptionalInt32());
315 assertEquals('102', message.getOptionalInt64());
316 assertEquals(103, message.getOptionalUint32());
317 assertEquals('104', message.getOptionalUint64());
318 assertEquals(105, message.getOptionalSint32());
319 assertEquals('106', message.getOptionalSint64());
320 assertEquals(107, message.getOptionalFixed32());
321 assertEquals('108', message.getOptionalFixed64());
322 assertEquals(109, message.getOptionalSfixed32());
323 assertEquals('110', message.getOptionalSfixed64());
324 assertEquals(111.5, message.getOptionalFloat());
325 assertEquals(112.5, message.getOptionalDouble());
326 assertEquals(true, message.getOptionalBool());
327 assertEquals('test', message.getOptionalString());
328 assertEquals('abcd', message.getOptionalBytes());
329 assertEquals(113, message.getOptionalgroup().getA());
330 assertEquals(114, message.getOptionalNestedMessage().getB());
331
332 assertEquals(
333 proto2.TestAllTypes.NestedEnum.FOO, message.getOptionalNestedEnum());
334 }
335
336 function testDeserializationByName() {
337 var simplified = {
338 'optional_int32': 101,
339 'optional_int64': '102',
340 'optional_uint32': 103,
341 'optional_uint64': '104',
342 'optional_sint32': 105,
343 'optional_sint64': '106',
344 'optional_fixed32': 107,
345 'optional_fixed64': '108',
346 'optional_sfixed32': 109,
347 'optional_sfixed64': '110',
348 'optional_float': 111.5,
349 'optional_double': 112.5,
350 'optional_bool': true,
351 'optional_string': 'test',
352 'optional_bytes': 'abcd',
353 'optionalgroup': {'a': 113},
354 'optional_nested_message': {'b': 114},
355 'optional_nested_enum': proto2.TestAllTypes.NestedEnum.FOO
356 };
357
358 var serializer = new goog.proto2.ObjectSerializer(
359 goog.proto2.ObjectSerializer.KeyOption.NAME);
360
361 var message =
362 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
363
364 assertNotNull(message);
365
366 assertTrue(message.hasOptionalInt32());
367 assertTrue(message.hasOptionalInt64());
368 assertTrue(message.hasOptionalUint32());
369 assertTrue(message.hasOptionalUint64());
370 assertTrue(message.hasOptionalSint32());
371 assertTrue(message.hasOptionalSint64());
372 assertTrue(message.hasOptionalFixed32());
373 assertTrue(message.hasOptionalFixed64());
374 assertTrue(message.hasOptionalSfixed32());
375 assertTrue(message.hasOptionalSfixed64());
376 assertTrue(message.hasOptionalFloat());
377 assertTrue(message.hasOptionalDouble());
378 assertTrue(message.hasOptionalBool());
379 assertTrue(message.hasOptionalString());
380 assertTrue(message.hasOptionalBytes());
381 assertTrue(message.hasOptionalgroup());
382 assertTrue(message.hasOptionalNestedMessage());
383 assertTrue(message.hasOptionalNestedEnum());
384
385 assertEquals(1, message.optionalInt32Count());
386 assertEquals(1, message.optionalInt64Count());
387 assertEquals(1, message.optionalUint32Count());
388 assertEquals(1, message.optionalUint64Count());
389 assertEquals(1, message.optionalSint32Count());
390 assertEquals(1, message.optionalSint64Count());
391 assertEquals(1, message.optionalFixed32Count());
392 assertEquals(1, message.optionalFixed64Count());
393 assertEquals(1, message.optionalSfixed32Count());
394 assertEquals(1, message.optionalSfixed64Count());
395 assertEquals(1, message.optionalFloatCount());
396 assertEquals(1, message.optionalDoubleCount());
397 assertEquals(1, message.optionalBoolCount());
398 assertEquals(1, message.optionalStringCount());
399 assertEquals(1, message.optionalBytesCount());
400 assertEquals(1, message.optionalgroupCount());
401 assertEquals(1, message.optionalNestedMessageCount());
402 assertEquals(1, message.optionalNestedEnumCount());
403
404 assertEquals(101, message.getOptionalInt32());
405 assertEquals('102', message.getOptionalInt64());
406 assertEquals(103, message.getOptionalUint32());
407 assertEquals('104', message.getOptionalUint64());
408 assertEquals(105, message.getOptionalSint32());
409 assertEquals('106', message.getOptionalSint64());
410 assertEquals(107, message.getOptionalFixed32());
411 assertEquals('108', message.getOptionalFixed64());
412 assertEquals(109, message.getOptionalSfixed32());
413 assertEquals('110', message.getOptionalSfixed64());
414 assertEquals(111.5, message.getOptionalFloat());
415 assertEquals(112.5, message.getOptionalDouble());
416 assertEquals(true, message.getOptionalBool());
417 assertEquals('test', message.getOptionalString());
418 assertEquals('abcd', message.getOptionalBytes());
419 assertEquals(113, message.getOptionalgroup().getA());
420 assertEquals(114, message.getOptionalNestedMessage().getB());
421
422 assertEquals(
423 proto2.TestAllTypes.NestedEnum.FOO, message.getOptionalNestedEnum());
424 }
425
426 function testDeserializationByCamelCaseName() {
427 var simplified = {
428 'optionalInt32': 101,
429 'optionalInt64': '102',
430 'optionalUint32': 103,
431 'optionalUint64': '104',
432 'optionalSint32': 105,
433 'optionalSint64': '106',
434 'optionalFixed32': 107,
435 'optionalFixed64': '108',
436 'optionalSfixed32': 109,
437 'optionalSfixed64': '110',
438 'optionalFloat': 111.5,
439 'optionalDouble': 112.5,
440 'optionalBool': true,
441 'optionalString': 'test',
442 'optionalBytes': 'abcd',
443 'optionalgroup': {'a': 113},
444 'optionalNestedMessage': {'b': 114},
445 'optionalNestedEnum': proto2.TestAllTypes.NestedEnum.FOO
446 };
447
448 var serializer = new goog.proto2.ObjectSerializer(
449 goog.proto2.ObjectSerializer.KeyOption.CAMEL_CASE_NAME);
450
451 var message =
452 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
453
454 assertNotNull(message);
455
456 assertTrue(message.hasOptionalInt32());
457 assertTrue(message.hasOptionalInt64());
458 assertTrue(message.hasOptionalUint32());
459 assertTrue(message.hasOptionalUint64());
460 assertTrue(message.hasOptionalSint32());
461 assertTrue(message.hasOptionalSint64());
462 assertTrue(message.hasOptionalFixed32());
463 assertTrue(message.hasOptionalFixed64());
464 assertTrue(message.hasOptionalSfixed32());
465 assertTrue(message.hasOptionalSfixed64());
466 assertTrue(message.hasOptionalFloat());
467 assertTrue(message.hasOptionalDouble());
468 assertTrue(message.hasOptionalBool());
469 assertTrue(message.hasOptionalString());
470 assertTrue(message.hasOptionalBytes());
471 assertTrue(message.hasOptionalgroup());
472 assertTrue(message.hasOptionalNestedMessage());
473 assertTrue(message.hasOptionalNestedEnum());
474
475 assertEquals(1, message.optionalInt32Count());
476 assertEquals(1, message.optionalInt64Count());
477 assertEquals(1, message.optionalUint32Count());
478 assertEquals(1, message.optionalUint64Count());
479 assertEquals(1, message.optionalSint32Count());
480 assertEquals(1, message.optionalSint64Count());
481 assertEquals(1, message.optionalFixed32Count());
482 assertEquals(1, message.optionalFixed64Count());
483 assertEquals(1, message.optionalSfixed32Count());
484 assertEquals(1, message.optionalSfixed64Count());
485 assertEquals(1, message.optionalFloatCount());
486 assertEquals(1, message.optionalDoubleCount());
487 assertEquals(1, message.optionalBoolCount());
488 assertEquals(1, message.optionalStringCount());
489 assertEquals(1, message.optionalBytesCount());
490 assertEquals(1, message.optionalgroupCount());
491 assertEquals(1, message.optionalNestedMessageCount());
492 assertEquals(1, message.optionalNestedEnumCount());
493
494 assertEquals(101, message.getOptionalInt32());
495 assertEquals('102', message.getOptionalInt64());
496 assertEquals(103, message.getOptionalUint32());
497 assertEquals('104', message.getOptionalUint64());
498 assertEquals(105, message.getOptionalSint32());
499 assertEquals('106', message.getOptionalSint64());
500 assertEquals(107, message.getOptionalFixed32());
501 assertEquals('108', message.getOptionalFixed64());
502 assertEquals(109, message.getOptionalSfixed32());
503 assertEquals('110', message.getOptionalSfixed64());
504 assertEquals(111.5, message.getOptionalFloat());
505 assertEquals(112.5, message.getOptionalDouble());
506 assertEquals(true, message.getOptionalBool());
507 assertEquals('test', message.getOptionalString());
508 assertEquals('abcd', message.getOptionalBytes());
509 assertEquals(113, message.getOptionalgroup().getA());
510 assertEquals(114, message.getOptionalNestedMessage().getB());
511
512 assertEquals(
513 proto2.TestAllTypes.NestedEnum.FOO, message.getOptionalNestedEnum());
514 }
515
516 function testDeserializationUnknownEnumValue() {
517 var simplified = {21: 1001};
518
519 var serializer = new goog.proto2.ObjectSerializer();
520
521 var message =
522 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
523
524 assertNotNull(message);
525
526 assertEquals(1001, message.getOptionalNestedEnum());
527 }
528
529 function testDeserializationSymbolicEnumValue() {
530 var simplified = {21: 'BAR'};
531
532 propertyReplacer.set(goog.proto2.Serializer, 'DECODE_SYMBOLIC_ENUMS', true);
533
534 var serializer = new goog.proto2.ObjectSerializer();
535
536 var message =
537 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
538
539 assertNotNull(message);
540
541 assertEquals(
542 proto2.TestAllTypes.NestedEnum.BAR, message.getOptionalNestedEnum());
543 }
544
545 function testDeserializationSymbolicEnumValueTurnedOff() {
546 var simplified = {21: 'BAR'};
547
548 var serializer = new goog.proto2.ObjectSerializer();
549
550 assertThrows(
551 'Should have an assertion failure in deserialization', function() {
552 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
553 });
554 }
555
556 function testDeserializationUnknownSymbolicEnumValue() {
557 var simplified = {21: 'BARRED'};
558
559 var serializer = new goog.proto2.ObjectSerializer();
560
561 assertThrows(
562 'Should have an assertion failure in deserialization', function() {
563 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
564 });
565 }
566
567 function testDeserializationEnumValueAsNumericString() {
568 var simplified = {21: '2'};
569
570 var serializer = new goog.proto2.ObjectSerializer();
571
572 var message =
573 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
574
575 assertNotNull(message);
576
577 assertEquals(
578 proto2.TestAllTypes.NestedEnum.BAR, message.getOptionalNestedEnum());
579 }
580
581 function testDeserializationEnumValueWithNegativeString() {
582 var simplified = {21: '-2'};
583
584 var serializer = new goog.proto2.ObjectSerializer();
585
586 assertThrows(
587 'Should have an assertion failure in deserialization', function() {
588 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
589 });
590 }
591
592 function testDeserializationNumbersOrStrings() {
593 // 64-bit types may have been serialized as numbers or strings.
594 // Deserialization should be able to handle either.
595
596 var simplifiedWithNumbers =
597 {50: 5000, 51: 5100, 52: [5200, 5201], 53: [5300, 5301]};
598
599 var simplifiedWithStrings =
600 {50: '5000', 51: '5100', 52: ['5200', '5201'], 53: ['5300', '5301']};
601
602 var serializer = new goog.proto2.ObjectSerializer();
603
604 var message = serializer.deserialize(
605 proto2.TestAllTypes.getDescriptor(), simplifiedWithNumbers);
606
607 assertNotNull(message);
608
609 assertEquals(5000, message.getOptionalInt64Number());
610 assertEquals('5100', message.getOptionalInt64String());
611 assertEquals(5200, message.getRepeatedInt64Number(0));
612 assertEquals(5201, message.getRepeatedInt64Number(1));
613 assertEquals('5300', message.getRepeatedInt64String(0));
614 assertEquals('5301', message.getRepeatedInt64String(1));
615
616 assertArrayEquals([5200, 5201], message.repeatedInt64NumberArray());
617 assertArrayEquals(['5300', '5301'], message.repeatedInt64StringArray());
618
619 message = serializer.deserialize(
620 proto2.TestAllTypes.getDescriptor(), simplifiedWithStrings);
621
622 assertNotNull(message);
623
624 assertEquals(5000, message.getOptionalInt64Number());
625 assertEquals('5100', message.getOptionalInt64String());
626 assertEquals(5200, message.getRepeatedInt64Number(0));
627 assertEquals(5201, message.getRepeatedInt64Number(1));
628 assertEquals('5300', message.getRepeatedInt64String(0));
629 assertEquals('5301', message.getRepeatedInt64String(1));
630
631 assertArrayEquals([5200, 5201], message.repeatedInt64NumberArray());
632 assertArrayEquals(['5300', '5301'], message.repeatedInt64StringArray());
633 }
634
635 function testSerializationSpecialFloatDoubleValues() {
636 // NaN, Infinity and -Infinity should get serialized as strings.
637 var message = new proto2.TestAllTypes();
638 message.setOptionalFloat(Infinity);
639 message.setOptionalDouble(-Infinity);
640 message.addRepeatedFloat(Infinity);
641 message.addRepeatedFloat(-Infinity);
642 message.addRepeatedFloat(NaN);
643 message.addRepeatedDouble(Infinity);
644 message.addRepeatedDouble(-Infinity);
645 message.addRepeatedDouble(NaN);
646 var simplified = new goog.proto2.ObjectSerializer().serialize(message);
647
648 // Assert that everything serialized properly.
649 assertEquals('Infinity', simplified[11]);
650 assertEquals('-Infinity', simplified[12]);
651 assertEquals('Infinity', simplified[41][0]);
652 assertEquals('-Infinity', simplified[41][1]);
653 assertEquals('NaN', simplified[41][2]);
654 assertEquals('Infinity', simplified[42][0]);
655 assertEquals('-Infinity', simplified[42][1]);
656 assertEquals('NaN', simplified[42][2]);
657 }
658
659 function testDeserializationSpecialFloatDoubleValues() {
660 // NaN, Infinity and -Infinity values should be de-serialized from their
661 // string representation.
662 var simplified = {
663 41: ['Infinity', '-Infinity', 'NaN'],
664 42: ['Infinity', '-Infinity', 'NaN']
665 };
666
667 var serializer = new goog.proto2.ObjectSerializer();
668
669 var message =
670 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
671
672 assertNotNull(message);
673
674 var floatArray = message.repeatedFloatArray();
675 assertEquals(Infinity, floatArray[0]);
676 assertEquals(-Infinity, floatArray[1]);
677 assertTrue(isNaN(floatArray[2]));
678
679 var doubleArray = message.repeatedDoubleArray();
680 assertEquals(Infinity, doubleArray[0]);
681 assertEquals(-Infinity, doubleArray[1]);
682 assertTrue(isNaN(doubleArray[2]));
683 }
684
685 function testDeserializationConversionProhibited() {
686 // 64-bit types may have been serialized as numbers or strings.
687 // But 32-bit types must be serialized as numbers.
688 // Test deserialization fails on 32-bit numbers as strings.
689
690 var simplified = {
691 1: '1000' // optionalInt32
692 };
693 var serializer = new goog.proto2.ObjectSerializer();
694
695 assertThrows(
696 'Should have an assertion failure in deserialization', function() {
697 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
698 });
699 }
700
701 function testDefaultValueNumbersOrStrings() {
702 // 64-bit types may have been serialized as numbers or strings.
703 // The default values should have the correct type.
704
705 var serializer = new goog.proto2.ObjectSerializer();
706 var message = serializer.deserialize(proto2.TestAllTypes.getDescriptor(), {});
707
708 assertNotNull(message);
709
710 // Default when using Number is a number, and precision is lost.
711 var value = message.getOptionalInt64NumberOrDefault();
712 assertTrue('Expecting a number', typeof value === 'number');
713 assertEquals(1000000000000000000, value);
714 assertEquals(1000000000000000001, value);
715 assertEquals(1000000000000000002, value);
716 assertEquals('1000000000000000000', String(value)); // Value is rounded!
717
718 // When using a String, the value is preserved.
719 assertEquals(
720 '1000000000000000001', message.getOptionalInt64StringOrDefault());
721 }
722
723 function testSerializationBooleanAsNumberFalse() {
724 // Some libraries, such as GWT, can expect boolean field values as 0/1
725
726 var message = new proto2.TestAllTypes();
727 message.setOptionalBool(false);
728
729 var serializer = new goog.proto2.ObjectSerializer(
730 goog.proto2.ObjectSerializer.KeyOption.TAG,
731 true /* opt_serializeBooleanAsNumber */);
732 var simplified = serializer.serialize(message);
733
734 assertEquals(0, simplified[13]);
735 }
736
737 function testSerializationBooleanAsNumberTrue() {
738 var message = new proto2.TestAllTypes();
739 message.setOptionalBool(true);
740
741 var serializer = new goog.proto2.ObjectSerializer(
742 goog.proto2.ObjectSerializer.KeyOption.TAG,
743 true /* opt_serializeBooleanAsNumber */);
744 var simplified = serializer.serialize(message);
745
746 assertEquals(1, simplified[13]);
747 }
748
749 function testDeserializationBooleanAsNumberFalse() {
750 // Some libraries, such as GWT, can serialize boolean values as 0/1
751
752 var simplified = {13: 0};
753
754 var serializer = new goog.proto2.ObjectSerializer();
755
756 var message =
757 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
758
759 assertNotNull(message);
760
761 assertFalse(message.getOptionalBool());
762 }
763
764 function testDeserializationBooleanAsNumberTrue() {
765 var simplified = {13: 1};
766
767 var serializer = new goog.proto2.ObjectSerializer();
768
769 var message =
770 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
771
772 assertNotNull(message);
773
774 assertTrue(message.getOptionalBool());
775 }
776
777 function testRoundTripping() {
778 var message = new proto2.TestAllTypes();
779
780 // Set the fields.
781 // Singular.
782 message.setOptionalInt32(101);
783 message.setOptionalInt64('102');
784 message.setOptionalUint32(103);
785 message.setOptionalUint64('104');
786 message.setOptionalSint32(105);
787 message.setOptionalSint64('106');
788 message.setOptionalFixed32(107);
789 message.setOptionalFixed64('108');
790 message.setOptionalSfixed32(109);
791 message.setOptionalSfixed64('110');
792 message.setOptionalFloat(111.5);
793 message.setOptionalDouble(112.5);
794 message.setOptionalBool(true);
795 message.setOptionalString('test');
796 message.setOptionalBytes('abcd');
797
798 var group = new proto2.TestAllTypes.OptionalGroup();
799 group.setA(111);
800
801 message.setOptionalgroup(group);
802
803 var nestedMessage = new proto2.TestAllTypes.NestedMessage();
804 nestedMessage.setB(112);
805
806 message.setOptionalNestedMessage(nestedMessage);
807
808 message.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
809
810 // Repeated.
811 message.addRepeatedInt32(201);
812 message.addRepeatedInt32(202);
813
814 var message_serialized_by_tag =
815 new goog.proto2.ObjectSerializer().serialize(message);
816
817 var message_serialized_by_tag_deserialized_by_tag = new proto2.TestAllTypes();
818 new goog.proto2.ObjectSerializer().deserializeTo(
819 message_serialized_by_tag_deserialized_by_tag, message_serialized_by_tag);
820 assertObjectEquals(message, message_serialized_by_tag_deserialized_by_tag);
821
822 var message_serialized_by_tag_deserialized_by_name =
823 new proto2.TestAllTypes();
824 // Deserializing by name still works since the parser will use the tags.
825 new goog.proto2.ObjectSerializer(goog.proto2.ObjectSerializer.KeyOption.NAME)
826 .deserializeTo(
827 message_serialized_by_tag_deserialized_by_name,
828 message_serialized_by_tag);
829 assertObjectEquals(message, message_serialized_by_tag_deserialized_by_name);
830
831 var message_serialized_by_tag_deserialized_by_camel_case_name =
832 new proto2.TestAllTypes();
833 // Deserializing by camel case name still works since the parser will use the
834 // tags.
835 new goog.proto2
836 .ObjectSerializer(goog.proto2.ObjectSerializer.KeyOption.CAMEL_CASE_NAME)
837 .deserializeTo(
838 message_serialized_by_tag_deserialized_by_camel_case_name,
839 message_serialized_by_tag);
840 assertObjectEquals(
841 message, message_serialized_by_tag_deserialized_by_camel_case_name);
842
843 var message_serialized_by_name =
844 new goog.proto2
845 .ObjectSerializer(goog.proto2.ObjectSerializer.KeyOption.NAME)
846 .serialize(message);
847
848 var message_serialized_by_name_deserialized_by_tag =
849 new proto2.TestAllTypes();
850 assertThrows(function() {
851 // Attempting to deserialize by tag will fail since names were used for
852 // serialization.
853 new goog.proto2.ObjectSerializer().deserializeTo(
854 message_serialized_by_name_deserialized_by_tag,
855 message_serialized_by_name);
856 });
857
858 var message_serialized_by_name_deserialized_by_name =
859 new proto2.TestAllTypes();
860 new goog.proto2.ObjectSerializer(goog.proto2.ObjectSerializer.KeyOption.NAME)
861 .deserializeTo(
862 message_serialized_by_name_deserialized_by_name,
863 message_serialized_by_name);
864 assertObjectEquals(message, message_serialized_by_name_deserialized_by_name);
865
866 var message_serialized_by_name_deserialized_by_camel_case_name =
867 new proto2.TestAllTypes();
868 // Deserializing by camel case name works since the transforming
869 // underscore_delimited to underscore_delimited is a no-op.
870 new goog.proto2
871 .ObjectSerializer(goog.proto2.ObjectSerializer.KeyOption.CAMEL_CASE_NAME)
872 .deserializeTo(
873 message_serialized_by_name_deserialized_by_camel_case_name,
874 message_serialized_by_name);
875 assertObjectEquals(
876 message, message_serialized_by_name_deserialized_by_camel_case_name);
877
878 var message_serialized_by_camel_case_name =
879 new goog.proto2
880 .ObjectSerializer(
881 goog.proto2.ObjectSerializer.KeyOption.CAMEL_CASE_NAME)
882 .serialize(message);
883
884 var message_serialized_by_camel_case_name_deserialized_by_tag =
885 new proto2.TestAllTypes();
886 assertThrows(function() {
887 // Attempting to deserialize by tag will fail since camel case names were
888 // used for serialization.
889 new goog.proto2.ObjectSerializer().deserializeTo(
890 message_serialized_by_camel_case_name_deserialized_by_tag,
891 message_serialized_by_camel_case_name);
892 });
893
894 var message_serialized_by_camel_case_name_deserialized_by_name =
895 new proto2.TestAllTypes();
896 assertThrows(function() {
897 // Attempting to deserialize by original name will fail since camel case
898 // names were used for serialization.
899 new goog.proto2
900 .ObjectSerializer(goog.proto2.ObjectSerializer.KeyOption.NAME)
901 .deserializeTo(
902 message_serialized_by_camel_case_name_deserialized_by_name,
903 message_serialized_by_camel_case_name);
904 });
905
906 var message_serialized_by_camel_case_name_deserialized_by_camel_case_name =
907 new proto2.TestAllTypes();
908 new goog.proto2
909 .ObjectSerializer(goog.proto2.ObjectSerializer.KeyOption.CAMEL_CASE_NAME)
910 .deserializeTo(
911 message_serialized_by_camel_case_name_deserialized_by_camel_case_name,
912 message_serialized_by_camel_case_name);
913 assertObjectEquals(
914 message,
915 message_serialized_by_camel_case_name_deserialized_by_camel_case_name);
916 }