clippy fixes

refactor: improve test assertions and streamline SQLx workflow

- Removed unnecessary test thread specification in the SQLx CI workflow.
- Updated test assertions in various modules to use `assert!` for boolean checks instead of `assert_eq!`.
- Enhanced ODBC row conversion to `AnyRow` by moving the implementation outside the tests for better organization.
- Corrected integer literals in tests to remove leading zeros for clarity.

Author: lovasoa

.github/workflows/sqlx.yml

@@ -122,8 +122,6 @@ jobs:
       - run: cargo test
           --no-default-features
           --features any,macros,migrate,sqlite,all-types,runtime-${{ matrix.runtime }}-${{ matrix.tls }}
-          --
-          --test-threads=1
         env:
           DATABASE_URL: sqlite://tests/sqlite/sqlite.db
           RUSTFLAGS: --cfg sqlite_ipaddr

sqlx-core/src/mysql/io/buf_mut.rs

@@ -40,71 +40,71 @@ impl MySqlBufMutExt for Vec<u8> {
 #[test]
 fn test_encodes_int_lenenc_u8() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(0xFA as u64);
+    buf.put_uint_lenenc(0xFA_u64);
 
     assert_eq!(&buf[..], b"\xFA");
 }
 
 #[test]
 fn test_encodes_int_lenenc_u16() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(std::u16::MAX as u64);
+    buf.put_uint_lenenc(u16::MAX as u64);
 
     assert_eq!(&buf[..], b"\xFC\xFF\xFF");
 }
 
 #[test]
 fn test_encodes_int_lenenc_u24() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(0xFF_FF_FF as u64);
+    buf.put_uint_lenenc(0xFF_FF_FF_u64);
 
     assert_eq!(&buf[..], b"\xFD\xFF\xFF\xFF");
 }
 
 #[test]
 fn test_encodes_int_lenenc_u64() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(std::u64::MAX);
+    buf.put_uint_lenenc(u64::MAX);
 
     assert_eq!(&buf[..], b"\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
 }
 
 #[test]
 fn test_encodes_int_lenenc_fb() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(0xFB as u64);
+    buf.put_uint_lenenc(0xFB_u64);
 
     assert_eq!(&buf[..], b"\xFC\xFB\x00");
 }
 
 #[test]
 fn test_encodes_int_lenenc_fc() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(0xFC as u64);
+    buf.put_uint_lenenc(0xFC_u64);
 
     assert_eq!(&buf[..], b"\xFC\xFC\x00");
 }
 
 #[test]
 fn test_encodes_int_lenenc_fd() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(0xFD as u64);
+    buf.put_uint_lenenc(0xFD_u64);
 
     assert_eq!(&buf[..], b"\xFC\xFD\x00");
 }
 
 #[test]
 fn test_encodes_int_lenenc_fe() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(0xFE as u64);
+    buf.put_uint_lenenc(0xFE_u64);
 
     assert_eq!(&buf[..], b"\xFC\xFE\x00");
 }
 
 #[test]
 fn test_encodes_int_lenenc_ff() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(0xFF as u64);
+    buf.put_uint_lenenc(0xFF_u64);
 
     assert_eq!(&buf[..], b"\xFC\xFF\x00");
 }

sqlx-core/src/odbc/row.rs

@@ -52,6 +52,25 @@ mod private {
     impl Sealed for OdbcRow {}
 }
 
+#[cfg(feature = "any")]
+impl From<OdbcRow> for crate::any::AnyRow {
+    fn from(row: OdbcRow) -> Self {
+        let columns = row
+            .columns
+            .iter()
+            .map(|col| crate::any::AnyColumn {
+                kind: crate::any::column::AnyColumnKind::Odbc(col.clone()),
+                type_info: crate::any::AnyTypeInfo::from(col.type_info.clone()),
+            })
+            .collect();
+
+        crate::any::AnyRow {
+            kind: crate::any::row::AnyRowKind::Odbc(row),
+            columns,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -177,22 +196,3 @@ mod tests {
         assert_eq!(columns[2].name, "MixedCase_Col");
     }
 }
-
-#[cfg(feature = "any")]
-impl From<OdbcRow> for crate::any::AnyRow {
-    fn from(row: OdbcRow) -> Self {
-        let columns = row
-            .columns
-            .iter()
-            .map(|col| crate::any::AnyColumn {
-                kind: crate::any::column::AnyColumnKind::Odbc(col.clone()),
-                type_info: crate::any::AnyTypeInfo::from(col.type_info.clone()),
-            })
-            .collect();
-
-        crate::any::AnyRow {
-            kind: crate::any::row::AnyRowKind::Odbc(row),
-            columns,
-        }
-    }
-}

sqlx-core/src/odbc/types/bool.rs

@@ -172,7 +172,7 @@ mod tests {
             },
         );
         let decoded = <bool as Decode<Odbc>>::decode(value)?;
-        assert_eq!(decoded, true);
+        assert!(decoded);
 
         let value = create_test_value_text(
             "0",
@@ -182,7 +182,7 @@ mod tests {
             },
         );
         let decoded = <bool as Decode<Odbc>>::decode(value)?;
-        assert_eq!(decoded, false);
+        assert!(!decoded);
 
         // Test with decimal values
         let value = create_test_value_text(
@@ -193,7 +193,7 @@ mod tests {
             },
         );
         let decoded = <bool as Decode<Odbc>>::decode(value)?;
-        assert_eq!(decoded, true);
+        assert!(decoded);
 
         let value = create_test_value_text(
             "0.0",
@@ -203,7 +203,7 @@ mod tests {
             },
         );
         let decoded = <bool as Decode<Odbc>>::decode(value)?;
-        assert_eq!(decoded, false);
+        assert!(!decoded);
 
         Ok(())
     }
@@ -212,15 +212,15 @@ mod tests {
     fn test_bool_decode_from_float() -> Result<(), BoxDynError> {
         let value = create_test_value_float(1.0, DataType::Double);
         let decoded = <bool as Decode<Odbc>>::decode(value)?;
-        assert_eq!(decoded, true);
+        assert!(decoded);
 
         let value = create_test_value_float(0.0, DataType::Double);
         let decoded = <bool as Decode<Odbc>>::decode(value)?;
-        assert_eq!(decoded, false);
+        assert!(!decoded);
 
         let value = create_test_value_float(42.5, DataType::Double);
         let decoded = <bool as Decode<Odbc>>::decode(value)?;
-        assert_eq!(decoded, true);
+        assert!(decoded);
 
         Ok(())
     }
@@ -229,15 +229,15 @@ mod tests {
     fn test_bool_decode_from_int() -> Result<(), BoxDynError> {
         let value = create_test_value_int(1, DataType::Integer);
         let decoded = <bool as Decode<Odbc>>::decode(value)?;
-        assert_eq!(decoded, true);
+        assert!(decoded);
 
         let value = create_test_value_int(0, DataType::Integer);
         let decoded = <bool as Decode<Odbc>>::decode(value)?;
-        assert_eq!(decoded, false);
+        assert!(!decoded);
 
         let value = create_test_value_int(-1, DataType::Integer);
         let decoded = <bool as Decode<Odbc>>::decode(value)?;
-        assert_eq!(decoded, true);
+        assert!(decoded);
 
         Ok(())
     }
@@ -275,7 +275,7 @@ mod tests {
             },
         );
         let decoded = <bool as Decode<Odbc>>::decode(value)?;
-        assert_eq!(decoded, true);
+        assert!(decoded);
 
         let value = create_test_value_text(
             "  0  ",
@@ -285,7 +285,7 @@ mod tests {
             },
         );
         let decoded = <bool as Decode<Odbc>>::decode(value)?;
-        assert_eq!(decoded, false);
+        assert!(!decoded);
 
         Ok(())
     }

sqlx-core/src/postgres/listener.rs

@@ -450,12 +450,12 @@ fn build_listen_all_query(channels: impl IntoIterator<Item = impl AsRef<str>>) -
 
 #[test]
 fn test_build_listen_all_query_with_single_channel() {
-    let output = build_listen_all_query(&["test"]);
+    let output = build_listen_all_query(["test"]);
     assert_eq!(output.as_str(), r#"LISTEN "test";"#);
 }
 
 #[test]
 fn test_build_listen_all_query_with_multiple_channels() {
-    let output = build_listen_all_query(&["channel.0", "channel.1"]);
+    let output = build_listen_all_query(["channel.0", "channel.1"]);
     assert_eq!(output.as_str(), r#"LISTEN "channel.0";LISTEN "channel.1";"#);
 }

sqlx-core/src/postgres/types/bigdecimal.rs

@@ -339,7 +339,7 @@ mod bigdecimal_to_pgnumeric {
                 sign: PgNumericSign::Positive,
                 scale: 5,
                 weight: -1,
-                digits: vec![0123, 4000]
+                digits: vec![123, 4000]
             }
         );
     }

sqlx-core/src/postgres/types/decimal.rs

@@ -313,7 +313,7 @@ mod decimal_to_pgnumeric {
                 sign: PgNumericSign::Positive,
                 scale: 5,
                 weight: -1,
-                digits: vec![0123, 4000]
+                digits: vec![123, 4000]
             }
         );
     }

sqlx-core/src/query_builder.rs

@@ -599,7 +599,7 @@ mod test {
             query.statement.unwrap_left(),
             "SELECT * FROM users WHERE id = $1"
         );
-        assert_eq!(query.persistent, true);
+        assert!(query.persistent);
     }
 
     #[test]