Debian Codegraph @

closure-library/closure/goog/proto2/proto_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.messageTest');
16 goog.setTestOnly('goog.proto2.messageTest');
17
18 goog.require('goog.proto2.FieldDescriptor');
19 goog.require('goog.testing.jsunit');
20 goog.require('proto2.TestAllTypes');
21 goog.require('proto2.TestDefaultParent');
22 goog.require('someprotopackage.TestPackageTypes');
23
24 function testPackage() {
25 var message = new someprotopackage.TestPackageTypes();
26 message.setOptionalInt32(45);
27 message.setOtherAll(new proto2.TestAllTypes());
28 }
29
30 function testFields() {
31 var message = new proto2.TestAllTypes();
32
33 // Ensure that the fields are not set.
34 assertFalse(message.hasOptionalInt32());
35 assertFalse(message.hasOptionalInt64());
36 assertFalse(message.hasOptionalUint32());
37 assertFalse(message.hasOptionalUint64());
38 assertFalse(message.hasOptionalSint32());
39 assertFalse(message.hasOptionalSint64());
40 assertFalse(message.hasOptionalFixed32());
41 assertFalse(message.hasOptionalFixed64());
42 assertFalse(message.hasOptionalSfixed32());
43 assertFalse(message.hasOptionalSfixed64());
44 assertFalse(message.hasOptionalFloat());
45 assertFalse(message.hasOptionalDouble());
46 assertFalse(message.hasOptionalBool());
47 assertFalse(message.hasOptionalString());
48 assertFalse(message.hasOptionalBytes());
49 assertFalse(message.hasOptionalgroup());
50 assertFalse(message.hasOptionalNestedMessage());
51 assertFalse(message.hasOptionalNestedEnum());
52
53 // Check non-set values.
54 assertNull(message.getOptionalInt32());
55 assertNull(message.getOptionalInt64());
56 assertNull(message.getOptionalFloat());
57 assertNull(message.getOptionalString());
58 assertNull(message.getOptionalBytes());
59 assertNull(message.getOptionalNestedMessage());
60 assertNull(message.getOptionalNestedEnum());
61
62 // Check default values.
63 assertEquals(0, message.getOptionalInt32OrDefault());
64 assertEquals('1', message.getOptionalInt64OrDefault());
65 assertEquals(1.5, message.getOptionalFloatOrDefault());
66 assertEquals('', message.getOptionalStringOrDefault());
67 assertEquals('moo', message.getOptionalBytesOrDefault());
68
69 // Set the fields.
70 message.setOptionalInt32(101);
71 message.setOptionalInt64('102');
72 message.setOptionalUint32(103);
73 message.setOptionalUint64('104');
74 message.setOptionalSint32(105);
75 message.setOptionalSint64('106');
76 message.setOptionalFixed32(107);
77 message.setOptionalFixed64('108');
78 message.setOptionalSfixed32(109);
79 message.setOptionalSfixed64('110');
80 message.setOptionalFloat(111.5);
81 message.setOptionalDouble(112.5);
82 message.setOptionalBool(true);
83 message.setOptionalString('test');
84 message.setOptionalBytes('abcd');
85
86 var group = new proto2.TestAllTypes.OptionalGroup();
87 group.setA(111);
88
89 message.setOptionalgroup(group);
90
91 var nestedMessage = new proto2.TestAllTypes.NestedMessage();
92 nestedMessage.setB(112);
93
94 message.setOptionalNestedMessage(nestedMessage);
95
96 message.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
97
98 // Ensure that the fields are set.
99 assertTrue(message.hasOptionalInt32());
100 assertTrue(message.hasOptionalInt64());
101 assertTrue(message.hasOptionalUint32());
102 assertTrue(message.hasOptionalUint64());
103 assertTrue(message.hasOptionalSint32());
104 assertTrue(message.hasOptionalSint64());
105 assertTrue(message.hasOptionalFixed32());
106 assertTrue(message.hasOptionalFixed64());
107 assertTrue(message.hasOptionalSfixed32());
108 assertTrue(message.hasOptionalSfixed64());
109 assertTrue(message.hasOptionalFloat());
110 assertTrue(message.hasOptionalDouble());
111 assertTrue(message.hasOptionalBool());
112 assertTrue(message.hasOptionalString());
113 assertTrue(message.hasOptionalBytes());
114 assertTrue(message.hasOptionalgroup());
115 assertTrue(message.hasOptionalNestedMessage());
116 assertTrue(message.hasOptionalNestedEnum());
117
118 // Ensure that there is a count of 1 for each of the fields.
119 assertEquals(1, message.optionalInt32Count());
120 assertEquals(1, message.optionalInt64Count());
121 assertEquals(1, message.optionalUint32Count());
122 assertEquals(1, message.optionalUint64Count());
123 assertEquals(1, message.optionalSint32Count());
124 assertEquals(1, message.optionalSint64Count());
125 assertEquals(1, message.optionalFixed32Count());
126 assertEquals(1, message.optionalFixed64Count());
127 assertEquals(1, message.optionalSfixed32Count());
128 assertEquals(1, message.optionalSfixed64Count());
129 assertEquals(1, message.optionalFloatCount());
130 assertEquals(1, message.optionalDoubleCount());
131 assertEquals(1, message.optionalBoolCount());
132 assertEquals(1, message.optionalStringCount());
133 assertEquals(1, message.optionalBytesCount());
134 assertEquals(1, message.optionalgroupCount());
135 assertEquals(1, message.optionalNestedMessageCount());
136 assertEquals(1, message.optionalNestedEnumCount());
137
138 // Ensure that the fields have the values expected.
139 assertEquals(101, message.getOptionalInt32());
140 assertEquals('102', message.getOptionalInt64());
141 assertEquals(103, message.getOptionalUint32());
142 assertEquals('104', message.getOptionalUint64());
143 assertEquals(105, message.getOptionalSint32());
144 assertEquals('106', message.getOptionalSint64());
145 assertEquals(107, message.getOptionalFixed32());
146 assertEquals('108', message.getOptionalFixed64());
147 assertEquals(109, message.getOptionalSfixed32());
148 assertEquals('110', message.getOptionalSfixed64());
149 assertEquals(111.5, message.getOptionalFloat());
150 assertEquals(112.5, message.getOptionalDouble());
151 assertEquals(true, message.getOptionalBool());
152 assertEquals('test', message.getOptionalString());
153 assertEquals('abcd', message.getOptionalBytes());
154 assertEquals(group, message.getOptionalgroup());
155 assertEquals(nestedMessage, message.getOptionalNestedMessage());
156 assertEquals(
157 proto2.TestAllTypes.NestedEnum.FOO, message.getOptionalNestedEnum());
158 }
159
160 function testRepeated() {
161 var message = new proto2.TestAllTypes();
162
163 // Ensure that the fields are not set.
164 assertFalse(message.hasRepeatedInt32());
165 assertFalse(message.hasRepeatedInt64());
166 assertFalse(message.hasRepeatedUint32());
167 assertFalse(message.hasRepeatedUint64());
168 assertFalse(message.hasRepeatedSint32());
169 assertFalse(message.hasRepeatedSint64());
170 assertFalse(message.hasRepeatedFixed32());
171 assertFalse(message.hasRepeatedFixed64());
172 assertFalse(message.hasRepeatedSfixed32());
173 assertFalse(message.hasRepeatedSfixed64());
174 assertFalse(message.hasRepeatedFloat());
175 assertFalse(message.hasRepeatedDouble());
176 assertFalse(message.hasRepeatedBool());
177 assertFalse(message.hasRepeatedString());
178 assertFalse(message.hasRepeatedBytes());
179 assertFalse(message.hasRepeatedgroup());
180 assertFalse(message.hasRepeatedNestedMessage());
181 assertFalse(message.hasRepeatedNestedEnum());
182
183 // Expect the arrays to be empty.
184 assertEquals(0, message.repeatedInt32Array().length);
185 assertEquals(0, message.repeatedInt64Array().length);
186 assertEquals(0, message.repeatedUint32Array().length);
187 assertEquals(0, message.repeatedUint64Array().length);
188 assertEquals(0, message.repeatedSint32Array().length);
189 assertEquals(0, message.repeatedSint64Array().length);
190 assertEquals(0, message.repeatedFixed32Array().length);
191 assertEquals(0, message.repeatedFixed64Array().length);
192 assertEquals(0, message.repeatedSfixed32Array().length);
193 assertEquals(0, message.repeatedSfixed64Array().length);
194 assertEquals(0, message.repeatedFloatArray().length);
195 assertEquals(0, message.repeatedDoubleArray().length);
196 assertEquals(0, message.repeatedBoolArray().length);
197 assertEquals(0, message.repeatedStringArray().length);
198 assertEquals(0, message.repeatedBytesArray().length);
199 assertEquals(0, message.repeatedgroupArray().length);
200 assertEquals(0, message.repeatedNestedMessageArray().length);
201 assertEquals(0, message.repeatedNestedEnumArray().length);
202
203 // Set the fields.
204 message.addRepeatedInt32(101);
205 message.addRepeatedInt64('102');
206 message.addRepeatedUint32(103);
207 message.addRepeatedUint64('104');
208 message.addRepeatedSint32(105);
209 message.addRepeatedSint64('106');
210 message.addRepeatedFixed32(107);
211 message.addRepeatedFixed64('108');
212 message.addRepeatedSfixed32(109);
213 message.addRepeatedSfixed64('110');
214 message.addRepeatedFloat(111.5);
215 message.addRepeatedDouble(112.5);
216 message.addRepeatedBool(true);
217 message.addRepeatedString('test');
218 message.addRepeatedBytes('abcd');
219
220 message.addRepeatedInt32(201);
221 message.addRepeatedInt64('202');
222 message.addRepeatedUint32(203);
223 message.addRepeatedUint64('204');
224 message.addRepeatedSint32(205);
225 message.addRepeatedSint64('206');
226 message.addRepeatedFixed32(207);
227 message.addRepeatedFixed64('208');
228 message.addRepeatedSfixed32(209);
229 message.addRepeatedSfixed64('210');
230 message.addRepeatedFloat(211.5);
231 message.addRepeatedDouble(212.5);
232 message.addRepeatedBool(true);
233 message.addRepeatedString('test#2');
234 message.addRepeatedBytes('efgh');
235
236
237 var group1 = new proto2.TestAllTypes.RepeatedGroup();
238 group1.addA(111);
239
240 message.addRepeatedgroup(group1);
241
242 var group2 = new proto2.TestAllTypes.RepeatedGroup();
243 group2.addA(211);
244
245 message.addRepeatedgroup(group2);
246
247 var nestedMessage1 = new proto2.TestAllTypes.NestedMessage();
248 nestedMessage1.setB(112);
249 message.addRepeatedNestedMessage(nestedMessage1);
250
251 var nestedMessage2 = new proto2.TestAllTypes.NestedMessage();
252 nestedMessage2.setB(212);
253 message.addRepeatedNestedMessage(nestedMessage2);
254
255 message.addRepeatedNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
256 message.addRepeatedNestedEnum(proto2.TestAllTypes.NestedEnum.BAR);
257
258 // Ensure that the fields are set.
259 assertTrue(message.hasRepeatedInt32());
260 assertTrue(message.hasRepeatedInt64());
261 assertTrue(message.hasRepeatedUint32());
262 assertTrue(message.hasRepeatedUint64());
263 assertTrue(message.hasRepeatedSint32());
264 assertTrue(message.hasRepeatedSint64());
265 assertTrue(message.hasRepeatedFixed32());
266 assertTrue(message.hasRepeatedFixed64());
267 assertTrue(message.hasRepeatedSfixed32());
268 assertTrue(message.hasRepeatedSfixed64());
269 assertTrue(message.hasRepeatedFloat());
270 assertTrue(message.hasRepeatedDouble());
271 assertTrue(message.hasRepeatedBool());
272 assertTrue(message.hasRepeatedString());
273 assertTrue(message.hasRepeatedBytes());
274 assertTrue(message.hasRepeatedgroup());
275 assertTrue(message.hasRepeatedNestedMessage());
276 assertTrue(message.hasRepeatedNestedEnum());
277
278 // Ensure that there is a count of 2 for each of the fields.
279 assertEquals(2, message.repeatedInt32Count());
280 assertEquals(2, message.repeatedInt64Count());
281 assertEquals(2, message.repeatedUint32Count());
282 assertEquals(2, message.repeatedUint64Count());
283 assertEquals(2, message.repeatedSint32Count());
284 assertEquals(2, message.repeatedSint64Count());
285 assertEquals(2, message.repeatedFixed32Count());
286 assertEquals(2, message.repeatedFixed64Count());
287 assertEquals(2, message.repeatedSfixed32Count());
288 assertEquals(2, message.repeatedSfixed64Count());
289 assertEquals(2, message.repeatedFloatCount());
290 assertEquals(2, message.repeatedDoubleCount());
291 assertEquals(2, message.repeatedBoolCount());
292 assertEquals(2, message.repeatedStringCount());
293 assertEquals(2, message.repeatedBytesCount());
294 assertEquals(2, message.repeatedgroupCount());
295 assertEquals(2, message.repeatedNestedMessageCount());
296 assertEquals(2, message.repeatedNestedEnumCount());
297
298 // Ensure that the fields have the values expected.
299 assertEquals(101, message.getRepeatedInt32(0));
300 assertEquals('102', message.getRepeatedInt64(0));
301 assertEquals(103, message.getRepeatedUint32(0));
302 assertEquals('104', message.getRepeatedUint64(0));
303 assertEquals(105, message.getRepeatedSint32(0));
304 assertEquals('106', message.getRepeatedSint64(0));
305 assertEquals(107, message.getRepeatedFixed32(0));
306 assertEquals('108', message.getRepeatedFixed64(0));
307 assertEquals(109, message.getRepeatedSfixed32(0));
308 assertEquals('110', message.getRepeatedSfixed64(0));
309 assertEquals(111.5, message.getRepeatedFloat(0));
310 assertEquals(112.5, message.getRepeatedDouble(0));
311 assertEquals(true, message.getRepeatedBool(0));
312 assertEquals('test', message.getRepeatedString(0));
313 assertEquals('abcd', message.getRepeatedBytes(0));
314 assertEquals(group1, message.getRepeatedgroup(0));
315 assertEquals(nestedMessage1, message.getRepeatedNestedMessage(0));
316 assertEquals(
317 proto2.TestAllTypes.NestedEnum.FOO, message.getRepeatedNestedEnum(0));
318
319 assertEquals(201, message.getRepeatedInt32(1));
320 assertEquals('202', message.getRepeatedInt64(1));
321 assertEquals(203, message.getRepeatedUint32(1));
322 assertEquals('204', message.getRepeatedUint64(1));
323 assertEquals(205, message.getRepeatedSint32(1));
324 assertEquals('206', message.getRepeatedSint64(1));
325 assertEquals(207, message.getRepeatedFixed32(1));
326 assertEquals('208', message.getRepeatedFixed64(1));
327 assertEquals(209, message.getRepeatedSfixed32(1));
328 assertEquals('210', message.getRepeatedSfixed64(1));
329 assertEquals(211.5, message.getRepeatedFloat(1));
330 assertEquals(212.5, message.getRepeatedDouble(1));
331 assertEquals(true, message.getRepeatedBool(1));
332 assertEquals('test#2', message.getRepeatedString(1));
333 assertEquals('efgh', message.getRepeatedBytes(1));
334 assertEquals(group2, message.getRepeatedgroup(1));
335 assertEquals(nestedMessage2, message.getRepeatedNestedMessage(1));
336 assertEquals(
337 proto2.TestAllTypes.NestedEnum.BAR, message.getRepeatedNestedEnum(1));
338
339 // Check the array lengths.
340 assertEquals(2, message.repeatedInt32Array().length);
341 assertEquals(2, message.repeatedInt64Array().length);
342 assertEquals(2, message.repeatedUint32Array().length);
343 assertEquals(2, message.repeatedUint64Array().length);
344 assertEquals(2, message.repeatedSint32Array().length);
345 assertEquals(2, message.repeatedSint64Array().length);
346 assertEquals(2, message.repeatedFixed32Array().length);
347 assertEquals(2, message.repeatedFixed64Array().length);
348 assertEquals(2, message.repeatedSfixed32Array().length);
349 assertEquals(2, message.repeatedSfixed64Array().length);
350 assertEquals(2, message.repeatedFloatArray().length);
351 assertEquals(2, message.repeatedDoubleArray().length);
352 assertEquals(2, message.repeatedBoolArray().length);
353 assertEquals(2, message.repeatedStringArray().length);
354 assertEquals(2, message.repeatedBytesArray().length);
355 assertEquals(2, message.repeatedgroupArray().length);
356 assertEquals(2, message.repeatedNestedMessageArray().length);
357 assertEquals(2, message.repeatedNestedEnumArray().length);
358
359 // Check the array values.
360 assertEquals(message.getRepeatedInt32(0), message.repeatedInt32Array()[0]);
361 assertEquals(message.getRepeatedInt64(0), message.repeatedInt64Array()[0]);
362 assertEquals(message.getRepeatedUint32(0), message.repeatedUint32Array()[0]);
363 assertEquals(message.getRepeatedUint64(0), message.repeatedUint64Array()[0]);
364 assertEquals(message.getRepeatedSint32(0), message.repeatedSint32Array()[0]);
365 assertEquals(message.getRepeatedSint64(0), message.repeatedSint64Array()[0]);
366 assertEquals(
367 message.getRepeatedFixed32(0), message.repeatedFixed32Array()[0]);
368 assertEquals(
369 message.getRepeatedFixed64(0), message.repeatedFixed64Array()[0]);
370 assertEquals(
371 message.getRepeatedSfixed32(0), message.repeatedSfixed32Array()[0]);
372 assertEquals(
373 message.getRepeatedSfixed64(0), message.repeatedSfixed64Array()[0]);
374 assertEquals(message.getRepeatedFloat(0), message.repeatedFloatArray()[0]);
375 assertEquals(message.getRepeatedDouble(0), message.repeatedDoubleArray()[0]);
376 assertEquals(message.getRepeatedBool(0), message.repeatedBoolArray()[0]);
377 assertEquals(message.getRepeatedString(0), message.repeatedStringArray()[0]);
378 assertEquals(message.getRepeatedBytes(0), message.repeatedBytesArray()[0]);
379 assertEquals(message.getRepeatedgroup(0), message.repeatedgroupArray()[0]);
380 assertEquals(
381 message.getRepeatedNestedMessage(0),
382 message.repeatedNestedMessageArray()[0]);
383 assertEquals(
384 message.getRepeatedNestedEnum(0), message.repeatedNestedEnumArray()[0]);
385
386 assertEquals(message.getRepeatedInt32(1), message.repeatedInt32Array()[1]);
387 assertEquals(message.getRepeatedInt64(1), message.repeatedInt64Array()[1]);
388 assertEquals(message.getRepeatedUint32(1), message.repeatedUint32Array()[1]);
389 assertEquals(message.getRepeatedUint64(1), message.repeatedUint64Array()[1]);
390 assertEquals(message.getRepeatedSint32(1), message.repeatedSint32Array()[1]);
391 assertEquals(message.getRepeatedSint64(1), message.repeatedSint64Array()[1]);
392 assertEquals(
393 message.getRepeatedFixed32(1), message.repeatedFixed32Array()[1]);
394 assertEquals(
395 message.getRepeatedFixed64(1), message.repeatedFixed64Array()[1]);
396 assertEquals(
397 message.getRepeatedSfixed32(1), message.repeatedSfixed32Array()[1]);
398 assertEquals(
399 message.getRepeatedSfixed64(1), message.repeatedSfixed64Array()[1]);
400 assertEquals(message.getRepeatedFloat(1), message.repeatedFloatArray()[1]);
401 assertEquals(message.getRepeatedDouble(1), message.repeatedDoubleArray()[1]);
402 assertEquals(message.getRepeatedBool(1), message.repeatedBoolArray()[1]);
403 assertEquals(message.getRepeatedString(1), message.repeatedStringArray()[1]);
404 assertEquals(message.getRepeatedBytes(1), message.repeatedBytesArray()[1]);
405 assertEquals(message.getRepeatedgroup(1), message.repeatedgroupArray()[1]);
406 assertEquals(
407 message.getRepeatedNestedMessage(1),
408 message.repeatedNestedMessageArray()[1]);
409 assertEquals(
410 message.getRepeatedNestedEnum(1), message.repeatedNestedEnumArray()[1]);
411 }
412
413 function testDescriptor() {
414 var message = new proto2.TestAllTypes();
415 var descriptor = message.getDescriptor();
416
417 assertEquals('TestAllTypes', descriptor.getName());
418 assertEquals('TestAllTypes', descriptor.getFullName());
419 assertEquals(null, descriptor.getContainingType());
420
421 var nestedMessage = new proto2.TestAllTypes.NestedMessage();
422 var nestedDescriptor = nestedMessage.getDescriptor();
423
424 assertEquals('NestedMessage', nestedDescriptor.getName());
425 assertEquals('TestAllTypes.NestedMessage', nestedDescriptor.getFullName());
426 assertEquals(descriptor, nestedDescriptor.getContainingType());
427 }
428
429 function testFieldDescriptor() {
430 var message = new proto2.TestAllTypes();
431 var descriptor = message.getDescriptor();
432 var fields = descriptor.getFields();
433
434 assertEquals(53, fields.length);
435
436 // Check the containing types.
437 for (var i = 0; i < fields.length; ++i) {
438 assertEquals(descriptor, fields[i].getContainingType());
439 }
440
441 // Check the field names.
442 assertEquals('optional_int32', fields[0].getName());
443 assertEquals('optional_int64', fields[1].getName());
444 assertEquals('optional_uint32', fields[2].getName());
445 assertEquals('optional_uint64', fields[3].getName());
446 assertEquals('optional_sint32', fields[4].getName());
447 assertEquals('optional_sint64', fields[5].getName());
448 assertEquals('optional_fixed32', fields[6].getName());
449 assertEquals('optional_fixed64', fields[7].getName());
450 assertEquals('optional_sfixed32', fields[8].getName());
451 assertEquals('optional_sfixed64', fields[9].getName());
452 assertEquals('optional_float', fields[10].getName());
453 assertEquals('optional_double', fields[11].getName());
454 assertEquals('optional_bool', fields[12].getName());
455 assertEquals('optional_string', fields[13].getName());
456 assertEquals('optional_bytes', fields[14].getName());
457 assertEquals('optionalgroup', fields[15].getName());
458 assertEquals('optional_nested_message', fields[16].getName());
459 assertEquals('optional_nested_enum', fields[17].getName());
460
461 assertEquals('repeated_int32', fields[18].getName());
462 assertEquals('repeated_int64', fields[19].getName());
463 assertEquals('repeated_uint32', fields[20].getName());
464 assertEquals('repeated_uint64', fields[21].getName());
465 assertEquals('repeated_sint32', fields[22].getName());
466 assertEquals('repeated_sint64', fields[23].getName());
467 assertEquals('repeated_fixed32', fields[24].getName());
468 assertEquals('repeated_fixed64', fields[25].getName());
469 assertEquals('repeated_sfixed32', fields[26].getName());
470 assertEquals('repeated_sfixed64', fields[27].getName());
471 assertEquals('repeated_float', fields[28].getName());
472 assertEquals('repeated_double', fields[29].getName());
473 assertEquals('repeated_bool', fields[30].getName());
474 assertEquals('repeated_string', fields[31].getName());
475 assertEquals('repeated_bytes', fields[32].getName());
476 assertEquals('repeatedgroup', fields[33].getName());
477 assertEquals('repeated_nested_message', fields[34].getName());
478 assertEquals('repeated_nested_enum', fields[35].getName());
479
480 assertEquals('optional_int64_number', fields[36].getName());
481 assertEquals('optional_int64_string', fields[37].getName());
482 assertEquals('repeated_int64_number', fields[38].getName());
483 assertEquals('repeated_int64_string', fields[39].getName());
484
485 assertEquals('packed_int32', fields[40].getName());
486 assertEquals('packed_int64', fields[41].getName());
487 assertEquals('packed_uint32', fields[42].getName());
488 assertEquals('packed_uint64', fields[43].getName());
489 assertEquals('packed_sint32', fields[44].getName());
490 assertEquals('packed_sint64', fields[45].getName());
491 assertEquals('packed_fixed32', fields[46].getName());
492 assertEquals('packed_fixed64', fields[47].getName());
493 assertEquals('packed_sfixed32', fields[48].getName());
494 assertEquals('packed_sfixed64', fields[49].getName());
495 assertEquals('packed_float', fields[50].getName());
496 assertEquals('packed_double', fields[51].getName());
497 assertEquals('packed_bool', fields[52].getName());
498
499 // Check the field types.
500 var FieldType = goog.proto2.FieldDescriptor.FieldType;
501 assertEquals(FieldType.INT32, fields[0].getFieldType());
502 assertEquals(FieldType.INT64, fields[1].getFieldType());
503 assertEquals(FieldType.UINT32, fields[2].getFieldType());
504 assertEquals(FieldType.UINT64, fields[3].getFieldType());
505 assertEquals(FieldType.SINT32, fields[4].getFieldType());
506 assertEquals(FieldType.SINT64, fields[5].getFieldType());
507 assertEquals(FieldType.FIXED32, fields[6].getFieldType());
508 assertEquals(FieldType.FIXED64, fields[7].getFieldType());
509 assertEquals(FieldType.SFIXED32, fields[8].getFieldType());
510 assertEquals(FieldType.SFIXED64, fields[9].getFieldType());
511 assertEquals(FieldType.FLOAT, fields[10].getFieldType());
512 assertEquals(FieldType.DOUBLE, fields[11].getFieldType());
513 assertEquals(FieldType.BOOL, fields[12].getFieldType());
514 assertEquals(FieldType.STRING, fields[13].getFieldType());
515 assertEquals(FieldType.BYTES, fields[14].getFieldType());
516 assertEquals(FieldType.GROUP, fields[15].getFieldType());
517 assertEquals(FieldType.MESSAGE, fields[16].getFieldType());
518 assertEquals(FieldType.ENUM, fields[17].getFieldType());
519
520 assertEquals(FieldType.INT32, fields[18].getFieldType());
521 assertEquals(FieldType.INT64, fields[19].getFieldType());
522 assertEquals(FieldType.UINT32, fields[20].getFieldType());
523 assertEquals(FieldType.UINT64, fields[21].getFieldType());
524 assertEquals(FieldType.SINT32, fields[22].getFieldType());
525 assertEquals(FieldType.SINT64, fields[23].getFieldType());
526 assertEquals(FieldType.FIXED32, fields[24].getFieldType());
527 assertEquals(FieldType.FIXED64, fields[25].getFieldType());
528 assertEquals(FieldType.SFIXED32, fields[26].getFieldType());
529 assertEquals(FieldType.SFIXED64, fields[27].getFieldType());
530 assertEquals(FieldType.FLOAT, fields[28].getFieldType());
531 assertEquals(FieldType.DOUBLE, fields[29].getFieldType());
532 assertEquals(FieldType.BOOL, fields[30].getFieldType());
533 assertEquals(FieldType.STRING, fields[31].getFieldType());
534 assertEquals(FieldType.BYTES, fields[32].getFieldType());
535 assertEquals(FieldType.GROUP, fields[33].getFieldType());
536 assertEquals(FieldType.MESSAGE, fields[34].getFieldType());
537 assertEquals(FieldType.ENUM, fields[35].getFieldType());
538
539 assertEquals(FieldType.INT64, fields[36].getFieldType());
540 assertEquals(FieldType.INT64, fields[37].getFieldType());
541 assertEquals(FieldType.INT64, fields[38].getFieldType());
542 assertEquals(FieldType.INT64, fields[39].getFieldType());
543
544 assertEquals(FieldType.INT32, fields[40].getFieldType());
545 assertEquals(FieldType.INT64, fields[41].getFieldType());
546 assertEquals(FieldType.UINT32, fields[42].getFieldType());
547 assertEquals(FieldType.UINT64, fields[43].getFieldType());
548 assertEquals(FieldType.SINT32, fields[44].getFieldType());
549 assertEquals(FieldType.SINT64, fields[45].getFieldType());
550 assertEquals(FieldType.FIXED32, fields[46].getFieldType());
551 assertEquals(FieldType.FIXED64, fields[47].getFieldType());
552 assertEquals(FieldType.SFIXED32, fields[48].getFieldType());
553 assertEquals(FieldType.SFIXED64, fields[49].getFieldType());
554 assertEquals(FieldType.FLOAT, fields[50].getFieldType());
555 assertEquals(FieldType.DOUBLE, fields[51].getFieldType());
556 assertEquals(FieldType.BOOL, fields[52].getFieldType());
557
558 // Check the field native types.
559 // Singular.
560 assertEquals(Number, fields[0].getNativeType());
561 assertEquals(
562 String, fields[1].getNativeType()); // 64 bit values are strings.
563 assertEquals(Number, fields[2].getNativeType());
564 assertEquals(String, fields[3].getNativeType());
565 assertEquals(Number, fields[4].getNativeType());
566 assertEquals(String, fields[5].getNativeType());
567 assertEquals(Number, fields[6].getNativeType());
568 assertEquals(String, fields[7].getNativeType());
569 assertEquals(Number, fields[8].getNativeType());
570 assertEquals(String, fields[9].getNativeType());
571 assertEquals(Number, fields[10].getNativeType());
572 assertEquals(Number, fields[11].getNativeType());
573
574 assertEquals(Boolean, fields[12].getNativeType());
575
576 assertEquals(String, fields[13].getNativeType());
577 assertEquals(String, fields[14].getNativeType());
578
579 assertEquals(proto2.TestAllTypes.OptionalGroup, fields[15].getNativeType());
580 assertEquals(proto2.TestAllTypes.NestedMessage, fields[16].getNativeType());
581 assertEquals(proto2.TestAllTypes.NestedEnum, fields[17].getNativeType());
582
583 assertEquals(Number, fields[36].getNativeType()); // [jstype="number"]
584 assertEquals(String, fields[37].getNativeType());
585
586 // Repeated.
587 assertEquals(Number, fields[18].getNativeType());
588 assertEquals(String, fields[19].getNativeType());
589 assertEquals(Number, fields[20].getNativeType());
590 assertEquals(String, fields[21].getNativeType());
591 assertEquals(Number, fields[22].getNativeType());
592 assertEquals(String, fields[23].getNativeType());
593 assertEquals(Number, fields[24].getNativeType());
594 assertEquals(String, fields[25].getNativeType());
595 assertEquals(Number, fields[26].getNativeType());
596 assertEquals(String, fields[27].getNativeType());
597 assertEquals(Number, fields[28].getNativeType());
598 assertEquals(Number, fields[29].getNativeType());
599
600 assertEquals(Boolean, fields[30].getNativeType());
601
602 assertEquals(String, fields[31].getNativeType());
603 assertEquals(String, fields[32].getNativeType());
604
605 assertEquals(proto2.TestAllTypes.RepeatedGroup, fields[33].getNativeType());
606 assertEquals(proto2.TestAllTypes.NestedMessage, fields[34].getNativeType());
607 assertEquals(proto2.TestAllTypes.NestedEnum, fields[35].getNativeType());
608
609 assertEquals(Number, fields[38].getNativeType()); // [jstype="number"]
610 assertEquals(String, fields[39].getNativeType());
611
612 // Packed (only numeric types can be packed).
613 assertEquals(Number, fields[40].getNativeType());
614 assertEquals(Number, fields[41].getNativeType());
615 assertEquals(Number, fields[42].getNativeType());
616 assertEquals(Number, fields[43].getNativeType());
617 assertEquals(Number, fields[44].getNativeType());
618 assertEquals(Number, fields[45].getNativeType());
619 assertEquals(Number, fields[46].getNativeType());
620 assertEquals(Number, fields[47].getNativeType());
621 assertEquals(Number, fields[48].getNativeType());
622 assertEquals(Number, fields[49].getNativeType());
623 assertEquals(Number, fields[50].getNativeType());
624 assertEquals(Number, fields[51].getNativeType());
625 assertEquals(Boolean, fields[52].getNativeType());
626 }
627
628 function testUnknown() {
629 var message = new proto2.TestAllTypes();
630
631 // Set some unknown fields.
632 message.setUnknown(1000, 101);
633 message.setUnknown(1001, -102);
634 message.setUnknown(1002, true);
635 message.setUnknown(1003, 'abcd');
636 message.setUnknown(1004, ['he', 'llo']);
637
638 // Ensure we find them all.
639 var count = 0;
640
641 message.forEachUnknown(function(tag, value) {
642 if (tag == 1000) {
643 assertEquals(101, value);
644 }
645
646 if (tag == 1001) {
647 assertEquals(-102, value);
648 }
649
650 if (tag == 1002) {
651 assertEquals(true, value);
652 }
653
654 if (tag == 1003) {
655 assertEquals('abcd', value);
656 }
657
658 if (tag == 1004) {
659 assertEquals('he', value[0]);
660 assertEquals('llo', value[1]);
661 }
662
663 count++;
664 });
665
666 assertEquals(5, count);
667 }
668
669 function testReflection() {
670 var message = new proto2.TestAllTypes();
671 var descriptor = message.getDescriptor();
672 var optionalInt = descriptor.findFieldByName('optional_int32');
673 var optionalString = descriptor.findFieldByName('optional_string');
674 var repeatedInt64 = descriptor.findFieldByName('repeated_int64');
675 var optionalWrong = descriptor.findFieldByName('foo_bar');
676
677 assertFalse(optionalInt == null);
678 assertFalse(optionalString == null);
679 assertFalse(repeatedInt64 == null);
680 assertTrue(optionalWrong == null);
681
682 // Check to ensure the fields are empty.
683 assertFalse(message.has(optionalInt));
684 assertFalse(message.has(optionalString));
685 assertFalse(message.has(repeatedInt64));
686
687 assertEquals(0, message.arrayOf(repeatedInt64).length);
688
689 // Check default values.
690 assertEquals(0, message.getOrDefault(optionalInt));
691 assertEquals('', message.getOrDefault(optionalString));
692
693 // Set some of the fields.
694 message.set(optionalString, 'hello!');
695
696 message.add(repeatedInt64, '101');
697 message.add(repeatedInt64, '102');
698
699 // Check the fields.
700 assertFalse(message.has(optionalInt));
701
702 assertTrue(message.has(optionalString));
703 assertTrue(message.hasOptionalString());
704
705 assertTrue(message.has(repeatedInt64));
706 assertTrue(message.hasRepeatedInt64());
707
708 // Check the values.
709 assertEquals('hello!', message.get(optionalString));
710 assertEquals('hello!', message.getOptionalString());
711
712 assertEquals('101', message.get(repeatedInt64, 0));
713 assertEquals('102', message.get(repeatedInt64, 1));
714
715 assertEquals('101', message.getRepeatedInt64(0));
716 assertEquals('102', message.getRepeatedInt64(1));
717
718 // Check the count.
719 assertEquals(0, message.countOf(optionalInt));
720
721 assertEquals(1, message.countOf(optionalString));
722 assertEquals(1, message.optionalStringCount());
723
724 assertEquals(2, message.countOf(repeatedInt64));
725 assertEquals(2, message.repeatedInt64Count());
726
727 // Check the array.
728 assertEquals(2, message.arrayOf(repeatedInt64).length);
729
730 assertEquals(
731 message.get(repeatedInt64, 0), message.arrayOf(repeatedInt64)[0]);
732
733 assertEquals(
734 message.get(repeatedInt64, 1), message.arrayOf(repeatedInt64)[1]);
735 }
736
737 function testDefaultValuesForMessages() {
738 var message = new proto2.TestDefaultParent();
739 // Ideally this object would be immutable, but the current API does not
740 // enforce that behavior, so get**OrDefault returns a new instance every time.
741 var child = message.getChildOrDefault();
742 child.setFoo(false);
743 // Changing the value returned by get**OrDefault does not actually change
744 // the value stored in the parent message.
745 assertFalse(message.hasChild());
746 assertNull(message.getChild());
747
748 var message2 = new proto2.TestDefaultParent();
749 var child2 = message2.getChildOrDefault();
750 assertNull(message2.getChild());
751
752 // The parent message returns a different object for the default.
753 assertNotEquals(child, child2);
754
755 // You've only changed the value of child, so child2 should be unaffected.
756 assertFalse(child2.hasFoo());
757 assertTrue(child2.getFooOrDefault());
758 }