babbel_yaml 0.1.1

Fast, modular YAML 1.2 parser and emitter with anchors, aliases, and tags
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

// =====================================================================================
//  File: bencode_tests.rs
//  Location: library/src/internal_tests/
// -------------------------------------------------------------------------------------
//  Purpose:
//      Internal tests for Bencode serialization in the babbel_yaml crate.
//      These tests validate correct conversion of YAML node structures to the
//      Bencode format, ensuring compliance with Bencode encoding rules for
//      strings, integers, lists, and dictionaries.
//
//  Context:
//      - Part of the babbel_yaml project, a Rust YAML parser/serializer.
//      - Bencode is used in applications such as BitTorrent for data serialization.
//      - Tests ensure interoperability and correctness of Bencode output.
//
// -------------------------------------------------------------------------------------
//  Test Coverage:
//      - String and integer encoding
//      - List and dictionary encoding
//      - Key sorting in dictionaries
//      - Edge cases for empty and nested structures
//      - Error handling for invalid input
// =====================================================================================

#[cfg(test)]
mod tests {
    use crate::nodes::node::{BlockStyle, QuoteType};
    use crate::{BufferDestination, Node, Numeric};

    #[test]
    fn test_bencode_string_and_integer() {
        let mut buf = BufferDestination::new();
        let n = Node::Str("hello".to_string(), QuoteType::Unquoted, BlockStyle::None);
        crate::stringify::bencode::stringify(&n, &mut buf).expect("bencode stringify failed");
        assert_eq!(buf.to_string(), "5:hello");

        buf.clear();
        let ni = Node::Number(Numeric::Integer(42));
        crate::stringify::bencode::stringify(&ni, &mut buf).expect("bencode stringify failed");
        assert_eq!(buf.to_string(), "i42e");
    }

    #[test]
    fn test_bencode_list_and_map_sorting() {
        let mut buf = BufferDestination::new();
        let list = Node::Array(vec![Node::from(1), Node::from("two")]);
        crate::stringify::bencode::stringify(&list, &mut buf).expect("bencode stringify failed");
        assert_eq!(buf.to_string(), "li1e3:twoe");

        buf.clear();
        let mapping = Node::Mapping(vec![
            (Node::from("b"), Node::from("beta")),
            (Node::from("a"), Node::from("alpha")),
        ]);
        crate::stringify::bencode::stringify(&mapping, &mut buf).expect("bencode stringify failed");

        assert_eq!(buf.to_string(), "d1: a5:alpha1: b4:betae".replace(" ", ""));
    }

    #[test]
    fn test_bencode_float_and_boolean() {
        let mut buf = BufferDestination::new();
        let nf = Node::Number(Numeric::Float(3.14));
        crate::stringify::bencode::stringify(&nf, &mut buf).expect("bencode stringify failed");
        assert_eq!(buf.to_string(), "4:3.14");

        buf.clear();
        let nb = Node::Boolean(true);
        crate::stringify::bencode::stringify(&nb, &mut buf).expect("bencode stringify failed");
        assert_eq!(buf.to_string(), "4:true");
    }

    #[test]
    fn test_bencode_nested_mapping() {
        let mut buf = BufferDestination::new();
        let mapping = Node::Mapping(vec![(
            Node::from("list"),
            Node::Array(vec![Node::from(1), Node::from(2)]),
        )]);
        crate::stringify::bencode::stringify(&mapping, &mut buf).expect("bencode stringify failed");

        assert_eq!(buf.to_string(), "d4:listli1ei2eee");
    }
}