mirror of
https://github.com/starovoid/rxing.git
synced 2026-07-26 04:12:34 +00:00
518 lines
17 KiB
Rust
518 lines
17 KiB
Rust
/*
|
|
* Copyright 2009 ZXing 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 encoding::{EncodingRef, Encoding};
|
|
use rand::{self, Rng};
|
|
use rand::rngs::ThreadRng;
|
|
|
|
use crate::pdf417::PDF417RXingResultMetadata;
|
|
use crate::pdf417::decoder::decoded_bit_stream_parser;
|
|
use crate::pdf417::encoder::{pdf_417_high_level_encoder_test_adapter, Compaction};
|
|
|
|
|
|
/**
|
|
* 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];
|
|
|
|
decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 2,&mut resultMetadata);
|
|
|
|
assert_eq!(0, resultMetadata.getSegmentIndex());
|
|
assert_eq!("017053", resultMetadata.getFileId());
|
|
assert!(!resultMetadata.isLastSegment());
|
|
assert_eq!(4, resultMetadata.getSegmentCount());
|
|
assert_eq!("CEN BE", resultMetadata.getSender());
|
|
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");
|
|
}
|
|
|
|
|
|
/**
|
|
* 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);
|
|
|
|
assert_eq!(3, resultMetadata.getSegmentIndex());
|
|
assert_eq!("017053", resultMetadata.getFileId());
|
|
assert!(resultMetadata.isLastSegment());
|
|
assert_eq!(4, resultMetadata.getSegmentCount());
|
|
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");
|
|
}
|
|
|
|
|
|
/**
|
|
* 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);
|
|
|
|
assert_eq!(0, resultMetadata.getSegmentIndex());
|
|
assert_eq!("100200300", resultMetadata.getFileId());
|
|
assert!(!resultMetadata.isLastSegment());
|
|
assert_eq!(-1, resultMetadata.getSegmentCount());
|
|
assert!(resultMetadata.getAddressee().is_empty());
|
|
assert!(resultMetadata.getSender().is_empty());
|
|
assert!(resultMetadata.getOptionalData().is_empty());
|
|
|
|
// 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());
|
|
}
|
|
|
|
#[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");
|
|
|
|
assert_eq!(0, resultMetadata.getSegmentIndex());
|
|
assert_eq!("000252021086", resultMetadata.getFileId());
|
|
assert!(!resultMetadata.isLastSegment());
|
|
assert_eq!(2, resultMetadata.getSegmentCount());
|
|
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();
|
|
|
|
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_eq!(180980729000000, resultMetadata.getTimestamp());
|
|
assert_eq!(30, resultMetadata.getFileSize());
|
|
assert_eq!(260013, resultMetadata.getChecksum());
|
|
}
|
|
|
|
#[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");
|
|
|
|
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() {
|
|
let sampleCodes = [3_u32, 928, 222, 0];
|
|
let mut resultMetadata = PDF417RXingResultMetadata::default();
|
|
decoded_bit_stream_parser::decodeMacroBlock(&sampleCodes, 2, &mut resultMetadata).expect("decode");
|
|
}
|
|
|
|
#[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");
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn testSampleWithNoDataNoMacro() {
|
|
let sampleCodes = [3_u32, 899, 899, 0];
|
|
decoded_bit_stream_parser::decode(&sampleCodes, "0").expect("decode");
|
|
}
|
|
|
|
#[test]
|
|
fn testUppercase() {
|
|
//encodeDecode("", 0);
|
|
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 testByte(){
|
|
performEncodeTest('\u{00c4}', &[ 3, 4, 5, 6, 7, 7, 8]);
|
|
}
|
|
|
|
#[test]
|
|
fn testUppercaseLowercaseMix1(){
|
|
encodeDecodeWithLength("aA", 4);
|
|
encodeDecodeWithLength("aAa", 5);
|
|
encodeDecodeWithLength("Aa", 4);
|
|
encodeDecodeWithLength("Aaa", 5);
|
|
encodeDecodeWithLength("AaA", 5);
|
|
encodeDecodeWithLength("AaaA", 6);
|
|
encodeDecodeWithLength("Aaaa", 6);
|
|
encodeDecodeWithLength("AaAaA", 5);
|
|
encodeDecodeWithLength("AaaAaaA", 6);
|
|
encodeDecodeWithLength("AaaAAaaA", 7);
|
|
}
|
|
|
|
#[test]
|
|
fn testPunctuation(){
|
|
performEncodeTest(';', &[ 3, 4, 5, 6, 6, 7, 8]);
|
|
encodeDecodeWithLength(";;;;;;;;;;;;;;;;", 17);
|
|
}
|
|
|
|
#[test]
|
|
fn testUppercaseLowercaseMix2(){
|
|
performPermutationTest(&['A', 'a'], 10, 8972);
|
|
}
|
|
|
|
#[test]
|
|
fn testUppercaseNumericMix() {
|
|
performPermutationTest(&['A', '1'], 14, 192510);
|
|
}
|
|
|
|
#[test]
|
|
fn testUppercaseMixedMix() {
|
|
performPermutationTest(&['A', '1', ' ', ';'], 7, 106060);
|
|
}
|
|
|
|
#[test]
|
|
fn testUppercasePunctuationMix(){
|
|
performPermutationTest(&['A', ';'], 10, 8967);
|
|
}
|
|
|
|
#[test]
|
|
fn testUppercaseByteMix() {
|
|
performPermutationTest(&['A', '\u{00c4}'], 10, 11222);
|
|
}
|
|
|
|
#[test]
|
|
fn testLowercaseByteMix(){
|
|
performPermutationTest(&['a', '\u{00c4}'], 10, 11233);
|
|
}
|
|
|
|
#[test]
|
|
fn testUppercaseLowercaseNumericMix(){
|
|
performPermutationTest(&['A', 'a', '1'], 7, 15491);
|
|
}
|
|
|
|
#[test]
|
|
fn testUppercaseLowercasePunctuationMix() {
|
|
performPermutationTest(&['A', 'a', ';'], 7, 15491);
|
|
}
|
|
|
|
#[test]
|
|
fn testUppercaseLowercaseByteMix() {
|
|
performPermutationTest(&['A', 'a', '\u{00c4}'], 7, 17288);
|
|
}
|
|
|
|
#[test]
|
|
fn testLowercasePunctuationByteMix(){
|
|
performPermutationTest(&['a', ';', '\u{00c4}'], 7, 17427);
|
|
}
|
|
|
|
#[test]
|
|
fn testUppercaseLowercaseNumericPunctuationMix(){
|
|
performPermutationTest(&['A', 'a', '1', ';'], 7, 120479);
|
|
}
|
|
|
|
#[test]
|
|
fn testBinaryData() {
|
|
// let bytes = [0_u8;500];
|
|
// let random = rand::thread_rng();
|
|
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"));
|
|
}
|
|
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
|
|
}
|
|
|
|
#[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);
|
|
}
|
|
|
|
#[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);
|
|
}
|
|
|
|
#[test]
|
|
fn testECIEnglishHalfWidthKatakana(){
|
|
//single ECI
|
|
performECITest(&['a', '1', '\u{ff80}'], &mut [20.0, 1.0, 10.0], 80617, 110914);
|
|
}
|
|
|
|
#[test]
|
|
fn testECIEnglishChinese() {
|
|
//single ECI
|
|
performECITest(&['a', '1', '\u{4e00}'], &mut [20.0, 1.0, 10.0], 95797, 110914);
|
|
}
|
|
|
|
#[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);
|
|
}
|
|
|
|
#[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);
|
|
}
|
|
|
|
#[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);
|
|
}
|
|
|
|
#[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);
|
|
}
|
|
|
|
#[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(&[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) {
|
|
assert_eq!(expectedLength, encodeDecode(input));
|
|
}
|
|
|
|
fn encodeDecode( input:&str) -> u32 {
|
|
return encodeDecodeWithAll(input, None, false, true);
|
|
}
|
|
|
|
fn encodeDecodeWithAll( input:&str, charset:Option<EncodingRef>, 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);
|
|
}
|
|
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
|
|
// Math.ceil(Math.pow(10, decimalLength * length))
|
|
}
|
|
|
|
fn generatePermutation( index:u32, length:u32, chars:&[char]) -> String{
|
|
let N = chars.len() as u32;
|
|
// let baseNNumber = Integer.toString(index, N);
|
|
let mut baseNNumber= int_to_string(index,N);
|
|
while baseNNumber.chars().count() < length as usize {
|
|
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]);
|
|
}
|
|
// 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) {
|
|
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));
|
|
}
|
|
assert_eq!(expectedTotal, total);
|
|
}
|
|
|
|
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]);
|
|
}
|
|
}
|
|
|
|
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();
|
|
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);
|
|
}
|
|
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();
|
|
let maxWordWidth = 7;
|
|
let mut total = 0.0;
|
|
// for (int i = 0; i < weights.length; i++) {
|
|
// total += weights[i];
|
|
// }
|
|
total += weights.iter().sum::<f32>();
|
|
|
|
for i in 0..weights.len() {
|
|
// 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::<f32>() * weights[j];
|
|
if value > maxValue {
|
|
maxValue = value;
|
|
maxIndex = j;
|
|
}
|
|
}
|
|
let wordLength = (maxWordWidth as f32 * random.gen::<f32>()) 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::<bool>() {
|
|
c = char::from_u32(c as u32- 'a' as u32 + 'A' as u32).unwrap();
|
|
}
|
|
result.push(c);
|
|
}
|
|
if cnt % 2 != 0 && random.gen_bool(0.51) {
|
|
result.push('.');
|
|
}
|
|
cnt+=1;
|
|
|
|
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;
|
|
// Handle the special case of 0
|
|
if x == 0 {
|
|
return "0".to_string();
|
|
}
|
|
|
|
// 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();
|
|
while x > 0 {
|
|
let remainder = (x % radix) as u8;
|
|
s = (remainder as char).to_string() + &s;
|
|
x /= radix;
|
|
}
|
|
|
|
s
|
|
}
|
|
|