add data packages and remove empty submodule

packages/data/radixtree/tests/serialize_test.rs

@@ -0,0 +1,180 @@
+use radixtree::{Node, NodeRef};
+
+#[test]
+fn test_node_serialization() {
+    // Create a node with some data
+    let node = Node {
+        key_segment: "test".to_string(),
+        value: b"test_value".to_vec(),
+        children: vec![
+            NodeRef {
+                key_part: "child1".to_string(),
+                node_id: 1,
+            },
+            NodeRef {
+                key_part: "child2".to_string(),
+                node_id: 2,
+            },
+        ],
+        is_leaf: true,
+    };
+
+    // Serialize the node
+    let serialized = node.serialize();
+    
+    // Deserialize the node
+    let deserialized = Node::deserialize(&serialized).expect("Failed to deserialize node");
+    
+    // Verify the deserialized node matches the original
+    assert_eq!(deserialized.key_segment, node.key_segment);
+    assert_eq!(deserialized.value, node.value);
+    assert_eq!(deserialized.is_leaf, node.is_leaf);
+    assert_eq!(deserialized.children.len(), node.children.len());
+    
+    for (i, child) in node.children.iter().enumerate() {
+        assert_eq!(deserialized.children[i].key_part, child.key_part);
+        assert_eq!(deserialized.children[i].node_id, child.node_id);
+    }
+}
+
+#[test]
+fn test_empty_node_serialization() {
+    // Create an empty node
+    let node = Node {
+        key_segment: "".to_string(),
+        value: vec![],
+        children: vec![],
+        is_leaf: false,
+    };
+
+    // Serialize the node
+    let serialized = node.serialize();
+    
+    // Deserialize the node
+    let deserialized = Node::deserialize(&serialized).expect("Failed to deserialize node");
+    
+    // Verify the deserialized node matches the original
+    assert_eq!(deserialized.key_segment, node.key_segment);
+    assert_eq!(deserialized.value, node.value);
+    assert_eq!(deserialized.is_leaf, node.is_leaf);
+    assert_eq!(deserialized.children.len(), node.children.len());
+}
+
+#[test]
+fn test_node_with_many_children() {
+    // Create a node with many children
+    let mut children = Vec::new();
+    for i in 0..100 {
+        children.push(NodeRef {
+            key_part: format!("child{}", i),
+            node_id: i as u32,
+        });
+    }
+    
+    let node = Node {
+        key_segment: "parent".to_string(),
+        value: b"parent_value".to_vec(),
+        children,
+        is_leaf: true,
+    };
+
+    // Serialize the node
+    let serialized = node.serialize();
+    
+    // Deserialize the node
+    let deserialized = Node::deserialize(&serialized).expect("Failed to deserialize node");
+    
+    // Verify the deserialized node matches the original
+    assert_eq!(deserialized.key_segment, node.key_segment);
+    assert_eq!(deserialized.value, node.value);
+    assert_eq!(deserialized.is_leaf, node.is_leaf);
+    assert_eq!(deserialized.children.len(), node.children.len());
+    
+    for (i, child) in node.children.iter().enumerate() {
+        assert_eq!(deserialized.children[i].key_part, child.key_part);
+        assert_eq!(deserialized.children[i].node_id, child.node_id);
+    }
+}
+
+#[test]
+fn test_node_with_large_value() {
+    // Create a node with a large value
+    let large_value = vec![0u8; 4096]; // 4KB value
+    
+    let node = Node {
+        key_segment: "large_value".to_string(),
+        value: large_value.clone(),
+        children: vec![],
+        is_leaf: true,
+    };
+
+    // Serialize the node
+    let serialized = node.serialize();
+    
+    // Deserialize the node
+    let deserialized = Node::deserialize(&serialized).expect("Failed to deserialize node");
+    
+    // Verify the deserialized node matches the original
+    assert_eq!(deserialized.key_segment, node.key_segment);
+    assert_eq!(deserialized.value, node.value);
+    assert_eq!(deserialized.is_leaf, node.is_leaf);
+    assert_eq!(deserialized.children.len(), node.children.len());
+}
+
+#[test]
+fn test_version_compatibility() {
+    // This test ensures that the serialization format is compatible with version 1
+    
+    // Create a node
+    let node = Node {
+        key_segment: "test".to_string(),
+        value: b"test_value".to_vec(),
+        children: vec![
+            NodeRef {
+                key_part: "child".to_string(),
+                node_id: 1,
+            },
+        ],
+        is_leaf: true,
+    };
+
+    // Serialize the node
+    let serialized = node.serialize();
+    
+    // Verify the first byte is the version byte (1)
+    assert_eq!(serialized[0], 1);
+    
+    // Deserialize the node
+    let deserialized = Node::deserialize(&serialized).expect("Failed to deserialize node");
+    
+    // Verify the deserialized node matches the original
+    assert_eq!(deserialized.key_segment, node.key_segment);
+    assert_eq!(deserialized.value, node.value);
+    assert_eq!(deserialized.is_leaf, node.is_leaf);
+    assert_eq!(deserialized.children.len(), node.children.len());
+}
+
+#[test]
+fn test_invalid_serialization() {
+    // Test with empty data
+    let result = Node::deserialize(&[]);
+    assert!(result.is_err());
+    
+    // Test with invalid version
+    let result = Node::deserialize(&[2, 0, 0, 0, 0]);
+    assert!(result.is_err());
+    
+    // Test with truncated data
+    let node = Node {
+        key_segment: "test".to_string(),
+        value: b"test_value".to_vec(),
+        children: vec![],
+        is_leaf: true,
+    };
+    
+    let serialized = node.serialize();
+    let truncated = &serialized[0..serialized.len() / 2];
+    
+    let result = Node::deserialize(truncated);
+    assert!(result.is_err());
+}