Andreas Hocevar
500 lines
16 KiB
JavaScript
500 lines
16 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.PbLiteSerializerTest');
|
|
goog.setTestOnly('goog.proto2.PbLiteSerializerTest');
|
|
|
|
goog.require('goog.proto2.PbLiteSerializer');
|
|
goog.require('goog.testing.jsunit');
|
|
goog.require('proto2.TestAllTypes');
|
|
|
|
function testSerializationAndDeserialization() {
|
|
var message = createPopulatedMessage();
|
|
|
|
// Serialize.
|
|
var serializer = new goog.proto2.PbLiteSerializer();
|
|
var pblite = serializer.serialize(message);
|
|
|
|
assertTrue(goog.isArray(pblite));
|
|
|
|
// Assert that everything serialized properly.
|
|
assertEquals(101, pblite[1]);
|
|
assertEquals('102', pblite[2]);
|
|
assertEquals(103, pblite[3]);
|
|
assertEquals('104', pblite[4]);
|
|
assertEquals(105, pblite[5]);
|
|
assertEquals('106', pblite[6]);
|
|
assertEquals(107, pblite[7]);
|
|
assertEquals('108', pblite[8]);
|
|
assertEquals(109, pblite[9]);
|
|
assertEquals('110', pblite[10]);
|
|
assertEquals(111.5, pblite[11]);
|
|
assertEquals(112.5, pblite[12]);
|
|
assertEquals(1, pblite[13]); // true is serialized as 1
|
|
assertEquals('test', pblite[14]);
|
|
assertEquals('abcd', pblite[15]);
|
|
|
|
assertEquals(111, pblite[16][17]);
|
|
assertEquals(112, pblite[18][1]);
|
|
|
|
assertTrue(pblite[19] === undefined);
|
|
assertTrue(pblite[20] === undefined);
|
|
|
|
assertEquals(proto2.TestAllTypes.NestedEnum.FOO, pblite[21]);
|
|
|
|
assertEquals(201, pblite[31][0]);
|
|
assertEquals(202, pblite[31][1]);
|
|
assertEquals('foo', pblite[44][0]);
|
|
assertEquals('bar', pblite[44][1]);
|
|
|
|
var serializer = new goog.proto2.PbLiteSerializer();
|
|
// Deserialize.
|
|
var messageCopy =
|
|
serializer.deserialize(proto2.TestAllTypes.getDescriptor(), pblite);
|
|
|
|
assertNotEquals(messageCopy, message);
|
|
|
|
assertDeserializationMatches(messageCopy);
|
|
}
|
|
|
|
function testZeroBasedSerializationAndDeserialization() {
|
|
var message = createPopulatedMessage();
|
|
|
|
// Serialize.
|
|
var serializer = new goog.proto2.PbLiteSerializer();
|
|
serializer.setZeroIndexed(true);
|
|
|
|
var pblite = serializer.serialize(message);
|
|
|
|
assertTrue(goog.isArray(pblite));
|
|
|
|
// Assert that everything serialized properly.
|
|
assertEquals(101, pblite[0]);
|
|
assertEquals('102', pblite[1]);
|
|
assertEquals(103, pblite[2]);
|
|
assertEquals('104', pblite[3]);
|
|
assertEquals(105, pblite[4]);
|
|
assertEquals('106', pblite[5]);
|
|
assertEquals(107, pblite[6]);
|
|
assertEquals('108', pblite[7]);
|
|
assertEquals(109, pblite[8]);
|
|
assertEquals('110', pblite[9]);
|
|
assertEquals(111.5, pblite[10]);
|
|
assertEquals(112.5, pblite[11]);
|
|
assertEquals(1, pblite[12]); // true is serialized as 1
|
|
assertEquals('test', pblite[13]);
|
|
assertEquals('abcd', pblite[14]);
|
|
|
|
assertEquals(111, pblite[15][16]);
|
|
assertEquals(112, pblite[17][0]);
|
|
|
|
assertTrue(pblite[18] === undefined);
|
|
assertTrue(pblite[19] === undefined);
|
|
|
|
assertEquals(proto2.TestAllTypes.NestedEnum.FOO, pblite[20]);
|
|
|
|
assertEquals(201, pblite[30][0]);
|
|
assertEquals(202, pblite[30][1]);
|
|
assertEquals('foo', pblite[43][0]);
|
|
assertEquals('bar', pblite[43][1]);
|
|
|
|
// Deserialize.
|
|
var messageCopy =
|
|
serializer.deserialize(proto2.TestAllTypes.getDescriptor(), pblite);
|
|
|
|
assertNotEquals(messageCopy, message);
|
|
|
|
assertEquals(message.getOptionalInt32(), messageCopy.getOptionalInt32());
|
|
assertDeserializationMatches(messageCopy);
|
|
}
|
|
|
|
function createPopulatedMessage() {
|
|
var message = new proto2.TestAllTypes();
|
|
|
|
// Set the fields.
|
|
// Singular.
|
|
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);
|
|
|
|
// Repeated.
|
|
message.addRepeatedInt32(201);
|
|
message.addRepeatedInt32(202);
|
|
|
|
// Skip a few repeated fields so we can test how null array values are
|
|
// handled.
|
|
message.addRepeatedString('foo');
|
|
message.addRepeatedString('bar');
|
|
return message;
|
|
}
|
|
|
|
function testDeserializationFromExternalSource() {
|
|
// Test deserialization where the JSON array is initialized from something
|
|
// outside the Closure proto2 library, such as the JsPbLite library, or
|
|
// manually as in this test.
|
|
var pblite = [
|
|
, // 0
|
|
101, // 1
|
|
'102', // 2
|
|
103, // 3
|
|
'104', // 4
|
|
105, // 5
|
|
'106', // 6
|
|
107, // 7
|
|
'108', // 8
|
|
109, // 9
|
|
'110', // 10
|
|
111.5, // 11
|
|
112.5, // 12
|
|
1, // 13
|
|
'test', // 14
|
|
'abcd', // 15
|
|
[,,,,,,,,,,,,,,,,, 111], // 16, note the 17 commas so value is index 17
|
|
, // 17
|
|
[, 112], // 18
|
|
,, // 19-20
|
|
proto2.TestAllTypes.NestedEnum.FOO, // 21
|
|
,,,,,,,,, // 22-30
|
|
[201, 202], // 31
|
|
,,,,,,,,,,,, // 32-43
|
|
['foo', 'bar'], // 44
|
|
,,,, // 45-49
|
|
];
|
|
|
|
// Deserialize.
|
|
var serializer = new goog.proto2.PbLiteSerializer();
|
|
var messageCopy =
|
|
serializer.deserialize(proto2.TestAllTypes.getDescriptor(), pblite);
|
|
|
|
assertDeserializationMatches(messageCopy);
|
|
|
|
// http://b/issue?id=2928075
|
|
assertFalse(messageCopy.hasRepeatedInt64());
|
|
assertEquals(0, messageCopy.repeatedInt64Count());
|
|
messageCopy.repeatedInt64Array();
|
|
assertFalse(messageCopy.hasRepeatedInt64());
|
|
assertEquals(0, messageCopy.repeatedInt64Count());
|
|
|
|
// Access a nested message to ensure it is deserialized.
|
|
assertNotNull(messageCopy.getOptionalNestedMessage());
|
|
|
|
// Verify that the pblite array itself has not been replaced by the
|
|
// deserialization.
|
|
assertEquals('array', goog.typeOf(pblite[16]));
|
|
|
|
// Update some fields and verify that the changes work with the lazy
|
|
// deserializer.
|
|
messageCopy.setOptionalBool(true);
|
|
assertTrue(messageCopy.getOptionalBool());
|
|
|
|
messageCopy.setOptionalBool(false);
|
|
assertFalse(messageCopy.getOptionalBool());
|
|
|
|
messageCopy.setOptionalInt32(1234);
|
|
assertEquals(1234, messageCopy.getOptionalInt32());
|
|
}
|
|
|
|
function testModifyLazyDeserializedMessage() {
|
|
var pblite = [
|
|
, // 0
|
|
101, // 1
|
|
'102', // 2
|
|
103, // 3
|
|
'104', // 4
|
|
105, // 5
|
|
'106', // 6
|
|
107, // 7
|
|
'108', // 8
|
|
109, // 9
|
|
'110', // 10
|
|
111.5, // 11
|
|
112.5, // 12
|
|
1, // 13
|
|
'test', // 14
|
|
'abcd', // 15
|
|
[,,,,,,,,,,,,,,,,, 111], // 16, note the 17 commas so value is index 17
|
|
, // 17
|
|
[, 112], // 18
|
|
,, // 19-20
|
|
proto2.TestAllTypes.NestedEnum.FOO, // 21
|
|
,,,,,,,,, // 22-30
|
|
[201, 202], // 31
|
|
,,,,,,,,,,,, // 32-43
|
|
['foo', 'bar'], // 44
|
|
,,,, // 45-49
|
|
];
|
|
|
|
// Deserialize.
|
|
var serializer = new goog.proto2.PbLiteSerializer();
|
|
var message =
|
|
serializer.deserialize(proto2.TestAllTypes.getDescriptor(), pblite);
|
|
|
|
// Conduct some operations, ensuring that they all work as expected, even with
|
|
// the lazily deserialized data.
|
|
assertEquals(101, message.getOptionalInt32());
|
|
message.setOptionalInt32(401);
|
|
assertEquals(401, message.getOptionalInt32());
|
|
|
|
assertEquals(2, message.repeatedInt32Count());
|
|
assertEquals(201, message.getRepeatedInt32(0));
|
|
assertEquals(202, message.getRepeatedInt32(1));
|
|
|
|
message.clearRepeatedInt32();
|
|
assertEquals(0, message.repeatedInt32Count());
|
|
|
|
message.addRepeatedInt32(101);
|
|
assertEquals(1, message.repeatedInt32Count());
|
|
assertEquals(101, message.getRepeatedInt32(0));
|
|
|
|
message.setUnknown(12345, 601);
|
|
message.forEachUnknown(function(tag, value) {
|
|
assertEquals(12345, tag);
|
|
assertEquals(601, value);
|
|
});
|
|
|
|
// Create a copy of the message.
|
|
var messageCopy = new proto2.TestAllTypes();
|
|
messageCopy.copyFrom(message);
|
|
|
|
assertEquals(1, messageCopy.repeatedInt32Count());
|
|
assertEquals(101, messageCopy.getRepeatedInt32(0));
|
|
}
|
|
|
|
function testModifyLazyDeserializedMessageByAddingMessage() {
|
|
var pblite = [
|
|
, // 0
|
|
101, // 1
|
|
'102', // 2
|
|
103, // 3
|
|
'104', // 4
|
|
105, // 5
|
|
'106', // 6
|
|
107, // 7
|
|
'108', // 8
|
|
109, // 9
|
|
'110', // 10
|
|
111.5, // 11
|
|
112.5, // 12
|
|
1, // 13
|
|
'test', // 14
|
|
'abcd', // 15
|
|
[,,,,,,,,,,,,,,,,, 111], // 16, note the 17 commas so value is index 17
|
|
, // 17
|
|
[, 112], // 18
|
|
,, // 19-20
|
|
proto2.TestAllTypes.NestedEnum.FOO, // 21
|
|
,,,,,,,,, // 22-30
|
|
[201, 202], // 31
|
|
,,,,,,,,,,,, // 32-43
|
|
['foo', 'bar'], // 44
|
|
,,,, // 45-49
|
|
];
|
|
|
|
// Deserialize.
|
|
var serializer = new goog.proto2.PbLiteSerializer();
|
|
var message =
|
|
serializer.deserialize(proto2.TestAllTypes.getDescriptor(), pblite);
|
|
|
|
// Add a new nested message.
|
|
var nested1 = new proto2.TestAllTypes.NestedMessage();
|
|
nested1.setB(1234);
|
|
|
|
var nested2 = new proto2.TestAllTypes.NestedMessage();
|
|
nested2.setB(4567);
|
|
|
|
message.addRepeatedNestedMessage(nested1);
|
|
|
|
// Check the new nested message.
|
|
assertEquals(1, message.repeatedNestedMessageArray().length);
|
|
assertTrue(message.repeatedNestedMessageArray()[0].equals(nested1));
|
|
|
|
// Add another nested message.
|
|
message.addRepeatedNestedMessage(nested2);
|
|
|
|
// Check both nested messages.
|
|
assertEquals(2, message.repeatedNestedMessageArray().length);
|
|
assertTrue(message.repeatedNestedMessageArray()[0].equals(nested1));
|
|
assertTrue(message.repeatedNestedMessageArray()[1].equals(nested2));
|
|
}
|
|
|
|
function assertDeserializationMatches(messageCopy) {
|
|
assertNotNull(messageCopy);
|
|
|
|
assertTrue(messageCopy.hasOptionalInt32());
|
|
assertTrue(messageCopy.hasOptionalInt64());
|
|
assertTrue(messageCopy.hasOptionalUint32());
|
|
assertTrue(messageCopy.hasOptionalUint64());
|
|
assertTrue(messageCopy.hasOptionalSint32());
|
|
assertTrue(messageCopy.hasOptionalSint64());
|
|
assertTrue(messageCopy.hasOptionalFixed32());
|
|
assertTrue(messageCopy.hasOptionalFixed64());
|
|
assertTrue(messageCopy.hasOptionalSfixed32());
|
|
assertTrue(messageCopy.hasOptionalSfixed64());
|
|
assertTrue(messageCopy.hasOptionalFloat());
|
|
assertTrue(messageCopy.hasOptionalDouble());
|
|
assertTrue(messageCopy.hasOptionalBool());
|
|
assertTrue(messageCopy.hasOptionalString());
|
|
assertTrue(messageCopy.hasOptionalBytes());
|
|
assertTrue(messageCopy.hasOptionalgroup());
|
|
assertTrue(messageCopy.hasOptionalNestedMessage());
|
|
assertTrue(messageCopy.hasOptionalNestedEnum());
|
|
|
|
assertTrue(messageCopy.hasRepeatedInt32());
|
|
assertFalse(messageCopy.hasRepeatedInt64());
|
|
assertFalse(messageCopy.hasRepeatedUint32());
|
|
assertFalse(messageCopy.hasRepeatedUint64());
|
|
assertFalse(messageCopy.hasRepeatedSint32());
|
|
assertFalse(messageCopy.hasRepeatedSint64());
|
|
assertFalse(messageCopy.hasRepeatedFixed32());
|
|
assertFalse(messageCopy.hasRepeatedFixed64());
|
|
assertFalse(messageCopy.hasRepeatedSfixed32());
|
|
assertFalse(messageCopy.hasRepeatedSfixed64());
|
|
assertFalse(messageCopy.hasRepeatedFloat());
|
|
assertFalse(messageCopy.hasRepeatedDouble());
|
|
assertFalse(messageCopy.hasRepeatedBool());
|
|
assertTrue(messageCopy.hasRepeatedString());
|
|
assertFalse(messageCopy.hasRepeatedBytes());
|
|
assertFalse(messageCopy.hasRepeatedgroup());
|
|
assertFalse(messageCopy.hasRepeatedNestedMessage());
|
|
assertFalse(messageCopy.hasRepeatedNestedEnum());
|
|
|
|
assertEquals(1, messageCopy.optionalInt32Count());
|
|
assertEquals(1, messageCopy.optionalInt64Count());
|
|
assertEquals(1, messageCopy.optionalUint32Count());
|
|
assertEquals(1, messageCopy.optionalUint64Count());
|
|
assertEquals(1, messageCopy.optionalSint32Count());
|
|
assertEquals(1, messageCopy.optionalSint64Count());
|
|
assertEquals(1, messageCopy.optionalFixed32Count());
|
|
assertEquals(1, messageCopy.optionalFixed64Count());
|
|
assertEquals(1, messageCopy.optionalSfixed32Count());
|
|
assertEquals(1, messageCopy.optionalSfixed64Count());
|
|
assertEquals(1, messageCopy.optionalFloatCount());
|
|
assertEquals(1, messageCopy.optionalDoubleCount());
|
|
assertEquals(1, messageCopy.optionalBoolCount());
|
|
assertEquals(1, messageCopy.optionalStringCount());
|
|
assertEquals(1, messageCopy.optionalBytesCount());
|
|
assertEquals(1, messageCopy.optionalgroupCount());
|
|
assertEquals(1, messageCopy.optionalNestedMessageCount());
|
|
assertEquals(1, messageCopy.optionalNestedEnumCount());
|
|
|
|
assertEquals(2, messageCopy.repeatedInt32Count());
|
|
assertEquals(0, messageCopy.repeatedInt64Count());
|
|
assertEquals(0, messageCopy.repeatedUint32Count());
|
|
assertEquals(0, messageCopy.repeatedUint64Count());
|
|
assertEquals(0, messageCopy.repeatedSint32Count());
|
|
assertEquals(0, messageCopy.repeatedSint64Count());
|
|
assertEquals(0, messageCopy.repeatedFixed32Count());
|
|
assertEquals(0, messageCopy.repeatedFixed64Count());
|
|
assertEquals(0, messageCopy.repeatedSfixed32Count());
|
|
assertEquals(0, messageCopy.repeatedSfixed64Count());
|
|
assertEquals(0, messageCopy.repeatedFloatCount());
|
|
assertEquals(0, messageCopy.repeatedDoubleCount());
|
|
assertEquals(0, messageCopy.repeatedBoolCount());
|
|
assertEquals(2, messageCopy.repeatedStringCount());
|
|
assertEquals(0, messageCopy.repeatedBytesCount());
|
|
assertEquals(0, messageCopy.repeatedgroupCount());
|
|
assertEquals(0, messageCopy.repeatedNestedMessageCount());
|
|
assertEquals(0, messageCopy.repeatedNestedEnumCount());
|
|
|
|
assertEquals(101, messageCopy.getOptionalInt32());
|
|
assertEquals('102', messageCopy.getOptionalInt64());
|
|
assertEquals(103, messageCopy.getOptionalUint32());
|
|
assertEquals('104', messageCopy.getOptionalUint64());
|
|
assertEquals(105, messageCopy.getOptionalSint32());
|
|
assertEquals('106', messageCopy.getOptionalSint64());
|
|
assertEquals(107, messageCopy.getOptionalFixed32());
|
|
assertEquals('108', messageCopy.getOptionalFixed64());
|
|
assertEquals(109, messageCopy.getOptionalSfixed32());
|
|
assertEquals('110', messageCopy.getOptionalSfixed64());
|
|
assertEquals(111.5, messageCopy.getOptionalFloat());
|
|
assertEquals(112.5, messageCopy.getOptionalDouble());
|
|
assertEquals(true, messageCopy.getOptionalBool());
|
|
assertEquals('test', messageCopy.getOptionalString());
|
|
assertEquals('abcd', messageCopy.getOptionalBytes());
|
|
assertEquals(111, messageCopy.getOptionalgroup().getA());
|
|
|
|
assertEquals(112, messageCopy.getOptionalNestedMessage().getB());
|
|
|
|
assertEquals(proto2.TestAllTypes.NestedEnum.FOO,
|
|
messageCopy.getOptionalNestedEnum());
|
|
|
|
assertEquals(201, messageCopy.getRepeatedInt32(0));
|
|
assertEquals(202, messageCopy.getRepeatedInt32(1));
|
|
}
|
|
|
|
function testMergeFromLazyTarget() {
|
|
var serializer = new goog.proto2.PbLiteSerializer();
|
|
|
|
var source = new proto2.TestAllTypes();
|
|
var nested = new proto2.TestAllTypes.NestedMessage();
|
|
nested.setB(66);
|
|
source.setOptionalNestedMessage(nested);
|
|
source.setOptionalInt32(32);
|
|
source.setOptionalString('foo');
|
|
source.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
|
|
source.addRepeatedInt32(2);
|
|
|
|
var target = new proto2.TestAllTypes();
|
|
nested = new proto2.TestAllTypes.NestedMessage();
|
|
nested.setC(77);
|
|
target.setOptionalNestedMessage(nested);
|
|
target.setOptionalInt64('64');
|
|
target.setOptionalString('bar');
|
|
target.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.BAR);
|
|
target.addRepeatedInt32(1);
|
|
var pbliteTarget = serializer.serialize(target);
|
|
var lazyTarget =
|
|
serializer.deserialize(proto2.TestAllTypes.getDescriptor(), pbliteTarget);
|
|
|
|
var expected = new proto2.TestAllTypes();
|
|
nested = new proto2.TestAllTypes.NestedMessage();
|
|
nested.setB(66);
|
|
nested.setC(77);
|
|
expected.setOptionalNestedMessage(nested);
|
|
expected.setOptionalInt32(32);
|
|
expected.setOptionalInt64('64');
|
|
expected.setOptionalString('foo');
|
|
expected.setOptionalNestedEnum(proto2.TestAllTypes.NestedEnum.FOO);
|
|
expected.addRepeatedInt32(1);
|
|
expected.addRepeatedInt32(2);
|
|
|
|
lazyTarget.mergeFrom(source);
|
|
assertTrue('expected and lazyTarget are equal after mergeFrom',
|
|
lazyTarget.equals(expected));
|
|
}
|