cargo fmt

src/oned/rss/expanded/expanded_row.rs

@@ -36,7 +36,7 @@ impl ExpandedRow {
     }
 
     #[cfg(test)]
-    pub(crate) fn getPairsMut(&mut self) -> &mut [ExpandedPair]{
+    pub(crate) fn getPairsMut(&mut self) -> &mut [ExpandedPair] {
         &mut self.pairs
     }
 

src/oned/rss/expanded/mod.rs

@@ -31,4 +31,4 @@ mod rss_expanded_image_2_string_test_case;
 mod rss_expanded_stacked_internal_test_case;
 
 #[cfg(test)]
-mod test_case_util;
+mod test_case_util;

src/oned/rss/expanded/rss_expanded_image_2_string_test_case.rs

@@ -24,168 +24,179 @@
  *   http://www.piramidepse.com/
  */
 
-use std::{rc::Rc, collections::HashMap};
+use std::{collections::HashMap, rc::Rc};
-
-use crate::{BinaryBitmap, common::{GlobalHistogramBinarizer, BitArray}, BufferedImageLuminanceSource, oned::{rss::expanded::RSSExpandedReader, OneDReader}, BarcodeFormat};
 
+use crate::{
+    common::{BitArray, GlobalHistogramBinarizer},
+    oned::{rss::expanded::RSSExpandedReader, OneDReader},
+    BarcodeFormat, BinaryBitmap, BufferedImageLuminanceSource,
+};
 
 /**
  * @author Pablo Orduña, University of Deusto (pablo.orduna@deusto.es)
  * @author Eduardo Castillejo, University of Deusto (eduardo.castillejo@deusto.es)
  */
 
- #[test]
+#[test]
- fn  testDecodeRow2string1()  {
+fn testDecodeRow2string1() {
     assertCorrectImage2string("1.png", "(11)100224(17)110224(3102)000100");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string2()  {
+fn testDecodeRow2string2() {
     assertCorrectImage2string("2.png", "(01)90012345678908(3103)001750");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string3()  {
+fn testDecodeRow2string3() {
     assertCorrectImage2string("3.png", "(10)12A");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string4()  {
+fn testDecodeRow2string4() {
     assertCorrectImage2string("4.png", "(01)98898765432106(3202)012345(15)991231");
-  }
+}
 
-  #[test]
+#[test]
-  fn testDecodeRow2string5()  {
+fn testDecodeRow2string5() {
     assertCorrectImage2string("5.png", "(01)90614141000015(3202)000150");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string7()  {
+fn testDecodeRow2string7() {
     assertCorrectImage2string("7.png", "(10)567(11)010101");
-  }
+}
 
-  #[test]
+#[test]
-  fn testDecodeRow2string10()  {
+fn testDecodeRow2string10() {
-    let expected = "(01)98898765432106(15)991231(3103)001750(10)12A(422)123(21)123456(423)012345678901";
+    let expected =
+        "(01)98898765432106(15)991231(3103)001750(10)12A(422)123(21)123456(423)012345678901";
     assertCorrectImage2string("10.png", expected);
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string11()  {
+fn testDecodeRow2string11() {
-    assertCorrectImage2string("11.png", "(01)98898765432106(15)991231(3103)001750(10)12A(422)123(21)123456");
+    assertCorrectImage2string(
-  }
+        "11.png",
+        "(01)98898765432106(15)991231(3103)001750(10)12A(422)123(21)123456",
+    );
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string12()  {
+fn testDecodeRow2string12() {
     assertCorrectImage2string("12.png", "(01)98898765432106(3103)001750");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string13()  {
+fn testDecodeRow2string13() {
     assertCorrectImage2string("13.png", "(01)90012345678908(3922)795");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string14()  {
+fn testDecodeRow2string14() {
     assertCorrectImage2string("14.png", "(01)90012345678908(3932)0401234");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string15()  {
+fn testDecodeRow2string15() {
     assertCorrectImage2string("15.png", "(01)90012345678908(3102)001750(11)100312");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string16()  {
+fn testDecodeRow2string16() {
     assertCorrectImage2string("16.png", "(01)90012345678908(3202)001750(11)100312");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string17()  {
+fn testDecodeRow2string17() {
     assertCorrectImage2string("17.png", "(01)90012345678908(3102)001750(13)100312");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string18()  {
+fn testDecodeRow2string18() {
     assertCorrectImage2string("18.png", "(01)90012345678908(3202)001750(13)100312");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string19()  {
+fn testDecodeRow2string19() {
     assertCorrectImage2string("19.png", "(01)90012345678908(3102)001750(15)100312");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string20()  {
+fn testDecodeRow2string20() {
     assertCorrectImage2string("20.png", "(01)90012345678908(3202)001750(15)100312");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string21()  {
+fn testDecodeRow2string21() {
     assertCorrectImage2string("21.png", "(01)90012345678908(3102)001750(17)100312");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string22()  {
+fn testDecodeRow2string22() {
     assertCorrectImage2string("22.png", "(01)90012345678908(3202)001750(17)100312");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string25()  {
+fn testDecodeRow2string25() {
     assertCorrectImage2string("25.png", "(10)123");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string26()  {
+fn testDecodeRow2string26() {
     assertCorrectImage2string("26.png", "(10)5678(11)010101");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string27()  {
+fn testDecodeRow2string27() {
     assertCorrectImage2string("27.png", "(10)1098-1234");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string28()  {
+fn testDecodeRow2string28() {
     assertCorrectImage2string("28.png", "(10)1098/1234");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string29()  {
+fn testDecodeRow2string29() {
     assertCorrectImage2string("29.png", "(10)1098.1234");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string30()  {
+fn testDecodeRow2string30() {
     assertCorrectImage2string("30.png", "(10)1098*1234");
-  }
+}
 
-  #[test]
+#[test]
-  fn  testDecodeRow2string31()  {
+fn testDecodeRow2string31() {
     assertCorrectImage2string("31.png", "(10)1098,1234");
-  }
+}
 
-  #[test]
+#[test]
-  fn testDecodeRow2string32()  {
+fn testDecodeRow2string32() {
-    assertCorrectImage2string("32.png", "(15)991231(3103)001750(10)12A(422)123(21)123456(423)0123456789012");
+    assertCorrectImage2string(
-  }
+        "32.png",
+        "(15)991231(3103)001750(10)12A(422)123(21)123456(423)0123456789012",
+    );
+}
 
-  fn assertCorrectImage2string( fileName:&str, expected:&str)
+fn assertCorrectImage2string(fileName: &str, expected: &str) {
-      {
+    let path = format!("test_resources/blackbox/rssexpanded-1/{}", fileName);
-    let path = format!("test_resources/blackbox/rssexpanded-1/{}",fileName);
 
     let image = image::open(path).expect("load image");
-    let binaryMap =
+    let binaryMap = BinaryBitmap::new(Rc::new(GlobalHistogramBinarizer::new(Box::new(
-         BinaryBitmap::new(Rc::new(GlobalHistogramBinarizer::new(Box::new(BufferedImageLuminanceSource::new(image)))));
+        BufferedImageLuminanceSource::new(image),
+    ))));
     let rowNumber = binaryMap.getHeight() / 2;
-    let row = binaryMap.getBlackRow(rowNumber, &mut BitArray::new()).expect("get row");
+    let row = binaryMap
-
+        .getBlackRow(rowNumber, &mut BitArray::new())
-    let mut rssExpandedReader =  RSSExpandedReader::new();
+        .expect("get row");
-    let result = rssExpandedReader.decodeRow(rowNumber as u32, &row, &HashMap::new()).expect("should decode");
-
 
+    let mut rssExpandedReader = RSSExpandedReader::new();
+    let result = rssExpandedReader
+        .decodeRow(rowNumber as u32, &row, &HashMap::new())
+        .expect("should decode");
 
     assert_eq!(&BarcodeFormat::RSS_EXPANDED, result.getBarcodeFormat());
     assert_eq!(expected, result.getText());
-  }
+}
-

src/oned/rss/expanded/rss_expanded_reader.rs

@@ -142,9 +142,9 @@ pub struct RSSExpandedReader {
     oddCounts: [u32; 4],
     evenCounts: [u32; 4],
 
-     pub(super) pairs: Vec<ExpandedPair>, //new ArrayList<>(MAX_PAIRS);
+    pub(super) pairs: Vec<ExpandedPair>, //new ArrayList<>(MAX_PAIRS);
-     pub(super) rows: Vec<ExpandedRow>,   // new ArrayList<>();
+    pub(super) rows: Vec<ExpandedRow>,   // new ArrayList<>();
-    startEnd: [u32; 2],       // new int[2];
+    startEnd: [u32; 2],                  // new int[2];
     startFromEven: bool,
 }
 impl AbstractRSSReaderTrait for RSSExpandedReader {}
@@ -534,8 +534,8 @@ impl RSSExpandedReader {
         &mut self.rows
     }
     #[cfg(test)]
-    pub(crate) fn getRows(& self) -> & [ExpandedRow] {
+    pub(crate) fn getRows(&self) -> &[ExpandedRow] {
-        & self.rows
+        &self.rows
     }
 
     // Not private for unit testing

src/oned/rss/expanded/rss_expanded_stacked_internal_test_case.rs

@@ -24,60 +24,75 @@
  *   http://www.piramidepse.com/
  */
 
-use crate::{Exceptions, common::BitArray, oned::rss::expanded::ExpandedPair, Reader};
+use crate::{common::BitArray, oned::rss::expanded::ExpandedPair, Exceptions, Reader};
-
-use super::{RSSExpandedReader, test_case_util};
 
+use super::{test_case_util, RSSExpandedReader};
 
 /**
  * Tests {@link RSSExpandedReader} handling of stacked RSS barcodes.
  */
 
-
+#[test]
-  #[test]
+fn testDecodingRowByRow() {
-  fn testDecodingRowByRow()  {
+    let mut rssExpandedReader = RSSExpandedReader::new();
-    let mut rssExpandedReader =  RSSExpandedReader::new();
 
     let binaryMap = test_case_util::getBinaryBitmap("1000.png");
 
     let firstRowNumber = binaryMap.getHeight() / 3;
-    let firstRow = binaryMap.getBlackRow(firstRowNumber, &mut BitArray::new()).expect("get row");
+    let firstRow = binaryMap
-    
+        .getBlackRow(firstRowNumber, &mut BitArray::new())
+        .expect("get row");
+
     // let tester = ;
 
-    assert!(|| -> Result<Vec<ExpandedPair>,Exceptions> {
+    assert!(|| -> Result<Vec<ExpandedPair>, Exceptions> {
-      rssExpandedReader.decodeRow2pairs(firstRowNumber as u32, &firstRow)
+        rssExpandedReader.decodeRow2pairs(firstRowNumber as u32, &firstRow)
-      // fail(NotFoundException.class.getName() + " expected");
+        // fail(NotFoundException.class.getName() + " expected");
-    }().is_err());
+    }()
-    
+    .is_err());
 
     assert_eq!(1, rssExpandedReader.getRows().len());
     let firstExpandedRow = &mut rssExpandedReader.rows[0]; //&mut rssExpandedReader.getRowsMut()[0];//.expect("not None");
-    
+
     assert_eq!(firstRowNumber as u32, firstExpandedRow.getRowNumber());
 
     assert_eq!(2, firstExpandedRow.getPairs().len());
 
-    firstExpandedRow.getPairsMut()[1].getFinderPatternMut().as_mut().unwrap().getStartEndMut()[1] = 0;
+    firstExpandedRow.getPairsMut()[1]
-    rssExpandedReader.pairs.last_mut().as_mut().unwrap().getFinderPatternMut().as_mut().unwrap().getStartEndMut()[1] = 0;
+        .getFinderPatternMut()
+        .as_mut()
+        .unwrap()
+        .getStartEndMut()[1] = 0;
+    rssExpandedReader
+        .pairs
+        .last_mut()
+        .as_mut()
+        .unwrap()
+        .getFinderPatternMut()
+        .as_mut()
+        .unwrap()
+        .getStartEndMut()[1] = 0;
 
     let secondRowNumber = 2 * binaryMap.getHeight() / 3;
-    let mut secondRow = binaryMap.getBlackRow(secondRowNumber, &mut BitArray::new()).expect("get row");
+    let mut secondRow = binaryMap
+        .getBlackRow(secondRowNumber, &mut BitArray::new())
+        .expect("get row");
     secondRow.reverse();
 
-    let totalPairs = rssExpandedReader.decodeRow2pairs(secondRowNumber as u32, &secondRow).expect("decode pairs");
+    let totalPairs = rssExpandedReader
+        .decodeRow2pairs(secondRowNumber as u32, &secondRow)
+        .expect("decode pairs");
 
     let result = RSSExpandedReader::constructRXingResult(&totalPairs).expect("construct");
     assert_eq!("(01)98898765432106(3202)012345(15)991231", result.getText());
-  }
+}
 
-  #[test]
+#[test]
-  fn testCompleteDecode() {
+fn testCompleteDecode() {
-    let mut rssExpandedReader =  RSSExpandedReader::new();
+    let mut rssExpandedReader = RSSExpandedReader::new();
 
     let binaryMap = test_case_util::getBinaryBitmap("1000.png");
 
     let result = rssExpandedReader.decode(&binaryMap).expect("decode");
     assert_eq!("(01)98898765432106(3202)012345(15)991231", result.getText());
-  }
+}
-

src/oned/rss/expanded/test_case_util.rs

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

src/oned/rss/finder_pattern.rs

@@ -49,7 +49,7 @@ impl FinderPattern {
     }
 
     #[cfg(test)]
-    pub(crate)fn getStartEndMut(&mut self) -> &mut [usize]{
+    pub(crate) fn getStartEndMut(&mut self) -> &mut [usize] {
         &mut self.startEnd
     }