flange-flat-tree 0.2.2

A tree that can be expanded by attaching new values to the node without mutability of the old ones
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

use crate::{tree::Tree, Builder, Subtree};

#[test]
fn test_create() {
    // Use builder
    let mut builder = Builder::with_capacity(10);
    builder.start_element(1);
    builder.start_end_element(2);
    builder.start_end_element(3);
    builder.start_end_element(4);
    builder.start_element(5);
    builder.start_end_element(6);
    builder.start_end_element(7);
    builder.start_element(8);
    builder.start_end_element(9);
    builder.end_element();
    builder.start_end_element(10);
    builder.end_element();
    builder.end_element();
    let _tree = builder.build();
}

#[test]
fn simple_test() {
    // Setup

    // Insert a root and some children
    let mut b = Builder::new();
    b.start_element(0);
    b.start_end_element(1);
    b.start_end_element(2);
    b.start_end_element(3);
    b.end_element();
    let t = b.build();

    let root = t.root();

    // Test
    assert_eq!(*root.value(), 0);
    assert_eq!(root.child_values(), vec![&1, &2, &3]);
}

#[test]
fn multi_children_test() {
    // Insert a root and some children
    let mut t = Builder::new();
    t.start_element(0);
    t.start_element(1);
    t.start_end_element(2);
    t.start_end_element(3);
    t.start_end_element(4);
    t.end_element();
    t.start_end_element(5);
    t.start_end_element(6);
    t.start_end_element(7);
    t.end_element();
    let t = t.build();
    let root = t.root();

    // Test
    assert_eq!(root.child_values(), vec![&1, &5, &6, &7]);
    assert_eq!(root.first_child().unwrap().child_values(), vec![&2, &3, &4]);
    assert_eq!(
        root.first_child()
            .unwrap()
            .first_child()
            .unwrap()
            .next_sibling()
            .unwrap()
            .value(),
        &3
    );
    assert_eq!(
        root.first_child().unwrap().children()[1]
            .next_sibling()
            .unwrap()
            .value(),
        &4
    );
    assert_eq!(
        root.first_child().unwrap().children()[1]
            .prev_sibling()
            .unwrap()
            .value(),
        &2
    );
    assert!(root.first_child().unwrap().children()[2]
        .next_sibling()
        .is_none());
    assert!(root.first_child().unwrap().children()[0]
        .prev_sibling()
        .is_none());
    assert!(root.parent().is_none());
    assert_eq!(root.children()[0].parent().unwrap().value(), &0);
    assert_eq!(root.children()[1].parent().unwrap().value(), &0);
    assert_eq!(root.children()[2].parent().unwrap().value(), &0);
    assert_eq!(root.children()[3].parent().unwrap().value(), &0);
    assert_eq!(
        root.first_child().unwrap().children()[0]
            .parent()
            .unwrap()
            .value(),
        &1
    );
}