From d5110ced91b4c2f7d0d9716532b9b93a34b372fb Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 31 Jul 2022 07:00:37 +0200 Subject: [PATCH] Fix clippy warnings --- src/blob/mod.rs | 12 ++++----- src/blob/pos_io.rs | 30 ++++++++++----------- src/functions.rs | 2 +- src/lib.rs | 14 +++++----- src/row.rs | 6 ++--- src/statement.rs | 7 +++-- src/types/chrono.rs | 16 +++++------ src/types/time.rs | 4 +-- src/types/to_sql.rs | 24 ++++++++--------- src/util/small_cstr.rs | 6 ++--- tests/deny_single_threaded_sqlite_config.rs | 2 +- 11 files changed, 59 insertions(+), 64 deletions(-) diff --git a/src/blob/mod.rs b/src/blob/mod.rs index 81c6098..38e0b1d 100644 --- a/src/blob/mod.rs +++ b/src/blob/mod.rs @@ -473,14 +473,14 @@ mod test { assert_eq!(&bytes, b"Clob5"); // should not be able to seek negative or past end - assert!(blob.seek(SeekFrom::Current(-20)).is_err()); - assert!(blob.seek(SeekFrom::End(0)).is_ok()); - assert!(blob.seek(SeekFrom::Current(1)).is_err()); + blob.seek(SeekFrom::Current(-20)).unwrap_err(); + blob.seek(SeekFrom::End(0)).unwrap(); + blob.seek(SeekFrom::Current(1)).unwrap_err(); // write_all should detect when we return Ok(0) because there is no space left, // and return a write error blob.reopen(rowid)?; - assert!(blob.write_all(b"0123456789x").is_err()); + blob.write_all(b"0123456789x").unwrap_err(); Ok(()) } @@ -519,7 +519,7 @@ mod test { // trying to write too much and then flush should fail assert_eq!(8, writer.write(b"01234567").unwrap()); assert_eq!(8, writer.write(b"01234567").unwrap()); - assert!(writer.flush().is_err()); + writer.flush().unwrap_err(); } { @@ -536,7 +536,7 @@ mod test { // trying to write_all too much should fail writer.write_all(b"aaaaaaaaaabbbbb").unwrap(); - assert!(writer.flush().is_err()); + writer.flush().unwrap_err(); } { diff --git a/src/blob/pos_io.rs b/src/blob/pos_io.rs index ecc7d65..5d4a3c8 100644 --- a/src/blob/pos_io.rs +++ b/src/blob/pos_io.rs @@ -214,7 +214,7 @@ mod test { let mut s = [0u8; 10]; blob.read_at_exact(&mut s, 0).unwrap(); assert_eq!(&s, &one2ten, "write should go through"); - assert!(blob.read_at_exact(&mut s, 1).is_err()); + blob.read_at_exact(&mut s, 1).unwrap_err(); blob.read_at_exact(&mut s, 0).unwrap(); assert_eq!(&s, &one2ten, "should be unchanged"); @@ -225,13 +225,13 @@ mod test { blob.read_at_exact(&mut fives, 5).unwrap(); assert_eq!(&fives, &[6u8, 7, 8, 9, 10]); - assert!(blob.read_at_exact(&mut fives, 7).is_err()); - assert!(blob.read_at_exact(&mut fives, 12).is_err()); - assert!(blob.read_at_exact(&mut fives, 10).is_err()); - assert!(blob.read_at_exact(&mut fives, i32::MAX as usize).is_err()); - assert!(blob - .read_at_exact(&mut fives, i32::MAX as usize + 1) - .is_err()); + blob.read_at_exact(&mut fives, 7).unwrap_err(); + blob.read_at_exact(&mut fives, 12).unwrap_err(); + blob.read_at_exact(&mut fives, 10).unwrap_err(); + blob.read_at_exact(&mut fives, i32::MAX as usize) + .unwrap_err(); + blob.read_at_exact(&mut fives, i32::MAX as usize + 1) + .unwrap_err(); // zero length writes are fine if in bounds blob.read_at_exact(&mut [], 10).unwrap(); @@ -242,13 +242,11 @@ mod test { blob.read_at_exact(&mut s, 0).unwrap(); assert_eq!(&s, &[1u8, 2, 3, 4, 5, 16, 17, 18, 19, 20]); - assert!(blob.write_at(&[100, 99, 98, 97, 96], 6).is_err()); - assert!(blob - .write_at(&[100, 99, 98, 97, 96], i32::MAX as usize) - .is_err()); - assert!(blob - .write_at(&[100, 99, 98, 97, 96], i32::MAX as usize + 1) - .is_err()); + blob.write_at(&[100, 99, 98, 97, 96], 6).unwrap_err(); + blob.write_at(&[100, 99, 98, 97, 96], i32::MAX as usize) + .unwrap_err(); + blob.write_at(&[100, 99, 98, 97, 96], i32::MAX as usize + 1) + .unwrap_err(); blob.read_at_exact(&mut s, 0).unwrap(); assert_eq!(&s, &[1u8, 2, 3, 4, 5, 16, 17, 18, 19, 20]); @@ -265,7 +263,7 @@ mod test { blob.raw_read_at_exact(&mut empty, 0).unwrap().as_ptr(), empty.as_ptr().cast(), )); - assert!(blob.raw_read_at_exact(&mut s2, 5).is_err()); + blob.raw_read_at_exact(&mut s2, 5).unwrap_err(); let end_pos = blob.seek(std::io::SeekFrom::Current(0)).unwrap(); assert_eq!(end_pos, 1); diff --git a/src/functions.rs b/src/functions.rs index 138baac..8966348 100644 --- a/src/functions.rs +++ b/src/functions.rs @@ -849,7 +849,7 @@ mod test { db.remove_function("half", 1)?; let result: Result = db.query_row("SELECT half(6)", [], |r| r.get(0)); - assert!(result.is_err()); + result.unwrap_err(); Ok(()) } diff --git a/src/lib.rs b/src/lib.rs index 89f133e..4587502 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1286,17 +1286,16 @@ mod test { #[test] fn test_open() { - assert!(Connection::open_in_memory().is_ok()); + Connection::open_in_memory().unwrap(); let db = checked_memory_handle(); - assert!(db.close().is_ok()); + db.close().unwrap(); } #[test] fn test_open_failure() { let filename = "no_such_file.db"; let result = Connection::open_with_flags(filename, OpenFlags::SQLITE_OPEN_READ_ONLY); - assert!(result.is_err()); let err = result.unwrap_err(); if let Error::SqliteFailure(e, Some(msg)) = err { assert_eq!(ErrorCode::CannotOpen, e.code); @@ -1391,7 +1390,7 @@ mod test { OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_READ_WRITE, OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_CREATE, ] { - assert!(Connection::open_in_memory_with_flags(*bad_flags).is_err()); + Connection::open_in_memory_with_flags(*bad_flags).unwrap_err(); } } @@ -1409,7 +1408,7 @@ mod test { db.execute_batch("UPDATE foo SET x = 3 WHERE x < 3")?; - assert!(db.execute_batch("INVALID SQL").is_err()); + db.execute_batch("INVALID SQL").unwrap_err(); Ok(()) } @@ -1572,7 +1571,7 @@ mod test { let bad_query_result = db.query_row("NOT A PROPER QUERY; test123", [], |_| Ok(())); - assert!(bad_query_result.is_err()); + bad_query_result.unwrap_err(); Ok(()) } @@ -1596,7 +1595,7 @@ mod test { let bad_query_result: Result = db.query_row("NOT A PROPER QUERY", [], |r| r.get(0)); let bad_query_result = bad_query_result.optional(); - assert!(bad_query_result.is_err()); + bad_query_result.unwrap_err(); Ok(()) } @@ -1707,7 +1706,6 @@ mod test { db.execute_batch("CREATE TABLE foo(x NOT NULL)")?; let result = db.execute("INSERT INTO foo (x) VALUES (NULL)", []); - assert!(result.is_err()); match result.unwrap_err() { Error::SqliteFailure(err, _) => { diff --git a/src/row.rs b/src/row.rs index 221905a..2c10f3e 100644 --- a/src/row.rs +++ b/src/row.rs @@ -391,7 +391,7 @@ impl RowIndex for usize { impl RowIndex for &'_ str { #[inline] fn idx(&self, stmt: &Statement<'_>) -> Result { - stmt.column_index(*self) + stmt.column_index(self) } } @@ -448,7 +448,7 @@ mod tests { let val = conn.query_row("SELECT a FROM test", [], |row| <(u32,)>::try_from(row))?; assert_eq!(val, (42,)); let fail = conn.query_row("SELECT a FROM test", [], |row| <(u32, u32)>::try_from(row)); - assert!(fail.is_err()); + fail.unwrap_err(); Ok(()) } @@ -466,7 +466,7 @@ mod tests { let fail = conn.query_row("SELECT a, b FROM test", [], |row| { <(u32, u32, u32)>::try_from(row) }); - assert!(fail.is_err()); + fail.unwrap_err(); Ok(()) } diff --git a/src/statement.rs b/src/statement.rs index ee5e220..6b0e342 100644 --- a/src/statement.rs +++ b/src/statement.rs @@ -1474,10 +1474,10 @@ mod test { let conn = Connection::open_in_memory()?; let mut stmt = conn.prepare("")?; assert_eq!(0, stmt.column_count()); - assert!(stmt.parameter_index("test").is_ok()); - assert!(stmt.step().is_err()); + stmt.parameter_index("test").unwrap(); + stmt.step().unwrap_err(); stmt.reset(); - assert!(stmt.execute([]).is_err()); + stmt.execute([]).unwrap_err(); Ok(()) } @@ -1542,7 +1542,6 @@ mod test { use crate::ffi::ErrorCode; let db = Connection::open_in_memory()?; let r = db.execute_batch("SELECT CURRENT_TIMESTANP;"); - assert!(r.is_err()); match r.unwrap_err() { Error::SqlInputError { error, offset, .. } => { assert_eq!(error.code, ErrorCode::Unknown); diff --git a/src/types/chrono.rs b/src/types/chrono.rs index 6bfc2f4..b84da30 100644 --- a/src/types/chrono.rs +++ b/src/types/chrono.rs @@ -287,15 +287,15 @@ mod test { fn test_sqlite_functions() -> Result<()> { let db = checked_memory_handle()?; let result: Result = db.query_row("SELECT CURRENT_TIME", [], |r| r.get(0)); - assert!(result.is_ok()); + result.unwrap(); let result: Result = db.query_row("SELECT CURRENT_DATE", [], |r| r.get(0)); - assert!(result.is_ok()); + result.unwrap(); let result: Result = db.query_row("SELECT CURRENT_TIMESTAMP", [], |r| r.get(0)); - assert!(result.is_ok()); + result.unwrap(); let result: Result> = db.query_row("SELECT CURRENT_TIMESTAMP", [], |r| r.get(0)); - assert!(result.is_ok()); + result.unwrap(); Ok(()) } @@ -303,7 +303,7 @@ mod test { fn test_naive_date_time_param() -> Result<()> { let db = checked_memory_handle()?; let result: Result = db.query_row("SELECT 1 WHERE ? BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [Utc::now().naive_utc()], |r| r.get(0)); - assert!(result.is_ok()); + result.unwrap(); Ok(()) } @@ -311,13 +311,13 @@ mod test { fn test_date_time_param() -> Result<()> { let db = checked_memory_handle()?; let result: Result = db.query_row("SELECT 1 WHERE ? BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [Utc::now()], |r| r.get(0)); - assert!(result.is_ok()); + result.unwrap(); Ok(()) } #[test] fn test_lenient_parse_timezone() { - assert!(DateTime::::column_result(ValueRef::Text(b"1970-01-01T00:00:00Z")).is_ok()); - assert!(DateTime::::column_result(ValueRef::Text(b"1970-01-01T00:00:00+00")).is_ok()); + DateTime::::column_result(ValueRef::Text(b"1970-01-01T00:00:00Z")).unwrap(); + DateTime::::column_result(ValueRef::Text(b"1970-01-01T00:00:00+00")).unwrap(); } } diff --git a/src/types/time.rs b/src/types/time.rs index 4e2811e..9adb9db 100644 --- a/src/types/time.rs +++ b/src/types/time.rs @@ -154,7 +154,7 @@ mod test { let db = Connection::open_in_memory()?; let result: Result = db.query_row("SELECT CURRENT_TIMESTAMP", [], |r| r.get(0)); - assert!(result.is_ok()); + result.unwrap(); Ok(()) } @@ -162,7 +162,7 @@ mod test { fn test_param() -> Result<()> { let db = Connection::open_in_memory()?; let result: Result = db.query_row("SELECT 1 WHERE ? BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [OffsetDateTime::now_utc()], |r| r.get(0)); - assert!(result.is_ok()); + result.unwrap(); Ok(()) } } diff --git a/src/types/to_sql.rs b/src/types/to_sql.rs index 4e0d882..a6668c9 100644 --- a/src/types/to_sql.rs +++ b/src/types/to_sql.rs @@ -278,7 +278,7 @@ mod test { let _a: &[&dyn ToSql] = crate::params![a]; let r = ToSql::to_sql(&a); - assert!(r.is_ok()); + r.unwrap(); } #[test] @@ -287,10 +287,10 @@ mod test { let s = "str"; let cow: Cow = Cow::Borrowed(s); let r = cow.to_sql(); - assert!(r.is_ok()); + r.unwrap(); let cow: Cow = Cow::Owned::(String::from(s)); let r = cow.to_sql(); - assert!(r.is_ok()); + r.unwrap(); // Ensure this compiles. let _p: &[&dyn ToSql] = crate::params![cow]; } @@ -301,7 +301,7 @@ mod test { let _s: &[&dyn ToSql] = crate::params![s]; let r = ToSql::to_sql(&s); - assert!(r.is_ok()); + r.unwrap(); } #[test] @@ -310,7 +310,7 @@ mod test { let _s: &[&dyn ToSql] = crate::params![s]; let r = s.to_sql(); - assert!(r.is_ok()); + r.unwrap(); } #[test] @@ -319,7 +319,7 @@ mod test { let _s: &[&dyn ToSql] = crate::params![s]; let r = ToSql::to_sql(&s); - assert!(r.is_ok()); + r.unwrap(); } #[test] @@ -331,32 +331,32 @@ mod test { let s: Rc> = Rc::new(source_str.clone()); let _s: &[&dyn ToSql] = crate::params![s]; let r = s.to_sql(); - assert!(r.is_ok()); + r.unwrap(); let s: Arc> = Arc::new(source_str.clone()); let _s: &[&dyn ToSql] = crate::params![s]; let r = s.to_sql(); - assert!(r.is_ok()); + r.unwrap(); let s: Arc = Arc::from(&*source_str); let _s: &[&dyn ToSql] = crate::params![s]; let r = s.to_sql(); - assert!(r.is_ok()); + r.unwrap(); let s: Arc = Arc::new(source_str.clone()); let _s: &[&dyn ToSql] = crate::params![s]; let r = s.to_sql(); - assert!(r.is_ok()); + r.unwrap(); let s: Rc = Rc::from(&*source_str); let _s: &[&dyn ToSql] = crate::params![s]; let r = s.to_sql(); - assert!(r.is_ok()); + r.unwrap(); let s: Rc = Rc::new(source_str); let _s: &[&dyn ToSql] = crate::params![s]; let r = s.to_sql(); - assert!(r.is_ok()); + r.unwrap(); } #[cfg(feature = "i128_blob")] diff --git a/src/util/small_cstr.rs b/src/util/small_cstr.rs index 78e43bd..1ec7374 100644 --- a/src/util/small_cstr.rs +++ b/src/util/small_cstr.rs @@ -163,8 +163,8 @@ mod test { assert_eq!(SmallCString::new("").unwrap().0.as_slice(), b"\0"); assert_eq!(SmallCString::new("").unwrap().as_bytes_without_nul(), b""); - assert!(SmallCString::new("\0").is_err()); - assert!(SmallCString::new("\0abc").is_err()); - assert!(SmallCString::new("abc\0").is_err()); + SmallCString::new("\0").unwrap_err(); + SmallCString::new("\0abc").unwrap_err(); + SmallCString::new("abc\0").unwrap_err(); } } diff --git a/tests/deny_single_threaded_sqlite_config.rs b/tests/deny_single_threaded_sqlite_config.rs index adfc8e5..7118dab 100644 --- a/tests/deny_single_threaded_sqlite_config.rs +++ b/tests/deny_single_threaded_sqlite_config.rs @@ -16,5 +16,5 @@ fn test_error_when_singlethread_mode() { assert_eq!(ffi::sqlite3_initialize(), ffi::SQLITE_OK); } let res = Connection::open_in_memory(); - assert!(res.is_err()); + res.unwrap_err(); }