demostf/parser
1
0
Fork 0
mirror of https://codeberg.org/demostf/parser.git synced 2026-06-03 10:14:06 +02:00
Code Issues Releases Wiki Activity

cleanup tests

Browse source
This commit is contained in:
Robin Appelman 2020-03-21 16:04:53 +01:00
commit acc1584524
5 changed files with 70 additions and 123 deletions
Download patch file Download diff file Expand all files Collapse all files

61
tests/entity.rs
View file

@ -1,24 +1,16 @@
#![allow(dead_code)]
#![allow(unused_imports)]
#![allow(unused_variables)]
use pretty_assertions::assert_eq;
use serde::{Deserialize, Serialize};
use serde_repr::{Deserialize_repr, Serialize_repr};
use std::fs::{self, File};
use test_case::test_case;
use std::collections::{HashMap, HashSet};
use std::collections::HashMap;
use std::io::{BufRead, BufReader};
use std::rc::Rc;
use tf_demo_parser::demo::message::packetentities::{EntityId, PacketEntity, PVS};
use tf_demo_parser::demo::message::Message;
use tf_demo_parser::demo::packet::datatable::{
ParseSendTable, SendTableName, ServerClass, ServerClassName,
};
use tf_demo_parser::demo::packet::stringtable::StringTableEntry;
use tf_demo_parser::demo::packet::datatable::{ServerClass, ServerClassName};
use tf_demo_parser::demo::parser::MessageHandler;
use tf_demo_parser::demo::sendprop::{SendPropDefinition, SendPropName, SendPropValue};
use tf_demo_parser::{Demo, DemoParser, MatchState, MessageType, MessageTypeAnalyser, ParserState};
use tf_demo_parser::demo::sendprop::SendPropValue;
use tf_demo_parser::{Demo, DemoParser, MessageType, ParserState};
/// Compatible serialization with the js parser entity dumps
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize_repr, Deserialize_repr)]
@ -53,7 +45,6 @@ struct EntityDump {
impl EntityDump {
pub fn from_entity(entity: PacketEntity, tick: u32, classes: &[ServerClass]) -> Self {
let id = entity.entity_index;
EntityDump {
tick,
server_class: classes[usize::from(entity.server_class)].name.clone(),
@ -115,6 +106,7 @@ impl MessageHandler for EntityDumper {
}
}
#[test_case("data/small.dem", "data/small_entities.json"; "small.dem")]
fn entity_test(input_file: &str, snapshot_file: &str) {
let file = fs::read(input_file).expect("Unable to read file");
let demo = Demo::new(file);
@ -135,31 +127,35 @@ fn entity_test(input_file: &str, snapshot_file: &str) {
buffer.clear();
}
assert_eq!(expected.len(), entities.len());
pretty_assertions::assert_eq!(expected.len(), entities.len());
let entity_ids: Vec<_> = entities.iter().map(|entity| entity.id).collect();
let expected_ids: Vec<_> = expected.iter().map(|entity| entity.id).collect();
assert_eq!(expected_ids, entity_ids);
pretty_assertions::assert_eq!(expected_ids, entity_ids);
for (expected_entity, entity) in expected.into_iter().zip(entities.into_iter()) {
assert_eq!(
expected_entity.tick, entity.tick,
pretty_assertions::assert_eq!(
expected_entity.tick,
entity.tick,
"Failed comparing entity {}",
entity.id
);
assert_eq!(
expected_entity.id, entity.id,
pretty_assertions::assert_eq!(
expected_entity.id,
entity.id,
"Failed comparing entity {}",
entity.id
);
assert_eq!(
expected_entity.server_class, entity.server_class,
pretty_assertions::assert_eq!(
expected_entity.server_class,
entity.server_class,
"Failed comparing entity {}",
entity.id
);
assert_eq!(
expected_entity.pvs, entity.pvs,
pretty_assertions::assert_eq!(
expected_entity.pvs,
entity.pvs,
"Failed comparing entity {}",
entity.id
);
@ -168,14 +164,15 @@ fn entity_test(input_file: &str, snapshot_file: &str) {
prop_names.sort();
expected_prop_names.sort();
assert_eq!(
expected_prop_names, prop_names,
pretty_assertions::assert_eq!(
expected_prop_names,
prop_names,
"Failed comparing entity {}",
entity.id
);
for prop_name in expected_prop_names {
assert_eq!(
pretty_assertions::assert_eq!(
expected_entity.props.get(prop_name),
entity.props.get(prop_name),
"Failed comparing entity {} prop {}",
@ -184,15 +181,11 @@ fn entity_test(input_file: &str, snapshot_file: &str) {
);
}
assert_eq!(
expected_entity, entity,
pretty_assertions::assert_eq!(
expected_entity,
entity,
"Failed comparing entity {}",
entity.id
);
}
}
#[test]
fn entity_test_short() {
entity_test("data/small.dem", "data/small_entities.json");
}

31
tests/sendprops.rs
View file

@ -1,19 +1,10 @@
#![allow(dead_code)]
#![allow(unused_imports)]
#![allow(unused_variables)]
use pretty_assertions::assert_eq;
use std::fs;
use test_case::test_case;
use std::collections::{HashMap, HashSet};
use tf_demo_parser::demo::message::Message;
use tf_demo_parser::demo::packet::datatable::{
ParseSendTable, SendTable, SendTableName, ServerClass,
};
use tf_demo_parser::demo::packet::stringtable::StringTableEntry;
use tf_demo_parser::demo::packet::datatable::{ParseSendTable, SendTableName, ServerClass};
use tf_demo_parser::demo::parser::MessageHandler;
use tf_demo_parser::demo::sendprop::SendPropDefinition;
use tf_demo_parser::{Demo, DemoParser, MatchState, MessageType, MessageTypeAnalyser, ParserState};
use tf_demo_parser::{Demo, DemoParser, MessageType, ParserState};
pub struct SendPropAnalyser {
tables: Vec<ParseSendTable>,
@ -28,19 +19,20 @@ impl SendPropAnalyser {
impl MessageHandler for SendPropAnalyser {
type Output = Vec<ParseSendTable>;
fn does_handle(message_type: MessageType) -> bool {
fn does_handle(_message_type: MessageType) -> bool {
false
}
fn handle_data_tables(&mut self, tables: &[ParseSendTable], server_classes: &[ServerClass]) {
fn handle_data_tables(&mut self, tables: &[ParseSendTable], _server_classes: &[ServerClass]) {
self.tables = tables.to_vec()
}
fn into_output(self, state: &ParserState) -> Self::Output {
fn into_output(self, _state: &ParserState) -> Self::Output {
self.tables
}
}
#[test_case("data/gully.dem", "data/gully_props.json"; "gully.dem")]
fn flatten_test(input_file: &str, snapshot_file: &str) {
let file = fs::read(input_file).expect("Unable to read file");
let demo = Demo::new(file);
@ -72,13 +64,8 @@ fn flatten_test(input_file: &str, snapshot_file: &str) {
let expected_tables: HashSet<_> = expected.keys().collect();
let actual_tables: HashSet<_> = flat_props.keys().collect();
assert_eq!(expected_tables, actual_tables);
pretty_assertions::assert_eq!(expected_tables, actual_tables);
for table in expected_tables {
assert_eq!(expected[table], flat_props[table]);
pretty_assertions::assert_eq!(expected[table], flat_props[table]);
}
}
#[test]
fn sendprop_test_gully() {
flatten_test("data/gully.dem", "data/gully_props.json");
}

79
tests/tests.rs
View file

@ -1,9 +1,16 @@
use pretty_assertions::assert_eq;
use std::fs;
use test_case::test_case;
use tf_demo_parser::demo::parser::gamestateanalyser::{GameState, GameStateAnalyser};
use tf_demo_parser::{Demo, DemoParser, MatchState, MessageType, MessageTypeAnalyser};
use tf_demo_parser::{Demo, DemoParser, MatchState};
#[test_case("data/small.dem", "data/small.json"; "small.dem")]
#[test_case("data/gully.dem", "data/gully.json"; "gully.dem")]
#[test_case("data/comp.dem", "data/comp.json"; "comp.dem")]
#[test_case("data/malformed_cvar.dem", "data/malformed_cvar.json"; "malformed_cvar.dem")]
#[test_case("data/unicode-saytext.dem", "data/unicode-saytext.json"; "unicode-saytext.dem")]
#[test_case("data/nousers.dem", "data/nousers.json"; "nousers.dem")]
#[test_case("data/decal.dem", "data/decal.json"; "decal.dem")]
fn snapshot_test(input_file: &str, snapshot_file: &str) {
let file = fs::read(input_file).expect("Unable to read file");
let demo = Demo::new(file);
@ -15,26 +22,11 @@ fn snapshot_test(input_file: &str, snapshot_file: &str) {
.as_slice(),
)
.unwrap();
assert_eq!(expected, state);
}
fn test_message_types(input_file: &str, snapshot_file: &str) {
let file = fs::read(input_file).expect("Unable to read file");
let demo = Demo::new(file);
let (_, message_types) =
DemoParser::new_with_analyser(demo.get_stream(), MessageTypeAnalyser::default())
.parse()
.unwrap();
let expected: Vec<MessageType> = serde_json::from_slice(
fs::read(snapshot_file)
.expect("Unable to read file")
.as_slice(),
)
.unwrap();
assert_eq!(expected, message_types);
pretty_assertions::assert_eq!(expected, state);
}
#[test_case("data/small.dem", "data/small_game_state.json"; "small.dem")]
#[test_case("data/gully.dem", "data/gully_game_state.json"; "gully.dem")]
fn game_state_test(input_file: &str, snapshot_file: &str) {
let file = fs::read(input_file).expect("Unable to read file");
let demo = Demo::new(file);
@ -48,50 +40,5 @@ fn game_state_test(input_file: &str, snapshot_file: &str) {
.as_slice(),
)
.unwrap();
assert_eq!(expected, state);
}
#[test]
fn snapshot_test_small() {
snapshot_test("data/small.dem", "data/small.json");
}
#[test]
fn snapshot_test_gully() {
snapshot_test("data/gully.dem", "data/gully.json");
}
#[test]
fn snapshot_test_comp() {
snapshot_test("data/comp.dem", "data/comp.json");
}
#[test]
fn snapshot_test_malformed_cvar() {
snapshot_test("data/malformed_cvar.dem", "data/malformed_cvar.json");
}
#[test]
fn snapshot_test_unicode_chat() {
snapshot_test("data/unicode-saytext.dem", "data/unicode-saytext.json");
}
#[test]
fn snapshot_test_player_in_update() {
snapshot_test("data/nousers.dem", "data/nousers.json");
}
#[test]
fn snapshot_test_decal() {
snapshot_test("data/decal.dem", "data/decal.json");
}
#[test]
fn game_state_test_small() {
game_state_test("data/small.dem", "data/small_game_state.json");
}
#[test]
fn game_state_test_gully() {
game_state_test("data/gully.dem", "data/gully_game_state.json");
pretty_assertions::assert_eq!(expected, state);
}