text: cleanup and flesh out missing tests

Author: hschimke

src/aztec/DecoderTest.rs

@@ -27,7 +27,7 @@
 // import org.junit.Assert;
 
 use crate::{
-    aztec::shared_test_methods::{stripSpace, toBitArray, toBooleanArray},
+    common::test_utils::{strip_space, to_bit_array, to_boolean_array},
     common::BitMatrix,
     Point,
 };
@@ -73,10 +73,10 @@ fn test_high_level_decode() {
 }
 
 fn test_high_level_decode_string(expectedString: &str, b: &str) {
-    let bits = toBitArray(&stripSpace(b));
+    let bits = to_bit_array(&strip_space(b));
     assert_eq!(
         expectedString,
-        decoder::highLevelDecode(&toBooleanArray(&bits)).expect("highLevelDecode Failed"),
+        decoder::highLevelDecode(&to_boolean_array(&bits)).expect("highLevelDecode Failed"),
         "highLevelDecode() failed for input bits: {b}"
     );
 }

src/aztec/EncoderTest.rs

@@ -15,13 +15,11 @@
  */
 
 use crate::{
-    aztec::{
-        aztec_detector_result::AztecDetectorRXingResult,
-        decoder,
-        encoder::HighLevelEncoder,
-        shared_test_methods::{stripSpace, toBitArray, toBooleanArray},
+    aztec::{aztec_detector_result::AztecDetectorRXingResult, decoder, encoder::HighLevelEncoder},
+    common::{
+        test_utils::{strip_space, to_bit_array, to_boolean_array},
+        CharacterSet,
     },
-    common::CharacterSet,
     BarcodeFormat, EncodeHints, Point,
 };
 
@@ -793,18 +791,18 @@ fn getPseudoRandom() -> rand::rngs::ThreadRng {
 fn testModeMessageComplex(compact: bool, layers: u32, words: u32, expected: &str) {
     let indata = aztec_encoder::generateModeMessage(compact, layers, words).expect("generate mode");
     assert_eq!(
-        stripSpace(expected),
-        stripSpace(&indata.to_string()),
+        strip_space(expected),
+        strip_space(&indata.to_string()),
         "generateModeMessage() failed"
     );
 }
 
 fn testStuffBits(wordSize: usize, bits: &str, expected: &str) {
-    let indata = toBitArray(bits);
+    let indata = to_bit_array(bits);
     let stuffed = aztec_encoder::stuffBits(&indata, wordSize).unwrap();
     assert_eq!(
-        stripSpace(expected),
-        stripSpace(&stuffed.to_string()),
+        strip_space(expected),
+        strip_space(&stuffed.to_string()),
         "stuffBits() failed for input string: {bits}"
     );
 }
@@ -819,14 +817,14 @@ fn testHighLevelEncodeStringUtf8(s: &str, expectedBits: &str) {
     .encode()
     .expect("high level ok");
     // let bits =  HighLevelEncoder::new(s.getBytes(StandardCharsets.ISO_8859_1)).encode();
-    let receivedBits = stripSpace(&bits.to_string());
+    let receivedBits = strip_space(&bits.to_string());
     assert_eq!(
         s,
-        decoder::highLevelDecode(&toBooleanArray(&bits)).expect("must decode")
+        decoder::highLevelDecode(&to_boolean_array(&bits)).expect("must decode")
     );
     // dbg!(s, decoder::highLevelDecode(&toBooleanArray(&bits)).expect("must decode"));
     assert_eq!(
-        stripSpace(expectedBits),
+        strip_space(expectedBits),
         receivedBits,
         "highLevelEncode() failed for input string: {s}"
     );
@@ -841,15 +839,15 @@ fn testHighLevelEncodeString(s: &str, expectedBits: &str) {
     .encode()
     .expect("high level ok");
     // let bits =  HighLevelEncoder::new(s.getBytes(StandardCharsets.ISO_8859_1)).encode();
-    let receivedBits = stripSpace(&bits.to_string());
+    let receivedBits = strip_space(&bits.to_string());
     assert_eq!(
-        stripSpace(expectedBits),
+        strip_space(expectedBits),
         receivedBits,
         "highLevelEncode() failed for input string: {s}"
     );
     assert_eq!(
         s,
-        decoder::highLevelDecode(&toBooleanArray(&bits)).expect("must decode")
+        decoder::highLevelDecode(&to_boolean_array(&bits)).expect("must decode")
     );
 }
 
@@ -862,11 +860,11 @@ fn testHighLevelEncodeStringCount(s: &str, expectedReceivedBits: u32) {
     .encode()
     .expect("high level ok");
     //let bits =  HighLevelEncoder::new(s.getBytes(StandardCharsets.ISO_8859_1)).encode().unwrap();
-    let receivedBitCount = stripSpace(&bits.to_string()).len();
+    let receivedBitCount = strip_space(&bits.to_string()).len();
     // dbg!(s, decoder::highLevelDecode(&toBooleanArray(&bits)).expect("should decode"));
     assert_eq!(
         s,
-        decoder::highLevelDecode(&toBooleanArray(&bits)).expect("should decode")
+        decoder::highLevelDecode(&to_boolean_array(&bits)).expect("should decode")
     );
     // assert!(
     //     expectedReceivedBits as usize >= receivedBitCount,

src/aztec/mod.rs

@@ -14,5 +14,3 @@ mod DecoderTest;
 mod DetectorTest;
 #[cfg(test)]
 mod EncoderTest;
-
-mod shared_test_methods;

src/aztec/shared_test_methods.rs

@@ -29,6 +29,7 @@
 use crate::common::BIT_FIELD_BASE_BITS;
 
 use super::{BitArray, BIT_FIELD_SHIFT_BITS};
+use crate::common::test_utils::arrays_are_equal;
 use rand::Rng;
 
 #[test]
@@ -303,6 +304,23 @@ fn test_equals() {
     // assert_eq!(a.hash(), b.hash());
 }
 
+#[test]
+fn test_reverse_with_modification() {
+    let mut ba = BitArray::with_size(10);
+    ba.set(0);
+    ba.reverse();
+    // Bit 0 was set, now bit 9 should be set (if it reverses 0..9)
+    assert!(ba.get(9));
+    assert!(!ba.get(0));
+
+    ba.set(8); // Now bits 8 and 9 are set
+    ba.reverse();
+    // If it correctly reverses the CURRENT bits, bit 0 and 1 should be set.
+    // If it uses the stale cache, only bit 0 will be set.
+    assert!(ba.get(0), "Bit 0 should be set");
+    assert!(ba.get(1), "Bit 1 should be set (reverse of bit 8)");
+}
+
 #[test]
 fn test_xor() {
     let val_1: super::BitFieldBaseType = 0b01_00_11;
@@ -365,13 +383,4 @@ fn bit_set(bits: &[super::BitFieldBaseType], i: usize) -> bool {
     (bits[i / BIT_FIELD_BASE_BITS] & (1 << (i & BIT_FIELD_SHIFT_BITS))) != 0
 }
 
-fn arrays_are_equal<T: Eq + Default>(left: &[T], right: &[T], size: usize) -> bool {
-    for i in 0..size {
-        if left[i] != right[i] {
-            return false;
-        }
-    }
-    true
-}
-
 // }

src/common/BitArrayTestCase.rs

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2026 RXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use super::test_utils::MockLuminanceSource;
+use super::AdaptiveThresholdBinarizer;
+use crate::Binarizer;
+
+#[test]
+fn test_adaptive_threshold_binarizer() {
+    let width = 40;
+    let height = 40;
+    let mut luminances = vec![0; width * height];
+
+    // Create a pattern with alternating black and white bars
+    for y in 0..height {
+        for x in 0..width {
+            if (x / 5) % 2 == 0 {
+                luminances[y * width + x] = 0; // Black
+            } else {
+                luminances[y * width + x] = 255; // White
+            }
+        }
+    }
+
+    let source = MockLuminanceSource::new(width, height, luminances);
+    // Radius of 10 for adaptive threshold
+    let binarizer = AdaptiveThresholdBinarizer::new(source, 10);
+    let matrix = binarizer.get_black_matrix().unwrap();
+
+    assert_eq!(width as u32, matrix.getWidth());
+    assert_eq!(height as u32, matrix.getHeight());
+
+    // Check points in the middle of bars to avoid boundary issues
+    assert!(matrix.get(2, 2)); // First bar (black)
+    assert!(!matrix.get(7, 7)); // Second bar (white)
+    assert!(matrix.get(12, 12)); // Third bar (black)
+    assert!(!matrix.get(17, 17)); // Fourth bar (white)
+}

src/common/adaptive_threshold_binarizer_test_case.rs

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2026 RXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use super::test_utils::MockLuminanceSource;
+use super::HybridBinarizer;
+use crate::Binarizer;
+
+#[test]
+fn test_hybrid_binarizer_small_image() {
+    // Small image should fall back to GlobalHistogramBinarizer
+    let width = 10;
+    let height = 10;
+    let mut luminances = vec![0; width * height];
+    // Create a simple black and white pattern
+    for y in 0..height {
+        for x in 0..width {
+            if x < 5 {
+                luminances[y * width + x] = 0; // Black
+            } else {
+                luminances[y * width + x] = 255; // White
+            }
+        }
+    }
+
+    let source = MockLuminanceSource::new(width, height, luminances);
+    let binarizer = HybridBinarizer::new(source);
+    let matrix = binarizer.get_black_matrix().unwrap();
+
+    assert_eq!(width as u32, matrix.getWidth());
+    assert_eq!(height as u32, matrix.getHeight());
+
+    for y in 0..height {
+        for x in 0..width {
+            if x < 5 {
+                assert!(matrix.get(x as u32, y as u32));
+            } else {
+                assert!(!matrix.get(x as u32, y as u32));
+            }
+        }
+    }
+}
+
+#[test]
+fn test_hybrid_binarizer_large_image() {
+    // Large image uses local thresholding
+    let width = 40; // HybridBinarizer::MINIMUM_DIMENSION is 40
+    let height = 40;
+    let mut luminances = vec![0; width * height];
+
+    // Create a pattern with a gradient to test local thresholding
+    for y in 0..height {
+        for x in 0..width {
+            if x < 20 {
+                luminances[y * width + x] = 50; // Dark grey
+            } else {
+                luminances[y * width + x] = 200; // Light grey
+            }
+        }
+    }
+
+    let source = MockLuminanceSource::new(width, height, luminances);
+    let binarizer = HybridBinarizer::new(source);
+    let matrix = binarizer.get_black_matrix().unwrap();
+
+    assert_eq!(width as u32, matrix.getWidth());
+    assert_eq!(height as u32, matrix.getHeight());
+
+    for y in 0..height {
+        for x in 0..width {
+            if x < 20 {
+                assert!(
+                    matrix.get(x as u32, y as u32),
+                    "Bit at ({}, {}) should be set",
+                    x,
+                    y
+                );
+            } else {
+                assert!(
+                    !matrix.get(x as u32, y as u32),
+                    "Bit at ({}, {}) should NOT be set",
+                    x,
+                    y
+                );
+            }
+        }
+    }
+}

src/common/hybrid_binarizer_test_case.rs

@@ -3,12 +3,21 @@ pub mod reedsolomon;
 
 use crate::Point;
 
+#[cfg(test)]
+pub mod test_utils;
+
 #[cfg(test)]
 mod StringUtilsTestCase;
 
 #[cfg(test)]
 mod BitArrayTestCase;
 
+#[cfg(test)]
+mod hybrid_binarizer_test_case;
+
+#[cfg(test)]
+mod adaptive_threshold_binarizer_test_case;
+
 #[cfg(test)]
 pub(crate) mod bit_matrix_test_case;