1 files changed, 305 insertions, 0 deletions
diff --git a/tests/count_prefix.rs b/tests/count_prefix.rs
new file mode 100644
index 0000000..ab25e30
--- /dev/null
+++ b/tests/count_prefix.rs
@@ -0,0 +1,305 @@
+use zr_protocol::{
+    codec::{decode::Decode, encode::Encode},
+    types::prefix::count::CountPrefix,
+};
+
+fn encode_to_bytes<T: Encode>(value: T) -> Vec<u8> {
+    let mut buf = Vec::new();
+    value.encode(&mut buf).unwrap();
+    buf
+}
+
+// ────────────────────── Vecteur vide ────────────
+
+#[test]
+fn empty_vec_u8_with_u8_count() {
+    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(vec![]);
+    let buf = encode_to_bytes(cp);
+    assert_eq!(buf, vec![0x00]);
+}
+
+#[test]
+fn empty_vec_u32_with_u16_count() {
+    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(vec![]);
+    let buf = encode_to_bytes(cp);
+    assert_eq!(buf, vec![0x00, 0x00]);
+}
+
+#[test]
+fn empty_vec_u8_with_u32_count() {
+    let cp = CountPrefix::<u8, u32, Vec<u8>>::new(vec![]);
+    let buf = encode_to_bytes(cp);
+    assert_eq!(buf, vec![0x00, 0x00, 0x00, 0x00]);
+}
+
+// ────────────────────── Un seul élément ─────────
+
+#[test]
+fn single_u8_u8_count() {
+    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(vec![42]);
+    let buf = encode_to_bytes(cp);
+    assert_eq!(buf, vec![0x01, 0x2A]);
+}
+
+#[test]
+fn single_u32_u8_count() {
+    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![0x01020304]);
+    let buf = encode_to_bytes(cp);
+    assert_eq!(buf, vec![0x01, 0x01, 0x02, 0x03, 0x04]);
+}
+
+// ────────────────────── Plusieurs éléments ──────
+
+#[test]
+fn multiple_u8_u8_count() {
+    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(vec![1, 2, 3]);
+    let buf = encode_to_bytes(cp);
+    assert_eq!(buf, vec![0x03, 0x01, 0x02, 0x03]);
+}
+
+#[test]
+fn multiple_u16_u8_count() {
+    let cp = CountPrefix::<u16, u8, Vec<u16>>::new(vec![256, 512, 1024]);
+    let buf = encode_to_bytes(cp);
+    assert_eq!(
+        buf,
+        vec![
+            0x03, // count = 3
+            0x01, 0x00, // 256
+            0x02, 0x00, // 512
+            0x04, 0x00, // 1024
+        ]
+    );
+}
+
+#[test]
+fn multiple_u32_u16_count() {
+    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(vec![100, 200, 300]);
+    let buf = encode_to_bytes(cp);
+    assert_eq!(
+        buf,
+        vec![
+            0x00, 0x03, // count = 3 (u16)
+            0x00, 0x00, 0x00, 0x64, // 100
+            0x00, 0x00, 0x00, 0xC8, // 200
+            0x00, 0x00, 0x01, 0x2C, // 300
+        ]
+    );
+}
+
+// ────────────────────── Valeurs extrêmes ────────
+
+#[test]
+fn u8_count_max_255() {
+    let data: Vec<u8> = (0..255).collect();
+    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(data.clone());
+    let buf = encode_to_bytes(cp);
+    assert_eq!(buf[0], 0xFF);
+    assert_eq!(buf.len(), 1 + 255);
+}
+
+#[test]
+fn large_u32_items_u16_count() {
+    let data: Vec<u32> = vec![u32::MAX, 0, u32::MIN + 1];
+    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(data);
+    let buf = encode_to_bytes(cp);
+    assert_eq!(buf.len(), 2 + 3 * 4);
+    assert_eq!(&buf[0..2], &[0x00, 0x03]); // count = 3
+}
+
+// ────────────────────── Roundtrip ───────────────
+
+#[test]
+fn roundtrip_u8_u8() {
+    let data = vec![10, 20, 30, 40, 50];
+    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(data.clone());
+    let buf = encode_to_bytes(cp);
+
+    let mut reader = &buf[..];
+    let decoded = CountPrefix::<u8, u8, Vec<u8>>::decode(&mut reader).unwrap();
+    assert_eq!(*decoded.as_ref(), data);
+}
+
+#[test]
+fn roundtrip_u32_u16() {
+    let data = vec![1, 2, 3, 4, 5];
+    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(data.clone());
+    let buf = encode_to_bytes(cp);
+
+    let mut reader = &buf[..];
+    let decoded = CountPrefix::<u32, u16, Vec<u32>>::decode(&mut reader).unwrap();
+    assert_eq!(*decoded.as_ref(), data);
+}
+
+#[test]
+fn roundtrip_empty() {
+    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![]);
+    let buf = encode_to_bytes(cp);
+
+    let mut reader = &buf[..];
+    let decoded = CountPrefix::<u32, u8, Vec<u32>>::decode(&mut reader).unwrap();
+    assert!(decoded.as_ref().is_empty());
+}
+
+#[test]
+fn roundtrip_single_element() {
+    let cp = CountPrefix::<u64, u8, Vec<u64>>::new(vec![u64::MAX]);
+    let buf = encode_to_bytes(cp);
+
+    let mut reader = &buf[..];
+    let decoded = CountPrefix::<u64, u8, Vec<u64>>::decode(&mut reader).unwrap();
+    assert_eq!(*decoded.as_ref(), vec![u64::MAX]);
+}
+
+#[test]
+fn roundtrip_negative_i32() {
+    let data = vec![-1, -100, 0, 100, 1];
+    let cp = CountPrefix::<i32, u16, Vec<i32>>::new(data.clone());
+    let buf = encode_to_bytes(cp);
+
+    let mut reader = &buf[..];
+    let decoded = CountPrefix::<i32, u16, Vec<i32>>::decode(&mut reader).unwrap();
+    assert_eq!(*decoded.as_ref(), data);
+}
+
+#[test]
+fn roundtrip_f64() {
+    let data = vec![0.0, 3.14, -2.71, f64::INFINITY, f64::NEG_INFINITY];
+    let cp = CountPrefix::<f64, u8, Vec<f64>>::new(data.clone());
+    let buf = encode_to_bytes(cp);
+
+    let mut reader = &buf[..];
+    let decoded = CountPrefix::<f64, u8, Vec<f64>>::decode(&mut reader).unwrap();
+    let decoded_data = decoded.as_ref().clone();
+    assert_eq!(decoded_data.len(), data.len());
+    for (a, b) in decoded_data.iter().zip(data.iter()) {
+        if a.is_nan() {
+            assert!(b.is_nan());
+        } else {
+            assert_eq!(a, b);
+        }
+    }
+}
+
+#[test]
+fn roundtrip_bool() {
+    let data = vec![true, false, true, true, false];
+    let cp = CountPrefix::<bool, u8, Vec<bool>>::new(data.clone());
+    let buf = encode_to_bytes(cp);
+
+    let mut reader = &buf[..];
+    let decoded = CountPrefix::<bool, u8, Vec<bool>>::decode(&mut reader).unwrap();
+    assert_eq!(*decoded.as_ref(), data);
+}
+
+#[test]
+fn roundtrip_large_dataset() {
+    let data: Vec<u32> = (0..1000).collect();
+    let cp = CountPrefix::<u32, u16, Vec<u32>>::new(data.clone());
+    let buf = encode_to_bytes(cp);
+
+    let mut reader = &buf[..];
+    let decoded = CountPrefix::<u32, u16, Vec<u32>>::decode(&mut reader).unwrap();
+    assert_eq!(*decoded.as_ref(), data);
+}
+
+// ────────────────────── Imbrication ─────────────
+
+#[test]
+fn nested_count_prefix() {
+    let inner1 = CountPrefix::<u8, u8, Vec<u8>>::new(vec![1, 2, 3]);
+    let inner2 = CountPrefix::<u8, u8, Vec<u8>>::new(vec![4, 5]);
+    let outer =
+        CountPrefix::<CountPrefix<u8, u8, Vec<u8>>, u8, Vec<CountPrefix<u8, u8, Vec<u8>>>>::new(
+            vec![inner1, inner2],
+        );
+
+    let buf = encode_to_bytes(outer);
+
+    let mut reader = &buf[..];
+    let decoded_outer =
+        CountPrefix::<CountPrefix<u8, u8, Vec<u8>>, u8, Vec<CountPrefix<u8, u8, Vec<u8>>>>::decode(
+            &mut reader,
+        )
+        .unwrap();
+
+    let outer_data: Vec<_> = decoded_outer
+        .as_ref()
+        .iter()
+        .map(|c| c.as_ref().clone())
+        .collect();
+    assert_eq!(outer_data.len(), 2);
+    assert_eq!(outer_data[0], vec![1, 2, 3]);
+    assert_eq!(outer_data[1], vec![4, 5]);
+}
+
+// ────────────────────── Erreurs de décodage ─────
+
+#[test]
+fn decode_empty_buffer_fails() {
+    let result = CountPrefix::<u8, u8, Vec<u8>>::decode(&mut &[][..]);
+    assert!(result.is_err());
+}
+
+#[test]
+fn decode_truncated_data_fails() {
+    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![1, 2, 3]);
+    let buf = encode_to_bytes(cp);
+    let truncated = &buf[..buf.len() - 1];
+    let result = CountPrefix::<u32, u8, Vec<u32>>::decode(&mut &truncated[..]);
+    assert!(result.is_err());
+}
+
+#[test]
+fn decode_wrong_count_fails() {
+    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![1, 2]);
+    let mut buf = encode_to_bytes(cp);
+    buf[0] = 0x05;
+    let result = CountPrefix::<u32, u8, Vec<u32>>::decode(&mut &buf[..]);
+    assert!(result.is_err());
+}
+
+// ────────────────────── AsRef / AsMut ───────────
+
+#[test]
+fn as_ref_returns_inner_data() {
+    let data = vec![10u32, 20, 30];
+    let cp = CountPrefix::<u32, u8, Vec<u32>>::new(data.clone());
+    assert_eq!(*cp.as_ref(), data);
+}
+
+#[test]
+fn as_mut_allows_mutation() {
+    let mut cp = CountPrefix::<u32, u8, Vec<u32>>::new(vec![1, 2, 3]);
+    cp.as_mut().push(4);
+    assert_eq!(*cp.as_ref(), vec![1, 2, 3, 4]);
+}
+
+// ────────────────────── Counts byte exactitude ──
+
+#[test]
+fn u8_count_header() {
+    let cp = CountPrefix::<u8, u8, Vec<u8>>::new(vec![1; 10]);
+    let buf = encode_to_bytes(cp);
+    assert_eq!(buf[0], 10);
+    assert_eq!(buf.len(), 1 + 10);
+}
+
+#[test]
+fn u16_count_header() {
+    let cp = CountPrefix::<u8, u16, Vec<u8>>::new(vec![1; 300]);
+    let buf = encode_to_bytes(cp);
+    assert_eq!(buf[0], 0x01);
+    assert_eq!(buf[1], 0x2C);
+    assert_eq!(buf.len(), 2 + 300);
+}
+
+#[test]
+fn u32_count_header() {
+    let data: Vec<u8> = vec![0xAA; 300];
+    let len = data.len();
+    let cp = CountPrefix::<u8, u32, Vec<u8>>::new(data);
+    let buf = encode_to_bytes(cp);
+    assert_eq!(buf.len(), 4 + len);
+    assert_eq!(&buf[0..4], &[0x00, 0x00, 0x01, 0x2C]);
+}