Merge #1897: test for excluded bounds in outputs_in_range

ad79267 test for excluded bounds in outputs_in_range (aagbotemi)

Pull request description:

  <!-- You can erase any parts of this template not applicable to your Pull Request. -->

  ### Description
  This PR covers a wide range on tests for excluded bounds and the `SpkTxOutIndex::outputs_in_range`. This PR fixes bitcoindevkit/bdk_wallet#58

  <!-- Describe the purpose of this PR, what's being adding and/or fixed -->

  ### Notes to the reviewers

  <!-- In this section you can include notes directed to the reviewers, like explaining why some parts
  of the PR were done in a specific way -->

  ### Changelog notice

  <!-- Notice the release manager should include in the release tag message changelog -->
  <!-- See https://keepachangelog.com/en/1.0.0/ for examples -->

  ### Checklists

  #### All Submissions:

  * [x] I've signed all my commits
  * [x] I followed the [contribution guidelines](https://github.com/bitcoindevkit/bdk/blob/master/CONTRIBUTING.md)
  * [x] I ran `cargo fmt` and `cargo clippy` before committing

  #### New Features:

  * [ ] I've added tests for the new feature
  * [ ] I've added docs for the new feature

  #### Bugfixes:

  * [ ] This pull request breaks the existing API
  * [ ] I've added tests to reproduce the issue which are now passing
  * [x] I'm linking the issue being fixed by this PR

ACKs for top commit:
  ValuedMammal:
    ACK ad79267
  oleonardolima:
    utACK ad79267

Tree-SHA512: 268e48ce6e7ffb0ed62d0124869caf1fbcff65d787a1a6566a5521408a8b9659a9f25cba5523802e805ac24bfa7809fff51e49c6be59cef6b6ecf4a29ffb9b0a

Author: ValuedMammal

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 core::ops::Bound;
 
 #[test]
 fn spk_txout_sent_and_received() {
@@ -122,3 +123,194 @@ fn unmark_used_does_not_result_in_invalid_representation() {
     assert!(!spk_index.unmark_used(&2));
     assert!(spk_index.unused_spks(..).collect::<Vec<_>>().is_empty());
 }
+
+#[test]
+fn outputs_in_range_excluded_bounds() {
+    let spk1 = ScriptBuf::from_hex("001404f1e52ce2bab3423c6a8c63b7cd730d8f12542c").unwrap();
+    let spk2 = ScriptBuf::from_hex("00142b57404ae14f08c3a0c903feb2af7830605eb00f").unwrap();
+    let spk3 = ScriptBuf::from_hex("0014afa973f4364b2772d35f7a13ed83eb0c3330cf9c").unwrap();
+    let spk4 = ScriptBuf::from_hex("00140707d2493460cad9bb20f5f447a5a89d16d9e21c").unwrap();
+    let spk5 = ScriptBuf::from_hex("0014a10d9257489e685dda030662390dc177852faf13").unwrap();
+
+    let mut spk_index = SpkTxOutIndex::default();
+    spk_index.insert_spk(1, spk1.clone());
+    spk_index.insert_spk(2, spk2.clone());
+    spk_index.insert_spk(3, spk3.clone());
+    spk_index.insert_spk(4, spk4.clone());
+    spk_index.insert_spk(5, spk5.clone());
+
+    let tx1 = Transaction {
+        version: transaction::Version::TWO,
+        lock_time: absolute::LockTime::ZERO,
+        input: vec![],
+        output: vec![TxOut {
+            value: Amount::from_sat(10_000),
+            script_pubkey: spk1,
+        }],
+    };
+
+    let tx2 = Transaction {
+        version: transaction::Version::TWO,
+        lock_time: absolute::LockTime::ZERO,
+        input: vec![],
+        output: vec![TxOut {
+            value: Amount::from_sat(20_000),
+            script_pubkey: spk2,
+        }],
+    };
+
+    let tx3 = Transaction {
+        version: transaction::Version::TWO,
+        lock_time: absolute::LockTime::ZERO,
+        input: vec![],
+        output: vec![TxOut {
+            value: Amount::from_sat(30_000),
+            script_pubkey: spk3,
+        }],
+    };
+
+    let tx4 = Transaction {
+        version: transaction::Version::TWO,
+        lock_time: absolute::LockTime::ZERO,
+        input: vec![],
+        output: vec![TxOut {
+            value: Amount::from_sat(40_000),
+            script_pubkey: spk4,
+        }],
+    };
+
+    let tx5 = Transaction {
+        version: transaction::Version::TWO,
+        lock_time: absolute::LockTime::ZERO,
+        input: vec![],
+        output: vec![TxOut {
+            value: Amount::from_sat(50_000),
+            script_pubkey: spk5,
+        }],
+    };
+
+    spk_index.index_tx(&tx1);
+    spk_index.index_tx(&tx2);
+    spk_index.index_tx(&tx3);
+    spk_index.index_tx(&tx4);
+    spk_index.index_tx(&tx5);
+
+    let tx1_op = OutPoint {
+        txid: tx1.compute_txid(),
+        vout: 0,
+    };
+    let tx2_op = OutPoint {
+        txid: tx2.compute_txid(),
+        vout: 0,
+    };
+    let tx3_op = OutPoint {
+        txid: tx3.compute_txid(),
+        vout: 0,
+    };
+    let tx4_op = OutPoint {
+        txid: tx4.compute_txid(),
+        vout: 0,
+    };
+
+    // Full range (unbounded)
+    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((Bound::Included(1u32), Bound::Included(4u32)))
+        .collect();
+    assert_eq!(outputs_one_to_four.len(), 4);
+    assert!(outputs_one_to_four
+        .iter()
+        .any(|(i, op)| **i == 1 && *op == tx1_op));
+    assert!(outputs_one_to_four
+        .iter()
+        .any(|(i, op)| **i == 4 && *op == tx4_op));
+    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((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
+        .iter()
+        .any(|(i, op)| **i == 3 && *op == tx3_op));
+    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((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
+        .iter()
+        .any(|(i, op)| **i == 2 && *op == tx2_op));
+    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((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((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((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((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((Bound::Excluded(3u32), 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 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((Bound::Included(3u32), Bound::Excluded(3u32)))
+        .collect();
+    assert_eq!(outputs_empty.len(), 0);
+}