Use assert_eq! and assert_ne! where relevant (#5547)

Tpt · web-flow · commit da5777a7b81a · 2025-10-21T15:00:12.000Z
diff --git a/pyo3-build-config/src/impl_.rs b/pyo3-build-config/src/impl_.rs
@@ -1998,7 +1998,7 @@ fn escape(bytes: &[u8]) -> String {
 }
 
 fn unescape(escaped: &str) -> Vec<u8> {
-    assert!(escaped.len() % 2 == 0, "invalid hex encoding");
+    assert_eq!(escaped.len() % 2, 0, "invalid hex encoding");
 
     let mut bytes = Vec::with_capacity(escaped.len() / 2);
 
diff --git a/src/conversions/hashbrown.rs b/src/conversions/hashbrown.rs
@@ -158,7 +158,7 @@ mod tests {
 
             let py_map = (&map).into_pyobject(py).unwrap();
 
-            assert!(py_map.len() == 1);
+            assert_eq!(py_map.len(), 1);
             assert!(
                 py_map
                     .get_item(1)
diff --git a/src/conversions/indexmap.rs b/src/conversions/indexmap.rs
@@ -165,7 +165,7 @@ mod test_indexmap {
 
             let py_map = (&map).into_pyobject(py).unwrap();
 
-            assert!(py_map.len() == 1);
+            assert_eq!(py_map.len(), 1);
             assert!(
                 py_map
                     .get_item(1)
diff --git a/src/conversions/std/array.rs b/src/conversions/std/array.rs
@@ -183,7 +183,7 @@ mod tests {
                 .unwrap()
                 .extract()
                 .unwrap();
-            assert!(&v == b"abcabcabcabcabcabcabcabcabcabcabc");
+            assert_eq!(&v, b"abcabcabcabcabcabcabcabcabcabcabc");
         })
     }
 
@@ -213,7 +213,7 @@ mod tests {
                 .unwrap()
                 .extract()
                 .unwrap();
-            assert!(&v == b"abcabcabcabcabcabcabcabcabcabcabc");
+            assert_eq!(&v, b"abcabcabcabcabcabcabcabcabcabcabc");
         })
     }
 
@@ -225,7 +225,7 @@ mod tests {
                 .unwrap()
                 .extract()
                 .unwrap();
-            assert!(&v == b"abc");
+            assert_eq!(&v, b"abc");
         });
     }
     #[test]
diff --git a/src/conversions/std/map.rs b/src/conversions/std/map.rs
@@ -171,7 +171,7 @@ mod tests {
 
             let py_map = (&map).into_pyobject(py).unwrap();
 
-            assert!(py_map.len() == 1);
+            assert_eq!(py_map.len(), 1);
             assert!(
                 py_map
                     .get_item(1)
@@ -193,7 +193,7 @@ mod tests {
 
             let py_map = (&map).into_pyobject(py).unwrap();
 
-            assert!(py_map.len() == 1);
+            assert_eq!(py_map.len(), 1);
             assert!(
                 py_map
                     .get_item(1)
@@ -215,7 +215,7 @@ mod tests {
 
             let py_map = map.into_pyobject(py).unwrap();
 
-            assert!(py_map.len() == 1);
+            assert_eq!(py_map.len(), 1);
             assert!(
                 py_map
                     .get_item(1)
@@ -236,7 +236,7 @@ mod tests {
 
             let py_map = map.into_pyobject(py).unwrap();
 
-            assert!(py_map.len() == 1);
+            assert_eq!(py_map.len(), 1);
             assert!(
                 py_map
                     .get_item(1)
diff --git a/src/conversions/std/vec.rs b/src/conversions/std/vec.rs
@@ -165,7 +165,7 @@ mod tests {
                 .unwrap()
                 .extract()
                 .unwrap();
-            assert!(v == [1, 2]);
+            assert_eq!(v, [1, 2]);
         });
     }
 
@@ -177,7 +177,7 @@ mod tests {
                 .unwrap()
                 .extract()
                 .unwrap();
-            assert!(v == [1, 2, 3, 4]);
+            assert_eq!(v, [1, 2, 3, 4]);
         });
     }
 
@@ -189,7 +189,7 @@ mod tests {
                 .unwrap()
                 .extract()
                 .unwrap();
-            assert!(v == b"abc");
+            assert_eq!(v, b"abc");
         });
     }
 }
diff --git a/src/internal/state.rs b/src/internal/state.rs
@@ -504,7 +504,7 @@ mod tests {
         Python::attach(|py| {
             // Make a simple object with 1 reference
             let obj = get_object(py);
-            assert!(obj.get_refcnt(py) == 1);
+            assert_eq!(obj.get_refcnt(py), 1);
             // Cloning the object when detached should panic
             py.detach(|| obj.clone());
         });
diff --git a/src/sync.rs b/src/sync.rs
@@ -1467,7 +1467,7 @@ mod tests {
                 Err(poisoned) => poisoned.into_inner(),
             }
         });
-        assert!(*guard == 42);
+        assert_eq!(*guard, 42);
     }
 
     #[cfg(feature = "macros")]
@@ -1699,7 +1699,7 @@ mod tests {
         Python::attach(|py| {
             // recover from the poisoning
             let guard = rwlock.write_py_attached(py).unwrap_err().into_inner();
-            assert!(*guard == 42);
+            assert_eq!(*guard, 42);
         });
     }
 }
diff --git a/src/types/list.rs b/src/types/list.rs
@@ -1222,7 +1222,7 @@ mod tests {
                 -5
             });
             assert_eq!(sum, -5);
-            assert!(list.len() == 0);
+            assert_eq!(list.len(), 0);
         });
     }
 
diff --git a/src/types/mutex.rs b/src/types/mutex.rs
@@ -452,7 +452,7 @@ mod tests {
             .join()
         });
         mutex.clear_poison();
-        assert!(*mutex.lock().unwrap() == 0);
+        assert_eq!(*mutex.lock().unwrap(), 0);
     }
 
     #[test]
diff --git a/src/version.rs b/src/version.rs
@@ -128,12 +128,12 @@ mod test {
     fn test_python_version_info_parse() {
         assert!(PythonVersionInfo::from_str("3.5.0a1").unwrap() >= (3, 5, 0));
         assert!(PythonVersionInfo::from_str("3.5+").unwrap() >= (3, 5, 0));
-        assert!(PythonVersionInfo::from_str("3.5+").unwrap() == (3, 5, 0));
-        assert!(PythonVersionInfo::from_str("3.5+").unwrap() != (3, 5, 1));
+        assert_eq!(PythonVersionInfo::from_str("3.5+").unwrap(), (3, 5, 0));
+        assert_ne!(PythonVersionInfo::from_str("3.5+").unwrap(), (3, 5, 1));
         assert!(PythonVersionInfo::from_str("3.5.2a1+").unwrap() < (3, 5, 3));
-        assert!(PythonVersionInfo::from_str("3.5.2a1+").unwrap() == (3, 5, 2));
-        assert!(PythonVersionInfo::from_str("3.5.2a1+").unwrap() == (3, 5));
-        assert!(PythonVersionInfo::from_str("3.5+").unwrap() == (3, 5));
+        assert_eq!(PythonVersionInfo::from_str("3.5.2a1+").unwrap(), (3, 5, 2));
+        assert_eq!(PythonVersionInfo::from_str("3.5.2a1+").unwrap(), (3, 5));
+        assert_eq!(PythonVersionInfo::from_str("3.5+").unwrap(), (3, 5));
         assert!(PythonVersionInfo::from_str("3.5.2a1+").unwrap() < (3, 6));
         assert!(PythonVersionInfo::from_str("3.5.2a1+").unwrap() > (3, 4));
         assert!(PythonVersionInfo::from_str("3.11.3+chromium.29").unwrap() >= (3, 11, 3));
diff --git a/tests/test_class_new.rs b/tests/test_class_new.rs
@@ -244,12 +244,12 @@ fn test_new_existing() {
         let obj5 = typeobj.call1((2,)).unwrap();
         let obj6 = typeobj.call1((2,)).unwrap();
 
-        assert!(obj1.getattr("num").unwrap().extract::<u32>().unwrap() == 0);
-        assert!(obj2.getattr("num").unwrap().extract::<u32>().unwrap() == 0);
-        assert!(obj3.getattr("num").unwrap().extract::<u32>().unwrap() == 1);
-        assert!(obj4.getattr("num").unwrap().extract::<u32>().unwrap() == 1);
-        assert!(obj5.getattr("num").unwrap().extract::<u32>().unwrap() == 2);
-        assert!(obj6.getattr("num").unwrap().extract::<u32>().unwrap() == 2);
+        assert_eq!(obj1.getattr("num").unwrap().extract::<u32>().unwrap(), 0);
+        assert_eq!(obj2.getattr("num").unwrap().extract::<u32>().unwrap(), 0);
+        assert_eq!(obj3.getattr("num").unwrap().extract::<u32>().unwrap(), 1);
+        assert_eq!(obj4.getattr("num").unwrap().extract::<u32>().unwrap(), 1);
+        assert_eq!(obj5.getattr("num").unwrap().extract::<u32>().unwrap(), 2);
+        assert_eq!(obj6.getattr("num").unwrap().extract::<u32>().unwrap(), 2);
 
         assert!(obj1.is(&obj2));
         assert!(obj3.is(&obj4));
diff --git a/tests/test_datetime.rs b/tests/test_datetime.rs
@@ -52,8 +52,8 @@ macro_rules! assert_check_exact {
     ($check_func:ident, $check_func_exact:ident, $obj: expr) => {
         unsafe {
             use pyo3::ffi::*;
-            assert!($check_func(($obj).as_ptr()) != 0);
-            assert!($check_func_exact(($obj).as_ptr()) != 0);
+            assert_ne!($check_func(($obj).as_ptr()), 0);
+            assert_ne!($check_func_exact(($obj).as_ptr()), 0);
         }
     };
 }
@@ -62,8 +62,8 @@ macro_rules! assert_check_only {
     ($check_func:ident, $check_func_exact:ident, $obj: expr) => {
         unsafe {
             use pyo3::ffi::*;
-            assert!($check_func(($obj).as_ptr()) != 0);
-            assert!($check_func_exact(($obj).as_ptr()) == 0);
+            assert_ne!($check_func(($obj).as_ptr()), 0);
+            assert_eq!($check_func_exact(($obj).as_ptr()), 0);
         }
     };
 }

Original file line number	Diff line number	Diff line change
`@@ -1998,7 +1998,7 @@ fn escape(bytes: &[u8]) -> String {`
`1998`	`1998`	`}`
`1999`	`1999`
`2000`	`2000`	`fn unescape(escaped: &str) -> Vec<u8> {`
`2001`		`- assert!(escaped.len() % 2 == 0, "invalid hex encoding");`
	`2001`	`+ assert_eq!(escaped.len() % 2, 0, "invalid hex encoding");`
`2002`	`2002`
`2003`	`2003`	`let mut bytes = Vec::with_capacity(escaped.len() / 2);`
`2004`	`2004`
Original file line number	Diff line number	Diff line change
`@@ -165,7 +165,7 @@ mod tests {`
`165`	`165`	`.unwrap()`
`166`	`166`	`.extract()`
`167`	`167`	`.unwrap();`
`168`		`- assert!(v == [1, 2]);`
	`168`	`+ assert_eq!(v, [1, 2]);`
`169`	`169`	`});`
`170`	`170`	`}`
`171`	`171`
`@@ -177,7 +177,7 @@ mod tests {`
`177`	`177`	`.unwrap()`
`178`	`178`	`.extract()`
`179`	`179`	`.unwrap();`
`180`		`- assert!(v == [1, 2, 3, 4]);`
	`180`	`+ assert_eq!(v, [1, 2, 3, 4]);`
`181`	`181`	`});`
`182`	`182`	`}`
`183`	`183`
`@@ -189,7 +189,7 @@ mod tests {`
`189`	`189`	`.unwrap()`
`190`	`190`	`.extract()`
`191`	`191`	`.unwrap();`
`192`		`- assert!(v == b"abc");`
	`192`	`+ assert_eq!(v, b"abc");`
`193`	`193`	`});`
`194`	`194`	`}`
`195`	`195`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1467,7 +1467,7 @@ mod tests {`
`1467`	`1467`	`Err(poisoned) => poisoned.into_inner(),`
`1468`	`1468`	`}`
`1469`	`1469`	`});`
`1470`		`- assert!(*guard == 42);`
	`1470`	`+ assert_eq!(*guard, 42);`
`1471`	`1471`	`}`
`1472`	`1472`
`1473`	`1473`	`#[cfg(feature = "macros")]`
`@@ -1699,7 +1699,7 @@ mod tests {`
`1699`	`1699`	`Python::attach(\|py\| {`
`1700`	`1700`	`// recover from the poisoning`
`1701`	`1701`	`let guard = rwlock.write_py_attached(py).unwrap_err().into_inner();`
`1702`		`- assert!(*guard == 42);`
	`1702`	`+ assert_eq!(*guard, 42);`
`1703`	`1703`	`});`
`1704`	`1704`	`}`
`1705`	`1705`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1222,7 +1222,7 @@ mod tests {`
`1222`	`1222`	`-5`
`1223`	`1223`	`});`
`1224`	`1224`	`assert_eq!(sum, -5);`
`1225`		`- assert!(list.len() == 0);`
	`1225`	`+ assert_eq!(list.len(), 0);`
`1226`	`1226`	`});`
`1227`	`1227`	`}`
`1228`	`1228`
Original file line number	Diff line number	Diff line change
`@@ -452,7 +452,7 @@ mod tests {`
`452`	`452`	`.join()`
`453`	`453`	`});`
`454`	`454`	`mutex.clear_poison();`
`455`		`- assert!(*mutex.lock().unwrap() == 0);`
	`455`	`+ assert_eq!(*mutex.lock().unwrap(), 0);`
`456`	`456`	`}`
`457`	`457`
`458`	`458`	`#[test]`