ejv 2.1.1 → 2.1.3

package/spec/NumberScheme.ts

@@ -1,1160 +1,1160 @@
-import { describe, it } from 'mocha';
-import { expect } from 'chai';
-
-import { ejv } from '../src/ejv';
-
-import { EjvError, Scheme } from '../src/interfaces';
-import { ERROR_MESSAGE, ERROR_TYPE } from '../src/constants';
-import { createErrorMsg } from '../src/util';
-import { checkSchemeError, TypeTester, typeTesterArr } from './common-test-util';
-
-
-describe('NumberScheme', () => {
-	describe('type', () => {
-		describe('mismatch', () => {
-			typeTesterArr
-				.filter((obj: TypeTester): boolean => obj.type !== 'number')
-				.forEach((obj: TypeTester): void => {
-					const data = {
-						a: obj.value
-					};
-
-					it(obj.type, () => {
-						const error: EjvError | null = ejv(data, [{
-							key: 'a',
-							type: 'number'
-						}]);
-
-						expect(error).to.be.instanceof(EjvError);
-
-						if (!error) {
-							throw new Error('spec failed');
-						}
-
-						expect(error.type).to.be.eql(ERROR_TYPE.TYPE_MISMATCH);
-						expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.TYPE_MISMATCH, {
-							placeholders: ['number']
-						}));
-						expect(error.path).to.be.eql('a');
-						expect(error.data).to.be.deep.equal(data);
-						expect(error.errorData).to.be.eql(obj.value);
-					});
-				});
-
-			it('multiple types', () => {
-				const value = 123;
-				const typeArr: string[] = ['boolean', 'string'];
-
-				const data = {
-					a: value
-				};
-
-				const error: EjvError | null = ejv(data, [{
-					key: 'a',
-					type: typeArr
-				}]);
-
-				expect(error).to.be.instanceof(EjvError);
-
-				if (!error) {
-					throw new Error('spec failed');
-				}
-
-				expect(error.type).to.be.eql(ERROR_TYPE.TYPE_MISMATCH_ONE_OF);
-				expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.TYPE_MISMATCH_ONE_OF, {
-					placeholders: [JSON.stringify(typeArr)]
-				}));
-				expect(error.path).to.be.eql('a');
-				expect(error.data).to.be.deep.equal(data);
-				expect(error.errorData).to.be.eql(value);
-			});
-		});
-
-		describe('match', () => {
-			it('optional', () => {
-				expect(ejv({
-					a: undefined
-				}, [{
-					key: 'a',
-					type: 'number',
-					optional: true
-				}])).to.be.null;
-			});
-
-			it('single type', () => {
-				expect(ejv({
-					a: 123
-				}, [{
-					key: 'a',
-					type: 'number'
-				}])).to.be.null;
-			});
-
-			it('multiple types', () => {
-				expect(ejv({
-					a: 123
-				}, [{
-					key: 'a',
-					type: ['number', 'string']
-				}])).to.be.null;
-			});
-
-			it('multiple types', () => {
-				expect(ejv({
-					a: 123
-				}, [{
-					key: 'a',
-					type: ['string', 'number']
-				}])).to.be.null;
-			});
-		});
-	});
-
-	describe('enum & notEnum', () => {
-		describe('enum', () => {
-			describe('check parameter', () => {
-				it('undefined is ok', () => {
-					expect(ejv({
-						a: 1
-					}, [{
-						key: 'a',
-						type: 'number',
-						enum: undefined
-					}])).to.be.null;
-				});
-
-				it('null', () => {
-					const data = {
-						a: 1
-					};
-
-					const errorScheme: Scheme = {
-						key: 'a',
-						type: 'number',
-						enum: null as unknown as number[]
-					};
-
-					checkSchemeError({
-						data,
-						errorScheme,
-						message: createErrorMsg(ERROR_MESSAGE.ENUM_SHOULD_BE_ARRAY)
-					});
-				});
-
-				it('not array', () => {
-					const data = {
-						a: 10
-					};
-
-					const errorScheme: Scheme = {
-						key: 'a',
-						type: 'number',
-						enum: 1 as unknown as number[]
-					};
-
-					checkSchemeError({
-						data,
-						errorScheme,
-						message: createErrorMsg(ERROR_MESSAGE.ENUM_SHOULD_BE_ARRAY)
-					});
-				});
-
-				it('not number', () => {
-					const data = {
-						a: 10
-					};
-
-					const errorScheme: Scheme = {
-						key: 'a',
-						type: 'number',
-						enum: ['10']
-					};
-
-					checkSchemeError({
-						data,
-						errorScheme,
-						message: createErrorMsg(ERROR_MESSAGE.ENUM_SHOULD_BE_NUMBERS)
-					});
-				});
-			});
-
-			it('fail', () => {
-				const enumArr: number[] = [9, 11];
-
-				const data = {
-					a: 10
-				};
-
-				const error: EjvError | null = ejv(data, [{
-					key: 'a',
-					type: 'number',
-					enum: enumArr
-				}]);
-
-				expect(error).to.be.instanceof(EjvError);
-
-				if (!error) {
-					throw new Error('spec failed');
-				}
-
-				expect(error.type).to.be.eql(ERROR_TYPE.ONE_VALUE_OF);
-				expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.ONE_VALUE_OF, {
-					placeholders: [JSON.stringify(enumArr)]
-				}));
-				expect(error.path).to.be.eql('a');
-				expect(error.data).to.be.deep.equal(data);
-				expect(error.errorData).to.be.eql(10);
-			});
-
-			it('ok', () => {
-				expect(ejv({
-					a: 10
-				}, [{
-					key: 'a',
-					type: 'number',
-					enum: [9, 10, 11]
-				}])).to.be.null;
-			});
-		});
-
-		describe('notEnum', () => {
-			describe('check parameter', () => {
-				it('undefined is ok', () => {
-					expect(ejv({
-						a: 1
-					}, [{
-						key: 'a',
-						type: 'number',
-						notEnum: undefined
-					}])).to.be.null;
-				});
-
-				it('null', () => {
-					const data = {
-						a: 1
-					};
-
-					const errorScheme: Scheme = {
-						key: 'a',
-						type: 'number',
-						notEnum: null as unknown as number[]
-					};
-
-					checkSchemeError({
-						data,
-						errorScheme,
-						message: createErrorMsg(ERROR_MESSAGE.NOT_ENUM_SHOULD_BE_ARRAY)
-					});
-				});
-
-				it('not array', () => {
-					const data = {
-						a: 10
-					};
-
-					const errorScheme: Scheme = {
-						key: 'a',
-						type: 'number',
-						notEnum: 1 as unknown as number[]
-					};
-
-					checkSchemeError({
-						data,
-						errorScheme,
-						message: createErrorMsg(ERROR_MESSAGE.NOT_ENUM_SHOULD_BE_ARRAY)
-					});
-				});
-
-				it('not number', () => {
-					const data = {
-						a: 10
-					};
-
-					const errorScheme: Scheme = {
-						key: 'a',
-						type: 'number',
-						notEnum: ['10']
-					};
-
-					checkSchemeError({
-						data,
-						errorScheme,
-						message: createErrorMsg(ERROR_MESSAGE.NOT_ENUM_SHOULD_BE_NUMBERS)
-					});
-				});
-			});
-
-			it('fail', () => {
-				const enumArr: number[] = [9, 10, 11];
-
-				const data = {
-					a: 9
-				};
-
-				const error: EjvError | null = ejv(data, [{
-					key: 'a',
-					type: 'number',
-					notEnum: enumArr
-				}]);
-
-				expect(error).to.be.instanceof(EjvError);
-
-				if (!error) {
-					throw new Error('spec failed');
-				}
-
-				expect(error.type).to.be.eql(ERROR_TYPE.NOT_ONE_VALUE_OF);
-				expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.NOT_ONE_VALUE_OF, {
-					placeholders: [JSON.stringify(enumArr)]
-				}));
-				expect(error.path).to.be.eql('a');
-				expect(error.data).to.be.deep.equal(data);
-				expect(error.errorData).to.be.eql(9);
-			});
-
-			it('ok', () => {
-				expect(ejv({
-					a: 8
-				}, [{
-					key: 'a',
-					type: 'number',
-					notEnum: [9, 10, 11]
-				}])).to.be.null;
-			});
-		});
-	});
-
-	describe('min & exclusiveMin', () => {
-		describe('min only', () => {
-			describe('check parameter', () => {
-				it('undefined is ok', () => {
-					expect(ejv({
-						a: 1
-					}, [{
-						key: 'a',
-						type: 'number',
-						min: undefined
-					}])).to.be.null;
-				});
-
-				it('null', () => {
-					const data = {
-						a: 3
-					};
-
-					const errorScheme: Scheme = {
-						key: 'a',
-						type: 'number',
-						min: null as unknown as number
-					};
-
-					checkSchemeError({
-						data,
-						errorScheme,
-						message: createErrorMsg(ERROR_MESSAGE.MIN_SHOULD_BE_NUMBER)
-					});
-				});
-
-				it('min type', () => {
-					const data = {
-						a: 3
-					};
-
-					const errorScheme: Scheme = {
-						key: 'a',
-						type: 'number',
-						min: '3'
-					};
-
-					checkSchemeError({
-						data,
-						errorScheme,
-						message: createErrorMsg(ERROR_MESSAGE.MIN_SHOULD_BE_NUMBER)
-					});
-				});
-
-				it('0 is ok', () => {
-					expect(ejv({
-						a: 1
-					}, [{
-						key: 'a',
-						type: 'number',
-						min: 0
-					}])).to.be.null;
-				});
-			});
-
-			it('ok', () => {
-				const error1: EjvError | null = ejv({
-					a: 9
-				}, [{
-					key: 'a',
-					type: 'number',
-					min: 10
-				}]);
-
-				expect(error1).to.be.instanceof(EjvError);
-
-				if (!error1) {
-					throw new Error('spec failed');
-				}
-
-				expect(error1.type).to.be.eql(ERROR_TYPE.BIGGER_THAN_OR_EQUAL);
-				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.BIGGER_THAN_OR_EQUAL, {
-					placeholders: [10]
-				}));
-
-				expect(ejv({
-					a: 10
-				}, [{
-					key: 'a',
-					type: 'number',
-					min: 10
-				}])).to.be.null;
-
-				expect(ejv({
-					a: 11
-				}, [{
-					key: 'a',
-					type: 'number',
-					min: 10
-				}])).to.be.null;
-			});
-		});
-
-		describe('exclusiveMin', () => {
-			describe('check parameter', () => {
-				it('exclusiveMin type', () => {
-					const data = {
-						a: 3
-					};
-
-					const errorScheme: Scheme = {
-						key: 'a',
-						type: 'number',
-						min: 3,
-						exclusiveMin: '3' as unknown as boolean
-					};
-
-					checkSchemeError({
-						data,
-						errorScheme,
-						message: createErrorMsg(ERROR_MESSAGE.EXCLUSIVE_MIN_SHOULD_BE_BOOLEAN)
-					});
-				});
-			});
-
-			it('exclusiveMin === true', () => {
-				const error1: EjvError | null = ejv({
-					a: 9
-				}, [{
-					key: 'a',
-					type: 'number',
-					min: 10,
-					exclusiveMin: true
-				}]);
-
-				expect(error1).to.be.instanceof(EjvError);
-
-				if (!error1) {
-					throw new Error('spec failed');
-				}
-
-				expect(error1.type).to.be.eql(ERROR_TYPE.BIGGER_THAN);
-				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.BIGGER_THAN, {
-					placeholders: [10]
-				}));
-
-				const error2: EjvError | null = ejv({
-					a: 10
-				}, [{
-					key: 'a',
-					type: 'number',
-					min: 10,
-					exclusiveMin: true
-				}]);
-
-				expect(error2).to.be.instanceof(EjvError);
-
-				if (!error2) {
-					throw new Error('spec failed');
-				}
-
-				expect(error2.type).to.be.eql(ERROR_TYPE.BIGGER_THAN);
-				expect(error2.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.BIGGER_THAN, {
-					placeholders: [10]
-				}));
-
-				expect(ejv({
-					a: 11
-				}, [{
-					key: 'a',
-					type: 'number',
-					min: 10,
-					exclusiveMin: true
-				}])).to.be.null;
-			});
-
-			it('exclusiveMin === false', () => {
-				const error1: EjvError | null = ejv({
-					a: 9
-				}, [{
-					key: 'a',
-					type: 'number',
-					min: 10,
-					exclusiveMin: false
-				}]);
-
-				expect(error1).to.be.instanceof(EjvError);
-
-				if (!error1) {
-					throw new Error('spec failed');
-				}
-
-				expect(error1.type).to.be.eql(ERROR_TYPE.BIGGER_THAN_OR_EQUAL);
-				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.BIGGER_THAN_OR_EQUAL, {
-					placeholders: [10]
-				}));
-
-				expect(ejv({
-					a: 10
-				}, [{
-					key: 'a',
-					type: 'number',
-					min: 10,
-					exclusiveMin: false
-				}])).to.be.null;
-
-				expect(ejv({
-					a: 11
-				}, [{
-					key: 'a',
-					type: 'number',
-					min: 10,
-					exclusiveMin: false
-				}])).to.be.null;
-			});
-		});
-	});
-
-	describe('max & exclusiveMax', () => {
-		describe('max only', () => {
-			describe('check parameter', () => {
-				it('undefined is ok', () => {
-					expect(ejv({
-						a: 1
-					}, [{
-						key: 'a',
-						type: 'number',
-						max: undefined
-					}])).to.be.null;
-				});
-
-				it('null', () => {
-					const data = {
-						a: 3
-					};
-
-					const errorScheme: Scheme = {
-						key: 'a',
-						type: 'number',
-						max: null as unknown as number
-					};
-
-					checkSchemeError({
-						data,
-						errorScheme,
-						message: createErrorMsg(ERROR_MESSAGE.MAX_SHOULD_BE_NUMBER)
-					});
-				});
-
-				it('max type', () => {
-					const data = {
-						a: 3
-					};
-
-					const errorScheme: Scheme = {
-						key: 'a',
-						type: 'number',
-						max: '3'
-					};
-
-					checkSchemeError({
-						data,
-						errorScheme,
-						message: createErrorMsg(ERROR_MESSAGE.MAX_SHOULD_BE_NUMBER)
-					});
-				});
-
-				it('0 is ok', () => {
-					expect(ejv({
-						a: -1
-					}, [{
-						key: 'a',
-						type: 'number',
-						max: 0
-					}])).to.be.null;
-				});
-			});
-
-			it('ok', () => {
-				expect(ejv({
-					a: 9
-				}, [{
-					key: 'a',
-					type: 'number',
-					max: 10
-				}])).to.be.null;
-
-				expect(ejv({
-					a: 10
-				}, [{
-					key: 'a',
-					type: 'number',
-					max: 10
-				}])).to.be.null;
-
-				const error1: EjvError | null = ejv({
-					a: 11
-				}, [{
-					key: 'a',
-					type: 'number',
-					max: 10
-				}]);
-
-				expect(error1).to.be.instanceof(EjvError);
-
-				if (!error1) {
-					throw new Error('spec failed');
-				}
-
-				expect(error1.type).to.be.eql(ERROR_TYPE.SMALLER_THAN_OR_EQUAL);
-				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.SMALLER_THAN_OR_EQUAL, {
-					placeholders: [10]
-				}));
-			});
-		});
-
-		describe('exclusiveMax', () => {
-			describe('check parameter', () => {
-				it('exclusiveMax type', () => {
-					const data = {
-						a: 3
-					};
-
-					const errorScheme: Scheme = {
-						key: 'a',
-						type: 'number',
-						max: 3,
-						exclusiveMax: '3' as unknown as boolean
-					};
-
-					checkSchemeError({
-						data,
-						errorScheme,
-						message: createErrorMsg(ERROR_MESSAGE.EXCLUSIVE_MAX_SHOULD_BE_BOOLEAN)
-					});
-				});
-			});
-
-			it('exclusiveMax === true', () => {
-				expect(ejv({
-					a: 9
-				}, [{
-					key: 'a',
-					type: 'number',
-					max: 10,
-					exclusiveMax: true
-				}])).to.be.null;
-
-				const error1: EjvError | null = ejv({
-					a: 10
-				}, [{
-					key: 'a',
-					type: 'number',
-					max: 10,
-					exclusiveMax: true
-				}]);
-
-				expect(error1).to.be.instanceof(EjvError);
-
-				if (!error1) {
-					throw new Error('spec failed');
-				}
-
-				expect(error1.type).to.be.eql(ERROR_TYPE.SMALLER_THAN);
-				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.SMALLER_THAN, {
-					placeholders: [10]
-				}));
-
-				const error2: EjvError | null = ejv({
-					a: 11
-				}, [{
-					key: 'a',
-					type: 'number',
-					max: 10,
-					exclusiveMax: true
-				}]);
-
-				expect(error2).to.be.instanceof(EjvError);
-
-				if (!error2) {
-					throw new Error('spec failed');
-				}
-
-				expect(error2.type).to.be.eql(ERROR_TYPE.SMALLER_THAN);
-				expect(error2.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.SMALLER_THAN, {
-					placeholders: [10]
-				}));
-			});
-
-			it('exclusiveMax === false', () => {
-				expect(ejv({
-					a: 9
-				}, [{
-					key: 'a',
-					type: 'number',
-					max: 10,
-					exclusiveMax: false
-				}])).to.be.null;
-
-				expect(ejv({
-					a: 10
-				}, [{
-					key: 'a',
-					type: 'number',
-					max: 10,
-					exclusiveMax: false
-				}])).to.be.null;
-
-				const error1: EjvError | null = ejv({
-					a: 11
-				}, [{
-					key: 'a',
-					type: 'number',
-					max: 10,
-					exclusiveMax: false
-				}]);
-
-				expect(error1).to.be.instanceof(EjvError);
-
-				if (!error1) {
-					throw new Error('spec failed');
-				}
-
-				expect(error1.type).to.be.eql(ERROR_TYPE.SMALLER_THAN_OR_EQUAL);
-				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.SMALLER_THAN_OR_EQUAL, {
-					placeholders: [10]
-				}));
-			});
-		});
-	});
-
-	describe('format', () => {
-		describe('check parameter', () => {
-			it('undefined is ok', () => {
-				expect(ejv({
-					a: 123.5
-				}, [{
-					key: 'a',
-					type: 'number',
-					format: undefined
-				}])).to.be.null;
-			});
-
-			it('null', () => {
-				const data = {
-					a: 123.5
-				};
-
-				const errorScheme: Scheme = {
-					key: 'a',
-					type: 'number',
-					format: null as unknown as string
-				};
-
-				checkSchemeError({
-					data,
-					errorScheme,
-					message: createErrorMsg(ERROR_MESSAGE.INVALID_NUMBER_FORMAT, {
-						placeholders: ['null']
-					})
-				});
-			});
-
-			describe('invalid number format', () => {
-				const data = {
-					a: 1
-				};
-
-				it('single', () => {
-					const errorScheme: Scheme = {
-						key: 'a',
-						type: 'number',
-						format: 'invalidNumberFormat'
-					};
-
-					checkSchemeError({
-						data,
-						errorScheme,
-						message: createErrorMsg(ERROR_MESSAGE.INVALID_NUMBER_FORMAT, {
-							placeholders: ['invalidNumberFormat']
-						})
-					});
-				});
-
-				it('multiple', () => {
-					const errorScheme: Scheme = {
-						key: 'a',
-						type: 'number',
-						format: ['index', 'invalidNumberFormat']
-					};
-
-					checkSchemeError({
-						data,
-						errorScheme,
-						message: createErrorMsg(ERROR_MESSAGE.INVALID_NUMBER_FORMAT, {
-							placeholders: ['invalidNumberFormat']
-						})
-					});
-				});
-			});
-		});
-
-		describe('integer', () => {
-			describe('single format', () => {
-				it('fail', () => {
-					const error: EjvError | null = ejv({
-						a: 123.5
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: 'integer'
-					}]);
-
-					expect(error).to.be.instanceof(EjvError);
-
-					if (!error) {
-						throw new Error('spec failed');
-					}
-
-					expect(error.type).to.be.eql(ERROR_TYPE.FORMAT);
-					expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT, {
-						placeholders: ['integer']
-					}));
-				});
-
-				it('ok', () => {
-					expect(ejv({
-						a: 123
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: 'integer'
-					}])).to.be.null;
-				});
-			});
-
-			describe('multiple formats', () => {
-				it('fail', () => {
-					const formatArr: string[] = ['integer'];
-
-					const error: EjvError | null = ejv({
-						a: 123.5
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: formatArr
-					}]);
-
-					expect(error).to.be.instanceof(EjvError);
-
-					if (!error) {
-						throw new Error('spec failed');
-					}
-
-					expect(error.type).to.be.eql(ERROR_TYPE.FORMAT_ONE_OF);
-					expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT_ONE_OF, {
-						placeholders: [JSON.stringify(formatArr)]
-					}));
-				});
-
-				it('ok', () => {
-					expect(ejv({
-						a: -7
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['integer']
-					}])).to.be.null;
-
-					expect(ejv({
-						a: 0
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['integer']
-					}])).to.be.null;
-
-					expect(ejv({
-						a: 123
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['integer']
-					}])).to.be.null;
-				});
-
-				it('ok - with others', () => {
-					expect(ejv({
-						a: -7
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['integer', 'index']
-					}])).to.be.null;
-
-					expect(ejv({
-						a: 0
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['integer', 'index']
-					}])).to.be.null;
-
-					expect(ejv({
-						a: 123
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['integer', 'index']
-					}])).to.be.null;
-				});
-
-				it('ok - with others', () => {
-					expect(ejv({
-						a: -7
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['index', 'integer']
-					}])).to.be.null;
-
-					expect(ejv({
-						a: 0
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['index', 'integer']
-					}])).to.be.null;
-
-					expect(ejv({
-						a: 123
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['index', 'integer']
-					}])).to.be.null;
-				});
-			});
-		});
-
-		describe('index', () => {
-			describe('single format', () => {
-				it('fail', () => {
-					const error1: EjvError | null = ejv({
-						a: 1.5
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: 'index'
-					}]);
-
-					expect(error1).to.be.instanceof(EjvError);
-
-					if (!error1) {
-						throw new Error('spec failed');
-					}
-
-					expect(error1.type).to.be.eql(ERROR_TYPE.FORMAT);
-					expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT, {
-						placeholders: ['index']
-					}));
-
-					const error2: EjvError | null = ejv({
-						a: -1
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: 'index'
-					}]);
-
-					expect(error2).to.be.instanceof(EjvError);
-
-					if (!error2) {
-						throw new Error('spec failed');
-					}
-
-					expect(error2.type).to.be.eql(ERROR_TYPE.FORMAT);
-					expect(error2.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT, {
-						placeholders: ['index']
-					}));
-
-					const error3: EjvError | null = ejv({
-						a: -1.6
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: 'index'
-					}]);
-
-					expect(error3).to.be.instanceof(EjvError);
-
-					if (!error3) {
-						throw new Error('spec failed');
-					}
-
-					expect(error3.type).to.be.eql(ERROR_TYPE.FORMAT);
-					expect(error3.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT, {
-						placeholders: ['index']
-					}));
-				});
-
-				it('ok', () => {
-					expect(ejv({
-						a: 0
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: 'index'
-					}])).to.be.null;
-
-					expect(ejv({
-						a: 6
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: 'index'
-					}])).to.be.null;
-				});
-			});
-
-			describe('multiple formats', () => {
-				it('fail', () => {
-					const formatArr: string[] = ['index'];
-
-					const error1: EjvError | null = ejv({
-						a: 1.5
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: formatArr
-					}]);
-
-					expect(error1).to.be.instanceof(EjvError);
-
-					if (!error1) {
-						throw new Error('spec failed');
-					}
-
-					expect(error1.type).to.be.eql(ERROR_TYPE.FORMAT_ONE_OF);
-					expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT_ONE_OF, {
-						placeholders: [JSON.stringify(formatArr)]
-					}));
-
-					const error2: EjvError | null = ejv({
-						a: -1
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: formatArr
-					}]);
-
-					expect(error2).to.be.instanceof(EjvError);
-
-					if (!error2) {
-						throw new Error('spec failed');
-					}
-
-					expect(error2.type).to.be.eql(ERROR_TYPE.FORMAT_ONE_OF);
-					expect(error2.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT_ONE_OF, {
-						placeholders: [JSON.stringify(formatArr)]
-					}));
-
-					const error3: EjvError | null = ejv({
-						a: -1.6
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: formatArr
-					}]);
-
-					expect(error3).to.be.instanceof(EjvError);
-
-					if (!error3) {
-						throw new Error('spec failed');
-					}
-
-					expect(error3.type).to.be.eql(ERROR_TYPE.FORMAT_ONE_OF);
-					expect(error3.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT_ONE_OF, {
-						placeholders: [JSON.stringify(formatArr)]
-					}));
-				});
-
-				it('ok', () => {
-					expect(ejv({
-						a: 0
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['index']
-					}])).to.be.null;
-
-					expect(ejv({
-						a: 6
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['index']
-					}])).to.be.null;
-				});
-
-				it('ok - with others', () => {
-					expect(ejv({
-						a: 0
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['index', 'integer']
-					}])).to.be.null;
-
-					expect(ejv({
-						a: 6
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['index', 'integer']
-					}])).to.be.null;
-				});
-
-				it('ok - with others', () => {
-					expect(ejv({
-						a: 0
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['integer', 'index']
-					}])).to.be.null;
-
-					expect(ejv({
-						a: 6
-					}, [{
-						key: 'a',
-						type: 'number',
-						format: ['integer', 'index']
-					}])).to.be.null;
-				});
-			});
-		});
-	});
-});
+import { describe, it } from 'mocha';
+import { expect } from 'chai';
+
+import { ejv } from '../src/ejv';
+
+import { EjvError, Scheme } from '../src/interfaces';
+import { ERROR_MESSAGE, ERROR_TYPE } from '../src/constants';
+import { createErrorMsg } from '../src/util';
+import { checkSchemeError, TypeTester, typeTesterArr } from './common-test-util';
+
+
+describe('NumberScheme', () => {
+	describe('type', () => {
+		describe('mismatch', () => {
+			typeTesterArr
+				.filter((obj: TypeTester): boolean => obj.type !== 'number')
+				.forEach((obj: TypeTester): void => {
+					const data = {
+						a: obj.value
+					};
+
+					it(obj.type, () => {
+						const error: EjvError | null = ejv(data, [{
+							key: 'a',
+							type: 'number'
+						}]);
+
+						expect(error).to.be.instanceof(EjvError);
+
+						if (!error) {
+							throw new Error('spec failed');
+						}
+
+						expect(error.type).to.be.eql(ERROR_TYPE.TYPE_MISMATCH);
+						expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.TYPE_MISMATCH, {
+							placeholders: ['number']
+						}));
+						expect(error.path).to.be.eql('a');
+						expect(error.data).to.be.deep.equal(data);
+						expect(error.errorData).to.be.eql(obj.value);
+					});
+				});
+
+			it('multiple types', () => {
+				const value = 123;
+				const typeArr: string[] = ['boolean', 'string'];
+
+				const data = {
+					a: value
+				};
+
+				const error: EjvError | null = ejv(data, [{
+					key: 'a',
+					type: typeArr
+				}]);
+
+				expect(error).to.be.instanceof(EjvError);
+
+				if (!error) {
+					throw new Error('spec failed');
+				}
+
+				expect(error.type).to.be.eql(ERROR_TYPE.TYPE_MISMATCH_ONE_OF);
+				expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.TYPE_MISMATCH_ONE_OF, {
+					placeholders: [JSON.stringify(typeArr)]
+				}));
+				expect(error.path).to.be.eql('a');
+				expect(error.data).to.be.deep.equal(data);
+				expect(error.errorData).to.be.eql(value);
+			});
+		});
+
+		describe('match', () => {
+			it('optional', () => {
+				expect(ejv({
+					a: undefined
+				}, [{
+					key: 'a',
+					type: 'number',
+					optional: true
+				}])).to.be.null;
+			});
+
+			it('single type', () => {
+				expect(ejv({
+					a: 123
+				}, [{
+					key: 'a',
+					type: 'number'
+				}])).to.be.null;
+			});
+
+			it('multiple types', () => {
+				expect(ejv({
+					a: 123
+				}, [{
+					key: 'a',
+					type: ['number', 'string']
+				}])).to.be.null;
+			});
+
+			it('multiple types', () => {
+				expect(ejv({
+					a: 123
+				}, [{
+					key: 'a',
+					type: ['string', 'number']
+				}])).to.be.null;
+			});
+		});
+	});
+
+	describe('enum & notEnum', () => {
+		describe('enum', () => {
+			describe('check parameter', () => {
+				it('undefined is ok', () => {
+					expect(ejv({
+						a: 1
+					}, [{
+						key: 'a',
+						type: 'number',
+						enum: undefined
+					}])).to.be.null;
+				});
+
+				it('null', () => {
+					const data = {
+						a: 1
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						enum: null as unknown as number[]
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.ENUM_SHOULD_BE_ARRAY)
+					});
+				});
+
+				it('not array', () => {
+					const data = {
+						a: 10
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						enum: 1 as unknown as number[]
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.ENUM_SHOULD_BE_ARRAY)
+					});
+				});
+
+				it('not number', () => {
+					const data = {
+						a: 10
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						enum: ['10']
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.ENUM_SHOULD_BE_NUMBERS)
+					});
+				});
+			});
+
+			it('fail', () => {
+				const enumArr: number[] = [9, 11];
+
+				const data = {
+					a: 10
+				};
+
+				const error: EjvError | null = ejv(data, [{
+					key: 'a',
+					type: 'number',
+					enum: enumArr
+				}]);
+
+				expect(error).to.be.instanceof(EjvError);
+
+				if (!error) {
+					throw new Error('spec failed');
+				}
+
+				expect(error.type).to.be.eql(ERROR_TYPE.ONE_VALUE_OF);
+				expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.ONE_VALUE_OF, {
+					placeholders: [JSON.stringify(enumArr)]
+				}));
+				expect(error.path).to.be.eql('a');
+				expect(error.data).to.be.deep.equal(data);
+				expect(error.errorData).to.be.eql(10);
+			});
+
+			it('ok', () => {
+				expect(ejv({
+					a: 10
+				}, [{
+					key: 'a',
+					type: 'number',
+					enum: [9, 10, 11]
+				}])).to.be.null;
+			});
+		});
+
+		describe('notEnum', () => {
+			describe('check parameter', () => {
+				it('undefined is ok', () => {
+					expect(ejv({
+						a: 1
+					}, [{
+						key: 'a',
+						type: 'number',
+						notEnum: undefined
+					}])).to.be.null;
+				});
+
+				it('null', () => {
+					const data = {
+						a: 1
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						notEnum: null as unknown as number[]
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.NOT_ENUM_SHOULD_BE_ARRAY)
+					});
+				});
+
+				it('not array', () => {
+					const data = {
+						a: 10
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						notEnum: 1 as unknown as number[]
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.NOT_ENUM_SHOULD_BE_ARRAY)
+					});
+				});
+
+				it('not number', () => {
+					const data = {
+						a: 10
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						notEnum: ['10']
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.NOT_ENUM_SHOULD_BE_NUMBERS)
+					});
+				});
+			});
+
+			it('fail', () => {
+				const enumArr: number[] = [9, 10, 11];
+
+				const data = {
+					a: 9
+				};
+
+				const error: EjvError | null = ejv(data, [{
+					key: 'a',
+					type: 'number',
+					notEnum: enumArr
+				}]);
+
+				expect(error).to.be.instanceof(EjvError);
+
+				if (!error) {
+					throw new Error('spec failed');
+				}
+
+				expect(error.type).to.be.eql(ERROR_TYPE.NOT_ONE_VALUE_OF);
+				expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.NOT_ONE_VALUE_OF, {
+					placeholders: [JSON.stringify(enumArr)]
+				}));
+				expect(error.path).to.be.eql('a');
+				expect(error.data).to.be.deep.equal(data);
+				expect(error.errorData).to.be.eql(9);
+			});
+
+			it('ok', () => {
+				expect(ejv({
+					a: 8
+				}, [{
+					key: 'a',
+					type: 'number',
+					notEnum: [9, 10, 11]
+				}])).to.be.null;
+			});
+		});
+	});
+
+	describe('min & exclusiveMin', () => {
+		describe('min only', () => {
+			describe('check parameter', () => {
+				it('undefined is ok', () => {
+					expect(ejv({
+						a: 1
+					}, [{
+						key: 'a',
+						type: 'number',
+						min: undefined
+					}])).to.be.null;
+				});
+
+				it('null', () => {
+					const data = {
+						a: 3
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						min: null as unknown as number
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.MIN_SHOULD_BE_NUMBER)
+					});
+				});
+
+				it('min type', () => {
+					const data = {
+						a: 3
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						min: '3'
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.MIN_SHOULD_BE_NUMBER)
+					});
+				});
+
+				it('0 is ok', () => {
+					expect(ejv({
+						a: 1
+					}, [{
+						key: 'a',
+						type: 'number',
+						min: 0
+					}])).to.be.null;
+				});
+			});
+
+			it('ok', () => {
+				const error1: EjvError | null = ejv({
+					a: 9
+				}, [{
+					key: 'a',
+					type: 'number',
+					min: 10
+				}]);
+
+				expect(error1).to.be.instanceof(EjvError);
+
+				if (!error1) {
+					throw new Error('spec failed');
+				}
+
+				expect(error1.type).to.be.eql(ERROR_TYPE.BIGGER_THAN_OR_EQUAL);
+				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.BIGGER_THAN_OR_EQUAL, {
+					placeholders: [10]
+				}));
+
+				expect(ejv({
+					a: 10
+				}, [{
+					key: 'a',
+					type: 'number',
+					min: 10
+				}])).to.be.null;
+
+				expect(ejv({
+					a: 11
+				}, [{
+					key: 'a',
+					type: 'number',
+					min: 10
+				}])).to.be.null;
+			});
+		});
+
+		describe('exclusiveMin', () => {
+			describe('check parameter', () => {
+				it('exclusiveMin type', () => {
+					const data = {
+						a: 3
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						min: 3,
+						exclusiveMin: '3' as unknown as boolean
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.EXCLUSIVE_MIN_SHOULD_BE_BOOLEAN)
+					});
+				});
+			});
+
+			it('exclusiveMin === true', () => {
+				const error1: EjvError | null = ejv({
+					a: 9
+				}, [{
+					key: 'a',
+					type: 'number',
+					min: 10,
+					exclusiveMin: true
+				}]);
+
+				expect(error1).to.be.instanceof(EjvError);
+
+				if (!error1) {
+					throw new Error('spec failed');
+				}
+
+				expect(error1.type).to.be.eql(ERROR_TYPE.BIGGER_THAN);
+				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.BIGGER_THAN, {
+					placeholders: [10]
+				}));
+
+				const error2: EjvError | null = ejv({
+					a: 10
+				}, [{
+					key: 'a',
+					type: 'number',
+					min: 10,
+					exclusiveMin: true
+				}]);
+
+				expect(error2).to.be.instanceof(EjvError);
+
+				if (!error2) {
+					throw new Error('spec failed');
+				}
+
+				expect(error2.type).to.be.eql(ERROR_TYPE.BIGGER_THAN);
+				expect(error2.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.BIGGER_THAN, {
+					placeholders: [10]
+				}));
+
+				expect(ejv({
+					a: 11
+				}, [{
+					key: 'a',
+					type: 'number',
+					min: 10,
+					exclusiveMin: true
+				}])).to.be.null;
+			});
+
+			it('exclusiveMin === false', () => {
+				const error1: EjvError | null = ejv({
+					a: 9
+				}, [{
+					key: 'a',
+					type: 'number',
+					min: 10,
+					exclusiveMin: false
+				}]);
+
+				expect(error1).to.be.instanceof(EjvError);
+
+				if (!error1) {
+					throw new Error('spec failed');
+				}
+
+				expect(error1.type).to.be.eql(ERROR_TYPE.BIGGER_THAN_OR_EQUAL);
+				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.BIGGER_THAN_OR_EQUAL, {
+					placeholders: [10]
+				}));
+
+				expect(ejv({
+					a: 10
+				}, [{
+					key: 'a',
+					type: 'number',
+					min: 10,
+					exclusiveMin: false
+				}])).to.be.null;
+
+				expect(ejv({
+					a: 11
+				}, [{
+					key: 'a',
+					type: 'number',
+					min: 10,
+					exclusiveMin: false
+				}])).to.be.null;
+			});
+		});
+	});
+
+	describe('max & exclusiveMax', () => {
+		describe('max only', () => {
+			describe('check parameter', () => {
+				it('undefined is ok', () => {
+					expect(ejv({
+						a: 1
+					}, [{
+						key: 'a',
+						type: 'number',
+						max: undefined
+					}])).to.be.null;
+				});
+
+				it('null', () => {
+					const data = {
+						a: 3
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						max: null as unknown as number
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.MAX_SHOULD_BE_NUMBER)
+					});
+				});
+
+				it('max type', () => {
+					const data = {
+						a: 3
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						max: '3'
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.MAX_SHOULD_BE_NUMBER)
+					});
+				});
+
+				it('0 is ok', () => {
+					expect(ejv({
+						a: -1
+					}, [{
+						key: 'a',
+						type: 'number',
+						max: 0
+					}])).to.be.null;
+				});
+			});
+
+			it('ok', () => {
+				expect(ejv({
+					a: 9
+				}, [{
+					key: 'a',
+					type: 'number',
+					max: 10
+				}])).to.be.null;
+
+				expect(ejv({
+					a: 10
+				}, [{
+					key: 'a',
+					type: 'number',
+					max: 10
+				}])).to.be.null;
+
+				const error1: EjvError | null = ejv({
+					a: 11
+				}, [{
+					key: 'a',
+					type: 'number',
+					max: 10
+				}]);
+
+				expect(error1).to.be.instanceof(EjvError);
+
+				if (!error1) {
+					throw new Error('spec failed');
+				}
+
+				expect(error1.type).to.be.eql(ERROR_TYPE.SMALLER_THAN_OR_EQUAL);
+				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.SMALLER_THAN_OR_EQUAL, {
+					placeholders: [10]
+				}));
+			});
+		});
+
+		describe('exclusiveMax', () => {
+			describe('check parameter', () => {
+				it('exclusiveMax type', () => {
+					const data = {
+						a: 3
+					};
+
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						max: 3,
+						exclusiveMax: '3' as unknown as boolean
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.EXCLUSIVE_MAX_SHOULD_BE_BOOLEAN)
+					});
+				});
+			});
+
+			it('exclusiveMax === true', () => {
+				expect(ejv({
+					a: 9
+				}, [{
+					key: 'a',
+					type: 'number',
+					max: 10,
+					exclusiveMax: true
+				}])).to.be.null;
+
+				const error1: EjvError | null = ejv({
+					a: 10
+				}, [{
+					key: 'a',
+					type: 'number',
+					max: 10,
+					exclusiveMax: true
+				}]);
+
+				expect(error1).to.be.instanceof(EjvError);
+
+				if (!error1) {
+					throw new Error('spec failed');
+				}
+
+				expect(error1.type).to.be.eql(ERROR_TYPE.SMALLER_THAN);
+				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.SMALLER_THAN, {
+					placeholders: [10]
+				}));
+
+				const error2: EjvError | null = ejv({
+					a: 11
+				}, [{
+					key: 'a',
+					type: 'number',
+					max: 10,
+					exclusiveMax: true
+				}]);
+
+				expect(error2).to.be.instanceof(EjvError);
+
+				if (!error2) {
+					throw new Error('spec failed');
+				}
+
+				expect(error2.type).to.be.eql(ERROR_TYPE.SMALLER_THAN);
+				expect(error2.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.SMALLER_THAN, {
+					placeholders: [10]
+				}));
+			});
+
+			it('exclusiveMax === false', () => {
+				expect(ejv({
+					a: 9
+				}, [{
+					key: 'a',
+					type: 'number',
+					max: 10,
+					exclusiveMax: false
+				}])).to.be.null;
+
+				expect(ejv({
+					a: 10
+				}, [{
+					key: 'a',
+					type: 'number',
+					max: 10,
+					exclusiveMax: false
+				}])).to.be.null;
+
+				const error1: EjvError | null = ejv({
+					a: 11
+				}, [{
+					key: 'a',
+					type: 'number',
+					max: 10,
+					exclusiveMax: false
+				}]);
+
+				expect(error1).to.be.instanceof(EjvError);
+
+				if (!error1) {
+					throw new Error('spec failed');
+				}
+
+				expect(error1.type).to.be.eql(ERROR_TYPE.SMALLER_THAN_OR_EQUAL);
+				expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.SMALLER_THAN_OR_EQUAL, {
+					placeholders: [10]
+				}));
+			});
+		});
+	});
+
+	describe('format', () => {
+		describe('check parameter', () => {
+			it('undefined is ok', () => {
+				expect(ejv({
+					a: 123.5
+				}, [{
+					key: 'a',
+					type: 'number',
+					format: undefined
+				}])).to.be.null;
+			});
+
+			it('null', () => {
+				const data = {
+					a: 123.5
+				};
+
+				const errorScheme: Scheme = {
+					key: 'a',
+					type: 'number',
+					format: null as unknown as string
+				};
+
+				checkSchemeError({
+					data,
+					errorScheme,
+					message: createErrorMsg(ERROR_MESSAGE.INVALID_NUMBER_FORMAT, {
+						placeholders: ['null']
+					})
+				});
+			});
+
+			describe('invalid number format', () => {
+				const data = {
+					a: 1
+				};
+
+				it('single', () => {
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						format: 'invalidNumberFormat'
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.INVALID_NUMBER_FORMAT, {
+							placeholders: ['invalidNumberFormat']
+						})
+					});
+				});
+
+				it('multiple', () => {
+					const errorScheme: Scheme = {
+						key: 'a',
+						type: 'number',
+						format: ['index', 'invalidNumberFormat']
+					};
+
+					checkSchemeError({
+						data,
+						errorScheme,
+						message: createErrorMsg(ERROR_MESSAGE.INVALID_NUMBER_FORMAT, {
+							placeholders: ['invalidNumberFormat']
+						})
+					});
+				});
+			});
+		});
+
+		describe('integer', () => {
+			describe('single format', () => {
+				it('fail', () => {
+					const error: EjvError | null = ejv({
+						a: 123.5
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: 'integer'
+					}]);
+
+					expect(error).to.be.instanceof(EjvError);
+
+					if (!error) {
+						throw new Error('spec failed');
+					}
+
+					expect(error.type).to.be.eql(ERROR_TYPE.FORMAT);
+					expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT, {
+						placeholders: ['integer']
+					}));
+				});
+
+				it('ok', () => {
+					expect(ejv({
+						a: 123
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: 'integer'
+					}])).to.be.null;
+				});
+			});
+
+			describe('multiple formats', () => {
+				it('fail', () => {
+					const formatArr: string[] = ['integer'];
+
+					const error: EjvError | null = ejv({
+						a: 123.5
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: formatArr
+					}]);
+
+					expect(error).to.be.instanceof(EjvError);
+
+					if (!error) {
+						throw new Error('spec failed');
+					}
+
+					expect(error.type).to.be.eql(ERROR_TYPE.FORMAT_ONE_OF);
+					expect(error.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT_ONE_OF, {
+						placeholders: [JSON.stringify(formatArr)]
+					}));
+				});
+
+				it('ok', () => {
+					expect(ejv({
+						a: -7
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['integer']
+					}])).to.be.null;
+
+					expect(ejv({
+						a: 0
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['integer']
+					}])).to.be.null;
+
+					expect(ejv({
+						a: 123
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['integer']
+					}])).to.be.null;
+				});
+
+				it('ok - with others', () => {
+					expect(ejv({
+						a: -7
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['integer', 'index']
+					}])).to.be.null;
+
+					expect(ejv({
+						a: 0
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['integer', 'index']
+					}])).to.be.null;
+
+					expect(ejv({
+						a: 123
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['integer', 'index']
+					}])).to.be.null;
+				});
+
+				it('ok - with others', () => {
+					expect(ejv({
+						a: -7
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['index', 'integer']
+					}])).to.be.null;
+
+					expect(ejv({
+						a: 0
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['index', 'integer']
+					}])).to.be.null;
+
+					expect(ejv({
+						a: 123
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['index', 'integer']
+					}])).to.be.null;
+				});
+			});
+		});
+
+		describe('index', () => {
+			describe('single format', () => {
+				it('fail', () => {
+					const error1: EjvError | null = ejv({
+						a: 1.5
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: 'index'
+					}]);
+
+					expect(error1).to.be.instanceof(EjvError);
+
+					if (!error1) {
+						throw new Error('spec failed');
+					}
+
+					expect(error1.type).to.be.eql(ERROR_TYPE.FORMAT);
+					expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT, {
+						placeholders: ['index']
+					}));
+
+					const error2: EjvError | null = ejv({
+						a: -1
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: 'index'
+					}]);
+
+					expect(error2).to.be.instanceof(EjvError);
+
+					if (!error2) {
+						throw new Error('spec failed');
+					}
+
+					expect(error2.type).to.be.eql(ERROR_TYPE.FORMAT);
+					expect(error2.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT, {
+						placeholders: ['index']
+					}));
+
+					const error3: EjvError | null = ejv({
+						a: -1.6
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: 'index'
+					}]);
+
+					expect(error3).to.be.instanceof(EjvError);
+
+					if (!error3) {
+						throw new Error('spec failed');
+					}
+
+					expect(error3.type).to.be.eql(ERROR_TYPE.FORMAT);
+					expect(error3.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT, {
+						placeholders: ['index']
+					}));
+				});
+
+				it('ok', () => {
+					expect(ejv({
+						a: 0
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: 'index'
+					}])).to.be.null;
+
+					expect(ejv({
+						a: 6
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: 'index'
+					}])).to.be.null;
+				});
+			});
+
+			describe('multiple formats', () => {
+				it('fail', () => {
+					const formatArr: string[] = ['index'];
+
+					const error1: EjvError | null = ejv({
+						a: 1.5
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: formatArr
+					}]);
+
+					expect(error1).to.be.instanceof(EjvError);
+
+					if (!error1) {
+						throw new Error('spec failed');
+					}
+
+					expect(error1.type).to.be.eql(ERROR_TYPE.FORMAT_ONE_OF);
+					expect(error1.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT_ONE_OF, {
+						placeholders: [JSON.stringify(formatArr)]
+					}));
+
+					const error2: EjvError | null = ejv({
+						a: -1
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: formatArr
+					}]);
+
+					expect(error2).to.be.instanceof(EjvError);
+
+					if (!error2) {
+						throw new Error('spec failed');
+					}
+
+					expect(error2.type).to.be.eql(ERROR_TYPE.FORMAT_ONE_OF);
+					expect(error2.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT_ONE_OF, {
+						placeholders: [JSON.stringify(formatArr)]
+					}));
+
+					const error3: EjvError | null = ejv({
+						a: -1.6
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: formatArr
+					}]);
+
+					expect(error3).to.be.instanceof(EjvError);
+
+					if (!error3) {
+						throw new Error('spec failed');
+					}
+
+					expect(error3.type).to.be.eql(ERROR_TYPE.FORMAT_ONE_OF);
+					expect(error3.message).to.be.eql(createErrorMsg(ERROR_MESSAGE.FORMAT_ONE_OF, {
+						placeholders: [JSON.stringify(formatArr)]
+					}));
+				});
+
+				it('ok', () => {
+					expect(ejv({
+						a: 0
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['index']
+					}])).to.be.null;
+
+					expect(ejv({
+						a: 6
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['index']
+					}])).to.be.null;
+				});
+
+				it('ok - with others', () => {
+					expect(ejv({
+						a: 0
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['index', 'integer']
+					}])).to.be.null;
+
+					expect(ejv({
+						a: 6
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['index', 'integer']
+					}])).to.be.null;
+				});
+
+				it('ok - with others', () => {
+					expect(ejv({
+						a: 0
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['integer', 'index']
+					}])).to.be.null;
+
+					expect(ejv({
+						a: 6
+					}, [{
+						key: 'a',
+						type: 'number',
+						format: ['integer', 'index']
+					}])).to.be.null;
+				});
+			});
+		});
+	});
+});