Generate native packet catalog (#46)

crates/libremetaverse/src/lib.rs

@@ -4,6 +4,8 @@ extern crate self as libremetaverse;
 
 mod generated;
 mod j2k;
+#[rustfmt::skip]
+pub mod packet_catalog;
 mod targa;
 
 #[cfg(test)]

crates/libremetaverse/tests/packet_catalog.rs

@@ -0,0 +1,143 @@
+use libremetaverse::PacketFrequency;
+use libremetaverse::packet_catalog::{
+    BlockRepetition, FieldKind, PACKETS, descriptor_by_name, descriptor_by_type,
+};
+use libremetaverse::packets::{
+    Packet, PacketAckPacket, PacketType, TestMessagePacket, UseCircuitCodePacket,
+};
+use std::collections::BTreeSet;
+
+#[test]
+fn generated_catalog_matches_the_complete_pinned_protocol() {
+    assert_eq!(PACKETS.len(), 483);
+    assert_eq!(
+        PACKETS
+            .iter()
+            .filter(|packet| packet.frequency == PacketFrequency::Low)
+            .count(),
+        434
+    );
+    assert_eq!(
+        PACKETS
+            .iter()
+            .filter(|packet| packet.frequency == PacketFrequency::Medium)
+            .count(),
+        17
+    );
+    assert_eq!(
+        PACKETS
+            .iter()
+            .filter(|packet| packet.frequency == PacketFrequency::High)
+            .count(),
+        32
+    );
+
+    let names = PACKETS
+        .iter()
+        .map(|packet| packet.name)
+        .collect::<BTreeSet<_>>();
+    let ids = PACKETS
+        .iter()
+        .map(|packet| (packet.frequency as u8, packet.id))
+        .collect::<BTreeSet<_>>();
+    assert_eq!(names.len(), PACKETS.len());
+    assert_eq!(ids.len(), PACKETS.len());
+
+    for descriptor in PACKETS {
+        assert_eq!(descriptor_by_name(descriptor.name), Some(descriptor));
+        assert_eq!(descriptor_by_type(descriptor.packet_type), Some(descriptor));
+        assert_eq!(
+            Packet::get_type(descriptor.id, descriptor.frequency).unwrap(),
+            descriptor.packet_type
+        );
+    }
+}
+
+#[test]
+fn generated_ids_repetition_and_field_widths_match_golden_entries() {
+    assert_eq!(PacketType::TestMessage as i32, 0x1_0001);
+    assert_eq!(PacketType::PacketAck as i32, 0x1_fffb);
+    assert_eq!(PacketType::ObjectUpdate as i32, 0x3_000c);
+
+    let test = descriptor_by_name("TestMessage").unwrap();
+    assert_eq!(test.id, 1);
+    assert_eq!(test.blocks.len(), 2);
+    assert_eq!(test.blocks[0].repetition, BlockRepetition::Single);
+    assert_eq!(test.blocks[1].repetition, BlockRepetition::Multiple(4));
+    assert_eq!(test.blocks[1].fields.len(), 3);
+    assert!(
+        test.blocks[1]
+            .fields
+            .iter()
+            .all(|field| field.kind == FieldKind::U32 && field.fixed_width == 4)
+    );
+
+    let ack = descriptor_by_name("PacketAck").unwrap();
+    assert_eq!(ack.id, 0xfffb);
+    assert_eq!(ack.frequency, PacketFrequency::Low);
+    assert_eq!(ack.blocks[0].repetition, BlockRepetition::Variable);
+    assert_eq!(ack.blocks[0].fields[0].kind, FieldKind::U32);
+
+    let object_update = descriptor_by_name("ObjectUpdate").unwrap();
+    assert!(object_update.zerocoded);
+    assert!(object_update.trusted);
+    assert!(
+        object_update
+            .blocks
+            .iter()
+            .flat_map(|block| block.fields)
+            .any(|field| field.kind == FieldKind::Fixed)
+    );
+}
+
+#[test]
+fn generated_constructors_initialize_blocks_headers_and_sizing_metadata() {
+    let test = TestMessagePacket::new_with_constructor().unwrap();
+    assert_eq!(test.base.type_, PacketType::TestMessage);
+    assert_eq!(test.base.header.frequency, PacketFrequency::Low);
+    assert_eq!(test.base.header.id, 1);
+    assert!(test.base.header.reliable);
+    assert!(test.base.header.zerocoded);
+    assert_eq!(test.neighbor_block.len(), 4);
+    assert_eq!(test.length(), 62);
+    assert!(test.uses_buffer_pooling());
+
+    let ack = PacketAckPacket::new_with_constructor().unwrap();
+    assert!(ack.packets.is_empty());
+    // The source generator includes one variable-block metadata byte in the
+    // base and one in the block contribution; preserve that exact Length API.
+    assert_eq!(ack.length(), 12);
+    assert!(!ack.uses_buffer_pooling());
+
+    let circuit = UseCircuitCodePacket::new_with_constructor().unwrap();
+    assert_eq!(circuit.circuit_code.code, 0);
+    assert_eq!(circuit.circuit_code.id, libremetaverse_types::UUID::zero());
+    assert_eq!(
+        circuit.circuit_code.session_id,
+        libremetaverse_types::UUID::zero()
+    );
+    assert_eq!(circuit.length(), 46);
+    assert!(circuit.uses_buffer_pooling());
+}
+
+#[test]
+fn generated_dispatch_handles_known_and_unknown_packets_without_fallbacks() {
+    let packet = Packet::build_packet_with_packet_type(PacketType::UseCircuitCode).unwrap();
+    assert_eq!(packet.type_, PacketType::UseCircuitCode);
+    assert_eq!(packet.header.frequency, PacketFrequency::Low);
+    assert_eq!(packet.header.id, 3);
+    assert!(packet.header.reliable);
+    assert!(!packet.header.zerocoded);
+    assert!(!packet.has_variable_blocks);
+
+    assert_eq!(
+        Packet::get_type(u16::MAX, PacketFrequency::High).unwrap(),
+        PacketType::Default
+    );
+    assert!(matches!(
+        Packet::build_packet_with_packet_type(PacketType::Default),
+        Err(libremetaverse::Error::InvalidOperation)
+    ));
+    assert_eq!(descriptor_by_name("NotAPacket"), None);
+    assert_eq!(descriptor_by_type(PacketType::Default), None);
+}