Merge rust-bitcoin/rust-bitcoin#1043: Clear clippy warnings from --all-targets

apoelstra · apoelstra · commit 663861958eb1 · 2022-06-08T12:50:37.000Z
271d0ba Allow many arguments in test function (Tobin C. Harding) c0c88fe Use vec instead of pushing to a mutable vector (Tobin C. Harding) 73066e7 Use values() to iterate map values (Tobin C. Harding) 38ff025 Remove useless use of vec! (Tobin C. Harding) d8e82d5 Remove length comparison to zero (Tobin C. Harding) c1f34f5 Return Address directly (Tobin C. Harding) ff8d585 Use flat_map instead of map().flatten() (Tobin C. Harding) b24a112 Remove calls to clone from types that implement Copy (Tobin C. Harding) 2b8d93e Remove unnecessary explicit reference (Tobin C. Harding) ef90e3d Use plus-equals operator (Tobin C. Harding) 922b820 Replace assert!(false) with panic! (Tobin C. Harding) a8039e1 Remove redundant clone (Tobin C. Harding) cf8de73 Remove unnecessary cast of integer literal (Tobin C. Harding) 999ac45 Do not use assert_eq with literal bool (Tobin C. Harding) 827fcd8 Allow unusual digit grouping (Tobin C. Harding) 242c640 Remove redundant field names (Tobin C. Harding) 0f8f4c5 Collapse if statements (Tobin C. Harding) 229fcb9 Use if let instead of destructuring pattern (Tobin C. Harding) Pull request description: Clear all the clippy warnings (excl. #1042) that are returned by running `cargo clippy --all-targets`. I apologize in advance for the review burden :) ACKs for top commit: elichai: ACK 271d0ba apoelstra: ACK 271d0ba Tree-SHA512: 71ad2ec3db808e795791b7513f8b2a1c13dc90317f5328602c9ecbc31c09f82471f79c9c31a71a0ded5280554d1019d2bb4899fb9e8fa6421d46a2397cd31242
diff --git a/src/blockdata/block.rs b/src/blockdata/block.rs
@@ -517,15 +517,15 @@ mod tests {
         // test with zero target
         match some_header.validate_pow(&Uint256::default()) {
             Err(BlockBadTarget) => (),
-            _ => assert!(false)
+            _ => panic!("unexpected result from validate_pow"),
         }
 
         // test with modified header
-        let mut invalid_header: BlockHeader = some_header.clone();
-        invalid_header.version = invalid_header.version + 1;
+        let mut invalid_header: BlockHeader = some_header;
+        invalid_header.version += 1;
         match invalid_header.validate_pow(&invalid_header.target()) {
             Err(BlockBadProofOfWork) => (),
-            _ => assert!(false)
+            _ => panic!("unexpected result from validate_pow"),
         }
     }
 
diff --git a/src/blockdata/script.rs b/src/blockdata/script.rs
@@ -1329,18 +1329,18 @@ mod test {
     #[test]
     fn provably_unspendable_test() {
         // p2pk
-        assert_eq!(hex_script!("410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac").is_provably_unspendable(), false);
-        assert_eq!(hex_script!("4104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac").is_provably_unspendable(), false);
+        assert!(!hex_script!("410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac").is_provably_unspendable());
+        assert!(!hex_script!("4104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac").is_provably_unspendable());
         // p2pkhash
-        assert_eq!(hex_script!("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac").is_provably_unspendable(), false);
-        assert_eq!(hex_script!("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87").is_provably_unspendable(), true);
+        assert!(!hex_script!("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac").is_provably_unspendable());
+        assert!(hex_script!("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87").is_provably_unspendable());
     }
 
     #[test]
     fn op_return_test() {
-        assert_eq!(hex_script!("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87").is_op_return(), true);
-        assert_eq!(hex_script!("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac").is_op_return(), false);
-        assert_eq!(hex_script!("").is_op_return(), false);
+        assert!(hex_script!("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87").is_op_return());
+        assert!(!hex_script!("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac").is_op_return());
+        assert!(!hex_script!("").is_op_return());
     }
 
     #[test]
diff --git a/src/blockdata/transaction.rs b/src/blockdata/transaction.rs
@@ -1009,7 +1009,7 @@ mod tests {
         assert_eq!(txin.script_sig, Script::new());
         assert_eq!(txin.sequence, 0xFFFFFFFF);
         assert_eq!(txin.previous_output, OutPoint::default());
-        assert_eq!(txin.witness.len(), 0 as usize);
+        assert_eq!(txin.witness.len(), 0);
     }
 
     #[test]
@@ -1092,7 +1092,7 @@ mod tests {
         let expected_strippedsize = (EXPECTED_WEIGHT - tx_bytes.len()) / (WITNESS_SCALE_FACTOR - 1);
         assert_eq!(realtx.strippedsize(), expected_strippedsize);
         // Construct a transaction without the witness data.
-        let mut tx_without_witness = realtx.clone();
+        let mut tx_without_witness = realtx;
         tx_without_witness.input.iter_mut().for_each(|input| input.witness.clear());
         assert_eq!(tx_without_witness.weight(), expected_strippedsize*WITNESS_SCALE_FACTOR);
         assert_eq!(tx_without_witness.size(), expected_strippedsize);
diff --git a/src/network/message.rs b/src/network/message.rs
@@ -597,7 +597,7 @@ mod test {
             assert_eq!(version_msg.nonce, 13952548347456104954);
             assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");
             assert_eq!(version_msg.start_height, 560275);
-            assert_eq!(version_msg.relay, true);
+            assert!(version_msg.relay);
         } else {
             panic!("Wrong message type");
         }
@@ -634,7 +634,7 @@ mod test {
             assert_eq!(version_msg.nonce, 13952548347456104954);
             assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");
             assert_eq!(version_msg.start_height, 560275);
-            assert_eq!(version_msg.relay, true);
+            assert!(version_msg.relay);
         } else {
             panic!("Wrong message type");
         }
diff --git a/src/network/message_network.rs b/src/network/message_network.rs
@@ -170,7 +170,7 @@ mod tests {
         assert_eq!(real_decode.nonce, 16735069437859780935);
         assert_eq!(real_decode.user_agent, "/Satoshi:0.9.99/".to_string());
         assert_eq!(real_decode.start_height, 302892);
-        assert_eq!(real_decode.relay, true);
+        assert!(real_decode.relay);
 
         assert_eq!(serialize(&real_decode), from_sat);
     }
diff --git a/src/network/stream_reader.rs b/src/network/stream_reader.rs
@@ -139,7 +139,7 @@ mod test {
             assert_eq!(version_msg.nonce, 13952548347456104954);
             assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");
             assert_eq!(version_msg.start_height, 560275);
-            assert_eq!(version_msg.relay, true);
+            assert!(version_msg.relay);
         } else {
             panic!("Wrong message type: expected VersionMessage");
         }
diff --git a/src/util/address.rs b/src/util/address.rs
@@ -693,10 +693,10 @@ impl Address {
 
     /// Constructs an [`Address`] from an output script (`scriptPubkey`).
     pub fn from_script(script: &script::Script, network: Network) -> Option<Address> {
-        if script.is_witness_program() {
-            if script.witness_version() == Some(WitnessVersion::V0) && !(script.is_v0_p2wpkh() || script.is_v0_p2wsh()) {
+        if script.is_witness_program()
+            && script.witness_version() == Some(WitnessVersion::V0)
+            && !(script.is_v0_p2wpkh() || script.is_v0_p2wsh()) {
                 return None
-            }
         }
 
         Some(Address {
@@ -988,7 +988,7 @@ mod tests {
         let addr = Address::p2pkh(&key, Bitcoin);
         assert_eq!(&addr.to_string(), "1QJVDzdqb1VpbDK7uDeyVXy9mR27CJiyhY");
 
-        let key = hex_key!(&"03df154ebfcf29d29cc10d5c2565018bce2d9edbab267c31d2caf44a63056cf99f");
+        let key = hex_key!("03df154ebfcf29d29cc10d5c2565018bce2d9edbab267c31d2caf44a63056cf99f");
         let addr = Address::p2pkh(&key, Testnet);
         assert_eq!(&addr.to_string(), "mqkhEMH6NCeYjFybv7pvFC22MFeaNT9AQC");
         assert_eq!(addr.address_type(), Some(AddressType::P2pkh));
@@ -1086,7 +1086,7 @@ mod tests {
         let addr = Address {
             payload: Payload::WitnessProgram {
                 version: WitnessVersion::V13,
-                program: program,
+                program,
             },
             network: Network::Bitcoin,
         };
@@ -1108,7 +1108,7 @@ mod tests {
             ("bc1zw508d6qejxtdg4y5r3zarvaryvaxxpcs", None),
         ];
         for (address, expected_type) in &addresses {
-            let addr = Address::from_str(&address).unwrap();
+            let addr = Address::from_str(address).unwrap();
             assert_eq!(&addr.address_type(), expected_type);
         }
     }
@@ -1292,11 +1292,10 @@ mod tests {
 
         fn test_addr_type(payloads: &[Payload], equivalence_classes: &[&[Network]]) {
             for pl in payloads {
-                for addr_net in equivalence_classes.iter().map(|ec| ec.iter()).flatten() {
+                for addr_net in equivalence_classes.iter().flat_map(|ec| ec.iter()) {
                     for valid_net in equivalence_classes.iter()
                         .filter(|ec| ec.contains(addr_net))
-                        .map(|ec| ec.iter())
-                        .flatten()
+                        .flat_map(|ec| ec.iter())
                     {
                         let addr = Address {
                             payload: pl.clone(),
@@ -1307,8 +1306,7 @@ mod tests {
 
                     for invalid_net in equivalence_classes.iter()
                         .filter(|ec| !ec.contains(addr_net))
-                        .map(|ec| ec.iter())
-                        .flatten()
+                        .flat_map(|ec| ec.iter())
                     {
                         let addr = Address {
                             payload: pl.clone(),
diff --git a/src/util/amount.rs b/src/util/amount.rs
@@ -1599,6 +1599,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
     fn parsing() {
         use super::ParseAmountError as E;
         let btc = Denomination::Bitcoin;
@@ -1868,6 +1869,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
     fn from_str() {
         use super::ParseAmountError as E;
         let p = Amount::from_str;
@@ -1906,6 +1908,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
     fn to_from_string_in() {
         use super::Denomination as D;
         let ua_str = Amount::from_str_in;
diff --git a/src/util/base58.rs b/src/util/base58.rs
@@ -299,7 +299,7 @@ mod tests {
         assert_eq!(&encode_slice(&[0, 0, 0, 0, 13, 36][..]), "1111211");
 
         // Long input (>100 bytes => has to use heap)
-        let res = encode_slice(&"BitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBit\
+        let res = encode_slice("BitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBit\
         coinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoin".as_bytes());
         let exp = "ZqC5ZdfpZRi7fjA8hbhX5pEE96MdH9hEaC1YouxscPtbJF16qVWksHWR4wwvx7MotFcs2ChbJqK8KJ9X\
         wZznwWn1JFDhhTmGo9v6GjAVikzCsBWZehu7bm22xL8b5zBR5AsBygYRwbFJsNwNkjpyFuDKwmsUTKvkULCvucPJrN5\
diff --git a/src/util/bip143.rs b/src/util/bip143.rs
@@ -201,8 +201,7 @@ mod tests {
 
     fn p2pkh_hex(pk: &str) -> Script {
         let pk: PublicKey = PublicKey::from_str(pk).unwrap();
-        let witness_script = Address::p2pkh(&pk, Network::Bitcoin).script_pubkey();
-        witness_script
+        Address::p2pkh(&pk, Network::Bitcoin).script_pubkey()
     }
 
     fn run_test_sighash_bip143(tx: &str, script: &str, input_index: usize, value: u64, hash_type: u32, expected_result: &str) {
diff --git a/src/util/bip158.rs b/src/util/bip158.rs
@@ -542,27 +542,27 @@ mod test {
 
         let testdata = serde_json::from_str::<Value>(data).unwrap().as_array().unwrap().clone();
         for t in testdata.iter().skip(1) {
-            let block_hash = BlockHash::from_hex(&t.get(1).unwrap().as_str().unwrap()).unwrap();
-            let block: Block = deserialize(&Vec::from_hex(&t.get(2).unwrap().as_str().unwrap()).unwrap()).unwrap();
+            let block_hash = BlockHash::from_hex(t.get(1).unwrap().as_str().unwrap()).unwrap();
+            let block: Block = deserialize(&Vec::from_hex(t.get(2).unwrap().as_str().unwrap()).unwrap()).unwrap();
             assert_eq!(block.block_hash(), block_hash);
             let scripts = t.get(3).unwrap().as_array().unwrap();
-            let previous_filter_header = FilterHeader::from_hex(&t.get(4).unwrap().as_str().unwrap()).unwrap();
-            let filter_content = Vec::from_hex(&t.get(5).unwrap().as_str().unwrap()).unwrap();
-            let filter_header = FilterHeader::from_hex(&t.get(6).unwrap().as_str().unwrap()).unwrap();
+            let previous_filter_header = FilterHeader::from_hex(t.get(4).unwrap().as_str().unwrap()).unwrap();
+            let filter_content = Vec::from_hex(t.get(5).unwrap().as_str().unwrap()).unwrap();
+            let filter_header = FilterHeader::from_hex(t.get(6).unwrap().as_str().unwrap()).unwrap();
 
             let mut txmap = HashMap::new();
             let mut si = scripts.iter();
             for tx in block.txdata.iter().skip(1) {
                 for input in tx.input.iter() {
-                    txmap.insert(input.previous_output.clone(), Script::from(Vec::from_hex(si.next().unwrap().as_str().unwrap()).unwrap()));
+                    txmap.insert(input.previous_output, Script::from(Vec::from_hex(si.next().unwrap().as_str().unwrap()).unwrap()));
                 }
             }
 
             let filter = BlockFilter::new_script_filter(&block,
                                         |o| if let Some(s) = txmap.get(o) {
                                             Ok(s.clone())
                                         } else {
-                                            Err(Error::UtxoMissing(o.clone()))
+                                            Err(Error::UtxoMissing(*o))
                                         }).unwrap();
 
             let test_filter = BlockFilter::new(filter_content.as_slice());
@@ -573,10 +573,10 @@ mod test {
             assert!(filter.match_all(block_hash, &mut txmap.iter()
                 .filter_map(|(_, s)| if !s.is_empty() { Some(s.as_bytes()) } else { None })).unwrap());
 
-            for (_, script) in &txmap {
+            for script in txmap.values() {
                 let query = vec![script];
                 if !script.is_empty () {
-                    assert!(filter.match_any(&block_hash, &mut query.iter()
+                    assert!(filter.match_any(block_hash, &mut query.iter()
                         .map(|s| s.as_bytes())).unwrap());
                 }
             }
@@ -618,19 +618,13 @@ mod test {
         let bytes = out;
 
         {
-            let mut query = Vec::new();
-            query.push(Vec::from_hex("abcdef").unwrap());
-            query.push(Vec::from_hex("eeeeee").unwrap());
-
+            let query = vec![Vec::from_hex("abcdef").unwrap(), Vec::from_hex("eeeeee").unwrap()];
             let reader = GCSFilterReader::new(0, 0, M, P);
             let mut input = Cursor::new(bytes.clone());
             assert!(reader.match_any(&mut input, &mut query.iter().map(|v| v.as_slice())).unwrap());
         }
         {
-            let mut query = Vec::new();
-            query.push(Vec::from_hex("abcdef").unwrap());
-            query.push(Vec::from_hex("123456").unwrap());
-
+            let query = vec![Vec::from_hex("abcdef").unwrap(), Vec::from_hex("123456").unwrap()];
             let reader = GCSFilterReader::new(0, 0, M, P);
             let mut input = Cursor::new(bytes.clone());
             assert!(!reader.match_any(&mut input, &mut query.iter().map(|v| v.as_slice())).unwrap());
@@ -651,7 +645,7 @@ mod test {
                 query.push(p.clone());
             }
             query.push(Vec::from_hex("abcdef").unwrap());
-            let mut input = Cursor::new(bytes.clone());
+            let mut input = Cursor::new(bytes);
             assert!(!reader.match_all(&mut input, &mut query.iter().map(|v| v.as_slice())).unwrap());
         }
     }
diff --git a/src/util/key.rs b/src/util/key.rs
@@ -497,7 +497,7 @@ mod tests {
         // testnet compressed
         let sk = PrivateKey::from_wif("cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy").unwrap();
         assert_eq!(sk.network, Testnet);
-        assert_eq!(sk.compressed, true);
+        assert!(sk.compressed);
         assert_eq!(&sk.to_wif(), "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy");
 
         let secp = Secp256k1::new();
@@ -513,12 +513,12 @@ mod tests {
         // mainnet uncompressed
         let sk = PrivateKey::from_wif("5JYkZjmN7PVMjJUfJWfRFwtuXTGB439XV6faajeHPAM9Z2PT2R3").unwrap();
         assert_eq!(sk.network, Bitcoin);
-        assert_eq!(sk.compressed, false);
+        assert!(!sk.compressed);
         assert_eq!(&sk.to_wif(), "5JYkZjmN7PVMjJUfJWfRFwtuXTGB439XV6faajeHPAM9Z2PT2R3");
 
         let secp = Secp256k1::new();
         let mut pk = sk.public_key(&secp);
-        assert_eq!(pk.compressed, false);
+        assert!(!pk.compressed);
         assert_eq!(&pk.to_string(), "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133");
         assert_eq!(pk, PublicKey::from_str("042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133").unwrap());
         let addr = Address::p2pkh(&pk, sk.network);
diff --git a/src/util/psbt/map/input.rs b/src/util/psbt/map/input.rs
@@ -178,9 +178,8 @@ impl FromStr for PsbtSighashType {
         // NB: some of Schnorr sighash types are non-standard for pre-taproot
         // inputs. We also do not support SIGHASH_RESERVED in verbatim form
         // ("0xFF" string should be used instead).
-        match SchnorrSighashType::from_str(s) {
-            Ok(ty) => return Ok(ty.into()),
-            Err(_) => {}
+        if let Ok(ty) = SchnorrSighashType::from_str(s) {
+            return Ok(ty.into());
         }
 
         // We accept non-standard sighash values.
diff --git a/src/util/psbt/mod.rs b/src/util/psbt/mod.rs
@@ -358,7 +358,7 @@ mod tests {
     use crate::blockdata::transaction::{Transaction, TxIn, TxOut, OutPoint};
     use crate::network::constants::Network::Bitcoin;
     use crate::consensus::encode::{deserialize, serialize, serialize_hex};
-    use crate::util::bip32::{ChildNumber, ExtendedPrivKey, ExtendedPubKey, Fingerprint, KeySource};
+    use crate::util::bip32::{ChildNumber, ExtendedPrivKey, ExtendedPubKey, KeySource};
     use crate::util::psbt::map::{Output, Input};
     use crate::util::psbt::raw;
 
@@ -404,7 +404,7 @@ mod tests {
 
         let mut sk: ExtendedPrivKey = ExtendedPrivKey::new_master(Bitcoin, &seed).unwrap();
 
-        let fprint: Fingerprint = sk.fingerprint(&secp);
+        let fprint = sk.fingerprint(secp);
 
         let dpath: Vec<ChildNumber> = vec![
             ChildNumber::from_normal_idx(0).unwrap(),
@@ -419,7 +419,7 @@ mod tests {
 
         sk = sk.derive_priv(secp, &dpath).unwrap();
 
-        let pk: ExtendedPubKey = ExtendedPubKey::from_priv(&secp, &sk);
+        let pk = ExtendedPubKey::from_priv(secp, &sk);
 
         hd_keypaths.insert(pk.public_key, (fprint, dpath.into()));
 
@@ -803,7 +803,7 @@ mod tests {
 
             assert!(&psbt.inputs[0].final_script_sig.is_some());
 
-            let redeem_script: &Script = &psbt.inputs[1].redeem_script.as_ref().unwrap();
+            let redeem_script = psbt.inputs[1].redeem_script.as_ref().unwrap();
             let expected_out = hex_script!("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787");
 
             assert!(redeem_script.is_v0_p2wpkh());
@@ -849,7 +849,7 @@ mod tests {
             assert!(&psbt.inputs[0].final_script_sig.is_none());
             assert!(&psbt.inputs[1].final_script_sig.is_none());
 
-            let redeem_script: &Script = &psbt.inputs[1].redeem_script.as_ref().unwrap();
+            let redeem_script = psbt.inputs[1].redeem_script.as_ref().unwrap();
             let expected_out = hex_script!("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787");
 
             assert!(redeem_script.is_v0_p2wpkh());
@@ -860,7 +860,7 @@ mod tests {
             assert_eq!(redeem_script.to_p2sh(), expected_out);
 
             for output in psbt.outputs {
-                assert!(output.get_pairs().unwrap().len() > 0)
+                assert!(!output.get_pairs().unwrap().is_empty())
             }
         }
 
@@ -873,7 +873,7 @@ mod tests {
 
             assert!(&psbt.inputs[0].final_script_sig.is_none());
 
-            let redeem_script: &Script = &psbt.inputs[0].redeem_script.as_ref().unwrap();
+            let redeem_script = psbt.inputs[0].redeem_script.as_ref().unwrap();
             let expected_out = hex_script!("a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87");
 
             assert!(redeem_script.is_v0_p2wsh());
diff --git a/src/util/psbt/serialize.rs b/src/util/psbt/serialize.rs
@@ -393,7 +393,7 @@ mod tests {
         let mut builder = compose_taproot_builder(0x51, &[2, 2, 2]);
         builder = builder.add_leaf_with_ver(3, Script::from_hex("b9").unwrap(), LeafVersion::from_consensus(0xC2).unwrap()).unwrap();
         builder = builder.add_hidden_node(3, sha256::Hash::default()).unwrap();
-        assert!(TapTree::from_builder(builder.clone()).is_err());
+        assert!(TapTree::from_builder(builder).is_err());
     }
 
     #[test]
diff --git a/src/util/sighash.rs b/src/util/sighash.rs
diff --git a/src/util/taproot.rs b/src/util/taproot.rs

Original file line number	Diff line number	Diff line change
`@@ -517,15 +517,15 @@ mod tests {`
`517`	`517`	`// test with zero target`
`518`	`518`	`match some_header.validate_pow(&Uint256::default()) {`
`519`	`519`	`Err(BlockBadTarget) => (),`
`520`		`- _ => assert!(false)`
	`520`	`+ _ => panic!("unexpected result from validate_pow"),`
`521`	`521`	`}`
`522`	`522`
`523`	`523`	`// test with modified header`
`524`		`- let mut invalid_header: BlockHeader = some_header.clone();`
`525`		`- invalid_header.version = invalid_header.version + 1;`
	`524`	`+ let mut invalid_header: BlockHeader = some_header;`
	`525`	`+ invalid_header.version += 1;`
`526`	`526`	`match invalid_header.validate_pow(&invalid_header.target()) {`
`527`	`527`	`Err(BlockBadProofOfWork) => (),`
`528`		`- _ => assert!(false)`
	`528`	`+ _ => panic!("unexpected result from validate_pow"),`
`529`	`529`	`}`
`530`	`530`	`}`
`531`	`531`
Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ mod tests {`
`170`	`170`	`assert_eq!(real_decode.nonce, 16735069437859780935);`
`171`	`171`	`assert_eq!(real_decode.user_agent, "/Satoshi:0.9.99/".to_string());`
`172`	`172`	`assert_eq!(real_decode.start_height, 302892);`
`173`		`- assert_eq!(real_decode.relay, true);`
	`173`	`+ assert!(real_decode.relay);`
`174`	`174`
`175`	`175`	`assert_eq!(serialize(&real_decode), from_sat);`
`176`	`176`	`}`
Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@ mod test {`
`139`	`139`	`assert_eq!(version_msg.nonce, 13952548347456104954);`
`140`	`140`	`assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");`
`141`	`141`	`assert_eq!(version_msg.start_height, 560275);`
`142`		`- assert_eq!(version_msg.relay, true);`
	`142`	`+ assert!(version_msg.relay);`
`143`	`143`	`} else {`
`144`	`144`	`panic!("Wrong message type: expected VersionMessage");`
`145`	`145`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1599,6 +1599,7 @@ mod tests {`
`1599`	`1599`	`}`
`1600`	`1600`
`1601`	`1601`	`#[test]`
	`1602`	`+ #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.`
`1602`	`1603`	`fn parsing() {`
`1603`	`1604`	`use super::ParseAmountError as E;`
`1604`	`1605`	`let btc = Denomination::Bitcoin;`
`@@ -1868,6 +1869,7 @@ mod tests {`
`1868`	`1869`	`}`
`1869`	`1870`
`1870`	`1871`	`#[test]`
	`1872`	`+ #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.`
`1871`	`1873`	`fn from_str() {`
`1872`	`1874`	`use super::ParseAmountError as E;`
`1873`	`1875`	`let p = Amount::from_str;`
`@@ -1906,6 +1908,7 @@ mod tests {`
`1906`	`1908`	`}`
`1907`	`1909`
`1908`	`1910`	`#[test]`
	`1911`	`+ #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.`
`1909`	`1912`	`fn to_from_string_in() {`
`1910`	`1913`	`use super::Denomination as D;`
`1911`	`1914`	`let ua_str = Amount::from_str_in;`
Original file line number	Diff line number	Diff line change
`@@ -201,8 +201,7 @@ mod tests {`
`201`	`201`
`202`	`202`	`fn p2pkh_hex(pk: &str) -> Script {`
`203`	`203`	`let pk: PublicKey = PublicKey::from_str(pk).unwrap();`
`204`		`- let witness_script = Address::p2pkh(&pk, Network::Bitcoin).script_pubkey();`
`205`		`- witness_script`
	`204`	`+ Address::p2pkh(&pk, Network::Bitcoin).script_pubkey()`
`206`	`205`	`}`
`207`	`206`
`208`	`207`	`fn run_test_sighash_bip143(tx: &str, script: &str, input_index: usize, value: u64, hash_type: u32, expected_result: &str) {`