links-notation 0.13.0

Rust implementation of the Links Notation parser
Documentation 
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use links_notation::LiNo;

#[test]
fn link_constructor_with_id_only_test() {
    let link = LiNo::Link::<String> {
        id: Some("test".to_string()),
        values: vec![],
    };
    if let LiNo::Link { id, values } = link {
        assert_eq!(id, Some("test".to_string()));
        assert!(values.is_empty());
    } else {
        panic!("Expected Link variant");
    }
}

#[test]
fn link_constructor_with_id_and_values_test() {
    let values = vec![
        LiNo::Ref("value1".to_string()),
        LiNo::Ref("value2".to_string()),
    ];
    let link = LiNo::Link {
        id: Some("parent".to_string()),
        values: values.clone(),
    };
    if let LiNo::Link {
        id,
        values: link_values,
    } = link
    {
        assert_eq!(id, Some("parent".to_string()));
        assert_eq!(link_values.len(), 2);
    } else {
        panic!("Expected Link variant");
    }
}

#[test]
fn link_to_string_with_id_only_test() {
    let link = LiNo::Link::<String> {
        id: Some("test".to_string()),
        values: vec![],
    };
    assert_eq!(link.to_string(), "(test: )");
}

#[test]
fn link_to_string_with_values_only_test() {
    let values = vec![
        LiNo::Ref("value1".to_string()),
        LiNo::Ref("value2".to_string()),
    ];
    let link = LiNo::Link::<String> { id: None, values };
    assert_eq!(link.to_string(), "(value1 value2)");
}

#[test]
fn link_to_string_with_id_and_values_test() {
    let values = vec![
        LiNo::Ref("child1".to_string()),
        LiNo::Ref("child2".to_string()),
    ];
    let link = LiNo::Link {
        id: Some("parent".to_string()),
        values,
    };
    assert_eq!(link.to_string(), "(parent: child1 child2)");
}

#[test]
fn link_equals_test() {
    let link1 = LiNo::Link::<String> {
        id: Some("test".to_string()),
        values: vec![],
    };
    let link2 = LiNo::Link::<String> {
        id: Some("test".to_string()),
        values: vec![],
    };
    let link3 = LiNo::Link::<String> {
        id: Some("other".to_string()),
        values: vec![],
    };

    assert_eq!(link1, link2);
    assert_ne!(link1, link3);
}

#[test]
fn link_combine_test() {
    // Rust doesn't have a direct combine method, but we can test creating combined structures
    let link1 = LiNo::Ref("first".to_string());
    let link2 = LiNo::Ref("second".to_string());
    let combined = LiNo::Link::<String> {
        id: None,
        values: vec![link1, link2],
    };

    if let LiNo::Link { id, values } = combined {
        assert_eq!(id, None);
        assert_eq!(values.len(), 2);
    } else {
        panic!("Expected Link variant");
    }
}

#[test]
fn link_escape_reference_simple_test() {
    let ref_simple = LiNo::Ref("test".to_string());
    assert_eq!(ref_simple.to_string(), "test");

    let ref_with_nums = LiNo::Ref("test123".to_string());
    assert_eq!(ref_with_nums.to_string(), "test123");
}

#[test]
fn link_escape_reference_with_special_characters_test() {
    // In Rust implementation, special character handling would be in the parser
    // These tests verify basic string handling
    let ref_space = LiNo::Ref("has space".to_string());
    assert_eq!(ref_space.to_string(), "has space");

    let ref_colon = LiNo::Ref("has:colon".to_string());
    assert_eq!(ref_colon.to_string(), "has:colon");
}

#[test]
fn link_simplify_test() {
    // Test simplification behavior - empty values
    let link1 = LiNo::Link::<String> {
        id: Some("test".to_string()),
        values: vec![],
    };
    // In Rust, we don't have a simplify method, but we can test the structure
    if let LiNo::Link { id, values } = link1 {
        assert_eq!(id, Some("test".to_string()));
        assert!(values.is_empty());
    }

    // Test with single value
    let single_ref = LiNo::Ref("single".to_string());
    let link2 = LiNo::Link::<String> {
        id: None,
        values: vec![single_ref.clone()],
    };
    if let LiNo::Link { id, values } = link2 {
        assert_eq!(id, None);
        assert_eq!(values.len(), 1);
        assert_eq!(values[0], single_ref);
    }
}