parent
7e5f980508
commit
10ea25133d
31 changed files with 5878 additions and 46 deletions
@ -0,0 +1,355 @@ |
||||
// 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.
|
||||
|
||||
/** |
||||
* @fileoverview Test cases for Int64-manipulation functions. |
||||
* |
||||
* Test suite is written using Jasmine -- see http://jasmine.github.io/
|
||||
* |
||||
* @author cfallin@google.com (Chris Fallin) |
||||
*/ |
||||
|
||||
goog.require('goog.testing.asserts'); |
||||
goog.require('jspb.arith.Int64'); |
||||
goog.require('jspb.arith.UInt64'); |
||||
|
||||
|
||||
describe('binaryArithTest', function() { |
||||
/** |
||||
* Tests comparison operations. |
||||
*/ |
||||
it('testCompare', function() { |
||||
var a = new jspb.arith.UInt64(1234, 5678); |
||||
var b = new jspb.arith.UInt64(1234, 5678); |
||||
assertEquals(a.cmp(b), 0); |
||||
assertEquals(b.cmp(a), 0); |
||||
b.lo -= 1; |
||||
assertEquals(a.cmp(b), 1); |
||||
assertEquals(b.cmp(a), -1); |
||||
b.lo += 2; |
||||
assertEquals(a.cmp(b), -1); |
||||
assertEquals(b.cmp(a), 1); |
||||
b.lo = a.lo; |
||||
b.hi = a.hi - 1; |
||||
assertEquals(a.cmp(b), 1); |
||||
assertEquals(b.cmp(a), -1); |
||||
|
||||
assertEquals(a.zero(), false); |
||||
assertEquals(a.msb(), false); |
||||
assertEquals(a.lsb(), false); |
||||
a.hi = 0; |
||||
a.lo = 0; |
||||
assertEquals(a.zero(), true); |
||||
a.hi = 0x80000000; |
||||
assertEquals(a.zero(), false); |
||||
assertEquals(a.msb(), true); |
||||
a.lo = 0x00000001; |
||||
assertEquals(a.lsb(), true); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests shifts. |
||||
*/ |
||||
it('testShifts', function() { |
||||
var a = new jspb.arith.UInt64(1, 0); |
||||
assertEquals(a.lo, 1); |
||||
assertEquals(a.hi, 0); |
||||
var orig = a; |
||||
a = a.leftShift(); |
||||
assertEquals(orig.lo, 1); // original unmodified.
|
||||
assertEquals(orig.hi, 0); |
||||
assertEquals(a.lo, 2); |
||||
assertEquals(a.hi, 0); |
||||
a = a.leftShift(); |
||||
assertEquals(a.lo, 4); |
||||
assertEquals(a.hi, 0); |
||||
for (var i = 0; i < 29; i++) { |
||||
a = a.leftShift(); |
||||
} |
||||
assertEquals(a.lo, 0x80000000); |
||||
assertEquals(a.hi, 0); |
||||
a = a.leftShift(); |
||||
assertEquals(a.lo, 0); |
||||
assertEquals(a.hi, 1); |
||||
a = a.leftShift(); |
||||
assertEquals(a.lo, 0); |
||||
assertEquals(a.hi, 2); |
||||
a = a.rightShift(); |
||||
a = a.rightShift(); |
||||
assertEquals(a.lo, 0x80000000); |
||||
assertEquals(a.hi, 0); |
||||
a = a.rightShift(); |
||||
assertEquals(a.lo, 0x40000000); |
||||
assertEquals(a.hi, 0); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests additions. |
||||
*/ |
||||
it('testAdd', function() { |
||||
var a = new jspb.arith.UInt64(/* lo = */ 0x89abcdef, |
||||
/* hi = */ 0x01234567); |
||||
var b = new jspb.arith.UInt64(/* lo = */ 0xff52ab91, |
||||
/* hi = */ 0x92fa2123); |
||||
// Addition with carry.
|
||||
var c = a.add(b); |
||||
assertEquals(a.lo, 0x89abcdef); // originals unmodified.
|
||||
assertEquals(a.hi, 0x01234567); |
||||
assertEquals(b.lo, 0xff52ab91); |
||||
assertEquals(b.hi, 0x92fa2123); |
||||
assertEquals(c.lo, 0x88fe7980); |
||||
assertEquals(c.hi, 0x941d668b); |
||||
|
||||
// Simple addition without carry.
|
||||
a.lo = 2; |
||||
a.hi = 0; |
||||
b.lo = 3; |
||||
b.hi = 0; |
||||
c = a.add(b); |
||||
assertEquals(c.lo, 5); |
||||
assertEquals(c.hi, 0); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Test subtractions. |
||||
*/ |
||||
it('testSub', function() { |
||||
var kLength = 10; |
||||
var hiValues = [0x1682ef32, |
||||
0x583902f7, |
||||
0xb62f5955, |
||||
0x6ea99bbf, |
||||
0x25a39c20, |
||||
0x0700a08b, |
||||
0x00f7304d, |
||||
0x91a5b5af, |
||||
0x89077fd2, |
||||
0xe09e347c]; |
||||
var loValues = [0xe1538b18, |
||||
0xbeacd556, |
||||
0x74100758, |
||||
0x96e3cb26, |
||||
0x56c37c3f, |
||||
0xe00b3f7d, |
||||
0x859f25d7, |
||||
0xc2ee614a, |
||||
0xe1d21cd7, |
||||
0x30aae6a4]; |
||||
for (var i = 0; i < kLength; i++) { |
||||
for (var j = 0; j < kLength; j++) { |
||||
var a = new jspb.arith.UInt64(loValues[i], hiValues[j]); |
||||
var b = new jspb.arith.UInt64(loValues[j], hiValues[i]); |
||||
var c = a.add(b).sub(b); |
||||
assertEquals(c.hi, a.hi); |
||||
assertEquals(c.lo, a.lo); |
||||
} |
||||
} |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests 32-by-32 multiplication. |
||||
*/ |
||||
it('testMul32x32', function() { |
||||
var testData = [ |
||||
// a b low(a*b) high(a*b)
|
||||
[0xc0abe2f8, 0x1607898a, 0x5de711b0, 0x109471b8], |
||||
[0x915eb3cb, 0x4fb66d0e, 0xbd0d441a, 0x2d43d0bc], |
||||
[0xfe4efe70, 0x80b48c37, 0xbcddea10, 0x7fdada0c], |
||||
[0xe222fd4a, 0xe43d524a, 0xd5e0eb64, 0xc99d549c], |
||||
[0xd171f469, 0xb94ebd01, 0x4be17969, 0x979bc4fa], |
||||
[0x829cc1df, 0xe2598b38, 0xf4157dc8, 0x737c12ad], |
||||
[0xf10c3767, 0x8382881e, 0x942b3612, 0x7bd428b8], |
||||
[0xb0f6dd24, 0x232597e1, 0x079c98a4, 0x184bbce7], |
||||
[0xfcdb05a7, 0x902f55bc, 0x636199a4, 0x8e69f412], |
||||
[0x0dd0bfa9, 0x916e27b1, 0x6e2542d9, 0x07d92e65] |
||||
]; |
||||
|
||||
for (var i = 0; i < testData.length; i++) { |
||||
var a = testData[i][0] >>> 0; |
||||
var b = testData[i][1] >>> 0; |
||||
var cLow = testData[i][2] >>> 0; |
||||
var cHigh = testData[i][3] >>> 0; |
||||
var c = jspb.arith.UInt64.mul32x32(a, b); |
||||
assertEquals(c.lo, cLow); |
||||
assertEquals(c.hi, cHigh); |
||||
} |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests 64-by-32 multiplication. |
||||
*/ |
||||
it('testMul', function() { |
||||
// 64x32 bits produces 96 bits of product. The multiplication function under
|
||||
// test truncates the top 32 bits, so we compare against a 64-bit expected
|
||||
// product.
|
||||
var testData = [ |
||||
// low(a) high(a) low(a*b) high(a*b)
|
||||
[0xec10955b, 0x360eb168, 0x4b7f3f5b, 0xbfcb7c59, 0x9517da5f], |
||||
[0x42b000fc, 0x9d101642, 0x6fa1ab72, 0x2584c438, 0x6a9e6d2b], |
||||
[0xf42d4fb4, 0xae366403, 0xa65a1000, 0x92434000, 0x1ff978df], |
||||
[0x17e2f56b, 0x25487693, 0xf13f98c7, 0x73794e2d, 0xa96b0c6a], |
||||
[0x492f241f, 0x76c0eb67, 0x7377ac44, 0xd4336c3c, 0xfc4b1ebe], |
||||
[0xd6b92321, 0xe184fa48, 0xd6e76904, 0x93141584, 0xcbf44da1], |
||||
[0x4bf007ea, 0x968c0a9e, 0xf5e4026a, 0x4fdb1ae4, 0x61b9fb7d], |
||||
[0x10a83be7, 0x2d685ba6, 0xc9e5fb7f, 0x2ad43499, 0x3742473d], |
||||
[0x2f261829, 0x1aca681a, 0x3d3494e3, 0x8213205b, 0x283719f8], |
||||
[0xe4f2ce21, 0x2e74b7bd, 0xd801b38b, 0xbc17feeb, 0xc6c44e0f] |
||||
]; |
||||
|
||||
for (var i = 0; i < testData.length; i++) { |
||||
var a = new jspb.arith.UInt64(testData[i][0], testData[i][1]); |
||||
var prod = a.mul(testData[i][2]); |
||||
assertEquals(prod.lo, testData[i][3]); |
||||
assertEquals(prod.hi, testData[i][4]); |
||||
} |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests 64-div-by-32 division. |
||||
*/ |
||||
it('testDiv', function() { |
||||
// Compute a/b, yielding quot = a/b and rem = a%b.
|
||||
var testData = [ |
||||
// --- divisors in (0, 2^32-1) to test full divisor range
|
||||
// low(a) high(a) b low(quot) high(quot) rem
|
||||
[0x712443f1, 0xe85cefcc, 0xc1a7050b, 0x332c79ad, 0x00000001, 0x92ffa882], |
||||
[0x11912915, 0xb2699eb5, 0x30467cbe, 0xb21b4be4, 0x00000003, 0x283465dd], |
||||
[0x0d917982, 0x201f2a6e, 0x3f35bf03, 0x8217c8e4, 0x00000000, 0x153402d6], |
||||
[0xa072c108, 0x74020c96, 0xc60568fd, 0x95f9613e, 0x00000000, 0x3f4676c2], |
||||
[0xd845d5d8, 0xcdd235c4, 0x20426475, 0x6154e78b, 0x00000006, 0x202fb751], |
||||
[0xa4dbf71f, 0x9e90465e, 0xf08e022f, 0xa8be947f, 0x00000000, 0xbe43b5ce], |
||||
[0x3dbe627f, 0xa791f4b9, 0x28a5bd89, 0x1f5dfe93, 0x00000004, 0x02bf9ed4], |
||||
[0x5c1c53ee, 0xccf5102e, 0x198576e7, 0x07e3ae31, 0x00000008, 0x02ea8fb7], |
||||
[0xfef1e581, 0x04714067, 0xca6540c1, 0x059e73ec, 0x00000000, 0x31658095], |
||||
[0x1e2dd90c, 0x13dd6667, 0x8b2184c3, 0x248d1a42, 0x00000000, 0x4ca6d0c6], |
||||
// --- divisors in (0, 2^16-1) to test larger quotient high-words
|
||||
// low(a) high(a) b low(quot) high(quot) rem
|
||||
[0x86722b47, 0x2cd57c9a, 0x00003123, 0x2ae41b7a, 0x0000e995, 0x00000f99], |
||||
[0x1dd7884c, 0xf5e839bc, 0x00009eeb, 0x5c886242, 0x00018c21, 0x000099b6], |
||||
[0x5c53d625, 0x899fc7e5, 0x000087d7, 0xd625007a, 0x0001035c, 0x000019af], |
||||
[0x6932d932, 0x9d0a5488, 0x000051fb, 0x9d976143, 0x0001ea63, 0x00004981], |
||||
[0x4d18bb85, 0x0c92fb31, 0x00001d9f, 0x03265ab4, 0x00006cac, 0x000001b9], |
||||
[0xbe756768, 0xdea67ccb, 0x00008a03, 0x58add442, 0x00019cff, 0x000056a2], |
||||
[0xe2466f9a, 0x2521f114, 0x0000c350, 0xa0c0860d, 0x000030ab, 0x0000a48a], |
||||
[0xf00ddad1, 0xe2f5446a, 0x00002cfc, 0x762697a6, 0x00050b96, 0x00000b69], |
||||
[0xa879152a, 0x0a70e0a5, 0x00007cdf, 0xb44151b3, 0x00001567, 0x0000363d], |
||||
[0x7179a74c, 0x46083fff, 0x0000253c, 0x4d39ba6e, 0x0001e17f, 0x00000f84] |
||||
]; |
||||
|
||||
for (var i = 0; i < testData.length; i++) { |
||||
var a = new jspb.arith.UInt64(testData[i][0], testData[i][1]); |
||||
var result = a.div(testData[i][2]); |
||||
var quotient = result[0]; |
||||
var remainder = result[1]; |
||||
assertEquals(quotient.lo, testData[i][3]); |
||||
assertEquals(quotient.hi, testData[i][4]); |
||||
assertEquals(remainder.lo, testData[i][5]); |
||||
} |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests .toString() and .fromString(). |
||||
*/ |
||||
it('testStrings', function() { |
||||
var testData = [ |
||||
[0x5e84c935, 0xcae33d0e, '14619595947299359029'], |
||||
[0x62b3b8b8, 0x93480544, '10612738313170434232'], |
||||
[0x319bfb13, 0xc01c4172, '13843011313344445203'], |
||||
[0x5b8a65fb, 0xa5885b31, '11927883880638080507'], |
||||
[0x6bdb80f1, 0xb0d1b16b, '12741159895737008369'], |
||||
[0x4b82b442, 0x2e0d8c97, '3318463081876730946'], |
||||
[0x780d5208, 0x7d76752c, '9040542135845999112'], |
||||
[0x2e46800f, 0x0993778d, '690026616168284175'], |
||||
[0xf00a7e32, 0xcd8e3931, '14811839111111540274'], |
||||
[0x1baeccd6, 0x923048c4, '10533999535534820566'], |
||||
[0x03669d29, 0xbff3ab72, '13831587386756603177'], |
||||
[0x2526073e, 0x01affc81, '121593346566522686'], |
||||
[0xc24244e0, 0xd7f40d0e, '15561076969511732448'], |
||||
[0xc56a341e, 0xa68b66a7, '12000798502816461854'], |
||||
[0x8738d64d, 0xbfe78604, '13828168534871037517'], |
||||
[0x5baff03b, 0xd7572aea, '15516918227177304123'], |
||||
[0x4a843d8a, 0x864e132b, '9677693725920476554'], |
||||
[0x25b4e94d, 0x22b54dc6, '2500990681505655117'], |
||||
[0x6bbe664b, 0x55a5cc0e, '6171563226690381387'], |
||||
[0xee916c81, 0xb00aabb3, '12685140089732426881'] |
||||
]; |
||||
|
||||
for (var i = 0; i < testData.length; i++) { |
||||
var a = new jspb.arith.UInt64(testData[i][0], testData[i][1]); |
||||
var roundtrip = jspb.arith.UInt64.fromString(a.toString()); |
||||
assertEquals(roundtrip.lo, a.lo); |
||||
assertEquals(roundtrip.hi, a.hi); |
||||
assertEquals(a.toString(), testData[i][2]); |
||||
} |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests signed Int64s. These are built on UInt64s, so we only need to test |
||||
* the explicit overrides: .toString() and .fromString(). |
||||
*/ |
||||
it('testSignedInt64', function() { |
||||
var testStrings = [ |
||||
'-7847499644178593666', |
||||
'3771946501229139523', |
||||
'2872856549054995060', |
||||
'-5780049594274350904', |
||||
'3383785956695105201', |
||||
'2973055184857072610', |
||||
'-3879428459215627206', |
||||
'4589812431064156631', |
||||
'8484075557333689940', |
||||
'1075325817098092407', |
||||
'-4346697501012292314', |
||||
'2488620459718316637', |
||||
'6112655187423520672', |
||||
'-3655278273928612104', |
||||
'3439154019435803196', |
||||
'1004112478843763757', |
||||
'-6587790776614368413', |
||||
'664320065099714586', |
||||
'4760412909973292912', |
||||
'-7911903989602274672' |
||||
]; |
||||
|
||||
for (var i = 0; i < testStrings.length; i++) { |
||||
var roundtrip = |
||||
jspb.arith.Int64.fromString(testStrings[i]).toString(); |
||||
assertEquals(roundtrip, testStrings[i]); |
||||
} |
||||
}); |
||||
}); |
@ -0,0 +1,334 @@ |
||||
// 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.
|
||||
|
||||
/** |
||||
* @fileoverview Test cases for jspb's binary protocol buffer decoder. |
||||
* |
||||
* There are two particular magic numbers that need to be pointed out - |
||||
* 2^64-1025 is the largest number representable as both a double and an |
||||
* unsigned 64-bit integer, and 2^63-513 is the largest number representable as |
||||
* both a double and a signed 64-bit integer. |
||||
* |
||||
* Test suite is written using Jasmine -- see http://jasmine.github.io/
|
||||
* |
||||
* @author aappleby@google.com (Austin Appleby) |
||||
*/ |
||||
|
||||
goog.require('goog.testing.asserts'); |
||||
goog.require('jspb.BinaryConstants'); |
||||
goog.require('jspb.BinaryDecoder'); |
||||
goog.require('jspb.BinaryEncoder'); |
||||
|
||||
|
||||
/** |
||||
* Tests encoding and decoding of unsigned types. |
||||
* @param {Function} readValue |
||||
* @param {Function} writeValue |
||||
* @param {number} epsilon |
||||
* @param {number} upperLimit |
||||
* @param {Function} filter |
||||
* @suppress {missingProperties|visibility} |
||||
*/ |
||||
function doTestUnsignedValue(readValue, |
||||
writeValue, epsilon, upperLimit, filter) { |
||||
var encoder = new jspb.BinaryEncoder(); |
||||
|
||||
// Encode zero and limits.
|
||||
writeValue.call(encoder, filter(0)); |
||||
writeValue.call(encoder, filter(epsilon)); |
||||
writeValue.call(encoder, filter(upperLimit)); |
||||
|
||||
// Encode positive values.
|
||||
for (var cursor = epsilon; cursor < upperLimit; cursor *= 1.1) { |
||||
writeValue.call(encoder, filter(cursor)); |
||||
} |
||||
|
||||
var decoder = jspb.BinaryDecoder.alloc(encoder.end()); |
||||
|
||||
// Check zero and limits.
|
||||
assertEquals(filter(0), readValue.call(decoder)); |
||||
assertEquals(filter(epsilon), readValue.call(decoder)); |
||||
assertEquals(filter(upperLimit), readValue.call(decoder)); |
||||
|
||||
// Check positive values.
|
||||
for (var cursor = epsilon; cursor < upperLimit; cursor *= 1.1) { |
||||
if (filter(cursor) != readValue.call(decoder)) throw 'fail!'; |
||||
} |
||||
|
||||
// Encoding values outside the valid range should assert.
|
||||
assertThrows(function() {writeValue.call(encoder, -1);}); |
||||
assertThrows(function() {writeValue.call(encoder, upperLimit * 1.1);}); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Tests encoding and decoding of signed types. |
||||
* @param {Function} readValue |
||||
* @param {Function} writeValue |
||||
* @param {number} epsilon |
||||
* @param {number} lowerLimit |
||||
* @param {number} upperLimit |
||||
* @param {Function} filter |
||||
* @suppress {missingProperties} |
||||
*/ |
||||
function doTestSignedValue(readValue, |
||||
writeValue, epsilon, lowerLimit, upperLimit, filter) { |
||||
var encoder = new jspb.BinaryEncoder(); |
||||
|
||||
// Encode zero and limits.
|
||||
writeValue.call(encoder, filter(lowerLimit)); |
||||
writeValue.call(encoder, filter(-epsilon)); |
||||
writeValue.call(encoder, filter(0)); |
||||
writeValue.call(encoder, filter(epsilon)); |
||||
writeValue.call(encoder, filter(upperLimit)); |
||||
|
||||
var inputValues = []; |
||||
|
||||
// Encode negative values.
|
||||
for (var cursor = lowerLimit; cursor < -epsilon; cursor /= 1.1) { |
||||
var val = filter(cursor); |
||||
writeValue.call(encoder, val); |
||||
inputValues.push(val); |
||||
} |
||||
|
||||
// Encode positive values.
|
||||
for (var cursor = epsilon; cursor < upperLimit; cursor *= 1.1) { |
||||
var val = filter(cursor); |
||||
writeValue.call(encoder, val); |
||||
inputValues.push(val); |
||||
} |
||||
|
||||
var decoder = jspb.BinaryDecoder.alloc(encoder.end()); |
||||
|
||||
// Check zero and limits.
|
||||
assertEquals(filter(lowerLimit), readValue.call(decoder)); |
||||
assertEquals(filter(-epsilon), readValue.call(decoder)); |
||||
assertEquals(filter(0), readValue.call(decoder)); |
||||
assertEquals(filter(epsilon), readValue.call(decoder)); |
||||
assertEquals(filter(upperLimit), readValue.call(decoder)); |
||||
|
||||
// Verify decoded values.
|
||||
for (var i = 0; i < inputValues.length; i++) { |
||||
assertEquals(inputValues[i], readValue.call(decoder)); |
||||
} |
||||
|
||||
// Encoding values outside the valid range should assert.
|
||||
assertThrows(function() {writeValue.call(encoder, lowerLimit * 1.1);}); |
||||
assertThrows(function() {writeValue.call(encoder, upperLimit * 1.1);}); |
||||
} |
||||
|
||||
describe('binaryDecoderTest', function() { |
||||
/** |
||||
* Tests the decoder instance cache. |
||||
*/ |
||||
it('testInstanceCache', /** @suppress {visibility} */ function() { |
||||
// Empty the instance caches.
|
||||
jspb.BinaryDecoder.instanceCache_ = []; |
||||
|
||||
// Allocating and then freeing a decoder should put it in the instance
|
||||
// cache.
|
||||
jspb.BinaryDecoder.alloc().free(); |
||||
|
||||
assertEquals(1, jspb.BinaryDecoder.instanceCache_.length); |
||||
|
||||
// Allocating and then freeing three decoders should leave us with three in
|
||||
// the cache.
|
||||
|
||||
var decoder1 = jspb.BinaryDecoder.alloc(); |
||||
var decoder2 = jspb.BinaryDecoder.alloc(); |
||||
var decoder3 = jspb.BinaryDecoder.alloc(); |
||||
decoder1.free(); |
||||
decoder2.free(); |
||||
decoder3.free(); |
||||
|
||||
assertEquals(3, jspb.BinaryDecoder.instanceCache_.length); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests reading 64-bit integers as hash strings. |
||||
*/ |
||||
it('testHashStrings', function() { |
||||
var encoder = new jspb.BinaryEncoder(); |
||||
|
||||
var hashA = String.fromCharCode(0x00, 0x00, 0x00, 0x00, |
||||
0x00, 0x00, 0x00, 0x00); |
||||
var hashB = String.fromCharCode(0x12, 0x34, 0x00, 0x00, |
||||
0x00, 0x00, 0x00, 0x00); |
||||
var hashC = String.fromCharCode(0x12, 0x34, 0x56, 0x78, |
||||
0x87, 0x65, 0x43, 0x21); |
||||
var hashD = String.fromCharCode(0xFF, 0xFF, 0xFF, 0xFF, |
||||
0xFF, 0xFF, 0xFF, 0xFF); |
||||
|
||||
encoder.writeVarintHash64(hashA); |
||||
encoder.writeVarintHash64(hashB); |
||||
encoder.writeVarintHash64(hashC); |
||||
encoder.writeVarintHash64(hashD); |
||||
|
||||
encoder.writeFixedHash64(hashA); |
||||
encoder.writeFixedHash64(hashB); |
||||
encoder.writeFixedHash64(hashC); |
||||
encoder.writeFixedHash64(hashD); |
||||
|
||||
var decoder = jspb.BinaryDecoder.alloc(encoder.end()); |
||||
|
||||
assertEquals(hashA, decoder.readVarintHash64()); |
||||
assertEquals(hashB, decoder.readVarintHash64()); |
||||
assertEquals(hashC, decoder.readVarintHash64()); |
||||
assertEquals(hashD, decoder.readVarintHash64()); |
||||
|
||||
assertEquals(hashA, decoder.readFixedHash64()); |
||||
assertEquals(hashB, decoder.readFixedHash64()); |
||||
assertEquals(hashC, decoder.readFixedHash64()); |
||||
assertEquals(hashD, decoder.readFixedHash64()); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Verifies that misuse of the decoder class triggers assertions. |
||||
* @suppress {checkTypes|visibility} |
||||
*/ |
||||
it('testDecodeErrors', function() { |
||||
// Reading a value past the end of the stream should trigger an assertion.
|
||||
var decoder = jspb.BinaryDecoder.alloc([0, 1, 2]); |
||||
assertThrows(function() {decoder.readUint64()}); |
||||
|
||||
// Overlong varints should trigger assertions.
|
||||
decoder.setBlock([255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 0]); |
||||
assertThrows(function() {decoder.readUnsignedVarint64()}); |
||||
decoder.reset(); |
||||
assertThrows(function() {decoder.readSignedVarint64()}); |
||||
decoder.reset(); |
||||
assertThrows(function() {decoder.readZigzagVarint64()}); |
||||
|
||||
// Positive 32-bit varints encoded with 1 bits in positions 33 through 35
|
||||
// should trigger assertions.
|
||||
decoder.setBlock([255, 255, 255, 255, 0x1F]); |
||||
assertThrows(function() {decoder.readUnsignedVarint32()}); |
||||
|
||||
decoder.setBlock([255, 255, 255, 255, 0x2F]); |
||||
assertThrows(function() {decoder.readUnsignedVarint32()}); |
||||
|
||||
decoder.setBlock([255, 255, 255, 255, 0x4F]); |
||||
assertThrows(function() {decoder.readUnsignedVarint32()}); |
||||
|
||||
// Negative 32-bit varints encoded with non-1 bits in the high dword should
|
||||
// trigger assertions.
|
||||
decoder.setBlock([255, 255, 255, 255, 255, 255, 0, 255, 255, 1]); |
||||
assertThrows(function() {decoder.readUnsignedVarint32()}); |
||||
|
||||
decoder.setBlock([255, 255, 255, 255, 255, 255, 255, 255, 255, 0]); |
||||
assertThrows(function() {decoder.readUnsignedVarint32()}); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests encoding and decoding of unsigned integers. |
||||
*/ |
||||
it('testUnsignedIntegers', function() { |
||||
doTestUnsignedValue( |
||||
jspb.BinaryDecoder.prototype.readUint8, |
||||
jspb.BinaryEncoder.prototype.writeUint8, |
||||
1, 0xFF, Math.round); |
||||
|
||||
doTestUnsignedValue( |
||||
jspb.BinaryDecoder.prototype.readUint16, |
||||
jspb.BinaryEncoder.prototype.writeUint16, |
||||
1, 0xFFFF, Math.round); |
||||
|
||||
doTestUnsignedValue( |
||||
jspb.BinaryDecoder.prototype.readUint32, |
||||
jspb.BinaryEncoder.prototype.writeUint32, |
||||
1, 0xFFFFFFFF, Math.round); |
||||
|
||||
doTestUnsignedValue( |
||||
jspb.BinaryDecoder.prototype.readUint64, |
||||
jspb.BinaryEncoder.prototype.writeUint64, |
||||
1, Math.pow(2, 64) - 1025, Math.round); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests encoding and decoding of signed integers. |
||||
*/ |
||||
it('testSignedIntegers', function() { |
||||
doTestSignedValue( |
||||
jspb.BinaryDecoder.prototype.readInt8, |
||||
jspb.BinaryEncoder.prototype.writeInt8, |
||||
1, -0x80, 0x7F, Math.round); |
||||
|
||||
doTestSignedValue( |
||||
jspb.BinaryDecoder.prototype.readInt16, |
||||
jspb.BinaryEncoder.prototype.writeInt16, |
||||
1, -0x8000, 0x7FFF, Math.round); |
||||
|
||||
doTestSignedValue( |
||||
jspb.BinaryDecoder.prototype.readInt32, |
||||
jspb.BinaryEncoder.prototype.writeInt32, |
||||
1, -0x80000000, 0x7FFFFFFF, Math.round); |
||||
|
||||
doTestSignedValue( |
||||
jspb.BinaryDecoder.prototype.readInt64, |
||||
jspb.BinaryEncoder.prototype.writeInt64, |
||||
1, -Math.pow(2, 63), Math.pow(2, 63) - 513, Math.round); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests encoding and decoding of floats. |
||||
*/ |
||||
it('testFloats', function() { |
||||
/** |
||||
* @param {number} x |
||||
* @return {number} |
||||
*/ |
||||
function truncate(x) { |
||||
var temp = new Float32Array(1); |
||||
temp[0] = x; |
||||
return temp[0]; |
||||
} |
||||
doTestSignedValue( |
||||
jspb.BinaryDecoder.prototype.readFloat, |
||||
jspb.BinaryEncoder.prototype.writeFloat, |
||||
jspb.BinaryConstants.FLOAT32_EPS, |
||||
-jspb.BinaryConstants.FLOAT32_MAX, |
||||
jspb.BinaryConstants.FLOAT32_MAX, |
||||
truncate); |
||||
|
||||
doTestSignedValue( |
||||
jspb.BinaryDecoder.prototype.readDouble, |
||||
jspb.BinaryEncoder.prototype.writeDouble, |
||||
jspb.BinaryConstants.FLOAT64_EPS * 10, |
||||
-jspb.BinaryConstants.FLOAT64_MAX, |
||||
jspb.BinaryConstants.FLOAT64_MAX, |
||||
function(x) { return x; }); |
||||
}); |
||||
}); |
@ -0,0 +1,628 @@ |
||||
// 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.require('goog.crypt.base64'); |
||||
goog.require('goog.testing.asserts'); |
||||
goog.require('jspb.Message'); |
||||
|
||||
// CommonJS-LoadFromFile: ../testbinary_pb proto.jspb.test
|
||||
goog.require('proto.jspb.test.ExtendsWithMessage'); |
||||
goog.require('proto.jspb.test.ForeignEnum'); |
||||
goog.require('proto.jspb.test.ForeignMessage'); |
||||
goog.require('proto.jspb.test.TestAllTypes'); |
||||
goog.require('proto.jspb.test.TestExtendable'); |
||||
goog.require('proto.jspb.test.extendOptionalBool'); |
||||
goog.require('proto.jspb.test.extendOptionalBytes'); |
||||
goog.require('proto.jspb.test.extendOptionalDouble'); |
||||
goog.require('proto.jspb.test.extendOptionalFixed32'); |
||||
goog.require('proto.jspb.test.extendOptionalFixed64'); |
||||
goog.require('proto.jspb.test.extendOptionalFloat'); |
||||
goog.require('proto.jspb.test.extendOptionalForeignEnum'); |
||||
goog.require('proto.jspb.test.extendOptionalInt32'); |
||||
goog.require('proto.jspb.test.extendOptionalInt64'); |
||||
goog.require('proto.jspb.test.extendOptionalSfixed32'); |
||||
goog.require('proto.jspb.test.extendOptionalSfixed64'); |
||||
goog.require('proto.jspb.test.extendOptionalSint32'); |
||||
goog.require('proto.jspb.test.extendOptionalSint64'); |
||||
goog.require('proto.jspb.test.extendOptionalString'); |
||||
goog.require('proto.jspb.test.extendOptionalUint32'); |
||||
goog.require('proto.jspb.test.extendOptionalUint64'); |
||||
goog.require('proto.jspb.test.extendPackedRepeatedBoolList'); |
||||
goog.require('proto.jspb.test.extendPackedRepeatedDoubleList'); |
||||
goog.require('proto.jspb.test.extendPackedRepeatedFixed32List'); |
||||
goog.require('proto.jspb.test.extendPackedRepeatedFixed64List'); |
||||
goog.require('proto.jspb.test.extendPackedRepeatedFloatList'); |
||||
goog.require('proto.jspb.test.extendPackedRepeatedForeignEnumList'); |
||||
goog.require('proto.jspb.test.extendPackedRepeatedInt32List'); |
||||
goog.require('proto.jspb.test.extendPackedRepeatedInt64List'); |
||||
goog.require('proto.jspb.test.extendPackedRepeatedSfixed32List'); |
||||
goog.require('proto.jspb.test.extendPackedRepeatedSfixed64List'); |
||||
goog.require('proto.jspb.test.extendPackedRepeatedSint32List'); |
||||
goog.require('proto.jspb.test.extendPackedRepeatedSint64List'); |
||||
goog.require('proto.jspb.test.extendPackedRepeatedUint32List'); |
||||
goog.require('proto.jspb.test.extendPackedRepeatedUint64List'); |
||||
goog.require('proto.jspb.test.extendRepeatedBoolList'); |
||||
goog.require('proto.jspb.test.extendRepeatedBytesList'); |
||||
goog.require('proto.jspb.test.extendRepeatedDoubleList'); |
||||
goog.require('proto.jspb.test.extendRepeatedFixed32List'); |
||||
goog.require('proto.jspb.test.extendRepeatedFixed64List'); |
||||
goog.require('proto.jspb.test.extendRepeatedFloatList'); |
||||
goog.require('proto.jspb.test.extendRepeatedForeignEnumList'); |
||||
goog.require('proto.jspb.test.extendRepeatedInt32List'); |
||||
goog.require('proto.jspb.test.extendRepeatedInt64List'); |
||||
goog.require('proto.jspb.test.extendRepeatedSfixed32List'); |
||||
goog.require('proto.jspb.test.extendRepeatedSfixed64List'); |
||||
goog.require('proto.jspb.test.extendRepeatedSint32List'); |
||||
goog.require('proto.jspb.test.extendRepeatedSint64List'); |
||||
goog.require('proto.jspb.test.extendRepeatedStringList'); |
||||
goog.require('proto.jspb.test.extendRepeatedUint32List'); |
||||
goog.require('proto.jspb.test.extendRepeatedUint64List'); |
||||
|
||||
|
||||
var suite = {}; |
||||
|
||||
var BYTES = new Uint8Array([1, 2, 8, 9]); |
||||
|
||||
var BYTES_B64 = goog.crypt.base64.encodeByteArray(BYTES); |
||||
|
||||
|
||||
/** |
||||
* Helper: fill all fields on a TestAllTypes message. |
||||
* @param {proto.jspb.test.TestAllTypes} msg |
||||
*/ |
||||
function fillAllFields(msg) { |
||||
msg.setOptionalInt32(-42); |
||||
// can be exactly represented by JS number (64-bit double, i.e., 52-bit
|
||||
// mantissa).
|
||||
msg.setOptionalInt64(-0x7fffffff00000000); |
||||
msg.setOptionalUint32(0x80000000); |
||||
msg.setOptionalUint64(0xf000000000000000); |
||||
msg.setOptionalSint32(-100); |
||||
msg.setOptionalSint64(-0x8000000000000000); |
||||
msg.setOptionalFixed32(1234); |
||||
msg.setOptionalFixed64(0x1234567800000000); |
||||
msg.setOptionalSfixed32(-1234); |
||||
msg.setOptionalSfixed64(-0x1234567800000000); |
||||
msg.setOptionalFloat(1.5); |
||||
msg.setOptionalDouble(-1.5); |
||||
msg.setOptionalBool(true); |
||||
msg.setOptionalString('hello world'); |
||||
msg.setOptionalBytes(BYTES); |
||||
msg.setOptionalGroup(new proto.jspb.test.TestAllTypes.OptionalGroup()); |
||||
msg.getOptionalGroup().setA(100); |
||||
var submsg = new proto.jspb.test.ForeignMessage(); |
||||
submsg.setC(16); |
||||
msg.setOptionalForeignMessage(submsg); |
||||
msg.setOptionalForeignEnum(proto.jspb.test.ForeignEnum.FOREIGN_FOO); |
||||
msg.setOneofString('oneof'); |
||||
|
||||
|
||||
msg.setRepeatedInt32List([-42]); |
||||
msg.setRepeatedInt64List([-0x7fffffff00000000]); |
||||
msg.setRepeatedUint32List([0x80000000]); |
||||
msg.setRepeatedUint64List([0xf000000000000000]); |
||||
msg.setRepeatedSint32List([-100]); |
||||
msg.setRepeatedSint64List([-0x8000000000000000]); |
||||
msg.setRepeatedFixed32List([1234]); |
||||
msg.setRepeatedFixed64List([0x1234567800000000]); |
||||
msg.setRepeatedSfixed32List([-1234]); |
||||
msg.setRepeatedSfixed64List([-0x1234567800000000]); |
||||
msg.setRepeatedFloatList([1.5]); |
||||
msg.setRepeatedDoubleList([-1.5]); |
||||
msg.setRepeatedBoolList([true]); |
||||
msg.setRepeatedStringList(['hello world']); |
||||
msg.setRepeatedBytesList([BYTES, BYTES]); |
||||
msg.setRepeatedGroupList([new proto.jspb.test.TestAllTypes.RepeatedGroup()]); |
||||
msg.getRepeatedGroupList()[0].setA(100); |
||||
submsg = new proto.jspb.test.ForeignMessage(); |
||||
submsg.setC(1000); |
||||
msg.setRepeatedForeignMessageList([submsg]); |
||||
msg.setRepeatedForeignEnumList([proto.jspb.test.ForeignEnum.FOREIGN_FOO]); |
||||
|
||||
msg.setPackedRepeatedInt32List([-42]); |
||||
msg.setPackedRepeatedInt64List([-0x7fffffff00000000]); |
||||
msg.setPackedRepeatedUint32List([0x80000000]); |
||||
msg.setPackedRepeatedUint64List([0xf000000000000000]); |
||||
msg.setPackedRepeatedSint32List([-100]); |
||||
msg.setPackedRepeatedSint64List([-0x8000000000000000]); |
||||
msg.setPackedRepeatedFixed32List([1234]); |
||||
msg.setPackedRepeatedFixed64List([0x1234567800000000]); |
||||
msg.setPackedRepeatedSfixed32List([-1234]); |
||||
msg.setPackedRepeatedSfixed64List([-0x1234567800000000]); |
||||
msg.setPackedRepeatedFloatList([1.5]); |
||||
msg.setPackedRepeatedDoubleList([-1.5]); |
||||
msg.setPackedRepeatedBoolList([true]); |
||||
|
||||
} |
||||
|
||||
|
||||
/** |
||||
* Helper: compare a bytes field to an expected value |
||||
* @param {Uint8Array|string} arr |
||||
* @param {Uint8Array} expected |
||||
* @return {boolean} |
||||
*/ |
||||
function bytesCompare(arr, expected) { |
||||
if (goog.isString(arr)) { |
||||
arr = goog.crypt.base64.decodeStringToUint8Array(arr); |
||||
} |
||||
if (arr.length != expected.length) { |
||||
return false; |
||||
} |
||||
for (var i = 0; i < arr.length; i++) { |
||||
if (arr[i] != expected[i]) { |
||||
return false; |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Helper: verify contents of given TestAllTypes message as set by |
||||
* fillAllFields(). |
||||
* @param {proto.jspb.test.TestAllTypes} original |
||||
* @param {proto.jspb.test.TestAllTypes} copy |
||||
*/ |
||||
function checkAllFields(original, copy) { |
||||
assertTrue(jspb.Message.equals(original, copy)); |
||||
|
||||
assertEquals(copy.getOptionalInt32(), -42); |
||||
assertEquals(copy.getOptionalInt64(), -0x7fffffff00000000); |
||||
assertEquals(copy.getOptionalUint32(), 0x80000000); |
||||
assertEquals(copy.getOptionalUint64(), 0xf000000000000000); |
||||
assertEquals(copy.getOptionalSint32(), -100); |
||||
assertEquals(copy.getOptionalSint64(), -0x8000000000000000); |
||||
assertEquals(copy.getOptionalFixed32(), 1234); |
||||
assertEquals(copy.getOptionalFixed64(), 0x1234567800000000); |
||||
assertEquals(copy.getOptionalSfixed32(), -1234); |
||||
assertEquals(copy.getOptionalSfixed64(), -0x1234567800000000); |
||||
assertEquals(copy.getOptionalFloat(), 1.5); |
||||
assertEquals(copy.getOptionalDouble(), -1.5); |
||||
assertEquals(copy.getOptionalBool(), true); |
||||
assertEquals(copy.getOptionalString(), 'hello world'); |
||||
assertEquals(true, bytesCompare(copy.getOptionalBytes(), BYTES)); |
||||
assertEquals(true, bytesCompare(copy.getOptionalBytes_asU8(), BYTES)); |
||||
assertEquals( |
||||
copy.getOptionalBytes_asB64(), goog.crypt.base64.encodeByteArray(BYTES)); |
||||
|
||||
assertEquals(copy.getOptionalGroup().getA(), 100); |
||||
assertEquals(copy.getOptionalForeignMessage().getC(), 16); |
||||
assertEquals(copy.getOptionalForeignEnum(), |
||||
proto.jspb.test.ForeignEnum.FOREIGN_FOO); |
||||
|
||||
|
||||
assertEquals(copy.getOneofString(), 'oneof'); |
||||
assertEquals(copy.getOneofFieldCase(), |
||||
proto.jspb.test.TestAllTypes.OneofFieldCase.ONEOF_STRING); |
||||
|
||||
assertElementsEquals(copy.getRepeatedInt32List(), [-42]); |
||||
assertElementsEquals(copy.getRepeatedInt64List(), [-0x7fffffff00000000]); |
||||
assertElementsEquals(copy.getRepeatedUint32List(), [0x80000000]); |
||||
assertElementsEquals(copy.getRepeatedUint64List(), [0xf000000000000000]); |
||||
assertElementsEquals(copy.getRepeatedSint32List(), [-100]); |
||||
assertElementsEquals(copy.getRepeatedSint64List(), [-0x8000000000000000]); |
||||
assertElementsEquals(copy.getRepeatedFixed32List(), [1234]); |
||||
assertElementsEquals(copy.getRepeatedFixed64List(), [0x1234567800000000]); |
||||
assertElementsEquals(copy.getRepeatedSfixed32List(), [-1234]); |
||||
assertElementsEquals(copy.getRepeatedSfixed64List(), [-0x1234567800000000]); |
||||
assertElementsEquals(copy.getRepeatedFloatList(), [1.5]); |
||||
assertElementsEquals(copy.getRepeatedDoubleList(), [-1.5]); |
||||
assertElementsEquals(copy.getRepeatedBoolList(), [true]); |
||||
assertElementsEquals(copy.getRepeatedStringList(), ['hello world']); |
||||
assertEquals(copy.getRepeatedBytesList().length, 2); |
||||
assertEquals(true, bytesCompare(copy.getRepeatedBytesList_asU8()[0], BYTES)); |
||||
assertEquals(true, bytesCompare(copy.getRepeatedBytesList()[0], BYTES)); |
||||
assertEquals(true, bytesCompare(copy.getRepeatedBytesList_asU8()[1], BYTES)); |
||||
assertEquals(copy.getRepeatedBytesList_asB64()[0], BYTES_B64); |
||||
assertEquals(copy.getRepeatedBytesList_asB64()[1], BYTES_B64); |
||||
assertEquals(copy.getRepeatedGroupList().length, 1); |
||||
assertEquals(copy.getRepeatedGroupList()[0].getA(), 100); |
||||
assertEquals(copy.getRepeatedForeignMessageList().length, 1); |
||||
assertEquals(copy.getRepeatedForeignMessageList()[0].getC(), 1000); |
||||
assertElementsEquals(copy.getRepeatedForeignEnumList(), |
||||
[proto.jspb.test.ForeignEnum.FOREIGN_FOO]); |
||||
|
||||
assertElementsEquals(copy.getPackedRepeatedInt32List(), [-42]); |
||||
assertElementsEquals(copy.getPackedRepeatedInt64List(), |
||||
[-0x7fffffff00000000]); |
||||
assertElementsEquals(copy.getPackedRepeatedUint32List(), [0x80000000]); |
||||
assertElementsEquals(copy.getPackedRepeatedUint64List(), |
||||
[0xf000000000000000]); |
||||
assertElementsEquals(copy.getPackedRepeatedSint32List(), [-100]); |
||||
assertElementsEquals(copy.getPackedRepeatedSint64List(), |
||||
[-0x8000000000000000]); |
||||
assertElementsEquals(copy.getPackedRepeatedFixed32List(), [1234]); |
||||
assertElementsEquals(copy.getPackedRepeatedFixed64List(), |
||||
[0x1234567800000000]); |
||||
assertElementsEquals(copy.getPackedRepeatedSfixed32List(), [-1234]); |
||||
assertElementsEquals(copy.getPackedRepeatedSfixed64List(), |
||||
[-0x1234567800000000]); |
||||
assertElementsEquals(copy.getPackedRepeatedFloatList(), [1.5]); |
||||
assertElementsEquals(copy.getPackedRepeatedDoubleList(), [-1.5]); |
||||
|
||||
} |
||||
|
||||
|
||||
/** |
||||
* Helper: verify that all expected extensions are present. |
||||
* @param {!proto.jspb.test.TestExtendable} msg |
||||
*/ |
||||
function checkExtensions(msg) { |
||||
assertEquals(-42, |
||||
msg.getExtension(proto.jspb.test.extendOptionalInt32)); |
||||
assertEquals(-0x7fffffff00000000, |
||||
msg.getExtension(proto.jspb.test.extendOptionalInt64)); |
||||
assertEquals(0x80000000, |
||||
msg.getExtension(proto.jspb.test.extendOptionalUint32)); |
||||
assertEquals(0xf000000000000000, |
||||
msg.getExtension(proto.jspb.test.extendOptionalUint64)); |
||||
assertEquals(-100, |
||||
msg.getExtension(proto.jspb.test.extendOptionalSint32)); |
||||
assertEquals(-0x8000000000000000, |
||||
msg.getExtension(proto.jspb.test.extendOptionalSint64)); |
||||
assertEquals(1234, |
||||
msg.getExtension(proto.jspb.test.extendOptionalFixed32)); |
||||
assertEquals(0x1234567800000000, |
||||
msg.getExtension(proto.jspb.test.extendOptionalFixed64)); |
||||
assertEquals(-1234, |
||||
msg.getExtension(proto.jspb.test.extendOptionalSfixed32)); |
||||
assertEquals(-0x1234567800000000, |
||||
msg.getExtension(proto.jspb.test.extendOptionalSfixed64)); |
||||
assertEquals(1.5, |
||||
msg.getExtension(proto.jspb.test.extendOptionalFloat)); |
||||
assertEquals(-1.5, |
||||
msg.getExtension(proto.jspb.test.extendOptionalDouble)); |
||||
assertEquals(true, |
||||
msg.getExtension(proto.jspb.test.extendOptionalBool)); |
||||
assertEquals('hello world', |
||||
msg.getExtension(proto.jspb.test.extendOptionalString)); |
||||
assertEquals( |
||||
true, bytesCompare( |
||||
msg.getExtension(proto.jspb.test.extendOptionalBytes), BYTES)); |
||||
assertEquals(16, |
||||
msg.getExtension( |
||||
proto.jspb.test.ExtendsWithMessage.optionalExtension).getFoo()); |
||||
|
||||
|
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedInt32List), |
||||
[-42]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedInt64List), |
||||
[-0x7fffffff00000000]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedUint32List), |
||||
[0x80000000]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedUint64List), |
||||
[0xf000000000000000]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedSint32List), |
||||
[-100]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedSint64List), |
||||
[-0x8000000000000000]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedFixed32List), |
||||
[1234]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedFixed64List), |
||||
[0x1234567800000000]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedSfixed32List), |
||||
[-1234]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedSfixed64List), |
||||
[-0x1234567800000000]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedFloatList), |
||||
[1.5]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedDoubleList), |
||||
[-1.5]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedBoolList), |
||||
[true]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedStringList), |
||||
['hello world']); |
||||
assertEquals( |
||||
true, |
||||
bytesCompare( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedBytesList)[0], BYTES)); |
||||
assertEquals(1000, |
||||
msg.getExtension( |
||||
proto.jspb.test.ExtendsWithMessage.repeatedExtensionList)[0] |
||||
.getFoo()); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendRepeatedForeignEnumList), |
||||
[proto.jspb.test.ForeignEnum.FOREIGN_FOO]); |
||||
|
||||
|
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendPackedRepeatedInt32List), |
||||
[-42]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendPackedRepeatedInt64List), |
||||
[-0x7fffffff00000000]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendPackedRepeatedUint32List), |
||||
[0x80000000]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendPackedRepeatedUint64List), |
||||
[0xf000000000000000]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendPackedRepeatedSint32List), |
||||
[-100]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendPackedRepeatedSint64List), |
||||
[-0x8000000000000000]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendPackedRepeatedFixed32List), |
||||
[1234]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendPackedRepeatedFixed64List), |
||||
[0x1234567800000000]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendPackedRepeatedSfixed32List), |
||||
[-1234]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendPackedRepeatedSfixed64List), |
||||
[-0x1234567800000000]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendPackedRepeatedFloatList), |
||||
[1.5]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendPackedRepeatedDoubleList), |
||||
[-1.5]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendPackedRepeatedBoolList), |
||||
[true]); |
||||
assertElementsEquals( |
||||
msg.getExtension(proto.jspb.test.extendPackedRepeatedForeignEnumList), |
||||
[proto.jspb.test.ForeignEnum.FOREIGN_FOO]); |
||||
|
||||
} |
||||
|
||||
|
||||
describe('protoBinaryTest', function() { |
||||
/** |
||||
* Tests a basic serialization-deserializaton round-trip with all supported |
||||
* field types (on the TestAllTypes message type). |
||||
*/ |
||||
it('testRoundTrip', function() { |
||||
var msg = new proto.jspb.test.TestAllTypes(); |
||||
fillAllFields(msg); |
||||
var encoded = msg.serializeBinary(); |
||||
var decoded = proto.jspb.test.TestAllTypes.deserializeBinary(encoded); |
||||
checkAllFields(msg, decoded); |
||||
}); |
||||
|
||||
/** |
||||
* Test that base64 string and Uint8Array are interchangeable in bytes fields. |
||||
*/ |
||||
it('testBytesFieldsGettersInterop', function() { |
||||
var msg = new proto.jspb.test.TestAllTypes(); |
||||
// Set from a base64 string and check all the getters work.
|
||||
msg.setOptionalBytes(BYTES_B64); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes_asU8(), BYTES)); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes_asB64(), BYTES)); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes(), BYTES)); |
||||
|
||||
// Test binary serialize round trip doesn't break it.
|
||||
msg = proto.jspb.test.TestAllTypes.deserializeBinary(msg.serializeBinary()); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes_asU8(), BYTES)); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes_asB64(), BYTES)); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes(), BYTES)); |
||||
|
||||
msg = new proto.jspb.test.TestAllTypes(); |
||||
// Set from a Uint8Array and check all the getters work.
|
||||
msg.setOptionalBytes(BYTES); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes_asU8(), BYTES)); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes_asB64(), BYTES)); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes(), BYTES)); |
||||
|
||||
}); |
||||
|
||||
/** |
||||
* Test that bytes setters will receive result of any of the getters. |
||||
*/ |
||||
it('testBytesFieldsSettersInterop', function() { |
||||
var msg = new proto.jspb.test.TestAllTypes(); |
||||
msg.setOptionalBytes(BYTES); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes(), BYTES)); |
||||
|
||||
msg.setOptionalBytes(msg.getOptionalBytes()); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes(), BYTES)); |
||||
msg.setOptionalBytes(msg.getOptionalBytes_asB64()); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes(), BYTES)); |
||||
msg.setOptionalBytes(msg.getOptionalBytes_asU8()); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes(), BYTES)); |
||||
}); |
||||
|
||||
/** |
||||
* Test that bytes setters will receive result of any of the getters. |
||||
*/ |
||||
it('testRepeatedBytesGetters', function() { |
||||
var msg = new proto.jspb.test.TestAllTypes(); |
||||
|
||||
function assertGetters() { |
||||
assertTrue(goog.isString(msg.getRepeatedBytesList_asB64()[0])); |
||||
assertTrue(goog.isString(msg.getRepeatedBytesList_asB64()[1])); |
||||
assertTrue(msg.getRepeatedBytesList_asU8()[0] instanceof Uint8Array); |
||||
assertTrue(msg.getRepeatedBytesList_asU8()[1] instanceof Uint8Array); |
||||
|
||||
assertTrue(bytesCompare(msg.getRepeatedBytesList()[0], BYTES)); |
||||
assertTrue(bytesCompare(msg.getRepeatedBytesList()[1], BYTES)); |
||||
assertTrue(bytesCompare(msg.getRepeatedBytesList_asB64()[0], BYTES)); |
||||
assertTrue(bytesCompare(msg.getRepeatedBytesList_asB64()[1], BYTES)); |
||||
assertTrue(bytesCompare(msg.getRepeatedBytesList_asU8()[0], BYTES)); |
||||
assertTrue(bytesCompare(msg.getRepeatedBytesList_asU8()[1], BYTES)); |
||||
} |
||||
|
||||
msg.setRepeatedBytesList([BYTES, BYTES]); |
||||
assertGetters(); |
||||
|
||||
msg.setRepeatedBytesList([BYTES_B64, BYTES_B64]); |
||||
assertGetters(); |
||||
|
||||
msg.setRepeatedBytesList(null); |
||||
assertEquals(0, msg.getRepeatedBytesList().length); |
||||
assertEquals(0, msg.getRepeatedBytesList_asB64().length); |
||||
assertEquals(0, msg.getRepeatedBytesList_asU8().length); |
||||
}); |
||||
|
||||
/** |
||||
* Helper: fill all extension values. |
||||
* @param {proto.jspb.test.TestExtendable} msg |
||||
*/ |
||||
function fillExtensions(msg) { |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalInt32, -42); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalInt64, -0x7fffffff00000000); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalUint32, 0x80000000); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalUint64, 0xf000000000000000); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalSint32, -100); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalSint64, -0x8000000000000000); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalFixed32, 1234); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalFixed64, 0x1234567800000000); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalSfixed32, -1234); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalSfixed64, -0x1234567800000000); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalFloat, 1.5); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalDouble, -1.5); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalBool, true); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalString, 'hello world'); |
||||
msg.setExtension(proto.jspb.test.extendOptionalBytes, BYTES); |
||||
var submsg = new proto.jspb.test.ExtendsWithMessage(); |
||||
submsg.setFoo(16); |
||||
msg.setExtension( |
||||
proto.jspb.test.ExtendsWithMessage.optionalExtension, submsg); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendOptionalForeignEnum, |
||||
proto.jspb.test.ForeignEnum.FOREIGN_FOO); |
||||
|
||||
|
||||
msg.setExtension( |
||||
proto.jspb.test.extendRepeatedInt32List, [-42]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendRepeatedInt64List, [-0x7fffffff00000000]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendRepeatedUint32List, [0x80000000]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendRepeatedUint64List, [0xf000000000000000]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendRepeatedSint32List, [-100]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendRepeatedSint64List, [-0x8000000000000000]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendRepeatedFixed32List, [1234]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendRepeatedFixed64List, [0x1234567800000000]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendRepeatedSfixed32List, [-1234]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendRepeatedSfixed64List, [-0x1234567800000000]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendRepeatedFloatList, [1.5]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendRepeatedDoubleList, [-1.5]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendRepeatedBoolList, [true]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendRepeatedStringList, ['hello world']); |
||||
msg.setExtension(proto.jspb.test.extendRepeatedBytesList, [BYTES]); |
||||
submsg = new proto.jspb.test.ExtendsWithMessage(); |
||||
submsg.setFoo(1000); |
||||
msg.setExtension( |
||||
proto.jspb.test.ExtendsWithMessage.repeatedExtensionList, [submsg]); |
||||
msg.setExtension(proto.jspb.test.extendRepeatedForeignEnumList, |
||||
[proto.jspb.test.ForeignEnum.FOREIGN_FOO]); |
||||
|
||||
|
||||
msg.setExtension( |
||||
proto.jspb.test.extendPackedRepeatedInt32List, [-42]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendPackedRepeatedInt64List, [-0x7fffffff00000000]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendPackedRepeatedUint32List, [0x80000000]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendPackedRepeatedUint64List, [0xf000000000000000]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendPackedRepeatedSint32List, [-100]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendPackedRepeatedSint64List, [-0x8000000000000000]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendPackedRepeatedFixed32List, [1234]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendPackedRepeatedFixed64List, [0x1234567800000000]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendPackedRepeatedSfixed32List, [-1234]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendPackedRepeatedSfixed64List, |
||||
[-0x1234567800000000]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendPackedRepeatedFloatList, [1.5]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendPackedRepeatedDoubleList, [-1.5]); |
||||
msg.setExtension( |
||||
proto.jspb.test.extendPackedRepeatedBoolList, [true]); |
||||
msg.setExtension(proto.jspb.test.extendPackedRepeatedForeignEnumList, |
||||
[proto.jspb.test.ForeignEnum.FOREIGN_FOO]); |
||||
|
||||
} |
||||
|
||||
|
||||
/** |
||||
* Tests extension serialization and deserialization. |
||||
*/ |
||||
it('testExtensions', function() { |
||||
var msg = new proto.jspb.test.TestExtendable(); |
||||
fillExtensions(msg); |
||||
var encoded = msg.serializeBinary(); |
||||
var decoded = proto.jspb.test.TestExtendable.deserializeBinary(encoded); |
||||
checkExtensions(decoded); |
||||
}); |
||||
}); |
@ -0,0 +1,922 @@ |
||||
// 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.
|
||||
|
||||
/** |
||||
* @fileoverview Test cases for jspb's binary protocol buffer reader. |
||||
* |
||||
* There are two particular magic numbers that need to be pointed out - |
||||
* 2^64-1025 is the largest number representable as both a double and an |
||||
* unsigned 64-bit integer, and 2^63-513 is the largest number representable as |
||||
* both a double and a signed 64-bit integer. |
||||
* |
||||
* Test suite is written using Jasmine -- see http://jasmine.github.io/
|
||||
* |
||||
* @author aappleby@google.com (Austin Appleby) |
||||
*/ |
||||
|
||||
goog.require('goog.testing.asserts'); |
||||
goog.require('jspb.BinaryConstants'); |
||||
goog.require('jspb.BinaryDecoder'); |
||||
goog.require('jspb.BinaryReader'); |
||||
goog.require('jspb.BinaryWriter'); |
||||
|
||||
|
||||
|
||||
describe('binaryReaderTest', function() { |
||||
/** |
||||
* Tests the reader instance cache. |
||||
*/ |
||||
it('testInstanceCaches', /** @suppress {visibility} */ function() { |
||||
var writer = new jspb.BinaryWriter(); |
||||
var dummyMessage = /** @type {!jspb.BinaryMessage} */({}); |
||||
writer.writeMessage(1, dummyMessage, goog.nullFunction); |
||||
writer.writeMessage(2, dummyMessage, goog.nullFunction); |
||||
|
||||
var buffer = writer.getResultBuffer(); |
||||
|
||||
// Empty the instance caches.
|
||||
jspb.BinaryReader.instanceCache_ = []; |
||||
|
||||
// Allocating and then freeing three decoders should leave us with three in
|
||||
// the cache.
|
||||
|
||||
var decoder1 = jspb.BinaryDecoder.alloc(); |
||||
var decoder2 = jspb.BinaryDecoder.alloc(); |
||||
var decoder3 = jspb.BinaryDecoder.alloc(); |
||||
decoder1.free(); |
||||
decoder2.free(); |
||||
decoder3.free(); |
||||
|
||||
assertEquals(3, jspb.BinaryDecoder.instanceCache_.length); |
||||
assertEquals(0, jspb.BinaryReader.instanceCache_.length); |
||||
|
||||
// Allocating and then freeing a reader should remove one decoder from its
|
||||
// cache, but it should stay stuck to the reader afterwards since we can't
|
||||
// have a reader without a decoder.
|
||||
jspb.BinaryReader.alloc().free(); |
||||
|
||||
assertEquals(2, jspb.BinaryDecoder.instanceCache_.length); |
||||
assertEquals(1, jspb.BinaryReader.instanceCache_.length); |
||||
|
||||
// Allocating a reader should remove a reader from the cache.
|
||||
var reader = jspb.BinaryReader.alloc(buffer); |
||||
|
||||
assertEquals(2, jspb.BinaryDecoder.instanceCache_.length); |
||||
assertEquals(0, jspb.BinaryReader.instanceCache_.length); |
||||
|
||||
// Processing the message reuses the current reader.
|
||||
reader.nextField(); |
||||
assertEquals(1, reader.getFieldNumber()); |
||||
reader.readMessage(dummyMessage, function() { |
||||
assertEquals(0, jspb.BinaryReader.instanceCache_.length); |
||||
}); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(2, reader.getFieldNumber()); |
||||
reader.readMessage(dummyMessage, function() { |
||||
assertEquals(0, jspb.BinaryReader.instanceCache_.length); |
||||
}); |
||||
|
||||
assertEquals(false, reader.nextField()); |
||||
|
||||
assertEquals(2, jspb.BinaryDecoder.instanceCache_.length); |
||||
assertEquals(0, jspb.BinaryReader.instanceCache_.length); |
||||
|
||||
// Freeing the reader should put it back into the cache.
|
||||
reader.free(); |
||||
|
||||
assertEquals(2, jspb.BinaryDecoder.instanceCache_.length); |
||||
assertEquals(1, jspb.BinaryReader.instanceCache_.length); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* @param {number} x |
||||
* @return {number} |
||||
*/ |
||||
function truncate(x) { |
||||
var temp = new Float32Array(1); |
||||
temp[0] = x; |
||||
return temp[0]; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Verifies that misuse of the reader class triggers assertions. |
||||
*/ |
||||
it('testReadErrors', /** @suppress {checkTypes|visibility} */ function() { |
||||
// Calling readMessage on a non-delimited field should trigger an
|
||||
// assertion.
|
||||
var reader = jspb.BinaryReader.alloc([8, 1]); |
||||
var dummyMessage = /** @type {!jspb.BinaryMessage} */({}); |
||||
reader.nextField(); |
||||
assertThrows(function() { |
||||
reader.readMessage(dummyMessage, goog.nullFunction); |
||||
}); |
||||
|
||||
// Reading past the end of the stream should trigger an assertion.
|
||||
reader = jspb.BinaryReader.alloc([9, 1]); |
||||
reader.nextField(); |
||||
assertThrows(function() {reader.readFixed64()}); |
||||
|
||||
// Reading past the end of a submessage should trigger an assertion.
|
||||
reader = jspb.BinaryReader.alloc([10, 4, 13, 1, 1, 1]); |
||||
reader.nextField(); |
||||
reader.readMessage(dummyMessage, function() { |
||||
reader.nextField(); |
||||
assertThrows(function() {reader.readFixed32()}); |
||||
}); |
||||
|
||||
// Skipping an invalid field should trigger an assertion.
|
||||
reader = jspb.BinaryReader.alloc([12, 1]); |
||||
reader.nextWireType_ = 1000; |
||||
assertThrows(function() {reader.skipField()}); |
||||
|
||||
// Reading fields with the wrong wire type should assert.
|
||||
reader = jspb.BinaryReader.alloc([9, 0, 0, 0, 0, 0, 0, 0, 0]); |
||||
reader.nextField(); |
||||
assertThrows(function() {reader.readInt32()}); |
||||
assertThrows(function() {reader.readInt32String()}); |
||||
assertThrows(function() {reader.readInt64()}); |
||||
assertThrows(function() {reader.readInt64String()}); |
||||
assertThrows(function() {reader.readUint32()}); |
||||
assertThrows(function() {reader.readUint32String()}); |
||||
assertThrows(function() {reader.readUint64()}); |
||||
assertThrows(function() {reader.readUint64String()}); |
||||
assertThrows(function() {reader.readSint32()}); |
||||
assertThrows(function() {reader.readBool()}); |
||||
assertThrows(function() {reader.readEnum()}); |
||||
|
||||
reader = jspb.BinaryReader.alloc([8, 1]); |
||||
reader.nextField(); |
||||
assertThrows(function() {reader.readFixed32()}); |
||||
assertThrows(function() {reader.readFixed64()}); |
||||
assertThrows(function() {reader.readSfixed32()}); |
||||
assertThrows(function() {reader.readSfixed64()}); |
||||
assertThrows(function() {reader.readFloat()}); |
||||
assertThrows(function() {reader.readDouble()}); |
||||
|
||||
assertThrows(function() {reader.readString()}); |
||||
assertThrows(function() {reader.readBytes()}); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests encoding and decoding of unsigned field types. |
||||
* @param {Function} readField |
||||
* @param {Function} writeField |
||||
* @param {number} epsilon |
||||
* @param {number} upperLimit |
||||
* @param {Function} filter |
||||
* @private |
||||
* @suppress {missingProperties} |
||||
*/ |
||||
var doTestUnsignedField_ = function(readField, |
||||
writeField, epsilon, upperLimit, filter) { |
||||
assertNotNull(readField); |
||||
assertNotNull(writeField); |
||||
|
||||
var writer = new jspb.BinaryWriter(); |
||||
|
||||
// Encode zero and limits.
|
||||
writeField.call(writer, 1, filter(0)); |
||||
writeField.call(writer, 2, filter(epsilon)); |
||||
writeField.call(writer, 3, filter(upperLimit)); |
||||
|
||||
// Encode positive values.
|
||||
for (var cursor = epsilon; cursor < upperLimit; cursor *= 1.1) { |
||||
writeField.call(writer, 4, filter(cursor)); |
||||
} |
||||
|
||||
var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); |
||||
|
||||
// Check zero and limits.
|
||||
reader.nextField(); |
||||
assertEquals(1, reader.getFieldNumber()); |
||||
assertEquals(filter(0), readField.call(reader)); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(2, reader.getFieldNumber()); |
||||
assertEquals(filter(epsilon), readField.call(reader)); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(3, reader.getFieldNumber()); |
||||
assertEquals(filter(upperLimit), readField.call(reader)); |
||||
|
||||
// Check positive values.
|
||||
for (var cursor = epsilon; cursor < upperLimit; cursor *= 1.1) { |
||||
reader.nextField(); |
||||
if (4 != reader.getFieldNumber()) throw 'fail!'; |
||||
if (filter(cursor) != readField.call(reader)) throw 'fail!'; |
||||
} |
||||
}; |
||||
|
||||
|
||||
/** |
||||
* Tests encoding and decoding of signed field types. |
||||
* @param {Function} readField |
||||
* @param {Function} writeField |
||||
* @param {number} epsilon |
||||
* @param {number} lowerLimit |
||||
* @param {number} upperLimit |
||||
* @param {Function} filter |
||||
* @private |
||||
* @suppress {missingProperties} |
||||
*/ |
||||
var doTestSignedField_ = function(readField, |
||||
writeField, epsilon, lowerLimit, upperLimit, filter) { |
||||
var writer = new jspb.BinaryWriter(); |
||||
|
||||
// Encode zero and limits.
|
||||
writeField.call(writer, 1, filter(lowerLimit)); |
||||
writeField.call(writer, 2, filter(-epsilon)); |
||||
writeField.call(writer, 3, filter(0)); |
||||
writeField.call(writer, 4, filter(epsilon)); |
||||
writeField.call(writer, 5, filter(upperLimit)); |
||||
|
||||
var inputValues = []; |
||||
|
||||
// Encode negative values.
|
||||
for (var cursor = lowerLimit; cursor < -epsilon; cursor /= 1.1) { |
||||
var val = filter(cursor); |
||||
writeField.call(writer, 6, val); |
||||
inputValues.push({ |
||||
fieldNumber: 6, |
||||
value: val |
||||
}); |
||||
} |
||||
|
||||
// Encode positive values.
|
||||
for (var cursor = epsilon; cursor < upperLimit; cursor *= 1.1) { |
||||
var val = filter(cursor); |
||||
writeField.call(writer, 7, val); |
||||
inputValues.push({ |
||||
fieldNumber: 7, |
||||
value: val |
||||
}); |
||||
} |
||||
|
||||
var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); |
||||
|
||||
// Check zero and limits.
|
||||
reader.nextField(); |
||||
assertEquals(1, reader.getFieldNumber()); |
||||
assertEquals(filter(lowerLimit), readField.call(reader)); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(2, reader.getFieldNumber()); |
||||
assertEquals(filter(-epsilon), readField.call(reader)); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(3, reader.getFieldNumber()); |
||||
assertEquals(filter(0), readField.call(reader)); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(4, reader.getFieldNumber()); |
||||
assertEquals(filter(epsilon), readField.call(reader)); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(5, reader.getFieldNumber()); |
||||
assertEquals(filter(upperLimit), readField.call(reader)); |
||||
|
||||
for (var i = 0; i < inputValues.length; i++) { |
||||
var expected = inputValues[i]; |
||||
reader.nextField(); |
||||
assertEquals(expected.fieldNumber, reader.getFieldNumber()); |
||||
assertEquals(expected.value, readField.call(reader)); |
||||
} |
||||
}; |
||||
|
||||
|
||||
/** |
||||
* Tests fields that use varint encoding. |
||||
*/ |
||||
it('testVarintFields', function() { |
||||
assertNotUndefined(jspb.BinaryReader.prototype.readUint32); |
||||
assertNotUndefined(jspb.BinaryWriter.prototype.writeUint32); |
||||
assertNotUndefined(jspb.BinaryReader.prototype.readUint64); |
||||
assertNotUndefined(jspb.BinaryWriter.prototype.writeUint64); |
||||
assertNotUndefined(jspb.BinaryReader.prototype.readBool); |
||||
assertNotUndefined(jspb.BinaryWriter.prototype.writeBool); |
||||
doTestUnsignedField_( |
||||
jspb.BinaryReader.prototype.readUint32, |
||||
jspb.BinaryWriter.prototype.writeUint32, |
||||
1, Math.pow(2, 32) - 1, Math.round); |
||||
|
||||
doTestUnsignedField_( |
||||
jspb.BinaryReader.prototype.readUint64, |
||||
jspb.BinaryWriter.prototype.writeUint64, |
||||
1, Math.pow(2, 64) - 1025, Math.round); |
||||
|
||||
doTestSignedField_( |
||||
jspb.BinaryReader.prototype.readInt32, |
||||
jspb.BinaryWriter.prototype.writeInt32, |
||||
1, -Math.pow(2, 31), Math.pow(2, 31) - 1, Math.round); |
||||
|
||||
doTestSignedField_( |
||||
jspb.BinaryReader.prototype.readInt64, |
||||
jspb.BinaryWriter.prototype.writeInt64, |
||||
1, -Math.pow(2, 63), Math.pow(2, 63) - 513, Math.round); |
||||
|
||||
doTestSignedField_( |
||||
jspb.BinaryReader.prototype.readEnum, |
||||
jspb.BinaryWriter.prototype.writeEnum, |
||||
1, -Math.pow(2, 31), Math.pow(2, 31) - 1, Math.round); |
||||
|
||||
doTestUnsignedField_( |
||||
jspb.BinaryReader.prototype.readBool, |
||||
jspb.BinaryWriter.prototype.writeBool, |
||||
1, 1, function(x) { return !!x; }); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests reading a field from hexadecimal string (format: '08 BE EF'). |
||||
* @param {Function} readField |
||||
* @param {number} expected |
||||
* @param {string} hexString |
||||
*/ |
||||
function doTestHexStringVarint_(readField, expected, hexString) { |
||||
var bytesCount = (hexString.length + 1) / 3; |
||||
var bytes = new Uint8Array(bytesCount); |
||||
for (var i = 0; i < bytesCount; i++) { |
||||
bytes[i] = parseInt(hexString.substring(i * 3, i * 3 + 2), 16); |
||||
} |
||||
var reader = jspb.BinaryReader.alloc(bytes); |
||||
reader.nextField(); |
||||
assertEquals(expected, readField.call(reader)); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Tests non-canonical redundant varint decoding. |
||||
*/ |
||||
it('testRedundantVarintFields', function() { |
||||
assertNotNull(jspb.BinaryReader.prototype.readUint32); |
||||
assertNotNull(jspb.BinaryReader.prototype.readUint64); |
||||
assertNotNull(jspb.BinaryReader.prototype.readSint32); |
||||
assertNotNull(jspb.BinaryReader.prototype.readSint64); |
||||
|
||||
// uint32 and sint32 take no more than 5 bytes
|
||||
// 08 - field prefix (type = 0 means varint)
|
||||
doTestHexStringVarint_( |
||||
jspb.BinaryReader.prototype.readUint32, |
||||
12, '08 8C 80 80 80 00'); |
||||
|
||||
// 11 stands for -6 in zigzag encoding
|
||||
doTestHexStringVarint_( |
||||
jspb.BinaryReader.prototype.readSint32, |
||||
-6, '08 8B 80 80 80 00'); |
||||
|
||||
// uint64 and sint64 take no more than 10 bytes
|
||||
// 08 - field prefix (type = 0 means varint)
|
||||
doTestHexStringVarint_( |
||||
jspb.BinaryReader.prototype.readUint64, |
||||
12, '08 8C 80 80 80 80 80 80 80 80 00'); |
||||
|
||||
// 11 stands for -6 in zigzag encoding
|
||||
doTestHexStringVarint_( |
||||
jspb.BinaryReader.prototype.readSint64, |
||||
-6, '08 8B 80 80 80 80 80 80 80 80 00'); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests 64-bit fields that are handled as strings. |
||||
*/ |
||||
it('testStringInt64Fields', function() { |
||||
var writer = new jspb.BinaryWriter(); |
||||
|
||||
var testSignedData = [ |
||||
'2730538252207801776', |
||||
'-2688470994844604560', |
||||
'3398529779486536359', |
||||
'3568577411627971000', |
||||
'272477188847484900', |
||||
'-6649058714086158188', |
||||
'-7695254765712060806', |
||||
'-4525541438037104029', |
||||
'-4993706538836508568', |
||||
'4990160321893729138' |
||||
]; |
||||
var testUnsignedData = [ |
||||
'7822732630241694882', |
||||
'6753602971916687352', |
||||
'2399935075244442116', |
||||
'8724292567325338867', |
||||
'16948784802625696584', |
||||
'4136275908516066934', |
||||
'3575388346793700364', |
||||
'5167142028379259461', |
||||
'1557573948689737699', |
||||
'17100725280812548567' |
||||
]; |
||||
|
||||
for (var i = 0; i < testSignedData.length; i++) { |
||||
writer.writeInt64String(2 * i + 1, testSignedData[i]); |
||||
writer.writeUint64String(2 * i + 2, testUnsignedData[i]); |
||||
} |
||||
|
||||
var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); |
||||
|
||||
for (var i = 0; i < testSignedData.length; i++) { |
||||
reader.nextField(); |
||||
assertEquals(2 * i + 1, reader.getFieldNumber()); |
||||
assertEquals(testSignedData[i], reader.readInt64String()); |
||||
reader.nextField(); |
||||
assertEquals(2 * i + 2, reader.getFieldNumber()); |
||||
assertEquals(testUnsignedData[i], reader.readUint64String()); |
||||
} |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests fields that use zigzag encoding. |
||||
*/ |
||||
it('testZigzagFields', function() { |
||||
doTestSignedField_( |
||||
jspb.BinaryReader.prototype.readSint32, |
||||
jspb.BinaryWriter.prototype.writeSint32, |
||||
1, -Math.pow(2, 31), Math.pow(2, 31) - 1, Math.round); |
||||
|
||||
doTestSignedField_( |
||||
jspb.BinaryReader.prototype.readSint64, |
||||
jspb.BinaryWriter.prototype.writeSint64, |
||||
1, -Math.pow(2, 63), Math.pow(2, 63) - 513, Math.round); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests fields that use fixed-length encoding. |
||||
*/ |
||||
it('testFixedFields', function() { |
||||
doTestUnsignedField_( |
||||
jspb.BinaryReader.prototype.readFixed32, |
||||
jspb.BinaryWriter.prototype.writeFixed32, |
||||
1, Math.pow(2, 32) - 1, Math.round); |
||||
|
||||
doTestUnsignedField_( |
||||
jspb.BinaryReader.prototype.readFixed64, |
||||
jspb.BinaryWriter.prototype.writeFixed64, |
||||
1, Math.pow(2, 64) - 1025, Math.round); |
||||
|
||||
doTestSignedField_( |
||||
jspb.BinaryReader.prototype.readSfixed32, |
||||
jspb.BinaryWriter.prototype.writeSfixed32, |
||||
1, -Math.pow(2, 31), Math.pow(2, 31) - 1, Math.round); |
||||
|
||||
doTestSignedField_( |
||||
jspb.BinaryReader.prototype.readSfixed64, |
||||
jspb.BinaryWriter.prototype.writeSfixed64, |
||||
1, -Math.pow(2, 63), Math.pow(2, 63) - 513, Math.round); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests floating point fields. |
||||
*/ |
||||
it('testFloatFields', function() { |
||||
doTestSignedField_( |
||||
jspb.BinaryReader.prototype.readFloat, |
||||
jspb.BinaryWriter.prototype.writeFloat, |
||||
jspb.BinaryConstants.FLOAT32_MIN, |
||||
-jspb.BinaryConstants.FLOAT32_MAX, |
||||
jspb.BinaryConstants.FLOAT32_MAX, |
||||
truncate); |
||||
|
||||
doTestSignedField_( |
||||
jspb.BinaryReader.prototype.readDouble, |
||||
jspb.BinaryWriter.prototype.writeDouble, |
||||
jspb.BinaryConstants.FLOAT64_EPS * 10, |
||||
-jspb.BinaryConstants.FLOAT64_MIN, |
||||
jspb.BinaryConstants.FLOAT64_MIN, |
||||
function(x) { return x; }); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests length-delimited string fields. |
||||
*/ |
||||
it('testStringFields', function() { |
||||
var s1 = 'The quick brown fox jumps over the lazy dog.'; |
||||
var s2 = '人人生而自由,在尊嚴和權利上一律平等。'; |
||||
|
||||
var writer = new jspb.BinaryWriter(); |
||||
|
||||
writer.writeString(1, s1); |
||||
writer.writeString(2, s2); |
||||
|
||||
var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(1, reader.getFieldNumber()); |
||||
assertEquals(s1, reader.readString()); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(2, reader.getFieldNumber()); |
||||
assertEquals(s2, reader.readString()); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests length-delimited byte fields. |
||||
*/ |
||||
it('testByteFields', function() { |
||||
var message = []; |
||||
var lowerLimit = 1; |
||||
var upperLimit = 256; |
||||
var scale = 1.1; |
||||
|
||||
var writer = new jspb.BinaryWriter(); |
||||
|
||||
for (var cursor = lowerLimit; cursor < upperLimit; cursor *= 1.1) { |
||||
var len = Math.round(cursor); |
||||
var bytes = []; |
||||
for (var i = 0; i < len; i++) bytes.push(i % 256); |
||||
|
||||
writer.writeBytes(len, bytes); |
||||
} |
||||
|
||||
var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); |
||||
|
||||
for (var cursor = lowerLimit; reader.nextField(); cursor *= 1.1) { |
||||
var len = Math.round(cursor); |
||||
if (len != reader.getFieldNumber()) throw 'fail!'; |
||||
|
||||
var bytes = reader.readBytes(); |
||||
if (len != bytes.length) throw 'fail!'; |
||||
for (var i = 0; i < bytes.length; i++) { |
||||
if (i % 256 != bytes[i]) throw 'fail!'; |
||||
} |
||||
} |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests nested messages. |
||||
*/ |
||||
it('testNesting', function() { |
||||
var writer = new jspb.BinaryWriter(); |
||||
var dummyMessage = /** @type {!jspb.BinaryMessage} */({}); |
||||
|
||||
writer.writeInt32(1, 100); |
||||
|
||||
// Add one message with 3 int fields.
|
||||
writer.writeMessage(2, dummyMessage, function() { |
||||
writer.writeInt32(3, 300); |
||||
writer.writeInt32(4, 400); |
||||
writer.writeInt32(5, 500); |
||||
}); |
||||
|
||||
// Add one empty message.
|
||||
writer.writeMessage(6, dummyMessage, goog.nullFunction); |
||||
|
||||
writer.writeInt32(7, 700); |
||||
|
||||
var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); |
||||
|
||||
// Validate outermost message.
|
||||
|
||||
reader.nextField(); |
||||
assertEquals(1, reader.getFieldNumber()); |
||||
assertEquals(100, reader.readInt32()); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(2, reader.getFieldNumber()); |
||||
reader.readMessage(dummyMessage, function() { |
||||
// Validate embedded message 1.
|
||||
reader.nextField(); |
||||
assertEquals(3, reader.getFieldNumber()); |
||||
assertEquals(300, reader.readInt32()); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(4, reader.getFieldNumber()); |
||||
assertEquals(400, reader.readInt32()); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(5, reader.getFieldNumber()); |
||||
assertEquals(500, reader.readInt32()); |
||||
|
||||
assertEquals(false, reader.nextField()); |
||||
}); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(6, reader.getFieldNumber()); |
||||
reader.readMessage(dummyMessage, function() { |
||||
// Validate embedded message 2.
|
||||
|
||||
assertEquals(false, reader.nextField()); |
||||
}); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(7, reader.getFieldNumber()); |
||||
assertEquals(700, reader.readInt32()); |
||||
|
||||
assertEquals(false, reader.nextField()); |
||||
}); |
||||
|
||||
/** |
||||
* Tests skipping fields of each type by interleaving them with sentinel |
||||
* values and skipping everything that's not a sentinel. |
||||
*/ |
||||
it('testSkipField', function() { |
||||
var writer = new jspb.BinaryWriter(); |
||||
|
||||
var sentinel = 123456789; |
||||
|
||||
// Write varint fields of different sizes.
|
||||
writer.writeInt32(1, sentinel); |
||||
writer.writeInt32(1, 1); |
||||
writer.writeInt32(1, 1000); |
||||
writer.writeInt32(1, 1000000); |
||||
writer.writeInt32(1, 1000000000); |
||||
|
||||
// Write fixed 64-bit encoded fields.
|
||||
writer.writeInt32(2, sentinel); |
||||
writer.writeDouble(2, 1); |
||||
writer.writeFixed64(2, 1); |
||||
writer.writeSfixed64(2, 1); |
||||
|
||||
// Write fixed 32-bit encoded fields.
|
||||
writer.writeInt32(3, sentinel); |
||||
writer.writeFloat(3, 1); |
||||
writer.writeFixed32(3, 1); |
||||
writer.writeSfixed32(3, 1); |
||||
|
||||
// Write delimited fields.
|
||||
writer.writeInt32(4, sentinel); |
||||
writer.writeBytes(4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); |
||||
writer.writeString(4, 'The quick brown fox jumps over the lazy dog'); |
||||
|
||||
// Write a group with a nested group inside.
|
||||
writer.writeInt32(5, sentinel); |
||||
var dummyMessage = /** @type {!jspb.BinaryMessage} */({}); |
||||
writer.writeGroup(5, dummyMessage, function() { |
||||
writer.writeInt64(42, 42); |
||||
writer.writeGroup(6, dummyMessage, function() { |
||||
writer.writeInt64(84, 42); |
||||
}); |
||||
}); |
||||
|
||||
// Write final sentinel.
|
||||
writer.writeInt32(6, sentinel); |
||||
|
||||
var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); |
||||
|
||||
function skip(field, count) { |
||||
for (var i = 0; i < count; i++) { |
||||
reader.nextField(); |
||||
if (field != reader.getFieldNumber()) throw 'fail!'; |
||||
reader.skipField(); |
||||
} |
||||
} |
||||
|
||||
reader.nextField(); |
||||
assertEquals(1, reader.getFieldNumber()); |
||||
assertEquals(sentinel, reader.readInt32()); |
||||
skip(1, 4); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(2, reader.getFieldNumber()); |
||||
assertEquals(sentinel, reader.readInt32()); |
||||
skip(2, 3); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(3, reader.getFieldNumber()); |
||||
assertEquals(sentinel, reader.readInt32()); |
||||
skip(3, 3); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(4, reader.getFieldNumber()); |
||||
assertEquals(sentinel, reader.readInt32()); |
||||
skip(4, 2); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(5, reader.getFieldNumber()); |
||||
assertEquals(sentinel, reader.readInt32()); |
||||
skip(5, 1); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(6, reader.getFieldNumber()); |
||||
assertEquals(sentinel, reader.readInt32()); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests packed fields. |
||||
*/ |
||||
it('testPackedFields', function() { |
||||
var writer = new jspb.BinaryWriter(); |
||||
|
||||
var sentinel = 123456789; |
||||
|
||||
var unsignedData = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; |
||||
var signedData = [-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]; |
||||
var floatData = [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.10]; |
||||
var doubleData = [1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.10]; |
||||
var boolData = [true, false, true, true, false, false, true, false]; |
||||
|
||||
for (var i = 0; i < floatData.length; i++) { |
||||
floatData[i] = truncate(floatData[i]); |
||||
} |
||||
|
||||
writer.writeInt32(1, sentinel); |
||||
|
||||
writer.writePackedInt32(2, signedData); |
||||
writer.writePackedInt64(2, signedData); |
||||
writer.writePackedUint32(2, unsignedData); |
||||
writer.writePackedUint64(2, unsignedData); |
||||
writer.writePackedSint32(2, signedData); |
||||
writer.writePackedSint64(2, signedData); |
||||
writer.writePackedFixed32(2, unsignedData); |
||||
writer.writePackedFixed64(2, unsignedData); |
||||
writer.writePackedSfixed32(2, signedData); |
||||
writer.writePackedSfixed64(2, signedData); |
||||
writer.writePackedFloat(2, floatData); |
||||
writer.writePackedDouble(2, doubleData); |
||||
writer.writePackedBool(2, boolData); |
||||
writer.writePackedEnum(2, unsignedData); |
||||
|
||||
writer.writeInt32(3, sentinel); |
||||
|
||||
var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(sentinel, reader.readInt32()); |
||||
|
||||
reader.nextField(); |
||||
assertElementsEquals(reader.readPackedInt32(), signedData); |
||||
|
||||
reader.nextField(); |
||||
assertElementsEquals(reader.readPackedInt64(), signedData); |
||||
|
||||
reader.nextField(); |
||||
assertElementsEquals(reader.readPackedUint32(), unsignedData); |
||||
|
||||
reader.nextField(); |
||||
assertElementsEquals(reader.readPackedUint64(), unsignedData); |
||||
|
||||
reader.nextField(); |
||||
assertElementsEquals(reader.readPackedSint32(), signedData); |
||||
|
||||
reader.nextField(); |
||||
assertElementsEquals(reader.readPackedSint64(), signedData); |
||||
|
||||
reader.nextField(); |
||||
assertElementsEquals(reader.readPackedFixed32(), unsignedData); |
||||
|
||||
reader.nextField(); |
||||
assertElementsEquals(reader.readPackedFixed64(), unsignedData); |
||||
|
||||
reader.nextField(); |
||||
assertElementsEquals(reader.readPackedSfixed32(), signedData); |
||||
|
||||
reader.nextField(); |
||||
assertElementsEquals(reader.readPackedSfixed64(), signedData); |
||||
|
||||
reader.nextField(); |
||||
assertElementsEquals(reader.readPackedFloat(), floatData); |
||||
|
||||
reader.nextField(); |
||||
assertElementsEquals(reader.readPackedDouble(), doubleData); |
||||
|
||||
reader.nextField(); |
||||
assertElementsEquals(reader.readPackedBool(), boolData); |
||||
|
||||
reader.nextField(); |
||||
assertElementsEquals(reader.readPackedEnum(), unsignedData); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(sentinel, reader.readInt32()); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Byte blobs inside nested messages should always have their byte offset set |
||||
* relative to the start of the outermost blob, not the start of their parent |
||||
* blob. |
||||
*/ |
||||
it('testNestedBlobs', function() { |
||||
// Create a proto consisting of two nested messages, with the inner one
|
||||
// containing a blob of bytes.
|
||||
|
||||
var fieldTag = (1 << 3) | jspb.BinaryConstants.WireType.DELIMITED; |
||||
var blob = [1, 2, 3, 4, 5]; |
||||
var writer = new jspb.BinaryWriter(); |
||||
var dummyMessage = /** @type {!jspb.BinaryMessage} */({}); |
||||
|
||||
writer.writeMessage(1, dummyMessage, function() { |
||||
writer.writeMessage(1, dummyMessage, function() { |
||||
writer.writeBytes(1, blob); |
||||
}); |
||||
}); |
||||
|
||||
// Peel off the outer two message layers. Each layer should have two bytes
|
||||
// of overhead, one for the field tag and one for the length of the inner
|
||||
// blob.
|
||||
|
||||
var decoder1 = new jspb.BinaryDecoder(writer.getResultBuffer()); |
||||
assertEquals(fieldTag, decoder1.readUnsignedVarint32()); |
||||
assertEquals(blob.length + 4, decoder1.readUnsignedVarint32()); |
||||
|
||||
var decoder2 = new jspb.BinaryDecoder(decoder1.readBytes(blob.length + 4)); |
||||
assertEquals(fieldTag, decoder2.readUnsignedVarint32()); |
||||
assertEquals(blob.length + 2, decoder2.readUnsignedVarint32()); |
||||
|
||||
assertEquals(fieldTag, decoder2.readUnsignedVarint32()); |
||||
assertEquals(blob.length, decoder2.readUnsignedVarint32()); |
||||
var bytes = decoder2.readBytes(blob.length); |
||||
|
||||
assertElementsEquals(bytes, blob); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests read callbacks. |
||||
*/ |
||||
it('testReadCallbacks', function() { |
||||
var writer = new jspb.BinaryWriter(); |
||||
var dummyMessage = /** @type {!jspb.BinaryMessage} */({}); |
||||
|
||||
// Add an int, a submessage, and another int.
|
||||
writer.writeInt32(1, 100); |
||||
|
||||
writer.writeMessage(2, dummyMessage, function() { |
||||
writer.writeInt32(3, 300); |
||||
writer.writeInt32(4, 400); |
||||
writer.writeInt32(5, 500); |
||||
}); |
||||
|
||||
writer.writeInt32(7, 700); |
||||
|
||||
// Create the reader and register a custom read callback.
|
||||
var reader = jspb.BinaryReader.alloc(writer.getResultBuffer()); |
||||
|
||||
/** |
||||
* @param {!jspb.BinaryReader} reader |
||||
* @return {*} |
||||
*/ |
||||
function readCallback(reader) { |
||||
reader.nextField(); |
||||
assertEquals(3, reader.getFieldNumber()); |
||||
assertEquals(300, reader.readInt32()); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(4, reader.getFieldNumber()); |
||||
assertEquals(400, reader.readInt32()); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(5, reader.getFieldNumber()); |
||||
assertEquals(500, reader.readInt32()); |
||||
|
||||
assertEquals(false, reader.nextField()); |
||||
}; |
||||
|
||||
reader.registerReadCallback('readCallback', readCallback); |
||||
|
||||
// Read the container message.
|
||||
reader.nextField(); |
||||
assertEquals(1, reader.getFieldNumber()); |
||||
assertEquals(100, reader.readInt32()); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(2, reader.getFieldNumber()); |
||||
reader.readMessage(dummyMessage, function() { |
||||
// Decode the embedded message using the registered callback.
|
||||
reader.runReadCallback('readCallback'); |
||||
}); |
||||
|
||||
reader.nextField(); |
||||
assertEquals(7, reader.getFieldNumber()); |
||||
assertEquals(700, reader.readInt32()); |
||||
|
||||
assertEquals(false, reader.nextField()); |
||||
}); |
||||
}); |
@ -0,0 +1,668 @@ |
||||
// 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.
|
||||
|
||||
/** |
||||
* @fileoverview Test cases for jspb's helper functions. |
||||
* |
||||
* Test suite is written using Jasmine -- see http://jasmine.github.io/
|
||||
* |
||||
* @author aappleby@google.com (Austin Appleby) |
||||
*/ |
||||
|
||||
goog.require('goog.crypt.base64'); |
||||
goog.require('goog.testing.asserts'); |
||||
goog.require('jspb.BinaryConstants'); |
||||
goog.require('jspb.BinaryWriter'); |
||||
goog.require('jspb.utils'); |
||||
|
||||
|
||||
/** |
||||
* @param {number} x |
||||
* @return {number} |
||||
*/ |
||||
function truncate(x) { |
||||
var temp = new Float32Array(1); |
||||
temp[0] = x; |
||||
return temp[0]; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* Converts an 64-bit integer in split representation to a 64-bit hash string |
||||
* (8 bits encoded per character). |
||||
* @param {number} bitsLow The low 32 bits of the split 64-bit integer. |
||||
* @param {number} bitsHigh The high 32 bits of the split 64-bit integer. |
||||
* @return {string} The encoded hash string, 8 bits per character. |
||||
*/ |
||||
function toHashString(bitsLow, bitsHigh) { |
||||
return String.fromCharCode((bitsLow >>> 0) & 0xFF, |
||||
(bitsLow >>> 8) & 0xFF, |
||||
(bitsLow >>> 16) & 0xFF, |
||||
(bitsLow >>> 24) & 0xFF, |
||||
(bitsHigh >>> 0) & 0xFF, |
||||
(bitsHigh >>> 8) & 0xFF, |
||||
(bitsHigh >>> 16) & 0xFF, |
||||
(bitsHigh >>> 24) & 0xFF); |
||||
} |
||||
|
||||
|
||||
describe('binaryUtilsTest', function() { |
||||
/** |
||||
* Tests lossless binary-to-decimal conversion. |
||||
*/ |
||||
it('testDecimalConversion', function() { |
||||
// Check some magic numbers.
|
||||
var result = |
||||
jspb.utils.joinUnsignedDecimalString(0x89e80001, 0x8ac72304); |
||||
assertEquals('10000000000000000001', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0xacd05f15, 0x1b69b4b); |
||||
assertEquals('123456789123456789', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0xeb1f0ad2, 0xab54a98c); |
||||
assertEquals('12345678901234567890', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0xe3b70cb1, 0x891087b8); |
||||
assertEquals('9876543210987654321', result); |
||||
|
||||
// Check limits.
|
||||
result = jspb.utils.joinUnsignedDecimalString(0x00000000, 0x00000000); |
||||
assertEquals('0', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0xFFFFFFFF, 0xFFFFFFFF); |
||||
assertEquals('18446744073709551615', result); |
||||
|
||||
// Check each bit of the low dword.
|
||||
for (var i = 0; i < 32; i++) { |
||||
var low = (1 << i) >>> 0; |
||||
result = jspb.utils.joinUnsignedDecimalString(low, 0); |
||||
assertEquals('' + Math.pow(2, i), result); |
||||
} |
||||
|
||||
// Check the first 20 bits of the high dword.
|
||||
for (var i = 0; i < 20; i++) { |
||||
var high = (1 << i) >>> 0; |
||||
result = jspb.utils.joinUnsignedDecimalString(0, high); |
||||
assertEquals('' + Math.pow(2, 32 + i), result); |
||||
} |
||||
|
||||
// V8's internal double-to-string conversion is inaccurate for values above
|
||||
// 2^52, even if they're representable integers - check the rest of the bits
|
||||
// manually against the correct string representations of 2^N.
|
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0x00000000, 0x00100000); |
||||
assertEquals('4503599627370496', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0x00000000, 0x00200000); |
||||
assertEquals('9007199254740992', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0x00000000, 0x00400000); |
||||
assertEquals('18014398509481984', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0x00000000, 0x00800000); |
||||
assertEquals('36028797018963968', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0x00000000, 0x01000000); |
||||
assertEquals('72057594037927936', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0x00000000, 0x02000000); |
||||
assertEquals('144115188075855872', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0x00000000, 0x04000000); |
||||
assertEquals('288230376151711744', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0x00000000, 0x08000000); |
||||
assertEquals('576460752303423488', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0x00000000, 0x10000000); |
||||
assertEquals('1152921504606846976', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0x00000000, 0x20000000); |
||||
assertEquals('2305843009213693952', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0x00000000, 0x40000000); |
||||
assertEquals('4611686018427387904', result); |
||||
|
||||
result = jspb.utils.joinUnsignedDecimalString(0x00000000, 0x80000000); |
||||
assertEquals('9223372036854775808', result); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Going from hash strings to decimal strings should also be lossless. |
||||
*/ |
||||
it('testHashToDecimalConversion', function() { |
||||
var result; |
||||
var convert = jspb.utils.hash64ToDecimalString; |
||||
|
||||
result = convert(toHashString(0x00000000, 0x00000000), false); |
||||
assertEquals('0', result); |
||||
|
||||
result = convert(toHashString(0x00000000, 0x00000000), true); |
||||
assertEquals('0', result); |
||||
|
||||
result = convert(toHashString(0xFFFFFFFF, 0xFFFFFFFF), false); |
||||
assertEquals('18446744073709551615', result); |
||||
|
||||
result = convert(toHashString(0xFFFFFFFF, 0xFFFFFFFF), true); |
||||
assertEquals('-1', result); |
||||
|
||||
result = convert(toHashString(0x00000000, 0x80000000), false); |
||||
assertEquals('9223372036854775808', result); |
||||
|
||||
result = convert(toHashString(0x00000000, 0x80000000), true); |
||||
assertEquals('-9223372036854775808', result); |
||||
|
||||
result = convert(toHashString(0xacd05f15, 0x01b69b4b), false); |
||||
assertEquals('123456789123456789', result); |
||||
|
||||
result = convert(toHashString(~0xacd05f15 + 1, ~0x01b69b4b), true); |
||||
assertEquals('-123456789123456789', result); |
||||
|
||||
// And converting arrays of hashes should work the same way.
|
||||
result = jspb.utils.hash64ArrayToDecimalStrings([ |
||||
toHashString(0xFFFFFFFF, 0xFFFFFFFF), |
||||
toHashString(0x00000000, 0x80000000), |
||||
toHashString(0xacd05f15, 0x01b69b4b)], false); |
||||
assertEquals(3, result.length); |
||||
assertEquals('18446744073709551615', result[0]); |
||||
assertEquals('9223372036854775808', result[1]); |
||||
assertEquals('123456789123456789', result[2]); |
||||
}); |
||||
|
||||
/* |
||||
* Going from decimal strings to hash strings should be lossless. |
||||
*/ |
||||
it('testDecimalToHashConversion', function() { |
||||
var result; |
||||
var convert = jspb.utils.decimalStringToHash64; |
||||
|
||||
result = convert('0'); |
||||
assertEquals(String.fromCharCode.apply(null, |
||||
[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]), result); |
||||
|
||||
result = convert('-1'); |
||||
assertEquals(String.fromCharCode.apply(null, |
||||
[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]), result); |
||||
|
||||
result = convert('18446744073709551615'); |
||||
assertEquals(String.fromCharCode.apply(null, |
||||
[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]), result); |
||||
|
||||
result = convert('9223372036854775808'); |
||||
assertEquals(String.fromCharCode.apply(null, |
||||
[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80]), result); |
||||
|
||||
result = convert('-9223372036854775808'); |
||||
assertEquals(String.fromCharCode.apply(null, |
||||
[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80]), result); |
||||
|
||||
result = convert('123456789123456789'); |
||||
assertEquals(String.fromCharCode.apply(null, |
||||
[0x15, 0x5F, 0xD0, 0xAC, 0x4B, 0x9B, 0xB6, 0x01]), result); |
||||
|
||||
result = convert('-123456789123456789'); |
||||
assertEquals(String.fromCharCode.apply(null, |
||||
[0xEB, 0xA0, 0x2F, 0x53, 0xB4, 0x64, 0x49, 0xFE]), result); |
||||
}); |
||||
|
||||
/** |
||||
* Going from hash strings to hex strings should be lossless. |
||||
*/ |
||||
it('testHashToHexConversion', function() { |
||||
var result; |
||||
var convert = jspb.utils.hash64ToHexString; |
||||
|
||||
result = convert(toHashString(0x00000000, 0x00000000)); |
||||
assertEquals('0x0000000000000000', result); |
||||
|
||||
result = convert(toHashString(0xFFFFFFFF, 0xFFFFFFFF)); |
||||
assertEquals('0xffffffffffffffff', result); |
||||
|
||||
result = convert(toHashString(0x12345678, 0x9ABCDEF0)); |
||||
assertEquals('0x9abcdef012345678', result); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Going from hex strings to hash strings should be lossless. |
||||
*/ |
||||
it('testHexToHashConversion', function() { |
||||
var result; |
||||
var convert = jspb.utils.hexStringToHash64; |
||||
|
||||
result = convert('0x0000000000000000'); |
||||
assertEquals(String.fromCharCode.apply(null, |
||||
[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]), result); |
||||
|
||||
result = convert('0xffffffffffffffff'); |
||||
assertEquals(String.fromCharCode.apply(null, |
||||
[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]), result); |
||||
|
||||
// Hex string is big-endian, hash string is little-endian.
|
||||
result = convert('0x123456789ABCDEF0'); |
||||
assertEquals(String.fromCharCode.apply(null, |
||||
[0xF0, 0xDE, 0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12]), result); |
||||
|
||||
// Capitalization should not matter.
|
||||
result = convert('0x0000abcdefABCDEF'); |
||||
assertEquals(String.fromCharCode.apply(null, |
||||
[0xEF, 0xCD, 0xAB, 0xEF, 0xCD, 0xAB, 0x00, 0x00]), result); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Going from numbers to hash strings should be lossless for up to 53 bits of |
||||
* precision. |
||||
*/ |
||||
it('testNumberToHashConversion', function() { |
||||
var result; |
||||
var convert = jspb.utils.numberToHash64; |
||||
|
||||
result = convert(0x0000000000000); |
||||
assertEquals('0x0000000000000000', jspb.utils.hash64ToHexString(result)); |
||||
|
||||
result = convert(0xFFFFFFFFFFFFF); |
||||
assertEquals('0x000fffffffffffff', jspb.utils.hash64ToHexString(result)); |
||||
|
||||
result = convert(0x123456789ABCD); |
||||
assertEquals('0x000123456789abcd', jspb.utils.hash64ToHexString(result)); |
||||
|
||||
result = convert(0xDCBA987654321); |
||||
assertEquals('0x000dcba987654321', jspb.utils.hash64ToHexString(result)); |
||||
|
||||
// 53 bits of precision should not be truncated.
|
||||
result = convert(0x10000000000001); |
||||
assertEquals('0x0010000000000001', jspb.utils.hash64ToHexString(result)); |
||||
|
||||
// 54 bits of precision should be truncated.
|
||||
result = convert(0x20000000000001); |
||||
assertNotEquals( |
||||
'0x0020000000000001', jspb.utils.hash64ToHexString(result)); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Sanity check the behavior of Javascript's strings when doing funny things |
||||
* with unicode characters. |
||||
*/ |
||||
it('sanityCheckUnicodeStrings', function() { |
||||
var strings = new Array(65536); |
||||
|
||||
// All possible unsigned 16-bit values should be storable in a string, they
|
||||
// shouldn't do weird things with the length of the string, and they should
|
||||
// come back out of the string unchanged.
|
||||
for (var i = 0; i < 65536; i++) { |
||||
strings[i] = 'a' + String.fromCharCode(i) + 'a'; |
||||
if (3 != strings[i].length) throw 'fail!'; |
||||
if (i != strings[i].charCodeAt(1)) throw 'fail!'; |
||||
} |
||||
|
||||
// Each unicode character should compare equal to itself and not equal to a
|
||||
// different unicode character.
|
||||
for (var i = 0; i < 65536; i++) { |
||||
if (strings[i] != strings[i]) throw 'fail!'; |
||||
if (strings[i] == strings[(i + 1) % 65536]) throw 'fail!'; |
||||
} |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests conversion from 32-bit floating point numbers to split64 numbers. |
||||
*/ |
||||
it('testFloat32ToSplit64', function() { |
||||
var f32_eps = jspb.BinaryConstants.FLOAT32_EPS; |
||||
var f32_min = jspb.BinaryConstants.FLOAT32_MIN; |
||||
var f32_max = jspb.BinaryConstants.FLOAT32_MAX; |
||||
|
||||
// NaN.
|
||||
jspb.utils.splitFloat32(NaN); |
||||
if (!isNaN(jspb.utils.joinFloat32(jspb.utils.split64Low, |
||||
jspb.utils.split64High))) { |
||||
throw 'fail!'; |
||||
} |
||||
|
||||
/** |
||||
* @param {number} x |
||||
* @param {number=} opt_bits |
||||
*/ |
||||
function test(x, opt_bits) { |
||||
jspb.utils.splitFloat32(x); |
||||
if (goog.isDef(opt_bits)) { |
||||
if (opt_bits != jspb.utils.split64Low) throw 'fail!'; |
||||
} |
||||
if (truncate(x) != jspb.utils.joinFloat32(jspb.utils.split64Low, |
||||
jspb.utils.split64High)) { |
||||
throw 'fail!'; |
||||
} |
||||
} |
||||
|
||||
// Positive and negative infinity.
|
||||
test(Infinity, 0x7f800000); |
||||
test(-Infinity, 0xff800000); |
||||
|
||||
// Positive and negative zero.
|
||||
test(0, 0x00000000); |
||||
test(-0, 0x80000000); |
||||
|
||||
// Positive and negative epsilon.
|
||||
test(f32_eps, 0x00000001); |
||||
test(-f32_eps, 0x80000001); |
||||
|
||||
// Positive and negative min.
|
||||
test(f32_min, 0x00800000); |
||||
test(-f32_min, 0x80800000); |
||||
|
||||
// Positive and negative max.
|
||||
test(f32_max, 0x7F7FFFFF); |
||||
test(-f32_max, 0xFF7FFFFF); |
||||
|
||||
// Various positive values.
|
||||
var cursor = f32_eps * 10; |
||||
while (cursor != Infinity) { |
||||
test(cursor); |
||||
cursor *= 1.1; |
||||
} |
||||
|
||||
// Various negative values.
|
||||
cursor = -f32_eps * 10; |
||||
while (cursor != -Infinity) { |
||||
test(cursor); |
||||
cursor *= 1.1; |
||||
} |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests conversion from 64-bit floating point numbers to split64 numbers. |
||||
*/ |
||||
it('testFloat64ToSplit64', function() { |
||||
var f64_eps = jspb.BinaryConstants.FLOAT64_EPS; |
||||
var f64_min = jspb.BinaryConstants.FLOAT64_MIN; |
||||
var f64_max = jspb.BinaryConstants.FLOAT64_MAX; |
||||
|
||||
// NaN.
|
||||
jspb.utils.splitFloat64(NaN); |
||||
if (!isNaN(jspb.utils.joinFloat64(jspb.utils.split64Low, |
||||
jspb.utils.split64High))) { |
||||
throw 'fail!'; |
||||
} |
||||
|
||||
/** |
||||
* @param {number} x |
||||
* @param {number=} opt_highBits |
||||
* @param {number=} opt_lowBits |
||||
*/ |
||||
function test(x, opt_highBits, opt_lowBits) { |
||||
jspb.utils.splitFloat64(x); |
||||
if (goog.isDef(opt_highBits)) { |
||||
if (opt_highBits != jspb.utils.split64High) throw 'fail!'; |
||||
} |
||||
if (goog.isDef(opt_lowBits)) { |
||||
if (opt_lowBits != jspb.utils.split64Low) throw 'fail!'; |
||||
} |
||||
if (x != jspb.utils.joinFloat64(jspb.utils.split64Low, |
||||
jspb.utils.split64High)) { |
||||
throw 'fail!'; |
||||
} |
||||
} |
||||
|
||||
// Positive and negative infinity.
|
||||
test(Infinity, 0x7ff00000, 0x00000000); |
||||
test(-Infinity, 0xfff00000, 0x00000000); |
||||
|
||||
// Positive and negative zero.
|
||||
test(0, 0x00000000, 0x00000000); |
||||
test(-0, 0x80000000, 0x00000000); |
||||
|
||||
// Positive and negative epsilon.
|
||||
test(f64_eps, 0x00000000, 0x00000001); |
||||
test(-f64_eps, 0x80000000, 0x00000001); |
||||
|
||||
// Positive and negative min.
|
||||
test(f64_min, 0x00100000, 0x00000000); |
||||
test(-f64_min, 0x80100000, 0x00000000); |
||||
|
||||
// Positive and negative max.
|
||||
test(f64_max, 0x7FEFFFFF, 0xFFFFFFFF); |
||||
test(-f64_max, 0xFFEFFFFF, 0xFFFFFFFF); |
||||
|
||||
// Various positive values.
|
||||
var cursor = f64_eps * 10; |
||||
while (cursor != Infinity) { |
||||
test(cursor); |
||||
cursor *= 1.1; |
||||
} |
||||
|
||||
// Various negative values.
|
||||
cursor = -f64_eps * 10; |
||||
while (cursor != -Infinity) { |
||||
test(cursor); |
||||
cursor *= 1.1; |
||||
} |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests counting packed varints. |
||||
*/ |
||||
it('testCountVarints', function() { |
||||
var values = []; |
||||
for (var i = 1; i < 1000000000; i *= 1.1) { |
||||
values.push(Math.floor(i)); |
||||
} |
||||
|
||||
var writer = new jspb.BinaryWriter(); |
||||
writer.writePackedUint64(1, values); |
||||
|
||||
var buffer = new Uint8Array(writer.getResultBuffer()); |
||||
|
||||
// We should have two more varints than we started with - one for the field
|
||||
// tag, one for the packed length.
|
||||
assertEquals(values.length + 2, |
||||
jspb.utils.countVarints(buffer, 0, buffer.length)); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests counting matching varint fields. |
||||
*/ |
||||
it('testCountVarintFields', function() { |
||||
var writer = new jspb.BinaryWriter(); |
||||
|
||||
var count = 0; |
||||
for (var i = 1; i < 1000000000; i *= 1.1) { |
||||
writer.writeUint64(1, Math.floor(i)); |
||||
count++; |
||||
} |
||||
writer.writeString(2, 'terminator'); |
||||
|
||||
var buffer = new Uint8Array(writer.getResultBuffer()); |
||||
assertEquals(count, |
||||
jspb.utils.countVarintFields(buffer, 0, buffer.length, 1)); |
||||
|
||||
writer = new jspb.BinaryWriter(); |
||||
|
||||
count = 0; |
||||
for (var i = 1; i < 1000000000; i *= 1.1) { |
||||
writer.writeUint64(123456789, Math.floor(i)); |
||||
count++; |
||||
} |
||||
writer.writeString(2, 'terminator'); |
||||
|
||||
buffer = new Uint8Array(writer.getResultBuffer()); |
||||
assertEquals(count, |
||||
jspb.utils.countVarintFields(buffer, 0, buffer.length, 123456789)); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests counting matching fixed32 fields. |
||||
*/ |
||||
it('testCountFixed32Fields', function() { |
||||
var writer = new jspb.BinaryWriter(); |
||||
|
||||
var count = 0; |
||||
for (var i = 1; i < 1000000000; i *= 1.1) { |
||||
writer.writeFixed32(1, Math.floor(i)); |
||||
count++; |
||||
} |
||||
writer.writeString(2, 'terminator'); |
||||
|
||||
var buffer = new Uint8Array(writer.getResultBuffer()); |
||||
assertEquals(count, |
||||
jspb.utils.countFixed32Fields(buffer, 0, buffer.length, 1)); |
||||
|
||||
writer = new jspb.BinaryWriter(); |
||||
|
||||
count = 0; |
||||
for (var i = 1; i < 1000000000; i *= 1.1) { |
||||
writer.writeFixed32(123456789, Math.floor(i)); |
||||
count++; |
||||
} |
||||
writer.writeString(2, 'terminator'); |
||||
|
||||
buffer = new Uint8Array(writer.getResultBuffer()); |
||||
assertEquals(count, |
||||
jspb.utils.countFixed32Fields(buffer, 0, buffer.length, 123456789)); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests counting matching fixed64 fields. |
||||
*/ |
||||
it('testCountFixed64Fields', function() { |
||||
var writer = new jspb.BinaryWriter(); |
||||
|
||||
var count = 0; |
||||
for (var i = 1; i < 1000000000; i *= 1.1) { |
||||
writer.writeDouble(1, i); |
||||
count++; |
||||
} |
||||
writer.writeString(2, 'terminator'); |
||||
|
||||
var buffer = new Uint8Array(writer.getResultBuffer()); |
||||
assertEquals(count, |
||||
jspb.utils.countFixed64Fields(buffer, 0, buffer.length, 1)); |
||||
|
||||
writer = new jspb.BinaryWriter(); |
||||
|
||||
count = 0; |
||||
for (var i = 1; i < 1000000000; i *= 1.1) { |
||||
writer.writeDouble(123456789, i); |
||||
count++; |
||||
} |
||||
writer.writeString(2, 'terminator'); |
||||
|
||||
buffer = new Uint8Array(writer.getResultBuffer()); |
||||
assertEquals(count, |
||||
jspb.utils.countFixed64Fields(buffer, 0, buffer.length, 123456789)); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests counting matching delimited fields. |
||||
*/ |
||||
it('testCountDelimitedFields', function() { |
||||
var writer = new jspb.BinaryWriter(); |
||||
|
||||
var count = 0; |
||||
for (var i = 1; i < 1000; i *= 1.1) { |
||||
writer.writeBytes(1, [Math.floor(i)]); |
||||
count++; |
||||
} |
||||
writer.writeString(2, 'terminator'); |
||||
|
||||
var buffer = new Uint8Array(writer.getResultBuffer()); |
||||
assertEquals(count, |
||||
jspb.utils.countDelimitedFields(buffer, 0, buffer.length, 1)); |
||||
|
||||
writer = new jspb.BinaryWriter(); |
||||
|
||||
count = 0; |
||||
for (var i = 1; i < 1000; i *= 1.1) { |
||||
writer.writeBytes(123456789, [Math.floor(i)]); |
||||
count++; |
||||
} |
||||
writer.writeString(2, 'terminator'); |
||||
|
||||
buffer = new Uint8Array(writer.getResultBuffer()); |
||||
assertEquals(count, |
||||
jspb.utils.countDelimitedFields(buffer, 0, buffer.length, 123456789)); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests byte format for debug strings. |
||||
*/ |
||||
it('testDebugBytesToTextFormat', function() { |
||||
assertEquals('""', jspb.utils.debugBytesToTextFormat(null)); |
||||
assertEquals('"\\x00\\x10\\xff"', |
||||
jspb.utils.debugBytesToTextFormat([0, 16, 255])); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Tests converting byte blob sources into byte blobs. |
||||
*/ |
||||
it('testByteSourceToUint8Array', function() { |
||||
var convert = jspb.utils.byteSourceToUint8Array; |
||||
|
||||
var sourceData = []; |
||||
for (var i = 0; i < 256; i++) { |
||||
sourceData.push(i); |
||||
} |
||||
|
||||
var sourceBytes = new Uint8Array(sourceData); |
||||
var sourceBuffer = sourceBytes.buffer; |
||||
var sourceBase64 = goog.crypt.base64.encodeByteArray(sourceData); |
||||
var sourceString = String.fromCharCode.apply(null, sourceData); |
||||
|
||||
function check(result) { |
||||
assertEquals(Uint8Array, result.constructor); |
||||
assertEquals(sourceData.length, result.length); |
||||
for (var i = 0; i < result.length; i++) { |
||||
assertEquals(sourceData[i], result[i]); |
||||
} |
||||
} |
||||
|
||||
// Converting Uint8Arrays into Uint8Arrays should be a no-op.
|
||||
assertEquals(sourceBytes, convert(sourceBytes)); |
||||
|
||||
// Converting Array.<numbers> into Uint8Arrays should work.
|
||||
check(convert(sourceData)); |
||||
|
||||
// Converting ArrayBuffers into Uint8Arrays should work.
|
||||
check(convert(sourceBuffer)); |
||||
|
||||
// Converting base64-encoded strings into Uint8Arrays should work.
|
||||
check(convert(sourceBase64)); |
||||
}); |
||||
}); |
@ -0,0 +1,122 @@ |
||||
// 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.
|
||||
|
||||
/** |
||||
* @fileoverview Test cases for jspb's binary protocol buffer writer. In |
||||
* practice BinaryWriter is used to drive the Decoder and Reader test cases, |
||||
* so only writer-specific tests are here. |
||||
* |
||||
* Test suite is written using Jasmine -- see http://jasmine.github.io/
|
||||
* |
||||
* @author aappleby@google.com (Austin Appleby) |
||||
*/ |
||||
|
||||
goog.require('goog.crypt'); |
||||
goog.require('goog.testing.asserts'); |
||||
goog.require('jspb.BinaryWriter'); |
||||
|
||||
|
||||
/** |
||||
* @param {function()} func This function should throw an error when run. |
||||
*/ |
||||
function assertFails(func) { |
||||
var e = assertThrows(func); |
||||
//assertNotNull(e.toString().match(/Error/));
|
||||
} |
||||
|
||||
|
||||
describe('binaryWriterTest', function() { |
||||
/** |
||||
* Verifies that misuse of the writer class triggers assertions. |
||||
*/ |
||||
it('testWriteErrors', function() { |
||||
// Submessages with invalid field indices should assert.
|
||||
var writer = new jspb.BinaryWriter(); |
||||
var dummyMessage = /** @type {!jspb.BinaryMessage} */({}); |
||||
|
||||
assertFails(function() { |
||||
writer.writeMessage(-1, dummyMessage, goog.nullFunction); |
||||
}); |
||||
|
||||
// Writing invalid field indices should assert.
|
||||
writer = new jspb.BinaryWriter(); |
||||
assertFails(function() {writer.writeUint64(-1, 1);}); |
||||
|
||||
// Writing out-of-range field values should assert.
|
||||
writer = new jspb.BinaryWriter(); |
||||
|
||||
assertFails(function() {writer.writeInt32(1, -Infinity);}); |
||||
assertFails(function() {writer.writeInt32(1, Infinity);}); |
||||
|
||||
assertFails(function() {writer.writeInt64(1, -Infinity);}); |
||||
assertFails(function() {writer.writeInt64(1, Infinity);}); |
||||
|
||||
assertFails(function() {writer.writeUint32(1, -1);}); |
||||
assertFails(function() {writer.writeUint32(1, Infinity);}); |
||||
|
||||
assertFails(function() {writer.writeUint64(1, -1);}); |
||||
assertFails(function() {writer.writeUint64(1, Infinity);}); |
||||
|
||||
assertFails(function() {writer.writeSint32(1, -Infinity);}); |
||||
assertFails(function() {writer.writeSint32(1, Infinity);}); |
||||
|
||||
assertFails(function() {writer.writeSint64(1, -Infinity);}); |
||||
assertFails(function() {writer.writeSint64(1, Infinity);}); |
||||
|
||||
assertFails(function() {writer.writeFixed32(1, -1);}); |
||||
assertFails(function() {writer.writeFixed32(1, Infinity);}); |
||||
|
||||
assertFails(function() {writer.writeFixed64(1, -1);}); |
||||
assertFails(function() {writer.writeFixed64(1, Infinity);}); |
||||
|
||||
assertFails(function() {writer.writeSfixed32(1, -Infinity);}); |
||||
assertFails(function() {writer.writeSfixed32(1, Infinity);}); |
||||
|
||||
assertFails(function() {writer.writeSfixed64(1, -Infinity);}); |
||||
assertFails(function() {writer.writeSfixed64(1, Infinity);}); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Basic test of retrieving the result as a Uint8Array buffer |
||||
*/ |
||||
it('testGetResultBuffer', function() { |
||||
var expected = '0864120b48656c6c6f20776f726c641a0301020320c801'; |
||||
|
||||
var writer = new jspb.BinaryWriter(); |
||||
writer.writeUint32(1, 100); |
||||
writer.writeString(2, 'Hello world'); |
||||
writer.writeBytes(3, new Uint8Array([1, 2, 3])); |
||||
writer.writeUint32(4, 200); |
||||
|
||||
var buffer = writer.getResultBuffer(); |
||||
assertEquals(expected, goog.crypt.byteArrayToHex(buffer)); |
||||
}); |
||||
}); |
@ -0,0 +1,37 @@ |
||||
/** |
||||
* @fileoverview Exports symbols needed only by tests. |
||||
* |
||||
* This file exports several Closure Library symbols that are only |
||||
* used by tests. It is used to generate a file |
||||
* closure_asserts_commonjs.js that is only used at testing time. |
||||
*/ |
||||
|
||||
goog.require('goog.testing.asserts'); |
||||
|
||||
var global = Function('return this')(); |
||||
|
||||
// All of the closure "assert" functions are exported at the global level.
|
||||
//
|
||||
// The Google Closure assert functions start with assert, eg.
|
||||
// assertThrows
|
||||
// assertNotThrows
|
||||
// assertTrue
|
||||
// ...
|
||||
//
|
||||
// The one exception is the "fail" function.
|
||||
function shouldExport(str) { |
||||
return str.lastIndexOf('assert') === 0 || str == 'fail'; |
||||
} |
||||
|
||||
for (var key in global) { |
||||
if ((typeof key == "string") && global.hasOwnProperty(key) && |
||||
shouldExport(key)) { |
||||
exports[key] = global[key]; |
||||
} |
||||
} |
||||
|
||||
// The COMPILED variable is set by Closure compiler to "true" when it compiles
|
||||
// JavaScript, so in practice this is equivalent to "exports.COMPILED = true".
|
||||
// This will disable some debugging functionality in debug.js. We could
|
||||
// investigate whether this can/should be enabled in CommonJS builds.
|
||||
exports.COMPILED = COMPILED |
@ -0,0 +1,18 @@ |
||||
/** |
||||
* @fileoverview Export symbols needed by tests in CommonJS style. |
||||
* |
||||
* This file is like export.js, but for symbols that are only used by tests. |
||||
* However we exclude assert functions here, because they are exported into |
||||
* the global namespace, so those are handled as a special case in |
||||
* export_asserts.js. |
||||
*/ |
||||
|
||||
goog.require('goog.crypt.base64'); |
||||
goog.require('jspb.arith.Int64'); |
||||
goog.require('jspb.arith.UInt64'); |
||||
goog.require('jspb.BinaryEncoder'); |
||||
goog.require('jspb.BinaryDecoder'); |
||||
goog.require('jspb.utils'); |
||||
|
||||
exports.goog = goog; |
||||
exports.jspb = jspb; |
@ -0,0 +1,52 @@ |
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2016 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/
|
||||
|
||||
|
||||
|
||||
var googleProtobuf = require('google-protobuf'); |
||||
var asserts = require('closure_asserts_commonjs'); |
||||
var global = Function('return this')(); |
||||
|
||||
// Bring asserts into the global namespace.
|
||||
googleProtobuf.object.extend(global, asserts); |
||||
googleProtobuf.exportSymbol('jspb.Message', googleProtobuf.Message, global); |
||||
|
||||
var test7_pb = require('./test7/test7_pb'); |
||||
googleProtobuf.exportSymbol('proto.jspb.test.framing.FramingMessage', test7_pb.FramingMessage, global); |
||||
|
||||
describe('Import test suite', function() { |
||||
it('testImportedMessage', function() { |
||||
var framing1 = new proto.jspb.test.framing.FramingMessage([]); |
||||
var framing2 = new proto.jspb.test.framing.FramingMessage([]); |
||||
assertObjectEquals(framing1.toObject(), framing2.toObject()); |
||||
}); |
||||
}); |
@ -0,0 +1,9 @@ |
||||
{ |
||||
"spec_dir": "", |
||||
"spec_files": [ |
||||
"*_test.js", |
||||
"binary/proto_test.js" |
||||
], |
||||
"helpers": [ |
||||
] |
||||
} |
@ -0,0 +1,97 @@ |
||||
/** |
||||
* @fileoverview Utility to translate test files to CommonJS imports. |
||||
* |
||||
* This is a somewhat hacky tool designed to do one very specific thing. |
||||
* All of the test files in *_test.js are written with Closure-style |
||||
* imports (goog.require()). This works great for running the tests |
||||
* against Closure-style generated code, but we also want to run the |
||||
* tests against CommonJS-style generated code without having to fork |
||||
* the tests. |
||||
* |
||||
* Closure-style imports import each individual type by name. This is |
||||
* very different than CommonJS imports which are by file. So we put |
||||
* special comments in these tests like: |
||||
* |
||||
* // CommonJS-LoadFromFile: test_pb
|
||||
* goog.require('proto.jspb.test.CloneExtension'); |
||||
* goog.require('proto.jspb.test.Complex'); |
||||
* goog.require('proto.jspb.test.DefaultValues'); |
||||
* |
||||
* This script parses that special comment and uses it to generate proper |
||||
* CommonJS require() statements so that the tests can run and pass using |
||||
* CommonJS imports. The script will change the above statements into: |
||||
* |
||||
* var test_pb = require('test_pb'); |
||||
* googleProtobuf.exportSymbol('proto.jspb.test.CloneExtension', test_pb.CloneExtension, global); |
||||
* googleProtobuf.exportSymbol('proto.jspb.test.Complex', test_pb.Complex, global); |
||||
* googleProtobuf.exportSymbol('proto.jspb.test.DefaultValues', test_pb.DefaultValues, global); |
||||
* |
||||
* (The "exportSymbol" function will define the given names in the global |
||||
* namespace, taking care not to overwrite any previous value for |
||||
* "proto.jspb.test"). |
||||
*/ |
||||
|
||||
var lineReader = require('readline').createInterface({ |
||||
input: process.stdin, |
||||
output: process.stdout |
||||
}); |
||||
|
||||
function tryStripPrefix(str, prefix) { |
||||
if (str.lastIndexOf(prefix) !== 0) { |
||||
throw "String: " + str + " didn't start with: " + prefix; |
||||
} |
||||
return str.substr(prefix.length); |
||||
} |
||||
|
||||
function camelCase(str) { |
||||
var ret = ''; |
||||
var ucaseNext = false; |
||||
for (var i = 0; i < str.length; i++) { |
||||
if (str[i] == '-') { |
||||
ucaseNext = true; |
||||
} else if (ucaseNext) { |
||||
ret += str[i].toUpperCase(); |
||||
ucaseNext = false; |
||||
} else { |
||||
ret += str[i]; |
||||
} |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
var module = null; |
||||
var pkg = null; |
||||
|
||||
// Header: goes in every file at the top.
|
||||
console.log("var global = Function('return this')();"); |
||||
console.log("var googleProtobuf = require('google-protobuf');"); |
||||
console.log("var testdeps = require('testdeps_commonjs');"); |
||||
console.log("global.goog = testdeps.goog;"); |
||||
console.log("global.jspb = testdeps.jspb;"); |
||||
console.log("var asserts = require('closure_asserts_commonjs');"); |
||||
console.log(""); |
||||
console.log("// Bring asserts into the global namespace."); |
||||
console.log("googleProtobuf.object.extend(global, asserts);"); |
||||
|
||||
lineReader.on('line', function(line) { |
||||
var isRequire = line.match(/goog\.require\('([^']*)'\)/); |
||||
var isLoadFromFile = line.match(/CommonJS-LoadFromFile: (\S*) (.*)/); |
||||
var isSetTestOnly = line.match(/goog.setTestOnly()/); |
||||
if (isRequire) { |
||||
if (module) { // Skip goog.require() lines before the first directive.
|
||||
var fullSym = isRequire[1]; |
||||
var sym = tryStripPrefix(fullSym, pkg); |
||||
console.log("googleProtobuf.exportSymbol('" + fullSym + "', " + module + sym + ', global);'); |
||||
} |
||||
} else if (isLoadFromFile) { |
||||
var module_path = isLoadFromFile[1].split('/'); |
||||
module = camelCase(module_path[module_path.length - 1]); |
||||
pkg = isLoadFromFile[2]; |
||||
|
||||
if (module != "googleProtobuf") { // We unconditionally require this in the header.
|
||||
console.log("var " + module + " = require('./" + isLoadFromFile[1] + "');"); |
||||
} |
||||
} else if (!isSetTestOnly) { // Remove goog.setTestOnly() lines.
|
||||
console.log(line); |
||||
} |
||||
}); |
@ -0,0 +1,40 @@ |
||||
// Protocol Buffers - Google's data interchange format |
||||
// Copyright 2016 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. |
||||
|
||||
syntax = "proto3"; |
||||
|
||||
option java_package = "com.google.apps.jspb.proto"; |
||||
option java_multiple_files = true; |
||||
|
||||
package jspb.test.importing; |
||||
|
||||
message ImportedMessage { |
||||
string string_value = 1; |
||||
} |
@ -0,0 +1,42 @@ |
||||
// Protocol Buffers - Google's data interchange format |
||||
// Copyright 2016 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. |
||||
|
||||
syntax = "proto3"; |
||||
|
||||
option java_package = "com.google.apps.jspb.proto"; |
||||
option java_multiple_files = true; |
||||
|
||||
package jspb.test.framing; |
||||
|
||||
import "test6/test6.proto"; |
||||
|
||||
message FramingMessage { |
||||
jspb.test.importing.ImportedMessage imported_message = 1; |
||||
} |
@ -0,0 +1,51 @@ |
||||
// 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. |
||||
|
||||
// Author: mwr@google.com (Mark Rawling) |
||||
|
||||
syntax = "proto2"; |
||||
|
||||
option java_package = "com.google.apps.jspb.proto"; |
||||
option java_multiple_files = true; |
||||
|
||||
package jspb.test; |
||||
|
||||
// legacy data, must be nested |
||||
message data { |
||||
message NestedData { |
||||
required string str = 1; |
||||
} |
||||
} |
||||
|
||||
// new data, does not require nesting |
||||
message UnnestedData { |
||||
required string str = 1; |
||||
} |
||||
|
@ -0,0 +1,105 @@ |
||||
// 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.
|
||||
|
||||
goog.setTestOnly(); |
||||
|
||||
goog.require('goog.testing.asserts'); |
||||
|
||||
// CommonJS-LoadFromFile: google-protobuf
|
||||
goog.require('jspb.debug'); |
||||
|
||||
// CommonJS-LoadFromFile: test_pb
|
||||
goog.require('proto.jspb.test.HasExtensions'); |
||||
goog.require('proto.jspb.test.IsExtension'); |
||||
goog.require('proto.jspb.test.Simple1'); |
||||
|
||||
|
||||
|
||||
describe('debugTest', function() { |
||||
it('testSimple1', function() { |
||||
if (COMPILED) { |
||||
return; |
||||
} |
||||
var message = new proto.jspb.test.Simple1(); |
||||
message.setAString('foo'); |
||||
assertObjectEquals({ |
||||
$name: 'proto.jspb.test.Simple1', |
||||
'aString': 'foo', |
||||
'aRepeatedStringList': [] |
||||
}, jspb.debug.dump(message)); |
||||
|
||||
message.setABoolean(true); |
||||
message.setARepeatedStringList(['1', '2']); |
||||
|
||||
assertObjectEquals({ |
||||
$name: 'proto.jspb.test.Simple1', |
||||
'aString': 'foo', |
||||
'aRepeatedStringList': ['1', '2'], |
||||
'aBoolean': true |
||||
}, jspb.debug.dump(message)); |
||||
|
||||
message.setAString(undefined); |
||||
|
||||
assertObjectEquals({ |
||||
$name: 'proto.jspb.test.Simple1', |
||||
'aRepeatedStringList': ['1', '2'], |
||||
'aBoolean': true |
||||
}, jspb.debug.dump(message)); |
||||
}); |
||||
|
||||
|
||||
it('testExtensions', function() { |
||||
if (COMPILED) { |
||||
return; |
||||
} |
||||
var extension = new proto.jspb.test.IsExtension(); |
||||
extension.setExt1('ext1field'); |
||||
var extendable = new proto.jspb.test.HasExtensions(); |
||||
extendable.setStr1('v1'); |
||||
extendable.setStr2('v2'); |
||||
extendable.setStr3('v3'); |
||||
extendable.setExtension(proto.jspb.test.IsExtension.extField, extension); |
||||
|
||||
assertObjectEquals({ |
||||
'$name': 'proto.jspb.test.HasExtensions', |
||||
'str1': 'v1', |
||||
'str2': 'v2', |
||||
'str3': 'v3', |
||||
'$extensions': { |
||||
'extField': { |
||||
'$name': 'proto.jspb.test.IsExtension', |
||||
'ext1': 'ext1field' |
||||
}, |
||||
'repeatedSimpleList': [] |
||||
} |
||||
}, jspb.debug.dump(extendable)); |
||||
}); |
||||
|
||||
}); |
@ -0,0 +1,17 @@ |
||||
{ |
||||
"spec_dir": "", |
||||
"spec_files": [ |
||||
"*_test.js", |
||||
"binary/*_test.js" |
||||
], |
||||
"helpers": [ |
||||
"../../../js/node_modules/google-closure-library/closure/goog/bootstrap/nodejs.js", |
||||
"../../../js/node_loader.js", |
||||
"../../../js/deps.js", |
||||
"../../../js/google/protobuf/any.js", |
||||
"../../../js/google/protobuf/struct.js", |
||||
"../../../js/google/protobuf/timestamp.js", |
||||
"testproto_libs1.js", |
||||
"testproto_libs2.js" |
||||
] |
||||
} |
@ -0,0 +1,17 @@ |
||||
{ |
||||
"spec_dir": "", |
||||
"spec_files": [ |
||||
"*_test.js", |
||||
"binary/*_test.js" |
||||
], |
||||
"helpers": [ |
||||
"../../../js/node_modules/google-closure-library/closure/goog/bootstrap/nodejs.js", |
||||
"../../../js/node_loader.js", |
||||
"../../../js/deps.js", |
||||
"../../../js/google/protobuf/any.js", |
||||
"../../../js/google/protobuf/struct.js", |
||||
"../../../js/google/protobuf/timestamp.js", |
||||
"testproto_libs1_new.js", |
||||
"testproto_libs2.js" |
||||
] |
||||
} |
@ -0,0 +1,17 @@ |
||||
{ |
||||
"spec_dir": "", |
||||
"spec_files": [ |
||||
"*_test.js", |
||||
"binary/*_test.js" |
||||
], |
||||
"helpers": [ |
||||
"../../../js/node_modules/google-closure-library/closure/goog/bootstrap/nodejs.js", |
||||
"../../../js/node_loader.js", |
||||
"../../../js/deps.js", |
||||
"../../../js/google/protobuf/any.js", |
||||
"../../../js/google/protobuf/struct.js", |
||||
"../../../js/google/protobuf/timestamp.js", |
||||
"testproto_libs1.js", |
||||
"testproto_libs2_new.js" |
||||
] |
||||
} |
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,329 @@ |
||||
// 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.
|
||||
|
||||
goog.require('goog.crypt.base64'); |
||||
goog.require('goog.testing.asserts'); |
||||
|
||||
// CommonJS-LoadFromFile: testbinary_pb proto.jspb.test
|
||||
goog.require('proto.jspb.test.ForeignMessage'); |
||||
|
||||
// CommonJS-LoadFromFile: proto3_test_pb proto.jspb.test
|
||||
goog.require('proto.jspb.test.Proto3Enum'); |
||||
goog.require('proto.jspb.test.TestProto3'); |
||||
|
||||
|
||||
var BYTES = new Uint8Array([1, 2, 8, 9]); |
||||
var BYTES_B64 = goog.crypt.base64.encodeByteArray(BYTES); |
||||
|
||||
|
||||
/** |
||||
* Helper: compare a bytes field to an expected value |
||||
* @param {Uint8Array|string} arr |
||||
* @param {Uint8Array} expected |
||||
* @return {boolean} |
||||
*/ |
||||
function bytesCompare(arr, expected) { |
||||
if (goog.isString(arr)) { |
||||
arr = goog.crypt.base64.decodeStringToUint8Array(arr); |
||||
} |
||||
if (arr.length != expected.length) { |
||||
return false; |
||||
} |
||||
for (var i = 0; i < arr.length; i++) { |
||||
if (arr[i] != expected[i]) { |
||||
return false; |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
|
||||
describe('proto3Test', function() { |
||||
/** |
||||
* Test defaults for proto3 message fields. |
||||
*/ |
||||
it('testProto3FieldDefaults', function() { |
||||
var msg = new proto.jspb.test.TestProto3(); |
||||
|
||||
assertEquals(msg.getOptionalInt32(), 0); |
||||
assertEquals(msg.getOptionalInt64(), 0); |
||||
assertEquals(msg.getOptionalUint32(), 0); |
||||
assertEquals(msg.getOptionalUint64(), 0); |
||||
assertEquals(msg.getOptionalSint32(), 0); |
||||
assertEquals(msg.getOptionalSint64(), 0); |
||||
assertEquals(msg.getOptionalFixed32(), 0); |
||||
assertEquals(msg.getOptionalFixed64(), 0); |
||||
assertEquals(msg.getOptionalSfixed32(), 0); |
||||
assertEquals(msg.getOptionalSfixed64(), 0); |
||||
assertEquals(msg.getOptionalFloat(), 0); |
||||
assertEquals(msg.getOptionalDouble(), 0); |
||||
assertEquals(msg.getOptionalString(), ''); |
||||
|
||||
// TODO(b/26173701): when we change bytes fields default getter to return
|
||||
// Uint8Array, we'll want to switch this assertion to match the u8 case.
|
||||
assertEquals(typeof msg.getOptionalBytes(), 'string'); |
||||
assertEquals(msg.getOptionalBytes_asU8() instanceof Uint8Array, true); |
||||
assertEquals(typeof msg.getOptionalBytes_asB64(), 'string'); |
||||
assertEquals(msg.getOptionalBytes().length, 0); |
||||
assertEquals(msg.getOptionalBytes_asU8().length, 0); |
||||
assertEquals(msg.getOptionalBytes_asB64(), ''); |
||||
|
||||
assertEquals(msg.getOptionalForeignEnum(), |
||||
proto.jspb.test.Proto3Enum.PROTO3_FOO); |
||||
assertEquals(msg.getOptionalForeignMessage(), undefined); |
||||
assertEquals(msg.getOptionalForeignMessage(), undefined); |
||||
|
||||
assertEquals(msg.getRepeatedInt32List().length, 0); |
||||
assertEquals(msg.getRepeatedInt64List().length, 0); |
||||
assertEquals(msg.getRepeatedUint32List().length, 0); |
||||
assertEquals(msg.getRepeatedUint64List().length, 0); |
||||
assertEquals(msg.getRepeatedSint32List().length, 0); |
||||
assertEquals(msg.getRepeatedSint64List().length, 0); |
||||
assertEquals(msg.getRepeatedFixed32List().length, 0); |
||||
assertEquals(msg.getRepeatedFixed64List().length, 0); |
||||
assertEquals(msg.getRepeatedSfixed32List().length, 0); |
||||
assertEquals(msg.getRepeatedSfixed64List().length, 0); |
||||
assertEquals(msg.getRepeatedFloatList().length, 0); |
||||
assertEquals(msg.getRepeatedDoubleList().length, 0); |
||||
assertEquals(msg.getRepeatedStringList().length, 0); |
||||
assertEquals(msg.getRepeatedBytesList().length, 0); |
||||
assertEquals(msg.getRepeatedForeignEnumList().length, 0); |
||||
assertEquals(msg.getRepeatedForeignMessageList().length, 0); |
||||
|
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Test that all fields can be set and read via a serialization roundtrip. |
||||
*/ |
||||
it('testProto3FieldSetGet', function() { |
||||
var msg = new proto.jspb.test.TestProto3(); |
||||
|
||||
msg.setOptionalInt32(-42); |
||||
msg.setOptionalInt64(-0x7fffffff00000000); |
||||
msg.setOptionalUint32(0x80000000); |
||||
msg.setOptionalUint64(0xf000000000000000); |
||||
msg.setOptionalSint32(-100); |
||||
msg.setOptionalSint64(-0x8000000000000000); |
||||
msg.setOptionalFixed32(1234); |
||||
msg.setOptionalFixed64(0x1234567800000000); |
||||
msg.setOptionalSfixed32(-1234); |
||||
msg.setOptionalSfixed64(-0x1234567800000000); |
||||
msg.setOptionalFloat(1.5); |
||||
msg.setOptionalDouble(-1.5); |
||||
msg.setOptionalBool(true); |
||||
msg.setOptionalString('hello world'); |
||||
msg.setOptionalBytes(BYTES); |
||||
var submsg = new proto.jspb.test.ForeignMessage(); |
||||
submsg.setC(16); |
||||
msg.setOptionalForeignMessage(submsg); |
||||
msg.setOptionalForeignEnum(proto.jspb.test.Proto3Enum.PROTO3_BAR); |
||||
|
||||
msg.setRepeatedInt32List([-42]); |
||||
msg.setRepeatedInt64List([-0x7fffffff00000000]); |
||||
msg.setRepeatedUint32List([0x80000000]); |
||||
msg.setRepeatedUint64List([0xf000000000000000]); |
||||
msg.setRepeatedSint32List([-100]); |
||||
msg.setRepeatedSint64List([-0x8000000000000000]); |
||||
msg.setRepeatedFixed32List([1234]); |
||||
msg.setRepeatedFixed64List([0x1234567800000000]); |
||||
msg.setRepeatedSfixed32List([-1234]); |
||||
msg.setRepeatedSfixed64List([-0x1234567800000000]); |
||||
msg.setRepeatedFloatList([1.5]); |
||||
msg.setRepeatedDoubleList([-1.5]); |
||||
msg.setRepeatedBoolList([true]); |
||||
msg.setRepeatedStringList(['hello world']); |
||||
msg.setRepeatedBytesList([BYTES]); |
||||
submsg = new proto.jspb.test.ForeignMessage(); |
||||
submsg.setC(1000); |
||||
msg.setRepeatedForeignMessageList([submsg]); |
||||
msg.setRepeatedForeignEnumList([proto.jspb.test.Proto3Enum.PROTO3_BAR]); |
||||
|
||||
msg.setOneofString('asdf'); |
||||
|
||||
var serialized = msg.serializeBinary(); |
||||
msg = proto.jspb.test.TestProto3.deserializeBinary(serialized); |
||||
|
||||
assertEquals(msg.getOptionalInt32(), -42); |
||||
assertEquals(msg.getOptionalInt64(), -0x7fffffff00000000); |
||||
assertEquals(msg.getOptionalUint32(), 0x80000000); |
||||
assertEquals(msg.getOptionalUint64(), 0xf000000000000000); |
||||
assertEquals(msg.getOptionalSint32(), -100); |
||||
assertEquals(msg.getOptionalSint64(), -0x8000000000000000); |
||||
assertEquals(msg.getOptionalFixed32(), 1234); |
||||
assertEquals(msg.getOptionalFixed64(), 0x1234567800000000); |
||||
assertEquals(msg.getOptionalSfixed32(), -1234); |
||||
assertEquals(msg.getOptionalSfixed64(), -0x1234567800000000); |
||||
assertEquals(msg.getOptionalFloat(), 1.5); |
||||
assertEquals(msg.getOptionalDouble(), -1.5); |
||||
assertEquals(msg.getOptionalBool(), true); |
||||
assertEquals(msg.getOptionalString(), 'hello world'); |
||||
assertEquals(true, bytesCompare(msg.getOptionalBytes(), BYTES)); |
||||
assertEquals(msg.getOptionalForeignMessage().getC(), 16); |
||||
assertEquals(msg.getOptionalForeignEnum(), |
||||
proto.jspb.test.Proto3Enum.PROTO3_BAR); |
||||
|
||||
assertElementsEquals(msg.getRepeatedInt32List(), [-42]); |
||||
assertElementsEquals(msg.getRepeatedInt64List(), [-0x7fffffff00000000]); |
||||
assertElementsEquals(msg.getRepeatedUint32List(), [0x80000000]); |
||||
assertElementsEquals(msg.getRepeatedUint64List(), [0xf000000000000000]); |
||||
assertElementsEquals(msg.getRepeatedSint32List(), [-100]); |
||||
assertElementsEquals(msg.getRepeatedSint64List(), [-0x8000000000000000]); |
||||
assertElementsEquals(msg.getRepeatedFixed32List(), [1234]); |
||||
assertElementsEquals(msg.getRepeatedFixed64List(), [0x1234567800000000]); |
||||
assertElementsEquals(msg.getRepeatedSfixed32List(), [-1234]); |
||||
assertElementsEquals(msg.getRepeatedSfixed64List(), [-0x1234567800000000]); |
||||
assertElementsEquals(msg.getRepeatedFloatList(), [1.5]); |
||||
assertElementsEquals(msg.getRepeatedDoubleList(), [-1.5]); |
||||
assertElementsEquals(msg.getRepeatedBoolList(), [true]); |
||||
assertElementsEquals(msg.getRepeatedStringList(), ['hello world']); |
||||
assertEquals(msg.getRepeatedBytesList().length, 1); |
||||
assertEquals(true, bytesCompare(msg.getRepeatedBytesList()[0], BYTES)); |
||||
assertEquals(msg.getRepeatedForeignMessageList().length, 1); |
||||
assertEquals(msg.getRepeatedForeignMessageList()[0].getC(), 1000); |
||||
assertElementsEquals(msg.getRepeatedForeignEnumList(), |
||||
[proto.jspb.test.Proto3Enum.PROTO3_BAR]); |
||||
|
||||
assertEquals(msg.getOneofString(), 'asdf'); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Test that oneofs continue to have a notion of field presence. |
||||
*/ |
||||
it('testOneofs', function() { |
||||
var msg = new proto.jspb.test.TestProto3(); |
||||
|
||||
assertEquals(msg.getOneofUint32(), 0); |
||||
assertEquals(msg.getOneofForeignMessage(), undefined); |
||||
assertEquals(msg.getOneofString(), ''); |
||||
assertEquals(msg.getOneofBytes(), ''); |
||||
assertFalse(msg.hasOneofUint32()); |
||||
assertFalse(msg.hasOneofString()); |
||||
assertFalse(msg.hasOneofBytes()); |
||||
|
||||
msg.setOneofUint32(42); |
||||
assertEquals(msg.getOneofUint32(), 42); |
||||
assertEquals(msg.getOneofForeignMessage(), undefined); |
||||
assertEquals(msg.getOneofString(), ''); |
||||
assertEquals(msg.getOneofBytes(), ''); |
||||
assertTrue(msg.hasOneofUint32()); |
||||
assertFalse(msg.hasOneofString()); |
||||
assertFalse(msg.hasOneofBytes()); |
||||
|
||||
|
||||
var submsg = new proto.jspb.test.ForeignMessage(); |
||||
msg.setOneofForeignMessage(submsg); |
||||
assertEquals(msg.getOneofUint32(), 0); |
||||
assertEquals(msg.getOneofForeignMessage(), submsg); |
||||
assertEquals(msg.getOneofString(), ''); |
||||
assertEquals(msg.getOneofBytes(), ''); |
||||
assertFalse(msg.hasOneofUint32()); |
||||
assertFalse(msg.hasOneofString()); |
||||
assertFalse(msg.hasOneofBytes()); |
||||
|
||||
msg.setOneofString('hello'); |
||||
assertEquals(msg.getOneofUint32(), 0); |
||||
assertEquals(msg.getOneofForeignMessage(), undefined); |
||||
assertEquals(msg.getOneofString(), 'hello'); |
||||
assertEquals(msg.getOneofBytes(), ''); |
||||
assertFalse(msg.hasOneofUint32()); |
||||
assertTrue(msg.hasOneofString()); |
||||
assertFalse(msg.hasOneofBytes()); |
||||
|
||||
msg.setOneofBytes(goog.crypt.base64.encodeString('\u00FF\u00FF')); |
||||
assertEquals(msg.getOneofUint32(), 0); |
||||
assertEquals(msg.getOneofForeignMessage(), undefined); |
||||
assertEquals(msg.getOneofString(), ''); |
||||
assertEquals(msg.getOneofBytes_asB64(), |
||||
goog.crypt.base64.encodeString('\u00FF\u00FF')); |
||||
assertFalse(msg.hasOneofUint32()); |
||||
assertFalse(msg.hasOneofString()); |
||||
assertTrue(msg.hasOneofBytes()); |
||||
}); |
||||
|
||||
|
||||
/** |
||||
* Test that "default"-valued primitive fields are not emitted on the wire. |
||||
*/ |
||||
it('testNoSerializeDefaults', function() { |
||||
var msg = new proto.jspb.test.TestProto3(); |
||||
|
||||
// Set each primitive to a non-default value, then back to its default, to
|
||||
// ensure that the serialization is actually checking the value and not just
|
||||
// whether it has ever been set.
|
||||
msg.setOptionalInt32(42); |
||||
msg.setOptionalInt32(0); |
||||
msg.setOptionalDouble(3.14); |
||||
msg.setOptionalDouble(0.0); |
||||
msg.setOptionalBool(true); |
||||
msg.setOptionalBool(false); |
||||
msg.setOptionalString('hello world'); |
||||
msg.setOptionalString(''); |
||||
msg.setOptionalBytes(goog.crypt.base64.encodeString('\u00FF\u00FF')); |
||||
msg.setOptionalBytes(''); |
||||
msg.setOptionalForeignMessage(new proto.jspb.test.ForeignMessage()); |
||||
msg.setOptionalForeignMessage(null); |
||||
msg.setOptionalForeignEnum(proto.jspb.test.Proto3Enum.PROTO3_BAR); |
||||
msg.setOptionalForeignEnum(proto.jspb.test.Proto3Enum.PROTO3_FOO); |
||||
msg.setOneofUint32(32); |
||||
msg.setOneofUint32(null); |
||||
|
||||
|
||||
var serialized = msg.serializeBinary(); |
||||
assertEquals(0, serialized.length); |
||||
}); |
||||
|
||||
/** |
||||
* Test that base64 string and Uint8Array are interchangeable in bytes fields. |
||||
*/ |
||||
it('testBytesFieldsInterop', function() { |
||||
var msg = new proto.jspb.test.TestProto3(); |
||||
// Set as a base64 string and check all the getters work.
|
||||
msg.setOptionalBytes(BYTES_B64); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes_asU8(), BYTES)); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes_asB64(), BYTES)); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes(), BYTES)); |
||||
|
||||
// Test binary serialize round trip doesn't break it.
|
||||
msg = proto.jspb.test.TestProto3.deserializeBinary(msg.serializeBinary()); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes_asU8(), BYTES)); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes_asB64(), BYTES)); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes(), BYTES)); |
||||
|
||||
msg = new proto.jspb.test.TestProto3(); |
||||
// Set as a Uint8Array and check all the getters work.
|
||||
msg.setOptionalBytes(BYTES); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes_asU8(), BYTES)); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes_asB64(), BYTES)); |
||||
assertTrue(bytesCompare(msg.getOptionalBytes(), BYTES)); |
||||
|
||||
}); |
||||
}); |
@ -0,0 +1,89 @@ |
||||
// 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. |
||||
|
||||
syntax = "proto3"; |
||||
|
||||
import "testbinary.proto"; |
||||
|
||||
package jspb.test; |
||||
|
||||
message TestProto3 { |
||||
int32 optional_int32 = 1; |
||||
int64 optional_int64 = 2; |
||||
uint32 optional_uint32 = 3; |
||||
uint64 optional_uint64 = 4; |
||||
sint32 optional_sint32 = 5; |
||||
sint64 optional_sint64 = 6; |
||||
fixed32 optional_fixed32 = 7; |
||||
fixed64 optional_fixed64 = 8; |
||||
sfixed32 optional_sfixed32 = 9; |
||||
sfixed64 optional_sfixed64 = 10; |
||||
float optional_float = 11; |
||||
double optional_double = 12; |
||||
bool optional_bool = 13; |
||||
string optional_string = 14; |
||||
bytes optional_bytes = 15; |
||||
|
||||
ForeignMessage optional_foreign_message = 19; |
||||
Proto3Enum optional_foreign_enum = 22; |
||||
|
||||
repeated int32 repeated_int32 = 31; |
||||
repeated int64 repeated_int64 = 32; |
||||
repeated uint32 repeated_uint32 = 33; |
||||
repeated uint64 repeated_uint64 = 34; |
||||
repeated sint32 repeated_sint32 = 35; |
||||
repeated sint64 repeated_sint64 = 36; |
||||
repeated fixed32 repeated_fixed32 = 37; |
||||
repeated fixed64 repeated_fixed64 = 38; |
||||
repeated sfixed32 repeated_sfixed32 = 39; |
||||
repeated sfixed64 repeated_sfixed64 = 40; |
||||
repeated float repeated_float = 41; |
||||
repeated double repeated_double = 42; |
||||
repeated bool repeated_bool = 43; |
||||
repeated string repeated_string = 44; |
||||
repeated bytes repeated_bytes = 45; |
||||
|
||||
repeated ForeignMessage repeated_foreign_message = 49; |
||||
repeated Proto3Enum repeated_foreign_enum = 52; |
||||
|
||||
|
||||
oneof oneof_field { |
||||
uint32 oneof_uint32 = 111; |
||||
ForeignMessage oneof_foreign_message = 112; |
||||
string oneof_string = 113; |
||||
bytes oneof_bytes = 114; |
||||
} |
||||
} |
||||
|
||||
enum Proto3Enum { |
||||
PROTO3_FOO = 0; |
||||
PROTO3_BAR = 1; |
||||
PROTO3_BAZ = 2; |
||||
} |
@ -0,0 +1,236 @@ |
||||
// 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. |
||||
|
||||
// Author: mwr@google.com (Mark Rawling) |
||||
|
||||
syntax = "proto2"; |
||||
|
||||
option java_package = "com.google.apps.jspb.proto"; |
||||
option java_multiple_files = true; |
||||
|
||||
import "google/protobuf/descriptor.proto"; |
||||
|
||||
package jspb.test; |
||||
|
||||
message Empty { |
||||
} |
||||
|
||||
enum OuterEnum { |
||||
FOO = 1; |
||||
BAR = 2; |
||||
} |
||||
|
||||
message EnumContainer { |
||||
optional OuterEnum outer_enum = 1; |
||||
} |
||||
|
||||
message Simple1 { |
||||
required string a_string = 1; |
||||
repeated string a_repeated_string = 2; |
||||
optional bool a_boolean = 3; |
||||
} |
||||
|
||||
// A message that differs from Simple1 only by name |
||||
message Simple2 { |
||||
required string a_string = 1; |
||||
repeated string a_repeated_string = 2; |
||||
} |
||||
|
||||
message SpecialCases { |
||||
required string normal = 1; |
||||
// Examples of Js reserved names that are converted to pb_<name>. |
||||
required string default = 2; |
||||
required string function = 3; |
||||
required string var = 4; |
||||
} |
||||
|
||||
message OptionalFields { |
||||
message Nested { |
||||
optional int32 an_int = 1; |
||||
} |
||||
optional string a_string = 1; |
||||
required bool a_bool = 2; |
||||
optional Nested a_nested_message = 3; |
||||
repeated Nested a_repeated_message = 4; |
||||
repeated string a_repeated_string = 5; |
||||
} |
||||
|
||||
message HasExtensions { |
||||
optional string str1 = 1; |
||||
optional string str2 = 2; |
||||
optional string str3 = 3; |
||||
extensions 10 to max; |
||||
} |
||||
|
||||
message Complex { |
||||
message Nested { |
||||
required int32 an_int = 2; |
||||
} |
||||
required string a_string = 1; |
||||
required bool an_out_of_order_bool = 9; |
||||
optional Nested a_nested_message = 4; |
||||
repeated Nested a_repeated_message = 5; |
||||
repeated string a_repeated_string = 7; |
||||
} |
||||
|
||||
message OuterMessage { |
||||
// Make sure this doesn't conflict with the other Complex message. |
||||
message Complex { |
||||
optional int32 inner_complex_field = 1; |
||||
} |
||||
} |
||||
|
||||
message IsExtension { |
||||
extend HasExtensions { |
||||
optional IsExtension ext_field = 100; |
||||
} |
||||
optional string ext1 = 1; |
||||
|
||||
// Extensions of proto2 Descriptor messages will be ignored. |
||||
extend google.protobuf.EnumOptions { |
||||
optional string simple_option = 42113038; |
||||
} |
||||
} |
||||
|
||||
message IndirectExtension { |
||||
extend HasExtensions { |
||||
optional Simple1 simple = 101; |
||||
optional string str = 102; |
||||
repeated string repeated_str = 103; |
||||
repeated Simple1 repeated_simple = 104; |
||||
} |
||||
} |
||||
|
||||
extend HasExtensions { |
||||
optional Simple1 simple1 = 105; |
||||
} |
||||
|
||||
message DefaultValues { |
||||
enum Enum { |
||||
E1 = 13; |
||||
E2 = 77; |
||||
} |
||||
optional string string_field = 1 [default="default<>\'\"abc"]; |
||||
optional bool bool_field = 2 [default=true]; |
||||
optional int64 int_field = 3 [default=11]; |
||||
optional Enum enum_field = 4 [default=E1]; |
||||
optional string empty_field = 6 [default=""]; |
||||
optional bytes bytes_field = 8 [default="moo"]; // Base64 encoding is "bW9v" |
||||
} |
||||
|
||||
message FloatingPointFields { |
||||
optional float optional_float_field = 1; |
||||
required float required_float_field = 2; |
||||
repeated float repeated_float_field = 3; |
||||
optional float default_float_field = 4 [default = 2.0]; |
||||
optional double optional_double_field = 5; |
||||
required double required_double_field = 6; |
||||
repeated double repeated_double_field = 7; |
||||
optional double default_double_field = 8 [default = 2.0]; |
||||
} |
||||
|
||||
message TestClone { |
||||
optional string str = 1; |
||||
optional Simple1 simple1 = 3; |
||||
repeated Simple1 simple2 = 5; |
||||
optional bytes bytes_field = 6; |
||||
optional string unused = 7; |
||||
extensions 10 to max; |
||||
} |
||||
|
||||
message CloneExtension { |
||||
extend TestClone { |
||||
optional CloneExtension ext_field = 100; |
||||
} |
||||
optional string ext = 2; |
||||
} |
||||
|
||||
message TestGroup { |
||||
repeated group RepeatedGroup = 1 { |
||||
required string id = 1; |
||||
repeated bool some_bool = 2; |
||||
} |
||||
required group RequiredGroup = 2 { |
||||
required string id = 1; |
||||
} |
||||
optional group OptionalGroup = 3 { |
||||
required string id = 1; |
||||
} |
||||
optional string id = 4; |
||||
required Simple2 required_simple = 5; |
||||
optional Simple2 optional_simple = 6; |
||||
} |
||||
|
||||
message TestGroup1 { |
||||
optional TestGroup.RepeatedGroup group = 1; |
||||
} |
||||
|
||||
message TestReservedNames { |
||||
optional int32 extension = 1; |
||||
extensions 10 to max; |
||||
} |
||||
|
||||
message TestReservedNamesExtension { |
||||
extend TestReservedNames { |
||||
optional int32 foo = 10; |
||||
} |
||||
} |
||||
|
||||
message TestMessageWithOneof { |
||||
|
||||
oneof partial_oneof { |
||||
string pone = 3; |
||||
string pthree = 5; |
||||
} |
||||
|
||||
oneof recursive_oneof { |
||||
TestMessageWithOneof rone = 6; |
||||
string rtwo = 7; |
||||
} |
||||
|
||||
optional bool normal_field = 8; |
||||
repeated string repeated_field = 9; |
||||
|
||||
oneof default_oneof_a { |
||||
int32 aone = 10 [default = 1234]; |
||||
int32 atwo = 11; |
||||
} |
||||
|
||||
oneof default_oneof_b { |
||||
int32 bone = 12; |
||||
int32 btwo = 13 [default = 1234]; |
||||
} |
||||
} |
||||
|
||||
message TestEndsWithBytes { |
||||
optional int32 value = 1; |
||||
optional bytes data = 2; |
||||
} |
||||
|
@ -0,0 +1,92 @@ |
||||
#!/bin/bash |
||||
|
||||
set -e |
||||
|
||||
# Download protoc 3.0.0 from Maven if it is not already present. |
||||
OLD_PROTOC_URL=https://repo1.maven.org/maven2/com/google/protobuf/protoc/3.0.0/protoc-3.0.0-linux-x86_64.exe |
||||
if [ ! -f protoc ]; then |
||||
wget $OLD_PROTOC_URL -O protoc |
||||
chmod +x protoc |
||||
fi |
||||
|
||||
pushd ../.. |
||||
npm install && npm test |
||||
popd |
||||
|
||||
old_protoc=./protoc |
||||
new_protoc=../../../src/protoc |
||||
|
||||
# The protos in group 2 have some dependencies on protos in group 1. The tests |
||||
# will verify that the generated code for one group can be regenerated |
||||
# independently of the other group in a compatible way. |
||||
# |
||||
# Note: these lists of protos duplicate the lists in gulpfile.js. Ideally we |
||||
# should find a good way of having a single source of truth for this. |
||||
group1_protos="data.proto test3.proto test5.proto commonjs/test6/test6.proto testbinary.proto testempty.proto test.proto" |
||||
group2_protos="proto3_test.proto test2.proto test4.proto commonjs/test7/test7.proto" |
||||
|
||||
# We test the following cases: |
||||
# |
||||
# Case 1: build groups 1 and 2 with the old protoc |
||||
# Case 2: build group 1 with new protoc but group 2 with old protoc |
||||
# Case 3: build group 1 with old protoc but group 2 with new protoc |
||||
# |
||||
# In each case, we use the current runtime. |
||||
|
||||
# |
||||
# CommonJS tests |
||||
# |
||||
mkdir -p commonjs_out{1,2,3} |
||||
# Case 1 |
||||
$old_protoc --js_out=import_style=commonjs,binary:commonjs_out1 -I ../../../src -I commonjs -I . $group1_protos |
||||
$old_protoc --js_out=import_style=commonjs,binary:commonjs_out1 -I ../../../src -I commonjs -I . $group2_protos |
||||
# Case 2 |
||||
$new_protoc --js_out=import_style=commonjs,binary:commonjs_out2 -I ../../../src -I commonjs -I . $group1_protos |
||||
$old_protoc --js_out=import_style=commonjs,binary:commonjs_out2 -I ../../../src -I commonjs -I . $group2_protos |
||||
# Case 3 |
||||
$old_protoc --js_out=import_style=commonjs,binary:commonjs_out3 -I ../../../src -I commonjs -I . $group1_protos |
||||
$new_protoc --js_out=import_style=commonjs,binary:commonjs_out3 -I ../../../src -I commonjs -I . $group2_protos |
||||
|
||||
mkdir -p commonjs_out/binary |
||||
for file in *_test.js binary/*_test.js; do |
||||
node commonjs/rewrite_tests_for_commonjs.js < "$file" > "commonjs_out/$file" |
||||
done |
||||
cp commonjs/{jasmine.json,import_test.js} commonjs_out/ |
||||
mkdir -p commonjs_out/test_node_modules |
||||
../../node_modules/google-closure-library/closure/bin/calcdeps.py -i commonjs/export_asserts.js -p . -p ../../node_modules/google-closure-library/closure -o compiled --compiler_jar ../../node_modules/google-closure-compiler/compiler.jar > commonjs_out/test_node_modules/closure_asserts_commonjs.js |
||||
../../node_modules/google-closure-library/closure/bin/calcdeps.py -i commonjs/export_testdeps.js -p ../.. -p ../../node_modules/google-closure-library/closure -o compiled --compiler_jar ../../node_modules/google-closure-compiler/compiler.jar > commonjs_out/test_node_modules/testdeps_commonjs.js |
||||
cp ../../google-protobuf.js commonjs_out/test_node_modules |
||||
cp -r ../../commonjs_out/node_modules commonjs_out |
||||
|
||||
echo |
||||
echo "Running tests with CommonJS imports" |
||||
echo "-----------------------------------" |
||||
for i in 1 2 3; do |
||||
cp -r commonjs_out/* "commonjs_out$i" |
||||
pushd "commonjs_out$i" |
||||
JASMINE_CONFIG_PATH=jasmine.json NODE_PATH=test_node_modules ../../../node_modules/.bin/jasmine |
||||
popd |
||||
done |
||||
|
||||
# |
||||
# Closure tests |
||||
# |
||||
$old_protoc --js_out=library=testproto_libs1,binary:. -I ../../../src -I commonjs -I . $group1_protos |
||||
$old_protoc --js_out=library=testproto_libs2,binary:. -I ../../../src -I commonjs -I . $group2_protos |
||||
$new_protoc --js_out=library=testproto_libs1_new,binary:. -I ../../../src -I commonjs -I . $group1_protos |
||||
$new_protoc --js_out=library=testproto_libs2_new,binary:. -I ../../../src -I commonjs -I . $group2_protos |
||||
|
||||
echo |
||||
echo "Running tests with Closure-style imports" |
||||
echo "----------------------------------------" |
||||
|
||||
# Case 1 |
||||
JASMINE_CONFIG_PATH=jasmine1.json ../../node_modules/.bin/jasmine |
||||
# Case 2 |
||||
JASMINE_CONFIG_PATH=jasmine2.json ../../node_modules/.bin/jasmine |
||||
# Case 3 |
||||
JASMINE_CONFIG_PATH=jasmine3.json ../../node_modules/.bin/jasmine |
||||
|
||||
# Remove these files so that calcdeps.py does not get confused by them the next |
||||
# time this script runs. |
||||
rm testproto_libs[12]* |
@ -0,0 +1,54 @@ |
||||
// 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. |
||||
|
||||
syntax = "proto2"; |
||||
|
||||
option java_package = "com.google.apps.jspb.proto"; |
||||
option java_multiple_files = true; |
||||
|
||||
package jspb.test; |
||||
|
||||
message TestExtensionsMessage { |
||||
optional int32 intfield = 1; |
||||
extensions 100 to max; |
||||
} |
||||
|
||||
message ExtensionMessage { |
||||
extend TestExtensionsMessage { |
||||
optional ExtensionMessage ext_field = 100; |
||||
} |
||||
optional string ext1 = 1; |
||||
} |
||||
|
||||
// Floating extensions are only supported when generating a _lib.js library. |
||||
extend TestExtensionsMessage { |
||||
optional ExtensionMessage floating_msg_field = 101; |
||||
optional string floating_str_field = 102; |
||||
} |
@ -0,0 +1,53 @@ |
||||
// 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. |
||||
|
||||
syntax = "proto2"; |
||||
|
||||
option java_package = "com.google.apps.jspb.proto"; |
||||
option java_multiple_files = true; |
||||
|
||||
package jspb.exttest; |
||||
|
||||
message TestExtensionsMessage { |
||||
optional int32 intfield = 1; |
||||
extensions 100 to max; |
||||
} |
||||
|
||||
message ExtensionMessage { |
||||
extend TestExtensionsMessage { |
||||
optional ExtensionMessage ext_field = 100; |
||||
} |
||||
optional string ext1 = 1; |
||||
} |
||||
|
||||
extend TestExtensionsMessage { |
||||
optional ExtensionMessage floating_msg_field = 101; |
||||
optional string floating_str_field = 102; |
||||
} |
@ -0,0 +1,42 @@ |
||||
// 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. |
||||
|
||||
syntax = "proto2"; |
||||
|
||||
option java_package = "com.google.apps.jspb.proto"; |
||||
option java_multiple_files = true; |
||||
|
||||
package jspb.exttest; |
||||
|
||||
import "test3.proto"; |
||||
|
||||
extend TestExtensionsMessage { |
||||
optional ExtensionMessage floating_msg_field_two = 103; |
||||
} |
@ -0,0 +1,44 @@ |
||||
// 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. |
||||
|
||||
syntax = "proto2"; |
||||
|
||||
option java_package = "com.google.apps.jspb.proto"; |
||||
option java_multiple_files = true; |
||||
|
||||
package jspb.exttest.beta; |
||||
|
||||
message TestBetaExtensionsMessage { |
||||
extensions 100 to max; |
||||
} |
||||
|
||||
extend TestBetaExtensionsMessage { |
||||
optional string floating_str_field = 101; |
||||
} |
@ -0,0 +1,212 @@ |
||||
// 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. |
||||
|
||||
// LINT: ALLOW_GROUPS |
||||
|
||||
syntax = "proto2"; |
||||
|
||||
|
||||
package jspb.test; |
||||
|
||||
// These types are borrowed from `unittest.proto` in the protobuf tree. We want |
||||
// to ensure that the binary-format support will handle all field types |
||||
// properly. |
||||
message TestAllTypes { |
||||
optional int32 optional_int32 = 1; |
||||
optional int64 optional_int64 = 2; |
||||
optional uint32 optional_uint32 = 3; |
||||
optional uint64 optional_uint64 = 4; |
||||
optional sint32 optional_sint32 = 5; |
||||
optional sint64 optional_sint64 = 6; |
||||
optional fixed32 optional_fixed32 = 7; |
||||
optional fixed64 optional_fixed64 = 8; |
||||
optional sfixed32 optional_sfixed32 = 9; |
||||
optional sfixed64 optional_sfixed64 = 10; |
||||
optional float optional_float = 11; |
||||
optional double optional_double = 12; |
||||
optional bool optional_bool = 13; |
||||
optional string optional_string = 14; |
||||
optional bytes optional_bytes = 15; |
||||
optional group OptionalGroup = 16 { |
||||
optional int32 a = 17; |
||||
} |
||||
|
||||
optional ForeignMessage optional_foreign_message = 19; |
||||
optional ForeignEnum optional_foreign_enum = 22; |
||||
|
||||
// Repeated |
||||
repeated int32 repeated_int32 = 31; |
||||
repeated int64 repeated_int64 = 32; |
||||
repeated uint32 repeated_uint32 = 33; |
||||
repeated uint64 repeated_uint64 = 34; |
||||
repeated sint32 repeated_sint32 = 35; |
||||
repeated sint64 repeated_sint64 = 36; |
||||
repeated fixed32 repeated_fixed32 = 37; |
||||
repeated fixed64 repeated_fixed64 = 38; |
||||
repeated sfixed32 repeated_sfixed32 = 39; |
||||
repeated sfixed64 repeated_sfixed64 = 40; |
||||
repeated float repeated_float = 41; |
||||
repeated double repeated_double = 42; |
||||
repeated bool repeated_bool = 43; |
||||
repeated string repeated_string = 44; |
||||
repeated bytes repeated_bytes = 45; |
||||
|
||||
repeated group RepeatedGroup = 46 { |
||||
optional int32 a = 47; |
||||
} |
||||
|
||||
repeated ForeignMessage repeated_foreign_message = 49; |
||||
repeated ForeignEnum repeated_foreign_enum = 52; |
||||
|
||||
// Packed repeated |
||||
repeated int32 packed_repeated_int32 = 61 [packed=true]; |
||||
repeated int64 packed_repeated_int64 = 62 [packed=true]; |
||||
repeated uint32 packed_repeated_uint32 = 63 [packed=true]; |
||||
repeated uint64 packed_repeated_uint64 = 64 [packed=true]; |
||||
repeated sint32 packed_repeated_sint32 = 65 [packed=true]; |
||||
repeated sint64 packed_repeated_sint64 = 66 [packed=true]; |
||||
repeated fixed32 packed_repeated_fixed32 = 67 [packed=true]; |
||||
repeated fixed64 packed_repeated_fixed64 = 68 [packed=true]; |
||||
repeated sfixed32 packed_repeated_sfixed32 = 69 [packed=true]; |
||||
repeated sfixed64 packed_repeated_sfixed64 = 70 [packed=true]; |
||||
repeated float packed_repeated_float = 71 [packed=true]; |
||||
repeated double packed_repeated_double = 72 [packed=true]; |
||||
repeated bool packed_repeated_bool = 73 [packed=true]; |
||||
|
||||
oneof oneof_field { |
||||
uint32 oneof_uint32 = 111; |
||||
ForeignMessage oneof_foreign_message = 112; |
||||
string oneof_string = 113; |
||||
bytes oneof_bytes = 114; |
||||
} |
||||
|
||||
} |
||||
|
||||
message ForeignMessage { |
||||
optional int32 c = 1; |
||||
} |
||||
|
||||
enum ForeignEnum { |
||||
FOREIGN_FOO = 4; |
||||
FOREIGN_BAR = 5; |
||||
FOREIGN_BAZ = 6; |
||||
} |
||||
|
||||
message TestExtendable { |
||||
extensions 1 to max; |
||||
} |
||||
|
||||
message ExtendsWithMessage { |
||||
extend TestExtendable { |
||||
optional ExtendsWithMessage optional_extension = 19; |
||||
repeated ExtendsWithMessage repeated_extension = 49; |
||||
} |
||||
optional int32 foo = 1; |
||||
} |
||||
|
||||
extend TestExtendable { |
||||
optional int32 extend_optional_int32 = 1; |
||||
optional int64 extend_optional_int64 = 2; |
||||
optional uint32 extend_optional_uint32 = 3; |
||||
optional uint64 extend_optional_uint64 = 4; |
||||
optional sint32 extend_optional_sint32 = 5; |
||||
optional sint64 extend_optional_sint64 = 6; |
||||
optional fixed32 extend_optional_fixed32 = 7; |
||||
optional fixed64 extend_optional_fixed64 = 8; |
||||
optional sfixed32 extend_optional_sfixed32 = 9; |
||||
optional sfixed64 extend_optional_sfixed64 = 10; |
||||
optional float extend_optional_float = 11; |
||||
optional double extend_optional_double = 12; |
||||
optional bool extend_optional_bool = 13; |
||||
optional string extend_optional_string = 14; |
||||
optional bytes extend_optional_bytes = 15; |
||||
optional ForeignEnum extend_optional_foreign_enum = 22; |
||||
|
||||
repeated int32 extend_repeated_int32 = 31; |
||||
repeated int64 extend_repeated_int64 = 32; |
||||
repeated uint32 extend_repeated_uint32 = 33; |
||||
repeated uint64 extend_repeated_uint64 = 34; |
||||
repeated sint32 extend_repeated_sint32 = 35; |
||||
repeated sint64 extend_repeated_sint64 = 36; |
||||
repeated fixed32 extend_repeated_fixed32 = 37; |
||||
repeated fixed64 extend_repeated_fixed64 = 38; |
||||
repeated sfixed32 extend_repeated_sfixed32 = 39; |
||||
repeated sfixed64 extend_repeated_sfixed64 = 40; |
||||
repeated float extend_repeated_float = 41; |
||||
repeated double extend_repeated_double = 42; |
||||
repeated bool extend_repeated_bool = 43; |
||||
repeated string extend_repeated_string = 44; |
||||
repeated bytes extend_repeated_bytes = 45; |
||||
repeated ForeignEnum extend_repeated_foreign_enum = 52; |
||||
|
||||
repeated int32 extend_packed_repeated_int32 = 61 [packed=true]; |
||||
repeated int64 extend_packed_repeated_int64 = 62 [packed=true]; |
||||
repeated uint32 extend_packed_repeated_uint32 = 63 [packed=true]; |
||||
repeated uint64 extend_packed_repeated_uint64 = 64 [packed=true]; |
||||
repeated sint32 extend_packed_repeated_sint32 = 65 [packed=true]; |
||||
repeated sint64 extend_packed_repeated_sint64 = 66 [packed=true]; |
||||
repeated fixed32 extend_packed_repeated_fixed32 = 67 [packed=true]; |
||||
repeated fixed64 extend_packed_repeated_fixed64 = 68 [packed=true]; |
||||
repeated sfixed32 extend_packed_repeated_sfixed32 = 69 [packed=true]; |
||||
repeated sfixed64 extend_packed_repeated_sfixed64 = 70 [packed=true]; |
||||
repeated float extend_packed_repeated_float = 71 [packed=true]; |
||||
repeated double extend_packed_repeated_double = 72 [packed=true]; |
||||
repeated bool extend_packed_repeated_bool = 73 [packed=true]; |
||||
repeated ForeignEnum extend_packed_repeated_foreign_enum = 82 |
||||
[packed=true]; |
||||
|
||||
} |
||||
|
||||
message TestMapFields { |
||||
map<string, string> map_string_string = 1; |
||||
map<string, int32> map_string_int32 = 2; |
||||
map<string, int64> map_string_int64 = 3; |
||||
map<string, bool> map_string_bool = 4; |
||||
map<string, double> map_string_double = 5; |
||||
map<string, MapValueEnum> map_string_enum = 6; |
||||
map<string, MapValueMessage> map_string_msg = 7; |
||||
|
||||
map<int32, string> map_int32_string = 8; |
||||
map<int64, string> map_int64_string = 9; |
||||
map<bool, string> map_bool_string = 10; |
||||
|
||||
optional TestMapFields test_map_fields = 11; |
||||
map<string, TestMapFields> map_string_testmapfields = 12; |
||||
} |
||||
|
||||
enum MapValueEnum { |
||||
MAP_VALUE_FOO = 0; |
||||
MAP_VALUE_BAR = 1; |
||||
MAP_VALUE_BAZ = 2; |
||||
} |
||||
|
||||
message MapValueMessage { |
||||
optional int32 foo = 1; |
||||
} |
@ -0,0 +1,34 @@ |
||||
// 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. |
||||
|
||||
syntax = "proto2"; |
||||
|
||||
package javatests.com.google.apps.jspb; |
||||
|
Loading…
Reference in new issue