test: replace range syntax with explicit Bound types in outputs_in_range tests

Author: aagbotemi

crates/chain/tests/test_spk_txout_index.rs

@@ -2,6 +2,7 @@ use bdk_chain::{spk_txout::SpkTxOutIndex, Indexer};
 use bitcoin::{
     absolute, transaction, Amount, OutPoint, ScriptBuf, SignedAmount, Transaction, TxIn, TxOut,
 };
+use std::ops::Bound;
 
 #[test]
 fn spk_txout_sent_and_received() {
@@ -212,11 +213,15 @@ fn outputs_in_range_excluded_bounds() {
     };
 
     // Full range (unbounded)
-    let all_outputs: Vec<_> = spk_index.outputs_in_range(..).collect();
+    let all_outputs: Vec<_> = spk_index
+        .outputs_in_range((Bound::Unbounded::<u32>, Bound::Unbounded::<u32>))
+        .collect();
     assert_eq!(all_outputs.len(), 5);
 
     // Included start, included end
-    let outputs_one_to_four: Vec<_> = spk_index.outputs_in_range(1..=4).collect();
+    let outputs_one_to_four: Vec<_> = spk_index
+        .outputs_in_range((Bound::Included(1u32), Bound::Included(4u32)))
+        .collect();
     assert_eq!(outputs_one_to_four.len(), 4);
     assert!(outputs_one_to_four
         .iter()
@@ -227,7 +232,9 @@ fn outputs_in_range_excluded_bounds() {
     assert!(!outputs_one_to_four.iter().any(|(i, _)| **i == 5));
 
     // Included start, Excluded end
-    let outputs_one_to_four_excl: Vec<_> = spk_index.outputs_in_range(1..4).collect();
+    let outputs_one_to_four_excl: Vec<_> = spk_index
+        .outputs_in_range((Bound::Included(1u32), Bound::Excluded(4u32)))
+        .collect();
     assert_eq!(outputs_one_to_four_excl.len(), 3);
     assert!(outputs_one_to_four_excl.iter().any(|(i, _)| **i == 1));
     assert!(outputs_one_to_four_excl
@@ -236,7 +243,9 @@ fn outputs_in_range_excluded_bounds() {
     assert!(!outputs_one_to_four_excl.iter().any(|(i, _)| **i == 4));
 
     // Excluded start, Included end
-    let outputs_one_excl_to_four: Vec<_> = spk_index.outputs_in_range(2..=4).collect();
+    let outputs_one_excl_to_four: Vec<_> = spk_index
+        .outputs_in_range((Bound::Excluded(1u32), Bound::Included(4u32)))
+        .collect();
     assert_eq!(outputs_one_excl_to_four.len(), 3,);
     assert!(!outputs_one_excl_to_four.iter().any(|(i, _)| **i == 1));
     assert!(outputs_one_excl_to_four
@@ -245,49 +254,63 @@ fn outputs_in_range_excluded_bounds() {
     assert!(outputs_one_excl_to_four.iter().any(|(i, _)| **i == 4));
 
     // Excluded start, Excluded end
-    let outputs_one_excl_to_four_excl: Vec<_> = spk_index.outputs_in_range(2..4).collect();
+    let outputs_one_excl_to_four_excl: Vec<_> = spk_index
+        .outputs_in_range((Bound::Excluded(1u32), Bound::Excluded(4u32)))
+        .collect();
     assert_eq!(outputs_one_excl_to_four_excl.len(), 2);
     assert!(!outputs_one_excl_to_four_excl.iter().any(|(i, _)| **i == 1));
     assert!(outputs_one_excl_to_four_excl.iter().any(|(i, _)| **i == 2));
     assert!(outputs_one_excl_to_four_excl.iter().any(|(i, _)| **i == 3));
     assert!(!outputs_one_excl_to_four_excl.iter().any(|(i, _)| **i == 4));
 
     // Unbounded start, Included end
-    let outputs_to_three: Vec<_> = spk_index.outputs_in_range(..=3).collect();
+    let outputs_to_three: Vec<_> = spk_index
+        .outputs_in_range((Bound::Unbounded::<u32>, Bound::Included(3u32)))
+        .collect();
     assert_eq!(outputs_to_three.len(), 3,);
     assert!(outputs_to_three.iter().any(|(i, _)| **i == 1));
     assert!(outputs_to_three.iter().any(|(i, _)| **i == 3));
     assert!(!outputs_to_three.iter().any(|(i, _)| **i == 4));
 
     // Unbounded start, excluded end
-    let outputs_to_three_excl: Vec<_> = spk_index.outputs_in_range(..3).collect();
+    let outputs_to_three_excl: Vec<_> = spk_index
+        .outputs_in_range((Bound::Unbounded::<u32>, Bound::Excluded(3u32)))
+        .collect();
     assert_eq!(outputs_to_three_excl.len(), 2,);
     assert!(outputs_to_three_excl.iter().any(|(i, _)| **i == 1));
     assert!(outputs_to_three_excl.iter().any(|(i, _)| **i == 2));
     assert!(!outputs_to_three_excl.iter().any(|(i, _)| **i == 3),);
 
     // Included start, Unbounded end
-    let outputs_to_three: Vec<_> = spk_index.outputs_in_range(3..).collect();
+    let outputs_to_three: Vec<_> = spk_index
+        .outputs_in_range((Bound::Included(3u32), Bound::Unbounded::<u32>))
+        .collect();
     assert_eq!(outputs_to_three.len(), 3,);
     assert!(outputs_to_three.iter().any(|(i, _)| **i == 3));
     assert!(outputs_to_three.iter().any(|(i, _)| **i == 5),);
     assert!(!outputs_to_three.iter().any(|(i, _)| **i == 2),);
 
     // Excluded start, Unbounded end
-    let outputs_to_three_excl: Vec<_> = spk_index.outputs_in_range(4..).collect();
+    let outputs_to_three_excl: Vec<_> = spk_index
+        .outputs_in_range((Bound::Included(4u32), Bound::Unbounded::<u32>))
+        .collect();
     assert_eq!(outputs_to_three_excl.len(), 2,);
     assert!(!outputs_to_three_excl.iter().any(|(i, _)| **i == 3));
     assert!(outputs_to_three_excl.iter().any(|(i, _)| **i == 5),);
     assert!(outputs_to_three_excl.iter().any(|(i, _)| **i == 4));
 
     // Single element range
-    let outputs_to_three: Vec<_> = spk_index.outputs_in_range(3..=3).collect();
-    assert_eq!(outputs_to_three.len(), 1,);
-    assert!(outputs_to_three.iter().any(|(i, _)| **i == 3));
-    assert!(!outputs_to_three.iter().any(|(i, _)| **i == 4));
-    assert!(!outputs_to_three.iter().any(|(i, _)| **i == 2));
+    let output_at_three: Vec<_> = spk_index
+        .outputs_in_range((Bound::Included(3u32), Bound::Included(3u32)))
+        .collect();
+    assert_eq!(output_at_three.len(), 1,);
+    assert!(output_at_three.iter().any(|(i, _)| **i == 3));
+    assert!(!output_at_three.iter().any(|(i, _)| **i == 4));
+    assert!(!output_at_three.iter().any(|(i, _)| **i == 2));
 
     // Empty range with excluded bound
-    let outputs_empty: Vec<_> = spk_index.outputs_in_range(3..3).collect();
+    let outputs_empty: Vec<_> = spk_index
+        .outputs_in_range((Bound::Included(3u32), Bound::Excluded(3u32)))
+        .collect();
     assert_eq!(outputs_empty.len(), 0);
 }