| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| /** |
| * @fileoverview Tests for canonicalize.js |
| */ |
| |
| var test = require('tape'); |
| |
| var BigInt = require('./../../src/vdl/big-int.js'); |
| var Complex = require('./../../src/vdl/complex.js'); |
| var kind = require('./../../src/vdl/kind.js'); |
| var registry = require('./../../src/vdl/registry.js'); |
| var Type = require('./../../src/vdl/type.js'); |
| var types = require('./../../src/vdl/types.js'); |
| var canonicalize = require('./../../src/vdl/canonicalize.js'); |
| var stringify = require('./../../src/vdl/stringify.js'); |
| require('../../src/vom/native-types'); |
| var Time = require('../../src/gen-vdl/v.io/v23/vdlroot/time').Time; |
| var makeError = require('../../src/verror/make-errors'); |
| var actions = require('../../src/verror/actions'); |
| |
| // A helper function that shallow copies an object into an object with the |
| // JSValue prototype. It makes the test cases a lot more readable. |
| function JS(obj) { |
| var JSValue = registry.lookupOrCreateConstructor(types.JSVALUE); |
| var jsval = Object.create(JSValue.prototype); |
| Object.keys(obj).forEach(function(key) { |
| jsval[key] = obj[key]; |
| }); |
| return jsval; |
| } |
| [ |
| { |
| name: 'null', |
| input: null, |
| output: null, |
| outputDeep: JS({ |
| 'null': {} |
| }) |
| }, |
| { |
| name: 'number', |
| input: 4, |
| output: 4, |
| outputDeep: JS({ |
| 'number': { |
| val: 4 |
| } |
| }) |
| }, |
| { |
| name: 'string', |
| input: 'fadasa', |
| output: 'fadasa', |
| outputDeep: JS({ |
| 'string': { |
| val: 'fadasa' |
| } |
| }) |
| }, |
| { |
| name: 'list', |
| input: [3, false, null, 'abc', undefined], |
| output: [3, false, null, 'abc', null], |
| outputDeep: JS({ |
| 'list': { |
| val: [ |
| { |
| val: JS({ |
| 'number': { val: 3 } |
| }) |
| }, |
| { |
| val: JS({ |
| 'boolean': { val: false } |
| }) |
| }, |
| { |
| val: JS({ |
| 'null': {} |
| }) |
| }, |
| { |
| val: JS({ |
| 'string': { val: 'abc' } |
| }) |
| }, |
| { |
| val: JS({ |
| 'null': {} |
| }) |
| } |
| ] |
| } |
| }) |
| }, |
| { |
| name: 'map', |
| input: new Map([ |
| [345, '345'], |
| [null, null] |
| ]), |
| output: new Map([ |
| [345, '345'], |
| [null, null] |
| ]), |
| outputDeep: JS({ |
| 'map': { |
| val: [ |
| { |
| key: { |
| val: JS({ 'number': { val: 345 } }) |
| }, |
| value: { |
| val: JS({ 'string': { val: '345' } }) |
| } |
| }, |
| { |
| key: { |
| val: JS({ 'null': {} }) |
| }, |
| value: { |
| val: JS({ 'null': {} }) |
| } |
| } |
| ] |
| } |
| }) |
| }, |
| { |
| name: 'object', |
| input: { name: '', servers: [], mT: false }, |
| output: { name: '', servers: [], mT: false }, |
| outputDeep: JS({ |
| 'object': { |
| val: [ |
| { |
| key: { |
| val: 'name' |
| }, |
| value: { |
| val: JS({ 'string': { val: '' } }) |
| } |
| }, |
| { |
| key: { |
| val: 'servers' |
| }, |
| value: { |
| val: JS({ 'list': { val: [] } }) |
| } |
| }, |
| { |
| key: { |
| val: 'mT' |
| }, |
| value: { |
| val: JS({ 'boolean': { val: false } }) |
| } |
| } |
| ] |
| } |
| }) |
| } |
| ].forEach(function(testCase) { |
| // Test basic JSValue canonicalization. Pure JSValues are used. |
| // TODO(alexfandrianto): It would be good to test a JSValue inside another |
| // type. For example, []JSValue or a struct with JSValues. |
| test('canonicalize JSValue - basic functionality - ' + |
| testCase.name, function(t) { |
| var input = testCase.input; |
| var expected = testCase.output; |
| var expectedDeep = testCase.outputDeep; |
| |
| var type = types.JSVALUE; |
| |
| // The input canonicalizes to the expected output. |
| var output = canonicalize.reduce(input, type); |
| t.deepEqual(output, expected, 'canon match'); |
| |
| // Canonicalize is idempotent. |
| var output2 = canonicalize.reduce(output, type); |
| t.deepEqual(output2, output, 'idempotent'); |
| |
| // The deep wrapped output should also match the expected deep output. |
| var outputDeep = canonicalize.fill(input, type); |
| t.deepEqual(outputDeep, expectedDeep, 'deep'); |
| |
| // This is also idempotent. |
| var outputDeep2 = canonicalize.fill(outputDeep, type); |
| t.deepEqual(outputDeep2, outputDeep, 'deep idempotent'); |
| |
| // DeepWrap(output) === outputDeep |
| var outputToDeep = canonicalize.fill(output, type); |
| t.deepEqual(outputToDeep, outputDeep, 'shallow to deep'); |
| |
| // Unwrap(outputDeep) === output |
| var outputDeepToShallow = canonicalize.reduce(outputDeep, type); |
| t.deepEqual(outputDeepToShallow, output, 'deep to shallow'); |
| |
| |
| // The type of the deep output must match. (Shallow lacks type.) |
| var expectedTypeStr = stringify(type); |
| var outputDeepTypeStr = stringify(outputDeep._type); |
| t.equal(outputDeepTypeStr, expectedTypeStr, 'top-level type match'); |
| t.end(); |
| }); |
| }); |
| |
| var Float32 = registry.lookupOrCreateConstructor(types.FLOAT32); |
| [ |
| { |
| name: 'list w/ typed values', |
| input: [3, false, null, 'abc', undefined, new Float32(3.14)], |
| output: [3, false, null, 'abc', null, new Float32(3.14)], |
| outputDeep: JS({ |
| 'list': { |
| val: [ |
| { |
| val: JS({ |
| 'number': { val: 3 } |
| }) |
| }, |
| { |
| val: JS({ |
| 'boolean': { val: false } |
| }) |
| }, |
| { |
| val: JS({ |
| 'null': {} |
| }) |
| }, |
| { |
| val: JS({ |
| 'string': { val: 'abc' } |
| }) |
| }, |
| { |
| val: JS({ |
| 'null': {} |
| }) |
| }, |
| { |
| val: new Float32(3.14)// any with wrapped float32 |
| } |
| ] |
| } |
| }) |
| }, |
| ].forEach(function(testCase) { |
| var name = 'canonicalize JSValue - mixed JSValue and non-JSValue ' + |
| 'functionality - ' + testCase.name; |
| test(name, function(t) { |
| var input = testCase.input; |
| var expected = testCase.output; |
| var expectedDeep = testCase.outputDeep; |
| var type = types.JSVALUE; |
| |
| // The input canonicalizes to the expected output. |
| var output = canonicalize.reduce(input, type); |
| t.deepEqual(output, expected); |
| |
| // Canonicalize is idempotent. |
| var output2 = canonicalize.reduce(output, type); |
| t.deepEqual(output2, output, 'idempotent'); |
| |
| // The deep wrapped output should also match the expected deep output. |
| var outputDeep = canonicalize.fill(input, type); |
| t.deepEqual(outputDeep, expectedDeep, 'deep'); |
| |
| // This is also idempotent. |
| var outputDeep2 = canonicalize.fill(outputDeep, type); |
| t.deepEqual(outputDeep2, outputDeep, 'deep idempotent'); |
| |
| // DeepWrap(output) === outputDeep |
| var outputToDeep = canonicalize.fill(output, type); |
| t.deepEqual(outputToDeep, outputDeep, 'shallow to deep'); |
| |
| // Unwrap(outputDeep) === output |
| var outputDeepToShallow = canonicalize.reduce(outputDeep, type); |
| t.deepEqual(outputDeepToShallow, output, 'deep to shallow'); |
| |
| |
| // The type of the deep output must match. (Shallow lacks type.) |
| var expectedTypeStr = stringify(type); |
| var outputDeepTypeStr = stringify(outputDeep._type); |
| t.equal(outputDeepTypeStr, expectedTypeStr, 'top-level type match'); |
| t.end(); |
| }); |
| }); |
| |
| var OptStringType = new Type({ |
| kind: kind.OPTIONAL, |
| elem: types.STRING |
| }); |
| var OptStr = registry.lookupOrCreateConstructor(OptStringType); |
| var AnyListType = new Type({ |
| kind: kind.LIST, |
| elem: types.ANY |
| }); |
| var BoolListType = new Type({ |
| kind: kind.LIST, |
| elem: types.BOOL |
| }); |
| |
| var ComplicatedStringStructType = new Type({ |
| kind: kind.STRUCT, |
| fields: [ |
| { |
| name: 'JSValueString', |
| type: types.ANY |
| }, |
| { |
| name: 'WrappedString', |
| type: types.STRING |
| }, |
| { |
| name: 'NativeString', |
| type: types.STRING |
| }, |
| { |
| name: 'AnyString', |
| type: types.ANY |
| }, |
| { |
| name: 'NullOptionalAny', |
| type: OptStringType |
| }, |
| { |
| name: 'OptionalToString', |
| type: OptStringType |
| }, |
| { |
| name: 'UndefinedToZeroString', |
| type: types.STRING |
| }, |
| { |
| name: 'UndefinedToZeroStringAny', |
| type: types.STRING |
| } |
| ] |
| }); |
| var ComplicatedBoolAnyListType = new Type({ |
| kind: kind.STRUCT, |
| fields: [ |
| { |
| name: 'BoolToAny', |
| type: BoolListType |
| }, |
| { |
| name: 'BoolToBool', |
| type: BoolListType |
| }, |
| { |
| name: 'AnyToBool', |
| type: AnyListType |
| }, |
| { |
| name: 'AnyToAny', |
| type: AnyListType |
| } |
| ] |
| }); |
| |
| var Bool = registry.lookupOrCreateConstructor(types.BOOL); |
| var Str = registry.lookupOrCreateConstructor(types.STRING); |
| var ComplicatedStringStruct = registry.lookupOrCreateConstructor( |
| ComplicatedStringStructType); |
| var ComplicatedBoolAnyList = registry.lookupOrCreateConstructor( |
| ComplicatedBoolAnyListType); |
| [ |
| { |
| name: 'empty object, no fields', |
| inputObject: {}, |
| inputFields: [], |
| outputObject: {}, |
| outputObjectDeep: {} |
| }, |
| { |
| name: 'object w/ private properties, no fields', |
| inputObject: {_private: 'I persist!'}, |
| inputFields: [], |
| outputObject: {_private: 'I persist!'}, |
| outputObjectDeep: {_private: 'I persist!'} |
| }, |
| { |
| name: 'normal object, no extra fields', |
| inputObject: { |
| a: 4, |
| b: 'can', |
| e: 'plan' |
| }, |
| inputFields: [ |
| { |
| name: 'A', |
| type: types.UINT32 |
| }, |
| { |
| name: 'B', |
| type: types.STRING |
| }, |
| { |
| name: 'E', |
| type: types.ANY |
| }, |
| ], |
| outputObject: { |
| a: 4, |
| b: 'can', |
| e: 'plan' // JSValue in ANY has no wrapping in shallow mode. |
| }, |
| outputObjectDeep: { |
| a: { val: 4 }, |
| b: { val: 'can' }, |
| e: { // any |
| val: { // INFERRED: JSValue(string). |
| string: { val: 'plan' } |
| } |
| } |
| } |
| }, |
| { |
| name: 'empty object, some fields', |
| inputObject: {}, |
| inputFields: [ |
| { |
| name: 'Man', |
| type: types.ANY |
| }, |
| { |
| name: 'Ban', |
| type: types.BOOL |
| }, |
| { |
| name: 'Dan', |
| type: types.COMPLEX64 |
| } |
| ], |
| outputObject: { |
| man: null, |
| ban: false, |
| dan: new Complex(0, 0) |
| }, |
| outputObjectDeep: { |
| man: { val: null }, |
| ban: { val: false }, |
| dan: { val: new Complex(0, 0) } |
| } |
| }, |
| { |
| name: 'struct with internal string/any', |
| inputObject: new ComplicatedStringStruct({ |
| jSValueString: 'go as JSValue', |
| wrappedString: new Str('overly wrapped input'), |
| nativeString: 'true string', |
| anyString: new Str('string any'), |
| nullOptionalAny: null, |
| optionalToString: new OptStr('non-empty string'), |
| undefinedToZeroString: undefined, |
| undefinedToZeroStringAny: undefined |
| }), |
| inputFields: [ |
| { |
| name: 'JSValueString', |
| type: types.ANY |
| }, |
| { |
| name: 'WrappedString', |
| type: types.ANY |
| }, |
| { |
| name: 'NativeString', |
| type: types.ANY |
| }, |
| { |
| name: 'AnyString', |
| type: types.STRING |
| }, |
| { |
| name: 'NullOptionalAny', |
| type: types.ANY |
| }, |
| { |
| name: 'OptionalToString', |
| type: types.STRING |
| }, |
| { |
| name: 'UndefinedToZeroString', |
| type: types.STRING |
| }, |
| { |
| name: 'UndefinedToZeroStringAny', |
| type: types.ANY |
| } |
| ], |
| outputObject: { |
| jSValueString: 'go as JSValue', |
| wrappedString: new Str('overly wrapped input'), |
| nativeString: new Str('true string'), |
| anyString: 'string any', |
| nullOptionalAny: { |
| val: null |
| }, |
| optionalToString: 'non-empty string', |
| undefinedToZeroString: '', |
| undefinedToZeroStringAny: new Str('') |
| }, |
| outputObjectDeep: { |
| jSValueString: { |
| val: { |
| string: { |
| val: 'go as JSValue' |
| } |
| } |
| }, |
| wrappedString: { |
| val: new Str('overly wrapped input') |
| }, |
| nativeString: { |
| val: new Str('true string') |
| }, |
| anyString: new Str('string any'), |
| nullOptionalAny: { |
| val: { |
| val: null |
| } |
| }, |
| optionalToString: new Str('non-empty string'), |
| undefinedToZeroString: new Str(''), |
| undefinedToZeroStringAny: { |
| val: new Str('') |
| } |
| } |
| }, |
| { |
| name: 'struct with internal []any and []bool', |
| inputObject: new ComplicatedBoolAnyList({ |
| boolToAny: [true, false, true], |
| boolToBool: [false, false], |
| anyToBool: [new Bool(true), new Bool(true), new Bool(false)], |
| anyToAny: [new Bool(true)] |
| }), |
| inputFields: [ |
| { |
| name: 'BoolToAny', |
| type: AnyListType |
| }, |
| { |
| name: 'BoolToBool', |
| type: BoolListType |
| }, |
| { |
| name: 'AnyToBool', |
| type: BoolListType |
| }, |
| { |
| name: 'AnyToAny', |
| type: AnyListType |
| }, |
| ], |
| outputObject: { |
| boolToAny: [new Bool(true), new Bool(false), new Bool(true)], |
| boolToBool: [false, false], |
| anyToBool: [true, true, false], |
| anyToAny: [new Bool(true)] |
| }, |
| outputObjectDeep: { |
| boolToAny: { |
| val: [ |
| { val: new Bool(true) }, |
| { val: new Bool(false) }, |
| { val: new Bool(true) } |
| ] |
| }, |
| boolToBool: { |
| val: [new Bool(false), new Bool(false)] |
| }, |
| anyToBool: { |
| val: [new Bool(true), new Bool(true), new Bool(false)] |
| }, |
| anyToAny: { |
| val: [{ val: new Bool(true) }] |
| }, |
| } |
| }, |
| { |
| name: 'simple zero values', |
| inputObject: {}, |
| inputFields: [ |
| { |
| name: 'Enum', |
| type: { |
| kind: kind.ENUM, |
| labels: ['Sunday', 'Monday', 'Tuesday'] |
| } |
| }, |
| { |
| name: 'Optional', |
| type: { |
| kind: kind.OPTIONAL, |
| elem: types.STRING |
| } |
| }, |
| { |
| name: 'String', |
| type: types.STRING |
| }, |
| { |
| name: 'Array', |
| type: { |
| kind: kind.ARRAY, |
| elem: types.BOOL, |
| len: 3 |
| } |
| }, |
| { |
| name: 'List', |
| type: { |
| kind: kind.LIST, |
| elem: types.BOOL |
| } |
| }, |
| { |
| name: 'Set', |
| type: { |
| kind: kind.SET, |
| key: types.UINT64 |
| } |
| }, |
| { |
| name: 'Map', |
| type: { |
| kind: kind.MAP, |
| key: types.STRING, |
| elem: types.STRING |
| } |
| }, |
| { |
| name: 'TypeObject', |
| type: types.TYPEOBJECT |
| } |
| ], |
| outputObject: { |
| 'enum': 'Sunday', |
| 'optional': null, |
| 'string': '', |
| 'array': [false, false, false], |
| 'list': [], |
| 'set': new Set(), |
| 'map': new Map(), |
| 'typeObject': types.ANY |
| }, |
| outputObjectDeep: { |
| 'enum': { val: 'Sunday' }, |
| 'optional': { val: null }, |
| 'string': { val: '' }, |
| 'array': { |
| val: [ |
| { val: false }, |
| { val: false }, |
| { val: false } |
| ] |
| }, |
| 'list': { |
| val: [] |
| }, |
| 'set': { |
| val: new Set() |
| }, |
| 'map': { |
| val: new Map() |
| }, |
| 'typeObject': types.ANY |
| } |
| }, |
| { |
| name: 'byte slice', |
| inputObject: {}, |
| inputFields: [ |
| { |
| name: 'ByteSlice', |
| type: { |
| kind: kind.LIST, |
| elem: types.BYTE |
| } |
| } |
| ], |
| outputObject: { |
| 'byteSlice': new Uint8Array() |
| }, |
| outputObjectDeep: { |
| 'byteSlice': { |
| val: new Uint8Array() |
| } |
| } |
| }, |
| { |
| name: 'byte array', |
| inputObject: {}, |
| inputFields: [ |
| { |
| name: 'ByteArray', |
| type: { |
| kind: kind.ARRAY, |
| elem: types.BYTE, |
| len: 4 |
| } |
| } |
| ], |
| outputObject: { |
| 'byteArray': new Uint8Array([0, 0, 0, 0]) |
| }, |
| outputObjectDeep: { |
| 'byteArray': { |
| val: new Uint8Array([0, 0, 0, 0]) |
| } |
| } |
| }, |
| { |
| name: 'recursive canonicalize - struct, union', |
| inputObject: {}, |
| inputFields: [ |
| { |
| name: 'Struct', |
| type: { |
| kind: kind.STRUCT, |
| fields: [ |
| { |
| name: 'A', |
| type: types.BOOL |
| }, |
| { |
| name: 'B', |
| type: types.UINT64 |
| } |
| ] |
| } |
| }, |
| { |
| name: 'Union', |
| type: { |
| kind: kind.UNION, |
| fields: [ |
| { |
| name: 'A', |
| type: types.BOOL |
| }, |
| { |
| name: 'B', |
| type: types.UINT64 |
| } |
| ] |
| } |
| } |
| ], |
| outputObject: { |
| 'struct': { |
| a: false, |
| b: new BigInt(0, new Uint8Array()) |
| }, |
| 'union': { |
| a: false |
| } |
| }, |
| outputObjectDeep: { |
| 'struct': { |
| a: { val: false }, |
| b: { val: new BigInt(0, new Uint8Array()) } |
| }, |
| 'union': { |
| a: { val: false } |
| } |
| } |
| } |
| ].forEach(function(testCase) { |
| test('canonicalize struct - basic functionality - ' + testCase.name, |
| function(t) { |
| var type = new Type({ |
| kind: kind.STRUCT, |
| fields: testCase.inputFields |
| }); |
| runNativeWireTest(testCase, type, t); |
| t.end(); |
| }); |
| }); |
| |
| function runNativeWireTest(test, type, t) { |
| var input = test.inputObject; |
| var expected = test.outputObject; |
| var expectedDeep = test.outputObjectDeep; |
| |
| // The input object and its fields canonicalize to the expected output. |
| var output = canonicalize.reduce(input, type); |
| t.deepEqual(output, expected); |
| |
| // Canonicalize is idempotent. |
| var output2 = canonicalize.reduce(output, type); |
| t.deepEqual(output2, output, 'idempotent'); |
| |
| // The deep wrapped output should also match the expected deep output. |
| var outputDeep = canonicalize.fill(input, type); |
| t.deepEqual(outputDeep, expectedDeep, 'deep'); |
| |
| // This is also idempotent. |
| var outputDeep2 = canonicalize.fill(outputDeep, type); |
| t.deepEqual(outputDeep2, outputDeep, 'deep idempotent'); |
| |
| // DeepWrap(output) === outputDeep |
| var outputToDeep = canonicalize.fill(output, type); |
| t.deepEqual(outputToDeep, outputDeep, ' - shallow to deep'); |
| |
| // Unwrap(outputDeep) === output |
| var outputDeepToShallow = canonicalize.reduce(outputDeep, type); |
| t.deepEqual(outputDeepToShallow, output, ' - deep to shallow'); |
| } |
| [ |
| { |
| name: 'filled union A, some fields', |
| inputObject: { |
| a: 4 |
| }, |
| inputFields: [ |
| { |
| name: 'A', |
| type: types.UINT32 |
| }, |
| { |
| name: 'B', |
| type: types.STRING |
| }, |
| { |
| name: 'E', |
| type: types.ANY |
| } |
| ], |
| outputObject: { |
| a: 4 |
| }, |
| outputObjectDeep: { |
| a: { |
| val: 4 |
| } |
| } |
| }, |
| { |
| name: 'filled union E, some fields', |
| inputObject: { |
| e: [4, 'asdf'] |
| }, |
| inputFields: [ |
| { |
| name: 'A', |
| type: types.UINT32 |
| }, |
| { |
| name: 'B', |
| type: types.STRING |
| }, |
| { |
| name: 'E', |
| type: types.ANY |
| } |
| ], |
| outputObject: { // any with []JSValue |
| e: [4, 'asdf'] |
| }, |
| outputObjectDeep: { |
| e: { // any |
| val: { // INFERRED: JSValue(list) |
| list: { |
| val: [ |
| { |
| val: { // any |
| number: { // JSValue(float64) |
| val: 4 |
| } |
| } |
| }, |
| { |
| val: { // any |
| string: { // JSValue(string) |
| val: 'asdf' |
| } |
| } |
| } |
| ] |
| } |
| } |
| } |
| } |
| }, |
| { |
| name: 'filled union with explicitly undefined fields', |
| inputObject: { |
| a: undefined, |
| b: 'and', |
| e: undefined |
| }, |
| inputFields: [ |
| { |
| name: 'A', |
| type: types.UINT32 |
| }, |
| { |
| name: 'B', |
| type: types.STRING |
| }, |
| { |
| name: 'E', |
| type: types.ANY |
| } |
| ], |
| outputObject: { |
| b: 'and' |
| }, |
| outputObjectDeep: { |
| b: { val: 'and' } |
| } |
| }, |
| { |
| name: 'union with private properties', |
| inputObject: { |
| a: undefined, |
| b: 'foo', |
| _private1: 'I LIVE!', |
| _private2: 'ME TOO!' |
| }, |
| inputFields: [ |
| { |
| name: 'A', |
| type: types.UINT32 |
| }, |
| { |
| name: 'B', |
| type: types.STRING |
| }, |
| { |
| name: 'E', |
| type: types.ANY |
| } |
| ], |
| outputObject: { |
| b: 'foo', |
| _private1: 'I LIVE!', |
| _private2: 'ME TOO!' |
| }, |
| outputObjectDeep: { |
| b: { val: 'foo' }, |
| _private1: 'I LIVE!', |
| _private2: 'ME TOO!' |
| } |
| } |
| ].forEach(function(testCase) { |
| test('canonicalize union - basic functionality ' + testCase.name, |
| function(t) { |
| var type = new Type({ |
| kind: kind.UNION, |
| fields: testCase.inputFields |
| }); |
| runNativeWireTest(testCase, type, t); |
| t.end(); |
| }); |
| }); |
| |
| var loopyList = { |
| kind: kind.LIST |
| }; |
| loopyList.elem = loopyList; |
| var expectedLoopyList = { |
| name: '', |
| kind: kind.LIST |
| }; |
| expectedLoopyList.elem = expectedLoopyList; |
| |
| // Ensures that valid types don't error out when canonicalizing. |
| [ |
| { |
| name: 'undefined type => any', |
| inputType: undefined, |
| outputType: types.ANY |
| }, |
| { |
| name: 'simple list', |
| inputType: { |
| kind: kind.LIST, |
| elem: types.INT16 |
| }, |
| outputType: { |
| name: '', |
| kind: kind.LIST, |
| elem: types.INT16 |
| } |
| }, |
| { |
| name: 'typeobject', |
| inputType: { |
| kind: kind.TYPEOBJECT |
| }, |
| outputType: types.TYPEOBJECT |
| }, |
| { |
| name: 'loopyList', |
| inputType: loopyList, |
| outputType: expectedLoopyList |
| } |
| ].forEach(function(testCase) { |
| test('canonicalize type - basic functionality - ' + testCase.name, |
| function(t) { |
| var input = testCase.inputType; |
| var expected = testCase.outputType; |
| |
| // The input object and its fields canonicalize to the expected output. |
| // Since TypeObjects can be recursive, it's best to stringify them. |
| var output = canonicalize.type(input); |
| var outputStr = stringify(output); |
| var expectedStr = stringify(expected); |
| t.equal(outputStr, expectedStr); |
| |
| // Canonicalize Type is idempotent. |
| var output2 = canonicalize.type(output); |
| var output2Str = stringify(output2); |
| t.equal(output2Str, expectedStr, 'idempotent'); |
| |
| // Post-canonicalization, the type is still a TypeObject. |
| t.deepEqual(output._type, types.TYPEOBJECT, 'type is TypeObject'); |
| t.end(); |
| }); |
| }); |
| |
| // TODO(alexfandrianto): Add a general idempotency test since we always expect |
| // canonicalize and canonicalizeType to be idempotent when successful. |
| |
| |
| // TODO(alexfandrianto): Perhaps this test is not necessary anymore; we have |
| // other coverage, and it seems like it's just checking that deep wrap converts |
| // to shallow wrap. |
| var Int16 = registry.lookupOrCreateConstructor(types.INT16); |
| var Int64 = registry.lookupOrCreateConstructor(types.INT64); |
| var Uint32 = registry.lookupOrCreateConstructor(types.UINT32); |
| var Complex64 = registry.lookupOrCreateConstructor(types.COMPLEX64); |
| var Uint32Uint32Map = registry.lookupOrCreateConstructor({ |
| kind: kind.MAP, |
| name: '', |
| key: types.INT32, |
| elem: types.INT32 |
| }); |
| var KindNameStruct = registry.lookupOrCreateConstructor({ |
| kind: kind.STRUCT, |
| name: '', |
| fields: [ |
| { |
| name: 'kind', |
| type: types.UINT32 |
| }, |
| { |
| name: 'Name', |
| type: types.STRING |
| } |
| ] |
| }); |
| var ABUnion = registry.lookupOrCreateConstructor({ |
| kind: kind.UNION, |
| name: '', |
| fields: [ |
| { |
| name: 'A', |
| type: types.UINT32 |
| }, |
| { |
| name: 'B', |
| type: types.STRING |
| } |
| ] |
| }); |
| var ABStruct = registry.lookupOrCreateConstructor({ |
| kind: kind.STRUCT, |
| name: '', |
| fields: [ |
| { |
| name: 'A', |
| type: types.UINT32 |
| }, |
| { |
| name: 'B', |
| type: types.STRING |
| } |
| ] |
| }); |
| var AnyStrStruct = registry.lookupOrCreateConstructor({ |
| kind: kind.STRUCT, |
| name: '', |
| fields: [ |
| { |
| name: 'Any', |
| type: types.ANY |
| }, |
| { |
| name: 'Normal', |
| type: types.STRING |
| } |
| ] |
| }); |
| [ |
| { |
| name: 'top-level only', |
| input: new Int16(5, true), |
| expected: new Int16(5) |
| }, |
| { |
| name: 'wrapped big int', |
| input: new Int64(new BigInt(1, new Uint8Array([0x10, 0xff])), true), |
| expected: new Int64(new BigInt(1, new Uint8Array([0x10, 0xff]))) |
| }, |
| { |
| name: 'wrapped complex', |
| input: new Complex64(new Complex(4, 5), true), |
| expected: new Complex64(new Complex(4, 5)) |
| }, |
| { |
| name: 'map', |
| input: new Uint32Uint32Map(new Map([[3, 4], [6, 3]]), true), |
| expected: new Uint32Uint32Map(new Map([[3, 4], [6, 3]])) |
| }, |
| { |
| name: 'fake typeobject', |
| input: new KindNameStruct({ |
| kind: new Uint32(3, true), |
| name: new Str('Boolean', true) |
| }, true), |
| expected: { |
| kind: 3, |
| name: 'Boolean' |
| } |
| }, |
| { |
| name: 'union', |
| input: new ABUnion({ |
| b: new Str('abc', true), |
| }, true), |
| expected: { |
| b: 'abc' |
| } |
| }, |
| { |
| name: 'struct', |
| input: new ABStruct({ |
| a: new Uint32(3, true), |
| b: new Str('abc', true) |
| }, true), |
| expected: { |
| a: 3, |
| b: 'abc', |
| } |
| }, |
| { |
| name: 'Struct with ANY', |
| input: new AnyStrStruct({ |
| any: new Str('wrapped', true), |
| normal: new Str('shallow', true) |
| }, true), |
| expected: { |
| any: new Str('wrapped'), |
| normal: 'shallow' |
| } |
| } |
| ].forEach(function(testCase) { |
| test('canonicalize deep to shallow - basic functionality ' + testCase.name, |
| function(t) { |
| testDeepWrapToUnwrap(t, testCase); |
| t.end(); |
| }); |
| }); |
| |
| // TODO(alexfandrianto): DeepWrapToUnwrap can be expanded to test more, just |
| // like the canonicalize struct and union tests. In fact, this tests basic |
| // canonicalization, since it includes more types than just struct/union. |
| // So the TODO is to convert this into a basic canonicalization test. |
| function testDeepWrapToUnwrap(t, test) { |
| var input = test.input; |
| var expected = test.expected; |
| |
| // Canonicalize without wrapping deeply. |
| var output = canonicalize.reduce(input, input._type); |
| |
| // Compare with stringify; the output/expected could be recursive. |
| var expectedStr = stringify(expected); |
| var outputStr = stringify(output); |
| t.equal(outputStr, expectedStr); |
| |
| // The types must also match. |
| var type = input._type; |
| var expectedTypeStr = stringify(type); |
| var outputTypeStr = stringify(output._type); |
| t.equal(outputTypeStr, expectedTypeStr, 'top-level type match'); |
| } |
| |
| |
| // This test checks the successful cases of value to type conversion. |
| // For example, some structs can convert to maps, and non-null optionals convert |
| // to their base type. |
| // This test supplements the cross-language conversion tests cases in |
| // test-vom-compatible.js |
| // |
| var StringListType = new Type({ |
| kind: kind.LIST, |
| elem: types.STRING |
| }); |
| var ByteListType = new Type({ |
| kind: kind.LIST, |
| elem: types.BYTE |
| }); |
| var MyEnumType = new Type({ |
| kind: kind.ENUM, |
| labels: ['M', 'A', 'G'] |
| }); |
| var IntSetType = new Type({ |
| kind: kind.SET, |
| key: types.INT16 |
| }); |
| var FloatBoolMapType = new Type({ |
| kind: kind.MAP, |
| key: types.FLOAT32, |
| elem: types.BOOL |
| }); |
| var StringSetType = new Type({ |
| kind: kind.SET, |
| key: types.STRING |
| }); |
| var StringyStructType = new Type({ |
| kind: kind.STRUCT, |
| fields: [ |
| { |
| name: 'Ma', |
| type: types.STRING |
| }, |
| { |
| name: 'Bu', |
| type: ByteListType |
| }, |
| { |
| name: 'Fu', |
| type: MyEnumType |
| } |
| ] |
| }); |
| var StringStringMapType = new Type({ |
| kind: kind.MAP, |
| key: types.STRING, |
| elem: types.STRING |
| }); |
| var StringAnyMapType = new Type({ |
| kind: kind.MAP, |
| key: types.STRING, |
| elem: types.ANY |
| }); |
| var Byte10ArrayType = new Type({ |
| kind: kind.ARRAY, |
| elem: types.BYTE, |
| len: 10 |
| }); |
| var StructABCType = new Type({ |
| kind: kind.STRUCT, |
| fields: [ |
| { |
| name: 'A', |
| type: types.BOOL |
| }, |
| { |
| name: 'B', |
| type: types.STRING |
| }, |
| { |
| name: 'C', |
| type: types.UINT32 |
| } |
| ] |
| }); |
| var StructCDBType = new Type({ |
| kind: kind.STRUCT, |
| fields: [ |
| { |
| name: 'C', |
| type: types.UINT32 |
| }, |
| { |
| name: 'D', |
| type: OptStringType |
| }, |
| { |
| name: 'B', |
| type: types.STRING |
| } |
| ] |
| }); |
| |
| var Any = registry.lookupOrCreateConstructor(types.ANY); |
| var AnyList = registry.lookupOrCreateConstructor(AnyListType); |
| var StrList = registry.lookupOrCreateConstructor(StringListType); |
| var IntSet = registry.lookupOrCreateConstructor(IntSetType); |
| var FloatBoolMap = registry.lookupOrCreateConstructor(FloatBoolMapType); |
| var ByteList = registry.lookupOrCreateConstructor(ByteListType); |
| var Byte10Array = registry.lookupOrCreateConstructor(Byte10ArrayType); |
| var MyEnum = registry.lookupOrCreateConstructor(MyEnumType); |
| var StructABC = registry.lookupOrCreateConstructor(StructABCType); |
| var StructCDB = registry.lookupOrCreateConstructor(StructCDBType); |
| var StringSet = registry.lookupOrCreateConstructor(StringSetType); |
| var StringStringMap = registry.lookupOrCreateConstructor(StringStringMapType); |
| var StringAnyMap = registry.lookupOrCreateConstructor(StringAnyMapType); |
| var StringyStruct = registry.lookupOrCreateConstructor(StringyStructType); |
| |
| [ |
| { |
| name: 'Any(String) to String', |
| inValue: new Any(new Str('fff')), |
| outValue: new Str('fff'), |
| targetType: types.STRING |
| }, |
| { |
| name: 'String to Any(String)', |
| inValue: new Str('fff'), |
| outValue: new Any(new Str('fff')), |
| targetType: types.ANY |
| }, |
| { |
| name: '[]Any to []String', |
| // Note: 'jsval' is a JSValue that happens to convert to a string. |
| // This cannot always be expected to work, however. |
| inValue: new AnyList([new Str('fff'), 'jsval']), |
| outValue: new StrList(['fff', 'jsval']), |
| targetType: StringListType |
| }, |
| { |
| name: '[]string to []any', |
| inValue: new StrList(['fff', 'not jsval']), |
| outValue: new AnyList([new Str('fff'), new Str('not jsval')]), |
| targetType: AnyListType |
| }, |
| { |
| name: 'OptString to String', |
| inValue: new OptStr('abc'), |
| outValue: new Str('abc'), |
| targetType: types.STRING |
| }, |
| { |
| name: 'String to ByteArray', |
| inValue: '1234567', |
| outValue: new Byte10Array( |
| new Uint8Array([49, 50, 51, 52, 53, 54, 55, 0, 0, 0]) |
| ), |
| targetType: Byte10ArrayType |
| }, |
| { |
| name: 'Set to Map', |
| inValue: new IntSet(new Set([4, -5, 8])), |
| outValue: new FloatBoolMap(new Map([[4, true], [-5, true], [8, true]])), |
| targetType: FloatBoolMapType |
| }, |
| { |
| name: 'Map to Set', |
| inValue: new FloatBoolMap(new Map([[4, false], [-5, true], [8, true]])), |
| outValue: new IntSet(new Set([-5, 8])), |
| targetType: IntSetType |
| }, |
| { |
| name: 'StructABC to StructCDB', |
| inValue: new StructABC({ |
| a: true, |
| b: 'boom', |
| c: 5 |
| }), |
| outValue: new StructCDB({ |
| b: 'boom', |
| c: 5, |
| d: undefined |
| }), |
| targetType: StructCDBType |
| }, |
| { |
| name: 'StructCDB to StructABC', |
| inValue: new StructCDB({ |
| d: null, |
| b: 'doom', |
| c: 6 |
| }), |
| outValue: new StructABC({ |
| a: undefined, |
| b: 'doom', |
| c: 6 |
| }), |
| targetType: StructABCType |
| }, |
| { |
| name: 'set[string] to map[string]any', |
| inValue: new StringSet( |
| new Set(['me', 'di', 'a']) |
| ), |
| outValue: new StringAnyMap( |
| new Map([ |
| ['me', new Bool(true)], |
| ['di', new Bool(true)], |
| ['a', new Bool(true)] |
| ]) |
| ), |
| targetType: StringAnyMapType |
| }, |
| { |
| name: 'struct with string-y fields to map[string]any', |
| inValue: new StringyStruct({ |
| ma: 'Pool', // string |
| bu: 'imp', // bytelist 105 109 112 |
| fu: 'A' // autoconverts to enum |
| }), |
| outValue: new StringAnyMap(new Map([ |
| ['Ma', new Str('Pool')], |
| ['Bu', new ByteList(new Uint8Array([105, 109, 112]))], |
| ['Fu', new MyEnum('A')] |
| ])), |
| targetType: StringAnyMapType |
| }, |
| { |
| name: 'struct with string-y fields to map[string]string', |
| inValue: new StringyStruct({ |
| ma: 'Pool', |
| bu: 'imp', |
| fu: 'A' |
| }), |
| outValue: new StringStringMap(new Map([ |
| ['Ma', 'Pool'], |
| ['Bu', 'imp'], |
| ['Fu', 'A'] |
| ])), |
| targetType: StringStringMapType |
| }, |
| { |
| name: 'map[string]any to struct with stringy-fields', |
| inValue: new StringAnyMap(new Map([ |
| ['Ma', 'V'], // JSValue happens to be string-compatible. |
| ['Bu', new ByteList(new Uint8Array([79]))], |
| ['Fu', new MyEnum('M')] |
| ])), |
| outValue: new StringyStruct({ |
| ma: 'V', |
| bu: 'O', // bytelist 79 |
| fu: 'M' // enum with M |
| }), |
| targetType: StringyStructType |
| }, |
| { |
| name: 'map[string]any to set[string]', |
| inValue: new StringAnyMap(new Map([ |
| ['Z', true], // JSValue that happens to be bool-compatible |
| ['o', new Bool(true)], |
| ['nga', false], // Will not appear since it's false |
| ['dine', new Bool(true)] |
| ])), |
| outValue: new StringSet(new Set([ |
| 'Z', 'o', 'dine' |
| ])), |
| targetType: StringSetType |
| } |
| ].forEach(function(testCase) { |
| var testName = 'canonicalize conversion - success - ' + testCase.name; |
| test(testName, function(t) { |
| var reduced = canonicalize.reduce(testCase.inValue, testCase.targetType); |
| var outValue = testCase.outValue; |
| t.deepEqual( |
| stringify(reduced), |
| stringify(outValue), |
| test.name + ' converts correctly' |
| ); |
| t.end(); |
| }); |
| }); |
| |
| test('canonicalize error', function(t) { |
| var E = makeError('MyId', actions.NO_RETRY, '', [ |
| types.STRING, types.INT32 ]); |
| |
| // There are two different values of native errors we expect. The first is |
| // the value that the developer will pass in. It's paramList will not have |
| // any wrapped elements. The second is the result of the conversion from the |
| // wire format to the native format. In this form, the individual values of |
| // in the paramList will be wrapped since they are of type any. This is |
| // strictly correct, but cumbersome. This is probably ok since we want to |
| // strongly discourage the use of the paramList programmatically. |
| var err = new E(null, 'foo', 32); |
| err.msg = 'My awesome message!!!'; |
| Object.defineProperty(err, 'message', { value: err.msg }); |
| var wrappedErr = err.clone(); |
| wrappedErr.paramList = wrappedErr.paramList.map(function(v) { |
| return { val: v }; |
| }); |
| |
| var VerrorConstructor = registry.lookupOrCreateConstructor(types.ERROR.elem); |
| var Int32 = registry.lookupOrCreateConstructor(types.INT32); |
| |
| var wrappedMessage = new VerrorConstructor({ |
| id: 'MyId', |
| retryCode: actions.NO_RETRY, |
| msg: 'My awesome message!!!', |
| paramList: [new Str('app'), new Str('op'), new Str('foo'), new Int32(32)] |
| }, true); |
| |
| var wrappedMessageWithLangId = new VerrorConstructor({ |
| id: 'MyId', |
| retryCode: actions.NO_RETRY, |
| msg: 'My awesome message!!!', |
| paramList: [new Str('app'), new Str('op'), new Str('foo'), new Int32(32)] |
| }, true); |
| |
| // When we convert from native type to wire type we transfer the _ |
| wrappedMessageWithLangId._langId = 'en-US'; |
| var tests = [ |
| { |
| name: 'err, deepWrap = false', |
| inValue: err, |
| deepWrap: false, |
| outValue: { val: wrappedErr }, // any(error) |
| }, { |
| name: 'err, deepWrap = true', |
| inValue: err, |
| deepWrap: true, |
| outValue: { val: wrappedMessageWithLangId }, // any(error) deep |
| }, { |
| name: 'wrappedMessage, deepWrap = false', |
| inValue: wrappedMessage, |
| deepWrap: false, |
| outValue: { val: wrappedErr }, // any(error) |
| }, { |
| name: 'wrappedMessage, deepWrap = true', |
| inValue: wrappedMessage, |
| deepWrap: true, |
| outValue: { val: wrappedMessage }, // any(error) deep |
| }, |
| { |
| name: '?err, deepWrap = false', |
| inValue: err, |
| type: types.ERROR, |
| deepWrap: false, |
| outValue: { val: wrappedErr } // optional(error) |
| }, |
| { |
| name: '?err, deepWrap = true', |
| inValue: err, |
| type: types.ERROR, |
| deepWrap: true, |
| outValue: { val: wrappedMessageWithLangId } // optional(error) deep |
| } |
| ]; |
| |
| for (var i = 0; i < tests.length; i++) { |
| var test = tests[i]; |
| |
| var type = test.type || types.ANY; |
| var canon = canonicalize.value(test.inValue, type, test.deepWrap); |
| var outValue = test.outValue; |
| t.deepEqual( |
| stringify(canon), |
| stringify(outValue), |
| test.name); |
| } |
| t.end(); |
| }); |
| |
| test('canonicalize time (to any)', function(t) { |
| var d = new Date(1999,11,30,23,59,59); |
| var conv = Date.parse('0001-01-01') / 1000; |
| var millis = d.getTime(); |
| var timeStruct = new Time({ |
| seconds: millis / 1000 - conv, |
| nanos: 0, |
| }, true); |
| |
| var tests = [{ |
| name: 'date deepWrap = true', |
| inValue: d, |
| deepWrap: true, |
| outValue: { |
| val: timeStruct |
| } |
| }, { |
| name: 'date deepWrap = false', |
| inValue: d, |
| deepWrap: false, |
| outValue: { val: d } |
| }, { |
| name: 'time.Time deepWrap = true', |
| inValue: timeStruct, |
| deepWrap: true, |
| outValue: { |
| val: timeStruct |
| }, |
| },{ |
| name: 'time.Time deepWrap = false', |
| inValue: timeStruct, |
| deepWrap: false, |
| outValue: { |
| val: d |
| } |
| }]; |
| |
| for (var i = 0; i < tests.length; i++) { |
| var test = tests[i]; |
| |
| var canon = canonicalize.value(test.inValue, types.ANY, test.deepWrap); |
| var outValue = test.outValue; |
| t.deepEqual( |
| stringify(canon), |
| stringify(outValue), |
| test.name); |
| } |
| t.end(); |
| }); |
| |
| // Tests the combination of native and vdl values. |
| var TimeType = Time.prototype._type; |
| var TimeArray = new Type({ |
| kind: kind.ARRAY, |
| elem: TimeType, |
| len: 3 |
| }); |
| var TimeErrStruct = new Type({ |
| kind: kind.STRUCT, |
| fields: [ |
| { |
| name: 'Time', |
| type: TimeType |
| }, |
| { |
| name: 'Err', |
| type: types.ERROR |
| } |
| ] |
| }); |
| |
| // The canonical error (input) and its wrapped paramList form. |
| var CanonError = makeError( |
| 'cerrID', |
| actions.RETRY_BACKOFF, |
| 'Canonical Error', |
| [ types.STRING, types.INT32 ] |
| ); |
| var cError = new CanonError(null, 'blue', -1); // no ctx, string, int32 |
| var cErrorN = cError.clone(); // The reduced cError params should be wrapped. |
| cErrorN.paramList = cError.paramList.map(function(p) { |
| return { val: p }; |
| }); |
| |
| // Additional constants |
| var MILLI_TO_NANO = 1000*1000; |
| var zeroDateOffset = Date.parse('0001-01-01'); |
| |
| [ |
| { |
| name: 'TimeArray', |
| type: TimeArray, |
| inputObject: [ |
| new Date(zeroDateOffset), |
| new Date(zeroDateOffset+100), |
| new Date(zeroDateOffset-2001) |
| ], |
| outputObject: { |
| val: [ |
| new Date(zeroDateOffset), |
| new Date(zeroDateOffset+100), |
| new Date(zeroDateOffset-2001) |
| ] |
| }, |
| outputObjectDeep: { |
| val: [ |
| { |
| seconds: { val: BigInt.fromNativeNumber(0) }, |
| nanos: { val: 0 } |
| }, |
| { |
| seconds: { val: BigInt.fromNativeNumber(0) }, |
| nanos: { val: 100*MILLI_TO_NANO } |
| }, |
| { |
| seconds: { val: BigInt.fromNativeNumber(-3) }, |
| nanos: { val: 999*MILLI_TO_NANO } |
| } |
| ] |
| } |
| }, |
| { |
| name: 'TimeArray (empty)', |
| type: TimeArray, |
| inputObject: undefined, |
| outputObject: { |
| val: [new Date(zeroDateOffset), new Date(zeroDateOffset), |
| new Date(zeroDateOffset)] |
| }, |
| outputObjectDeep: { |
| val: [ |
| { |
| seconds: { val: BigInt.fromNativeNumber(0) }, |
| nanos: { val: 0 } |
| }, |
| { |
| seconds: { val: BigInt.fromNativeNumber(0) }, |
| nanos: { val: 0 } |
| }, |
| { |
| seconds: { val: BigInt.fromNativeNumber(0) }, |
| nanos: { val: 0 } |
| }, |
| ] |
| } |
| }, |
| { |
| name: 'TimeErrStruct (empty)', |
| type: TimeErrStruct, |
| inputObject: undefined, |
| outputObject: { |
| time: new Date(zeroDateOffset), |
| err: null, |
| }, |
| outputObjectDeep: { |
| time: { |
| seconds: { val: BigInt.fromNativeNumber(0) }, |
| nanos: { val: 0 } |
| }, |
| err: { val: null } |
| } |
| }, |
| { |
| name: 'TimeErrStruct', |
| type: TimeErrStruct, |
| inputObject: { |
| time: new Date(zeroDateOffset+4024), |
| err: cError |
| }, |
| outputObject: { |
| time: new Date(zeroDateOffset+4024), |
| err: cErrorN |
| }, |
| outputObjectDeep: { |
| time: { |
| seconds: { val: BigInt.fromNativeNumber(4) }, |
| nanos: { val: 24 * MILLI_TO_NANO } |
| }, |
| err: { // optional error |
| val: { // error |
| _langId: 'en-US', |
| id: { val: 'cerrID' }, |
| retryCode: { val: actions.RETRY_BACKOFF }, |
| msg: { val: 'Canonical Error' }, |
| paramList: { |
| val: [ |
| { // any(string) |
| val: { val: 'app' } |
| }, |
| { // any(string) |
| val: { val: 'op' } |
| }, |
| { // any(string) |
| val: { val: 'blue' } |
| }, |
| { // any(int32) |
| val: { val: -1 } |
| } |
| ] |
| } |
| } |
| } |
| } |
| } |
| ].forEach(function(testCase) { |
| test('canonicalize native and vdl -' + testCase.name, function(t) { |
| runNativeWireTest(testCase, testCase.type, t); |
| t.end(); |
| }); |
| }); |
| |
| var IntListType = new Type({ |
| kind: kind.LIST, |
| elem: types.INT32 |
| }); |
| var Int3ArrType = new Type({ |
| kind: kind.ARRAY, |
| elem: types.INT32, |
| len: 3 |
| }); |
| |
| var IntList = registry.lookupOrCreateConstructor(IntListType); |
| // This test checks the failure cases of value to type conversion. |
| // For example, some maps fail to convert to sets, and null optional values |
| // cannot convert to their base type. |
| // This test supplements the cross-language conversion tests cases in |
| // test-vom-compatible.js |
| [ |
| { |
| name: 'number larger than MAX_FLOAT32', |
| inValue: 1e40, |
| targetType: types.FLOAT32, |
| expectedErr: 'is too large' |
| }, |
| { |
| name: 'imag smaller than MAX_FLOAT32 in Complex64', |
| inValue: { real: 0, imag: -1e40 }, |
| targetType: types.COMPLEX64, |
| expectedErr: 'is too small' |
| }, |
| { |
| name: 'negative, real Complex to uint', |
| inValue: new Complex(-4, 0), |
| targetType: types.UINT16, |
| expectedErr: 'value cannot be negative' |
| }, |
| { |
| name: 'null OptString to String', |
| inValue: new OptStr(null), |
| targetType: types.STRING, |
| expectedErr: 'value is null for non-optional type' |
| }, |
| { |
| name: 'String to Bool', |
| inValue: new Str('not a boolean'), |
| targetType: types.BOOL, |
| expectedErr: 'not compatible' |
| }, |
| { |
| name: 'String to Bool - native', |
| inValue: 'not a boolean', |
| targetType: types.BOOL, |
| expectedErr: 'value is not a boolean' |
| }, |
| { |
| name: 'large list to smaller array', |
| inValue: new IntList([3, 4, 8, 1]), |
| targetType: Int3ArrType, |
| expectedErr: 'exceeds type length 3' |
| }, |
| { |
| name: 'large list to smaller array - native', |
| inValue: [3, 4, 8, 1], |
| targetType: Int3ArrType, |
| expectedErr: 'exceeds type length 3' |
| }, |
| { |
| name: 'map to set', |
| inValue: new Map([[4, 'not a bool'], [5, true]]), |
| targetType: IntSetType, |
| expectedErr: 'this Map value cannot convert to Set' |
| } |
| ].forEach(function(testCase) { |
| test('canonicalize conversion - failure -' + testCase.name, function(t) { |
| t.throws( |
| canonicalize.reduce.bind(null, testCase.inValue, testCase.targetType), |
| new RegExp('.*' + (testCase.expectedErr || '') + '.*'), |
| 'fails to convert' |
| ); |
| t.end(); |
| }); |
| }); |
