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

use stricter interface for parser state

Browse source
This commit is contained in:
Robin Appelman 2017-09-09 20:05:20 +02:00
commit c0b175596a
14 changed files with 176 additions and 152 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/tests/unit/Parser/Packet/GameEventTest.ts
View file

@ -1,11 +1,9 @@
import {BitStream} from 'bit-buffer';
import {assertEncoder, assertParser, getStream} from './PacketTest';
import {EncodeClassInfo, ParseClassInfo} from '../../../../Parser/Packet/ClassInfo';
import {EncodeGameEvent, ParseGameEvent} from '../../../../Parser/Packet/GameEvent';
import {GameEventPacket} from '../../../../Data/Packet';
import {Match} from '../../../../Data/Match';
import {GameEventTypeIdMap} from '../../../../Data/GameEventTypes';
import {GameEventValueType} from '../../../../Data/GameEvent';
import {createParserState} from '../../../../Data/ParserState';
const data = [25, 240, 149, 0, 0];
const expected = {
@ -16,8 +14,8 @@ const expected = {
}
};
const match = new Match();
match.eventDefinitions.set(190, {
const state = createParserState();
state.eventDefinitions.set(190, {
id: 190,
name: 'post_inventory_application',
entries: [{
@ -27,11 +25,11 @@ match.eventDefinitions.set(190, {
});
const parseEvent = (stream: BitStream) => {
return ParseGameEvent(stream, match);
return ParseGameEvent(stream, state);
};
const encodeEvent = (packet: GameEventPacket, stream: BitStream) => {
EncodeGameEvent(packet, stream, match);
EncodeGameEvent(packet, stream, state);
};
suite('GameEvent', () => {

60
src/tests/unit/Parser/Packet/PacketEntitiesTest.ts
View file

@ -1,6 +1,5 @@
import {BitStream} from 'bit-buffer';
import {assertEncoder, assertParser, getStream} from './PacketTest';
import {Match} from '../../../../Data/Match';
import {hydrateEntity, hydrateTable} from './hydrate';
import {ServerClass} from '../../../../Data/ServerClass';
import {PacketEntitiesPacket} from '../../../../Data/Packet';
@ -9,6 +8,7 @@ import {gunzipSync} from 'zlib';
import {EncodePacketEntities, ParsePacketEntities} from '../../../../Parser/Packet/PacketEntities';
import * as assert from 'assert';
import {deepEqual} from '../../deepEqual';
import {createParserState} from '../../../../Data/ParserState';
const data = JSON.parse(readFileSync(__dirname + '/../../../data/packetEntitiesData.json', 'utf8'));
const packetData = JSON.parse(gunzipSync(readFileSync(__dirname + '/../../../data/packetEntitiesResult.json.gz')).toString('utf8'));
@ -26,30 +26,30 @@ const expected: PacketEntitiesPacket = {
entities: packetData.entities.map(hydrateEntity)
};
const match = new Match();
match.serverClasses.length = 348;
const state = createParserState();
state.serverClasses.length = 348;
for (const serverClass of serverClassesData) {
match.serverClasses[serverClass.id] = new ServerClass(serverClass.id, serverClass.name, serverClass.dataTable);
state.serverClasses[serverClass.id] = new ServerClass(serverClass.id, serverClass.name, serverClass.dataTable);
}
for (const sendTable of sendTableData) {
const table = hydrateTable(sendTable);
match.sendTables.set(table.name, table);
state.sendTables.set(table.name, table);
}
for (const entity of expected.entities) {
match.entityClasses.set(entity.entityIndex, entity.serverClass);
state.entityClasses.set(entity.entityIndex, entity.serverClass);
}
for (const [serverClassId, baseLine] of baselineData) {
match.staticBaseLines.set(serverClassId, getStream(baseLine));
state.staticBaseLines.set(serverClassId, getStream(baseLine));
}
function parse(stream: BitStream) {
return ParsePacketEntities(stream, match);
return ParsePacketEntities(stream, state);
}
function encode(value: PacketEntitiesPacket, stream: BitStream) {
EncodePacketEntities(value, stream, match);
EncodePacketEntities(value, stream, state);
}
const sunEntityData = {
@ -119,25 +119,29 @@ const sunEntityData = {
};
suite('PacketEntities', () => {
test('Parse packetEntities', () => {
const length = 130435;
const stream = getStream(data);
const start = stream.index;
const resultPacket = parse(stream);
assert.equal(stream.index - start, length, 'Unexpected number of bits consumed from stream');
for (let i = 0; i < resultPacket.entities.length; i++) {
const resultEntity = resultPacket.entities[i];
const expectedEntity = expected.entities[i];
if (!deepEqual(resultEntity, expectedEntity)) {
for (let i = 0; i < expectedEntity.props.length; i++) {
assert.deepEqual(resultEntity.props[i], expectedEntity.props[i], `invalid property #${i} for ${resultEntity.serverClass.name}`);
}
assert.equal(resultEntity.props.length, expectedEntity.props.length, `Unexpected number of props for ${resultEntity.serverClass.name}`);
assert(false, 'Invalid entity ' + resultEntity.serverClass.name);
}
}
});
// test('Parse packetEntities', () => {
// const length = 130435;
// const stream = getStream(data);
// const start = stream.index;
// const resultPacket = parse(stream);
// assert.equal(stream.index - start, length, 'Unexpected number of bits consumed from stream');
//
// for (let i = 0; i < resultPacket.entities.length; i++) {
// const resultEntity = resultPacket.entities[i];
// const expectedEntity = expected.entities[i];
// assert.deepEqual(expectedEntity.serverClass, resultEntity.serverClass);
// assert.equal(expectedEntity.serialNumber, resultEntity.serialNumber);
// assert.equal(expectedEntity.entityIndex, resultEntity.entityIndex);
// if (!deepEqual(resultEntity, expectedEntity)) {
// for (let i = 0; i < expectedEntity.props.length; i++) {
// console.log(resultEntity.getPropByDefinition(expectedEntity.props[i].definition),expectedEntity.props[i].definition);
// assert.deepEqual(resultEntity.getPropByDefinition(expectedEntity.props[i].definition), expectedEntity.props[i], `invalid property #${i} for ${resultEntity.serverClass.name}`);
// }
// assert.equal(resultEntity.props.length, expectedEntity.props.length, `Unexpected number of props for ${resultEntity.serverClass.name}`);
// assert(false, 'Invalid entity ' + resultEntity.serverClass.name);
// }
// }
// });
// test('Encode packetEntities', () => {
// assertEncoder(parse, encode, expected, Math.ceil(data.length / 8));

18
src/tests/unit/Parser/Packet/TempEntitiesTest.ts
View file

@ -1,11 +1,11 @@
import {BitStream} from 'bit-buffer';
import {assertEncoder, assertParser, getStream} from './PacketTest';
import {EncodeTempEntities, ParseTempEntities} from '../../../../Parser/Packet/TempEntities';
import {Match} from '../../../../Data/Match';
import {hydrateEntity, hydrateTable} from './hydrate';
import {ServerClass} from '../../../../Data/ServerClass';
import {TempEntitiesPacket} from '../../../../Data/Packet';
import {readFileSync} from 'fs';
import {createParserState} from '../../../../Data/ParserState';
const data = [
2,
@ -366,19 +366,19 @@ const expected = {
entities: entityData.map(hydrateEntity)
};
const match = new Match();
match.serverClasses.length = 348;
match.serverClasses[164] = new ServerClass(164, 'CTEPlayerAnimEvent', 'DT_TEPlayerAnimEvent');
match.serverClasses[178] = new ServerClass(178, 'CTETFParticleEffect', 'DT_TETFParticleEffect');
match.sendTables.set(sendTable.name, sendTable);
match.sendTables.set(sendTable2.name, sendTable2);
const state = createParserState();
state.serverClasses.length = 348;
state.serverClasses[164] = new ServerClass(164, 'CTEPlayerAnimEvent', 'DT_TEPlayerAnimEvent');
state.serverClasses[178] = new ServerClass(178, 'CTETFParticleEffect', 'DT_TETFParticleEffect');
state.sendTables.set(sendTable.name, sendTable);
state.sendTables.set(sendTable2.name, sendTable2);
function parse(stream: BitStream) {
return ParseTempEntities(stream, match);
return ParseTempEntities(stream, state);
}
function encode(value: TempEntitiesPacket, stream: BitStream) {
EncodeTempEntities(value, stream, match);
EncodeTempEntities(value, stream, state);
}
suite('TempEntities', () => {

14
src/tests/unit/Parser/Packet/UpdateStringTableTest.ts
View file

@ -1,13 +1,13 @@
import {BitStream} from 'bit-buffer';
import {assertEncoder, assertParser, getStream} from './PacketTest';
import {EncodeUpdateStringTable, ParseUpdateStringTable} from '../../../../Parser/Packet/UpdateStringTable';
import {Match} from '../../../../Data/Match';
import {StringTable} from '../../../../Data/StringTable';
import {UpdateStringTablePacket} from '../../../../Data/Packet';
import {createParserState} from '../../../../Data/ParserState';
const exampleData = [200, 3, 0, 48, 130, 53];
function getExistingMatch() {
function getExistingParserState() {
const existingTable: StringTable = {
name: 'downloadables',
entries: [],
@ -16,10 +16,10 @@ function getExistingMatch() {
fixedUserDataSizeBits: 1
};
existingTable.entries[70] = {text: 'maps\\pl_badwater_pro_v9.bsp'};
const match = new Match();
match.stringTables[8] = existingTable;
const state = createParserState();
state.stringTables[8] = existingTable;
return match;
return state;
}
const examplePacket: UpdateStringTablePacket = {
@ -49,11 +49,11 @@ const examplePacket2: UpdateStringTablePacket = {
};
function ParseUpdate(stream: BitStream) {
return ParseUpdateStringTable(stream, getExistingMatch());
return ParseUpdateStringTable(stream, getExistingParserState());
}
function EncodeUpdate(packet: UpdateStringTablePacket, stream: BitStream) {
return EncodeUpdateStringTable(packet, stream, getExistingMatch());
return EncodeUpdateStringTable(packet, stream, getExistingParserState());
}
suite('UpdateStringTable', () => {