Add error reporting to tests

src/multi_format_reader.rs

@@ -119,22 +119,20 @@ impl MultiFormatReader {
         &mut self,
         image: &mut BinaryBitmap<B>,
     ) -> Result<RXingResult> {
-        if !self.possible_formats.is_empty() {
+        let res = self.decode_formats(image);
+        if res.is_ok() {
+            return res;
+        }
+        if matches!(
+            self.hints.get(&DecodeHintType::ALSO_INVERTED),
+            Some(DecodeHintValue::AlsoInverted(true))
+        ) {
+            // Calling all readers again with inverted image
+            image.get_black_matrix_mut().flip_self();
             let res = self.decode_formats(image);
             if res.is_ok() {
                 return res;
             }
-            if matches!(
-                self.hints.get(&DecodeHintType::ALSO_INVERTED),
-                Some(DecodeHintValue::AlsoInverted(true))
-            ) {
-                // Calling all readers again with inverted image
-                image.get_black_matrix_mut().flip_self();
-                let res = self.decode_formats(image);
-                if res.is_ok() {
-                    return res;
-                }
-            }
         }
         Err(Exceptions::NOT_FOUND)
     }

src/oned/one_d_reader.rs

@@ -105,8 +105,8 @@ pub trait OneDReader: Reader {
                     }
                 }
                 let Ok(mut result) = self.decode_row(row_number as u32, &row, &hints) else {
-            continue
+                    continue
-          };
+                };
                 // We found our barcode
                 if attempt == 1 {
                     // But it was upside down, so note that

src/oned/rss/expanded/test_case_util.rs

@@ -28,7 +28,9 @@ use std::rc::Rc;
 
 use image::DynamicImage;
 
-use crate::{common::GlobalHistogramBinarizer, BinaryBitmap, BufferedImageLuminanceSource, Binarizer};
+use crate::{
+    common::GlobalHistogramBinarizer, Binarizer, BinaryBitmap, BufferedImageLuminanceSource,
+};
 
 fn getBufferedImage(fileName: &str) -> DynamicImage {
     let path = format!("test_resources/blackbox/rssexpandedstacked-2/{fileName}");
@@ -36,7 +38,9 @@ fn getBufferedImage(fileName: &str) -> DynamicImage {
     image::open(path).expect("load image")
 }
 
-pub(crate) fn getBinaryBitmap(fileName: &str) -> BinaryBitmap<GlobalHistogramBinarizer<BufferedImageLuminanceSource>> {
+pub(crate) fn getBinaryBitmap(
+    fileName: &str,
+) -> BinaryBitmap<GlobalHistogramBinarizer<BufferedImageLuminanceSource>> {
     let bufferedImage = getBufferedImage(fileName);
 
     BinaryBitmap::new(GlobalHistogramBinarizer::new(

tests/common/abstract_black_box_test_case.rs

@@ -25,7 +25,12 @@ use std::{
 };
 
 use encoding::Encoding;
-use rxing::{common::{HybridBinarizer, Result}, pdf417::PDF417RXingResultMetadata, BarcodeFormat, BinaryBitmap, BufferedImageLuminanceSource, DecodeHintType, DecodeHintValue, RXingResultMetadataType, RXingResultMetadataValue, Reader, Binarizer};
+use rxing::{
+    common::{HybridBinarizer, Result},
+    pdf417::PDF417RXingResultMetadata,
+    BarcodeFormat, Binarizer, BinaryBitmap, BufferedImageLuminanceSource, DecodeHintType,
+    DecodeHintValue, RXingResultMetadataType, RXingResultMetadataValue, Reader,
+};
 
 use super::TestRXingResult;
 
@@ -254,21 +259,23 @@ impl<T: Reader> AbstractBlackBoxTestCase<T> {
                 // drop(f);
                 // Self::rotate_image(&image, rotation).save("test_image.png").unwrap();
                 // }
-
+                match self.decode(
-                if let Ok(decoded) = self.decode(
                     &mut bitmap,
                     rotation,
                     &expected_text,
                     &expected_metadata,
                     false,
                 ) {
-                    if decoded {
+                    Ok(decoded) => {
-                        passed_counts[x] += 1;
+                        if decoded {
-                    } else {
+                            passed_counts[x] += 1;
-                        misread_counts[x] += 1;
+                        } else {
+                            misread_counts[x] += 1;
+                        }
+                    }
+                    Err(e) => {
+                        log::fine(format!("could not read at rotation {rotation}: {e:?}"));
                     }
-                } else {
-                    log::fine(format!("could not read at rotation {rotation}"));
                 }
                 // try {
                 //   if (decode(bitmap, rotation, expectedText, expectedMetadata, false)) {
@@ -279,20 +286,23 @@ impl<T: Reader> AbstractBlackBoxTestCase<T> {
                 // } catch (ReaderException ignored) {
                 //   log::fine(format!("could not read at rotation {}", rotation));
                 // }
-                if let Ok(decoded) = self.decode(
+                match self.decode(
                     &mut bitmap,
                     rotation,
                     &expected_text,
                     &expected_metadata,
                     true,
                 ) {
-                    if decoded {
+                    Ok(decoded) => {
-                        try_harder_counts[x] += 1;
+                        if decoded {
-                    } else {
+                            try_harder_counts[x] += 1;
-                        try_harder_misread_counts[x] += 1;
+                        } else {
+                            try_harder_misread_counts[x] += 1;
+                        }
+                    }
+                    Err(e) => {
+                        log::fine(format!("could not read at rotation {rotation} w/TH: {e:?}"));
                     }
-                } else {
-                    log::fine(format!("could not read at rotation {rotation} w/TH"));
                 }
                 // try {
                 //   if (decode(bitmap, rotation, expectedText, expectedMetadata, true)) {

tests/common/pdf_417_multiimage_span.rs

@@ -24,7 +24,13 @@ use std::{
 };
 
 use encoding::Encoding;
-use rxing::{common::{HybridBinarizer, Result}, multi::MultipleBarcodeReader, pdf417::PDF417RXingResultMetadata, BarcodeFormat, BinaryBitmap, BufferedImageLuminanceSource, DecodeHintType, DecodeHintValue, RXingResult, RXingResultMetadataType, RXingResultMetadataValue, Reader, Binarizer};
+use rxing::{
+    common::{HybridBinarizer, Result},
+    multi::MultipleBarcodeReader,
+    pdf417::PDF417RXingResultMetadata,
+    BarcodeFormat, Binarizer, BinaryBitmap, BufferedImageLuminanceSource, DecodeHintType,
+    DecodeHintValue, RXingResult, RXingResultMetadataType, RXingResultMetadataValue, Reader,
+};
 
 use super::TestRXingResult;
 
@@ -174,8 +180,7 @@ impl<T: MultipleBarcodeReader + Reader> PDF417MultiImageSpanAbstractBlackBoxTest
                     let rotation: f32 = self.test_rxing_results.get(x).expect("ok").get_rotation();
                     let rotated_image = Self::rotate_image(&image, rotation);
                     let source = BufferedImageLuminanceSource::new(rotated_image);
-                    let mut bitmap =
+                    let mut bitmap = BinaryBitmap::new(HybridBinarizer::new(source));
-                        BinaryBitmap::new(HybridBinarizer::new(source));
 
                     if let Ok(res) =
                         Self::decode_pdf417(&mut bitmap, false, &mut self.barcode_reader)