Use better assert_*! for clarity

nyurik · danielrh · commit c10b88d0bd95 · 2024-03-15T23:10:21.000-07:00
diff --git a/src/bin/test_threading.rs b/src/bin/test_threading.rs
@@ -77,7 +77,7 @@ fn multi_threaded_split_compression_test(
     if observed_size > expected_size {
         assert_eq!(observed_size, expected_size);
     }
-    assert!(observed_size != 0);
+    assert_ne!(observed_size, 0);
     let mut compressed_version = UnlimitedBuffer::new(&output.slice()[..observed_size]);
     let mut rt = UnlimitedBuffer::new(&[]);
     match super::decompress(&mut compressed_version, &mut rt, 65536, Rebox::default()) {
@@ -179,7 +179,7 @@ fn thread_spawn_per_job_split_compression_test(
     if observed_size > expected_size {
         assert_eq!(observed_size, expected_size);
     }
-    assert!(observed_size != 0);
+    assert_ne!(observed_size, 0);
     let mut compressed_version = UnlimitedBuffer::new(&output.slice()[..observed_size]);
     let mut rt = UnlimitedBuffer::new(&[]);
     match super::decompress(&mut compressed_version, &mut rt, 65536, Rebox::default()) {
diff --git a/src/concat/mod.rs b/src/concat/mod.rs
@@ -376,7 +376,7 @@ impl BroCatli {
                     .clone_from_slice(&realigned_header[1..]);
             }
         } else {
-            assert!(self.window_size != 0);
+            assert_ne!(self.window_size, 0);
         }
         let to_copy = core::cmp::min(
             out_bytes.len() - *out_offset,
@@ -495,7 +495,7 @@ impl BroCatli {
         }
         let mut to_copy =
             core::cmp::min(out_bytes.len() - *out_offset, in_bytes.len() - *in_offset);
-        assert!(to_copy != 0);
+        assert_ne!(to_copy, 0);
         if to_copy == 1 {
             out_bytes[*out_offset] = self.last_bytes[0];
             self.last_bytes[0] = self.last_bytes[1];
@@ -707,7 +707,7 @@ mod test {
         assert_eq!(res, super::BroCatliResult::NeedsMoreInput);
         res = bcat.finish(&mut out_bytes[..], &mut out_offset);
         assert_eq!(res, super::BroCatliResult::Success);
-        assert!(out_offset != 0);
+        assert_ne!(out_offset, 0);
         assert_eq!(&out_bytes[..out_offset], &[b';']);
     }
 }
diff --git a/src/enc/brotli_bit_stream.rs b/src/enc/brotli_bit_stream.rs
@@ -792,7 +792,7 @@ static kBlockLengthPrefixCode: [PrefixCodeRange; BROTLI_NUM_BLOCK_LEN_SYMBOLS] =
 ];
 
 fn BrotliWriteBits(n_bits: u8, bits: u64, pos: &mut usize, array: &mut [u8]) {
-    assert!((bits >> n_bits as usize) == 0);
+    assert_eq!(bits >> n_bits, 0);
     assert!(n_bits <= 56);
     let ptr_offset: usize = ((*pos >> 3) as u32) as usize;
     let mut v = array[ptr_offset] as u64;
diff --git a/src/enc/context_map_entropy.rs b/src/enc/context_map_entropy.rs
@@ -120,10 +120,10 @@ fn compute_combined_cost(
     let cm_max = mixing_cdf[15];
     for i in 0..NUM_SPEEDS_TO_TRY {
         if stride_pdf[i] == 0 {
-            assert!(stride_pdf[i] != 0);
+            assert_ne!(stride_pdf[i], 0);
         }
         if stride_max[i] == 0 {
-            assert!(stride_max[i] != 0);
+            assert_ne!(stride_max[i], 0);
         }
 
         let w = (1 << (BLEND_FIXED_POINT_PRECISION - 2)); // a quarter of weight to stride
@@ -162,10 +162,10 @@ fn compute_cost(singleton_cost: &mut [floatX; NUM_SPEEDS_TO_TRY], cdfs: &[u16],
     max.clone_from_slice(cdfs.split_at(NUM_SPEEDS_TO_TRY * 15).1);
     for i in 0..NUM_SPEEDS_TO_TRY {
         if pdf[i] == 0 {
-            assert!(pdf[i] != 0);
+            assert_ne!(pdf[i], 0);
         }
         if max[i] == 0 {
-            assert!(max[i] != 0);
+            assert_ne!(max[i], 0);
         }
         let del = FastLog2u16(pdf[i]) - FastLog2u16(max[i]);
         singleton_cost[i] -= del;
@@ -184,12 +184,12 @@ fn update_cdf(cdfs: &mut [u16], nibble_u8: u8) {
     for nibble in 0..16 {
         for speed_index in 0..NUM_SPEEDS_TO_TRY {
             if nibble == 0 {
-                assert!(cdfs[overall_index + speed_index] != 0);
+                assert_ne!(cdfs[overall_index + speed_index], 0);
             } else {
-                assert!(
+                assert_ne!(
                     cdfs[overall_index + speed_index]
-                        - cdfs[overall_index + speed_index - NUM_SPEEDS_TO_TRY]
-                        != 0
+                        - cdfs[overall_index + speed_index - NUM_SPEEDS_TO_TRY],
+                    0
                 );
             }
         }
@@ -209,12 +209,12 @@ fn update_cdf(cdfs: &mut [u16], nibble_u8: u8) {
     for nibble in 0..16 {
         for speed_index in 0..NUM_SPEEDS_TO_TRY {
             if nibble == 0 {
-                assert!(cdfs[overall_index + speed_index] != 0);
+                assert_ne!(cdfs[overall_index + speed_index], 0);
             } else {
-                assert!(
+                assert_ne!(
                     cdfs[overall_index + speed_index]
-                        - cdfs[overall_index + speed_index - NUM_SPEEDS_TO_TRY]
-                        != 0
+                        - cdfs[overall_index + speed_index - NUM_SPEEDS_TO_TRY],
+                    0
                 );
             }
         }
diff --git a/src/enc/encode.rs b/src/enc/encode.rs
@@ -1584,7 +1584,7 @@ pub fn BrotliEncoderCompress<
             return 1i32;
         }
     }
-    assert!(is_fallback != 0);
+    assert_ne!(is_fallback, 0);
     *encoded_size = 0usize;
     if max_out_size == 0 {
         return 0i32;
diff --git a/src/ffi/multicompress/test.rs b/src/ffi/multicompress/test.rs
@@ -100,7 +100,7 @@ fn test_compress_empty_workpool() {
     assert_eq!(ret, 1);
     let mut rt_size = 256;
     let mut rt_buffer = [0u8; 256];
-    assert!(encoded_size != 0);
+    assert_ne!(encoded_size, 0);
     let ret2 = unsafe {
         super::super::decompressor::CBrotliDecoderDecompress(
             encoded_size,
@@ -151,7 +151,7 @@ fn test_compress_empty_multi_raw() {
     assert_eq!(ret, 1);
     let mut rt_size = 256;
     let mut rt_buffer = [0u8; 256];
-    assert!(encoded_size != 0);
+    assert_ne!(encoded_size, 0);
     let ret2 = unsafe {
         super::super::decompressor::CBrotliDecoderDecompress(
             encoded_size,
@@ -201,7 +201,7 @@ fn test_compress_null_multi_raw() {
     assert_eq!(ret, 1);
     let mut rt_size = 256;
     let mut rt_buffer = [0u8; 256];
-    assert!(encoded_size != 0);
+    assert_ne!(encoded_size, 0);
     let ret2 = unsafe {
         super::super::decompressor::CBrotliDecoderDecompress(
             encoded_size,
@@ -252,7 +252,7 @@ fn test_compress_empty_multi_raw_one_thread() {
     assert_eq!(ret, 1);
     let mut rt_size = 256;
     let mut rt_buffer = [0u8; 256];
-    assert!(encoded_size != 0);
+    assert_ne!(encoded_size, 0);
     let ret2 = unsafe {
         super::super::decompressor::CBrotliDecoderDecompress(
             encoded_size,
@@ -303,7 +303,7 @@ fn test_compress_empty_multi_catable() {
     assert_eq!(ret, 1);
     let mut rt_size = 256;
     let mut rt_buffer = [0u8; 256];
-    assert!(encoded_size != 0);
+    assert_ne!(encoded_size, 0);
     let ret2 = unsafe {
         super::super::decompressor::CBrotliDecoderDecompress(
             encoded_size,

Original file line number	Diff line number	Diff line change
`@@ -376,7 +376,7 @@ impl BroCatli {`
`376`	`376`	`.clone_from_slice(&realigned_header[1..]);`
`377`	`377`	`}`
`378`	`378`	`} else {`
`379`		`- assert!(self.window_size != 0);`
	`379`	`+ assert_ne!(self.window_size, 0);`
`380`	`380`	`}`
`381`	`381`	`let to_copy = core::cmp::min(`
`382`	`382`	`out_bytes.len() - *out_offset,`
`@@ -495,7 +495,7 @@ impl BroCatli {`
`495`	`495`	`}`
`496`	`496`	`let mut to_copy =`
`497`	`497`	`core::cmp::min(out_bytes.len() - out_offset, in_bytes.len() - in_offset);`
`498`		`- assert!(to_copy != 0);`
	`498`	`+ assert_ne!(to_copy, 0);`
`499`	`499`	`if to_copy == 1 {`
`500`	`500`	`out_bytes[*out_offset] = self.last_bytes[0];`
`501`	`501`	`self.last_bytes[0] = self.last_bytes[1];`
`@@ -707,7 +707,7 @@ mod test {`
`707`	`707`	`assert_eq!(res, super::BroCatliResult::NeedsMoreInput);`
`708`	`708`	`res = bcat.finish(&mut out_bytes[..], &mut out_offset);`
`709`	`709`	`assert_eq!(res, super::BroCatliResult::Success);`
`710`		`- assert!(out_offset != 0);`
	`710`	`+ assert_ne!(out_offset, 0);`
`711`	`711`	`assert_eq!(&out_bytes[..out_offset], &[b';']);`
`712`	`712`	`}`
`713`	`713`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1584,7 +1584,7 @@ pub fn BrotliEncoderCompress<`
`1584`	`1584`	`return 1i32;`
`1585`	`1585`	`}`
`1586`	`1586`	`}`
`1587`		`- assert!(is_fallback != 0);`
	`1587`	`+ assert_ne!(is_fallback, 0);`
`1588`	`1588`	`*encoded_size = 0usize;`
`1589`	`1589`	`if max_out_size == 0 {`
`1590`	`1590`	`return 0i32;`