Andreas Hocevar
756 lines
32 KiB
JavaScript
756 lines
32 KiB
JavaScript
// Copyright 2008 The Closure Library Authors. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS-IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
goog.provide('goog.proto2.messageTest');
|
|
goog.setTestOnly('goog.proto2.messageTest');
|
|
|
|
goog.require('goog.proto2.FieldDescriptor');
|
|
goog.require('goog.testing.jsunit');
|
|
goog.require('proto2.TestAllTypes');
|
|
goog.require('someprotopackage.TestPackageTypes');
|
|
|
|
function testPackage() {
|
|
var message = new someprotopackage.TestPackageTypes();
|
|
message.setOptionalInt32(45);
|
|
message.setOtherAll(new proto2.TestAllTypes());
|
|
}
|
|
|
|
function testFields() {
|
|
var message = new proto2.TestAllTypes();
|
|
|
|
// Ensure that the fields are not set.
|
|
assertFalse(message.hasOptionalInt32());
|
|
assertFalse(message.hasOptionalInt64());
|
|
assertFalse(message.hasOptionalUint32());
|
|
assertFalse(message.hasOptionalUint64());
|
|
assertFalse(message.hasOptionalSint32());
|
|
assertFalse(message.hasOptionalSint64());
|
|
assertFalse(message.hasOptionalFixed32());
|
|
assertFalse(message.hasOptionalFixed64());
|
|
assertFalse(message.hasOptionalSfixed32());
|
|
assertFalse(message.hasOptionalSfixed64());
|
|
assertFalse(message.hasOptionalFloat());
|
|
assertFalse(message.hasOptionalDouble());
|
|
assertFalse(message.hasOptionalBool());
|
|
assertFalse(message.hasOptionalString());
|
|
assertFalse(message.hasOptionalBytes());
|
|
assertFalse(message.hasOptionalgroup());
|
|
assertFalse(message.hasOptionalNestedMessage());
|
|
assertFalse(message.hasOptionalNestedEnum());
|
|
|
|
// Check non-set values.
|
|
assertNull(message.getOptionalInt32());
|
|
assertNull(message.getOptionalInt64());
|
|
assertNull(message.getOptionalFloat());
|
|
assertNull(message.getOptionalString());
|
|
assertNull(message.getOptionalBytes());
|
|
assertNull(message.getOptionalNestedMessage());
|
|
assertNull(message.getOptionalNestedEnum());
|
|
|
|
// Check default values.
|
|
assertEquals(0, message.getOptionalInt32OrDefault());
|
|
assertEquals('1', message.getOptionalInt64OrDefault());
|
|
assertEquals(1.5, message.getOptionalFloatOrDefault());
|
|
assertEquals('', message.getOptionalStringOrDefault());
|
|
assertEquals('moo', message.getOptionalBytesOrDefault());
|
|
|
|
// Set the fields.
|
|
message.setOptionalInt32(101);
|
|
message.setOptionalInt64('102');
|
|
message.setOptionalUint32(103);
|
|
message.setOptionalUint64('104');
|
|
message.setOptionalSint32(105);
|
|
message.setOptionalSint64('106');
|
|
message.setOptionalFixed32(107);
|
|
message.setOptionalFixed64('108');
|
|
message.setOptionalSfixed32(109);
|
|
message.setOptionalSfixed64('110');
|
|
message.setOptionalFloat(111.5);
|
|
message.setOptionalDouble(112.5);
|
|
message.setOptionalBool(true);
|
|
message.setOptionalString('test');
|
|
message.setOptionalBytes('abcd');
|
|
|
|
var group = new proto2.TestAllTypes.OptionalGroup();
|
|
group.setA(111);
|
|
|
|
message.setOptionalgroup(group);
|
|
|
|
var nestedMessage = new proto2.TestAllTypes.NestedMessage();
|
|
nestedMessage.setB(112);
|
|
|
|
message.setOptionalNestedMessage(nestedMessage);
|
|
|
|
message.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
|
|
|
|
// Ensure that the fields are set.
|
|
assertTrue(message.hasOptionalInt32());
|
|
assertTrue(message.hasOptionalInt64());
|
|
assertTrue(message.hasOptionalUint32());
|
|
assertTrue(message.hasOptionalUint64());
|
|
assertTrue(message.hasOptionalSint32());
|
|
assertTrue(message.hasOptionalSint64());
|
|
assertTrue(message.hasOptionalFixed32());
|
|
assertTrue(message.hasOptionalFixed64());
|
|
assertTrue(message.hasOptionalSfixed32());
|
|
assertTrue(message.hasOptionalSfixed64());
|
|
assertTrue(message.hasOptionalFloat());
|
|
assertTrue(message.hasOptionalDouble());
|
|
assertTrue(message.hasOptionalBool());
|
|
assertTrue(message.hasOptionalString());
|
|
assertTrue(message.hasOptionalBytes());
|
|
assertTrue(message.hasOptionalgroup());
|
|
assertTrue(message.hasOptionalNestedMessage());
|
|
assertTrue(message.hasOptionalNestedEnum());
|
|
|
|
// Ensure that there is a count of 1 for each of the fields.
|
|
assertEquals(1, message.optionalInt32Count());
|
|
assertEquals(1, message.optionalInt64Count());
|
|
assertEquals(1, message.optionalUint32Count());
|
|
assertEquals(1, message.optionalUint64Count());
|
|
assertEquals(1, message.optionalSint32Count());
|
|
assertEquals(1, message.optionalSint64Count());
|
|
assertEquals(1, message.optionalFixed32Count());
|
|
assertEquals(1, message.optionalFixed64Count());
|
|
assertEquals(1, message.optionalSfixed32Count());
|
|
assertEquals(1, message.optionalSfixed64Count());
|
|
assertEquals(1, message.optionalFloatCount());
|
|
assertEquals(1, message.optionalDoubleCount());
|
|
assertEquals(1, message.optionalBoolCount());
|
|
assertEquals(1, message.optionalStringCount());
|
|
assertEquals(1, message.optionalBytesCount());
|
|
assertEquals(1, message.optionalgroupCount());
|
|
assertEquals(1, message.optionalNestedMessageCount());
|
|
assertEquals(1, message.optionalNestedEnumCount());
|
|
|
|
// Ensure that the fields have the values expected.
|
|
assertEquals(101, message.getOptionalInt32());
|
|
assertEquals('102', message.getOptionalInt64());
|
|
assertEquals(103, message.getOptionalUint32());
|
|
assertEquals('104', message.getOptionalUint64());
|
|
assertEquals(105, message.getOptionalSint32());
|
|
assertEquals('106', message.getOptionalSint64());
|
|
assertEquals(107, message.getOptionalFixed32());
|
|
assertEquals('108', message.getOptionalFixed64());
|
|
assertEquals(109, message.getOptionalSfixed32());
|
|
assertEquals('110', message.getOptionalSfixed64());
|
|
assertEquals(111.5, message.getOptionalFloat());
|
|
assertEquals(112.5, message.getOptionalDouble());
|
|
assertEquals(true, message.getOptionalBool());
|
|
assertEquals('test', message.getOptionalString());
|
|
assertEquals('abcd', message.getOptionalBytes());
|
|
assertEquals(group, message.getOptionalgroup());
|
|
assertEquals(nestedMessage, message.getOptionalNestedMessage());
|
|
assertEquals(proto2.TestAllTypes.NestedEnum.FOO,
|
|
message.getOptionalNestedEnum());
|
|
}
|
|
|
|
function testRepeated() {
|
|
var message = new proto2.TestAllTypes();
|
|
|
|
// Ensure that the fields are not set.
|
|
assertFalse(message.hasRepeatedInt32());
|
|
assertFalse(message.hasRepeatedInt64());
|
|
assertFalse(message.hasRepeatedUint32());
|
|
assertFalse(message.hasRepeatedUint64());
|
|
assertFalse(message.hasRepeatedSint32());
|
|
assertFalse(message.hasRepeatedSint64());
|
|
assertFalse(message.hasRepeatedFixed32());
|
|
assertFalse(message.hasRepeatedFixed64());
|
|
assertFalse(message.hasRepeatedSfixed32());
|
|
assertFalse(message.hasRepeatedSfixed64());
|
|
assertFalse(message.hasRepeatedFloat());
|
|
assertFalse(message.hasRepeatedDouble());
|
|
assertFalse(message.hasRepeatedBool());
|
|
assertFalse(message.hasRepeatedString());
|
|
assertFalse(message.hasRepeatedBytes());
|
|
assertFalse(message.hasRepeatedgroup());
|
|
assertFalse(message.hasRepeatedNestedMessage());
|
|
assertFalse(message.hasRepeatedNestedEnum());
|
|
|
|
// Expect the arrays to be empty.
|
|
assertEquals(0, message.repeatedInt32Array().length);
|
|
assertEquals(0, message.repeatedInt64Array().length);
|
|
assertEquals(0, message.repeatedUint32Array().length);
|
|
assertEquals(0, message.repeatedUint64Array().length);
|
|
assertEquals(0, message.repeatedSint32Array().length);
|
|
assertEquals(0, message.repeatedSint64Array().length);
|
|
assertEquals(0, message.repeatedFixed32Array().length);
|
|
assertEquals(0, message.repeatedFixed64Array().length);
|
|
assertEquals(0, message.repeatedSfixed32Array().length);
|
|
assertEquals(0, message.repeatedSfixed64Array().length);
|
|
assertEquals(0, message.repeatedFloatArray().length);
|
|
assertEquals(0, message.repeatedDoubleArray().length);
|
|
assertEquals(0, message.repeatedBoolArray().length);
|
|
assertEquals(0, message.repeatedStringArray().length);
|
|
assertEquals(0, message.repeatedBytesArray().length);
|
|
assertEquals(0, message.repeatedgroupArray().length);
|
|
assertEquals(0, message.repeatedNestedMessageArray().length);
|
|
assertEquals(0, message.repeatedNestedEnumArray().length);
|
|
|
|
// Set the fields.
|
|
message.addRepeatedInt32(101);
|
|
message.addRepeatedInt64('102');
|
|
message.addRepeatedUint32(103);
|
|
message.addRepeatedUint64('104');
|
|
message.addRepeatedSint32(105);
|
|
message.addRepeatedSint64('106');
|
|
message.addRepeatedFixed32(107);
|
|
message.addRepeatedFixed64('108');
|
|
message.addRepeatedSfixed32(109);
|
|
message.addRepeatedSfixed64('110');
|
|
message.addRepeatedFloat(111.5);
|
|
message.addRepeatedDouble(112.5);
|
|
message.addRepeatedBool(true);
|
|
message.addRepeatedString('test');
|
|
message.addRepeatedBytes('abcd');
|
|
|
|
message.addRepeatedInt32(201);
|
|
message.addRepeatedInt64('202');
|
|
message.addRepeatedUint32(203);
|
|
message.addRepeatedUint64('204');
|
|
message.addRepeatedSint32(205);
|
|
message.addRepeatedSint64('206');
|
|
message.addRepeatedFixed32(207);
|
|
message.addRepeatedFixed64('208');
|
|
message.addRepeatedSfixed32(209);
|
|
message.addRepeatedSfixed64('210');
|
|
message.addRepeatedFloat(211.5);
|
|
message.addRepeatedDouble(212.5);
|
|
message.addRepeatedBool(true);
|
|
message.addRepeatedString('test#2');
|
|
message.addRepeatedBytes('efgh');
|
|
|
|
|
|
var group1 = new proto2.TestAllTypes.RepeatedGroup();
|
|
group1.addA(111);
|
|
|
|
message.addRepeatedgroup(group1);
|
|
|
|
var group2 = new proto2.TestAllTypes.RepeatedGroup();
|
|
group2.addA(211);
|
|
|
|
message.addRepeatedgroup(group2);
|
|
|
|
var nestedMessage1 = new proto2.TestAllTypes.NestedMessage();
|
|
nestedMessage1.setB(112);
|
|
message.addRepeatedNestedMessage(nestedMessage1);
|
|
|
|
var nestedMessage2 = new proto2.TestAllTypes.NestedMessage();
|
|
nestedMessage2.setB(212);
|
|
message.addRepeatedNestedMessage(nestedMessage2);
|
|
|
|
message.addRepeatedNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
|
|
message.addRepeatedNestedEnum(proto2.TestAllTypes.NestedEnum.BAR);
|
|
|
|
// Ensure that the fields are set.
|
|
assertTrue(message.hasRepeatedInt32());
|
|
assertTrue(message.hasRepeatedInt64());
|
|
assertTrue(message.hasRepeatedUint32());
|
|
assertTrue(message.hasRepeatedUint64());
|
|
assertTrue(message.hasRepeatedSint32());
|
|
assertTrue(message.hasRepeatedSint64());
|
|
assertTrue(message.hasRepeatedFixed32());
|
|
assertTrue(message.hasRepeatedFixed64());
|
|
assertTrue(message.hasRepeatedSfixed32());
|
|
assertTrue(message.hasRepeatedSfixed64());
|
|
assertTrue(message.hasRepeatedFloat());
|
|
assertTrue(message.hasRepeatedDouble());
|
|
assertTrue(message.hasRepeatedBool());
|
|
assertTrue(message.hasRepeatedString());
|
|
assertTrue(message.hasRepeatedBytes());
|
|
assertTrue(message.hasRepeatedgroup());
|
|
assertTrue(message.hasRepeatedNestedMessage());
|
|
assertTrue(message.hasRepeatedNestedEnum());
|
|
|
|
// Ensure that there is a count of 2 for each of the fields.
|
|
assertEquals(2, message.repeatedInt32Count());
|
|
assertEquals(2, message.repeatedInt64Count());
|
|
assertEquals(2, message.repeatedUint32Count());
|
|
assertEquals(2, message.repeatedUint64Count());
|
|
assertEquals(2, message.repeatedSint32Count());
|
|
assertEquals(2, message.repeatedSint64Count());
|
|
assertEquals(2, message.repeatedFixed32Count());
|
|
assertEquals(2, message.repeatedFixed64Count());
|
|
assertEquals(2, message.repeatedSfixed32Count());
|
|
assertEquals(2, message.repeatedSfixed64Count());
|
|
assertEquals(2, message.repeatedFloatCount());
|
|
assertEquals(2, message.repeatedDoubleCount());
|
|
assertEquals(2, message.repeatedBoolCount());
|
|
assertEquals(2, message.repeatedStringCount());
|
|
assertEquals(2, message.repeatedBytesCount());
|
|
assertEquals(2, message.repeatedgroupCount());
|
|
assertEquals(2, message.repeatedNestedMessageCount());
|
|
assertEquals(2, message.repeatedNestedEnumCount());
|
|
|
|
// Ensure that the fields have the values expected.
|
|
assertEquals(101, message.getRepeatedInt32(0));
|
|
assertEquals('102', message.getRepeatedInt64(0));
|
|
assertEquals(103, message.getRepeatedUint32(0));
|
|
assertEquals('104', message.getRepeatedUint64(0));
|
|
assertEquals(105, message.getRepeatedSint32(0));
|
|
assertEquals('106', message.getRepeatedSint64(0));
|
|
assertEquals(107, message.getRepeatedFixed32(0));
|
|
assertEquals('108', message.getRepeatedFixed64(0));
|
|
assertEquals(109, message.getRepeatedSfixed32(0));
|
|
assertEquals('110', message.getRepeatedSfixed64(0));
|
|
assertEquals(111.5, message.getRepeatedFloat(0));
|
|
assertEquals(112.5, message.getRepeatedDouble(0));
|
|
assertEquals(true, message.getRepeatedBool(0));
|
|
assertEquals('test', message.getRepeatedString(0));
|
|
assertEquals('abcd', message.getRepeatedBytes(0));
|
|
assertEquals(group1, message.getRepeatedgroup(0));
|
|
assertEquals(nestedMessage1, message.getRepeatedNestedMessage(0));
|
|
assertEquals(proto2.TestAllTypes.NestedEnum.FOO,
|
|
message.getRepeatedNestedEnum(0));
|
|
|
|
assertEquals(201, message.getRepeatedInt32(1));
|
|
assertEquals('202', message.getRepeatedInt64(1));
|
|
assertEquals(203, message.getRepeatedUint32(1));
|
|
assertEquals('204', message.getRepeatedUint64(1));
|
|
assertEquals(205, message.getRepeatedSint32(1));
|
|
assertEquals('206', message.getRepeatedSint64(1));
|
|
assertEquals(207, message.getRepeatedFixed32(1));
|
|
assertEquals('208', message.getRepeatedFixed64(1));
|
|
assertEquals(209, message.getRepeatedSfixed32(1));
|
|
assertEquals('210', message.getRepeatedSfixed64(1));
|
|
assertEquals(211.5, message.getRepeatedFloat(1));
|
|
assertEquals(212.5, message.getRepeatedDouble(1));
|
|
assertEquals(true, message.getRepeatedBool(1));
|
|
assertEquals('test#2', message.getRepeatedString(1));
|
|
assertEquals('efgh', message.getRepeatedBytes(1));
|
|
assertEquals(group2, message.getRepeatedgroup(1));
|
|
assertEquals(nestedMessage2, message.getRepeatedNestedMessage(1));
|
|
assertEquals(proto2.TestAllTypes.NestedEnum.BAR,
|
|
message.getRepeatedNestedEnum(1));
|
|
|
|
// Check the array lengths.
|
|
assertEquals(2, message.repeatedInt32Array().length);
|
|
assertEquals(2, message.repeatedInt64Array().length);
|
|
assertEquals(2, message.repeatedUint32Array().length);
|
|
assertEquals(2, message.repeatedUint64Array().length);
|
|
assertEquals(2, message.repeatedSint32Array().length);
|
|
assertEquals(2, message.repeatedSint64Array().length);
|
|
assertEquals(2, message.repeatedFixed32Array().length);
|
|
assertEquals(2, message.repeatedFixed64Array().length);
|
|
assertEquals(2, message.repeatedSfixed32Array().length);
|
|
assertEquals(2, message.repeatedSfixed64Array().length);
|
|
assertEquals(2, message.repeatedFloatArray().length);
|
|
assertEquals(2, message.repeatedDoubleArray().length);
|
|
assertEquals(2, message.repeatedBoolArray().length);
|
|
assertEquals(2, message.repeatedStringArray().length);
|
|
assertEquals(2, message.repeatedBytesArray().length);
|
|
assertEquals(2, message.repeatedgroupArray().length);
|
|
assertEquals(2, message.repeatedNestedMessageArray().length);
|
|
assertEquals(2, message.repeatedNestedEnumArray().length);
|
|
|
|
// Check the array values.
|
|
assertEquals(message.getRepeatedInt32(0), message.repeatedInt32Array()[0]);
|
|
assertEquals(message.getRepeatedInt64(0), message.repeatedInt64Array()[0]);
|
|
assertEquals(message.getRepeatedUint32(0), message.repeatedUint32Array()[0]);
|
|
assertEquals(message.getRepeatedUint64(0), message.repeatedUint64Array()[0]);
|
|
assertEquals(message.getRepeatedSint32(0), message.repeatedSint32Array()[0]);
|
|
assertEquals(message.getRepeatedSint64(0), message.repeatedSint64Array()[0]);
|
|
assertEquals(message.getRepeatedFixed32(0),
|
|
message.repeatedFixed32Array()[0]);
|
|
assertEquals(message.getRepeatedFixed64(0),
|
|
message.repeatedFixed64Array()[0]);
|
|
assertEquals(message.getRepeatedSfixed32(0),
|
|
message.repeatedSfixed32Array()[0]);
|
|
assertEquals(message.getRepeatedSfixed64(0),
|
|
message.repeatedSfixed64Array()[0]);
|
|
assertEquals(message.getRepeatedFloat(0), message.repeatedFloatArray()[0]);
|
|
assertEquals(message.getRepeatedDouble(0), message.repeatedDoubleArray()[0]);
|
|
assertEquals(message.getRepeatedBool(0), message.repeatedBoolArray()[0]);
|
|
assertEquals(message.getRepeatedString(0), message.repeatedStringArray()[0]);
|
|
assertEquals(message.getRepeatedBytes(0), message.repeatedBytesArray()[0]);
|
|
assertEquals(message.getRepeatedgroup(0), message.repeatedgroupArray()[0]);
|
|
assertEquals(message.getRepeatedNestedMessage(0),
|
|
message.repeatedNestedMessageArray()[0]);
|
|
assertEquals(message.getRepeatedNestedEnum(0),
|
|
message.repeatedNestedEnumArray()[0]);
|
|
|
|
assertEquals(message.getRepeatedInt32(1), message.repeatedInt32Array()[1]);
|
|
assertEquals(message.getRepeatedInt64(1), message.repeatedInt64Array()[1]);
|
|
assertEquals(message.getRepeatedUint32(1), message.repeatedUint32Array()[1]);
|
|
assertEquals(message.getRepeatedUint64(1), message.repeatedUint64Array()[1]);
|
|
assertEquals(message.getRepeatedSint32(1), message.repeatedSint32Array()[1]);
|
|
assertEquals(message.getRepeatedSint64(1), message.repeatedSint64Array()[1]);
|
|
assertEquals(message.getRepeatedFixed32(1),
|
|
message.repeatedFixed32Array()[1]);
|
|
assertEquals(message.getRepeatedFixed64(1),
|
|
message.repeatedFixed64Array()[1]);
|
|
assertEquals(message.getRepeatedSfixed32(1),
|
|
message.repeatedSfixed32Array()[1]);
|
|
assertEquals(message.getRepeatedSfixed64(1),
|
|
message.repeatedSfixed64Array()[1]);
|
|
assertEquals(message.getRepeatedFloat(1), message.repeatedFloatArray()[1]);
|
|
assertEquals(message.getRepeatedDouble(1), message.repeatedDoubleArray()[1]);
|
|
assertEquals(message.getRepeatedBool(1), message.repeatedBoolArray()[1]);
|
|
assertEquals(message.getRepeatedString(1), message.repeatedStringArray()[1]);
|
|
assertEquals(message.getRepeatedBytes(1), message.repeatedBytesArray()[1]);
|
|
assertEquals(message.getRepeatedgroup(1), message.repeatedgroupArray()[1]);
|
|
assertEquals(message.getRepeatedNestedMessage(1),
|
|
message.repeatedNestedMessageArray()[1]);
|
|
assertEquals(message.getRepeatedNestedEnum(1),
|
|
message.repeatedNestedEnumArray()[1]);
|
|
}
|
|
|
|
function testDescriptor() {
|
|
var message = new proto2.TestAllTypes();
|
|
var descriptor = message.getDescriptor();
|
|
|
|
assertEquals('TestAllTypes', descriptor.getName());
|
|
assertEquals('TestAllTypes', descriptor.getFullName());
|
|
assertEquals(null, descriptor.getContainingType());
|
|
|
|
var nestedMessage = new proto2.TestAllTypes.NestedMessage();
|
|
var nestedDescriptor = nestedMessage.getDescriptor();
|
|
|
|
assertEquals('NestedMessage', nestedDescriptor.getName());
|
|
assertEquals('TestAllTypes.NestedMessage',
|
|
nestedDescriptor.getFullName());
|
|
assertEquals(descriptor, nestedDescriptor.getContainingType());
|
|
}
|
|
|
|
function testFieldDescriptor() {
|
|
var message = new proto2.TestAllTypes();
|
|
var descriptor = message.getDescriptor();
|
|
var fields = descriptor.getFields();
|
|
|
|
assertEquals(53, fields.length);
|
|
|
|
// Check the containing types.
|
|
for (var i = 0; i < fields.length; ++i) {
|
|
assertEquals(descriptor, fields[i].getContainingType());
|
|
}
|
|
|
|
// Check the field names.
|
|
assertEquals('optional_int32', fields[0].getName());
|
|
assertEquals('optional_int64', fields[1].getName());
|
|
assertEquals('optional_uint32', fields[2].getName());
|
|
assertEquals('optional_uint64', fields[3].getName());
|
|
assertEquals('optional_sint32', fields[4].getName());
|
|
assertEquals('optional_sint64', fields[5].getName());
|
|
assertEquals('optional_fixed32', fields[6].getName());
|
|
assertEquals('optional_fixed64', fields[7].getName());
|
|
assertEquals('optional_sfixed32', fields[8].getName());
|
|
assertEquals('optional_sfixed64', fields[9].getName());
|
|
assertEquals('optional_float', fields[10].getName());
|
|
assertEquals('optional_double', fields[11].getName());
|
|
assertEquals('optional_bool', fields[12].getName());
|
|
assertEquals('optional_string', fields[13].getName());
|
|
assertEquals('optional_bytes', fields[14].getName());
|
|
assertEquals('optionalgroup', fields[15].getName());
|
|
assertEquals('optional_nested_message', fields[16].getName());
|
|
assertEquals('optional_nested_enum', fields[17].getName());
|
|
|
|
assertEquals('repeated_int32', fields[18].getName());
|
|
assertEquals('repeated_int64', fields[19].getName());
|
|
assertEquals('repeated_uint32', fields[20].getName());
|
|
assertEquals('repeated_uint64', fields[21].getName());
|
|
assertEquals('repeated_sint32', fields[22].getName());
|
|
assertEquals('repeated_sint64', fields[23].getName());
|
|
assertEquals('repeated_fixed32', fields[24].getName());
|
|
assertEquals('repeated_fixed64', fields[25].getName());
|
|
assertEquals('repeated_sfixed32', fields[26].getName());
|
|
assertEquals('repeated_sfixed64', fields[27].getName());
|
|
assertEquals('repeated_float', fields[28].getName());
|
|
assertEquals('repeated_double', fields[29].getName());
|
|
assertEquals('repeated_bool', fields[30].getName());
|
|
assertEquals('repeated_string', fields[31].getName());
|
|
assertEquals('repeated_bytes', fields[32].getName());
|
|
assertEquals('repeatedgroup', fields[33].getName());
|
|
assertEquals('repeated_nested_message', fields[34].getName());
|
|
assertEquals('repeated_nested_enum', fields[35].getName());
|
|
|
|
assertEquals('optional_int64_number', fields[36].getName());
|
|
assertEquals('optional_int64_string', fields[37].getName());
|
|
assertEquals('repeated_int64_number', fields[38].getName());
|
|
assertEquals('repeated_int64_string', fields[39].getName());
|
|
|
|
assertEquals('packed_int32', fields[40].getName());
|
|
assertEquals('packed_int64', fields[41].getName());
|
|
assertEquals('packed_uint32', fields[42].getName());
|
|
assertEquals('packed_uint64', fields[43].getName());
|
|
assertEquals('packed_sint32', fields[44].getName());
|
|
assertEquals('packed_sint64', fields[45].getName());
|
|
assertEquals('packed_fixed32', fields[46].getName());
|
|
assertEquals('packed_fixed64', fields[47].getName());
|
|
assertEquals('packed_sfixed32', fields[48].getName());
|
|
assertEquals('packed_sfixed64', fields[49].getName());
|
|
assertEquals('packed_float', fields[50].getName());
|
|
assertEquals('packed_double', fields[51].getName());
|
|
assertEquals('packed_bool', fields[52].getName());
|
|
|
|
// Check the field types.
|
|
var FieldType = goog.proto2.FieldDescriptor.FieldType;
|
|
assertEquals(FieldType.INT32, fields[0].getFieldType());
|
|
assertEquals(FieldType.INT64, fields[1].getFieldType());
|
|
assertEquals(FieldType.UINT32, fields[2].getFieldType());
|
|
assertEquals(FieldType.UINT64, fields[3].getFieldType());
|
|
assertEquals(FieldType.SINT32, fields[4].getFieldType());
|
|
assertEquals(FieldType.SINT64, fields[5].getFieldType());
|
|
assertEquals(FieldType.FIXED32, fields[6].getFieldType());
|
|
assertEquals(FieldType.FIXED64, fields[7].getFieldType());
|
|
assertEquals(FieldType.SFIXED32, fields[8].getFieldType());
|
|
assertEquals(FieldType.SFIXED64, fields[9].getFieldType());
|
|
assertEquals(FieldType.FLOAT, fields[10].getFieldType());
|
|
assertEquals(FieldType.DOUBLE, fields[11].getFieldType());
|
|
assertEquals(FieldType.BOOL, fields[12].getFieldType());
|
|
assertEquals(FieldType.STRING, fields[13].getFieldType());
|
|
assertEquals(FieldType.BYTES, fields[14].getFieldType());
|
|
assertEquals(FieldType.GROUP, fields[15].getFieldType());
|
|
assertEquals(FieldType.MESSAGE, fields[16].getFieldType());
|
|
assertEquals(FieldType.ENUM, fields[17].getFieldType());
|
|
|
|
assertEquals(FieldType.INT32, fields[18].getFieldType());
|
|
assertEquals(FieldType.INT64, fields[19].getFieldType());
|
|
assertEquals(FieldType.UINT32, fields[20].getFieldType());
|
|
assertEquals(FieldType.UINT64, fields[21].getFieldType());
|
|
assertEquals(FieldType.SINT32, fields[22].getFieldType());
|
|
assertEquals(FieldType.SINT64, fields[23].getFieldType());
|
|
assertEquals(FieldType.FIXED32, fields[24].getFieldType());
|
|
assertEquals(FieldType.FIXED64, fields[25].getFieldType());
|
|
assertEquals(FieldType.SFIXED32, fields[26].getFieldType());
|
|
assertEquals(FieldType.SFIXED64, fields[27].getFieldType());
|
|
assertEquals(FieldType.FLOAT, fields[28].getFieldType());
|
|
assertEquals(FieldType.DOUBLE, fields[29].getFieldType());
|
|
assertEquals(FieldType.BOOL, fields[30].getFieldType());
|
|
assertEquals(FieldType.STRING, fields[31].getFieldType());
|
|
assertEquals(FieldType.BYTES, fields[32].getFieldType());
|
|
assertEquals(FieldType.GROUP, fields[33].getFieldType());
|
|
assertEquals(FieldType.MESSAGE, fields[34].getFieldType());
|
|
assertEquals(FieldType.ENUM, fields[35].getFieldType());
|
|
|
|
assertEquals(FieldType.INT64, fields[36].getFieldType());
|
|
assertEquals(FieldType.INT64, fields[37].getFieldType());
|
|
assertEquals(FieldType.INT64, fields[38].getFieldType());
|
|
assertEquals(FieldType.INT64, fields[39].getFieldType());
|
|
|
|
assertEquals(FieldType.INT32, fields[40].getFieldType());
|
|
assertEquals(FieldType.INT64, fields[41].getFieldType());
|
|
assertEquals(FieldType.UINT32, fields[42].getFieldType());
|
|
assertEquals(FieldType.UINT64, fields[43].getFieldType());
|
|
assertEquals(FieldType.SINT32, fields[44].getFieldType());
|
|
assertEquals(FieldType.SINT64, fields[45].getFieldType());
|
|
assertEquals(FieldType.FIXED32, fields[46].getFieldType());
|
|
assertEquals(FieldType.FIXED64, fields[47].getFieldType());
|
|
assertEquals(FieldType.SFIXED32, fields[48].getFieldType());
|
|
assertEquals(FieldType.SFIXED64, fields[49].getFieldType());
|
|
assertEquals(FieldType.FLOAT, fields[50].getFieldType());
|
|
assertEquals(FieldType.DOUBLE, fields[51].getFieldType());
|
|
assertEquals(FieldType.BOOL, fields[52].getFieldType());
|
|
|
|
// Check the field native types.
|
|
// Singular.
|
|
assertEquals(Number, fields[0].getNativeType());
|
|
assertEquals(String, fields[1].getNativeType()); // 64 bit values are strings.
|
|
assertEquals(Number, fields[2].getNativeType());
|
|
assertEquals(String, fields[3].getNativeType());
|
|
assertEquals(Number, fields[4].getNativeType());
|
|
assertEquals(String, fields[5].getNativeType());
|
|
assertEquals(Number, fields[6].getNativeType());
|
|
assertEquals(String, fields[7].getNativeType());
|
|
assertEquals(Number, fields[8].getNativeType());
|
|
assertEquals(String, fields[9].getNativeType());
|
|
assertEquals(Number, fields[10].getNativeType());
|
|
assertEquals(Number, fields[11].getNativeType());
|
|
|
|
assertEquals(Boolean, fields[12].getNativeType());
|
|
|
|
assertEquals(String, fields[13].getNativeType());
|
|
assertEquals(String, fields[14].getNativeType());
|
|
|
|
assertEquals(proto2.TestAllTypes.OptionalGroup, fields[15].getNativeType());
|
|
assertEquals(proto2.TestAllTypes.NestedMessage, fields[16].getNativeType());
|
|
assertEquals(proto2.TestAllTypes.NestedEnum, fields[17].getNativeType());
|
|
|
|
assertEquals(Number, fields[36].getNativeType()); // [jstype="number"]
|
|
assertEquals(String, fields[37].getNativeType());
|
|
|
|
// Repeated.
|
|
assertEquals(Number, fields[18].getNativeType());
|
|
assertEquals(String, fields[19].getNativeType());
|
|
assertEquals(Number, fields[20].getNativeType());
|
|
assertEquals(String, fields[21].getNativeType());
|
|
assertEquals(Number, fields[22].getNativeType());
|
|
assertEquals(String, fields[23].getNativeType());
|
|
assertEquals(Number, fields[24].getNativeType());
|
|
assertEquals(String, fields[25].getNativeType());
|
|
assertEquals(Number, fields[26].getNativeType());
|
|
assertEquals(String, fields[27].getNativeType());
|
|
assertEquals(Number, fields[28].getNativeType());
|
|
assertEquals(Number, fields[29].getNativeType());
|
|
|
|
assertEquals(Boolean, fields[30].getNativeType());
|
|
|
|
assertEquals(String, fields[31].getNativeType());
|
|
assertEquals(String, fields[32].getNativeType());
|
|
|
|
assertEquals(proto2.TestAllTypes.RepeatedGroup, fields[33].getNativeType());
|
|
assertEquals(proto2.TestAllTypes.NestedMessage, fields[34].getNativeType());
|
|
assertEquals(proto2.TestAllTypes.NestedEnum, fields[35].getNativeType());
|
|
|
|
assertEquals(Number, fields[38].getNativeType()); // [jstype="number"]
|
|
assertEquals(String, fields[39].getNativeType());
|
|
|
|
// Packed (only numeric types can be packed).
|
|
assertEquals(Number, fields[40].getNativeType());
|
|
assertEquals(Number, fields[41].getNativeType());
|
|
assertEquals(Number, fields[42].getNativeType());
|
|
assertEquals(Number, fields[43].getNativeType());
|
|
assertEquals(Number, fields[44].getNativeType());
|
|
assertEquals(Number, fields[45].getNativeType());
|
|
assertEquals(Number, fields[46].getNativeType());
|
|
assertEquals(Number, fields[47].getNativeType());
|
|
assertEquals(Number, fields[48].getNativeType());
|
|
assertEquals(Number, fields[49].getNativeType());
|
|
assertEquals(Number, fields[50].getNativeType());
|
|
assertEquals(Number, fields[51].getNativeType());
|
|
assertEquals(Boolean, fields[52].getNativeType());
|
|
}
|
|
|
|
function testUnknown() {
|
|
var message = new proto2.TestAllTypes();
|
|
|
|
// Set some unknown fields.
|
|
message.setUnknown(1000, 101);
|
|
message.setUnknown(1001, -102);
|
|
message.setUnknown(1002, true);
|
|
message.setUnknown(1003, 'abcd');
|
|
message.setUnknown(1004, ['he', 'llo']);
|
|
|
|
// Ensure we find them all.
|
|
var count = 0;
|
|
|
|
message.forEachUnknown(function(tag, value) {
|
|
if (tag == 1000) {
|
|
assertEquals(101, value);
|
|
}
|
|
|
|
if (tag == 1001) {
|
|
assertEquals(-102, value);
|
|
}
|
|
|
|
if (tag == 1002) {
|
|
assertEquals(true, value);
|
|
}
|
|
|
|
if (tag == 1003) {
|
|
assertEquals('abcd', value);
|
|
}
|
|
|
|
if (tag == 1004) {
|
|
assertEquals('he', value[0]);
|
|
assertEquals('llo', value[1]);
|
|
}
|
|
|
|
count++;
|
|
});
|
|
|
|
assertEquals(5, count);
|
|
}
|
|
|
|
function testReflection() {
|
|
var message = new proto2.TestAllTypes();
|
|
var descriptor = message.getDescriptor();
|
|
var optionalInt = descriptor.findFieldByName('optional_int32');
|
|
var optionalString = descriptor.findFieldByName('optional_string');
|
|
var repeatedInt64 = descriptor.findFieldByName('repeated_int64');
|
|
var optionalWrong = descriptor.findFieldByName('foo_bar');
|
|
|
|
assertFalse(optionalInt == null);
|
|
assertFalse(optionalString == null);
|
|
assertFalse(repeatedInt64 == null);
|
|
assertTrue(optionalWrong == null);
|
|
|
|
// Check to ensure the fields are empty.
|
|
assertFalse(message.has(optionalInt));
|
|
assertFalse(message.has(optionalString));
|
|
assertFalse(message.has(repeatedInt64));
|
|
|
|
assertEquals(0, message.arrayOf(repeatedInt64).length);
|
|
|
|
// Check default values.
|
|
assertEquals(0, message.getOrDefault(optionalInt));
|
|
assertEquals('', message.getOrDefault(optionalString));
|
|
|
|
// Set some of the fields.
|
|
message.set(optionalString, 'hello!');
|
|
|
|
message.add(repeatedInt64, '101');
|
|
message.add(repeatedInt64, '102');
|
|
|
|
// Check the fields.
|
|
assertFalse(message.has(optionalInt));
|
|
|
|
assertTrue(message.has(optionalString));
|
|
assertTrue(message.hasOptionalString());
|
|
|
|
assertTrue(message.has(repeatedInt64));
|
|
assertTrue(message.hasRepeatedInt64());
|
|
|
|
// Check the values.
|
|
assertEquals('hello!', message.get(optionalString));
|
|
assertEquals('hello!', message.getOptionalString());
|
|
|
|
assertEquals('101', message.get(repeatedInt64, 0));
|
|
assertEquals('102', message.get(repeatedInt64, 1));
|
|
|
|
assertEquals('101', message.getRepeatedInt64(0));
|
|
assertEquals('102', message.getRepeatedInt64(1));
|
|
|
|
// Check the count.
|
|
assertEquals(0, message.countOf(optionalInt));
|
|
|
|
assertEquals(1, message.countOf(optionalString));
|
|
assertEquals(1, message.optionalStringCount());
|
|
|
|
assertEquals(2, message.countOf(repeatedInt64));
|
|
assertEquals(2, message.repeatedInt64Count());
|
|
|
|
// Check the array.
|
|
assertEquals(2, message.arrayOf(repeatedInt64).length);
|
|
|
|
assertEquals(message.get(repeatedInt64, 0),
|
|
message.arrayOf(repeatedInt64)[0]);
|
|
|
|
assertEquals(message.get(repeatedInt64, 1),
|
|
message.arrayOf(repeatedInt64)[1]);
|
|
}
|
|
|
|
function testDefaultValuesForMessages() {
|
|
var message = new proto2.TestDefaultParent();
|
|
// Ideally this object would be immutable, but the current API does not
|
|
// enforce that behavior, so get**OrDefault returns a new instance every time.
|
|
var child = message.getChildOrDefault();
|
|
child.setFoo(false);
|
|
// Changing the value returned by get**OrDefault does not actually change
|
|
// the value stored in the parent message.
|
|
assertFalse(message.hasChild());
|
|
assertNull(message.getChild());
|
|
|
|
var message2 = new proto2.TestDefaultParent();
|
|
var child2 = message2.getChildOrDefault();
|
|
assertNull(message2.getChild());
|
|
|
|
// The parent message returns a different object for the default.
|
|
assertNotEquals(child, child2);
|
|
|
|
// You've only changed the value of child, so child2 should be unaffected.
|
|
assertFalse(child2.hasFoo());
|
|
assertTrue(child2.getFooOrDefault());
|
|
}
|