demostf/demo.js
1
0
Fork 0
mirror of https://github.com/demostf/demo.js synced 2026-06-04 00:54:14 +02:00
Code Issues Releases Wiki Activity

tests refactoring

Browse source
This commit is contained in:
Robin Appelman 2017-08-12 15:17:17 +02:00
commit 628f23b216
2 changed files with 60 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

33
src/tests/unit/Parser/Packet/PacketTest.ts Normal file
View file

@ -0,0 +1,33 @@
import * as assert from 'assert';
import {BitStream} from 'bit-buffer';
import {Packet} from '../../../../Data/Packet';
import {Encoder, Parser} from '../../../../Parser/Packet/Parser';
export function getStream(data: string) {
const buffer = new Buffer(data);
return new BitStream(buffer);
}
export function assertEncoder(parser: Parser, encoder: Encoder, data: any, length: number = 0) {
const stream = new BitStream(new ArrayBuffer(64));
encoder(data as Packet, stream);
const pos = stream.index;
if (length) {
assert.equal(stream.index, length, 'Unexpected number of bits used for encoding');
}
stream.index = 0;
const result = parser(stream);
assert.deepEqual(data, result);
assert.equal(pos, stream.index, 'Number of bits used for encoding and parsing not equal');
}
export function assertParser(parser: Parser, stream: BitStream, expected: any, length: number) {
const start = stream.index;
assert.deepEqual(expected, parser(stream));
assert.equal(stream.index - start, length, 'Unexpected number of bits consumed from stream');
}

80
src/tests/unit/Parser/Packet/ParserGeneratorTest.ts
View file

@ -1,52 +1,30 @@
import * as assert from 'assert';
import {make} from '../../../../Parser/Packet/ParserGenerator'; import {make} from '../../../../Parser/Packet/ParserGenerator';
import {BitStream} from 'bit-buffer'; import {BitStream} from 'bit-buffer';
import {Packet} from '../../../../Data/Packet'; import {assertEncoder, assertParser, getStream} from './PacketTest';
function getStream(data: string) { function assertGeneratedParser(definition: string, stream: BitStream, expected: any, length: number) {
const buffer = new Buffer(data);
return new BitStream(buffer);
}
function assertEncoder(definition: string, data: any, length: number = 0) {
const stream = new BitStream(new ArrayBuffer(64));
const {parser, encoder} = make('packetName', definition);
data.packetType = 'packetName';
encoder(data as Packet, stream);
const pos = stream.index;
if (length) {
assert.equal(stream.index, length, 'Unexpected number of bits used for encoding');
}
stream.index = 0;
const result = parser(stream);
assert.deepEqual(data, result);
assert.equal(pos, stream.index, 'Number of bits used for encoding and parsing not equal');
}
function assertParser(definition: string, stream: BitStream, expected: any, length: number) {
const {parser} = make('packetName', definition);
expected.packetType = 'packetName'; expected.packetType = 'packetName';
const start = stream.index; const {parser} = make('packetName', definition);
assert.deepEqual(expected, parser(stream)); return assertParser(parser, stream, expected, length);
assert.equal(stream.index - start, length, 'Unexpected number of bits consumed from stream'); }
function assertGeneratedEncoder(definition: string, data: any, length: number = 0) {
data.packetType = 'packetName';
const {parser, encoder} = make('packetName', definition);
return assertEncoder(parser, encoder, data, length);
} }
suite('Parser generator', () => { suite('Parser generator', () => {
test('Empty parser', () => { test('Empty parser', () => {
assertParser('', getStream('dummy'), {}, 0); assertGeneratedParser('', getStream('dummy'), {}, 0);
}); });
test('Fixed string', () => { test('Fixed string', () => {
assertParser('foo{s3}', getStream('dummy'), {foo: 'dum'}, 3 * 8); assertGeneratedParser('foo{s3}', getStream('dummy'), {foo: 'dum'}, 3 * 8);
}); });
test('Null terminated string', () => { test('Null terminated string', () => {
assertParser('foo{s}', getStream('dummy'), {foo: 'dummy'}, 5 * 8); assertGeneratedParser('foo{s}', getStream('dummy'), {foo: 'dummy'}, 5 * 8);
}); });
test('Boolean', () => { test('Boolean', () => {
@ -56,8 +34,8 @@ suite('Parser generator', () => {
stream.writeASCIIString('remaining'); stream.writeASCIIString('remaining');
stream.index = 0; stream.index = 0;
assertParser('foo{b}', stream, {foo: true}, 1); assertGeneratedParser('foo{b}', stream, {foo: true}, 1);
assertParser('foo{b}', stream, {foo: false}, 1); assertGeneratedParser('foo{b}', stream, {foo: false}, 1);
}); });
test('Unsigned Int', () => { test('Unsigned Int', () => {
@ -68,9 +46,9 @@ suite('Parser generator', () => {
stream.writeASCIIString('remaining'); stream.writeASCIIString('remaining');
stream.index = 0; stream.index = 0;
assertParser('foo{u2}', stream, {foo: 3}, 2); assertGeneratedParser('foo{u2}', stream, {foo: 3}, 2);
assertParser('foo{u8}', stream, {foo: 0b00111111}, 8); assertGeneratedParser('foo{u8}', stream, {foo: 0b00111111}, 8);
assertParser('foo{u12}', stream, {foo: 0b0000111111000011}, 12); assertGeneratedParser('foo{u12}', stream, {foo: 0b0000111111000011}, 12);
}); });
test('Signed Int', () => { test('Signed Int', () => {
@ -81,9 +59,9 @@ suite('Parser generator', () => {
stream.writeASCIIString('remaining'); stream.writeASCIIString('remaining');
stream.index = 0; stream.index = 0;
assertParser('foo{2}', stream, {foo: -1}, 2); assertGeneratedParser('foo{2}', stream, {foo: -1}, 2);
assertParser('foo{8}', stream, {foo: 63}, 8); assertGeneratedParser('foo{8}', stream, {foo: 63}, 8);
assertParser('foo{12}', stream, {foo: -61}, 12); assertGeneratedParser('foo{12}', stream, {foo: -61}, 12);
}); });
test('Variable length', () => { test('Variable length', () => {
@ -93,7 +71,7 @@ suite('Parser generator', () => {
stream.writeASCIIString('remaining'); stream.writeASCIIString('remaining');
stream.index = 0; stream.index = 0;
assertParser('length{u2}foo{$length}', stream, {length: 3, foo: 7}, 5); assertGeneratedParser('length{u2}foo{$length}', stream, {length: 3, foo: 7}, 5);
}); });
test('Float32', () => { test('Float32', () => {
@ -102,41 +80,41 @@ suite('Parser generator', () => {
stream.writeASCIIString('remaining'); stream.writeASCIIString('remaining');
stream.index = 0; stream.index = 0;
assertParser('foo{f32}', stream, {foo: 12.234233856201172}, 32); assertGeneratedParser('foo{f32}', stream, {foo: 12.234233856201172}, 32);
}); });
test('Encode fixed string', () => { test('Encode fixed string', () => {
assertEncoder('foo{s3}', { assertGeneratedEncoder('foo{s3}', {
foo: 'bar' foo: 'bar'
}, 3 * 8); }, 3 * 8);
}); });
test('Encode null terminated string', () => { test('Encode null terminated string', () => {
assertEncoder('foo{s}', { assertGeneratedEncoder('foo{s}', {
foo: 'bar' foo: 'bar'
}, 4 * 8); }, 4 * 8);
}); });
test('Encode booleans', () => { test('Encode booleans', () => {
assertEncoder('foo{b}bar{b}', { assertGeneratedEncoder('foo{b}bar{b}', {
foo: 1, foo: 1,
bar: 0 bar: 0
}, 2); }, 2);
}); });
test('Encode integers', () => { test('Encode integers', () => {
assertEncoder('foo{u2}bar{12}', { assertGeneratedEncoder('foo{u2}bar{12}', {
foo: 3, foo: 3,
bar: 7 bar: 7
}, 2 + 12); }, 2 + 12);
}); });
test('Encode variable length', () => { test('Encode variable length', () => {
assertEncoder('foo{u2}bar{$foo}', { assertGeneratedEncoder('foo{u2}bar{$foo}', {
foo: 3, foo: 3,
bar: 4 bar: 4
}, 2 + 3); }, 2 + 3);
}); });
test('Encode float', () => { test('Encode float', () => {
assertEncoder('foo{f32}', { assertGeneratedEncoder('foo{f32}', {
foo: 3.5 foo: 3.5
}, 32); }, 32);
}); });