tynder
Version:
TypeScript friendly Data validator for JavaScript.
808 lines (801 loc) • 43.7 kB
text/typescript
import { TypeAssertion } from '../types';
import { validate,
getType } from '../validator';
import { compile } from '../compiler';
import { serialize,
deserialize } from '../serializer';
describe("compiler-1", function() {
it("compiler-primitive", function() {
const schema = compile(`
type FooA = number;
type FooB = bigint;
type FooC = string;
type FooD = boolean;
type FooE = null;
type FooF = undefined;
type BarA = 3;
type BarB = 7n;
type BarC = 'XB';
type BarD = true;
type BazA = integer;
`);
{
expect(Array.from(schema.keys())).toEqual([
'FooA', 'FooB', 'FooC', 'FooD', 'FooE', 'FooF', 'BarA', 'BarB', 'BarC', 'BarD', 'BazA',
]);
}
for (const ty of [getType(deserialize(serialize(schema)), 'FooA'), getType(schema, 'FooA')]) {
const rhs: TypeAssertion = {
name: 'FooA',
typeName: 'FooA',
kind: 'primitive',
primitiveName: 'number',
};
expect(ty).toEqual(rhs);
expect(validate<number>(0, ty)).toEqual({value: 0});
expect(validate<number>(1, ty)).toEqual({value: 1});
expect(validate<number>(1.1, ty)).toEqual({value: 1.1});
expect(validate<number>(BigInt(0), ty)).toEqual(null);
expect(validate<number>(BigInt(1), ty)).toEqual(null);
expect(validate<number>('', ty)).toEqual(null);
expect(validate<number>('1', ty)).toEqual(null);
expect(validate<number>(false, ty)).toEqual(null);
expect(validate<number>(true, ty)).toEqual(null);
expect(validate<number>(null, ty)).toEqual(null);
expect(validate<number>(void 0, ty)).toEqual(null);
expect(validate<number>({}, ty)).toEqual(null);
expect(validate<number>([], ty)).toEqual(null);
expect(validate<number>(3, ty)).toEqual({value: 3});
expect(validate<number>(BigInt(7), ty)).toEqual(null);
expect(validate<number>('XB', ty)).toEqual(null);
expect(validate<number>(true, ty)).toEqual(null);
}
for (const ty of [getType(deserialize(serialize(schema)), 'FooB'), getType(schema, 'FooB')]) {
const rhs: TypeAssertion = {
name: 'FooB',
typeName: 'FooB',
kind: 'primitive',
primitiveName: 'bigint',
};
expect(ty).toEqual(rhs);
expect(validate<BigInt>(0, ty)).toEqual(null);
expect(validate<BigInt>(1, ty)).toEqual(null);
expect(validate<BigInt>(1.1, ty)).toEqual(null);
expect(validate<BigInt>(BigInt(0), ty)).toEqual({value: BigInt(0)});
expect(validate<BigInt>(BigInt(1), ty)).toEqual({value: BigInt(1)});
expect(validate<BigInt>('', ty)).toEqual(null);
expect(validate<BigInt>('1', ty)).toEqual(null);
expect(validate<BigInt>(false, ty)).toEqual(null);
expect(validate<BigInt>(true, ty)).toEqual(null);
expect(validate<BigInt>(null, ty)).toEqual(null);
expect(validate<BigInt>(void 0, ty)).toEqual(null);
expect(validate<BigInt>({}, ty)).toEqual(null);
expect(validate<BigInt>([], ty)).toEqual(null);
expect(validate<BigInt>(3, ty)).toEqual(null);
expect(validate<BigInt>(BigInt(7), ty)).toEqual({value: BigInt(7)});
expect(validate<BigInt>('XB', ty)).toEqual(null);
expect(validate<BigInt>(true, ty)).toEqual(null);
}
for (const ty of [getType(deserialize(serialize(schema)), 'FooC'), getType(schema, 'FooC')]) {
const rhs: TypeAssertion = {
name: 'FooC',
typeName: 'FooC',
kind: 'primitive',
primitiveName: 'string',
};
expect(ty).toEqual(rhs);
expect(validate<string>(0, ty)).toEqual(null);
expect(validate<string>(1, ty)).toEqual(null);
expect(validate<string>(1.1, ty)).toEqual(null);
expect(validate<string>(BigInt(0), ty)).toEqual(null);
expect(validate<string>(BigInt(1), ty)).toEqual(null);
expect(validate<string>('', ty)).toEqual({value: ''});
expect(validate<string>('1', ty)).toEqual({value: '1'});
expect(validate<string>(false, ty)).toEqual(null);
expect(validate<string>(true, ty)).toEqual(null);
expect(validate<string>(null, ty)).toEqual(null);
expect(validate<string>(void 0, ty)).toEqual(null);
expect(validate<string>({}, ty)).toEqual(null);
expect(validate<string>([], ty)).toEqual(null);
expect(validate<string>(3, ty)).toEqual(null);
expect(validate<string>(BigInt(7), ty)).toEqual(null);
expect(validate<string>('XB', ty)).toEqual({value: 'XB'});
expect(validate<string>(true, ty)).toEqual(null);
}
for (const ty of [getType(deserialize(serialize(schema)), 'FooD'), getType(schema, 'FooD')]) {
const rhs: TypeAssertion = {
name: 'FooD',
typeName: 'FooD',
kind: 'primitive',
primitiveName: 'boolean',
};
expect(ty).toEqual(rhs);
expect(validate<boolean>(0, ty)).toEqual(null);
expect(validate<boolean>(1, ty)).toEqual(null);
expect(validate<boolean>(1.1, ty)).toEqual(null);
expect(validate<boolean>(BigInt(0), ty)).toEqual(null);
expect(validate<boolean>(BigInt(1), ty)).toEqual(null);
expect(validate<boolean>('', ty)).toEqual(null);
expect(validate<boolean>('1', ty)).toEqual(null);
expect(validate<boolean>(false, ty)).toEqual({value: false});
expect(validate<boolean>(true, ty)).toEqual({value: true});
expect(validate<boolean>(null, ty)).toEqual(null);
expect(validate<boolean>(void 0, ty)).toEqual(null);
expect(validate<boolean>({}, ty)).toEqual(null);
expect(validate<boolean>([], ty)).toEqual(null);
expect(validate<boolean>(3, ty)).toEqual(null);
expect(validate<boolean>(BigInt(7), ty)).toEqual(null);
expect(validate<boolean>('XB', ty)).toEqual(null);
expect(validate<boolean>(true, ty)).toEqual({value: true});
}
for (const ty of [getType(deserialize(serialize(schema)), 'FooE'), getType(schema, 'FooE')]) {
const rhs: TypeAssertion = {
name: 'FooE',
typeName: 'FooE',
kind: 'primitive',
primitiveName: 'null',
};
expect(ty).toEqual(rhs);
expect(validate<null>(0, ty)).toEqual(null);
expect(validate<null>(1, ty)).toEqual(null);
expect(validate<null>(1.1, ty)).toEqual(null);
expect(validate<null>(BigInt(0), ty)).toEqual(null);
expect(validate<null>(BigInt(1), ty)).toEqual(null);
expect(validate<null>('', ty)).toEqual(null);
expect(validate<null>('1', ty)).toEqual(null);
expect(validate<null>(false, ty)).toEqual(null);
expect(validate<null>(true, ty)).toEqual(null);
expect(validate<null>(null, ty)).toEqual({value: null});
expect(validate<null>(void 0, ty)).toEqual(null);
expect(validate<null>({}, ty)).toEqual(null);
expect(validate<null>([], ty)).toEqual(null);
expect(validate<null>(3, ty)).toEqual(null);
expect(validate<null>(BigInt(7), ty)).toEqual(null);
expect(validate<null>('XB', ty)).toEqual(null);
expect(validate<null>(true, ty)).toEqual(null);
}
for (const ty of [getType(deserialize(serialize(schema)), 'FooF'), getType(schema, 'FooF')]) {
const rhs: TypeAssertion = {
name: 'FooF',
typeName: 'FooF',
kind: 'primitive',
primitiveName: 'undefined',
};
expect(ty).toEqual(rhs);
expect(validate<undefined>(0, ty)).toEqual(null);
expect(validate<undefined>(1, ty)).toEqual(null);
expect(validate<undefined>(1.1, ty)).toEqual(null);
expect(validate<undefined>(BigInt(0), ty)).toEqual(null);
expect(validate<undefined>(BigInt(1), ty)).toEqual(null);
expect(validate<undefined>('', ty)).toEqual(null);
expect(validate<undefined>('1', ty)).toEqual(null);
expect(validate<undefined>(false, ty)).toEqual(null);
expect(validate<undefined>(true, ty)).toEqual(null);
expect(validate<undefined>(null, ty)).toEqual(null);
expect(validate<undefined>(void 0, ty)).toEqual({value: void 0});
expect(validate<undefined>({}, ty)).toEqual(null);
expect(validate<undefined>([], ty)).toEqual(null);
expect(validate<undefined>(3, ty)).toEqual(null);
expect(validate<undefined>(BigInt(7), ty)).toEqual(null);
expect(validate<undefined>('XB', ty)).toEqual(null);
expect(validate<undefined>(true, ty)).toEqual(null);
}
{
const rhs: TypeAssertion = {
name: 'BarA',
typeName: 'BarA',
kind: 'primitive-value',
value: 3,
};
// const ty = getType(schema, 'BarA');
for (const ty of [getType(deserialize(serialize(schema)), 'BarA'), getType(schema, 'BarA')]) {
expect(ty).toEqual(rhs);
expect(validate<number>(0, ty)).toEqual(null);
expect(validate<number>(1, ty)).toEqual(null);
expect(validate<number>(1.1, ty)).toEqual(null);
expect(validate<number>(BigInt(0), ty)).toEqual(null);
expect(validate<number>(BigInt(1), ty)).toEqual(null);
expect(validate<number>('', ty)).toEqual(null);
expect(validate<number>('1', ty)).toEqual(null);
expect(validate<number>(false, ty)).toEqual(null);
expect(validate<number>(true, ty)).toEqual(null);
expect(validate<number>(null, ty)).toEqual(null);
expect(validate<number>(void 0, ty)).toEqual(null);
expect(validate<number>({}, ty)).toEqual(null);
expect(validate<number>([], ty)).toEqual(null);
expect(validate<number>(3, ty)).toEqual({value: 3});
expect(validate<number>(BigInt(7), ty)).toEqual(null);
expect(validate<number>('XB', ty)).toEqual(null);
expect(validate<number>(true, ty)).toEqual(null);
}
}
{
const rhs: TypeAssertion = {
name: 'BarB',
typeName: 'BarB',
kind: 'primitive-value',
value: BigInt(7),
};
// const ty = getType(schema, 'BarB');
for (const ty of [getType(deserialize(serialize(schema)), 'BarB'), getType(schema, 'BarB')]) {
expect(ty).toEqual(rhs);
expect(validate<BigInt>(0, ty)).toEqual(null);
expect(validate<BigInt>(1, ty)).toEqual(null);
expect(validate<BigInt>(1.1, ty)).toEqual(null);
expect(validate<BigInt>(BigInt(0), ty)).toEqual(null);
expect(validate<BigInt>(BigInt(1), ty)).toEqual(null);
expect(validate<BigInt>('', ty)).toEqual(null);
expect(validate<BigInt>('1', ty)).toEqual(null);
expect(validate<BigInt>(false, ty)).toEqual(null);
expect(validate<BigInt>(true, ty)).toEqual(null);
expect(validate<BigInt>(null, ty)).toEqual(null);
expect(validate<BigInt>(void 0, ty)).toEqual(null);
expect(validate<BigInt>({}, ty)).toEqual(null);
expect(validate<BigInt>([], ty)).toEqual(null);
expect(validate<BigInt>(3, ty)).toEqual(null);
expect(validate<BigInt>(BigInt(7), ty)).toEqual({value: BigInt(7)});
expect(validate<BigInt>('XB', ty)).toEqual(null);
expect(validate<BigInt>(true, ty)).toEqual(null);
}
}
{
const rhs: TypeAssertion = {
name: 'BarC',
typeName: 'BarC',
kind: 'primitive-value',
value: 'XB',
};
// const ty = getType(schema, 'BarC');
for (const ty of [getType(deserialize(serialize(schema)), 'BarC'), getType(schema, 'BarC')]) {
expect(ty).toEqual(rhs);
expect(validate<string>(0, ty)).toEqual(null);
expect(validate<string>(1, ty)).toEqual(null);
expect(validate<string>(1.1, ty)).toEqual(null);
expect(validate<string>(BigInt(0), ty)).toEqual(null);
expect(validate<string>(BigInt(1), ty)).toEqual(null);
expect(validate<string>('', ty)).toEqual(null);
expect(validate<string>('1', ty)).toEqual(null);
expect(validate<string>(false, ty)).toEqual(null);
expect(validate<string>(true, ty)).toEqual(null);
expect(validate<string>(null, ty)).toEqual(null);
expect(validate<string>(void 0, ty)).toEqual(null);
expect(validate<string>({}, ty)).toEqual(null);
expect(validate<string>([], ty)).toEqual(null);
expect(validate<string>(3, ty)).toEqual(null);
expect(validate<string>(BigInt(7), ty)).toEqual(null);
expect(validate<string>('XB', ty)).toEqual({value: 'XB'});
expect(validate<string>(true, ty)).toEqual(null);
}
}
{
const rhs: TypeAssertion = {
name: 'BarD',
typeName: 'BarD',
kind: 'primitive-value',
value: true,
};
// const ty = getType(schema, 'BarD');
for (const ty of [getType(deserialize(serialize(schema)), 'BarD'), getType(schema, 'BarD')]) {
expect(ty).toEqual(rhs);
expect(validate<boolean>(0, ty)).toEqual(null);
expect(validate<boolean>(1, ty)).toEqual(null);
expect(validate<boolean>(1.1, ty)).toEqual(null);
expect(validate<boolean>(BigInt(0), ty)).toEqual(null);
expect(validate<boolean>(BigInt(1), ty)).toEqual(null);
expect(validate<boolean>('', ty)).toEqual(null);
expect(validate<boolean>('1', ty)).toEqual(null);
expect(validate<boolean>(false, ty)).toEqual(null);
expect(validate<boolean>(true, ty)).toEqual({value: true});
expect(validate<boolean>(null, ty)).toEqual(null);
expect(validate<boolean>(void 0, ty)).toEqual(null);
expect(validate<boolean>({}, ty)).toEqual(null);
expect(validate<boolean>([], ty)).toEqual(null);
expect(validate<boolean>(3, ty)).toEqual(null);
expect(validate<boolean>(BigInt(7), ty)).toEqual(null);
expect(validate<boolean>('XB', ty)).toEqual(null);
expect(validate<boolean>(true, ty)).toEqual({value: true});
}
}
for (const ty of [getType(deserialize(serialize(schema)), 'BazA'), getType(schema, 'BazA')]) {
const rhs: TypeAssertion = {
name: 'BazA',
typeName: 'BazA',
kind: 'primitive',
primitiveName: 'integer',
};
expect(ty).toEqual(rhs);
expect(validate<number>(0, ty)).toEqual({value: 0});
expect(validate<number>(1, ty)).toEqual({value: 1});
expect(validate<number>(1.1, ty)).toEqual(null);
expect(validate<number>(BigInt(0), ty)).toEqual(null);
expect(validate<number>(BigInt(1), ty)).toEqual(null);
expect(validate<number>('', ty)).toEqual(null);
expect(validate<number>('1', ty)).toEqual(null);
expect(validate<number>(false, ty)).toEqual(null);
expect(validate<number>(true, ty)).toEqual(null);
expect(validate<number>(null, ty)).toEqual(null);
expect(validate<number>(void 0, ty)).toEqual(null);
expect(validate<number>({}, ty)).toEqual(null);
expect(validate<number>([], ty)).toEqual(null);
expect(validate<number>(3, ty)).toEqual({value: 3});
expect(validate<number>(BigInt(7), ty)).toEqual(null);
expect(validate<number>('XB', ty)).toEqual(null);
expect(validate<number>(true, ty)).toEqual(null);
}
});
it("compiler-array-of-primitive", function() {
const schemas = [compile(`
type FooA = number[];
type FooB = bigint[];
type FooC = string[];
type FooD = boolean[];
type FooE = null[];
type FooF = undefined[];
type BarA = 3[];
type BarB = 7n[];
type BarC = 'XB'[];
type BarD = true[];
type BazA = integer[];
`), compile(`
type FooA = Array<number>;
type FooB = Array<bigint>;
type FooC = Array<string>;
type FooD = Array<boolean>;
type FooE = Array<null>;
type FooF = Array<undefined>;
type BarA = Array<3>;
type BarB = Array<7n>;
type BarC = Array<'XB'>;
type BarD = Array<true>;
type BazA = Array<integer>;
`)];
for (const schema of schemas) {
{
expect(Array.from(schema.keys())).toEqual([
'FooA', 'FooB', 'FooC', 'FooD', 'FooE', 'FooF', 'BarA', 'BarB', 'BarC', 'BarD', 'BazA',
]);
}
{
const rhs: TypeAssertion = {
name: 'FooA',
typeName: 'FooA',
kind: 'repeated',
min: null,
max: null,
repeated: {
kind: 'primitive',
primitiveName: 'number',
},
};
// const ty = getType(schema, 'FooA');
for (const ty of [getType(deserialize(serialize(schema)), 'FooA'), getType(schema, 'FooA')]) {
expect(ty).toEqual(rhs);
expect(validate<any>(0, ty)).toEqual(null);
expect(validate<any>(1, ty)).toEqual(null);
expect(validate<any>(BigInt(0), ty)).toEqual(null);
expect(validate<any>(BigInt(1), ty)).toEqual(null);
expect(validate<any>('', ty)).toEqual(null);
expect(validate<any>('1', ty)).toEqual(null);
expect(validate<any>(false, ty)).toEqual(null);
expect(validate<any>(true, ty)).toEqual(null);
expect(validate<any>(null, ty)).toEqual(null);
expect(validate<any>(void 0, ty)).toEqual(null);
expect(validate<any>({}, ty)).toEqual(null);
expect(validate<any>([], ty)).toEqual({value: []});
expect(validate<any>([0], ty)).toEqual({value: [0]});
expect(validate<any>([1.1], ty)).toEqual({value: [1.1]});
expect(validate<any>([BigInt(0)], ty)).toEqual(null);
expect(validate<any>([''], ty)).toEqual(null);
expect(validate<any>([false], ty)).toEqual(null);
expect(validate<any>([null], ty)).toEqual(null);
expect(validate<any>([void 0], ty)).toEqual(null);
expect(validate<any>([3], ty)).toEqual({value: [3]});
expect(validate<any>([BigInt(7)], ty)).toEqual(null);
expect(validate<any>(['XB'], ty)).toEqual(null);
expect(validate<any>([true], ty)).toEqual(null);
}
}
{
const rhs: TypeAssertion = {
name: 'FooB',
typeName: 'FooB',
kind: 'repeated',
min: null,
max: null,
repeated: {
kind: 'primitive',
primitiveName: 'bigint',
},
};
// const ty = getType(schema, 'FooB');
for (const ty of [getType(deserialize(serialize(schema)), 'FooB'), getType(schema, 'FooB')]) {
expect(ty).toEqual(rhs);
expect(validate<any>(0, ty)).toEqual(null);
expect(validate<any>(1, ty)).toEqual(null);
expect(validate<any>(BigInt(0), ty)).toEqual(null);
expect(validate<any>(BigInt(1), ty)).toEqual(null);
expect(validate<any>('', ty)).toEqual(null);
expect(validate<any>('1', ty)).toEqual(null);
expect(validate<any>(false, ty)).toEqual(null);
expect(validate<any>(true, ty)).toEqual(null);
expect(validate<any>(null, ty)).toEqual(null);
expect(validate<any>(void 0, ty)).toEqual(null);
expect(validate<any>({}, ty)).toEqual(null);
expect(validate<any>([], ty)).toEqual({value: []});
expect(validate<any>([0], ty)).toEqual(null);
expect(validate<any>([1.1], ty)).toEqual(null);
expect(validate<any>([BigInt(0)], ty)).toEqual({value: [BigInt(0)]});
expect(validate<any>([''], ty)).toEqual(null);
expect(validate<any>([false], ty)).toEqual(null);
expect(validate<any>([null], ty)).toEqual(null);
expect(validate<any>([void 0], ty)).toEqual(null);
expect(validate<any>([3], ty)).toEqual(null);
expect(validate<any>([BigInt(7)], ty)).toEqual({value: [BigInt(7)]});
expect(validate<any>(['XB'], ty)).toEqual(null);
expect(validate<any>([true], ty)).toEqual(null);
}
}
{
const rhs: TypeAssertion = {
name: 'FooC',
typeName: 'FooC',
kind: 'repeated',
min: null,
max: null,
repeated: {
kind: 'primitive',
primitiveName: 'string',
},
};
// const ty = getType(schema, 'FooC');
for (const ty of [getType(deserialize(serialize(schema)), 'FooC'), getType(schema, 'FooC')]) {
expect(ty).toEqual(rhs);
expect(validate<any>(0, ty)).toEqual(null);
expect(validate<any>(1, ty)).toEqual(null);
expect(validate<any>(BigInt(0), ty)).toEqual(null);
expect(validate<any>(BigInt(1), ty)).toEqual(null);
expect(validate<any>('', ty)).toEqual(null);
expect(validate<any>('1', ty)).toEqual(null);
expect(validate<any>(false, ty)).toEqual(null);
expect(validate<any>(true, ty)).toEqual(null);
expect(validate<any>(null, ty)).toEqual(null);
expect(validate<any>(void 0, ty)).toEqual(null);
expect(validate<any>({}, ty)).toEqual(null);
expect(validate<any>([], ty)).toEqual({value: []});
expect(validate<any>([0], ty)).toEqual(null);
expect(validate<any>([1.1], ty)).toEqual(null);
expect(validate<any>([BigInt(0)], ty)).toEqual(null);
expect(validate<any>([''], ty)).toEqual({value: ['']});
expect(validate<any>([false], ty)).toEqual(null);
expect(validate<any>([null], ty)).toEqual(null);
expect(validate<any>([void 0], ty)).toEqual(null);
expect(validate<any>([3], ty)).toEqual(null);
expect(validate<any>([BigInt(7)], ty)).toEqual(null);
expect(validate<any>(['XB'], ty)).toEqual({value: ['XB']});
expect(validate<any>([true], ty)).toEqual(null);
}
}
{
const rhs: TypeAssertion = {
name: 'FooD',
typeName: 'FooD',
kind: 'repeated',
min: null,
max: null,
repeated: {
kind: 'primitive',
primitiveName: 'boolean',
},
};
// const ty = getType(schema, 'FooD');
for (const ty of [getType(deserialize(serialize(schema)), 'FooD'), getType(schema, 'FooD')]) {
expect(ty).toEqual(rhs);
expect(validate<any>(0, ty)).toEqual(null);
expect(validate<any>(1, ty)).toEqual(null);
expect(validate<any>(BigInt(0), ty)).toEqual(null);
expect(validate<any>(BigInt(1), ty)).toEqual(null);
expect(validate<any>('', ty)).toEqual(null);
expect(validate<any>('1', ty)).toEqual(null);
expect(validate<any>(false, ty)).toEqual(null);
expect(validate<any>(true, ty)).toEqual(null);
expect(validate<any>(null, ty)).toEqual(null);
expect(validate<any>(void 0, ty)).toEqual(null);
expect(validate<any>({}, ty)).toEqual(null);
expect(validate<any>([], ty)).toEqual({value: []});
expect(validate<any>([0], ty)).toEqual(null);
expect(validate<any>([1.1], ty)).toEqual(null);
expect(validate<any>([BigInt(0)], ty)).toEqual(null);
expect(validate<any>([''], ty)).toEqual(null);
expect(validate<any>([false], ty)).toEqual({value: [false]});
expect(validate<any>([null], ty)).toEqual(null);
expect(validate<any>([void 0], ty)).toEqual(null);
expect(validate<any>([3], ty)).toEqual(null);
expect(validate<any>([BigInt(7)], ty)).toEqual(null);
expect(validate<any>(['XB'], ty)).toEqual(null);
expect(validate<any>([true], ty)).toEqual({value: [true]});
}
}
{
const rhs: TypeAssertion = {
name: 'FooE',
typeName: 'FooE',
kind: 'repeated',
min: null,
max: null,
repeated: {
kind: 'primitive',
primitiveName: 'null',
},
};
// const ty = getType(schema, 'FooE');
for (const ty of [getType(deserialize(serialize(schema)), 'FooE'), getType(schema, 'FooE')]) {
expect(ty).toEqual(rhs);
expect(validate<any>(0, ty)).toEqual(null);
expect(validate<any>(1, ty)).toEqual(null);
expect(validate<any>(BigInt(0), ty)).toEqual(null);
expect(validate<any>(BigInt(1), ty)).toEqual(null);
expect(validate<any>('', ty)).toEqual(null);
expect(validate<any>('1', ty)).toEqual(null);
expect(validate<any>(false, ty)).toEqual(null);
expect(validate<any>(true, ty)).toEqual(null);
expect(validate<any>(null, ty)).toEqual(null);
expect(validate<any>(void 0, ty)).toEqual(null);
expect(validate<any>({}, ty)).toEqual(null);
expect(validate<any>([], ty)).toEqual({value: []});
expect(validate<any>([0], ty)).toEqual(null);
expect(validate<any>([1.1], ty)).toEqual(null);
expect(validate<any>([BigInt(0)], ty)).toEqual(null);
expect(validate<any>([''], ty)).toEqual(null);
expect(validate<any>([false], ty)).toEqual(null);
expect(validate<any>([null], ty)).toEqual({value: [null]});
expect(validate<any>([void 0], ty)).toEqual(null);
expect(validate<any>([3], ty)).toEqual(null);
expect(validate<any>([BigInt(7)], ty)).toEqual(null);
expect(validate<any>(['XB'], ty)).toEqual(null);
expect(validate<any>([true], ty)).toEqual(null);
}
}
{
const rhs: TypeAssertion = {
name: 'FooF',
typeName: 'FooF',
kind: 'repeated',
min: null,
max: null,
repeated: {
kind: 'primitive',
primitiveName: 'undefined',
},
};
// const ty = getType(schema, 'FooF');
for (const ty of [getType(deserialize(serialize(schema)), 'FooF'), getType(schema, 'FooF')]) {
expect(ty).toEqual(rhs);
expect(validate<any>(0, ty)).toEqual(null);
expect(validate<any>(1, ty)).toEqual(null);
expect(validate<any>(BigInt(0), ty)).toEqual(null);
expect(validate<any>(BigInt(1), ty)).toEqual(null);
expect(validate<any>('', ty)).toEqual(null);
expect(validate<any>('1', ty)).toEqual(null);
expect(validate<any>(false, ty)).toEqual(null);
expect(validate<any>(true, ty)).toEqual(null);
expect(validate<any>(null, ty)).toEqual(null);
expect(validate<any>(void 0, ty)).toEqual(null);
expect(validate<any>({}, ty)).toEqual(null);
expect(validate<any>([], ty)).toEqual({value: []});
expect(validate<any>([0], ty)).toEqual(null);
expect(validate<any>([1.1], ty)).toEqual(null);
expect(validate<any>([BigInt(0)], ty)).toEqual(null);
expect(validate<any>([''], ty)).toEqual(null);
expect(validate<any>([false], ty)).toEqual(null);
expect(validate<any>([null], ty)).toEqual(null);
expect(validate<any>([void 0], ty)).toEqual({value: [void 0]});
expect(validate<any>([3], ty)).toEqual(null);
expect(validate<any>([BigInt(7)], ty)).toEqual(null);
expect(validate<any>(['XB'], ty)).toEqual(null);
expect(validate<any>([true], ty)).toEqual(null);
}
}
{
const rhs: TypeAssertion = {
name: 'BarA',
typeName: 'BarA',
kind: 'repeated',
min: null,
max: null,
repeated: {
kind: 'primitive-value',
value: 3,
},
};
// const ty = getType(schema, 'BarA');
for (const ty of [getType(deserialize(serialize(schema)), 'BarA'), getType(schema, 'BarA')]) {
expect(ty).toEqual(rhs);
expect(validate<any>(0, ty)).toEqual(null);
expect(validate<any>(1, ty)).toEqual(null);
expect(validate<any>(BigInt(0), ty)).toEqual(null);
expect(validate<any>(BigInt(1), ty)).toEqual(null);
expect(validate<any>('', ty)).toEqual(null);
expect(validate<any>('1', ty)).toEqual(null);
expect(validate<any>(false, ty)).toEqual(null);
expect(validate<any>(true, ty)).toEqual(null);
expect(validate<any>(null, ty)).toEqual(null);
expect(validate<any>(void 0, ty)).toEqual(null);
expect(validate<any>({}, ty)).toEqual(null);
expect(validate<any>([], ty)).toEqual({value: []});
expect(validate<any>([0], ty)).toEqual(null);
expect(validate<any>([1.1], ty)).toEqual(null);
expect(validate<any>([BigInt(0)], ty)).toEqual(null);
expect(validate<any>([''], ty)).toEqual(null);
expect(validate<any>([false], ty)).toEqual(null);
expect(validate<any>([null], ty)).toEqual(null);
expect(validate<any>([void 0], ty)).toEqual(null);
expect(validate<any>([3], ty)).toEqual({value: [3]});
expect(validate<any>([BigInt(7)], ty)).toEqual(null);
expect(validate<any>(['XB'], ty)).toEqual(null);
expect(validate<any>([true], ty)).toEqual(null);
}
}
{
const rhs: TypeAssertion = {
name: 'BarB',
typeName: 'BarB',
kind: 'repeated',
min: null,
max: null,
repeated: {
kind: 'primitive-value',
value: BigInt(7),
},
};
// const ty = getType(schema, 'BarB');
for (const ty of [getType(deserialize(serialize(schema)), 'BarB'), getType(schema, 'BarB')]) {
expect(ty).toEqual(rhs);
expect(validate<any>(0, ty)).toEqual(null);
expect(validate<any>(1, ty)).toEqual(null);
expect(validate<any>(BigInt(0), ty)).toEqual(null);
expect(validate<any>(BigInt(1), ty)).toEqual(null);
expect(validate<any>('', ty)).toEqual(null);
expect(validate<any>('1', ty)).toEqual(null);
expect(validate<any>(false, ty)).toEqual(null);
expect(validate<any>(true, ty)).toEqual(null);
expect(validate<any>(null, ty)).toEqual(null);
expect(validate<any>(void 0, ty)).toEqual(null);
expect(validate<any>({}, ty)).toEqual(null);
expect(validate<any>([], ty)).toEqual({value: []});
expect(validate<any>([0], ty)).toEqual(null);
expect(validate<any>([1.1], ty)).toEqual(null);
expect(validate<any>([BigInt(0)], ty)).toEqual(null);
expect(validate<any>([''], ty)).toEqual(null);
expect(validate<any>([false], ty)).toEqual(null);
expect(validate<any>([null], ty)).toEqual(null);
expect(validate<any>([void 0], ty)).toEqual(null);
expect(validate<any>([3], ty)).toEqual(null);
expect(validate<any>([BigInt(7)], ty)).toEqual({value: [BigInt(7)]});
expect(validate<any>(['XB'], ty)).toEqual(null);
expect(validate<any>([true], ty)).toEqual(null);
}
}
{
const rhs: TypeAssertion = {
name: 'BarC',
typeName: 'BarC',
kind: 'repeated',
min: null,
max: null,
repeated: {
kind: 'primitive-value',
value: 'XB',
},
};
// const ty = getType(schema, 'BarC');
for (const ty of [getType(deserialize(serialize(schema)), 'BarC'), getType(schema, 'BarC')]) {
expect(ty).toEqual(rhs);
expect(validate<any>(0, ty)).toEqual(null);
expect(validate<any>(1, ty)).toEqual(null);
expect(validate<any>(BigInt(0), ty)).toEqual(null);
expect(validate<any>(BigInt(1), ty)).toEqual(null);
expect(validate<any>('', ty)).toEqual(null);
expect(validate<any>('1', ty)).toEqual(null);
expect(validate<any>(false, ty)).toEqual(null);
expect(validate<any>(true, ty)).toEqual(null);
expect(validate<any>(null, ty)).toEqual(null);
expect(validate<any>(void 0, ty)).toEqual(null);
expect(validate<any>({}, ty)).toEqual(null);
expect(validate<any>([], ty)).toEqual({value: []});
expect(validate<any>([0], ty)).toEqual(null);
expect(validate<any>([1.1], ty)).toEqual(null);
expect(validate<any>([BigInt(0)], ty)).toEqual(null);
expect(validate<any>([''], ty)).toEqual(null);
expect(validate<any>([false], ty)).toEqual(null);
expect(validate<any>([null], ty)).toEqual(null);
expect(validate<any>([void 0], ty)).toEqual(null);
expect(validate<any>([3], ty)).toEqual(null);
expect(validate<any>([BigInt(7)], ty)).toEqual(null);
expect(validate<any>(['XB'], ty)).toEqual({value: ['XB']});
expect(validate<any>([true], ty)).toEqual(null);
}
}
{
const rhs: TypeAssertion = {
name: 'BarD',
typeName: 'BarD',
kind: 'repeated',
min: null,
max: null,
repeated: {
kind: 'primitive-value',
value: true,
},
};
// const ty = getType(schema, 'BarD');
for (const ty of [getType(deserialize(serialize(schema)), 'BarD'), getType(schema, 'BarD')]) {
expect(ty).toEqual(rhs);
expect(validate<any>(0, ty)).toEqual(null);
expect(validate<any>(1, ty)).toEqual(null);
expect(validate<any>(BigInt(0), ty)).toEqual(null);
expect(validate<any>(BigInt(1), ty)).toEqual(null);
expect(validate<any>('', ty)).toEqual(null);
expect(validate<any>('1', ty)).toEqual(null);
expect(validate<any>(false, ty)).toEqual(null);
expect(validate<any>(true, ty)).toEqual(null);
expect(validate<any>(null, ty)).toEqual(null);
expect(validate<any>(void 0, ty)).toEqual(null);
expect(validate<any>({}, ty)).toEqual(null);
expect(validate<any>([], ty)).toEqual({value: []});
expect(validate<any>([0], ty)).toEqual(null);
expect(validate<any>([1.1], ty)).toEqual(null);
expect(validate<any>([BigInt(0)], ty)).toEqual(null);
expect(validate<any>([''], ty)).toEqual(null);
expect(validate<any>([false], ty)).toEqual(null);
expect(validate<any>([null], ty)).toEqual(null);
expect(validate<any>([void 0], ty)).toEqual(null);
expect(validate<any>([3], ty)).toEqual(null);
expect(validate<any>([BigInt(7)], ty)).toEqual(null);
expect(validate<any>(['XB'], ty)).toEqual(null);
expect(validate<any>([true], ty)).toEqual({value: [true]});
}
}
{
const rhs: TypeAssertion = {
name: 'BazA',
typeName: 'BazA',
kind: 'repeated',
min: null,
max: null,
repeated: {
kind: 'primitive',
primitiveName: 'integer',
},
};
// const ty = getType(schema, 'BazA');
for (const ty of [getType(deserialize(serialize(schema)), 'BazA'), getType(schema, 'BazA')]) {
expect(ty).toEqual(rhs);
expect(validate<any>(0, ty)).toEqual(null);
expect(validate<any>(1, ty)).toEqual(null);
expect(validate<any>(1.1, ty)).toEqual(null);
expect(validate<any>(BigInt(0), ty)).toEqual(null);
expect(validate<any>(BigInt(1), ty)).toEqual(null);
expect(validate<any>('', ty)).toEqual(null);
expect(validate<any>('1', ty)).toEqual(null);
expect(validate<any>(false, ty)).toEqual(null);
expect(validate<any>(true, ty)).toEqual(null);
expect(validate<any>(null, ty)).toEqual(null);
expect(validate<any>(void 0, ty)).toEqual(null);
expect(validate<any>({}, ty)).toEqual(null);
expect(validate<any>([], ty)).toEqual({value: []});
expect(validate<any>([0], ty)).toEqual({value: [0]});
expect(validate<any>([1.1], ty)).toEqual(null);
expect(validate<any>([BigInt(0)], ty)).toEqual(null);
expect(validate<any>([''], ty)).toEqual(null);
expect(validate<any>([false], ty)).toEqual(null);
expect(validate<any>([null], ty)).toEqual(null);
expect(validate<any>([void 0], ty)).toEqual(null);
expect(validate<any>([3], ty)).toEqual({value: [3]});
expect(validate<any>([BigInt(7)], ty)).toEqual(null);
expect(validate<any>(['XB'], ty)).toEqual(null);
expect(validate<any>([true], ty)).toEqual(null);
}
}
}
});
});