envision 0.15.1

A ratatui framework for collaborative TUI development with headless testing support
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

use super::*;

// ========== TreeNode PartialEq Tests ==========

#[test]
fn test_node_equal() {
    let node1 = TreeNode::new("Label", 42);
    let node2 = TreeNode::new("Label", 42);
    assert_eq!(node1, node2);
}

#[test]
fn test_node_not_equal_label() {
    let node1 = TreeNode::new("Label A", 42);
    let node2 = TreeNode::new("Label B", 42);
    assert_ne!(node1, node2);
}

#[test]
fn test_node_not_equal_data() {
    let node1 = TreeNode::new("Label", 1);
    let node2 = TreeNode::new("Label", 2);
    assert_ne!(node1, node2);
}

#[test]
fn test_node_not_equal_expanded() {
    let node1 = TreeNode::new("Label", ());
    let node2 = TreeNode::new_expanded("Label", ());
    assert_ne!(node1, node2);
}

#[test]
fn test_node_not_equal_children() {
    let mut node1 = TreeNode::new("Parent", ());
    node1.add_child(TreeNode::new("Child A", ()));

    let mut node2 = TreeNode::new("Parent", ());
    node2.add_child(TreeNode::new("Child B", ()));

    assert_ne!(node1, node2);
}

#[test]
fn test_node_equal_with_children() {
    let mut node1 = TreeNode::new("Parent", ());
    node1.add_child(TreeNode::new("Child", ()));

    let mut node2 = TreeNode::new("Parent", ());
    node2.add_child(TreeNode::new("Child", ()));

    assert_eq!(node1, node2);
}

#[test]
fn test_node_not_equal_different_child_count() {
    let mut node1 = TreeNode::new("Parent", ());
    node1.add_child(TreeNode::new("Child 1", ()));

    let mut node2 = TreeNode::new("Parent", ());
    node2.add_child(TreeNode::new("Child 1", ()));
    node2.add_child(TreeNode::new("Child 2", ()));

    assert_ne!(node1, node2);
}

#[test]
fn test_node_equal_deep_nesting() {
    let mut child1 = TreeNode::new("Child", ());
    child1.add_child(TreeNode::new("Grandchild", ()));

    let mut parent1 = TreeNode::new("Parent", ());
    parent1.add_child(child1);

    let mut child2 = TreeNode::new("Child", ());
    child2.add_child(TreeNode::new("Grandchild", ()));

    let mut parent2 = TreeNode::new("Parent", ());
    parent2.add_child(child2);

    assert_eq!(parent1, parent2);
}

// ========== TreeState PartialEq Tests ==========

#[test]
fn test_state_equal() {
    let state1 = TreeState::new(vec![TreeNode::new("Root", 1)]);
    let state2 = TreeState::new(vec![TreeNode::new("Root", 1)]);
    assert_eq!(state1, state2);
}

#[test]
fn test_state_not_equal_roots() {
    let state1 = TreeState::new(vec![TreeNode::new("Root A", 1)]);
    let state2 = TreeState::new(vec![TreeNode::new("Root B", 1)]);
    assert_ne!(state1, state2);
}

#[test]
fn test_state_not_equal_selected_index() {
    let mut root1 = TreeNode::new_expanded("Root", ());
    root1.add_child(TreeNode::new("Child", ()));
    let mut root2 = TreeNode::new_expanded("Root", ());
    root2.add_child(TreeNode::new("Child", ()));

    let state1 = TreeState::new(vec![root1]).with_selected(0);
    let state2 = TreeState::new(vec![root2]).with_selected(1);
    assert_ne!(state1, state2);
}

#[test]
fn test_state_not_equal_filter_text() {
    let mut state1 = TreeState::new(vec![TreeNode::new("Root", ())]);
    let state2 = TreeState::new(vec![TreeNode::new("Root", ())]);

    state1.set_filter_text("abc");
    assert_ne!(state1, state2);
}

#[test]
fn test_state_equal_empty() {
    let state1: TreeState<()> = TreeState::new(Vec::new());
    let state2: TreeState<()> = TreeState::new(Vec::new());
    assert_eq!(state1, state2);
}

#[test]
fn test_state_equal_complex() {
    let mut root1 = TreeNode::new_expanded("Root", 1);
    root1.add_child(TreeNode::new("Child", 2));

    let mut root2 = TreeNode::new_expanded("Root", 1);
    root2.add_child(TreeNode::new("Child", 2));

    let state1 = TreeState::new(vec![root1]);
    let state2 = TreeState::new(vec![root2]);

    assert_eq!(state1, state2);
}