| // 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.testing.PropertyReplacer'); |
| goog.require('goog.testing.asserts'); |
| goog.require('goog.userAgent'); |
| |
| // CommonJS-LoadFromFile: google-protobuf jspb |
| goog.require('jspb.Message'); |
| |
| // CommonJS-LoadFromFile: test15_pb proto.jspb.filenametest.package1 |
| goog.require('proto.jspb.filenametest.package1.b'); |
| |
| // CommonJS-LoadFromFile: test14_pb proto.jspb.filenametest.package2 |
| goog.require('proto.jspb.filenametest.package2.TestMessage'); |
| |
| // CommonJS-LoadFromFile: test13_pb proto.jspb.filenametest.package1 |
| goog.require('proto.jspb.filenametest.package1.a'); |
| goog.require('proto.jspb.filenametest.package1.TestMessage'); |
| |
| // CommonJS-LoadFromFile: test12_pb proto.jspb.circulartest |
| goog.require('proto.jspb.circulartest.ExtensionContainingType1'); |
| goog.require('proto.jspb.circulartest.ExtensionContainingType2'); |
| goog.require('proto.jspb.circulartest.ExtensionField1'); |
| goog.require('proto.jspb.circulartest.ExtensionField2'); |
| goog.require('proto.jspb.circulartest.ExtensionField3'); |
| goog.require('proto.jspb.circulartest.MapField1'); |
| goog.require('proto.jspb.circulartest.MapField2'); |
| goog.require('proto.jspb.circulartest.MessageField1'); |
| goog.require('proto.jspb.circulartest.MessageField2'); |
| goog.require('proto.jspb.circulartest.NestedEnum1'); |
| goog.require('proto.jspb.circulartest.NestedEnum2'); |
| goog.require('proto.jspb.circulartest.NestedMessage1'); |
| goog.require('proto.jspb.circulartest.NestedMessage2'); |
| goog.require('proto.jspb.circulartest.RepeatedMessageField1'); |
| goog.require('proto.jspb.circulartest.RepeatedMessageField2'); |
| |
| // CommonJS-LoadFromFile: test11_pb proto.jspb.exttest.reverse |
| goog.require('proto.jspb.exttest.reverse.TestExtensionReverseOrderMessage1'); |
| goog.require('proto.jspb.exttest.reverse.TestExtensionReverseOrderMessage2'); |
| goog.require('proto.jspb.exttest.reverse.c'); |
| |
| // CommonJS-LoadFromFile: test8_pb proto.jspb.exttest.nested |
| goog.require('proto.jspb.exttest.nested.TestNestedExtensionsMessage'); |
| goog.require('proto.jspb.exttest.nested.TestOuterMessage'); |
| |
| // 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.BooleanFields'); |
| 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.TestCloneExtension'); |
| goog.require('proto.jspb.test.TestEndsWithBytes'); |
| goog.require('proto.jspb.test.TestGroup'); |
| goog.require('proto.jspb.test.TestGroup1'); |
| goog.require('proto.jspb.test.TestLastFieldBeforePivot'); |
| 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.TestAllowAliasEnum'); |
| // CommonJS-LoadFromFile: testlargenumbers_pb proto.jspb.test |
| goog.require('proto.jspb.test.MessageWithLargeFieldNumbers'); |
| |
| describe('Message test suite', function() { |
| var stubs = new goog.testing.PropertyReplacer(); |
| |
| beforeEach(function() { |
| stubs.set(jspb.Message, 'SERIALIZE_EMPTY_TRAILING_FIELDS', false); |
| }); |
| |
| afterEach(function() { |
| stubs.reset(); |
| }); |
| |
| 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'], , 1]; |
| var data2 = ['a', , , [, 11], [[, 22], [, 33]], , ['s1', 's2'], , 1]; |
| 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'], |
| aFloatingPointField: undefined, |
| }, |
| 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'], |
| aFloatingPointField: undefined, |
| $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: [], |
| aFloatingPointField: undefined, |
| }, |
| 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('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('testInitializeMessageWithLastFieldNull', function() { |
| // This tests for regression to bug http://b/117298778 |
| var msg = new proto.jspb.test.TestLastFieldBeforePivot([null]); |
| assertNotUndefined(msg.getLastFieldBeforePivot()); |
| }); |
| |
| it('testEqualsNonFinite', function() { |
| assertTrue(jspb.Message.compareFields(NaN, NaN)); |
| assertTrue(jspb.Message.compareFields(NaN, 'NaN')); |
| assertTrue(jspb.Message.compareFields('NaN', NaN)); |
| assertTrue(jspb.Message.compareFields(Infinity, Infinity)); |
| assertTrue(jspb.Message.compareFields(Infinity, 'Infinity')); |
| assertTrue(jspb.Message.compareFields('-Infinity', -Infinity)); |
| assertTrue(jspb.Message.compareFields([NaN], ['NaN'])); |
| assertFalse(jspb.Message.compareFields(undefined, NaN)); |
| assertFalse(jspb.Message.compareFields(NaN, undefined)); |
| }); |
| |
| 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('testNestedExtensions', function() { |
| var extendable = |
| new proto.jspb.exttest.nested.TestNestedExtensionsMessage(); |
| var extension = |
| new proto.jspb.exttest.nested.TestOuterMessage.NestedExtensionMessage( |
| ['s1']); |
| extendable.setExtension( |
| proto.jspb.exttest.nested.TestOuterMessage.innerExtension, extension); |
| assertObjectEquals( |
| extension, |
| extendable.getExtension( |
| proto.jspb.exttest.nested.TestOuterMessage.innerExtension)); |
| }); |
| |
| 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'], 102: ''}]); |
| var obj = data.toObject(); |
| assertEquals('str1', obj.str1); |
| assertEquals('ext1', obj.extField.ext1); |
| assertEquals('', obj.str); |
| }); |
| |
| 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('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('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()); |
| }); |
| |
| it('testFloatingPointsAreConvertedFromStringInput', function() { |
| var assertInf = function(x) { |
| assertTrue( |
| 'Expected ' + x + ' (' + goog.typeOf(x) + ') to be Infinity.', |
| x === Infinity); |
| }; |
| var message = new proto.jspb.test.FloatingPointFields([ |
| Infinity, 'Infinity', ['Infinity', Infinity], 'Infinity', 'Infinity', |
| 'Infinity', ['Infinity', Infinity], 'Infinity' |
| ]); |
| assertInf(message.getOptionalFloatField()); |
| assertInf(message.getRequiredFloatField()); |
| assertInf(message.getRepeatedFloatFieldList()[0]); |
| assertInf(message.getRepeatedFloatFieldList()[1]); |
| assertInf(message.getDefaultFloatField()); |
| assertInf(message.getOptionalDoubleField()); |
| assertInf(message.getRequiredDoubleField()); |
| assertInf(message.getRepeatedDoubleFieldList()[0]); |
| assertInf(message.getRepeatedDoubleFieldList()[1]); |
| assertInf(message.getDefaultDoubleField()); |
| }); |
| |
| it('testBooleansAreConvertedFromNumberInput', function() { |
| var assertBooleanFieldTrue = function(x) { |
| assertTrue( |
| 'Expected ' + x + ' (' + goog.typeOf(x) + ') to be True.', |
| x === true); |
| }; |
| var message = new proto.jspb.test.BooleanFields([1, 1, [true, 1]]); |
| assertBooleanFieldTrue(message.getOptionalBooleanField()); |
| assertBooleanFieldTrue(message.getRequiredBooleanField()); |
| assertBooleanFieldTrue(message.getRepeatedBooleanFieldList()[0]); |
| assertBooleanFieldTrue(message.getRepeatedBooleanFieldList()[1]); |
| assertBooleanFieldTrue(message.getDefaultBooleanField()); |
| |
| var assertBooleanFieldFalse = function(x) { |
| assertTrue( |
| 'Expected ' + x + ' (' + goog.typeOf(x) + ') to be False.', |
| x === false); |
| }; |
| message = new proto.jspb.test.BooleanFields([0, 0, [0, 0]]); |
| assertBooleanFieldFalse(message.getOptionalBooleanField()); |
| assertBooleanFieldFalse(message.getRequiredBooleanField()); |
| assertBooleanFieldFalse(message.getRepeatedBooleanFieldList()[0]); |
| assertBooleanFieldFalse(message.getRepeatedBooleanFieldList()[1]); |
| }); |
| |
| it('testExtensionReverseOrder', function() { |
| var message2 = |
| new proto.jspb.exttest.reverse.TestExtensionReverseOrderMessage2; |
| |
| message2.setExtension( |
| proto.jspb.exttest.reverse.TestExtensionReverseOrderMessage1.a, 233); |
| message2.setExtension( |
| proto.jspb.exttest.reverse.TestExtensionReverseOrderMessage1 |
| .TestExtensionReverseOrderNestedMessage1.b, |
| 2333); |
| message2.setExtension(proto.jspb.exttest.reverse.c, 23333); |
| |
| assertEquals( |
| 233, |
| message2.getExtension( |
| proto.jspb.exttest.reverse.TestExtensionReverseOrderMessage1.a)); |
| assertEquals( |
| 2333, |
| message2.getExtension( |
| proto.jspb.exttest.reverse.TestExtensionReverseOrderMessage1 |
| .TestExtensionReverseOrderNestedMessage1.b)); |
| assertEquals(23333, message2.getExtension(proto.jspb.exttest.reverse.c)); |
| }); |
| |
| it('testCircularDepsBaseOnMessageField', function() { |
| var nestMessage1 = new proto.jspb.circulartest.MessageField1; |
| var nestMessage2 = new proto.jspb.circulartest.MessageField2; |
| var message1 = new proto.jspb.circulartest.MessageField1; |
| var message2 = new proto.jspb.circulartest.MessageField2; |
| |
| nestMessage1.setA(1); |
| nestMessage2.setA(2); |
| message1.setB(nestMessage2); |
| message2.setB(nestMessage1); |
| |
| |
| assertEquals(2, message1.getB().getA()); |
| assertEquals(1, message2.getB().getA()); |
| }); |
| |
| |
| it('testCircularDepsBaseOnRepeatedMessageField', function() { |
| var nestMessage1 = new proto.jspb.circulartest.RepeatedMessageField1; |
| var nestMessage2 = new proto.jspb.circulartest.RepeatedMessageField2; |
| var message1 = new proto.jspb.circulartest.RepeatedMessageField1; |
| var message2 = new proto.jspb.circulartest.RepeatedMessageField2; |
| |
| nestMessage1.setA(1); |
| nestMessage2.setA(2); |
| message1.setB(nestMessage2); |
| message2.addB(nestMessage1); |
| |
| |
| assertEquals(2, message1.getB().getA()); |
| assertEquals(1, message2.getBList()[0].getA()); |
| }); |
| |
| it('testCircularDepsBaseOnMapField', function() { |
| var nestMessage1 = new proto.jspb.circulartest.MapField1; |
| var nestMessage2 = new proto.jspb.circulartest.MapField2; |
| var message1 = new proto.jspb.circulartest.MapField1; |
| var message2 = new proto.jspb.circulartest.MapField2; |
| |
| nestMessage1.setA(1); |
| nestMessage2.setA(2); |
| message1.setB(nestMessage2); |
| message2.getBMap().set(1, nestMessage1); |
| |
| |
| assertEquals(2, message1.getB().getA()); |
| assertEquals(1, message2.getBMap().get(1).getA()); |
| }); |
| |
| it('testCircularDepsBaseOnNestedMessage', function() { |
| var nestMessage1 = |
| new proto.jspb.circulartest.NestedMessage1.NestedNestedMessage; |
| var nestMessage2 = new proto.jspb.circulartest.NestedMessage2; |
| var message1 = new proto.jspb.circulartest.NestedMessage1; |
| var message2 = new proto.jspb.circulartest.NestedMessage2; |
| |
| nestMessage1.setA(1); |
| nestMessage2.setA(2); |
| message1.setB(nestMessage2); |
| message2.setB(nestMessage1); |
| |
| |
| assertEquals(2, message1.getB().getA()); |
| assertEquals(1, message2.getB().getA()); |
| }); |
| |
| it('testCircularDepsBaseOnNestedEnum', function() { |
| var nestMessage2 = new proto.jspb.circulartest.NestedEnum2; |
| var message1 = new proto.jspb.circulartest.NestedEnum1; |
| var message2 = new proto.jspb.circulartest.NestedEnum2; |
| |
| nestMessage2.setA(2); |
| message1.setB(nestMessage2); |
| message2.setB(proto.jspb.circulartest.NestedEnum1.NestedNestedEnum.VALUE_1); |
| |
| |
| assertEquals(2, message1.getB().getA()); |
| assertEquals( |
| proto.jspb.circulartest.NestedEnum1.NestedNestedEnum.VALUE_1, |
| message2.getB()); |
| }); |
| |
| it('testCircularDepsBaseOnExtensionContainingType', function() { |
| var nestMessage2 = new proto.jspb.circulartest.ExtensionContainingType2; |
| var message1 = new proto.jspb.circulartest.ExtensionContainingType1; |
| |
| nestMessage2.setA(2); |
| message1.setB(nestMessage2); |
| message1.setExtension( |
| proto.jspb.circulartest.ExtensionContainingType2.c, 1); |
| |
| |
| assertEquals(2, message1.getB().getA()); |
| assertEquals( |
| 1, |
| message1.getExtension( |
| proto.jspb.circulartest.ExtensionContainingType2.c)); |
| }); |
| |
| it('testCircularDepsBaseOnExtensionField', function() { |
| var nestMessage2 = new proto.jspb.circulartest.ExtensionField2; |
| var message1 = new proto.jspb.circulartest.ExtensionField1; |
| var message3 = new proto.jspb.circulartest.ExtensionField3; |
| |
| nestMessage2.setA(2); |
| message1.setB(nestMessage2); |
| message3.setExtension(proto.jspb.circulartest.ExtensionField2.c, message1); |
| |
| |
| assertEquals( |
| 2, |
| message3.getExtension(proto.jspb.circulartest.ExtensionField2.c) |
| .getB() |
| .getA()); |
| }); |
| |
| it('testSameMessageNameOuputs', function() { |
| var package1Message = new proto.jspb.filenametest.package1.TestMessage; |
| var package2Message = new proto.jspb.filenametest.package2.TestMessage; |
| |
| package1Message.setExtension(proto.jspb.filenametest.package1.a, 10); |
| package1Message.setExtension(proto.jspb.filenametest.package1.b, 11); |
| package2Message.setA(12); |
| |
| assertEquals( |
| 10, package1Message.getExtension(proto.jspb.filenametest.package1.a)); |
| assertEquals( |
| 11, package1Message.getExtension(proto.jspb.filenametest.package1.b)); |
| assertEquals(12, package2Message.getA()); |
| }); |
| |
| |
| it('testMessageWithLargeFieldNumbers', function() { |
| var message = new proto.jspb.test.MessageWithLargeFieldNumbers; |
| |
| message.setAString('string'); |
| assertEquals('string', message.getAString()); |
| |
| message.setAString(''); |
| assertEquals('', message.getAString()); |
| |
| message.setAString('new string'); |
| assertEquals('new string', message.getAString()); |
| |
| message.setABoolean(true); |
| assertEquals(true, message.getABoolean()); |
| |
| message.setABoolean(false); |
| assertEquals(false, message.getABoolean()); |
| |
| message.setABoolean(true); |
| assertEquals(true, message.getABoolean()); |
| |
| message.setAInt(42); |
| assertEquals(42, message.getAInt()); |
| |
| message.setAInt(0); |
| assertEquals(0, message.getAInt()); |
| |
| message.setAInt(42); |
| assertEquals(42, message.getAInt()); |
| }); |
| |
| }); |
