Debian Codegraph @

closure-library/closure/goog/proto2/pbliteserializer_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.PbLiteSerializerTest');
16 goog.setTestOnly('goog.proto2.PbLiteSerializerTest');
17
18 goog.require('goog.proto2.PbLiteSerializer');
19 goog.require('goog.testing.jsunit');
20 goog.require('proto2.TestAllTypes');
21
22 function testSerializationAndDeserialization() {
23 var message = createPopulatedMessage();
24
25 // Serialize.
26 var serializer = new goog.proto2.PbLiteSerializer();
27 var pblite = serializer.serialize(message);
28
29 assertTrue(goog.isArray(pblite));
30
31 // Assert that everything serialized properly.
32 assertEquals(101, pblite[1]);
33 assertEquals('102', pblite[2]);
34 assertEquals(103, pblite[3]);
35 assertEquals('104', pblite[4]);
36 assertEquals(105, pblite[5]);
37 assertEquals('106', pblite[6]);
38 assertEquals(107, pblite[7]);
39 assertEquals('108', pblite[8]);
40 assertEquals(109, pblite[9]);
41 assertEquals('110', pblite[10]);
42 assertEquals(111.5, pblite[11]);
43 assertEquals(112.5, pblite[12]);
44 assertEquals(1, pblite[13]); // true is serialized as 1
45 assertEquals('test', pblite[14]);
46 assertEquals('abcd', pblite[15]);
47
48 assertEquals(111, pblite[16][17]);
49 assertEquals(112, pblite[18][1]);
50
51 assertTrue(pblite[19] === undefined);
52 assertTrue(pblite[20] === undefined);
53
54 assertEquals(proto2.TestAllTypes.NestedEnum.FOO, pblite[21]);
55
56 assertEquals(201, pblite[31][0]);
57 assertEquals(202, pblite[31][1]);
58 assertEquals('foo', pblite[44][0]);
59 assertEquals('bar', pblite[44][1]);
60
61 var serializer = new goog.proto2.PbLiteSerializer();
62 // Deserialize.
63 var messageCopy =
64 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), pblite);
65
66 assertNotEquals(messageCopy, message);
67
68 assertDeserializationMatches(messageCopy);
69 }
70
71 function testZeroBasedSerializationAndDeserialization() {
72 var message = createPopulatedMessage();
73
74 // Serialize.
75 var serializer = new goog.proto2.PbLiteSerializer();
76 serializer.setZeroIndexed(true);
77
78 var pblite = serializer.serialize(message);
79
80 assertTrue(goog.isArray(pblite));
81
82 // Assert that everything serialized properly.
83 assertEquals(101, pblite[0]);
84 assertEquals('102', pblite[1]);
85 assertEquals(103, pblite[2]);
86 assertEquals('104', pblite[3]);
87 assertEquals(105, pblite[4]);
88 assertEquals('106', pblite[5]);
89 assertEquals(107, pblite[6]);
90 assertEquals('108', pblite[7]);
91 assertEquals(109, pblite[8]);
92 assertEquals('110', pblite[9]);
93 assertEquals(111.5, pblite[10]);
94 assertEquals(112.5, pblite[11]);
95 assertEquals(1, pblite[12]); // true is serialized as 1
96 assertEquals('test', pblite[13]);
97 assertEquals('abcd', pblite[14]);
98
99 assertEquals(111, pblite[15][16]);
100 assertEquals(112, pblite[17][0]);
101
102 assertTrue(pblite[18] === undefined);
103 assertTrue(pblite[19] === undefined);
104
105 assertEquals(proto2.TestAllTypes.NestedEnum.FOO, pblite[20]);
106
107 assertEquals(201, pblite[30][0]);
108 assertEquals(202, pblite[30][1]);
109 assertEquals('foo', pblite[43][0]);
110 assertEquals('bar', pblite[43][1]);
111
112 // Deserialize.
113 var messageCopy =
114 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), pblite);
115
116 assertNotEquals(messageCopy, message);
117
118 assertEquals(message.getOptionalInt32(), messageCopy.getOptionalInt32());
119 assertDeserializationMatches(messageCopy);
120 }
121
122 function createPopulatedMessage() {
123 var message = new proto2.TestAllTypes();
124
125 // Set the fields.
126 // Singular.
127 message.setOptionalInt32(101);
128 message.setOptionalInt64('102');
129 message.setOptionalUint32(103);
130 message.setOptionalUint64('104');
131 message.setOptionalSint32(105);
132 message.setOptionalSint64('106');
133 message.setOptionalFixed32(107);
134 message.setOptionalFixed64('108');
135 message.setOptionalSfixed32(109);
136 message.setOptionalSfixed64('110');
137 message.setOptionalFloat(111.5);
138 message.setOptionalDouble(112.5);
139 message.setOptionalBool(true);
140 message.setOptionalString('test');
141 message.setOptionalBytes('abcd');
142
143 var group = new proto2.TestAllTypes.OptionalGroup();
144 group.setA(111);
145
146 message.setOptionalgroup(group);
147
148 var nestedMessage = new proto2.TestAllTypes.NestedMessage();
149 nestedMessage.setB(112);
150
151 message.setOptionalNestedMessage(nestedMessage);
152
153 message.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
154
155 // Repeated.
156 message.addRepeatedInt32(201);
157 message.addRepeatedInt32(202);
158
159 // Skip a few repeated fields so we can test how null array values are
160 // handled.
161 message.addRepeatedString('foo');
162 message.addRepeatedString('bar');
163 return message;
164 }
165
166 function testDeserializationFromExternalSource() {
167 // Test deserialization where the JSON array is initialized from something
168 // outside the Closure proto2 library, such as the JsPbLite library, or
169 // manually as in this test.
170 var pblite = [
171 , // 0
172 101, // 1
173 '102', // 2
174 103, // 3
175 '104', // 4
176 105, // 5
177 '106', // 6
178 107, // 7
179 '108', // 8
180 109, // 9
181 '110', // 10
182 111.5, // 11
183 112.5, // 12
184 1, // 13
185 'test', // 14
186 'abcd', // 15
187 [
188 , , , , , , , , , , , , , , , , , 111
189 ], // 16, note the 17 commas so value is index 17
190 , // 17
191 [, 112], // 18
192 ,
193 , // 19-20
194 proto2.TestAllTypes.NestedEnum.FOO, // 21
195 , , , , , , , , , // 22-30
196 [201, 202], // 31
197 , , , , , , , , , , , , // 32-43
198 ['foo', 'bar'] // 44
199 ];
200 pblite.length = 50;
201
202 // Deserialize.
203 var serializer = new goog.proto2.PbLiteSerializer();
204 var messageCopy =
205 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), pblite);
206
207 assertDeserializationMatches(messageCopy);
208
209 // http://b/issue?id=2928075
210 assertFalse(messageCopy.hasRepeatedInt64());
211 assertEquals(0, messageCopy.repeatedInt64Count());
212 messageCopy.repeatedInt64Array();
213 assertFalse(messageCopy.hasRepeatedInt64());
214 assertEquals(0, messageCopy.repeatedInt64Count());
215
216 // Access a nested message to ensure it is deserialized.
217 assertNotNull(messageCopy.getOptionalNestedMessage());
218
219 // Verify that the pblite array itself has not been replaced by the
220 // deserialization.
221 assertEquals('array', goog.typeOf(pblite[16]));
222
223 // Update some fields and verify that the changes work with the lazy
224 // deserializer.
225 messageCopy.setOptionalBool(true);
226 assertTrue(messageCopy.getOptionalBool());
227
228 messageCopy.setOptionalBool(false);
229 assertFalse(messageCopy.getOptionalBool());
230
231 messageCopy.setOptionalInt32(1234);
232 assertEquals(1234, messageCopy.getOptionalInt32());
233 }
234
235 function testModifyLazyDeserializedMessage() {
236 var pblite = [
237 , // 0
238 101, // 1
239 '102', // 2
240 103, // 3
241 '104', // 4
242 105, // 5
243 '106', // 6
244 107, // 7
245 '108', // 8
246 109, // 9
247 '110', // 10
248 111.5, // 11
249 112.5, // 12
250 1, // 13
251 'test', // 14
252 'abcd', // 15
253 [
254 , , , , , , , , , , , , , , , , , 111
255 ], // 16, note the 17 commas so value is index 17
256 , // 17
257 [, 112], // 18
258 ,
259 , // 19-20
260 proto2.TestAllTypes.NestedEnum.FOO, // 21
261 , , , , , , , , , // 22-30
262 [201, 202], // 31
263 , , , , , , , , , , , , // 32-43
264 ['foo', 'bar'] // 44
265 ];
266 pblite.length = 50;
267
268 // Deserialize.
269 var serializer = new goog.proto2.PbLiteSerializer();
270 var message =
271 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), pblite);
272
273 // Conduct some operations, ensuring that they all work as expected, even with
274 // the lazily deserialized data.
275 assertEquals(101, message.getOptionalInt32());
276 message.setOptionalInt32(401);
277 assertEquals(401, message.getOptionalInt32());
278
279 assertEquals(2, message.repeatedInt32Count());
280 assertEquals(201, message.getRepeatedInt32(0));
281 assertEquals(202, message.getRepeatedInt32(1));
282
283 message.clearRepeatedInt32();
284 assertEquals(0, message.repeatedInt32Count());
285
286 message.addRepeatedInt32(101);
287 assertEquals(1, message.repeatedInt32Count());
288 assertEquals(101, message.getRepeatedInt32(0));
289
290 message.setUnknown(12345, 601);
291 message.forEachUnknown(function(tag, value) {
292 assertEquals(12345, tag);
293 assertEquals(601, value);
294 });
295
296 // Create a copy of the message.
297 var messageCopy = new proto2.TestAllTypes();
298 messageCopy.copyFrom(message);
299
300 assertEquals(1, messageCopy.repeatedInt32Count());
301 assertEquals(101, messageCopy.getRepeatedInt32(0));
302 }
303
304 function testModifyLazyDeserializedMessageByAddingMessage() {
305 var pblite = [
306 , // 0
307 101, // 1
308 '102', // 2
309 103, // 3
310 '104', // 4
311 105, // 5
312 '106', // 6
313 107, // 7
314 '108', // 8
315 109, // 9
316 '110', // 10
317 111.5, // 11
318 112.5, // 12
319 1, // 13
320 'test', // 14
321 'abcd', // 15
322 [
323 , , , , , , , , , , , , , , , , , 111
324 ], // 16, note the 17 commas so value is index 17
325 , // 17
326 [, 112], // 18
327 ,
328 , // 19-20
329 proto2.TestAllTypes.NestedEnum.FOO, // 21
330 , , , , , , , , , // 22-30
331 [201, 202], // 31
332 , , , , , , , , , , , , // 32-43
333 ['foo', 'bar'] // 44
334 ];
335 pblite.length = 50;
336
337 // Deserialize.
338 var serializer = new goog.proto2.PbLiteSerializer();
339 var message =
340 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), pblite);
341
342 // Add a new nested message.
343 var nested1 = new proto2.TestAllTypes.NestedMessage();
344 nested1.setB(1234);
345
346 var nested2 = new proto2.TestAllTypes.NestedMessage();
347 nested2.setB(4567);
348
349 message.addRepeatedNestedMessage(nested1);
350
351 // Check the new nested message.
352 assertEquals(1, message.repeatedNestedMessageArray().length);
353 assertTrue(message.repeatedNestedMessageArray()[0].equals(nested1));
354
355 // Add another nested message.
356 message.addRepeatedNestedMessage(nested2);
357
358 // Check both nested messages.
359 assertEquals(2, message.repeatedNestedMessageArray().length);
360 assertTrue(message.repeatedNestedMessageArray()[0].equals(nested1));
361 assertTrue(message.repeatedNestedMessageArray()[1].equals(nested2));
362 }
363
364 function assertDeserializationMatches(messageCopy) {
365 assertNotNull(messageCopy);
366
367 assertTrue(messageCopy.hasOptionalInt32());
368 assertTrue(messageCopy.hasOptionalInt64());
369 assertTrue(messageCopy.hasOptionalUint32());
370 assertTrue(messageCopy.hasOptionalUint64());
371 assertTrue(messageCopy.hasOptionalSint32());
372 assertTrue(messageCopy.hasOptionalSint64());
373 assertTrue(messageCopy.hasOptionalFixed32());
374 assertTrue(messageCopy.hasOptionalFixed64());
375 assertTrue(messageCopy.hasOptionalSfixed32());
376 assertTrue(messageCopy.hasOptionalSfixed64());
377 assertTrue(messageCopy.hasOptionalFloat());
378 assertTrue(messageCopy.hasOptionalDouble());
379 assertTrue(messageCopy.hasOptionalBool());
380 assertTrue(messageCopy.hasOptionalString());
381 assertTrue(messageCopy.hasOptionalBytes());
382 assertTrue(messageCopy.hasOptionalgroup());
383 assertTrue(messageCopy.hasOptionalNestedMessage());
384 assertTrue(messageCopy.hasOptionalNestedEnum());
385
386 assertTrue(messageCopy.hasRepeatedInt32());
387 assertFalse(messageCopy.hasRepeatedInt64());
388 assertFalse(messageCopy.hasRepeatedUint32());
389 assertFalse(messageCopy.hasRepeatedUint64());
390 assertFalse(messageCopy.hasRepeatedSint32());
391 assertFalse(messageCopy.hasRepeatedSint64());
392 assertFalse(messageCopy.hasRepeatedFixed32());
393 assertFalse(messageCopy.hasRepeatedFixed64());
394 assertFalse(messageCopy.hasRepeatedSfixed32());
395 assertFalse(messageCopy.hasRepeatedSfixed64());
396 assertFalse(messageCopy.hasRepeatedFloat());
397 assertFalse(messageCopy.hasRepeatedDouble());
398 assertFalse(messageCopy.hasRepeatedBool());
399 assertTrue(messageCopy.hasRepeatedString());
400 assertFalse(messageCopy.hasRepeatedBytes());
401 assertFalse(messageCopy.hasRepeatedgroup());
402 assertFalse(messageCopy.hasRepeatedNestedMessage());
403 assertFalse(messageCopy.hasRepeatedNestedEnum());
404
405 assertEquals(1, messageCopy.optionalInt32Count());
406 assertEquals(1, messageCopy.optionalInt64Count());
407 assertEquals(1, messageCopy.optionalUint32Count());
408 assertEquals(1, messageCopy.optionalUint64Count());
409 assertEquals(1, messageCopy.optionalSint32Count());
410 assertEquals(1, messageCopy.optionalSint64Count());
411 assertEquals(1, messageCopy.optionalFixed32Count());
412 assertEquals(1, messageCopy.optionalFixed64Count());
413 assertEquals(1, messageCopy.optionalSfixed32Count());
414 assertEquals(1, messageCopy.optionalSfixed64Count());
415 assertEquals(1, messageCopy.optionalFloatCount());
416 assertEquals(1, messageCopy.optionalDoubleCount());
417 assertEquals(1, messageCopy.optionalBoolCount());
418 assertEquals(1, messageCopy.optionalStringCount());
419 assertEquals(1, messageCopy.optionalBytesCount());
420 assertEquals(1, messageCopy.optionalgroupCount());
421 assertEquals(1, messageCopy.optionalNestedMessageCount());
422 assertEquals(1, messageCopy.optionalNestedEnumCount());
423
424 assertEquals(2, messageCopy.repeatedInt32Count());
425 assertEquals(0, messageCopy.repeatedInt64Count());
426 assertEquals(0, messageCopy.repeatedUint32Count());
427 assertEquals(0, messageCopy.repeatedUint64Count());
428 assertEquals(0, messageCopy.repeatedSint32Count());
429 assertEquals(0, messageCopy.repeatedSint64Count());
430 assertEquals(0, messageCopy.repeatedFixed32Count());
431 assertEquals(0, messageCopy.repeatedFixed64Count());
432 assertEquals(0, messageCopy.repeatedSfixed32Count());
433 assertEquals(0, messageCopy.repeatedSfixed64Count());
434 assertEquals(0, messageCopy.repeatedFloatCount());
435 assertEquals(0, messageCopy.repeatedDoubleCount());
436 assertEquals(0, messageCopy.repeatedBoolCount());
437 assertEquals(2, messageCopy.repeatedStringCount());
438 assertEquals(0, messageCopy.repeatedBytesCount());
439 assertEquals(0, messageCopy.repeatedgroupCount());
440 assertEquals(0, messageCopy.repeatedNestedMessageCount());
441 assertEquals(0, messageCopy.repeatedNestedEnumCount());
442
443 assertEquals(101, messageCopy.getOptionalInt32());
444 assertEquals('102', messageCopy.getOptionalInt64());
445 assertEquals(103, messageCopy.getOptionalUint32());
446 assertEquals('104', messageCopy.getOptionalUint64());
447 assertEquals(105, messageCopy.getOptionalSint32());
448 assertEquals('106', messageCopy.getOptionalSint64());
449 assertEquals(107, messageCopy.getOptionalFixed32());
450 assertEquals('108', messageCopy.getOptionalFixed64());
451 assertEquals(109, messageCopy.getOptionalSfixed32());
452 assertEquals('110', messageCopy.getOptionalSfixed64());
453 assertEquals(111.5, messageCopy.getOptionalFloat());
454 assertEquals(112.5, messageCopy.getOptionalDouble());
455 assertEquals(true, messageCopy.getOptionalBool());
456 assertEquals('test', messageCopy.getOptionalString());
457 assertEquals('abcd', messageCopy.getOptionalBytes());
458 assertEquals(111, messageCopy.getOptionalgroup().getA());
459
460 assertEquals(112, messageCopy.getOptionalNestedMessage().getB());
461
462 assertEquals(
463 proto2.TestAllTypes.NestedEnum.FOO, messageCopy.getOptionalNestedEnum());
464
465 assertEquals(201, messageCopy.getRepeatedInt32(0));
466 assertEquals(202, messageCopy.getRepeatedInt32(1));
467 }
468
469 function testMergeFromLazyTarget() {
470 var serializer = new goog.proto2.PbLiteSerializer();
471
472 var source = new proto2.TestAllTypes();
473 var nested = new proto2.TestAllTypes.NestedMessage();
474 nested.setB(66);
475 source.setOptionalNestedMessage(nested);
476 source.setOptionalInt32(32);
477 source.setOptionalString('foo');
478 source.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
479 source.addRepeatedInt32(2);
480
481 var target = new proto2.TestAllTypes();
482 nested = new proto2.TestAllTypes.NestedMessage();
483 nested.setC(77);
484 target.setOptionalNestedMessage(nested);
485 target.setOptionalInt64('64');
486 target.setOptionalString('bar');
487 target.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.BAR);
488 target.addRepeatedInt32(1);
489 var pbliteTarget = serializer.serialize(target);
490 var lazyTarget =
491 serializer.deserialize(proto2.TestAllTypes.getDescriptor(), pbliteTarget);
492
493 var expected = new proto2.TestAllTypes();
494 nested = new proto2.TestAllTypes.NestedMessage();
495 nested.setB(66);
496 nested.setC(77);
497 expected.setOptionalNestedMessage(nested);
498 expected.setOptionalInt32(32);
499 expected.setOptionalInt64('64');
500 expected.setOptionalString('foo');
501 expected.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
502 expected.addRepeatedInt32(1);
503 expected.addRepeatedInt32(2);
504
505 lazyTarget.mergeFrom(source);
506 assertTrue(
507 'expected and lazyTarget are equal after mergeFrom',
508 lazyTarget.equals(expected));
509 }