reencode and reparse tests

src/demo/packet/message.rs

@@ -1,6 +1,5 @@
 use bitbuffer::{
-    bit_size_of, BitRead, BitWrite, BitWriteSized, BitWriteStream, Endianness, LazyBitRead,
-    LittleEndian,
+    bit_size_of, BitRead, BitWrite, BitWriteStream, Endianness, LazyBitRead, LittleEndian,
 };
 
 use crate::demo::message::{Message, MessageType};
@@ -20,7 +19,7 @@ pub struct MessagePacketMeta {
 pub struct MessagePacket<'a> {
     pub tick: u32,
     pub messages: Vec<Message<'a>>,
-    pub meta: MessagePacketMeta,
+    pub meta: LazyBitRead<'a, MessagePacketMeta, LittleEndian>,
 }
 
 #[derive(Clone, Debug, PartialEq)]
@@ -141,7 +140,7 @@ impl<'a> Parse<'a> for MessagePacket<'a> {
 impl Encode for MessagePacket<'_> {
     fn encode(&self, stream: &mut BitWriteStream<LittleEndian>, state: &ParserState) -> Result<()> {
         self.tick.write(stream)?;
-        self.meta.write(stream)?;
+        self.meta.read()?.write(stream)?;
         stream.reserve_byte_length(32, |stream| {
             for message in self.messages.iter() {
                 message.get_message_type().write(stream)?;

tests/reencode.rs

@@ -0,0 +1,127 @@
+use std::fs;
+use test_case::test_case;
+
+use bitbuffer::{BitRead, BitReadBuffer, BitReadStream, BitWriteStream, LittleEndian};
+use std::collections::HashMap;
+use tf_demo_parser::demo::header::Header;
+use tf_demo_parser::demo::message::Message;
+use tf_demo_parser::demo::packet::datatable::SendTableName;
+use tf_demo_parser::demo::packet::Packet;
+use tf_demo_parser::demo::parser::{DemoHandler, Encode, NullHandler, RawPacketStream};
+use tf_demo_parser::demo::sendprop::{RawSendPropDefinition, SendPropIdentifier, SendPropName};
+use tf_demo_parser::{Demo, Parse};
+
+#[test_case("test_data/small.dem"; "small.dem")]
+#[test_case("test_data/gully.dem"; "gully.dem")]
+#[test_case("test_data/comp.dem"; "comp.dem")]
+#[test_case("test_data/malformed_cvar.dem"; "malformed_cvar.dem")]
+#[test_case("test_data/unicode-saytext.dem"; "unicode-saytext.dem")]
+#[test_case("test_data/nousers.dem"; "nousers.dem")]
+#[test_case("test_data/decal.dem"; "decal.dem")]
+#[test_case("test_data/saytext2.dem"; "saytext2.dem")]
+#[test_case("test_data/emptysaytext.dem"; "emptysaytext.dem")]
+fn re_encode_test(input_file: &str) {
+    let file = fs::read(input_file).expect("Unable to read file");
+    let demo = Demo::new(&file);
+    let mut out_buffer = Vec::with_capacity(file.len());
+
+    let mut stream = demo.get_stream();
+    let _header = Header::read(&mut stream).unwrap();
+
+    let mut packets = RawPacketStream::new(stream);
+    let mut handler = DemoHandler::parse_all_with_analyser(NullHandler);
+
+    let mut prop_names: HashMap<
+        SendPropIdentifier,
+        (SendTableName, SendPropName, RawSendPropDefinition),
+    > = HashMap::new();
+
+    while let Some(packet) = packets.next(&handler.state_handler).unwrap() {
+        if let Packet::DataTables(data_table) = &packet {
+            for table in data_table.tables.iter() {
+                for prop_def in &table.props {
+                    prop_names.insert(
+                        prop_def.identifier(),
+                        (table.name.clone(), prop_def.name.clone(), prop_def.clone()),
+                    );
+                }
+            }
+        }
+
+        out_buffer.clear();
+        {
+            let mut out_stream = BitWriteStream::new(&mut out_buffer, LittleEndian);
+            packet
+                .encode(&mut out_stream, &handler.state_handler)
+                .unwrap();
+        }
+        let mut re_read = BitReadStream::new(BitReadBuffer::new(&out_buffer, LittleEndian));
+        let re_decoded = Packet::parse(&mut re_read, &handler.state_handler)
+            .expect(&format!("while parsing {:?}", packet.packet_type()));
+        assert_eq!(packet.packet_type(), re_decoded.packet_type());
+        match (&packet, &re_decoded) {
+            (
+                Packet::Message(msg) | Packet::Sigon(msg),
+                Packet::Message(re_msg) | Packet::Sigon(re_msg),
+            ) => {
+                assert_eq!(msg.tick, re_msg.tick);
+                assert_eq!(msg.meta, re_msg.meta);
+                assert_eq!(
+                    msg.messages
+                        .iter()
+                        .map(|msg| msg.get_message_type())
+                        .collect::<Vec<_>>(),
+                    re_msg
+                        .messages
+                        .iter()
+                        .map(|msg| msg.get_message_type())
+                        .collect::<Vec<_>>()
+                );
+                assert_eq!(msg.messages.len(), re_msg.messages.len());
+                for (msg, re_msg) in msg.messages.iter().zip(re_msg.messages.iter()) {
+                    assert_eq!(msg.get_message_type(), re_msg.get_message_type());
+                    match (msg, re_msg) {
+                        (Message::PacketEntities(msg), Message::PacketEntities(re_msg)) => {
+                            assert_eq!(msg.updated_base_line, re_msg.updated_base_line);
+                            assert_eq!(msg.base_line, re_msg.base_line);
+                            assert_eq!(msg.delta, re_msg.delta);
+                            assert_eq!(msg.max_entries, re_msg.max_entries);
+                            assert_eq!(msg.removed_entities, re_msg.removed_entities);
+                            assert_eq!(msg.entities.len(), re_msg.entities.len());
+                            for (ent, re_ent) in msg.entities.iter().zip(re_msg.entities.iter()) {
+                                let props = ent
+                                    .props
+                                    .iter()
+                                    .map(|prop| {
+                                        (prop_names.get(&prop.index).unwrap(), prop.value.clone())
+                                    })
+                                    .collect::<Vec<_>>();
+                                let re_props = re_ent
+                                    .props
+                                    .iter()
+                                    .map(|prop| {
+                                        (prop_names.get(&prop.index).unwrap(), prop.value.clone())
+                                    })
+                                    .collect::<Vec<_>>();
+                                pretty_assertions::assert_eq!(props, re_props);
+                            }
+                        }
+                        (msg, re_msg) => assert_eq!(msg, re_msg),
+                    }
+                }
+            }
+            (Packet::StringTables(packet), Packet::StringTables(re_packet)) => {
+                assert_eq!(packet.tick, re_packet.tick);
+                assert_eq!(packet.tables.len(), re_packet.tables.len());
+                for (table, re_table) in packet.tables.iter().zip(re_packet.tables.iter()) {
+                    assert_eq!(table, re_table);
+                }
+            }
+            (packet, re_decoded) => {
+                assert_eq!(packet, re_decoded);
+            }
+        }
+
+        handler.handle_packet(packet).unwrap();
+    }
+}