script/research/dark-forest: proper traversal order tests

script/research/dark-forest/src/lib.rs

@@ -16,7 +16,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use std::{collections::VecDeque, iter::FusedIterator, mem, slice::Iter};
+use std::{collections::VecDeque, iter::FusedIterator, mem};
 
 #[cfg(test)]
 mod tests;

script/research/dark-forest/src/tests.rs

@@ -16,69 +16,81 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-#[cfg(test)]
-mod tests {
-    use crate::DarkTree;
+use crate::DarkTree;
 
-    fn generate_tree() -> DarkTree<i32> {
-        DarkTree::new(
-            5,
-            vec![
-                DarkTree::new(4, vec![DarkTree::new(3, vec![]), DarkTree::new(2, vec![])]),
-                DarkTree::new(1, vec![DarkTree::new(0, vec![])]),
-            ],
-        )
-    }
+fn generate_tree() -> (DarkTree<i32>, Vec<i32>) {
+    let tree = DarkTree::new(
+        5,
+        vec![
+            DarkTree::new(4, vec![DarkTree::new(3, vec![]), DarkTree::new(2, vec![])]),
+            DarkTree::new(1, vec![DarkTree::new(0, vec![])]),
+        ],
+    );
+    
+    let traversal_order = vec![3, 2, 4, 0, 1, 5];
+    
+    (tree, traversal_order)
+}
 
-    #[test]
-    pub fn test_darktree_iterator() {
-        let tree = generate_tree();
+#[test]
+pub fn test_darktree_iterator() {
+    let (tree, traversal_order) = generate_tree();
 
-        let nums: Vec<i32> = tree.iter().map(|x| x.data).collect();
+    let nums: Vec<i32> = tree.iter().map(|x| x.data).collect();
 
-        assert_eq!(nums, vec![3, 2, 4, 0, 1, 5]);
-        assert_eq!(tree.iter().nth(1).unwrap().data, 2);
-    }
+    assert_eq!(nums, traversal_order);
+    assert_eq!(tree.iter().nth(1).unwrap().data, traversal_order[1]);
+}
 
-    #[test]
-    fn test_owned_for_loop() {
-        let tree = DarkTree::new(42, vec![]);
+#[test]
+fn test_darktree_traversal_order() {
+    let (mut tree, traversal_order) = generate_tree();
 
-        for leaf in tree {
-            let _: i32 = leaf.data;
-        }
+    let mut index = 0;
+    for leaf in &tree {
+        assert_eq!(leaf.data, traversal_order[index]);
+        index += 1;
     }
-
-    #[test]
-    fn test_borrowing_for_loop() {
-        let tree = DarkTree::new(42, vec![]);
-
-        for &leaf in &tree {
-            let _: i32 = leaf.data;
-        }
+    
+    index = 0;
+    for leaf in &mut tree {
+        assert_eq!(leaf.data, traversal_order[index]);
+        index += 1;
     }
+    
+    for (index, leaf) in tree.iter_mut().enumerate() {
+        assert_eq!(leaf.data, traversal_order[index]);
+    }
+    
+    for (index, leaf) in tree.iter().enumerate() {
+        assert_eq!(leaf.data, traversal_order[index]);
+    }
+    
+    for (index, leaf) in tree.into_iter().enumerate() {
+        assert_eq!(leaf.data, traversal_order[index]);
+    }
+}
 
-    #[test]
-    fn test_darktree_mut_iterator() {
-        let mut tree = generate_tree();
-
-        for leaf in tree.iter_mut() {
-            leaf.data += 1;
-        }
+#[test]
+fn test_darktree_mut_iterator() {
+    let (mut tree, _) = generate_tree();
 
-        for leaf in &mut tree {
-            leaf.data += 1;
-        }
+    for leaf in tree.iter_mut() {
+        leaf.data += 1;
+    }
 
-        assert_eq!(
-            tree,
-            DarkTree::new(
-                7,
-                vec![
-                    DarkTree::new(6, vec![DarkTree::new(5, vec![]), DarkTree::new(4, vec![]),]),
-                    DarkTree::new(3, vec![DarkTree::new(2, vec![]),]),
-                ]
-            )
-        );
+    for leaf in &mut tree {
+        leaf.data += 1;
     }
+
+    assert_eq!(
+        tree,
+        DarkTree::new(
+            7,
+            vec![
+                DarkTree::new(6, vec![DarkTree::new(5, vec![]), DarkTree::new(4, vec![]),]),
+                DarkTree::new(3, vec![DarkTree::new(2, vec![]),]),
+            ]
+        )
+    );
 }