Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 847f104

Browse files
Added unit testing
1 parent 34a65d3 commit 847f104

File tree

3 files changed

+300
-8
lines changed

3 files changed

+300
-8
lines changed

‎src/tests/linked_lists.rs

Lines changed: 118 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,118 @@
1+
use crate::prelude::*;
2+
use crate::utils::ListNode;
3+
4+
///////////////////////////////////////////////////////////////////////////////////////////////////
5+
// Utility
6+
///////////////////////////////////////////////////////////////////////////////////////////////////
7+
8+
fn some_box_node(val: i32) -> Option<Box<ListNode>> {
9+
Some(Box::from(ListNode::new(val)))
10+
}
11+
12+
fn traverse_node(list_node: &mut Box<ListNode>, items: Vec<i32>) -> Result<()> {
13+
if items.is_empty() {
14+
return Err("The input vector is empty".into());
15+
}
16+
17+
assert_eq!(items[0], list_node.val);
18+
19+
let mut i: usize = 0;
20+
let len = items.len();
21+
while let Some(ref next) = list_node.next {
22+
i += 1;
23+
24+
if i >= len {
25+
return Err("Out of bounds traversal.".into());
26+
}
27+
28+
assert_eq!(items[i], next.val);
29+
30+
*list_node = list_node
31+
.next
32+
.clone()
33+
.expect("Infalliable unwrap within while-let loop");
34+
}
35+
36+
if i < len - 1 {
37+
return Err(format!(
38+
"{}{:?}{}{:?}{}{}",
39+
"The input vector: vec!",
40+
items,
41+
" is larger than the list node. Last node: ",
42+
list_node,
43+
". At index: ",
44+
i,
45+
)
46+
.into());
47+
}
48+
49+
Ok(())
50+
}
51+
52+
///////////////////////////////////////////////////////////////////////////////////////////////////
53+
// Preset nodes
54+
///////////////////////////////////////////////////////////////////////////////////////////////////
55+
56+
fn one_item_node(val: i32) -> ListNode {
57+
ListNode::new(val)
58+
}
59+
60+
fn two_items_node(val: i32, val2: Option<i32>) -> ListNode {
61+
ListNode {
62+
val,
63+
next: some_box_node(val2.unwrap_or(val)),
64+
}
65+
}
66+
67+
fn three_items_node(val: i32, val2: Option<i32>, val3: Option<i32>) -> ListNode {
68+
ListNode {
69+
val,
70+
next: Some(Box::from(ListNode {
71+
val: val2.unwrap_or(val),
72+
next: some_box_node(val3.unwrap_or(val2.unwrap_or(val))),
73+
})),
74+
}
75+
}
76+
77+
///////////////////////////////////////////////////////////////////////////////////////////////////
78+
// Tests with the preset nodes
79+
///////////////////////////////////////////////////////////////////////////////////////////////////
80+
81+
fn correct_traversals() -> Result<()> {
82+
// Three items
83+
84+
let three_items_values = vec![1, 2, 3];
85+
let mut three_items_node = Box::from(three_items_node(
86+
three_items_values[0],
87+
Some(three_items_values[1]),
88+
Some(three_items_values[2]),
89+
));
90+
traverse_node(&mut three_items_node, three_items_values)?;
91+
92+
// Two items
93+
94+
let two_items_values = vec![1, 2];
95+
let mut two_items_node = Box::from(two_items_node(
96+
two_items_values[0],
97+
Some(two_items_values[1]),
98+
));
99+
traverse_node(&mut two_items_node, two_items_values)?;
100+
101+
// One item
102+
103+
let one_item_value = vec![1];
104+
let mut one_item_node = Box::from(one_item_node(one_item_value[0]));
105+
traverse_node(&mut one_item_node, one_item_value)?;
106+
107+
Ok(())
108+
}
109+
110+
///////////////////////////////////////////////////////////////////////////////////////////////////
111+
// Main
112+
///////////////////////////////////////////////////////////////////////////////////////////////////
113+
114+
#[test]
115+
fn main() -> Result<()> {
116+
correct_traversals()?;
117+
Ok(())
118+
}

‎src/tests/mod.rs

Lines changed: 18 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,19 @@
1-
/// This test DOESN'T implement the Send and Sync traits. That's because the program as a whole
2-
/// isn't made to be async. It's meant to just be a basic CLI app that you can check your leetcode
3-
/// submitions in. Send and Sync both require Arc which breaks the leetcode TreeNode signature
4-
/// Option<Rc<Refcell<TreeNode>>>.
5-
fn _is_normal<T: Sized + Unpin>() {}
6-
#[test]
7-
fn normal_types() {
8-
_is_normal::<crate::utils::trees::TreeNode>();
1+
#[cfg(test)]
2+
mod linked_lists;
3+
4+
#[cfg(test)]
5+
mod trees;
6+
7+
#[cfg(test)]
8+
mod type_tests {
9+
/// This test DOESN'T implement the Send and Sync traits. That's because the program as a whole
10+
/// isn't made to be async. It's meant to just be a basic CLI app that you can check your leetcode
11+
/// submitions in. Send and Sync both require Arc which breaks the leetcode TreeNode signature
12+
/// Option<Rc<Refcell<TreeNode>>>.
13+
fn _is_normal<T: Sized + Unpin>() {}
14+
#[test]
15+
fn normal_types() {
16+
_is_normal::<crate::utils::TreeNode>();
17+
_is_normal::<crate::utils::ListNode>();
18+
}
919
}

‎src/tests/trees.rs

Lines changed: 164 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,164 @@
1+
use std::cell::RefCell;
2+
use std::rc::Rc;
3+
4+
use crate::prelude::*;
5+
use crate::utils::TreeNode;
6+
7+
///////////////////////////////////////////////////////////////////////////////////////////////////
8+
// Utility
9+
///////////////////////////////////////////////////////////////////////////////////////////////////
10+
11+
fn rc_cell_node(val: i32) -> Rc<RefCell<TreeNode>> {
12+
Rc::from(RefCell::from(TreeNode::new(val)))
13+
}
14+
15+
///////////////////////////////////////////////////////////////////////////////////////////////////
16+
// Preset nodes
17+
///////////////////////////////////////////////////////////////////////////////////////////////////
18+
19+
fn symmetric_tree(val: i32) -> TreeNode {
20+
let left_node = TreeNode::new(val);
21+
let right_node = TreeNode::new(val);
22+
TreeNode {
23+
val: 100,
24+
left: Some(Rc::from(RefCell::from(left_node))),
25+
right: Some(Rc::from(RefCell::from(right_node))),
26+
}
27+
}
28+
29+
fn asymmetric_values_tree(left_val: i32, right_val: i32) -> TreeNode {
30+
let left_node = TreeNode::new(left_val);
31+
let right_node = TreeNode::new(right_val);
32+
TreeNode {
33+
val: 100,
34+
left: Some(Rc::from(RefCell::from(left_node))),
35+
right: Some(Rc::from(RefCell::from(right_node))),
36+
}
37+
}
38+
39+
fn asymmetric_tree_no_right(val: i32) -> TreeNode {
40+
TreeNode {
41+
val: 100,
42+
left: Some(rc_cell_node(val)),
43+
right: None,
44+
}
45+
}
46+
47+
fn asymmetric_tree_no_left(val: i32) -> TreeNode {
48+
TreeNode {
49+
val: 100,
50+
left: None,
51+
right: Some(rc_cell_node(val)),
52+
}
53+
}
54+
55+
///////////////////////////////////////////////////////////////////////////////////////////////////
56+
// Tests with the preset nodes
57+
///////////////////////////////////////////////////////////////////////////////////////////////////
58+
59+
fn test_symmetric_tree() -> Result<()> {
60+
let left_right_vals = 50;
61+
62+
let symmetric_tree = symmetric_tree(left_right_vals);
63+
64+
match (symmetric_tree.left, symmetric_tree.right) {
65+
(Some(left_node), Some(right_node)) => {
66+
assert_eq!(left_node, rc_cell_node(left_right_vals));
67+
assert_eq!(right_node, rc_cell_node(left_right_vals));
68+
69+
assert_eq!(left_node, right_node);
70+
}
71+
(Some(_), None) => {
72+
return Err("Missing right_node".into());
73+
}
74+
(None, Some(_)) => {
75+
return Err("Missing left_node".into());
76+
}
77+
_ => {
78+
return Err("Missing both left_node and right_node".into());
79+
}
80+
}
81+
82+
Ok(())
83+
}
84+
85+
fn test_asymmetric_values_tree() -> Result<()> {
86+
let left_val = 42;
87+
let right_val = 21;
88+
89+
let asymmetric_tree = asymmetric_values_tree(left_val, right_val);
90+
91+
match (asymmetric_tree.left, asymmetric_tree.right) {
92+
(Some(left_node), Some(right_node)) => {
93+
assert_eq!(left_node, rc_cell_node(left_val));
94+
assert_eq!(right_node, rc_cell_node(right_val));
95+
96+
assert_ne!(left_node, right_node);
97+
}
98+
(Some(_), None) => {
99+
return Err("Missing right_node".into());
100+
}
101+
(None, Some(_)) => {
102+
return Err("Missing left_node".into());
103+
}
104+
_ => {
105+
return Err("Missing both left_node and right_node".into());
106+
}
107+
}
108+
109+
Ok(())
110+
}
111+
112+
fn test_asymmetric_depth_trees() -> Result<()> {
113+
let asymmetric_nodes_values = 50;
114+
115+
let asymmetric_tree_no_right = asymmetric_tree_no_right(asymmetric_nodes_values);
116+
let asymmetric_tree_no_left = asymmetric_tree_no_left(asymmetric_nodes_values);
117+
118+
match (
119+
asymmetric_tree_no_right.left,
120+
asymmetric_tree_no_right.right,
121+
) {
122+
(Some(_), Some(_)) => {
123+
return Err("There shouldn't be a right_node".into());
124+
}
125+
(Some(left_node), None) => {
126+
assert_eq!(left_node, rc_cell_node(asymmetric_nodes_values));
127+
}
128+
(None, Some(_)) => {
129+
return Err("Missing left_node and there shouldn't be a right node".into());
130+
}
131+
_ => {
132+
return Err("There should just be a right_node but there're no nodes".into());
133+
}
134+
}
135+
136+
match (asymmetric_tree_no_left.left, asymmetric_tree_no_left.right) {
137+
(Some(_), Some(_)) => {
138+
return Err("There shouldn't be a left_node".into());
139+
}
140+
(Some(_), None) => {
141+
return Err("Missing right_node and there shouldn't be a left node".into());
142+
}
143+
(None, Some(right_node)) => {
144+
assert_eq!(right_node, rc_cell_node(asymmetric_nodes_values));
145+
}
146+
_ => {
147+
return Err("There should just be a left_node but there're no nodes".into());
148+
}
149+
}
150+
151+
Ok(())
152+
}
153+
154+
///////////////////////////////////////////////////////////////////////////////////////////////////
155+
// Main
156+
///////////////////////////////////////////////////////////////////////////////////////////////////
157+
158+
#[test]
159+
fn main() -> Result<()> {
160+
test_symmetric_tree()?;
161+
test_asymmetric_values_tree()?;
162+
test_asymmetric_depth_trees()?;
163+
Ok(())
164+
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /