diff --git a/Cargo.toml b/Cargo.toml index 27b8157..33e1771 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -27,6 +27,7 @@ num = "0.4.0" [dev-dependencies] java-properties = "1.4.1" +java-rand = "0.2.0" [features] default = ["image"] diff --git a/src/multi/qrcode/qr_code_multi_reader.rs b/src/multi/qrcode/qr_code_multi_reader.rs index b01f31b..e050dd3 100644 --- a/src/multi/qrcode/qr_code_multi_reader.rs +++ b/src/multi/qrcode/qr_code_multi_reader.rs @@ -59,13 +59,14 @@ impl MultipleBarcodeReader for QRCodeMultiReader { )?; let mut points = detectorRXingResult.getPoints().clone(); // If the code was mirrored: swap the bottom-left and the top-right points. - if let Some( other) = decoderRXingResult.getOther(){ - if other.is::() { - (other - .downcast::() - .expect("must downcast to QRCodeDecoderMetaData")) - .applyMirroredCorrection(&mut points); - }} + if let Some(other) = decoderRXingResult.getOther() { + if other.is::() { + (other + .downcast::() + .expect("must downcast to QRCodeDecoderMetaData")) + .applyMirroredCorrection(&mut points); + } + } // if (decoderRXingResult.getOther() instanceof QRCodeDecoderMetaData) { // ((QRCodeDecoderMetaData) decoderRXingResult.getOther()).applyMirroredCorrection(points); // } diff --git a/src/pdf417/decoder/decoded_bit_stream_parser.rs b/src/pdf417/decoder/decoded_bit_stream_parser.rs index 319aa31..170a688 100644 --- a/src/pdf417/decoder/decoded_bit_stream_parser.rs +++ b/src/pdf417/decoder/decoded_bit_stream_parser.rs @@ -180,9 +180,13 @@ pub fn decode(codewords: &[u32], ecLevel: &str) -> Result { let mut fileName = ECIStringBuilder::new(); codeIndex = textCompaction(codewords, codeIndex + 1, &mut fileName)?; + fileName = fileName.build_result(); resultMetadata.setFileName(fileName.to_string()); } MACRO_PDF417_OPTIONAL_FIELD_SENDER => { let mut sender = ECIStringBuilder::new(); codeIndex = textCompaction(codewords, codeIndex + 1, &mut sender)?; + sender = sender.build_result(); resultMetadata.setSender(sender.to_string()); } MACRO_PDF417_OPTIONAL_FIELD_ADDRESSEE => { let mut addressee = ECIStringBuilder::new(); codeIndex = textCompaction(codewords, codeIndex + 1, &mut addressee)?; + addressee = addressee.build_result(); resultMetadata.setAddressee(addressee.to_string()); } MACRO_PDF417_OPTIONAL_FIELD_SEGMENT_COUNT => { let mut segmentCount = ECIStringBuilder::new(); codeIndex = numericCompaction(codewords, codeIndex + 1, &mut segmentCount)?; + segmentCount = segmentCount.build_result(); resultMetadata.setSegmentCount(segmentCount.to_string().parse().unwrap()); } MACRO_PDF417_OPTIONAL_FIELD_TIME_STAMP => { let mut timestamp = ECIStringBuilder::new(); codeIndex = numericCompaction(codewords, codeIndex + 1, &mut timestamp)?; + timestamp = timestamp.build_result(); resultMetadata.setTimestamp(timestamp.to_string().parse().unwrap()); } MACRO_PDF417_OPTIONAL_FIELD_CHECKSUM => { let mut checksum = ECIStringBuilder::new(); codeIndex = numericCompaction(codewords, codeIndex + 1, &mut checksum)?; + checksum = checksum.build_result(); resultMetadata.setChecksum(checksum.to_string().parse().unwrap()); } MACRO_PDF417_OPTIONAL_FIELD_FILE_SIZE => { let mut fileSize = ECIStringBuilder::new(); codeIndex = numericCompaction(codewords, codeIndex + 1, &mut fileSize)?; + fileSize = fileSize.build_result(); resultMetadata.setFileSize(fileSize.to_string().parse().unwrap()); } _ => return Err(Exceptions::FormatException("".to_owned())), diff --git a/src/pdf417/decoder/pdf_417_decoder_test_case.rs b/src/pdf417/decoder/pdf_417_decoder_test_case.rs index 7dd923050..7305fb7 100644 --- a/src/pdf417/decoder/pdf_417_decoder_test_case.rs +++ b/src/pdf417/decoder/pdf_417_decoder_test_case.rs @@ -14,31 +14,31 @@ * limitations under the License. */ -use encoding::{EncodingRef, Encoding}; -use rand::{self, Rng}; -use rand::rngs::ThreadRng; +use encoding::{Encoding, EncodingRef}; +use java_rand; -use crate::pdf417::PDF417RXingResultMetadata; use crate::pdf417::decoder::decoded_bit_stream_parser; use crate::pdf417::encoder::{pdf_417_high_level_encoder_test_adapter, Compaction}; - +use crate::pdf417::PDF417RXingResultMetadata; /** * Tests {@link DecodedBitStreamParser}. */ +/** + * Tests the first sample given in ISO/IEC 15438:2015(E) - Annex H.4 + */ +#[test] +fn testStandardSample1() { + let mut resultMetadata = PDF417RXingResultMetadata::default(); + let sampleCodes: [u32; 23] = [ + 20, 928, 111, 100, 17, 53, 923, 1, 111, 104, 923, 3, 64, 416, 34, 923, 4, 258, 446, 67, + // we should never reach these + 1000, 1000, 1000, + ]; - /** - * Tests the first sample given in ISO/IEC 15438:2015(E) - Annex H.4 - */ - #[test] - fn testStandardSample1() { - let mut resultMetadata = PDF417RXingResultMetadata::default(); - let sampleCodes:[u32;23] = [20, 928, 111, 100, 17, 53, 923, 1, 111, 104, 923, 3, 64, 416, 34, 923, 4, 258, 446, 67, - // we should never reach these - 1000, 1000, 1000]; - - decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 2,&mut resultMetadata); + decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 2, &mut resultMetadata) + .expect("decode"); assert_eq!(0, resultMetadata.getSegmentIndex()); assert_eq!("017053", resultMetadata.getFileId()); @@ -48,23 +48,30 @@ use crate::pdf417::encoder::{pdf_417_high_level_encoder_test_adapter, Compaction assert_eq!("ISO CH", resultMetadata.getAddressee()); let optionalData = resultMetadata.getOptionalData(); - assert_eq!( 1, optionalData[0],"first element of optional array should be the first field identifier"); assert_eq!( - 67, optionalData[optionalData.len() - 1],"last element of optional array should be the last codeword of the last field"); - } + 1, optionalData[0], + "first element of optional array should be the first field identifier" + ); + assert_eq!( + 67, + optionalData[optionalData.len() - 1], + "last element of optional array should be the last codeword of the last field" + ); +} +/** + * Tests the second given in ISO/IEC 15438:2015(E) - Annex H.4 + */ +#[test] +fn testStandardSample2() { + let mut resultMetadata = PDF417RXingResultMetadata::default(); + let sampleCodes: [u32; 14] = [ + 11, 928, 111, 103, 17, 53, 923, 1, 111, 104, 922, // we should never reach these + 1000, 1000, 1000, + ]; - /** - * Tests the second given in ISO/IEC 15438:2015(E) - Annex H.4 - */ - #[test] - fn testStandardSample2() { - let mut resultMetadata = PDF417RXingResultMetadata::default(); - let sampleCodes :[u32;14]= [11, 928, 111, 103, 17, 53, 923, 1, 111, 104, 922, - // we should never reach these - 1000, 1000, 1000]; - - decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 2, &mut resultMetadata); + decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 2, &mut resultMetadata) + .expect("decode"); assert_eq!(3, resultMetadata.getSegmentIndex()); assert_eq!("017053", resultMetadata.getFileId()); @@ -73,24 +80,28 @@ use crate::pdf417::encoder::{pdf_417_high_level_encoder_test_adapter, Compaction assert!(resultMetadata.getAddressee().is_empty()); assert!(resultMetadata.getSender().is_empty()); - let optionalData = resultMetadata.getOptionalData(); - assert_eq!( 1, optionalData[0],"first element of optional array should be the first field identifier"); assert_eq!( - 104, optionalData[optionalData.len() - 1],"last element of optional array should be the last codeword of the last field"); - } + 1, optionalData[0], + "first element of optional array should be the first field identifier" + ); + assert_eq!( + 104, + optionalData[optionalData.len() - 1], + "last element of optional array should be the last codeword of the last field" + ); +} +/** + * Tests the example given in ISO/IEC 15438:2015(E) - Annex H.6 + */ +#[test] +fn testStandardSample3() { + let mut resultMetadata = PDF417RXingResultMetadata::default(); + let sampleCodes = [7_u32, 928, 111, 100, 100, 200, 300, 0]; // Final dummy ECC codeword required to avoid ArrayIndexOutOfBounds - /** - * Tests the example given in ISO/IEC 15438:2015(E) - Annex H.6 - */ - #[test] - fn testStandardSample3() { - let mut resultMetadata = PDF417RXingResultMetadata::default(); - let sampleCodes = [7_u32, 928, 111, 100, 100, 200, 300, - 0]; // Final dummy ECC codeword required to avoid ArrayIndexOutOfBounds - - decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 2, &mut resultMetadata); + decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 2, &mut resultMetadata) + .expect("decode"); assert_eq!(0, resultMetadata.getSegmentIndex()); assert_eq!("100200300", resultMetadata.getFileId()); @@ -103,17 +114,20 @@ use crate::pdf417::encoder::{pdf_417_high_level_encoder_test_adapter, Compaction // Check that symbol containing no data except Macro is accepted (see note in Annex H.2) let decoderRXingResult = decoded_bit_stream_parser::decode(&sampleCodes, "0").expect("decode"); assert_eq!("", decoderRXingResult.getText()); - assert!(!decoderRXingResult.getOther().is_some()); - } + assert!(decoderRXingResult.getOther().is_some()); +} - #[test] - fn testSampleWithFilename() { - let sampleCodes = [23_u32, 477, 928, 111, 100, 0, 252, 21, 86, 923, 0, 815, 251, 133, 12, 148, 537, 593, - 599, 923, 1, 111, 102, 98, 311, 355, 522, 920, 779, 40, 628, 33, 749, 267, 506, 213, 928, 465, 248, - 493, 72, 780, 699, 780, 493, 755, 84, 198, 628, 368, 156, 198, 809, 19, 113]; - let mut resultMetadata = PDF417RXingResultMetadata::default(); +#[test] +fn testSampleWithFilename() { + let sampleCodes = [ + 23_u32, 477, 928, 111, 100, 0, 252, 21, 86, 923, 0, 815, 251, 133, 12, 148, 537, 593, 599, + 923, 1, 111, 102, 98, 311, 355, 522, 920, 779, 40, 628, 33, 749, 267, 506, 213, 928, 465, + 248, 493, 72, 780, 699, 780, 493, 755, 84, 198, 628, 368, 156, 198, 809, 19, 113, + ]; + let mut resultMetadata = PDF417RXingResultMetadata::default(); - decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 3, &mut resultMetadata).expect("decode"); + decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 3, &mut resultMetadata) + .expect("decode"); assert_eq!(0, resultMetadata.getSegmentIndex()); assert_eq!("000252021086", resultMetadata.getFileId()); @@ -122,80 +136,91 @@ use crate::pdf417::encoder::{pdf_417_high_level_encoder_test_adapter, Compaction assert!(resultMetadata.getAddressee().is_empty()); assert!(resultMetadata.getSender().is_empty()); assert_eq!("filename.txt", resultMetadata.getFileName()); - } +} - #[test] - fn testSampleWithNumericValues() { - let sampleCodes = [25_u32, 477, 928, 111, 100, 0, 252, 21, 86, 923, 2, 2, 0, 1, 0, 0, 0, 923, 5, 130, 923, - 6, 1, 500, 13, 0]; - let mut resultMetadata = PDF417RXingResultMetadata::default(); +#[test] +fn testSampleWithNumericValues() { + let sampleCodes = [ + 25_u32, 477, 928, 111, 100, 0, 252, 21, 86, 923, 2, 2, 0, 1, 0, 0, 0, 923, 5, 130, 923, 6, + 1, 500, 13, 0, + ]; + let mut resultMetadata = PDF417RXingResultMetadata::default(); - decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 3, &mut resultMetadata).expect("decode"); + decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 3, &mut resultMetadata) + .expect("decode"); assert_eq!(0, resultMetadata.getSegmentIndex()); assert_eq!("000252021086", resultMetadata.getFileId()); - assert!( !resultMetadata.isLastSegment() ); + assert!(!resultMetadata.isLastSegment()); assert_eq!(180980729000000, resultMetadata.getTimestamp()); assert_eq!(30, resultMetadata.getFileSize()); assert_eq!(260013, resultMetadata.getChecksum()); - } +} - #[test] - fn testSampleWithMacroTerminatorOnly() { +#[test] +fn testSampleWithMacroTerminatorOnly() { let sampleCodes = [7_u32, 477, 928, 222, 198, 0, 922]; let mut resultMetadata = PDF417RXingResultMetadata::default(); - decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 3, &mut resultMetadata).expect("decode"); + decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 3, &mut resultMetadata) + .expect("decode"); assert_eq!(99998, resultMetadata.getSegmentIndex()); assert_eq!("000", resultMetadata.getFileId()); assert!(resultMetadata.isLastSegment()); assert_eq!(-1, resultMetadata.getSegmentCount()); assert!(resultMetadata.getOptionalData().is_empty()); - } +} - #[test] - #[should_panic] - fn testSampleWithBadSequenceIndexMacro() { +#[test] +#[should_panic] +fn testSampleWithBadSequenceIndexMacro() { let sampleCodes = [3_u32, 928, 222, 0]; - let mut resultMetadata = PDF417RXingResultMetadata::default(); - decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 2, &mut resultMetadata).expect("decode"); - } + let mut resultMetadata = PDF417RXingResultMetadata::default(); + decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 2, &mut resultMetadata) + .expect("decode"); +} - #[test] - #[should_panic] - fn testSampleWithNoFileIdMacro() { +#[test] +#[should_panic] +fn testSampleWithNoFileIdMacro() { let sampleCodes = [4_u32, 928, 222, 198, 0]; - let mut resultMetadata = PDF417RXingResultMetadata::default(); - decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 2, &mut resultMetadata).expect("decode"); - } + let mut resultMetadata = PDF417RXingResultMetadata::default(); + decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 2, &mut resultMetadata) + .expect("decode"); +} - #[test] - #[should_panic] - fn testSampleWithNoDataNoMacro() { +#[test] +#[should_panic] +fn testSampleWithNoDataNoMacro() { let sampleCodes = [3_u32, 899, 899, 0]; decoded_bit_stream_parser::decode(&sampleCodes, "0").expect("decode"); - } +} - #[test] - fn testUppercase() { +#[test] +fn testUppercase() { //encodeDecode("", 0); - performEncodeTest('A', &[ 3, 4, 5, 6, 4, 4, 5, 5]); - } + performEncodeTest('A', &[3, 4, 5, 6, 4, 4, 5, 5]); +} - #[test] - fn testNumeric() { - performEncodeTest('1', &[ 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10]); - } +#[test] +fn testNumeric() { + performEncodeTest( + '1', + &[ + 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, + ], + ); +} - #[test] - fn testByte(){ - performEncodeTest('\u{00c4}', &[ 3, 4, 5, 6, 7, 7, 8]); - } +#[test] +fn testByte() { + performEncodeTest('\u{00c4}', &[3, 4, 5, 6, 7, 7, 8]); +} - #[test] - fn testUppercaseLowercaseMix1(){ +#[test] +fn testUppercaseLowercaseMix1() { encodeDecodeWithLength("aA", 4); encodeDecodeWithLength("aAa", 5); encodeDecodeWithLength("Aa", 4); @@ -206,249 +231,315 @@ use crate::pdf417::encoder::{pdf_417_high_level_encoder_test_adapter, Compaction encodeDecodeWithLength("AaAaA", 5); encodeDecodeWithLength("AaaAaaA", 6); encodeDecodeWithLength("AaaAAaaA", 7); - } +} - #[test] - fn testPunctuation(){ - performEncodeTest(';', &[ 3, 4, 5, 6, 6, 7, 8]); +#[test] +fn testPunctuation() { + performEncodeTest(';', &[3, 4, 5, 6, 6, 7, 8]); encodeDecodeWithLength(";;;;;;;;;;;;;;;;", 17); - } +} - #[test] - fn testUppercaseLowercaseMix2(){ +#[test] +fn testUppercaseLowercaseMix2() { performPermutationTest(&['A', 'a'], 10, 8972); - } +} - #[test] - fn testUppercaseNumericMix() { +#[test] +fn testUppercaseNumericMix() { performPermutationTest(&['A', '1'], 14, 192510); - } +} - #[test] - fn testUppercaseMixedMix() { +#[test] +fn testUppercaseMixedMix() { performPermutationTest(&['A', '1', ' ', ';'], 7, 106060); - } +} - #[test] - fn testUppercasePunctuationMix(){ +#[test] +fn testUppercasePunctuationMix() { performPermutationTest(&['A', ';'], 10, 8967); - } +} - #[test] - fn testUppercaseByteMix() { +#[test] +fn testUppercaseByteMix() { performPermutationTest(&['A', '\u{00c4}'], 10, 11222); - } +} - #[test] - fn testLowercaseByteMix(){ +#[test] +fn testLowercaseByteMix() { performPermutationTest(&['a', '\u{00c4}'], 10, 11233); - } +} - #[test] - fn testUppercaseLowercaseNumericMix(){ +#[test] +fn testUppercaseLowercaseNumericMix() { performPermutationTest(&['A', 'a', '1'], 7, 15491); - } +} - #[test] - fn testUppercaseLowercasePunctuationMix() { +#[test] +fn testUppercaseLowercasePunctuationMix() { performPermutationTest(&['A', 'a', ';'], 7, 15491); - } +} - #[test] - fn testUppercaseLowercaseByteMix() { +#[test] +fn testUppercaseLowercaseByteMix() { performPermutationTest(&['A', 'a', '\u{00c4}'], 7, 17288); - } +} - #[test] - fn testLowercasePunctuationByteMix(){ +#[test] +fn testLowercasePunctuationByteMix() { performPermutationTest(&['a', ';', '\u{00c4}'], 7, 17427); - } +} - #[test] - fn testUppercaseLowercaseNumericPunctuationMix(){ +#[test] +fn testUppercaseLowercaseNumericPunctuationMix() { performPermutationTest(&['A', 'a', '1', ';'], 7, 120479); - } +} - #[test] - fn testBinaryData() { - // let bytes = [0_u8;500]; +#[test] +fn testBinaryData() { + let mut bytes = [0_u8; 500]; // let random = rand::thread_rng(); + let mut random = java_rand::Random::new(0); let mut total = 0; - for i in 0..10000 { - // for (int i = 0; i < 10000; i++) { - let bytes = gen_500_random_bytes(); - - total += encodeDecode(&encoding::all::ISO_8859_1.decode(&bytes, encoding::DecoderTrap::Strict).expect("decode bytes")); + for _i in 0..10000 { + // for (int i = 0; i < 10000; i++) { + // let bytes = gen_500_random_bytes(); + random.next_bytes(&mut bytes); + + total += encodeDecode( + &encoding::all::ISO_8859_1 + .decode(&bytes, encoding::DecoderTrap::Strict) + .expect("decode bytes"), + ); } assert_eq!(4190044, total); - } +} - fn gen_500_random_bytes() -> [u8;500] { - let mut bytes = [0_u8;500]; - let mut random = rand::thread_rng(); - for i in 0..500 { - bytes[i] = random.gen(); - } - bytes - } +// fn gen_500_random_bytes() -> [u8;500] { +// let mut bytes = [0_u8;500]; +// let mut random = rand::thread_rng(); +// for i in 0..500 { +// bytes[i] = random.gen(); +// } +// bytes +// } - #[test] - fn testECIEnglishHiragana(){ +#[test] +fn testECIEnglishHiragana() { //multi ECI UTF-8, UTF-16 and ISO-8859-1 - performECITest(&['a', '1', '\u{3040}'], &mut [20.0, 1.0, 10.0], 105825, 110914); - } + performECITest( + &['a', '1', '\u{3040}'], + &mut [20.0, 1.0, 10.0], + 105825, + 110914, + ); +} - #[test] - fn testECIEnglishKatakana() { +#[test] +fn testECIEnglishKatakana() { //multi ECI UTF-8, UTF-16 and ISO-8859-1 - performECITest(&['a', '1', '\u{30a0}'], &mut [20.0, 1.0, 10.0], 109177, 110914); - } + performECITest( + &['a', '1', '\u{30a0}'], + &mut [20.0, 1.0, 10.0], + 109177, + 110914, + ); +} - #[test] - fn testECIEnglishHalfWidthKatakana(){ +#[test] +fn testECIEnglishHalfWidthKatakana() { //single ECI - performECITest(&['a', '1', '\u{ff80}'], &mut [20.0, 1.0, 10.0], 80617, 110914); - } + performECITest( + &['a', '1', '\u{ff80}'], + &mut [20.0, 1.0, 10.0], + 80617, + 110914, + ); +} - #[test] - fn testECIEnglishChinese() { +#[test] +fn testECIEnglishChinese() { //single ECI - performECITest(&['a', '1', '\u{4e00}'], &mut [20.0, 1.0, 10.0], 95797, 110914); - } + performECITest( + &['a', '1', '\u{4e00}'], + &mut [20.0, 1.0, 10.0], + 95797, + 110914, + ); +} - #[test] - fn testECIGermanCyrillic(){ +#[test] +fn testECIGermanCyrillic() { //single ECI since the German Umlaut is in ISO-8859-1 - performECITest(&['a', '1', '\u{00c4}', '\u{042f}'], &mut [20.0, 1.0, 1.0, 10.0], 80755, 96007); - } + performECITest( + &['a', '1', '\u{00c4}', '\u{042f}'], + &mut [20.0, 1.0, 1.0, 10.0], + 80755, + 96007, + ); +} - #[test] - fn testECIEnglishCzechCyrillic1() { +#[test] +fn testECIEnglishCzechCyrillic1() { //multi ECI between ISO-8859-2 and ISO-8859-5 - performECITest(&['a', '1', '\u{010c}', '\u{042f}'], &mut [10.0, 1.0, 10.0, 10.0], 102824, 124525); - } + performECITest( + &['a', '1', '\u{010c}', '\u{042f}'], + &mut [10.0, 1.0, 10.0, 10.0], + 102824, + 124525, + ); +} - #[test] - fn testECIEnglishCzechCyrillic2() { +#[test] +fn testECIEnglishCzechCyrillic2() { //multi ECI between ISO-8859-2 and ISO-8859-5 - performECITest(&['a', '1', '\u{010c}', '\u{042f}'], &mut [40.0, 1.0, 10.0, 10.0], 81321, 88236); - } + performECITest( + &['a', '1', '\u{010c}', '\u{042f}'], + &mut [40.0, 1.0, 10.0, 10.0], + 81321, + 88236, + ); +} - #[test] - fn testECIEnglishArabicCyrillic() { +#[test] +fn testECIEnglishArabicCyrillic() { //multi ECI between UTF-8 (ISO-8859-6 is excluded in CharacterSetECI) and ISO-8859-5 - performECITest(&['a', '1', '\u{0620}', '\u{042f}'], &mut [10.0, 1.0, 10.0, 10.0], 118510, 124525); - } + performECITest( + &['a', '1', '\u{0620}', '\u{042f}'], + &mut [10.0, 1.0, 10.0, 10.0], + 118510, + 124525, + ); +} - #[test] - fn testBinaryMultiECI() { +#[test] +fn testBinaryMultiECI() { //Test the cases described in 5.5.5.3 "ECI and Byte Compaction mode using latch 924 and 901" performDecodeTest(&[5, 927, 4, 913, 200], "\u{010c}"); performDecodeTest(&[9, 927, 4, 913, 200, 927, 7, 913, 207], "\u{010c}\u{042f}"); performDecodeTest(&[9, 927, 4, 901, 200, 927, 7, 901, 207], "\u{010c}\u{042f}"); performDecodeTest(&[8, 927, 4, 901, 200, 927, 7, 207], "\u{010c}\u{042f}"); - performDecodeTest(&[14, 927, 4, 901, 200, 927, 7, 207, 927, 4, 200, 927, 7, 207], - "\u{010c}\u{042f}\u{010c}\u{042f}"); + performDecodeTest( + &[14, 927, 4, 901, 200, 927, 7, 207, 927, 4, 200, 927, 7, 207], + "\u{010c}\u{042f}\u{010c}\u{042f}", + ); performDecodeTest(&[16, 927, 4, 924, 336, 432, 197, 51, 300, 927, 7, 348, 231, 311, 858, 567], "\u{010c}\u{010c}\u{010c}\u{010c}\u{010c}\u{010c}\u{042f}\u{042f}\u{042f}\u{042f}\u{042f}\u{042f}"); - } +} - fn encodeDecodeWithLength( input:&str, expectedLength:u32) { +fn encodeDecodeWithLength(input: &str, expectedLength: u32) { assert_eq!(expectedLength, encodeDecode(input)); - } +} - fn encodeDecode( input:&str) -> u32 { +fn encodeDecode(input: &str) -> u32 { return encodeDecodeWithAll(input, None, false, true); - } +} - fn encodeDecodeWithAll( input:&str, charset:Option, autoECI:bool, decode:bool) - -> u32 { - let s = pdf_417_high_level_encoder_test_adapter::encodeHighLevel(input, Compaction::AUTO, charset, autoECI).expect("encode"); +fn encodeDecodeWithAll( + input: &str, + charset: Option, + autoECI: bool, + decode: bool, +) -> u32 { + let s = pdf_417_high_level_encoder_test_adapter::encodeHighLevel( + input, + Compaction::AUTO, + charset, + autoECI, + ) + .expect("encode"); if decode { - let mut codewords = vec![0_u32;s.chars().count() + 1]; - codewords[0] = codewords.len() as u32; - for i in 1..codewords.len() { - // for (int i = 1; i < codewords.length; i++) { - codewords[i] = s.chars().nth(i - 1).unwrap() as u32; - } - performDecodeTest(&codewords, input); + let mut codewords = vec![0_u32; s.chars().count() + 1]; + codewords[0] = codewords.len() as u32; + for i in 1..codewords.len() { + // for (int i = 1; i < codewords.length; i++) { + codewords[i] = s.chars().nth(i - 1).unwrap() as u32; + } + performDecodeTest(&codewords, input); } - s.chars().count() as u32 + 1 - } + s.chars().count() as u32 + 1 +} - fn getEndIndex( length:u32, chars:&[char]) -> u32{ - let decimalLength : f64 = (chars.len() as f64).log10(); //Math.log10(chars.length); - (decimalLength*length as f64).powi(10).ceil() as u32 +fn getEndIndex(length: u32, chars: &[char]) -> u32 { + let decimalLength: f64 = (chars.len() as f64).log10(); //Math.log10(chars.length); + 10_f64.powf((decimalLength * length as f64)).ceil() as u32 + // (decimalLength*length as f64).powi(10).ceil() as u32 + // (decimalLength*length as f64).powi(10).ceil() as u32 // Math.ceil(Math.pow(10, decimalLength * length)) - } +} - fn generatePermutation( index:u32, length:u32, chars:&[char]) -> String{ - let N = chars.len() as u32; +fn generatePermutation(index: u32, length: u32, chars: &[char]) -> String { + let N = chars.len(); // let baseNNumber = Integer.toString(index, N); - let mut baseNNumber= int_to_string(index,N); + let mut baseNNumber = int_to_string(index, N); while baseNNumber.chars().count() < length as usize { - baseNNumber.insert(0, '0'); - // baseNNumber = "0" + baseNNumber; + baseNNumber.insert(0, '0'); + // baseNNumber = "0" + baseNNumber; } let mut prefix = String::from(""); for ch in baseNNumber.chars() { - prefix.push(chars[ch as usize - '0' as usize]); - } + prefix.push(chars[(ch as isize - '0' as isize) as usize]); + } // for i in 0..baseNNumber.chars().count() { // // for (int i = 0; i < baseNNumber.length(); i++) { // prefix += chars[baseNNumber.charAt(i) - '0']; // } - prefix - } +} - fn performPermutationTest( chars:&[char], length:u32, expectedTotal:u32) { +fn performPermutationTest(chars: &[char], length: u32, expectedTotal: u32) { let endIndex = getEndIndex(length, chars); let mut total = 0; for i in 0..endIndex { - // for (int i = 0; i < endIndex; i++) { - total += encodeDecode(&generatePermutation(i, length, chars)); + // for (int i = 0; i < endIndex; i++) { + total += encodeDecode(&generatePermutation(i, length, chars)); } assert_eq!(expectedTotal, total); - } +} - fn performEncodeTest( c:char, expectedLengths:&[u32]) { +fn performEncodeTest(c: char, expectedLengths: &[u32]) { for i in 0..expectedLengths.len() { - // for (int i = 0; i < expectedLengths.length; i++) { - let mut sb = String::new();//new StringBuilder(); - for j in 0..=i { - // for (int j = 0; j <= i; j++) { - sb.push(c); - } - encodeDecodeWithLength(&sb, expectedLengths[i]); + // for (int i = 0; i < expectedLengths.length; i++) { + let mut sb = String::new(); //new StringBuilder(); + for _j in 0..=i { + // for (int j = 0; j <= i; j++) { + sb.push(c); + } + encodeDecodeWithLength(&sb, expectedLengths[i]); } - } +} - fn performDecodeTest(codewords:&[u32], expectedRXingResult:&str) { +fn performDecodeTest(codewords: &[u32], expectedRXingResult: &str) { let result = decoded_bit_stream_parser::decode(codewords, "0").expect("decode"); assert_eq!(expectedRXingResult, result.getText()); - } +} - fn performECITest( chars:&[char], - weights:&mut [f32], - expectedMinLength:u32, - expectedUTFLength:u32) { - let mut random = rand::thread_rng(); +fn performECITest( + chars: &[char], + weights: &mut [f32], + expectedMinLength: u32, + expectedUTFLength: u32, +) { + let mut random = java_rand::Random::new(0); let mut minLength = 0; let mut utfLength = 0; - for i in 0..1000 { - // for (int i = 0; i < 1000; i++) { - let s = generateText(&mut random, 100, chars, weights); - minLength += encodeDecodeWithAll(&s, None, true, true); - utfLength += encodeDecodeWithAll(&s, Some(encoding::all::UTF_8), false, true); + for _i in 0..1000 { + // for (int i = 0; i < 1000; i++) { + let s = generateText(&mut random, 100, chars, weights); + minLength += encodeDecodeWithAll(&s, None, true, true); + utfLength += encodeDecodeWithAll(&s, Some(encoding::all::UTF_8), false, true); } assert_eq!(expectedMinLength, minLength); assert_eq!(expectedUTFLength, utfLength); - } +} - fn generateText( random:&mut ThreadRng, maxWidth:u32, chars:&[char], weights:&mut [f32]) -> String{ - let mut result = String::new();//new StringBuilder(); +fn generateText( + random: &mut java_rand::Random, + maxWidth: u32, + chars: &[char], + weights: &mut [f32], +) -> String { + let mut result = String::new(); //new StringBuilder(); let maxWordWidth = 7; let mut total = 0.0; // for (int i = 0; i < weights.length; i++) { @@ -457,47 +548,47 @@ use crate::pdf417::encoder::{pdf_417_high_level_encoder_test_adapter, Compaction total += weights.iter().sum::(); for i in 0..weights.len() { - // for (int i = 0; i < weights.length; i++) { - weights[i] /= total; + // for (int i = 0; i < weights.length; i++) { + weights[i] /= total; } let mut cnt = 0; loop { - let mut maxValue = 0.0; - let mut maxIndex = 0; - for j in 0..weights.len() { - // for (int j = 0; j < weights.length; j++) { - let value = random.gen::() * weights[j]; - if value > maxValue { - maxValue = value; - maxIndex = j; + let mut maxValue = 0.0; + let mut maxIndex = 0; + for j in 0..weights.len() { + // for (int j = 0; j < weights.length; j++) { + let value = random.next_f32() * weights[j]; + if value > maxValue { + maxValue = value; + maxIndex = j; + } } - } - let wordLength = (maxWordWidth as f32 * random.gen::()) as i32; - if wordLength > 0 && result.chars().count() > 0 { - result.push(' '); - } - for j in 0..wordLength { - // for (int j = 0; j < wordLength; j++) { - let mut c = chars[maxIndex]; - if j == 0 && c >= 'a' && c <= 'z' && random.gen::() { - c = char::from_u32(c as u32- 'a' as u32 + 'A' as u32).unwrap(); + let wordLength = maxWordWidth as f32 * random.next_f32(); + if wordLength > 0.0 && result.chars().count() > 0 { + result.push(' '); } - result.push(c); - } - if cnt % 2 != 0 && random.gen_bool(0.51) { - result.push('.'); - } - cnt+=1; + for j in 0..wordLength.ceil() as u32 { + // for (int j = 0; j < wordLength; j++) { + let mut c = chars[maxIndex]; + if j == 0 && c >= 'a' && c <= 'z' && random.next_bool() { + c = char::from_u32(c as u32 - 'a' as u32 + 'A' as u32).unwrap(); + } + result.push(c); + } + if cnt % 2 != 0 && random.next_bool() { + result.push('.'); + } + cnt += 1; - if !(result.chars().count() < (maxWidth as isize - maxWordWidth as isize) as usize) { break } + if !(result.chars().count() < (maxWidth as isize - maxWordWidth as isize) as usize) { + break; + } } //while (result.length() < maxWidth - maxWordWidth); - + result - } +} - - fn int_to_string(x: u32, radix: u32) -> String { - let mut x = x; +fn int_to_string(x: u32, radix: usize) -> String { // Handle the special case of 0 if x == 0 { return "0".to_string(); @@ -506,12 +597,12 @@ use crate::pdf417::encoder::{pdf_417_high_level_encoder_test_adapter, Compaction // Build the string by repeatedly dividing the number by the radix and // adding the remainder to the beginning of the string let mut s = String::new(); + let mut x = x as usize; while x > 0 { let remainder = (x % radix) as u8; - s = (remainder as char).to_string() + &s; + s = (remainder).to_string() + &s; x /= radix; } s } - diff --git a/src/pdf417/encoder/pdf_417_high_level_encoder.rs b/src/pdf417/encoder/pdf_417_high_level_encoder.rs index 3bdd826..6d8671c 100644 --- a/src/pdf417/encoder/pdf_417_high_level_encoder.rs +++ b/src/pdf417/encoder/pdf_417_high_level_encoder.rs @@ -316,10 +316,11 @@ pub fn encodeHighLevel( } }; //.getBytes(encoding))}; // if let Some(byts) = bytes { - let bytes_ok = if let Some(_) = bytes { true } else { false }; - if ((bytes_ok && b == 1) - || (!bytes_ok && bytes.as_ref().unwrap().len() == 1)) - && encodingMode == TEXT_COMPACTION + let bytes_ok = bytes.is_some(); //if let Some(_) = bytes { true } else { false }; + if (bytes_ok && b == 1) + /*((bytes_ok && b == 1) + || (!bytes_ok && bytes.as_ref().unwrap().len() == 1))*/ + && (encodingMode == TEXT_COMPACTION) { //Switch for one byte (instead of latch) if autoECI { @@ -406,7 +407,7 @@ fn encodeText( } else { tmp.push(29 as char); //ps tmp.push(char::from_u32(PUNCTUATION[ch as usize] as u32).unwrap()); - break; + //break; } } } @@ -423,7 +424,7 @@ fn encodeText( tmp.push(27 as char); //as tmp.push(char::from_u32(ch as u32 - 65).unwrap()); //space cannot happen here, it is also in "Lower" - break; + //break; } else if isMixed(ch) { submode = SUBMODE_MIXED; tmp.push(28 as char); //ml @@ -431,7 +432,7 @@ fn encodeText( } else { tmp.push(29 as char); //ps tmp.push(char::from_u32(PUNCTUATION[ch as usize] as u32).unwrap()); - break; + //break; } } } diff --git a/src/qrcode/qr_code_reader.rs b/src/qrcode/qr_code_reader.rs index 7992aee..5be7777 100644 --- a/src/qrcode/qr_code_reader.rs +++ b/src/qrcode/qr_code_reader.rs @@ -75,14 +75,15 @@ impl Reader for QRCodeReader { // If the code was mirrored: swap the bottom-left and the top-right points. if let Some(other) = decoderRXingResult.getOther() { - if other.is::() { - // if (decoderRXingResult.getOther() instanceof QRCodeDecoderMetaData) { + if other.is::() { + // if (decoderRXingResult.getOther() instanceof QRCodeDecoderMetaData) { other - .downcast_ref::() - .unwrap() - .applyMirroredCorrection(&mut points); - // ((QRCodeDecoderMetaData) decoderRXingResult.getOther()).applyMirroredCorrection(points); - }} + .downcast_ref::() + .unwrap() + .applyMirroredCorrection(&mut points); + // ((QRCodeDecoderMetaData) decoderRXingResult.getOther()).applyMirroredCorrection(points); + } + } let mut result = RXingResult::new( decoderRXingResult.getText(),