random usage is fixed in tests

Author: orxfun

Cargo.toml

@@ -30,5 +30,5 @@ default = []
 validation = []
 
 [[bench]]
-name = "doubly_shuffling_around"
+name = "doubly_mutation_ends"
 harness = false

tests/doubly.rs

@@ -37,16 +37,16 @@ const ACTIONS: [Actions; 10] = [
 const GROW_ACTIONS: [Actions; 3] = [Actions::PushBack, Actions::PushFront, Actions::Insert];
 
 fn val(r: &mut R) -> String {
-    r.gen_range(0..10000).to_string()
+    r.random_range(0..10000).to_string()
 }
 
 impl Actions {
     fn pick_grow(r: &mut R) -> Self {
-        GROW_ACTIONS[r.gen_range(0..GROW_ACTIONS.len())]
+        GROW_ACTIONS[r.random_range(0..GROW_ACTIONS.len())]
     }
 
     fn pick(r: &mut R) -> Self {
-        ACTIONS[r.gen_range(0..ACTIONS.len())]
+        ACTIONS[r.random_range(0..ACTIONS.len())]
     }
 
     fn apply<M>(self, r: &mut R, list: &mut List<Doubly<String>, M>)
@@ -86,14 +86,14 @@ impl Actions {
             Insert => {
                 let pos = match list.len() {
                     0 => 0,
-                    _ => r.gen_range(0..=list.len()),
+                    _ => r.random_range(0..=list.len()),
                 };
                 list.insert_at(pos, val(r));
             }
             Remove => {
                 let pos = match list.len() {
                     0 => 0,
-                    _ => r.gen_range(0..list.len()),
+                    _ => r.random_range(0..list.len()),
                 };
                 list.remove_at(pos);
             }

tests/list_swap.rs

@@ -19,8 +19,8 @@ fn list_swap() {
     let mut control: Vec<_> = list.iter().cloned().collect();
 
     for _ in 0..100 {
-        let a = r.gen_range(0..list.len());
-        let b = r.gen_range(0..list.len());
+        let a = r.random_range(0..list.len());
+        let b = r.random_range(0..list.len());
 
         list.swap(&idx[a], &idx[b]);
 

tests/singly.rs

@@ -29,16 +29,16 @@ const ACTIONS: [Actions; 6] = [
 const GROW_ACTIONS: [Actions; 2] = [Actions::PushFront, Actions::Insert];
 
 fn val(r: &mut R) -> String {
-    r.gen_range(0..10000).to_string()
+    r.random_range(0..10000).to_string()
 }
 
 impl Actions {
     fn pick_grow(r: &mut R) -> Self {
-        GROW_ACTIONS[r.gen_range(0..GROW_ACTIONS.len())]
+        GROW_ACTIONS[r.random_range(0..GROW_ACTIONS.len())]
     }
 
     fn pick(r: &mut R) -> Self {
-        ACTIONS[r.gen_range(0..ACTIONS.len())]
+        ACTIONS[r.random_range(0..ACTIONS.len())]
     }
 
     fn apply<M>(self, r: &mut R, list: &mut List<Singly<String>, M>)
@@ -64,14 +64,14 @@ impl Actions {
             Insert => {
                 let pos = match list.len() {
                     0 => 0,
-                    _ => r.gen_range(0..=list.len()),
+                    _ => r.random_range(0..=list.len()),
                 };
                 list.insert_at(pos, val(r));
             }
             Remove => {
                 let pos = match list.len() {
                     0 => 0,
-                    _ => r.gen_range(0..list.len()),
+                    _ => r.random_range(0..list.len()),
                 };
                 list.remove_at(pos);
             }

tests/utilization.rs

@@ -29,21 +29,21 @@ fn doubly() {
 
     list.pop_front();
     #[cfg(target_pointer_width = "64")]
-    assert_eq!(list.node_utilization().num_closed_nodes, 5);
+    assert_eq!(list.node_utilization().num_closed_nodes, 6);
     #[cfg(target_pointer_width = "32")]
     assert_eq!(list.node_utilization().num_closed_nodes, 6);
 
     list.pop_front();
     #[cfg(target_pointer_width = "64")]
-    assert_eq!(list.node_utilization().num_closed_nodes, 6);
+    assert_eq!(list.node_utilization().num_closed_nodes, 7);
     #[cfg(target_pointer_width = "32")]
-    assert_eq!(list.node_utilization().num_closed_nodes, 0);
+    assert_eq!(list.node_utilization().num_closed_nodes, 7);
 
     list.pop_front();
     #[cfg(target_pointer_width = "64")]
     assert_eq!(list.node_utilization().num_closed_nodes, 0);
     #[cfg(target_pointer_width = "32")]
-    assert_eq!(list.node_utilization().num_closed_nodes, 1);
+    assert_eq!(list.node_utilization().num_closed_nodes, 0);
 
     list.pop_back();
 
@@ -78,12 +78,12 @@ fn singly() {
 
     list.pop_front();
     #[cfg(target_pointer_width = "64")]
-    assert_eq!(list.node_utilization().num_closed_nodes, 7);
+    assert_eq!(list.node_utilization().num_closed_nodes, 1);
     #[cfg(target_pointer_width = "32")]
-    assert_eq!(list.node_utilization().num_closed_nodes, 4);
+    assert_eq!(list.node_utilization().num_closed_nodes, 1);
 
     list.pop_front();
-    assert_eq!(list.node_utilization().num_closed_nodes, 0);
+    assert_eq!(list.node_utilization().num_closed_nodes, 2);
 
     list.clear();
     assert_eq!(list.node_utilization().num_closed_nodes, 0);