syntactic changes: use assert_eq!() instead of assert!() for equality comparisons

core/storage/btree.rs

@@ -1126,16 +1126,7 @@ impl BTreeCursor {
                     for page in new_pages.iter_mut().take(new_pages_len - 1) {
                         let contents = page.get().contents.as_mut().unwrap();
 
-                        assert!(contents.cell_count() == 1);
-                        let last_cell = contents
-                            .cell_get(
-                                contents.cell_count() - 1,
-                                self.pager.clone(),
-                                self.payload_overflow_threshold_max(contents.page_type()),
-                                self.payload_overflow_threshold_min(contents.page_type()),
-                                self.usable_space(),
-                            )
-                            .unwrap();
+                        assert_eq!(contents.cell_count(), 1);
                         let last_cell = contents.cell_get(
                             contents.cell_count() - 1,
                             self.pager.clone(),
@@ -1509,8 +1500,8 @@ impl BTreeCursor {
             }
 
             // Next should always be 0 (NULL) at this point since we have reached the end of the freeblocks linked list
-            assert!(
-                next == 0,
+            assert_eq!(
+                next, 0,
                 "corrupted page: freeblocks list not in ascending order"
             );
 

core/storage/database.rs

@@ -48,7 +48,7 @@ impl DatabaseStorage for FileStorage {
         let buffer_size = buffer.borrow().len();
         assert!(buffer_size >= 512);
         assert!(buffer_size <= 65536);
-        assert!((buffer_size & (buffer_size - 1)) == 0);
+        assert_eq!(buffer_size & (buffer_size - 1), 0);
         let pos = (page_idx - 1) * buffer_size;
         self.file.pwrite(pos, buffer, c)?;
         Ok(())

core/storage/sqlite3_ondisk.rs

@@ -1340,7 +1340,7 @@ pub fn checksum_wal(
     input: (u32, u32),
     native_endian: bool, // Sqlite interprets big endian as "native"
 ) -> (u32, u32) {
-    assert!(buf.len() % 8 == 0, "buffer must be a multiple of 8");
+    assert_eq!(buf.len() % 8, 0, "buffer must be a multiple of 8");
     let mut s0: u32 = input.0;
     let mut s1: u32 = input.1;
     let mut i = 0;

core/translate/insert.rs

@@ -74,7 +74,7 @@ pub fn translate_insert(
     // Check if rowid was provided (through INTEGER PRIMARY KEY as a rowid alias)
     let rowid_alias_index = table.columns.iter().position(|c| c.is_rowid_alias);
     let has_user_provided_rowid = {
-        assert!(column_mappings.len() == table.columns.len());
+        assert_eq!(column_mappings.len(), table.columns.len());
         if let Some(index) = rowid_alias_index {
             column_mappings[index].value_index.is_some()
         } else {

core/translate/main_loop.rs

@@ -780,7 +780,7 @@ pub fn close_loop(
                     target_pc: lj_meta.label_match_flag_set_true,
                 });
 
-                assert!(program.offset() == jump_offset);
+                assert_eq!(program.offset(), jump_offset);
             }
 
             close_loop(program, t_ctx, left)?;

core/types.rs

@@ -660,7 +660,7 @@ mod tests {
         let header_length = record.values.len() + 1;
         let header = &buf[0..header_length];
         // First byte should be header size
-        assert!(header[0] == header_length as u8); // Header should be larger than number of values
+        assert_eq!(header[0], header_length as u8); // Header should be larger than number of values
 
         // Check that correct serial types were chosen
         assert_eq!(header[1] as u64, u64::from(SerialType::I8));

core/vdbe/builder.rs

@@ -83,7 +83,7 @@ impl ProgramBuilder {
         let cursor = self.next_free_cursor_id;
         self.next_free_cursor_id += 1;
         self.cursor_ref.push((table_identifier, cursor_type));
-        assert!(self.cursor_ref.len() == self.next_free_cursor_id);
+        assert_eq!(self.cursor_ref.len(), self.next_free_cursor_id);
         cursor
     }
 

core/vdbe/mod.rs

@@ -1625,7 +1625,7 @@ impl Program {
                         },
                         crate::function::Func::Scalar(scalar_func) => match scalar_func {
                             ScalarFunc::Cast => {
-                                assert!(arg_count == 2);
+                                assert_eq!(arg_count, 2);
                                 assert!(*start_reg + 1 < state.registers.len());
                                 let reg_value_argument = state.registers[*start_reg].clone();
                                 let OwnedValue::Text(reg_value_type) =
@@ -1915,7 +1915,7 @@ impl Program {
                                 state.registers[*dest] = OwnedValue::build_text(Rc::new(version));
                             }
                             ScalarFunc::Replace => {
-                                assert!(arg_count == 3);
+                                assert_eq!(arg_count, 3);
                                 let source = &state.registers[*start_reg];
                                 let pattern = &state.registers[*start_reg + 1];
                                 let replacement = &state.registers[*start_reg + 2];

test/src/lib.rs

@@ -446,6 +446,7 @@ mod tests {
             insert(1, &conn, &tmp_db).unwrap();
             assert_eq!(count(&conn, &tmp_db).unwrap(), 1);
             insert(1, &conn, &tmp_db)?;
+            assert_eq!(count(&conn, &tmp_db)?, 1);
             conn.close()?;
         }
         {