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

sendprop decoding

Browse source
This commit is contained in:
Robin Appelman 2019-08-10 22:30:12 +02:00
commit ff18680a02
25 changed files with 389 additions and 135 deletions
Download patch file Download diff file Expand all files Collapse all files

42
tests/sendprops.rs
View file

@ -2,16 +2,16 @@
#![allow(unused_imports)]
#![allow(unused_variables)]
use std::fs;
use pretty_assertions::assert_eq;
use std::fs;
use tf_demo_parser::{Demo, DemoParser, MatchState, MessageTypeAnalyser, MessageType, ParserState};
use std::collections::{HashMap, HashSet};
use tf_demo_parser::demo::message::Message;
use tf_demo_parser::demo::packet::datatable::{ParseSendTable, SendTableName};
use tf_demo_parser::demo::packet::stringtable::StringTableEntry;
use tf_demo_parser::demo::message::Message;
use tf_demo_parser::demo::sendprop::SendPropDefinition;
use std::collections::{HashMap, HashSet};
use tf_demo_parser::demo::parser::MessageHandler;
use tf_demo_parser::demo::sendprop::SendPropDefinition;
use tf_demo_parser::{Demo, DemoParser, MatchState, MessageType, MessageTypeAnalyser, ParserState};
pub struct SendPropAnalyser;
@ -27,31 +27,43 @@ impl MessageHandler for SendPropAnalyser {
fn handle_string_entry(&mut self, table: &String, _index: usize, entry: &StringTableEntry) {}
fn get_output(self, state: ParserState) -> Self::Output {
state.send_tables.into_iter().map(|(_k, v)| ParseSendTable {
name: v.name,
props: v.props,
needs_decoder: v.needs_decoder
}).collect()
state
.send_tables
.into_iter()
.map(|(_k, v)| ParseSendTable {
name: v.name,
props: v.props,
needs_decoder: v.needs_decoder,
})
.collect()
}
}
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);
let (_, send_tables) = DemoParser::parse_with_analyser(demo.get_stream(), SendPropAnalyser).unwrap();
let flat_props: HashMap<SendTableName, Vec<String>> = send_tables.iter()
let (_, send_tables) =
DemoParser::parse_with_analyser(demo.get_stream(), SendPropAnalyser).unwrap();
let flat_props: HashMap<SendTableName, Vec<String>> = send_tables
.iter()
.map(|table| {
(
table.name.clone(),
table.flatten_props(&send_tables)
table
.flatten_props(&send_tables)
.into_iter()
.map(|prop| format!("{}.{}", prop.owner_table, prop.name))
.collect()
.collect(),
)
})
.collect();
let expected: HashMap<SendTableName, Vec<String>> = serde_json::from_slice(fs::read(snapshot_file).expect("Unable to read file").as_slice()).unwrap();
let expected: HashMap<SendTableName, Vec<String>> = serde_json::from_slice(
fs::read(snapshot_file)
.expect("Unable to read file")
.as_slice(),
)
.unwrap();
let expected_tables: HashSet<_> = expected.keys().collect();
let actual_tables: HashSet<_> = flat_props.keys().collect();

27
tests/tests.rs
View file

@ -1,30 +1,42 @@
use std::fs;
use pretty_assertions::assert_eq;
use std::fs;
use tf_demo_parser::{Demo, DemoParser, MatchState, MessageTypeAnalyser, MessageType};
use tf_demo_parser::{Demo, DemoParser, MatchState, MessageType, MessageTypeAnalyser};
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);
let (_, state) = DemoParser::parse_demo(demo.get_stream()).unwrap();
let expected: MatchState = serde_json::from_slice(fs::read(snapshot_file).expect("Unable to read file").as_slice()).unwrap();
let expected: MatchState = serde_json::from_slice(
fs::read(snapshot_file)
.expect("Unable to read file")
.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::parse_with_analyser(demo.get_stream(), MessageTypeAnalyser::new()).unwrap();
let (_, message_types) =
DemoParser::parse_with_analyser(demo.get_stream(), MessageTypeAnalyser::new()).unwrap();
let expected: Vec<MessageType> = serde_json::from_slice(fs::read(snapshot_file).expect("Unable to read file").as_slice()).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);
}
fn dump_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::parse_with_analyser(demo.get_stream(), MessageTypeAnalyser::new()).unwrap();
let (_, message_types) =
DemoParser::parse_with_analyser(demo.get_stream(), MessageTypeAnalyser::new()).unwrap();
fs::write(snapshot_file, serde_json::to_vec(&message_types).unwrap()).unwrap();
}
@ -44,7 +56,6 @@ 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");
@ -53,4 +64,4 @@ fn snapshot_test_malformed_cvar() {
#[test]
fn message_type_test_comp() {
dump_message_types("data/comp.dem", "data/comp_message_types.json");
}
}