sku-pg
Version:
Skulpt is a Javascript implementation of Python 2.x. Python that runs in your browser!
490 lines (390 loc) • 15.2 kB
HTML
<html>
<!--
Copyright 2008 The Closure Library Authors. All Rights Reserved.
Use of this source code is governed by the Apache License, Version 2.0.
See the COPYING file for details.
-->
<!--
-->
<head>
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>Closure Unit Tests - goog.proto2 - objectserializer.js</title>
<script src="../base.js"></script>
<script>
goog.require('goog.proto2.ObjectSerializer');
goog.require('goog.testing.PropertyReplacer');
goog.require('goog.testing.jsunit');
goog.require('proto2.TestAllTypes');
</script>
</head>
<body>
<script>
var propertyReplacer = new goog.testing.PropertyReplacer();
function tearDown() {
propertyReplacer.reset();
}
function testSerialization() {
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);
// Serialize to a simplified object.
var simplified = new goog.proto2.ObjectSerializer().serialize(message);
// Assert that everything serialized properly.
assertEquals(101, simplified[1]);
assertEquals('102', simplified[2]);
assertEquals(103, simplified[3]);
assertEquals('104', simplified[4]);
assertEquals(105, simplified[5]);
assertEquals('106', simplified[6]);
assertEquals(107, simplified[7]);
assertEquals('108', simplified[8]);
assertEquals(109, simplified[9]);
assertEquals('110', simplified[10]);
assertEquals(111.5, simplified[11]);
assertEquals(112.5, simplified[12]);
assertEquals(true, simplified[13]);
assertEquals('test', simplified[14]);
assertEquals('abcd', simplified[15]);
assertEquals(111, simplified[16][17]);
assertEquals(112, simplified[18][1]);
assertEquals(proto2.TestAllTypes.NestedEnum.FOO, simplified[21]);
assertEquals(201, simplified[31][0]);
assertEquals(202, simplified[31][1]);
// Serialize to a simplified object (with key as name).
simplified = new goog.proto2.ObjectSerializer(
goog.proto2.ObjectSerializer.KeyOption.NAME).serialize(message);
// Assert that everything serialized properly.
assertEquals(101, simplified['optional_int32']);
assertEquals('102', simplified['optional_int64']);
assertEquals(103, simplified['optional_uint32']);
assertEquals('104', simplified['optional_uint64']);
assertEquals(105, simplified['optional_sint32']);
assertEquals('106', simplified['optional_sint64']);
assertEquals(107, simplified['optional_fixed32']);
assertEquals('108', simplified['optional_fixed64']);
assertEquals(109, simplified['optional_sfixed32']);
assertEquals('110', simplified['optional_sfixed64']);
assertEquals(111.5, simplified['optional_float']);
assertEquals(112.5, simplified['optional_double']);
assertEquals(true, simplified['optional_bool']);
assertEquals('test', simplified['optional_string']);
assertEquals('abcd', simplified['optional_bytes']);
assertEquals(111, simplified['optionalgroup']['a']);
assertEquals(112, simplified['optional_nested_message']['b']);
assertEquals(proto2.TestAllTypes.NestedEnum.FOO,
simplified['optional_nested_enum']);
assertEquals(201, simplified['repeated_int32'][0]);
assertEquals(202, simplified['repeated_int32'][1]);
}
function testSerializationOfUnknown() {
var message = new proto2.TestAllTypes();
// Set the fields.
// Known.
message.setOptionalInt32(101);
message.setOptionalInt64('102');
message.addRepeatedInt32(201);
message.addRepeatedInt32(202);
// Unknown.
message.setUnknown(1000, 301);
message.setUnknown(1001, 302);
// Serialize.
var simplified = new goog.proto2.ObjectSerializer().serialize(message);
assertEquals(101, simplified['1']);
assertEquals('102', simplified['2']);
assertEquals(201, simplified['31'][0]);
assertEquals(202, simplified['31'][1]);
assertEquals(301, simplified['1000']);
assertEquals(302, simplified['1001']);
}
function testDeserializationOfUnknown() {
var simplified = {
1: 101,
2: '102',
1000: 103,
1001: 104
};
var serializer = new goog.proto2.ObjectSerializer();
var message = serializer.deserialize(
proto2.TestAllTypes.getDescriptor(), simplified);
assertNotNull(message);
assertTrue(message.hasOptionalInt32());
assertTrue(message.hasOptionalInt64());
assertEquals(101, message.getOptionalInt32());
assertEquals('102', message.getOptionalInt64());
var count = 0;
message.forEachUnknown(function(tag, value) {
if (tag == 1000) {
assertEquals(103, value);
}
if (tag == 1001) {
assertEquals(104, value);
}
++count;
});
assertEquals(2, count);
};
function testDeserializationRepeated() {
var simplified = {
31: [101, 102],
41: [201.5, 202.5, 203.5],
42: [],
43: [ true, false ],
44: [ 'he', 'llo' ],
46: [ { 47: [101] } , { 47: [102] } ],
48: [ { 1: 201 }, { 1: 202 } ]
}
var serializer = new goog.proto2.ObjectSerializer();
var message = serializer.deserialize(
proto2.TestAllTypes.getDescriptor(), simplified);
assertNotNull(message);
// Ensure the fields are set as expected.
assertTrue(message.hasRepeatedInt32());
assertTrue(message.hasRepeatedFloat());
assertFalse(message.hasRepeatedDouble());
assertTrue(message.hasRepeatedBool());
assertTrue(message.hasRepeatedgroup());
assertTrue(message.hasRepeatedNestedMessage());
// Ensure the counts match.
assertEquals(2, message.repeatedInt32Count());
assertEquals(3, message.repeatedFloatCount());
assertEquals(0, message.repeatedDoubleCount());
assertEquals(2, message.repeatedBoolCount());
assertEquals(2, message.repeatedStringCount());
assertEquals(2, message.repeatedgroupCount());
assertEquals(2, message.repeatedNestedMessageCount());
// Ensure the values match.
assertEquals(101, message.getRepeatedInt32(0));
assertEquals(102, message.getRepeatedInt32(1));
assertEquals(201.5, message.getRepeatedFloat(0));
assertEquals(202.5, message.getRepeatedFloat(1));
assertEquals(203.5, message.getRepeatedFloat(2));
assertEquals(true, message.getRepeatedBool(0));
assertEquals(false, message.getRepeatedBool(1));
assertEquals('he', message.getRepeatedString(0));
assertEquals('llo', message.getRepeatedString(1));
assertEquals(101, message.getRepeatedgroup(0).getA(0));
assertEquals(102, message.getRepeatedgroup(1).getA(0));
assertEquals(201, message.getRepeatedNestedMessage(0).getB());
assertEquals(202, message.getRepeatedNestedMessage(1).getB());
}
function testDeserialization() {
var simplified = {
1: 101,
2: '102',
3: 103,
4: '104',
5: 105,
6: '106',
7: 107,
8: '108',
9: 109,
10: '110',
11: 111.5,
12: 112.5,
13: true,
14: 'test',
15: 'abcd',
16: { 17 : 113 },
18: { 1 : 114 },
21: proto2.TestAllTypes.NestedEnum.FOO
};
var serializer = new goog.proto2.ObjectSerializer();
var message = serializer.deserialize(
proto2.TestAllTypes.getDescriptor(), simplified);
assertNotNull(message);
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());
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());
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(113, message.getOptionalgroup().getA());
assertEquals(114, message.getOptionalNestedMessage().getB());
assertEquals(proto2.TestAllTypes.NestedEnum.FOO,
message.getOptionalNestedEnum());
}
function testDeserializationUnknownEnumValue() {
var simplified = {
21: 1001
};
var serializer = new goog.proto2.ObjectSerializer();
var message = serializer.deserialize(
proto2.TestAllTypes.getDescriptor(), simplified);
assertNotNull(message);
assertEquals(1001, message.getOptionalNestedEnum());
}
function testDeserializationSymbolicEnumValue() {
var simplified = {
21: 'BAR'
};
propertyReplacer.set(goog.proto2.Serializer, 'DECODE_SYMBOLIC_ENUMS', true);
var serializer = new goog.proto2.ObjectSerializer();
var message = serializer.deserialize(
proto2.TestAllTypes.getDescriptor(), simplified);
assertNotNull(message);
assertEquals(proto2.TestAllTypes.NestedEnum.BAR,
message.getOptionalNestedEnum());
}
function testDeserializationSymbolicEnumValueTurnedOff() {
var simplified = {
21: 'BAR'
};
var serializer = new goog.proto2.ObjectSerializer();
assertThrows('Should have an assertion failure in deserialization',
function() {
serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
});
}
function testDeserializationUnknownSymbolicEnumValue() {
var simplified = {
21: 'BARRED'
};
var serializer = new goog.proto2.ObjectSerializer();
assertThrows('Should have an assertion failure in deserialization',
function() {
serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
});
}
function testDeserializationNumbersOrStrings() {
// 64-bit types may have been serialized as numbers or strings.
// Deserialization should be able to handle either.
var simplifiedWithNumbers = {
50: 5000,
51: 5100,
52: [ 5200, 5201 ],
53: [ 5300, 5301 ]
};
var simplifiedWithStrings = {
50: '5000',
51: '5100',
52: [ '5200', '5201' ],
53: [ '5300', '5301' ]
};
var serializer = new goog.proto2.ObjectSerializer();
var message = serializer.deserialize(
proto2.TestAllTypes.getDescriptor(), simplifiedWithNumbers);
assertNotNull(message);
assertEquals(5000, message.getOptionalInt64Number());
assertEquals('5100', message.getOptionalInt64String());
assertEquals(5200, message.getRepeatedInt64Number(0));
assertEquals(5201, message.getRepeatedInt64Number(1));
assertEquals('5300', message.getRepeatedInt64String(0));
assertEquals('5301', message.getRepeatedInt64String(1));
assertArrayEquals([5200, 5201], message.repeatedInt64NumberArray());
assertArrayEquals(['5300', '5301'], message.repeatedInt64StringArray());
message = serializer.deserialize(
proto2.TestAllTypes.getDescriptor(), simplifiedWithStrings);
assertNotNull(message);
assertEquals(5000, message.getOptionalInt64Number());
assertEquals('5100', message.getOptionalInt64String());
assertEquals(5200, message.getRepeatedInt64Number(0));
assertEquals(5201, message.getRepeatedInt64Number(1));
assertEquals('5300', message.getRepeatedInt64String(0));
assertEquals('5301', message.getRepeatedInt64String(1));
assertArrayEquals([5200, 5201], message.repeatedInt64NumberArray());
assertArrayEquals(['5300', '5301'], message.repeatedInt64StringArray());
}
function testDeserializationConversionProhibited() {
// 64-bit types may have been serialized as numbers or strings.
// But 32-bit types must be serialized as numbers.
// Test deserialization fails on 32-bit numbers as strings.
var simplified = {
1: '1000' // optionalInt32
};
var serializer = new goog.proto2.ObjectSerializer();
assertThrows('Should have an assertion failure in deserialization',
function() {
serializer.deserialize(proto2.TestAllTypes.getDescriptor(), simplified);
});
}
function testDefaultValueNumbersOrStrings() {
// 64-bit types may have been serialized as numbers or strings.
// The default values should have the correct type.
var serializer = new goog.proto2.ObjectSerializer();
var message = serializer.deserialize(proto2.TestAllTypes.getDescriptor(), {});
assertNotNull(message);
// Default when using Number is a number, and precision is lost.
var value = message.getOptionalInt64NumberOrDefault();
assertTrue('Expecting a number', typeof value === 'number');
assertEquals(1000000000000000000, value);
assertEquals(1000000000000000001, value);
assertEquals(1000000000000000002, value);
assertEquals('1000000000000000000', String(value)); // Value is rounded!
// When using a String, the value is preserved.
assertEquals('1000000000000000001',
message.getOptionalInt64StringOrDefault());
}
</script>
</body>
</html>