Protocol Buffers - Google's data interchange format (grpc依赖)
https://developers.google.com/protocol-buffers/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
482 lines
17 KiB
482 lines
17 KiB
// Protocol Buffers - Google's data interchange format |
|
// Copyright 2008 Google Inc. All rights reserved. |
|
// https://developers.google.com/protocol-buffers/ |
|
// |
|
// Redistribution and use in source and binary forms, with or without |
|
// modification, are permitted provided that the following conditions are |
|
// met: |
|
// |
|
// * Redistributions of source code must retain the above copyright |
|
// notice, this list of conditions and the following disclaimer. |
|
// * Redistributions in binary form must reproduce the above |
|
// copyright notice, this list of conditions and the following disclaimer |
|
// in the documentation and/or other materials provided with the |
|
// distribution. |
|
// * Neither the name of Google Inc. nor the names of its |
|
// contributors may be used to endorse or promote products derived from |
|
// this software without specific prior written permission. |
|
// |
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
|
|
goog.require('goog.testing.asserts'); |
|
goog.require('goog.userAgent'); |
|
|
|
// CommonJS-LoadFromFile: testbinary_pb proto.jspb.test |
|
goog.require('proto.jspb.test.MapValueEnum'); |
|
goog.require('proto.jspb.test.MapValueMessage'); |
|
goog.require('proto.jspb.test.TestMapFields'); |
|
goog.require('proto.jspb.test.TestMapFieldsOptionalKeys'); |
|
goog.require('proto.jspb.test.TestMapFieldsOptionalValues'); |
|
goog.require('proto.jspb.test.MapEntryOptionalKeysStringKey'); |
|
goog.require('proto.jspb.test.MapEntryOptionalKeysInt32Key'); |
|
goog.require('proto.jspb.test.MapEntryOptionalKeysInt64Key'); |
|
goog.require('proto.jspb.test.MapEntryOptionalKeysBoolKey'); |
|
goog.require('proto.jspb.test.MapEntryOptionalValuesStringValue'); |
|
goog.require('proto.jspb.test.MapEntryOptionalValuesInt32Value'); |
|
goog.require('proto.jspb.test.MapEntryOptionalValuesInt64Value'); |
|
goog.require('proto.jspb.test.MapEntryOptionalValuesBoolValue'); |
|
goog.require('proto.jspb.test.MapEntryOptionalValuesDoubleValue'); |
|
goog.require('proto.jspb.test.MapEntryOptionalValuesEnumValue'); |
|
goog.require('proto.jspb.test.MapEntryOptionalValuesMessageValue'); |
|
|
|
// CommonJS-LoadFromFile: test_pb proto.jspb.test |
|
goog.require('proto.jspb.test.MapValueMessageNoBinary'); |
|
goog.require('proto.jspb.test.TestMapFieldsNoBinary'); |
|
|
|
/** |
|
* Helper: check that the given map has exactly this set of (sorted) entries. |
|
* @param {!jspb.Map} map |
|
* @param {!Array<!Array<?>>} entries |
|
*/ |
|
function checkMapEquals(map, entries) { |
|
var arr = map.toArray(); |
|
assertEquals(arr.length, entries.length); |
|
for (var i = 0; i < arr.length; i++) { |
|
if (Array.isArray(arr[i])) { |
|
assertTrue(Array.isArray(entries[i])); |
|
assertArrayEquals(arr[i], entries[i]); |
|
} else { |
|
assertElementsEquals(arr[i], entries[i]); |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Converts an ES6 iterator to an array. |
|
* @template T |
|
* @param {!Iterator<T>} iter an iterator |
|
* @return {!Array<T>} |
|
*/ |
|
function toArray(iter) { |
|
var arr = []; |
|
while (true) { |
|
var val = iter.next(); |
|
if (val.done) { |
|
break; |
|
} |
|
arr.push(val.value); |
|
} |
|
return arr; |
|
} |
|
|
|
|
|
/** |
|
* Helper: generate test methods for this TestMapFields class. |
|
* @param {?} msgInfo |
|
* @param {?} submessageCtor |
|
* @param {string} suffix |
|
*/ |
|
function makeTests(msgInfo, submessageCtor, suffix) { |
|
/** |
|
* Helper: fill all maps on a TestMapFields. |
|
* @param {?} msg |
|
*/ |
|
var fillMapFields = function(msg) { |
|
msg.getMapStringStringMap().set('asdf', 'jkl;').set('key 2', 'hello world'); |
|
msg.getMapStringInt32Map().set('a', 1).set('b', -2); |
|
msg.getMapStringInt64Map().set('c', 0x100000000).set('d', 0x200000000); |
|
msg.getMapStringBoolMap().set('e', true).set('f', false); |
|
msg.getMapStringDoubleMap().set('g', 3.14159).set('h', 2.71828); |
|
msg.getMapStringEnumMap() |
|
.set('i', proto.jspb.test.MapValueEnum.MAP_VALUE_BAR) |
|
.set('j', proto.jspb.test.MapValueEnum.MAP_VALUE_BAZ); |
|
msg.getMapStringMsgMap() |
|
.set('k', new submessageCtor()) |
|
.set('l', new submessageCtor()); |
|
msg.getMapStringMsgMap().get('k').setFoo(42); |
|
msg.getMapStringMsgMap().get('l').setFoo(84); |
|
msg.getMapInt32StringMap().set(-1, 'a').set(42, 'b'); |
|
msg.getMapInt64StringMap().set(0x123456789abc, 'c').set(0xcba987654321, 'd'); |
|
msg.getMapBoolStringMap().set(false, 'e').set(true, 'f'); |
|
}; |
|
|
|
/** |
|
* Helper: check all maps on a TestMapFields. |
|
* @param {?} msg |
|
*/ |
|
var checkMapFields = function(msg) { |
|
checkMapEquals(msg.getMapStringStringMap(), [ |
|
['asdf', 'jkl;'], |
|
['key 2', 'hello world'] |
|
]); |
|
checkMapEquals(msg.getMapStringInt32Map(), [ |
|
['a', 1], |
|
['b', -2] |
|
]); |
|
checkMapEquals(msg.getMapStringInt64Map(), [ |
|
['c', 0x100000000], |
|
['d', 0x200000000] |
|
]); |
|
checkMapEquals(msg.getMapStringBoolMap(), [ |
|
['e', true], |
|
['f', false] |
|
]); |
|
checkMapEquals(msg.getMapStringDoubleMap(), [ |
|
['g', 3.14159], |
|
['h', 2.71828] |
|
]); |
|
checkMapEquals(msg.getMapStringEnumMap(), [ |
|
['i', proto.jspb.test.MapValueEnum.MAP_VALUE_BAR], |
|
['j', proto.jspb.test.MapValueEnum.MAP_VALUE_BAZ] |
|
]); |
|
checkMapEquals(msg.getMapInt32StringMap(), [ |
|
[-1, 'a'], |
|
[42, 'b'] |
|
]); |
|
checkMapEquals(msg.getMapInt64StringMap(), [ |
|
[0x123456789abc, 'c'], |
|
[0xcba987654321, 'd'] |
|
]); |
|
checkMapEquals(msg.getMapBoolStringMap(), [ |
|
[false, 'e'], |
|
[true, 'f'] |
|
]); |
|
|
|
assertEquals(msg.getMapStringMsgMap().getLength(), 2); |
|
assertEquals(msg.getMapStringMsgMap().get('k').getFoo(), 42); |
|
assertEquals(msg.getMapStringMsgMap().get('l').getFoo(), 84); |
|
|
|
var entries = toArray(msg.getMapStringMsgMap().entries()); |
|
assertEquals(entries.length, 2); |
|
entries.forEach(function(entry) { |
|
var key = entry[0]; |
|
var val = entry[1]; |
|
assert(val === msg.getMapStringMsgMap().get(key)); |
|
}); |
|
|
|
msg.getMapStringMsgMap().forEach(function(val, key) { |
|
assert(val === msg.getMapStringMsgMap().get(key)); |
|
}); |
|
}; |
|
|
|
it('testMapStringStringField' + suffix, function() { |
|
var msg = new msgInfo.constructor(); |
|
assertEquals(msg.getMapStringStringMap().getLength(), 0); |
|
assertEquals(msg.getMapStringInt32Map().getLength(), 0); |
|
assertEquals(msg.getMapStringInt64Map().getLength(), 0); |
|
assertEquals(msg.getMapStringBoolMap().getLength(), 0); |
|
assertEquals(msg.getMapStringDoubleMap().getLength(), 0); |
|
assertEquals(msg.getMapStringEnumMap().getLength(), 0); |
|
assertEquals(msg.getMapStringMsgMap().getLength(), 0); |
|
|
|
// Re-create to clear out any internally-cached wrappers, etc. |
|
msg = new msgInfo.constructor(); |
|
var m = msg.getMapStringStringMap(); |
|
assertEquals(m.has('asdf'), false); |
|
assertEquals(m.get('asdf'), undefined); |
|
m.set('asdf', 'hello world'); |
|
assertEquals(m.has('asdf'), true); |
|
assertEquals(m.get('asdf'), 'hello world'); |
|
m.set('jkl;', 'key 2'); |
|
assertEquals(m.has('jkl;'), true); |
|
assertEquals(m.get('jkl;'), 'key 2'); |
|
assertEquals(m.getLength(), 2); |
|
var it = m.entries(); |
|
assertElementsEquals(it.next().value, ['asdf', 'hello world']); |
|
assertElementsEquals(it.next().value, ['jkl;', 'key 2']); |
|
assertEquals(it.next().done, true); |
|
checkMapEquals(m, [ |
|
['asdf', 'hello world'], |
|
['jkl;', 'key 2'] |
|
]); |
|
m.del('jkl;'); |
|
assertEquals(m.has('jkl;'), false); |
|
assertEquals(m.get('jkl;'), undefined); |
|
assertEquals(m.getLength(), 1); |
|
it = m.keys(); |
|
assertEquals(it.next().value, 'asdf'); |
|
assertEquals(it.next().done, true); |
|
it = m.values(); |
|
assertEquals(it.next().value, 'hello world'); |
|
assertEquals(it.next().done, true); |
|
|
|
var count = 0; |
|
m.forEach(function(value, key, map) { |
|
assertEquals(map, m); |
|
assertEquals(key, 'asdf'); |
|
assertEquals(value, 'hello world'); |
|
count++; |
|
}); |
|
assertEquals(count, 1); |
|
|
|
m.clear(); |
|
assertEquals(m.getLength(), 0); |
|
}); |
|
|
|
|
|
/** |
|
* Tests operations on maps with all key and value types. |
|
*/ |
|
it('testAllMapTypes' + suffix, function() { |
|
var msg = new msgInfo.constructor(); |
|
fillMapFields(msg); |
|
checkMapFields(msg); |
|
}); |
|
|
|
|
|
if (msgInfo.deserializeBinary) { |
|
/** |
|
* Tests serialization and deserialization in binary format. |
|
*/ |
|
it('testBinaryFormat' + suffix, function() { |
|
if (goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(10)) { |
|
// IE8/9 currently doesn't support binary format because they lack |
|
// TypedArray. |
|
return; |
|
} |
|
|
|
// Check that the format is correct. |
|
var msg = new msgInfo.constructor(); |
|
msg.getMapStringStringMap().set('A', 'a'); |
|
var serialized = msg.serializeBinary(); |
|
var expectedSerialized = [ |
|
0x0a, 0x6, // field 1 (map_string_string), delimited, length 6 |
|
0x0a, 0x1, // field 1 in submessage (key), delimited, length 1 |
|
0x41, // ASCII 'A' |
|
0x12, 0x1, // field 2 in submessage (value), delimited, length 1 |
|
0x61 // ASCII 'a' |
|
]; |
|
assertEquals(serialized.length, expectedSerialized.length); |
|
for (var i = 0; i < serialized.length; i++) { |
|
assertEquals(serialized[i], expectedSerialized[i]); |
|
} |
|
|
|
// Check that all map fields successfully round-trip. |
|
msg = new msgInfo.constructor(); |
|
fillMapFields(msg); |
|
serialized = msg.serializeBinary(); |
|
var decoded = msgInfo.deserializeBinary(serialized); |
|
checkMapFields(decoded); |
|
}); |
|
|
|
/** |
|
* Tests deserialization of undefined map keys go to default values in |
|
* binary format. |
|
*/ |
|
it('testMapDeserializationForUndefinedKeys', function() { |
|
var testMessageOptionalKeys = new proto.jspb.test.TestMapFieldsOptionalKeys(); |
|
var mapEntryStringKey = new proto.jspb.test.MapEntryOptionalKeysStringKey(); |
|
mapEntryStringKey.setValue("a"); |
|
testMessageOptionalKeys.setMapStringString(mapEntryStringKey); |
|
var mapEntryInt32Key = new proto.jspb.test.MapEntryOptionalKeysInt32Key(); |
|
mapEntryInt32Key.setValue("b"); |
|
testMessageOptionalKeys.setMapInt32String(mapEntryInt32Key); |
|
var mapEntryInt64Key = new proto.jspb.test.MapEntryOptionalKeysInt64Key(); |
|
mapEntryInt64Key.setValue("c"); |
|
testMessageOptionalKeys.setMapInt64String(mapEntryInt64Key); |
|
var mapEntryBoolKey = new proto.jspb.test.MapEntryOptionalKeysBoolKey(); |
|
mapEntryBoolKey.setValue("d"); |
|
testMessageOptionalKeys.setMapBoolString(mapEntryBoolKey); |
|
var deserializedMessage = msgInfo.deserializeBinary( |
|
testMessageOptionalKeys.serializeBinary() |
|
); |
|
checkMapEquals(deserializedMessage.getMapStringStringMap(), [ |
|
['', 'a'] |
|
]); |
|
checkMapEquals(deserializedMessage.getMapInt32StringMap(), [ |
|
[0, 'b'] |
|
]); |
|
checkMapEquals(deserializedMessage.getMapInt64StringMap(), [ |
|
[0, 'c'] |
|
]); |
|
checkMapEquals(deserializedMessage.getMapBoolStringMap(), [ |
|
[false, 'd'] |
|
]); |
|
}); |
|
|
|
/** |
|
* Tests deserialization of undefined map values go to default values in |
|
* binary format. |
|
*/ |
|
it('testMapDeserializationForUndefinedValues', function() { |
|
var testMessageOptionalValues = |
|
new proto.jspb.test.TestMapFieldsOptionalValues(); |
|
var mapEntryStringValue = |
|
new proto.jspb.test.MapEntryOptionalValuesStringValue(); |
|
mapEntryStringValue.setKey("a"); |
|
testMessageOptionalValues.setMapStringString(mapEntryStringValue); |
|
var mapEntryInt32Value = |
|
new proto.jspb.test.MapEntryOptionalValuesInt32Value(); |
|
mapEntryInt32Value.setKey("b"); |
|
testMessageOptionalValues.setMapStringInt32(mapEntryInt32Value); |
|
var mapEntryInt64Value = |
|
new proto.jspb.test.MapEntryOptionalValuesInt64Value(); |
|
mapEntryInt64Value.setKey("c"); |
|
testMessageOptionalValues.setMapStringInt64(mapEntryInt64Value); |
|
var mapEntryBoolValue = |
|
new proto.jspb.test.MapEntryOptionalValuesBoolValue(); |
|
mapEntryBoolValue.setKey("d"); |
|
testMessageOptionalValues.setMapStringBool(mapEntryBoolValue); |
|
var mapEntryDoubleValue = |
|
new proto.jspb.test.MapEntryOptionalValuesDoubleValue(); |
|
mapEntryDoubleValue.setKey("e"); |
|
testMessageOptionalValues.setMapStringDouble(mapEntryDoubleValue); |
|
var mapEntryEnumValue = |
|
new proto.jspb.test.MapEntryOptionalValuesEnumValue(); |
|
mapEntryEnumValue.setKey("f"); |
|
testMessageOptionalValues.setMapStringEnum(mapEntryEnumValue); |
|
var mapEntryMessageValue = |
|
new proto.jspb.test.MapEntryOptionalValuesMessageValue(); |
|
mapEntryMessageValue.setKey("g"); |
|
testMessageOptionalValues.setMapStringMsg(mapEntryMessageValue); |
|
var deserializedMessage = msgInfo.deserializeBinary( |
|
testMessageOptionalValues.serializeBinary() |
|
); |
|
checkMapEquals(deserializedMessage.getMapStringStringMap(), [ |
|
['a', ''] |
|
]); |
|
checkMapEquals(deserializedMessage.getMapStringInt32Map(), [ |
|
['b', 0] |
|
]); |
|
checkMapEquals(deserializedMessage.getMapStringInt64Map(), [ |
|
['c', 0] |
|
]); |
|
checkMapEquals(deserializedMessage.getMapStringBoolMap(), [ |
|
['d', false] |
|
]); |
|
checkMapEquals(deserializedMessage.getMapStringDoubleMap(), [ |
|
['e', 0.0] |
|
]); |
|
checkMapEquals(deserializedMessage.getMapStringEnumMap(), [ |
|
['f', 0] |
|
]); |
|
checkMapEquals(deserializedMessage.getMapStringMsgMap(), [ |
|
['g', []] |
|
]); |
|
}); |
|
} |
|
|
|
|
|
/** |
|
* Exercises the lazy map<->underlying array sync. |
|
*/ |
|
it('testLazyMapSync' + suffix, function() { |
|
// Start with a JSPB array containing a few map entries. |
|
var entries = [ |
|
['a', 'entry 1'], |
|
['c', 'entry 2'], |
|
['b', 'entry 3'] |
|
]; |
|
var msg = new msgInfo.constructor([entries]); |
|
assertEquals(entries.length, 3); |
|
assertEquals(entries[0][0], 'a'); |
|
assertEquals(entries[1][0], 'c'); |
|
assertEquals(entries[2][0], 'b'); |
|
msg.getMapStringStringMap().del('a'); |
|
assertEquals(entries.length, 3); // not yet sync'd |
|
msg.toArray(); // force a sync |
|
assertEquals(entries.length, 2); |
|
assertEquals(entries[0][0], 'b'); // now in sorted order |
|
assertEquals(entries[1][0], 'c'); |
|
|
|
var a = msg.toArray(); |
|
assertEquals(a[0], entries); // retains original reference |
|
}); |
|
|
|
/** |
|
* Returns IteratorIterables for entries(), keys() and values(). |
|
*/ |
|
it('testIteratorIterables' + suffix, function() { |
|
var msg = new msgInfo.constructor(); |
|
var m = msg.getMapStringStringMap(); |
|
m.set('key1', 'value1'); |
|
m.set('key2', 'value2'); |
|
var entryIterator = m.entries(); |
|
assertElementsEquals(entryIterator.next().value, ['key1', 'value1']); |
|
assertElementsEquals(entryIterator.next().value, ['key2', 'value2']); |
|
assertEquals(entryIterator.next().done, true); |
|
|
|
try { |
|
var entryIterable = m.entries()[Symbol.iterator](); |
|
assertElementsEquals(entryIterable.next().value, ['key1', 'value1']); |
|
assertElementsEquals(entryIterable.next().value, ['key2', 'value2']); |
|
assertEquals(entryIterable.next().done, true); |
|
} catch (err) { |
|
// jspb.Map.ArrayIteratorIterable_.prototype[Symbol.iterator] may be |
|
// undefined in some environment. |
|
if (err.name != 'TypeError' && err.name != 'ReferenceError') { |
|
throw err; |
|
} |
|
} |
|
|
|
var keyIterator = m.keys(); |
|
assertEquals(keyIterator.next().value, 'key1'); |
|
assertEquals(keyIterator.next().value, 'key2'); |
|
assertEquals(keyIterator.next().done, true); |
|
|
|
try { |
|
var keyIterable = m.keys()[Symbol.iterator](); |
|
assertEquals(keyIterable.next().value, 'key1'); |
|
assertEquals(keyIterable.next().value, 'key2'); |
|
assertEquals(keyIterable.next().done, true); |
|
} catch (err) { |
|
// jspb.Map.ArrayIteratorIterable_.prototype[Symbol.iterator] may be |
|
// undefined in some environment. |
|
if (err.name != 'TypeError' && err.name != 'ReferenceError') { |
|
throw err; |
|
} |
|
} |
|
var valueIterator = m.values(); |
|
assertEquals(valueIterator.next().value, 'value1'); |
|
assertEquals(valueIterator.next().value, 'value2'); |
|
assertEquals(valueIterator.next().done, true); |
|
|
|
try { |
|
var valueIterable = m.values()[Symbol.iterator](); |
|
assertEquals(valueIterable.next().value, 'value1'); |
|
assertEquals(valueIterable.next().value, 'value2'); |
|
assertEquals(valueIterable.next().done, true); |
|
} catch (err) { |
|
// jspb.Map.ArrayIteratorIterable_.prototype[Symbol.iterator] may be |
|
// undefined in some environment. |
|
if (err.name != 'TypeError' && err.name != 'ReferenceError') { |
|
throw err; |
|
} |
|
} |
|
}); |
|
} |
|
|
|
describe('mapsTest', function() { |
|
makeTests( |
|
{ |
|
constructor: proto.jspb.test.TestMapFields, |
|
deserializeBinary: proto.jspb.test.TestMapFields.deserializeBinary |
|
}, |
|
proto.jspb.test.MapValueMessage, '_Binary'); |
|
makeTests( |
|
{ |
|
constructor: proto.jspb.test.TestMapFieldsNoBinary, |
|
deserializeBinary: null |
|
}, |
|
proto.jspb.test.MapValueMessageNoBinary, '_NoBinary'); |
|
});
|
|
|