Use assert!(foo) instead of assert_eq!(foo, true)

It is redundant to pass true/false to `assert_eq!` since `assert!`
already asserts true/false.

This may, however, be controversial if someone thinks that

```
    assert_eq!(foo, false);
```

is more clear than

```
    assert!(!foo);
```

Use `assert!` directly instead of `assert_eq!` with true/false argument.

src/wallet/mod.rs

@@ -3514,7 +3514,7 @@ pub(crate) mod test {
         let (mut psbt, _) = builder.finish().unwrap();
 
         let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
-        assert_eq!(finalized, true);
+        assert!(finalized);
 
         let extracted = psbt.extract_tx();
         assert_eq!(extracted.input[0].witness.len(), 2);
@@ -3531,7 +3531,7 @@ pub(crate) mod test {
         let (mut psbt, _) = builder.finish().unwrap();
 
         let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
-        assert_eq!(finalized, true);
+        assert!(finalized);
 
         let extracted = psbt.extract_tx();
         assert_eq!(extracted.input[0].witness.len(), 2);
@@ -3548,7 +3548,7 @@ pub(crate) mod test {
         let (mut psbt, _) = builder.finish().unwrap();
 
         let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
-        assert_eq!(finalized, true);
+        assert!(finalized);
 
         let extracted = psbt.extract_tx();
         assert_eq!(extracted.input[0].witness.len(), 2);
@@ -3565,7 +3565,7 @@ pub(crate) mod test {
         let (mut psbt, _) = builder.finish().unwrap();
 
         let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
-        assert_eq!(finalized, true);
+        assert!(finalized);
 
         let extracted = psbt.extract_tx();
         assert_eq!(extracted.input[0].witness.len(), 2);
@@ -3583,7 +3583,7 @@ pub(crate) mod test {
         let (mut psbt, _) = builder.finish().unwrap();
 
         let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
-        assert_eq!(finalized, true);
+        assert!(finalized);
 
         let extracted = psbt.extract_tx();
         assert_eq!(extracted.input[0].witness.len(), 2);
@@ -3603,7 +3603,7 @@ pub(crate) mod test {
         assert_eq!(psbt.inputs[0].bip32_derivation.len(), 0);
 
         let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
-        assert_eq!(finalized, true);
+        assert!(finalized);
 
         let extracted = psbt.extract_tx();
         assert_eq!(extracted.input[0].witness.len(), 2);

src/wallet/utils.rs

@@ -201,31 +201,31 @@ mod test {
     #[test]
     fn test_check_nsequence_rbf_msb_set() {
         let result = check_nsequence_rbf(0x80000000, 5000);
-        assert_eq!(result, false);
+        assert!(!result);
     }
 
     #[test]
     fn test_check_nsequence_rbf_lt_csv() {
         let result = check_nsequence_rbf(4000, 5000);
-        assert_eq!(result, false);
+        assert!(!result);
     }
 
     #[test]
     fn test_check_nsequence_rbf_different_unit() {
         let result = check_nsequence_rbf(SEQUENCE_LOCKTIME_TYPE_FLAG + 5000, 5000);
-        assert_eq!(result, false);
+        assert!(!result);
     }
 
     #[test]
     fn test_check_nsequence_rbf_mask() {
         let result = check_nsequence_rbf(0x3f + 10_000, 5000);
-        assert_eq!(result, true);
+        assert!(result);
     }
 
     #[test]
     fn test_check_nsequence_rbf_same_unit_blocks() {
         let result = check_nsequence_rbf(10_000, 5000);
-        assert_eq!(result, true);
+        assert!(result);
     }
 
     #[test]
@@ -234,25 +234,25 @@ mod test {
             SEQUENCE_LOCKTIME_TYPE_FLAG + 10_000,
             SEQUENCE_LOCKTIME_TYPE_FLAG + 5000,
         );
-        assert_eq!(result, true);
+        assert!(result);
     }
 
     #[test]
     fn test_check_nlocktime_lt_cltv() {
         let result = check_nlocktime(4000, 5000);
-        assert_eq!(result, false);
+        assert!(!result);
     }
 
     #[test]
     fn test_check_nlocktime_different_unit() {
         let result = check_nlocktime(BLOCKS_TIMELOCK_THRESHOLD + 5000, 5000);
-        assert_eq!(result, false);
+        assert!(!result);
     }
 
     #[test]
     fn test_check_nlocktime_same_unit_blocks() {
         let result = check_nlocktime(10_000, 5000);
-        assert_eq!(result, true);
+        assert!(result);
     }
 
     #[test]
@@ -261,6 +261,6 @@ mod test {
             BLOCKS_TIMELOCK_THRESHOLD + 10_000,
             BLOCKS_TIMELOCK_THRESHOLD + 5000,
         );
-        assert_eq!(result, true);
+        assert!(result);
     }
 }