Protocol Buffers - Google's data interchange format (grpc依赖)
https://developers.google.com/protocol-buffers/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1060 lines
41 KiB
1060 lines
41 KiB
// Protocol Buffers - Google's data interchange format |
|
// Copyright 2008 Google Inc. All rights reserved. |
|
// https://developers.google.com/protocol-buffers/ |
|
// |
|
// Redistribution and use in source and binary forms, with or without |
|
// modification, are permitted provided that the following conditions are |
|
// met: |
|
// |
|
// * Redistributions of source code must retain the above copyright |
|
// notice, this list of conditions and the following disclaimer. |
|
// * Redistributions in binary form must reproduce the above |
|
// copyright notice, this list of conditions and the following disclaimer |
|
// in the documentation and/or other materials provided with the |
|
// distribution. |
|
// * Neither the name of Google Inc. nor the names of its |
|
// contributors may be used to endorse or promote products derived from |
|
// this software without specific prior written permission. |
|
// |
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
|
|
// Test suite is written using Jasmine -- see http://jasmine.github.io/ |
|
|
|
goog.setTestOnly(); |
|
|
|
goog.require('goog.json'); |
|
goog.require('goog.testing.asserts'); |
|
goog.require('goog.userAgent'); |
|
|
|
// CommonJS-LoadFromFile: google-protobuf jspb |
|
goog.require('jspb.Message'); |
|
|
|
// CommonJS-LoadFromFile: test5_pb proto.jspb.exttest.beta |
|
goog.require('proto.jspb.exttest.beta.floatingStrField'); |
|
|
|
// CommonJS-LoadFromFile: test3_pb proto.jspb.exttest |
|
goog.require('proto.jspb.exttest.floatingMsgField'); |
|
|
|
// CommonJS-LoadFromFile: test4_pb proto.jspb.exttest |
|
goog.require('proto.jspb.exttest.floatingMsgFieldTwo'); |
|
|
|
// CommonJS-LoadFromFile: test_pb proto.jspb.test |
|
goog.require('proto.jspb.test.CloneExtension'); |
|
goog.require('proto.jspb.test.Complex'); |
|
goog.require('proto.jspb.test.DefaultValues'); |
|
goog.require('proto.jspb.test.Empty'); |
|
goog.require('proto.jspb.test.EnumContainer'); |
|
goog.require('proto.jspb.test.floatingMsgField'); |
|
goog.require('proto.jspb.test.FloatingPointFields'); |
|
goog.require('proto.jspb.test.floatingStrField'); |
|
goog.require('proto.jspb.test.HasExtensions'); |
|
goog.require('proto.jspb.test.IndirectExtension'); |
|
goog.require('proto.jspb.test.IsExtension'); |
|
goog.require('proto.jspb.test.OptionalFields'); |
|
goog.require('proto.jspb.test.OuterEnum'); |
|
goog.require('proto.jspb.test.OuterMessage.Complex'); |
|
goog.require('proto.jspb.test.Simple1'); |
|
goog.require('proto.jspb.test.Simple2'); |
|
goog.require('proto.jspb.test.SpecialCases'); |
|
goog.require('proto.jspb.test.TestClone'); |
|
goog.require('proto.jspb.test.TestGroup'); |
|
goog.require('proto.jspb.test.TestGroup1'); |
|
goog.require('proto.jspb.test.TestMessageWithOneof'); |
|
goog.require('proto.jspb.test.TestReservedNames'); |
|
goog.require('proto.jspb.test.TestReservedNamesExtension'); |
|
|
|
// CommonJS-LoadFromFile: test2_pb proto.jspb.test |
|
goog.require('proto.jspb.test.ExtensionMessage'); |
|
goog.require('proto.jspb.test.TestExtensionsMessage'); |
|
goog.require('proto.jspb.test.simple1'); |
|
|
|
|
|
|
|
describe('Message test suite', function() { |
|
it('testEmptyProto', function() { |
|
var empty1 = new proto.jspb.test.Empty([]); |
|
var empty2 = new proto.jspb.test.Empty([]); |
|
assertObjectEquals({}, empty1.toObject()); |
|
assertObjectEquals('Message should not be corrupted:', empty2, empty1); |
|
}); |
|
|
|
it('testTopLevelEnum', function() { |
|
var response = new proto.jspb.test.EnumContainer([]); |
|
response.setOuterEnum(proto.jspb.test.OuterEnum.FOO); |
|
assertEquals(proto.jspb.test.OuterEnum.FOO, response.getOuterEnum()); |
|
}); |
|
|
|
it('testByteStrings', function() { |
|
var data = new proto.jspb.test.DefaultValues([]); |
|
data.setBytesField('some_bytes'); |
|
assertEquals('some_bytes', data.getBytesField()); |
|
}); |
|
|
|
it('testComplexConversion', function() { |
|
var data1 = ['a', , , [, 11], [[, 22], [, 33]], , ['s1', 's2'], , true]; |
|
var data2 = ['a', , , [, 11], [[, 22], [, 33]], , ['s1', 's2'], , true]; |
|
var foo = new proto.jspb.test.Complex(data1); |
|
var bar = new proto.jspb.test.Complex(data2); |
|
var result = foo.toObject(); |
|
assertObjectEquals( |
|
{ |
|
aString: 'a', |
|
anOutOfOrderBool: true, |
|
aNestedMessage: {anInt: 11}, |
|
aRepeatedMessageList: [{anInt: 22}, {anInt: 33}], |
|
aRepeatedStringList: ['s1', 's2'] |
|
}, |
|
result); |
|
|
|
// Now test with the jspb instances included. |
|
result = foo.toObject(true /* opt_includeInstance */); |
|
assertObjectEquals( |
|
{ |
|
aString: 'a', |
|
anOutOfOrderBool: true, |
|
aNestedMessage: |
|
{anInt: 11, $jspbMessageInstance: foo.getANestedMessage()}, |
|
aRepeatedMessageList: [ |
|
{anInt: 22, $jspbMessageInstance: foo.getARepeatedMessageList()[0]}, |
|
{anInt: 33, $jspbMessageInstance: foo.getARepeatedMessageList()[1]} |
|
], |
|
aRepeatedStringList: ['s1', 's2'], |
|
$jspbMessageInstance: foo |
|
}, |
|
result); |
|
}); |
|
|
|
it('testMissingFields', function() { |
|
var foo = new proto.jspb.test.Complex([ |
|
undefined, undefined, undefined, [], undefined, undefined, undefined, |
|
undefined |
|
]); |
|
var bar = new proto.jspb.test.Complex([ |
|
undefined, undefined, undefined, [], undefined, undefined, undefined, |
|
undefined |
|
]); |
|
var result = foo.toObject(); |
|
assertObjectEquals( |
|
{ |
|
aString: undefined, |
|
anOutOfOrderBool: undefined, |
|
aNestedMessage: {anInt: undefined}, |
|
// Note: JsPb converts undefined repeated fields to empty arrays. |
|
aRepeatedMessageList: [], |
|
aRepeatedStringList: [] |
|
}, |
|
result); |
|
}); |
|
|
|
it('testNestedComplexMessage', function() { |
|
// Instantiate the message and set a unique field, just to ensure that we |
|
// are not getting jspb.test.Complex instead. |
|
var msg = new proto.jspb.test.OuterMessage.Complex(); |
|
msg.setInnerComplexField(5); |
|
}); |
|
|
|
it('testSpecialCases', function() { |
|
// Note: Some property names are reserved in JavaScript. |
|
// These names are converted to the Js property named pb_<reserved_name>. |
|
var special = new proto.jspb.test.SpecialCases( |
|
['normal', 'default', 'function', 'var']); |
|
var result = special.toObject(); |
|
assertObjectEquals( |
|
{ |
|
normal: 'normal', |
|
pb_default: 'default', |
|
pb_function: 'function', |
|
pb_var: 'var' |
|
}, |
|
result); |
|
}); |
|
|
|
it('testDefaultValues', function() { |
|
var defaultString = 'default<>\'"abc'; |
|
var response = new proto.jspb.test.DefaultValues(); |
|
|
|
// Test toObject |
|
var expectedObject = { |
|
stringField: defaultString, |
|
boolField: true, |
|
intField: 11, |
|
enumField: 13, |
|
emptyField: '', |
|
bytesField: 'bW9v' |
|
}; |
|
assertObjectEquals(expectedObject, response.toObject()); |
|
|
|
|
|
// Test getters |
|
response = new proto.jspb.test.DefaultValues(); |
|
assertEquals(defaultString, response.getStringField()); |
|
assertEquals(true, response.getBoolField()); |
|
assertEquals(11, response.getIntField()); |
|
assertEquals(13, response.getEnumField()); |
|
assertEquals('', response.getEmptyField()); |
|
assertEquals('bW9v', response.getBytesField()); |
|
|
|
function makeDefault(values) { |
|
return new proto.jspb.test.DefaultValues(values); |
|
} |
|
|
|
// Test with undefined values, |
|
// Use push to workaround IE treating undefined array elements as holes. |
|
response = makeDefault([undefined, undefined, undefined, undefined]); |
|
assertEquals(defaultString, response.getStringField()); |
|
assertEquals(true, response.getBoolField()); |
|
assertEquals(11, response.getIntField()); |
|
assertEquals(13, response.getEnumField()); |
|
assertFalse(response.hasStringField()); |
|
assertFalse(response.hasBoolField()); |
|
assertFalse(response.hasIntField()); |
|
assertFalse(response.hasEnumField()); |
|
|
|
// Test with null values, as would be returned by a JSON serializer. |
|
response = makeDefault([null, null, null, null]); |
|
assertEquals(defaultString, response.getStringField()); |
|
assertEquals(true, response.getBoolField()); |
|
assertEquals(11, response.getIntField()); |
|
assertEquals(13, response.getEnumField()); |
|
assertFalse(response.hasStringField()); |
|
assertFalse(response.hasBoolField()); |
|
assertFalse(response.hasIntField()); |
|
assertFalse(response.hasEnumField()); |
|
|
|
// Test with false-like values. |
|
response = makeDefault(['', false, 0, 0]); |
|
assertEquals('', response.getStringField()); |
|
assertEquals(false, response.getBoolField()); |
|
assertEquals(true, response.getIntField() == 0); |
|
assertEquals(true, response.getEnumField() == 0); |
|
assertTrue(response.hasStringField()); |
|
assertTrue(response.hasBoolField()); |
|
assertTrue(response.hasIntField()); |
|
assertTrue(response.hasEnumField()); |
|
|
|
// Test that clearing the values reverts them to the default state. |
|
response = makeDefault(['blah', false, 111, 77]); |
|
response.clearStringField(); |
|
response.clearBoolField(); |
|
response.clearIntField(); |
|
response.clearEnumField(); |
|
assertEquals(defaultString, response.getStringField()); |
|
assertEquals(true, response.getBoolField()); |
|
assertEquals(11, response.getIntField()); |
|
assertEquals(13, response.getEnumField()); |
|
assertFalse(response.hasStringField()); |
|
assertFalse(response.hasBoolField()); |
|
assertFalse(response.hasIntField()); |
|
assertFalse(response.hasEnumField()); |
|
|
|
// Test that setFoo(null) clears the values. |
|
response = makeDefault(['blah', false, 111, 77]); |
|
response.setStringField(null); |
|
response.setBoolField(null); |
|
response.setIntField(undefined); |
|
response.setEnumField(undefined); |
|
assertEquals(defaultString, response.getStringField()); |
|
assertEquals(true, response.getBoolField()); |
|
assertEquals(11, response.getIntField()); |
|
assertEquals(13, response.getEnumField()); |
|
assertFalse(response.hasStringField()); |
|
assertFalse(response.hasBoolField()); |
|
assertFalse(response.hasIntField()); |
|
assertFalse(response.hasEnumField()); |
|
}); |
|
|
|
it('testClearFields', function() { |
|
var data = ['str', true, [11], [[22], [33]], ['s1', 's2']]; |
|
var foo = new proto.jspb.test.OptionalFields(data); |
|
foo.clearAString(); |
|
foo.clearABool(); |
|
foo.clearANestedMessage(); |
|
foo.clearARepeatedMessageList(); |
|
foo.clearARepeatedStringList(); |
|
assertEquals('', foo.getAString()); |
|
assertEquals(false, foo.getABool()); |
|
assertUndefined(foo.getANestedMessage()); |
|
assertFalse(foo.hasAString()); |
|
assertFalse(foo.hasABool()); |
|
assertObjectEquals([], foo.getARepeatedMessageList()); |
|
assertObjectEquals([], foo.getARepeatedStringList()); |
|
// NOTE: We want the missing fields in 'expected' to be undefined, |
|
// but we actually get a sparse array instead. We could use something |
|
// like [1,undefined,2] to avoid this, except that this is still |
|
// sparse on IE. No comment... |
|
var expected = [, , , [], []]; |
|
expected[0] = expected[1] = expected[2] = undefined; |
|
assertObjectEquals(expected, foo.toArray()); |
|
}); |
|
|
|
it('testDifferenceRawObject', /** @suppress {visibility} */ function() { |
|
var p1 = new proto.jspb.test.HasExtensions(['hi', 'diff', {}]); |
|
var p2 = |
|
new proto.jspb.test.HasExtensions(['hi', 'what', {1000: 'unique'}]); |
|
var diff = /** @type {proto.jspb.test.HasExtensions} */ |
|
(jspb.Message.difference(p1, p2)); |
|
assertEquals('', diff.getStr1()); |
|
assertEquals('what', diff.getStr2()); |
|
assertEquals('', diff.getStr3()); |
|
assertEquals('unique', diff.extensionObject_[1000]); |
|
}); |
|
|
|
it('testEqualsSimple', function() { |
|
var s1 = new proto.jspb.test.Simple1(['hi']); |
|
assertTrue(jspb.Message.equals(s1, new proto.jspb.test.Simple1(['hi']))); |
|
assertFalse(jspb.Message.equals(s1, new proto.jspb.test.Simple1(['bye']))); |
|
var s1b = new proto.jspb.test.Simple1(['hi', ['hello']]); |
|
assertTrue(jspb.Message.equals( |
|
s1b, new proto.jspb.test.Simple1(['hi', ['hello']]))); |
|
assertTrue(jspb.Message.equals(s1b, new proto.jspb.test.Simple1([ |
|
'hi', ['hello', undefined, undefined, undefined] |
|
]))); |
|
assertFalse(jspb.Message.equals( |
|
s1b, new proto.jspb.test.Simple1(['no', ['hello']]))); |
|
// Test with messages of different types |
|
var s2 = new proto.jspb.test.Simple2(['hi']); |
|
assertFalse(jspb.Message.equals(s1, s2)); |
|
}); |
|
|
|
it('testEquals_softComparison', function() { |
|
var s1 = new proto.jspb.test.Simple1(['hi', [], null]); |
|
assertTrue( |
|
jspb.Message.equals(s1, new proto.jspb.test.Simple1(['hi', []]))); |
|
|
|
var s1b = new proto.jspb.test.Simple1(['hi', [], true]); |
|
assertTrue( |
|
jspb.Message.equals(s1b, new proto.jspb.test.Simple1(['hi', [], 1]))); |
|
}); |
|
|
|
it('testEqualsComplex', function() { |
|
var data1 = ['a', , , [, 11], [[, 22], [, 33]], , ['s1', 's2'], , 1]; |
|
var data2 = ['a', , , [, 11], [[, 22], [, 34]], , ['s1', 's2'], , 1]; |
|
var data3 = ['a', , , [, 11], [[, 22]], , ['s1', 's2'], , 1]; |
|
var data4 = ['hi']; |
|
var c1a = new proto.jspb.test.Complex(data1); |
|
var c1b = new proto.jspb.test.Complex(data1); |
|
var c2 = new proto.jspb.test.Complex(data2); |
|
var c3 = new proto.jspb.test.Complex(data3); |
|
var s1 = new proto.jspb.test.Simple1(data4); |
|
|
|
assertTrue(jspb.Message.equals(c1a, c1b)); |
|
assertFalse(jspb.Message.equals(c1a, c2)); |
|
assertFalse(jspb.Message.equals(c2, c3)); |
|
assertFalse(jspb.Message.equals(c1a, s1)); |
|
}); |
|
|
|
it('testEqualsExtensionsConstructed', function() { |
|
assertTrue(jspb.Message.equals( |
|
new proto.jspb.test.HasExtensions([]), |
|
new proto.jspb.test.HasExtensions([{}]))); |
|
assertTrue(jspb.Message.equals( |
|
new proto.jspb.test.HasExtensions(['hi', {100: [{200: 'a'}]}]), |
|
new proto.jspb.test.HasExtensions(['hi', {100: [{200: 'a'}]}]))); |
|
assertFalse(jspb.Message.equals( |
|
new proto.jspb.test.HasExtensions(['hi', {100: [{200: 'a'}]}]), |
|
new proto.jspb.test.HasExtensions(['hi', {100: [{200: 'b'}]}]))); |
|
assertTrue(jspb.Message.equals( |
|
new proto.jspb.test.HasExtensions([{100: [{200: 'a'}]}]), |
|
new proto.jspb.test.HasExtensions([{100: [{200: 'a'}]}]))); |
|
assertTrue(jspb.Message.equals( |
|
new proto.jspb.test.HasExtensions([{100: [{200: 'a'}]}]), |
|
new proto.jspb.test.HasExtensions([, , , {100: [{200: 'a'}]}]))); |
|
assertTrue(jspb.Message.equals( |
|
new proto.jspb.test.HasExtensions([, , , {100: [{200: 'a'}]}]), |
|
new proto.jspb.test.HasExtensions([{100: [{200: 'a'}]}]))); |
|
assertTrue(jspb.Message.equals( |
|
new proto.jspb.test.HasExtensions(['hi', {100: [{200: 'a'}]}]), |
|
new proto.jspb.test.HasExtensions(['hi', , , {100: [{200: 'a'}]}]))); |
|
assertTrue(jspb.Message.equals( |
|
new proto.jspb.test.HasExtensions(['hi', , , {100: [{200: 'a'}]}]), |
|
new proto.jspb.test.HasExtensions(['hi', {100: [{200: 'a'}]}]))); |
|
}); |
|
|
|
it('testEqualsExtensionsUnconstructed', function() { |
|
assertTrue(jspb.Message.compareFields([], [{}])); |
|
assertTrue(jspb.Message.compareFields([, , , {}], [])); |
|
assertTrue(jspb.Message.compareFields([, , , {}], [, , {}])); |
|
assertTrue(jspb.Message.compareFields( |
|
['hi', {100: [{200: 'a'}]}], ['hi', {100: [{200: 'a'}]}])); |
|
assertFalse(jspb.Message.compareFields( |
|
['hi', {100: [{200: 'a'}]}], ['hi', {100: [{200: 'b'}]}])); |
|
assertTrue(jspb.Message.compareFields( |
|
[{100: [{200: 'a'}]}], [{100: [{200: 'a'}]}])); |
|
assertTrue(jspb.Message.compareFields( |
|
[{100: [{200: 'a'}]}], [, , , {100: [{200: 'a'}]}])); |
|
assertTrue(jspb.Message.compareFields( |
|
[, , , {100: [{200: 'a'}]}], [{100: [{200: 'a'}]}])); |
|
assertTrue(jspb.Message.compareFields( |
|
['hi', {100: [{200: 'a'}]}], ['hi', , , {100: [{200: 'a'}]}])); |
|
assertTrue(jspb.Message.compareFields( |
|
['hi', , , {100: [{200: 'a'}]}], ['hi', {100: [{200: 'a'}]}])); |
|
}); |
|
|
|
it('testToMap', function() { |
|
var p1 = new proto.jspb.test.Simple1(['k', ['v']]); |
|
var p2 = new proto.jspb.test.Simple1(['k1', ['v1', 'v2']]); |
|
var soymap = jspb.Message.toMap( |
|
[p1, p2], proto.jspb.test.Simple1.prototype.getAString, |
|
proto.jspb.test.Simple1.prototype.toObject); |
|
assertEquals('k', soymap['k'].aString); |
|
assertArrayEquals(['v'], soymap['k'].aRepeatedStringList); |
|
var protomap = jspb.Message.toMap( |
|
[p1, p2], proto.jspb.test.Simple1.prototype.getAString); |
|
assertEquals('k', protomap['k'].getAString()); |
|
assertArrayEquals(['v'], protomap['k'].getARepeatedStringList()); |
|
}); |
|
|
|
it('testClone', function() { |
|
var supportsUint8Array = |
|
!goog.userAgent.IE || goog.userAgent.isVersionOrHigher('10'); |
|
var original = new proto.jspb.test.TestClone(); |
|
original.setStr('v1'); |
|
var simple1 = new proto.jspb.test.Simple1(['x1', ['y1', 'z1']]); |
|
var simple2 = new proto.jspb.test.Simple1(['x2', ['y2', 'z2']]); |
|
var simple3 = new proto.jspb.test.Simple1(['x3', ['y3', 'z3']]); |
|
original.setSimple1(simple1); |
|
original.setSimple2List([simple2, simple3]); |
|
var bytes1 = supportsUint8Array ? new Uint8Array([1, 2, 3]) : '123'; |
|
original.setBytesField(bytes1); |
|
var extension = new proto.jspb.test.CloneExtension(); |
|
extension.setExt('e1'); |
|
original.setExtension(proto.jspb.test.IsExtension.extField, extension); |
|
var clone = original.clone(); |
|
assertArrayEquals( |
|
[ |
|
'v1', , ['x1', ['y1', 'z1']], , |
|
[['x2', ['y2', 'z2']], ['x3', ['y3', 'z3']]], bytes1, , |
|
{100: [, 'e1']} |
|
], |
|
clone.toArray()); |
|
clone.setStr('v2'); |
|
var simple4 = new proto.jspb.test.Simple1(['a1', ['b1', 'c1']]); |
|
var simple5 = new proto.jspb.test.Simple1(['a2', ['b2', 'c2']]); |
|
var simple6 = new proto.jspb.test.Simple1(['a3', ['b3', 'c3']]); |
|
clone.setSimple1(simple4); |
|
clone.setSimple2List([simple5, simple6]); |
|
if (supportsUint8Array) { |
|
clone.getBytesField()[0] = 4; |
|
assertObjectEquals(bytes1, original.getBytesField()); |
|
} |
|
var bytes2 = supportsUint8Array ? new Uint8Array([4, 5, 6]) : '456'; |
|
clone.setBytesField(bytes2); |
|
var newExtension = new proto.jspb.test.CloneExtension(); |
|
newExtension.setExt('e2'); |
|
clone.setExtension(proto.jspb.test.CloneExtension.extField, newExtension); |
|
assertArrayEquals( |
|
[ |
|
'v2', , ['a1', ['b1', 'c1']], , |
|
[['a2', ['b2', 'c2']], ['a3', ['b3', 'c3']]], bytes2, , |
|
{100: [, 'e2']} |
|
], |
|
clone.toArray()); |
|
assertArrayEquals( |
|
[ |
|
'v1', , ['x1', ['y1', 'z1']], , |
|
[['x2', ['y2', 'z2']], ['x3', ['y3', 'z3']]], bytes1, , |
|
{100: [, 'e1']} |
|
], |
|
original.toArray()); |
|
}); |
|
|
|
it('testCopyInto', function() { |
|
var supportsUint8Array = |
|
!goog.userAgent.IE || goog.userAgent.isVersionOrHigher('10'); |
|
var original = new proto.jspb.test.TestClone(); |
|
original.setStr('v1'); |
|
var dest = new proto.jspb.test.TestClone(); |
|
dest.setStr('override'); |
|
var simple1 = new proto.jspb.test.Simple1(['x1', ['y1', 'z1']]); |
|
var simple2 = new proto.jspb.test.Simple1(['x2', ['y2', 'z2']]); |
|
var simple3 = new proto.jspb.test.Simple1(['x3', ['y3', 'z3']]); |
|
var destSimple1 = new proto.jspb.test.Simple1(['ox1', ['oy1', 'oz1']]); |
|
var destSimple2 = new proto.jspb.test.Simple1(['ox2', ['oy2', 'oz2']]); |
|
var destSimple3 = new proto.jspb.test.Simple1(['ox3', ['oy3', 'oz3']]); |
|
original.setSimple1(simple1); |
|
original.setSimple2List([simple2, simple3]); |
|
dest.setSimple1(destSimple1); |
|
dest.setSimple2List([destSimple2, destSimple3]); |
|
var bytes1 = supportsUint8Array ? new Uint8Array([1, 2, 3]) : '123'; |
|
var bytes2 = supportsUint8Array ? new Uint8Array([4, 5, 6]) : '456'; |
|
original.setBytesField(bytes1); |
|
dest.setBytesField(bytes2); |
|
var extension = new proto.jspb.test.CloneExtension(); |
|
extension.setExt('e1'); |
|
original.setExtension(proto.jspb.test.CloneExtension.extField, extension); |
|
|
|
jspb.Message.copyInto(original, dest); |
|
assertArrayEquals(original.toArray(), dest.toArray()); |
|
assertEquals('x1', dest.getSimple1().getAString()); |
|
assertEquals( |
|
'e1', |
|
dest.getExtension(proto.jspb.test.CloneExtension.extField).getExt()); |
|
dest.getSimple1().setAString('new value'); |
|
assertNotEquals( |
|
dest.getSimple1().getAString(), original.getSimple1().getAString()); |
|
if (supportsUint8Array) { |
|
dest.getBytesField()[0] = 7; |
|
assertObjectEquals(bytes1, original.getBytesField()); |
|
assertObjectEquals(new Uint8Array([7, 2, 3]), dest.getBytesField()); |
|
} else { |
|
dest.setBytesField('789'); |
|
assertObjectEquals(bytes1, original.getBytesField()); |
|
assertObjectEquals('789', dest.getBytesField()); |
|
} |
|
dest.getExtension(proto.jspb.test.CloneExtension.extField) |
|
.setExt('new value'); |
|
assertNotEquals( |
|
dest.getExtension(proto.jspb.test.CloneExtension.extField).getExt(), |
|
original.getExtension(proto.jspb.test.CloneExtension.extField) |
|
.getExt()); |
|
}); |
|
|
|
it('testCopyInto_notSameType', function() { |
|
var a = new proto.jspb.test.TestClone(); |
|
var b = new proto.jspb.test.Simple1(['str', ['s1', 's2']]); |
|
|
|
var e = assertThrows(function() { |
|
jspb.Message.copyInto(a, b); |
|
}); |
|
assertContains('should have the same type', e.message); |
|
}); |
|
|
|
it('testExtensions', function() { |
|
var extension1 = new proto.jspb.test.IsExtension(['ext1field']); |
|
var extension2 = new proto.jspb.test.Simple1(['str', ['s1', 's2']]); |
|
var extendable = new proto.jspb.test.HasExtensions(['v1', 'v2', 'v3']); |
|
extendable.setExtension(proto.jspb.test.IsExtension.extField, extension1); |
|
extendable.setExtension( |
|
proto.jspb.test.IndirectExtension.simple, extension2); |
|
extendable.setExtension(proto.jspb.test.IndirectExtension.str, 'xyzzy'); |
|
extendable.setExtension( |
|
proto.jspb.test.IndirectExtension.repeatedStrList, ['a', 'b']); |
|
var s1 = new proto.jspb.test.Simple1(['foo', ['s1', 's2']]); |
|
var s2 = new proto.jspb.test.Simple1(['bar', ['t1', 't2']]); |
|
extendable.setExtension( |
|
proto.jspb.test.IndirectExtension.repeatedSimpleList, [s1, s2]); |
|
assertObjectEquals( |
|
extension1, |
|
extendable.getExtension(proto.jspb.test.IsExtension.extField)); |
|
assertObjectEquals( |
|
extension2, |
|
extendable.getExtension(proto.jspb.test.IndirectExtension.simple)); |
|
assertObjectEquals( |
|
'xyzzy', |
|
extendable.getExtension(proto.jspb.test.IndirectExtension.str)); |
|
assertObjectEquals( |
|
['a', 'b'], |
|
extendable.getExtension( |
|
proto.jspb.test.IndirectExtension.repeatedStrList)); |
|
assertObjectEquals( |
|
[s1, s2], |
|
extendable.getExtension( |
|
proto.jspb.test.IndirectExtension.repeatedSimpleList)); |
|
// Not supported yet, but it should work... |
|
extendable.setExtension(proto.jspb.test.IndirectExtension.simple, null); |
|
assertNull( |
|
extendable.getExtension(proto.jspb.test.IndirectExtension.simple)); |
|
extendable.setExtension(proto.jspb.test.IndirectExtension.str, null); |
|
assertNull(extendable.getExtension(proto.jspb.test.IndirectExtension.str)); |
|
|
|
|
|
// Extension fields with jspb.ignore = true are ignored. |
|
assertUndefined(proto.jspb.test.IndirectExtension['ignored']); |
|
assertUndefined(proto.jspb.test.HasExtensions['ignoredFloating']); |
|
}); |
|
|
|
it('testFloatingExtensions', function() { |
|
// From an autogenerated container. |
|
var extendable = new proto.jspb.test.HasExtensions(['v1', 'v2', 'v3']); |
|
var extension = new proto.jspb.test.Simple1(['foo', ['s1', 's2']]); |
|
extendable.setExtension(proto.jspb.test.simple1, extension); |
|
assertObjectEquals( |
|
extension, extendable.getExtension(proto.jspb.test.simple1)); |
|
|
|
// From _lib mode. |
|
extension = new proto.jspb.test.ExtensionMessage(['s1']); |
|
extendable = new proto.jspb.test.TestExtensionsMessage([16]); |
|
extendable.setExtension(proto.jspb.test.floatingMsgField, extension); |
|
extendable.setExtension(proto.jspb.test.floatingStrField, 's2'); |
|
assertObjectEquals( |
|
extension, extendable.getExtension(proto.jspb.test.floatingMsgField)); |
|
assertObjectEquals( |
|
's2', extendable.getExtension(proto.jspb.test.floatingStrField)); |
|
assertNotUndefined(proto.jspb.exttest.floatingMsgField); |
|
assertNotUndefined(proto.jspb.exttest.floatingMsgFieldTwo); |
|
assertNotUndefined(proto.jspb.exttest.beta.floatingStrField); |
|
}); |
|
|
|
it('testToObject_extendedObject', function() { |
|
var extension1 = new proto.jspb.test.IsExtension(['ext1field']); |
|
var extension2 = new proto.jspb.test.Simple1(['str', ['s1', 's2'], true]); |
|
var extendable = new proto.jspb.test.HasExtensions(['v1', 'v2', 'v3']); |
|
extendable.setExtension(proto.jspb.test.IsExtension.extField, extension1); |
|
extendable.setExtension( |
|
proto.jspb.test.IndirectExtension.simple, extension2); |
|
extendable.setExtension(proto.jspb.test.IndirectExtension.str, 'xyzzy'); |
|
extendable.setExtension( |
|
proto.jspb.test.IndirectExtension.repeatedStrList, ['a', 'b']); |
|
var s1 = new proto.jspb.test.Simple1(['foo', ['s1', 's2'], true]); |
|
var s2 = new proto.jspb.test.Simple1(['bar', ['t1', 't2'], false]); |
|
extendable.setExtension( |
|
proto.jspb.test.IndirectExtension.repeatedSimpleList, [s1, s2]); |
|
assertObjectEquals( |
|
{ |
|
str1: 'v1', |
|
str2: 'v2', |
|
str3: 'v3', |
|
extField: {ext1: 'ext1field'}, |
|
simple: { |
|
aString: 'str', |
|
aRepeatedStringList: ['s1', 's2'], |
|
aBoolean: true |
|
}, |
|
str: 'xyzzy', |
|
repeatedStrList: ['a', 'b'], |
|
repeatedSimpleList: [ |
|
{aString: 'foo', aRepeatedStringList: ['s1', 's2'], aBoolean: true}, |
|
{aString: 'bar', aRepeatedStringList: ['t1', 't2'], aBoolean: false} |
|
] |
|
}, |
|
extendable.toObject()); |
|
|
|
// Now, with instances included. |
|
assertObjectEquals( |
|
{ |
|
str1: 'v1', |
|
str2: 'v2', |
|
str3: 'v3', |
|
extField: { |
|
ext1: 'ext1field', |
|
$jspbMessageInstance: |
|
extendable.getExtension(proto.jspb.test.IsExtension.extField) |
|
}, |
|
simple: { |
|
aString: 'str', |
|
aRepeatedStringList: ['s1', 's2'], |
|
aBoolean: true, |
|
$jspbMessageInstance: extendable.getExtension( |
|
proto.jspb.test.IndirectExtension.simple) |
|
}, |
|
str: 'xyzzy', |
|
repeatedStrList: ['a', 'b'], |
|
repeatedSimpleList: [ |
|
{ |
|
aString: 'foo', |
|
aRepeatedStringList: ['s1', 's2'], |
|
aBoolean: true, |
|
$jspbMessageInstance: s1 |
|
}, |
|
{ |
|
aString: 'bar', |
|
aRepeatedStringList: ['t1', 't2'], |
|
aBoolean: false, |
|
$jspbMessageInstance: s2 |
|
} |
|
], |
|
$jspbMessageInstance: extendable |
|
}, |
|
extendable.toObject(true /* opt_includeInstance */)); |
|
}); |
|
|
|
it('testInitialization_emptyArray', function() { |
|
var msg = new proto.jspb.test.HasExtensions([]); |
|
assertArrayEquals([], msg.toArray()); |
|
}); |
|
|
|
it('testInitialization_justExtensionObject', function() { |
|
var msg = new proto.jspb.test.Empty([{1: 'hi'}]); |
|
// The extensionObject is not moved from its original location. |
|
assertArrayEquals([{1: 'hi'}], msg.toArray()); |
|
}); |
|
|
|
it('testInitialization_incompleteList', function() { |
|
var msg = new proto.jspb.test.Empty([1, {4: 'hi'}]); |
|
// The extensionObject is not moved from its original location. |
|
assertArrayEquals([1, {4: 'hi'}], msg.toArray()); |
|
}); |
|
|
|
it('testInitialization_forwardCompatible', function() { |
|
var msg = new proto.jspb.test.Empty([1, 2, 3, {1: 'hi'}]); |
|
assertArrayEquals([1, 2, 3, {1: 'hi'}], msg.toArray()); |
|
}); |
|
|
|
it('testExtendedMessageEnsureObject', |
|
/** @suppress {visibility} */ function() { |
|
var data = |
|
new proto.jspb.test.HasExtensions(['str1', {'a_key': 'an_object'}]); |
|
assertEquals('an_object', data.extensionObject_['a_key']); |
|
}); |
|
|
|
it('testToObject_hasExtensionField', function() { |
|
var data = new proto.jspb.test.HasExtensions(['str1', {100: ['ext1']}]); |
|
var obj = data.toObject(); |
|
assertEquals('str1', obj.str1); |
|
assertEquals('ext1', obj.extField.ext1); |
|
}); |
|
|
|
it('testGetExtension', function() { |
|
var data = new proto.jspb.test.HasExtensions(['str1', {100: ['ext1']}]); |
|
assertEquals('str1', data.getStr1()); |
|
var extension = data.getExtension(proto.jspb.test.IsExtension.extField); |
|
assertNotNull(extension); |
|
assertEquals('ext1', extension.getExt1()); |
|
}); |
|
|
|
it('testSetExtension', function() { |
|
var data = new proto.jspb.test.HasExtensions(); |
|
var extensionMessage = new proto.jspb.test.IsExtension(['is_extension']); |
|
data.setExtension(proto.jspb.test.IsExtension.extField, extensionMessage); |
|
var obj = data.toObject(); |
|
assertNotNull(data.getExtension(proto.jspb.test.IsExtension.extField)); |
|
assertEquals('is_extension', obj.extField.ext1); |
|
}); |
|
|
|
/** |
|
* Note that group is long deprecated, we only support it because JsPb has |
|
* a goal of being able to generate JS classes for all proto descriptors. |
|
*/ |
|
it('testGroups', function() { |
|
var group = new proto.jspb.test.TestGroup(); |
|
var someGroup = new proto.jspb.test.TestGroup.RepeatedGroup(); |
|
someGroup.setId('g1'); |
|
someGroup.setSomeBoolList([true, false]); |
|
group.setRepeatedGroupList([someGroup]); |
|
var groups = group.getRepeatedGroupList(); |
|
assertEquals('g1', groups[0].getId()); |
|
assertObjectEquals([true, false], groups[0].getSomeBoolList()); |
|
assertObjectEquals( |
|
{id: 'g1', someBoolList: [true, false]}, groups[0].toObject()); |
|
assertObjectEquals( |
|
{ |
|
repeatedGroupList: [{id: 'g1', someBoolList: [true, false]}], |
|
requiredGroup: {id: undefined}, |
|
optionalGroup: undefined, |
|
requiredSimple: {aRepeatedStringList: [], aString: undefined}, |
|
optionalSimple: undefined, |
|
id: undefined |
|
}, |
|
group.toObject()); |
|
var group1 = new proto.jspb.test.TestGroup1(); |
|
group1.setGroup(someGroup); |
|
assertEquals(someGroup, group1.getGroup()); |
|
}); |
|
|
|
it('testNonExtensionFieldsAfterExtensionRange', function() { |
|
var data = [{'1': 'a_string'}]; |
|
var message = new proto.jspb.test.Complex(data); |
|
assertArrayEquals([], message.getARepeatedStringList()); |
|
}); |
|
|
|
it('testReservedGetterNames', function() { |
|
var message = new proto.jspb.test.TestReservedNames(); |
|
message.setExtension$(11); |
|
message.setExtension(proto.jspb.test.TestReservedNamesExtension.foo, 12); |
|
assertEquals(11, message.getExtension$()); |
|
assertEquals( |
|
12, |
|
message.getExtension(proto.jspb.test.TestReservedNamesExtension.foo)); |
|
assertObjectEquals({extension: 11, foo: 12}, message.toObject()); |
|
}); |
|
|
|
it('testInitializeMessageWithUnsetOneof', function() { |
|
var message = new proto.jspb.test.TestMessageWithOneof([]); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.PartialOneofCase |
|
.PARTIAL_ONEOF_NOT_SET, |
|
message.getPartialOneofCase()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.RecursiveOneofCase |
|
.RECURSIVE_ONEOF_NOT_SET, |
|
message.getRecursiveOneofCase()); |
|
}); |
|
|
|
it('testInitializeMessageWithSingleValueSetInOneof', function() { |
|
var message = new proto.jspb.test.TestMessageWithOneof([, , 'x']); |
|
|
|
assertEquals('x', message.getPone()); |
|
assertEquals('', message.getPthree()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.PartialOneofCase.PONE, |
|
message.getPartialOneofCase()); |
|
}); |
|
|
|
it('testKeepsLastWireValueSetInUnion_multipleValues', function() { |
|
var message = new proto.jspb.test.TestMessageWithOneof([, , 'x', , 'y']); |
|
|
|
assertEquals('', message.getPone()); |
|
assertEquals('y', message.getPthree()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.PartialOneofCase.PTHREE, |
|
message.getPartialOneofCase()); |
|
}); |
|
|
|
it('testSettingOneofFieldClearsOthers', function() { |
|
var message = new proto.jspb.test.TestMessageWithOneof; |
|
assertEquals('', message.getPone()); |
|
assertEquals('', message.getPthree()); |
|
assertFalse(message.hasPone()); |
|
assertFalse(message.hasPthree()); |
|
|
|
message.setPone('hi'); |
|
assertEquals('hi', message.getPone()); |
|
assertEquals('', message.getPthree()); |
|
assertTrue(message.hasPone()); |
|
assertFalse(message.hasPthree()); |
|
|
|
message.setPthree('bye'); |
|
assertEquals('', message.getPone()); |
|
assertEquals('bye', message.getPthree()); |
|
assertFalse(message.hasPone()); |
|
assertTrue(message.hasPthree()); |
|
}); |
|
|
|
it('testSettingOneofFieldDoesNotClearFieldsFromOtherUnions', function() { |
|
var other = new proto.jspb.test.TestMessageWithOneof; |
|
var message = new proto.jspb.test.TestMessageWithOneof; |
|
assertEquals('', message.getPone()); |
|
assertEquals('', message.getPthree()); |
|
assertUndefined(message.getRone()); |
|
assertFalse(message.hasPone()); |
|
assertFalse(message.hasPthree()); |
|
|
|
message.setPone('hi'); |
|
message.setRone(other); |
|
assertEquals('hi', message.getPone()); |
|
assertEquals('', message.getPthree()); |
|
assertEquals(other, message.getRone()); |
|
assertTrue(message.hasPone()); |
|
assertFalse(message.hasPthree()); |
|
|
|
message.setPthree('bye'); |
|
assertEquals('', message.getPone()); |
|
assertEquals('bye', message.getPthree()); |
|
assertEquals(other, message.getRone()); |
|
assertFalse(message.hasPone()); |
|
assertTrue(message.hasPthree()); |
|
}); |
|
|
|
it('testUnsetsOneofCaseWhenFieldIsCleared', function() { |
|
var message = new proto.jspb.test.TestMessageWithOneof; |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.PartialOneofCase |
|
.PARTIAL_ONEOF_NOT_SET, |
|
message.getPartialOneofCase()); |
|
|
|
message.setPone('hi'); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.PartialOneofCase.PONE, |
|
message.getPartialOneofCase()); |
|
|
|
message.clearPone(); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.PartialOneofCase |
|
.PARTIAL_ONEOF_NOT_SET, |
|
message.getPartialOneofCase()); |
|
}); |
|
|
|
it('testMessageWithDefaultOneofValues', function() { |
|
var message = new proto.jspb.test.TestMessageWithOneof; |
|
assertEquals(1234, message.getAone()); |
|
assertEquals(0, message.getAtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.DefaultOneofACase |
|
.DEFAULT_ONEOF_A_NOT_SET, |
|
message.getDefaultOneofACase()); |
|
|
|
message.setAone(567); |
|
assertEquals(567, message.getAone()); |
|
assertEquals(0, message.getAtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.DefaultOneofACase.AONE, |
|
message.getDefaultOneofACase()); |
|
|
|
message.setAtwo(890); |
|
assertEquals(1234, message.getAone()); |
|
assertEquals(890, message.getAtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.DefaultOneofACase.ATWO, |
|
message.getDefaultOneofACase()); |
|
|
|
message.clearAtwo(); |
|
assertEquals(1234, message.getAone()); |
|
assertEquals(0, message.getAtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.DefaultOneofACase |
|
.DEFAULT_ONEOF_A_NOT_SET, |
|
message.getDefaultOneofACase()); |
|
}); |
|
|
|
it('testMessageWithDefaultOneofValues_defaultNotOnFirstField', function() { |
|
var message = new proto.jspb.test.TestMessageWithOneof; |
|
assertEquals(0, message.getBone()); |
|
assertEquals(1234, message.getBtwo()); |
|
assertFalse(message.hasBone()); |
|
assertFalse(message.hasBtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.DefaultOneofBCase |
|
.DEFAULT_ONEOF_B_NOT_SET, |
|
message.getDefaultOneofBCase()); |
|
|
|
message.setBone(2); |
|
assertEquals(2, message.getBone()); |
|
assertEquals(1234, message.getBtwo()); |
|
assertTrue(message.hasBone()); |
|
assertFalse(message.hasBtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.DefaultOneofBCase.BONE, |
|
message.getDefaultOneofBCase()); |
|
|
|
message.setBtwo(3); |
|
assertEquals(0, message.getBone()); |
|
assertFalse(message.hasBone()); |
|
assertTrue(message.hasBtwo()); |
|
assertEquals(3, message.getBtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.DefaultOneofBCase.BTWO, |
|
message.getDefaultOneofBCase()); |
|
|
|
message.clearBtwo(); |
|
assertEquals(0, message.getBone()); |
|
assertFalse(message.hasBone()); |
|
assertFalse(message.hasBtwo()); |
|
assertEquals(1234, message.getBtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.DefaultOneofBCase |
|
.DEFAULT_ONEOF_B_NOT_SET, |
|
message.getDefaultOneofBCase()); |
|
}); |
|
|
|
it('testInitializeMessageWithOneofDefaults', function() { |
|
var message = |
|
new proto.jspb.test.TestMessageWithOneof(new Array(9).concat(567)); |
|
assertEquals(567, message.getAone()); |
|
assertEquals(0, message.getAtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.DefaultOneofACase.AONE, |
|
message.getDefaultOneofACase()); |
|
|
|
message = |
|
new proto.jspb.test.TestMessageWithOneof(new Array(10).concat(890)); |
|
assertEquals(1234, message.getAone()); |
|
assertEquals(890, message.getAtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.DefaultOneofACase.ATWO, |
|
message.getDefaultOneofACase()); |
|
|
|
message = |
|
new proto.jspb.test.TestMessageWithOneof(new Array(9).concat(567, 890)); |
|
assertEquals(1234, message.getAone()); |
|
assertEquals(890, message.getAtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.DefaultOneofACase.ATWO, |
|
message.getDefaultOneofACase()); |
|
}); |
|
|
|
it('testInitializeMessageWithOneofDefaults_defaultNotSetOnFirstField', |
|
function() { |
|
var message; |
|
|
|
message = |
|
new proto.jspb.test.TestMessageWithOneof(new Array(11).concat(567)); |
|
assertEquals(567, message.getBone()); |
|
assertEquals(1234, message.getBtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.DefaultOneofBCase.BONE, |
|
message.getDefaultOneofBCase()); |
|
|
|
message = |
|
new proto.jspb.test.TestMessageWithOneof(new Array(12).concat(890)); |
|
assertEquals(0, message.getBone()); |
|
assertEquals(890, message.getBtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.DefaultOneofBCase.BTWO, |
|
message.getDefaultOneofBCase()); |
|
|
|
message = new proto.jspb.test.TestMessageWithOneof( |
|
new Array(11).concat(567, 890)); |
|
assertEquals(0, message.getBone()); |
|
assertEquals(890, message.getBtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.DefaultOneofBCase.BTWO, |
|
message.getDefaultOneofBCase()); |
|
}); |
|
|
|
it('testOneofContainingAnotherMessage', function() { |
|
var message = new proto.jspb.test.TestMessageWithOneof; |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.RecursiveOneofCase |
|
.RECURSIVE_ONEOF_NOT_SET, |
|
message.getRecursiveOneofCase()); |
|
|
|
var other = new proto.jspb.test.TestMessageWithOneof; |
|
message.setRone(other); |
|
assertEquals(other, message.getRone()); |
|
assertEquals('', message.getRtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.RecursiveOneofCase.RONE, |
|
message.getRecursiveOneofCase()); |
|
|
|
message.setRtwo('hi'); |
|
assertUndefined(message.getRone()); |
|
assertEquals('hi', message.getRtwo()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.RecursiveOneofCase.RTWO, |
|
message.getRecursiveOneofCase()); |
|
}); |
|
|
|
it('testQueryingOneofCaseEnsuresOnlyOneFieldIsSetInUnderlyingArray', |
|
function() { |
|
var message = new proto.jspb.test.TestMessageWithOneof; |
|
message.setPone('x'); |
|
assertEquals('x', message.getPone()); |
|
assertEquals('', message.getPthree()); |
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.PartialOneofCase.PONE, |
|
message.getPartialOneofCase()); |
|
|
|
var array = message.toArray(); |
|
assertEquals('x', array[2]); |
|
assertUndefined(array[4]); |
|
array[4] = 'y'; |
|
|
|
assertEquals( |
|
proto.jspb.test.TestMessageWithOneof.PartialOneofCase.PTHREE, |
|
message.getPartialOneofCase()); |
|
assertUndefined(array[2]); |
|
assertEquals('y', array[4]); |
|
}); |
|
|
|
it('testFloatingPointFieldsSupportNan', function() { |
|
var assertNan = function(x) { |
|
assertTrue( |
|
'Expected ' + x + ' (' + goog.typeOf(x) + ') to be NaN.', |
|
typeof x === 'number' && isNaN(x)); |
|
}; |
|
|
|
var message = new proto.jspb.test.FloatingPointFields([ |
|
'NaN', 'NaN', ['NaN', 'NaN'], 'NaN', 'NaN', 'NaN', ['NaN', 'NaN'], 'NaN' |
|
]); |
|
assertNan(message.getOptionalFloatField()); |
|
assertNan(message.getRequiredFloatField()); |
|
assertNan(message.getRepeatedFloatFieldList()[0]); |
|
assertNan(message.getRepeatedFloatFieldList()[1]); |
|
assertNan(message.getDefaultFloatField()); |
|
assertNan(message.getOptionalDoubleField()); |
|
assertNan(message.getRequiredDoubleField()); |
|
assertNan(message.getRepeatedDoubleFieldList()[0]); |
|
assertNan(message.getRepeatedDoubleFieldList()[1]); |
|
assertNan(message.getDefaultDoubleField()); |
|
}); |
|
});
|
|
|