unwrap() can be replaced with ?

src/blob/pos_io.rs

@@ -208,21 +208,21 @@ mod test {
         blob.seek(std::io::SeekFrom::Start(1)).unwrap();
 
         let one2ten: [u8; 10] = [1u8, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        blob.write_at(&one2ten, 0).unwrap();
+        blob.write_at(&one2ten, 0)?;
 
         let mut s = [0u8; 10];
-        blob.read_at_exact(&mut s, 0).unwrap();
+        blob.read_at_exact(&mut s, 0)?;
         assert_eq!(&s, &one2ten, "write should go through");
         blob.read_at_exact(&mut s, 1).unwrap_err();
 
-        blob.read_at_exact(&mut s, 0).unwrap();
+        blob.read_at_exact(&mut s, 0)?;
         assert_eq!(&s, &one2ten, "should be unchanged");
 
         let mut fives = [0u8; 5];
-        blob.read_at_exact(&mut fives, 0).unwrap();
+        blob.read_at_exact(&mut fives, 0)?;
         assert_eq!(&fives, &[1u8, 2, 3, 4, 5]);
 
-        blob.read_at_exact(&mut fives, 5).unwrap();
+        blob.read_at_exact(&mut fives, 5)?;
         assert_eq!(&fives, &[6u8, 7, 8, 9, 10]);
         blob.read_at_exact(&mut fives, 7).unwrap_err();
         blob.read_at_exact(&mut fives, 12).unwrap_err();
@@ -233,12 +233,12 @@ mod test {
             .unwrap_err();
 
         // zero length writes are fine if in bounds
-        blob.read_at_exact(&mut [], 10).unwrap();
-        blob.read_at_exact(&mut [], 0).unwrap();
-        blob.read_at_exact(&mut [], 5).unwrap();
+        blob.read_at_exact(&mut [], 10)?;
+        blob.read_at_exact(&mut [], 0)?;
+        blob.read_at_exact(&mut [], 5)?;
 
-        blob.write_all_at(&[16, 17, 18, 19, 20], 5).unwrap();
-        blob.read_at_exact(&mut s, 0).unwrap();
+        blob.write_all_at(&[16, 17, 18, 19, 20], 5)?;
+        blob.read_at_exact(&mut s, 0)?;
         assert_eq!(&s, &[1u8, 2, 3, 4, 5, 16, 17, 18, 19, 20]);
 
         blob.write_at(&[100, 99, 98, 97, 96], 6).unwrap_err();
@@ -247,19 +247,19 @@ mod test {
         blob.write_at(&[100, 99, 98, 97, 96], i32::MAX as usize + 1)
             .unwrap_err();
 
-        blob.read_at_exact(&mut s, 0).unwrap();
+        blob.read_at_exact(&mut s, 0)?;
         assert_eq!(&s, &[1u8, 2, 3, 4, 5, 16, 17, 18, 19, 20]);
 
         let mut s2: [std::mem::MaybeUninit<u8>; 10] = [std::mem::MaybeUninit::uninit(); 10];
         {
-            let read = blob.raw_read_at_exact(&mut s2, 0).unwrap();
+            let read = blob.raw_read_at_exact(&mut s2, 0)?;
             assert_eq!(read, &s);
             assert!(std::ptr::eq(read.as_ptr(), s2.as_ptr().cast()));
         }
 
         let mut empty = [];
         assert!(std::ptr::eq(
-            blob.raw_read_at_exact(&mut empty, 0).unwrap().as_ptr(),
+            blob.raw_read_at_exact(&mut empty, 0)?.as_ptr(),
             empty.as_ptr().cast(),
         ));
         blob.raw_read_at_exact(&mut s2, 5).unwrap_err();

src/hooks/mod.rs

@@ -869,8 +869,7 @@ mod test {
         use super::{AuthAction, AuthContext, Authorization};
 
         let db = Connection::open_in_memory()?;
-        db.execute_batch("CREATE TABLE foo (public TEXT, private TEXT)")
-            .unwrap();
+        db.execute_batch("CREATE TABLE foo (public TEXT, private TEXT)")?;
 
         let authorizer = move |ctx: AuthContext<'_>| match ctx.action {
             AuthAction::Read {
@@ -885,18 +884,16 @@ mod test {
         db.authorizer(Some(authorizer));
         db.execute_batch(
             "BEGIN TRANSACTION; INSERT INTO foo VALUES ('pub txt', 'priv txt'); COMMIT;",
-        )
-        .unwrap();
+        )?;
         db.query_row_and_then("SELECT * FROM foo", [], |row| -> Result<()> {
             assert_eq!(row.get::<_, String>("public")?, "pub txt");
             assert!(row.get::<_, Option<String>>("private")?.is_none());
             Ok(())
-        })
-        .unwrap();
+        })?;
         db.execute_batch("DROP TABLE foo").unwrap_err();
 
         db.authorizer(None::<fn(AuthContext<'_>) -> Authorization>);
-        db.execute_batch("PRAGMA user_version=1").unwrap(); // Disallowed by first authorizer, but it's now removed.
+        db.execute_batch("PRAGMA user_version=1")?; // Disallowed by first authorizer, but it's now removed.
 
         Ok(())
     }

src/lib.rs

@@ -46,7 +46,7 @@
 //!     })?;
 //!
 //!     for person in person_iter {
-//!         println!("Found person {:?}", person.unwrap());
+//!         println!("Found person {:?}", person?);
 //!     }
 //!     Ok(())
 //! }
@@ -2272,11 +2272,11 @@ mod test {
     #[cfg(feature = "modern_sqlite")]
     fn test_db_name() -> Result<()> {
         let db = Connection::open_in_memory()?;
-        assert_eq!(db.db_name(0).unwrap(), "main");
-        assert_eq!(db.db_name(1).unwrap(), "temp");
+        assert_eq!(db.db_name(0)?, "main");
+        assert_eq!(db.db_name(1)?, "temp");
         assert_eq!(db.db_name(2), Err(Error::InvalidDatabaseIndex(2)));
         db.execute_batch("ATTACH DATABASE ':memory:' AS xyz;")?;
-        assert_eq!(db.db_name(2).unwrap(), "xyz");
+        assert_eq!(db.db_name(2)?, "xyz");
         Ok(())
     }
 

src/statement.rs

@@ -1285,9 +1285,9 @@ mod test {
         let conn = Connection::open_in_memory()?;
         let mut stmt = conn.prepare("")?;
         assert_eq!(0, stmt.column_count());
-        stmt.parameter_index("test").unwrap();
+        stmt.parameter_index("test")?;
         stmt.step().unwrap_err();
-        stmt.reset().unwrap(); // SQLITE_OMIT_AUTORESET = false
+        stmt.reset()?; // SQLITE_OMIT_AUTORESET = false
         stmt.execute([]).unwrap_err();
         Ok(())
     }

src/types/chrono.rs

@@ -285,13 +285,13 @@ mod test {
     fn test_sqlite_functions() -> Result<()> {
         let db = checked_memory_handle()?;
         let result: Result<NaiveTime> = db.one_column("SELECT CURRENT_TIME");
-        result.unwrap();
+        result?;
         let result: Result<NaiveDate> = db.one_column("SELECT CURRENT_DATE");
-        result.unwrap();
+        result?;
         let result: Result<NaiveDateTime> = db.one_column("SELECT CURRENT_TIMESTAMP");
-        result.unwrap();
+        result?;
         let result: Result<DateTime<Utc>> = db.one_column("SELECT CURRENT_TIMESTAMP");
-        result.unwrap();
+        result?;
         Ok(())
     }
 
@@ -299,7 +299,7 @@ mod test {
     fn test_naive_date_time_param() -> Result<()> {
         let db = checked_memory_handle()?;
         let result: Result<bool> = db.query_row("SELECT 1 WHERE ?1 BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [Utc::now().naive_utc()], |r| r.get(0));
-        result.unwrap();
+        result?;
         Ok(())
     }
 
@@ -307,7 +307,7 @@ mod test {
     fn test_date_time_param() -> Result<()> {
         let db = checked_memory_handle()?;
         let result: Result<bool> = db.query_row("SELECT 1 WHERE ?1 BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [Utc::now()], |r| r.get(0));
-        result.unwrap();
+        result?;
         Ok(())
     }
 

src/types/time.rs

@@ -362,12 +362,10 @@ mod test {
     #[test]
     fn test_sqlite_functions() -> Result<()> {
         let db = checked_memory_handle()?;
-        db.one_column::<Time>("SELECT CURRENT_TIME").unwrap();
-        db.one_column::<Date>("SELECT CURRENT_DATE").unwrap();
-        db.one_column::<PrimitiveDateTime>("SELECT CURRENT_TIMESTAMP")
-            .unwrap();
-        db.one_column::<OffsetDateTime>("SELECT CURRENT_TIMESTAMP")
-            .unwrap();
+        db.one_column::<Time>("SELECT CURRENT_TIME")?;
+        db.one_column::<Date>("SELECT CURRENT_DATE")?;
+        db.one_column::<PrimitiveDateTime>("SELECT CURRENT_TIMESTAMP")?;
+        db.one_column::<OffsetDateTime>("SELECT CURRENT_TIMESTAMP")?;
         Ok(())
     }
 
@@ -380,7 +378,7 @@ mod test {
             [now],
             |r| r.get(0),
         );
-        result.unwrap();
+        result?;
         Ok(())
     }
 
@@ -393,7 +391,7 @@ mod test {
             [now],
             |r| r.get(0),
         );
-        result.unwrap();
+        result?;
         Ok(())
     }
 
@@ -409,7 +407,7 @@ mod test {
             [now],
             |r| r.get(0),
         );
-        result.unwrap();
+        result?;
         Ok(())
     }
 
@@ -421,7 +419,7 @@ mod test {
             [OffsetDateTime::now_utc()],
             |r| r.get(0),
         );
-        result.unwrap();
+        result?;
         Ok(())
     }
 }