adjust tests

src/demo/packet/datatable.rs

@@ -187,6 +187,7 @@ fn test_parse_send_table_roundtrip() {
                     bit_count: Some(10),
                     element_count: None,
                     array_property: None,
+                    original_bit_count: Some(10),
                 },
                 RawSendPropDefinition {
                     prop_type: SendPropType::Array,
@@ -211,7 +212,9 @@ fn test_parse_send_table_roundtrip() {
                         bit_count: Some(32),
                         element_count: None,
                         array_property: None,
+                        original_bit_count: Some(32),
                     })),
+                    original_bit_count: None,
                 },
                 RawSendPropDefinition {
                     prop_type: SendPropType::DataTable,
@@ -224,6 +227,7 @@ fn test_parse_send_table_roundtrip() {
                     bit_count: None,
                     element_count: None,
                     array_property: None,
+                    original_bit_count: None,
                 },
             ],
             needs_decoder: true,
@@ -396,6 +400,7 @@ fn test_data_table_packet_roundtrip() {
                 bit_count: Some(10),
                 element_count: None,
                 array_property: None,
+                original_bit_count: Some(10),
             },
             RawSendPropDefinition {
                 prop_type: SendPropType::Array,
@@ -420,7 +425,9 @@ fn test_data_table_packet_roundtrip() {
                     bit_count: Some(32),
                     element_count: None,
                     array_property: None,
+                    original_bit_count: Some(32),
                 })),
+                original_bit_count: None,
             },
             RawSendPropDefinition {
                 prop_type: SendPropType::DataTable,
@@ -433,6 +440,7 @@ fn test_data_table_packet_roundtrip() {
                 bit_count: None,
                 element_count: None,
                 array_property: None,
+                original_bit_count: None,
             },
         ],
         needs_decoder: true,
@@ -450,6 +458,7 @@ fn test_data_table_packet_roundtrip() {
             bit_count: Some(10),
             element_count: None,
             array_property: None,
+            original_bit_count: Some(10),
         }],
         needs_decoder: true,
     };

src/demo/sendprop.rs

@@ -70,7 +70,7 @@ pub struct RawSendPropDefinition {
     pub bit_count: Option<u32>,
     pub element_count: Option<u16>,
     pub array_property: Option<Box<RawSendPropDefinition>>,
-    original_bit_count: Option<u32>,
+    pub original_bit_count: Option<u32>,
 }
 
 impl PartialEq for RawSendPropDefinition {

tests/message_reencode.rs

@@ -2,30 +2,36 @@ use bitbuffer::{BitReadBuffer, BitReadStream, BitWriteStream, LittleEndian};
 use std::fs;
 use test_case::test_case;
 use tf_demo_parser::demo::message::Message;
-use tf_demo_parser::demo::parser::Encode;
+use tf_demo_parser::demo::packet::Packet;
-use tf_demo_parser::{MessageType, ParserState};
+use tf_demo_parser::demo::parser::{DemoHandler, Encode, NullHandler};
+use tf_demo_parser::{MessageType, Parse};
 
 #[test_case("test_data/messages/game_event_list.bin", MessageType::GameEventList; "game_event_list")]
+// #[test_case("test_data/messages/packet_entities.bin", MessageType::PacketEntities; "packet_entities")]
 fn message_reencode(input_file: &str, ty: MessageType) {
     let data = fs::read(input_file).unwrap();
 
-    let state = ParserState::new(|_| false, true);
+    let mut handler = DemoHandler::parse_all_with_analyser(NullHandler);
+    setup(&mut handler, "test_data/messages/setup_data_tables.bin");
+    setup(&mut handler, "test_data/messages/setup_string_tables.bin");
+
+    let state = &handler.state_handler;
 
     let mut stream = BitReadStream::new(BitReadBuffer::new(&data, LittleEndian));
-    let parsed = Message::from_type(ty, &mut stream, &state).unwrap();
+    let parsed = Message::from_type(ty, &mut stream, state).unwrap();
 
     let mut out = Vec::with_capacity(data.len());
     let written_bits = {
         let mut write = BitWriteStream::new(&mut out, LittleEndian);
-        parsed.encode(&mut write, &state).unwrap();
+        parsed.encode(&mut write, state).unwrap();
         write.bit_len()
     };
 
     let mut re_stream = BitReadStream::new(BitReadBuffer::new(&out, LittleEndian));
-    let re_parsed = Message::from_type(ty, &mut re_stream, &state).unwrap();
+    let re_parsed = Message::from_type(ty, &mut re_stream, state).unwrap();
 
-    assert_eq!(written_bits, stream.pos());
     assert_eq!(parsed, re_parsed);
+    assert_eq!(written_bits, stream.pos());
 
     assert_eq!(data.len(), out.len());
     if data.len() > 16 {
@@ -35,3 +41,10 @@ fn message_reencode(input_file: &str, ty: MessageType) {
         pretty_assertions::assert_eq!(data, out);
     }
 }
+
+fn setup(handler: &mut DemoHandler<NullHandler>, input: &str) {
+    let data = fs::read(input).unwrap();
+    let mut stream = BitReadStream::new(BitReadBuffer::new_owned(data, LittleEndian));
+    let packet = Packet::parse(&mut stream, &handler.state_handler).unwrap();
+    handler.handle_packet(packet).unwrap();
+}

tests/tests.rs

@@ -24,7 +24,12 @@ fn snapshot_test(input_file: &str, snapshot_file: &str) {
             .as_slice(),
     )
     .unwrap();
+    pretty_assertions::assert_eq!(expected.start_tick, state.start_tick);
     pretty_assertions::assert_eq!(expected.chat, state.chat);
+    pretty_assertions::assert_eq!(expected.deaths, state.deaths);
+    pretty_assertions::assert_eq!(expected.interval_per_tick, state.interval_per_tick);
+    pretty_assertions::assert_eq!(expected.rounds, state.rounds);
+    pretty_assertions::assert_eq!(expected.users, state.users);
     pretty_assertions::assert_eq!(expected, state);
 }