ak/rxing
1
0
Fork 0
mirror of https://github.com/starovoid/rxing.git synced 2026-07-28 05:12:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

builds but does not pass

Browse Source
This commit is contained in:
Henry Schimke
2022-10-31 12:31:50 -05:00
parent 083a9e952c
commit b351130fd6
2 changed files with 395 additions and 379 deletions
Download Patch File Download Diff File Expand all files Collapse all files

562
src/datamatrix/encoder/high_level_encode_test_case.rs
View File

@@ -16,10 +16,9 @@
use lazy_static::lazy_static; use lazy_static::lazy_static;
use crate::datamatrix::encoder::SymbolInfo; use crate::datamatrix::encoder::{SymbolInfo, SymbolShapeHint};
use super::{SymbolInfoLookup, symbol_info, high_level_encoder};
use super::{high_level_encoder, minimal_encoder, symbol_info, SymbolInfoLookup};
lazy_static! { lazy_static! {
/** /**
@@ -37,62 +36,61 @@ lazy_static!{
]; ];
} }
fn useTestSymbols(lookup:SymbolInfoLookup) -> SymbolInfoLookup { // const SIL: SymbolInfoLookup = SymbolInfoLookup::new();
lookup.overrideSymbolSet(&TEST_SYMBOLS);
lookup
}
fn resetSymbols(lookup:SymbolInfoLookup) -> SymbolInfoLookup { // fn useTestSymbols(lookup: SymbolInfoLookup) -> SymbolInfoLookup {
lookup.overrideSymbolSet(&symbol_info::PROD_SYMBOLS); // lookup.overrideSymbolSet(&TEST_SYMBOLS);
lookup // lookup
} // }
// fn resetSymbols(lookup: SymbolInfoLookup) -> SymbolInfoLookup {
// lookup.overrideSymbolSet(&symbol_info::PROD_SYMBOLS);
// lookup
// }
#[test] #[test]
fn testASCIIEncodation() { fn testASCIIEncodation() {
let mut visualized = encodeHighLevel("123456");
String visualized = encodeHighLevel("123456"); assert_eq!("142 164 186", visualized);
assertEquals("142 164 186", visualized);
visualized = encodeHighLevel("123456£"); visualized = encodeHighLevel("123456£");
assertEquals("142 164 186 235 36", visualized); assert_eq!("142 164 186 235 36", visualized);
visualized = encodeHighLevel("30Q324343430794<OQQ"); visualized = encodeHighLevel("30Q324343430794<OQQ");
assertEquals("160 82 162 173 173 173 137 224 61 80 82 82", visualized); assert_eq!("160 82 162 173 173 173 137 224 61 80 82 82", visualized);
} }
#[test] #[test]
fn testC40EncodationBasic1() { fn testC40EncodationBasic1() {
let visualized = encodeHighLevel("AIMAIMAIM");
String visualized = encodeHighLevel("AIMAIMAIM"); assert_eq!("230 91 11 91 11 91 11 254", visualized);
assertEquals("230 91 11 91 11 91 11 254", visualized);
//230 shifts to C40 encodation, 254 unlatches, "else" case //230 shifts to C40 encodation, 254 unlatches, "else" case
} }
#[test] #[test]
fn testC40EncodationBasic2() { fn testC40EncodationBasic2() {
let mut visualized = encodeHighLevel("AIMAIAB");
String visualized = encodeHighLevel("AIMAIAB"); assert_eq!("230 91 11 90 255 254 67 129", visualized);
assertEquals("230 91 11 90 255 254 67 129", visualized);
//"B" is normally encoded as "15" (one C40 value) //"B" is normally encoded as "15" (one C40 value)
//"else" case: "B" is encoded as ASCII //"else" case: "B" is encoded as ASCII
visualized = encodeHighLevel("AIMAIAb"); visualized = encodeHighLevel("AIMAIAb");
assertEquals("66 74 78 66 74 66 99 129", visualized); //Encoded as ASCII assert_eq!("66 74 78 66 74 66 99 129", visualized); //Encoded as ASCII
//Alternative solution: //Alternative solution:
//assertEquals("230 91 11 90 255 254 99 129", visualized); //assert_eq!("230 91 11 90 255 254 99 129", visualized);
//"b" is normally encoded as "Shift 3, 2" (two C40 values) //"b" is normally encoded as "Shift 3, 2" (two C40 values)
//"else" case: "b" is encoded as ASCII //"else" case: "b" is encoded as ASCII
visualized = encodeHighLevel("AIMAIMAIMË"); visualized = encodeHighLevel("AIMAIMAIMË");
assertEquals("230 91 11 91 11 91 11 254 235 76", visualized); assert_eq!("230 91 11 91 11 91 11 254 235 76", visualized);
//Alternative solution: //Alternative solution:
//assertEquals("230 91 11 91 11 91 11 11 9 254", visualized); //assert_eq!("230 91 11 91 11 91 11 11 9 254", visualized);
//Expl: 230 = shift to C40, "91 11" = "AIM", //Expl: 230 = shift to C40, "91 11" = "AIM",
//"11 9" = "<22>" = "Shift 2, UpperShift, <char> //"11 9" = "<22>" = "Shift 2, UpperShift, <char>
//"else" case //"else" case
visualized = encodeHighLevel("AIMAIMAIMë"); visualized = encodeHighLevel("AIMAIMAIMë");
assertEquals("230 91 11 91 11 91 11 254 235 108", visualized); //Activate when additional rectangulars are available assert_eq!("230 91 11 91 11 91 11 254 235 108", visualized); //Activate when additional rectangulars are available
//Expl: 230 = shift to C40, "91 11" = "AIM", //Expl: 230 = shift to C40, "91 11" = "AIM",
//"<22>" in C40 encodes to: 1 30 2 11 which doesn't fit into a triplet //"<22>" in C40 encodes to: 1 30 2 11 which doesn't fit into a triplet
//"10 243" = //"10 243" =
@@ -103,205 +101,239 @@ lazy_static!{
#[test] #[test]
fn testC40EncodationSpecExample() { fn testC40EncodationSpecExample() {
//Example in Figure 1 in the spec //Example in Figure 1 in the spec
String visualized = encodeHighLevel("A1B2C3D4E5F6G7H8I9J0K1L2"); let visualized = encodeHighLevel("A1B2C3D4E5F6G7H8I9J0K1L2");
assertEquals("230 88 88 40 8 107 147 59 67 126 206 78 126 144 121 35 47 254", visualized); assert_eq!(
"230 88 88 40 8 107 147 59 67 126 206 78 126 144 121 35 47 254",
visualized
);
} }
#[test] #[test]
fn testC40EncodationSpecialCases1() { fn testC40EncodationSpecialCases1() {
unimplemented!();
// //Special tests avoiding ultra-long test strings because these tests are only used
// //with the 16x48 symbol (47 data codewords)
// useTestSymbols();
//Special tests avoiding ultra-long test strings because these tests are only used // let visualized = encodeHighLevelCompare("AIMAIMAIMAIMAIMAIM", false);
//with the 16x48 symbol (47 data codewords) // assert_eq!("230 91 11 91 11 91 11 91 11 91 11 91 11", visualized);
useTestSymbols(); // //case "a": Unlatch is not required
String visualized = encodeHighLevel("AIMAIMAIMAIMAIMAIM", false); // visualized = encodeHighLevelCompare("AIMAIMAIMAIMAIMAI", false);
assertEquals("230 91 11 91 11 91 11 91 11 91 11 91 11", visualized); // assert_eq!("230 91 11 91 11 91 11 91 11 91 11 90 241", visualized);
//case "a": Unlatch is not required // //case "b": Add trailing shift 0 and Unlatch is not required
visualized = encodeHighLevel("AIMAIMAIMAIMAIMAI", false); // visualized = encodeHighLevel("AIMAIMAIMAIMAIMA");
assertEquals("230 91 11 91 11 91 11 91 11 91 11 90 241", visualized); // assert_eq!("230 91 11 91 11 91 11 91 11 91 11 254 66", visualized);
//case "b": Add trailing shift 0 and Unlatch is not required // //case "c": Unlatch and write last character in ASCII
visualized = encodeHighLevel("AIMAIMAIMAIMAIMA"); // resetSymbols();
assertEquals("230 91 11 91 11 91 11 91 11 91 11 254 66", visualized);
//case "c": Unlatch and write last character in ASCII
resetSymbols(); // visualized = encodeHighLevel("AIMAIMAIMAIMAIMAI");
// assert_eq!(
// "230 91 11 91 11 91 11 91 11 91 11 254 66 74 129 237",
// visualized
// );
visualized = encodeHighLevel("AIMAIMAIMAIMAIMAI"); // visualized = encodeHighLevel("AIMAIMAIMA");
assertEquals("230 91 11 91 11 91 11 91 11 91 11 254 66 74 129 237", visualized); // assert_eq!("230 91 11 91 11 91 11 66", visualized);
// //case "d": Skip Unlatch and write last character in ASCII
visualized = encodeHighLevel("AIMAIMAIMA");
assertEquals("230 91 11 91 11 91 11 66", visualized);
//case "d": Skip Unlatch and write last character in ASCII
} }
#[test] #[test]
fn testC40EncodationSpecialCases2() { fn testC40EncodationSpecialCases2() {
let visualized = encodeHighLevel("AIMAIMAIMAIMAIMAIMAI");
String visualized = encodeHighLevel("AIMAIMAIMAIMAIMAIMAI"); assert_eq!(
assertEquals("230 91 11 91 11 91 11 91 11 91 11 91 11 254 66 74", visualized); "230 91 11 91 11 91 11 91 11 91 11 91 11 254 66 74",
visualized
);
//available > 2, rest = 2 --> unlatch and encode as ASCII //available > 2, rest = 2 --> unlatch and encode as ASCII
} }
#[test] #[test]
fn testTextEncodation() { fn testTextEncodation() {
let mut visualized = encodeHighLevel("aimaimaim");
String visualized = encodeHighLevel("aimaimaim"); assert_eq!("239 91 11 91 11 91 11 254", visualized);
assertEquals("239 91 11 91 11 91 11 254", visualized);
//239 shifts to Text encodation, 254 unlatches //239 shifts to Text encodation, 254 unlatches
visualized = encodeHighLevel("aimaimaim'"); visualized = encodeHighLevel("aimaimaim'");
assertEquals("239 91 11 91 11 91 11 254 40 129", visualized); assert_eq!("239 91 11 91 11 91 11 254 40 129", visualized);
//assertEquals("239 91 11 91 11 91 11 7 49 254", visualized); //assert_eq!("239 91 11 91 11 91 11 7 49 254", visualized);
//This is an alternative, but doesn't strictly follow the rules in the spec. //This is an alternative, but doesn't strictly follow the rules in the spec.
visualized = encodeHighLevel("aimaimaIm"); visualized = encodeHighLevel("aimaimaIm");
assertEquals("239 91 11 91 11 87 218 110", visualized); assert_eq!("239 91 11 91 11 87 218 110", visualized);
visualized = encodeHighLevel("aimaimaimB"); visualized = encodeHighLevel("aimaimaimB");
assertEquals("239 91 11 91 11 91 11 254 67 129", visualized); assert_eq!("239 91 11 91 11 91 11 254 67 129", visualized);
visualized = encodeHighLevel("aimaimaim{txt}\u0004"); visualized = encodeHighLevel("aimaimaim{txt}\u{0004}");
assertEquals("239 91 11 91 11 91 11 254 124 117 121 117 126 5 129 237", visualized); assert_eq!(
"239 91 11 91 11 91 11 254 124 117 121 117 126 5 129 237",
visualized
);
} }
#[test] #[test]
fn testX12Encodation() { fn testX12Encodation() {
//238 shifts to X12 encodation, 254 unlatches //238 shifts to X12 encodation, 254 unlatches
String visualized = encodeHighLevel("ABC>ABC123>AB"); let mut visualized = encodeHighLevel("ABC>ABC123>AB");
assertEquals("238 89 233 14 192 100 207 44 31 67", visualized); assert_eq!("238 89 233 14 192 100 207 44 31 67", visualized);
visualized = encodeHighLevel("ABC>ABC123>ABC"); visualized = encodeHighLevel("ABC>ABC123>ABC");
assertEquals("238 89 233 14 192 100 207 44 31 254 67 68", visualized); assert_eq!("238 89 233 14 192 100 207 44 31 254 67 68", visualized);
visualized = encodeHighLevel("ABC>ABC123>ABCD"); visualized = encodeHighLevel("ABC>ABC123>ABCD");
assertEquals("238 89 233 14 192 100 207 44 31 96 82 254", visualized); assert_eq!("238 89 233 14 192 100 207 44 31 96 82 254", visualized);
visualized = encodeHighLevel("ABC>ABC123>ABCDE"); visualized = encodeHighLevel("ABC>ABC123>ABCDE");
assertEquals("238 89 233 14 192 100 207 44 31 96 82 70", visualized); assert_eq!("238 89 233 14 192 100 207 44 31 96 82 70", visualized);
visualized = encodeHighLevel("ABC>ABC123>ABCDEF"); visualized = encodeHighLevel("ABC>ABC123>ABCDEF");
assertEquals("238 89 233 14 192 100 207 44 31 96 82 254 70 71 129 237", visualized); assert_eq!(
"238 89 233 14 192 100 207 44 31 96 82 254 70 71 129 237",
visualized
);
} }
#[test] #[test]
fn testEDIFACTEncodation() { fn testEDIFACTEncodation() {
//240 shifts to EDIFACT encodation //240 shifts to EDIFACT encodation
String visualized = encodeHighLevel(".A.C1.3.DATA.123DATA.123DATA"); let mut visualized = encodeHighLevel(".A.C1.3.DATA.123DATA.123DATA");
assertEquals("240 184 27 131 198 236 238 16 21 1 187 28 179 16 21 1 187 28 179 16 21 1", assert_eq!(
visualized); "240 184 27 131 198 236 238 16 21 1 187 28 179 16 21 1 187 28 179 16 21 1",
visualized
);
visualized = encodeHighLevel(".A.C1.3.X.X2.."); visualized = encodeHighLevel(".A.C1.3.X.X2..");
assertEquals("240 184 27 131 198 236 238 98 230 50 47 47", visualized); assert_eq!("240 184 27 131 198 236 238 98 230 50 47 47", visualized);
visualized = encodeHighLevel(".A.C1.3.X.X2."); visualized = encodeHighLevel(".A.C1.3.X.X2.");
assertEquals("240 184 27 131 198 236 238 98 230 50 47 129", visualized); assert_eq!("240 184 27 131 198 236 238 98 230 50 47 129", visualized);
visualized = encodeHighLevel(".A.C1.3.X.X2"); visualized = encodeHighLevel(".A.C1.3.X.X2");
assertEquals("240 184 27 131 198 236 238 98 230 50", visualized); assert_eq!("240 184 27 131 198 236 238 98 230 50", visualized);
visualized = encodeHighLevel(".A.C1.3.X.X"); visualized = encodeHighLevel(".A.C1.3.X.X");
assertEquals("240 184 27 131 198 236 238 98 230 31", visualized); assert_eq!("240 184 27 131 198 236 238 98 230 31", visualized);
visualized = encodeHighLevel(".A.C1.3.X."); visualized = encodeHighLevel(".A.C1.3.X.");
assertEquals("240 184 27 131 198 236 238 98 231 192", visualized); assert_eq!("240 184 27 131 198 236 238 98 231 192", visualized);
visualized = encodeHighLevel(".A.C1.3.X"); visualized = encodeHighLevel(".A.C1.3.X");
assertEquals("240 184 27 131 198 236 238 89", visualized); assert_eq!("240 184 27 131 198 236 238 89", visualized);
//Checking temporary unlatch from EDIFACT //Checking temporary unlatch from EDIFACT
visualized = encodeHighLevel(".XXX.XXX.XXX.XXX.XXX.XXX.üXX.XXX.XXX.XXX.XXX.XXX.XXX"); visualized = encodeHighLevel(".XXX.XXX.XXX.XXX.XXX.XXX.üXX.XXX.XXX.XXX.XXX.XXX.XXX");
assertEquals("240 185 134 24 185 134 24 185 134 24 185 134 24 185 134 24 185 134 24" assert_eq!(
+ " 124 47 235 125 240" //<-- this is the temporary unlatch "240 185 134 24 185 134 24 185 134 24 185 134 24 185 134 24 185 134 24 124 47 235 125 240 97 139 152 97 139 152 97 139 152 97 139 152 97 139 152 97 139 152 89 89",
+ " 97 139 152 97 139 152 97 139 152 97 139 152 97 139 152 97 139 152 89 89", // + " 124 47 235 125 240" //<-- this is the temporary unlatch
visualized); visualized
);
} }
#[test] #[test]
fn testBase256Encodation() { fn testBase256Encodation() {
//231 shifts to Base256 encodation //231 shifts to Base256 encodation
String visualized = encodeHighLevel("\u00ABäöüé\u00BB"); let mut visualized = encodeHighLevel("\u{00AB}äöüé\u{00BB}");
assertEquals("231 44 108 59 226 126 1 104", visualized); assert_eq!("231 44 108 59 226 126 1 104", visualized);
visualized = encodeHighLevel("\u00ABäöüéà\u00BB"); visualized = encodeHighLevel("\u{00AB}äöüéà\u{00BB}");
assertEquals("231 51 108 59 226 126 1 141 254 129", visualized); assert_eq!("231 51 108 59 226 126 1 141 254 129", visualized);
visualized = encodeHighLevel("\u00ABäöüéàá\u00BB"); visualized = encodeHighLevel("\u{00AB}äöüéàá\u{00BB}");
assertEquals("231 44 108 59 226 126 1 141 36 147", visualized); assert_eq!("231 44 108 59 226 126 1 141 36 147", visualized);
visualized = encodeHighLevel(" 23£"); //ASCII only (for reference) visualized = encodeHighLevel(" 23£"); //ASCII only (for reference)
assertEquals("33 153 235 36 129", visualized); assert_eq!("33 153 235 36 129", visualized);
visualized = encodeHighLevel("\u00ABäöüé\u00BB 234"); //Mixed Base256 + ASCII visualized = encodeHighLevel("\u{00AB}äöüé\u{00BB} 234"); //Mixed Base256 + ASCII
assertEquals("231 50 108 59 226 126 1 104 33 153 53 129", visualized); assert_eq!("231 50 108 59 226 126 1 104 33 153 53 129", visualized);
visualized = encodeHighLevel("\u00ABäöüé\u00BB 23£ 1234567890123456789"); visualized = encodeHighLevel("\u{00AB}äöüé\u{00BB} 23£ 1234567890123456789");
assertEquals("231 54 108 59 226 126 1 104 99 10 161 167 33 142 164 186 208" assert_eq!("231 54 108 59 226 126 1 104 99 10 161 167 33 142 164 186 208 220 142 164 186 208 58 129 59 209 104 254 150 45", visualized);
+ " 220 142 164 186 208 58 129 59 209 104 254 150 45", visualized);
visualized = encodeHighLevel(createBinaryMessage(20)); visualized = encodeHighLevel(&createBinaryMessage(20));
assertEquals("231 44 108 59 226 126 1 141 36 5 37 187 80 230 123 17 166 60 210 103 253 150", assert_eq!(
visualized); "231 44 108 59 226 126 1 141 36 5 37 187 80 230 123 17 166 60 210 103 253 150",
visualized = encodeHighLevel(createBinaryMessage(19)); //padding necessary at the end visualized
assertEquals("231 63 108 59 226 126 1 141 36 5 37 187 80 230 123 17 166 60 210 103 1 129", );
visualized); visualized = encodeHighLevel(&createBinaryMessage(19)); //padding necessary at the end
assert_eq!(
"231 63 108 59 226 126 1 141 36 5 37 187 80 230 123 17 166 60 210 103 1 129",
visualized
);
visualized = encodeHighLevel(createBinaryMessage(276)); visualized = encodeHighLevel(&createBinaryMessage(276));
assertStartsWith("231 38 219 2 208 120 20 150 35", visualized); assertStartsWith("231 38 219 2 208 120 20 150 35", &visualized);
assertEndsWith("146 40 194 129", visualized); assertEndsWith("146 40 194 129", &visualized);
visualized = encodeHighLevel(createBinaryMessage(277)); visualized = encodeHighLevel(&createBinaryMessage(277));
assertStartsWith("231 38 220 2 208 120 20 150 35", visualized); assertStartsWith("231 38 220 2 208 120 20 150 35", &visualized);
assertEndsWith("146 40 190 87", visualized); assertEndsWith("146 40 190 87", &visualized);
} }
fn createBinaryMessage(len: usize) -> String { fn createBinaryMessage(len: usize) -> String {
StringBuilder sb = new StringBuilder(); let mut sb = String::new();
sb.append("\u00ABäöüéàá-"); sb.push_str("\u{00AB}äöüéàá-");
for (int i = 0; i < len - 9; i++) { for i in 0..len - 9 {
sb.append('\u00B7'); // for (int i = 0; i < len - 9; i++) {
sb.push('\u{00B7}');
} }
sb.append('\u00BB'); sb.push('\u{00BB}');
return sb.toString();
sb
} }
fn assertStartsWith(expected: &str, actual: &str) { fn assertStartsWith(expected: &str, actual: &str) {
if (!actual.startsWith(expected)) { if !actual.starts_with(expected) {
throw new ComparisonFailure(null, expected, actual.substring(0, expected.length())); panic!(
"got {} expected {}, with len ({},{})",
actual,
expected,
actual.len(),
expected.len()
)
// throw new ComparisonFailure(null, expected, actual.substring(0, expected.length()));
} }
} }
fn assertEndsWith(expected: &str, actual: &str) { fn assertEndsWith(expected: &str, actual: &str) {
if (!actual.endsWith(expected)) { if !actual.ends_with(expected) {
throw new ComparisonFailure(null, expected, actual.substring(actual.length() - expected.length())); panic!(
"got {} expected {}, with len ({},{})",
actual,
expected,
actual.len(),
expected.len()
)
// throw new ComparisonFailure(null, expected, actual.substring(actual.length() - expected.length()));
} }
} }
#[test] #[test]
fn testUnlatchingFromC40() { fn testUnlatchingFromC40() {
let visualized = encodeHighLevel("AIMAIMAIMAIMaimaimaim");
String visualized = encodeHighLevel("AIMAIMAIMAIMaimaimaim"); assert_eq!(
assertEquals("230 91 11 91 11 91 11 254 66 74 78 239 91 11 91 11 91 11", visualized); "230 91 11 91 11 91 11 254 66 74 78 239 91 11 91 11 91 11",
visualized
);
} }
#[test] #[test]
fn testUnlatchingFromText() { fn testUnlatchingFromText() {
let visualized = encodeHighLevel("aimaimaimaim12345678");
String visualized = encodeHighLevel("aimaimaimaim12345678"); assert_eq!(
assertEquals("239 91 11 91 11 91 11 91 11 254 142 164 186 208 129 237", visualized); "239 91 11 91 11 91 11 91 11 254 142 164 186 208 129 237",
visualized
);
} }
#[test] #[test]
fn testHelloWorld() { fn testHelloWorld() {
let visualized = encodeHighLevel("Hello World!");
String visualized = encodeHighLevel("Hello World!"); assert_eq!("73 239 116 130 175 123 148 64 158 233 254 34", visualized);
assertEquals("73 239 116 130 175 123 148 64 158 233 254 34", visualized);
} }
#[test] #[test]
@@ -309,26 +341,26 @@ lazy_static!{
//There was an exception and the encoder did not handle the unlatching from //There was an exception and the encoder did not handle the unlatching from
//EDIFACT encoding correctly //EDIFACT encoding correctly
String visualized = encodeHighLevel("CREX-TAN:h"); let mut visualized = encodeHighLevel("CREX-TAN:h");
assertEquals("68 83 70 89 46 85 66 79 59 105", visualized); assert_eq!("68 83 70 89 46 85 66 79 59 105", visualized);
visualized = encodeHighLevel("CREX-TAN:hh"); visualized = encodeHighLevel("CREX-TAN:hh");
assertEquals("68 83 70 89 46 85 66 79 59 105 105 129", visualized); assert_eq!("68 83 70 89 46 85 66 79 59 105 105 129", visualized);
visualized = encodeHighLevel("CREX-TAN:hhh"); visualized = encodeHighLevel("CREX-TAN:hhh");
assertEquals("68 83 70 89 46 85 66 79 59 105 105 105", visualized); assert_eq!("68 83 70 89 46 85 66 79 59 105 105 105", visualized);
} }
#[test] #[test]
fn testX12Unlatch() { fn testX12Unlatch() {
String visualized = encodeHighLevel("*DTCP01"); let visualized = encodeHighLevel("*DTCP01");
assertEquals("43 69 85 68 81 131 129 56", visualized); assert_eq!("43 69 85 68 81 131 129 56", visualized);
} }
#[test] #[test]
fn testX12Unlatch2() { fn testX12Unlatch2() {
String visualized = encodeHighLevel("*DTCP0"); let visualized = encodeHighLevel("*DTCP0");
assertEquals("238 9 10 104 141", visualized); assert_eq!("238 9 10 104 141", visualized);
} }
#[test] #[test]
@@ -336,201 +368,186 @@ lazy_static!{
//There was an IllegalArgumentException for an illegal character here because //There was an IllegalArgumentException for an illegal character here because
//of an encoding problem of the character 0x0060 in Java source code. //of an encoding problem of the character 0x0060 in Java source code.
String visualized = encodeHighLevel("fiykmj*Rh2`,e6"); let visualized = encodeHighLevel("fiykmj*Rh2`,e6");
assertEquals("103 106 122 108 110 107 43 83 105 51 97 45 102 55 129 237", visualized); assert_eq!(
"103 106 122 108 110 107 43 83 105 51 97 45 102 55 129 237",
visualized
);
} }
#[test] #[test]
fn testMacroCharacters() { fn testMacroCharacters() {
let visualized = encodeHighLevel("[)>\u{001E}05\u{001D}5555\u{001C}6666\u{001E}\u{0004}");
String visualized = encodeHighLevel("[)>\u001E05\u001D5555\u001C6666\u001E\u0004"); //assert_eq!("92 42 63 31 135 30 185 185 29 196 196 31 5 129 87 237", visualized);
//assertEquals("92 42 63 31 135 30 185 185 29 196 196 31 5 129 87 237", visualized); assert_eq!("236 185 185 29 196 196 129 56", visualized);
assertEquals("236 185 185 29 196 196 129 56", visualized);
} }
#[test] #[test]
fn testEncodingWithStartAsX12AndLatchToEDIFACTInTheMiddle() { fn testEncodingWithStartAsX12AndLatchToEDIFACTInTheMiddle() {
let visualized = encodeHighLevel("*MEMANT-1F-MESTECH");
String visualized = encodeHighLevel("*MEMANT-1F-MESTECH"); assert_eq!(
assertEquals("240 168 209 77 4 229 45 196 107 77 21 53 5 12 135 192", visualized); "240 168 209 77 4 229 45 196 107 77 21 53 5 12 135 192",
visualized
);
} }
#[test] #[test]
fn testX12AndEDIFACTSpecErrors() { fn testX12AndEDIFACTSpecErrors() {
//X12 encoding error with spec conform float point comparisons in lookAheadTest() //X12 encoding error with spec conform float point comparisons in lookAheadTest()
String visualized = encodeHighLevel("AAAAAAAAAAA**\u00FCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"); let mut visualized = encodeHighLevel("AAAAAAAAAAA**\u{00FC}AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
assertEquals("230 89 191 89 191 89 191 89 178 56 114 10 243 177 63 89 191 89 191 89 191 89 191 89 191 89 191 89 " + assert_eq!("230 89 191 89 191 89 191 89 178 56 114 10 243 177 63 89 191 89 191 89 191 89 191 89 191 89 191 89 191 89 191 89 191 254 66 129", visualized);
"191 89 191 89 191 254 66 129", visualized);
//X12 encoding error with integer comparisons in lookAheadTest() //X12 encoding error with integer comparisons in lookAheadTest()
visualized = encodeHighLevel("AAAAAAAAAAAA0+****AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"); visualized = encodeHighLevel("AAAAAAAAAAAA0+****AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
assertEquals("238 89 191 89 191 89 191 89 191 254 240 194 186 170 170 160 65 4 16 65 4 16 65 4 16 65 4 16 65 4 " + assert_eq!("238 89 191 89 191 89 191 89 191 254 240 194 186 170 170 160 65 4 16 65 4 16 65 4 16 65 4 16 65 4 16 65 4 16 65 4 16 65 124 129 167 62 212 107", visualized);
"16 65 4 16 65 4 16 65 124 129 167 62 212 107", visualized);
//EDIFACT encoding error with spec conform float point comparisons in lookAheadTest() //EDIFACT encoding error with spec conform float point comparisons in lookAheadTest()
visualized = encodeHighLevel("AAAAAAAAAAA++++\u00FCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"); visualized = encodeHighLevel("AAAAAAAAAAA++++\u{00FC}AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
assertEquals("230 89 191 89 191 89 191 254 66 66 44 44 44 44 235 125 230 89 191 89 191 89 191 89 191 89 191 89 " + assert_eq!("230 89 191 89 191 89 191 254 66 66 44 44 44 44 235 125 230 89 191 89 191 89 191 89 191 89 191 89 191 89 191 89 191 89 191 89 191 254 129 17 167 62 212 107", visualized);
"191 89 191 89 191 89 191 89 191 254 129 17 167 62 212 107", visualized);
//EDIFACT encoding error with integer comparisons in lookAheadTest() //EDIFACT encoding error with integer comparisons in lookAheadTest()
visualized = encodeHighLevel("++++++++++AAa0 0++++++++++++++++++++++++++++++"); visualized = encodeHighLevel("++++++++++AAa0 0++++++++++++++++++++++++++++++");
assertEquals("240 174 186 235 174 186 235 174 176 65 124 98 240 194 12 43 174 186 235 174 186 235 174 186 235 " + assert_eq!("240 174 186 235 174 186 235 174 176 65 124 98 240 194 12 43 174 186 235 174 186 235 174 186 235 174 186 235 174 186 235 174 186 235 174 186 235 173 240 129 167 62 212 107", visualized);
"174 186 235 174 186 235 174 186 235 174 186 235 173 240 129 167 62 212 107", visualized);
visualized = encodeHighLevel("AAAAAAAAAAAA*+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"); visualized = encodeHighLevel("AAAAAAAAAAAA*+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
assertEquals("230 89 191 89 191 89 191 89 191 7 170 64 191 89 191 89 191 89 191 89 191 89 191 89 191 89 191 89 " + assert_eq!("230 89 191 89 191 89 191 89 191 7 170 64 191 89 191 89 191 89 191 89 191 89 191 89 191 89 191 89 191 89 191 66", visualized);
"191 89 191 66", visualized);
visualized = encodeHighLevel("AAAAAAAAAAA*0a0 *AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"); visualized = encodeHighLevel("AAAAAAAAAAA*0a0 *AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
assertEquals("230 89 191 89 191 89 191 89 178 56 227 6 228 7 183 89 191 89 191 89 191 89 191 89 191 89 191 89 " + assert_eq!("230 89 191 89 191 89 191 89 178 56 227 6 228 7 183 89 191 89 191 89 191 89 191 89 191 89 191 89 191 89 191 89 191 254 66 66", visualized);
"191 89 191 89 191 254 66 66", visualized);
} }
#[test] #[test]
fn testSizes() { fn testSizes() {
int[] sizes = new int[2]; let mut sizes = [0usize; 2];
encodeHighLevel("A", sizes); encodeHighLevelWithSizes("A", &mut sizes);
assertEquals(3, sizes[0]); assert_eq!(3, sizes[0]);
assertEquals(3, sizes[1]); assert_eq!(3, sizes[1]);
encodeHighLevel("AB", sizes); encodeHighLevelWithSizes("AB", &mut sizes);
assertEquals(3, sizes[0]); assert_eq!(3, sizes[0]);
assertEquals(3, sizes[1]); assert_eq!(3, sizes[1]);
encodeHighLevel("ABC", sizes); encodeHighLevelWithSizes("ABC", &mut sizes);
assertEquals(3, sizes[0]); assert_eq!(3, sizes[0]);
assertEquals(3, sizes[1]); assert_eq!(3, sizes[1]);
encodeHighLevel("ABCD", sizes); encodeHighLevelWithSizes("ABCD", &mut sizes);
assertEquals(5, sizes[0]); assert_eq!(5, sizes[0]);
assertEquals(5, sizes[1]); assert_eq!(5, sizes[1]);
encodeHighLevel("ABCDE", sizes); encodeHighLevelWithSizes("ABCDE", &mut sizes);
assertEquals(5, sizes[0]); assert_eq!(5, sizes[0]);
assertEquals(5, sizes[1]); assert_eq!(5, sizes[1]);
encodeHighLevel("ABCDEF", sizes); encodeHighLevelWithSizes("ABCDEF", &mut sizes);
assertEquals(5, sizes[0]); assert_eq!(5, sizes[0]);
assertEquals(5, sizes[1]); assert_eq!(5, sizes[1]);
encodeHighLevel("ABCDEFG", sizes); encodeHighLevelWithSizes("ABCDEFG", &mut sizes);
assertEquals(8, sizes[0]); assert_eq!(8, sizes[0]);
assertEquals(8, sizes[1]); assert_eq!(8, sizes[1]);
encodeHighLevel("ABCDEFGH", sizes); encodeHighLevelWithSizes("ABCDEFGH", &mut sizes);
assertEquals(8, sizes[0]); assert_eq!(8, sizes[0]);
assertEquals(8, sizes[1]); assert_eq!(8, sizes[1]);
encodeHighLevel("ABCDEFGHI", sizes); encodeHighLevelWithSizes("ABCDEFGHI", &mut sizes);
assertEquals(8, sizes[0]); assert_eq!(8, sizes[0]);
assertEquals(8, sizes[1]); assert_eq!(8, sizes[1]);
encodeHighLevel("ABCDEFGHIJ", sizes); encodeHighLevelWithSizes("ABCDEFGHIJ", &mut sizes);
assertEquals(8, sizes[0]); assert_eq!(8, sizes[0]);
assertEquals(8, sizes[1]); assert_eq!(8, sizes[1]);
encodeHighLevel("a", sizes); encodeHighLevelWithSizes("a", &mut sizes);
assertEquals(3, sizes[0]); assert_eq!(3, sizes[0]);
assertEquals(3, sizes[1]); assert_eq!(3, sizes[1]);
encodeHighLevel("ab", sizes); encodeHighLevelWithSizes("ab", &mut sizes);
assertEquals(3, sizes[0]); assert_eq!(3, sizes[0]);
assertEquals(3, sizes[1]); assert_eq!(3, sizes[1]);
encodeHighLevel("abc", sizes); encodeHighLevelWithSizes("abc", &mut sizes);
assertEquals(3, sizes[0]); assert_eq!(3, sizes[0]);
assertEquals(3, sizes[1]); assert_eq!(3, sizes[1]);
encodeHighLevel("abcd", sizes); encodeHighLevelWithSizes("abcd", &mut sizes);
assertEquals(5, sizes[0]); assert_eq!(5, sizes[0]);
assertEquals(5, sizes[1]); assert_eq!(5, sizes[1]);
encodeHighLevel("abcdef", sizes); encodeHighLevelWithSizes("abcdef", &mut sizes);
assertEquals(5, sizes[0]); assert_eq!(5, sizes[0]);
assertEquals(5, sizes[1]); assert_eq!(5, sizes[1]);
encodeHighLevel("abcdefg", sizes); encodeHighLevelWithSizes("abcdefg", &mut sizes);
assertEquals(8, sizes[0]); assert_eq!(8, sizes[0]);
assertEquals(8, sizes[1]); assert_eq!(8, sizes[1]);
encodeHighLevel("abcdefgh", sizes); encodeHighLevelWithSizes("abcdefgh", &mut sizes);
assertEquals(8, sizes[0]); assert_eq!(8, sizes[0]);
assertEquals(8, sizes[1]); assert_eq!(8, sizes[1]);
encodeHighLevel("+", sizes); encodeHighLevelWithSizes("+", &mut sizes);
assertEquals(3, sizes[0]); assert_eq!(3, sizes[0]);
assertEquals(3, sizes[1]); assert_eq!(3, sizes[1]);
encodeHighLevel("++", sizes); encodeHighLevelWithSizes("++", &mut sizes);
assertEquals(3, sizes[0]); assert_eq!(3, sizes[0]);
assertEquals(3, sizes[1]); assert_eq!(3, sizes[1]);
encodeHighLevel("+++", sizes); encodeHighLevelWithSizes("+++", &mut sizes);
assertEquals(3, sizes[0]); assert_eq!(3, sizes[0]);
assertEquals(3, sizes[1]); assert_eq!(3, sizes[1]);
encodeHighLevel("++++", sizes); encodeHighLevelWithSizes("++++", &mut sizes);
assertEquals(5, sizes[0]); assert_eq!(5, sizes[0]);
assertEquals(5, sizes[1]); assert_eq!(5, sizes[1]);
encodeHighLevel("+++++", sizes); encodeHighLevelWithSizes("+++++", &mut sizes);
assertEquals(5, sizes[0]); assert_eq!(5, sizes[0]);
assertEquals(5, sizes[1]); assert_eq!(5, sizes[1]);
encodeHighLevel("++++++", sizes); encodeHighLevelWithSizes("++++++", &mut sizes);
assertEquals(8, sizes[0]); assert_eq!(8, sizes[0]);
assertEquals(8, sizes[1]); assert_eq!(8, sizes[1]);
encodeHighLevel("+++++++", sizes); encodeHighLevelWithSizes("+++++++", &mut sizes);
assertEquals(8, sizes[0]); assert_eq!(8, sizes[0]);
assertEquals(8, sizes[1]); assert_eq!(8, sizes[1]);
encodeHighLevel("++++++++", sizes); encodeHighLevelWithSizes("++++++++", &mut sizes);
assertEquals(8, sizes[0]); assert_eq!(8, sizes[0]);
assertEquals(8, sizes[1]); assert_eq!(8, sizes[1]);
encodeHighLevel("+++++++++", sizes); encodeHighLevelWithSizes("+++++++++", &mut sizes);
assertEquals(8, sizes[0]); assert_eq!(8, sizes[0]);
assertEquals(8, sizes[1]); assert_eq!(8, sizes[1]);
encodeHighLevel("\u00F0\u00F0" + encodeHighLevelWithSizes("\u{00F0}\u{00F0}ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEF", &mut sizes);
"ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEF", sizes); assert_eq!(114, sizes[0]);
assertEquals(114, sizes[0]); assert_eq!(62, sizes[1]);
assertEquals(62, sizes[1]);
} }
#[test] #[test]
fn testECIs() { fn testECIs() {
let mut visualized = visualize(&minimal_encoder::encodeHighLevel("that particularly stands out to me is \u{0625}\u{0650}\u{062C}\u{064E}\u{0651}\u{0627}\u{0635} (\u{02BE}\u{0101}\u{1E63}) \"pear\", suggested to have originated from Hebrew \u{05D0}\u{05B7}\u{05D2}\u{05B8}\u{05BC}\u{05E1} (ag\u{00E1}s)").expect("encode"));
String visualized = visualize(MinimalEncoder.encodeHighLevel("that particularly stands out to me is \u0625\u0650" + assert_eq!("239 209 151 206 214 92 122 140 35 158 144 162 52 205 55 171 137 23 67 206 218 175 147 113 15 254 116 33 241 25 231 186 14 212 64 253 151 252 159 33 41 241 27 231 83 171 53 209 35 25 134 6 42 33 35 239 184 31 193 234 7 252 205 101 127 241 209 34 24 5 22 23 221 148 179 239 128 140 92 187 106 204 198 59 19 25 114 248 118 36 254 231 106 196 19 239 101 27 107 69 189 112 236 156 252 16 174 125 24 10 125 116 42 129",
"\u062C\u064E\u0651\u0627\u0635 (\u02BE\u0101\u1E63) \"pear\", suggested to have originated from Hebrew " +
"\u05D0\u05B7\u05D2\u05B8\u05BC\u05E1 (ag\u00E1s)"));
assertEquals("239 209 151 206 214 92 122 140 35 158 144 162 52 205 55 171 137 23 67 206 218 175 147 113 15 254" +
" 116 33 241 25 231 186 14 212 64 253 151 252 159 33 41 241 27 231 83 171 53 209 35 25 134 6 42 33 35 239 184" +
" 31 193 234 7 252 205 101 127 241 209 34 24 5 22 23 221 148 179 239 128 140 92 187 106 204 198 59 19 25 114" +
" 248 118 36 254 231 106 196 19 239 101 27 107 69 189 112 236 156 252 16 174 125 24 10 125 116 42 129",
visualized); visualized);
visualized = visualize(MinimalEncoder.encodeHighLevel("that particularly stands out to me is \u0625\u0650" + visualized = visualize(&minimal_encoder::encodeHighLevelWithDetails("that particularly stands out to me is \u{0625}\u{0650}\u{062C}\u{064E}\u{0651}\u{0627}\u{0635} (\u{02BE}\u{0101}\u{1E63}) \"pear\", suggested to have originated from Hebrew \u{05D0}\u{05B7}\u{05D2}\u{05B8}\u{05BC}\u{05E1} (ag\u{00E1}s)", Some(encoding::all::UTF_8), None , SymbolShapeHint::FORCE_NONE).expect("encode"));
"\u062C\u064E\u0651\u0627\u0635 (\u02BE\u0101\u1E63) \"pear\", suggested to have originated from Hebrew " + assert_eq!("241 27 239 209 151 206 214 92 122 140 35 158 144 162 52 205 55 171 137 23 67 206 218 175 147 113 15 254 116 33 231 202 33 131 77 154 119 225 163 238 206 28 249 93 36 150 151 53 108 246 145 228 217 71 199 42 33 35 239 184 31 193 234 7 252 205 101 127 241 209 34 24 5 22 23 221 148 179 239 128 140 92 187 106 204 198 59 19 25 114 248 118 36 254 231 43 133 212 175 38 220 44 6 125 49 172 93 189 209 111 61 217 203 62 116 42 129 1 151 46 196 91 241 137 32 182 77 227 122 18 168 63 213 108 4 154 49 199 94 244 140 35 185 80",
"\u05D0\u05B7\u05D2\u05B8\u05BC\u05E1 (ag\u00E1s)", StandardCharsets.UTF_8, -1 , SymbolShapeHint.FORCE_NONE));
assertEquals("241 27 239 209 151 206 214 92 122 140 35 158 144 162 52 205 55 171 137 23 67 206 218 175 147 113" +
" 15 254 116 33 231 202 33 131 77 154 119 225 163 238 206 28 249 93 36 150 151 53 108 246 145 228 217 71" +
" 199 42 33 35 239 184 31 193 234 7 252 205 101 127 241 209 34 24 5 22 23 221 148 179 239 128 140 92 187 106" +
" 204 198 59 19 25 114 248 118 36 254 231 43 133 212 175 38 220 44 6 125 49 172 93 189 209 111 61 217 203 62" +
" 116 42 129 1 151 46 196 91 241 137 32 182 77 227 122 18 168 63 213 108 4 154 49 199 94 244 140 35 185 80",
visualized); visualized);
} }
#[test] #[test]
fn testPadding() { fn testPadding() {
int[] sizes = new int[2]; let mut sizes = [0usize; 2];
encodeHighLevel("IS010000000000000000000000S1118058599124123S21.2.250.1.213.1.4.8 S3FIRST NAMETEST S5MS618-06" + encodeHighLevelWithSizes("IS010000000000000000000000S1118058599124123S21.2.250.1.213.1.4.8 S3FIRST NAMETEST S5MS618-06-1985S713201S4LASTNAMETEST", &mut sizes);
"-1985S713201S4LASTNAMETEST", sizes); assert_eq!(86, sizes[0]);
assertEquals(86, sizes[0]); assert_eq!(86, sizes[1]);
assertEquals(86, sizes[1]);
} }
fn encodeHighLevelWithSizes(msg: &str, sizes: &mut [usize]) {
fn encodeHighLevelWithSizes( msg:&str, sizes:&[u32]) { sizes[0] = high_level_encoder::encodeHighLevel(msg)
sizes[0] = high_level_encoder::encodeHighLevel(msg).expect("encodes").len(); .expect("encodes")
sizes[1] = MinimalEncoder.encodeHighLevel(msg).length(); .len();
sizes[1] = minimal_encoder::encodeHighLevel(msg)
.expect("encodes")
.len();
} }
fn encodeHighLevel(msg: &str) -> String { fn encodeHighLevel(msg: &str) -> String {
@@ -539,8 +556,8 @@ lazy_static!{
fn encodeHighLevelCompare(msg: &str, compareSizeToMinimalEncoder: bool) -> String { fn encodeHighLevelCompare(msg: &str, compareSizeToMinimalEncoder: bool) -> String {
let encoded = high_level_encoder::encodeHighLevel(msg).expect("encodes"); let encoded = high_level_encoder::encodeHighLevel(msg).expect("encodes");
let encoded2 = high_level_encoder::encodeHighLevel(msg).expect("encodes"); let encoded2 = minimal_encoder::encodeHighLevel(msg).expect("encodes");
assert!(!compareSizeToMinimalEncoder || encoded2.len() <= encoded.len()); assert!(!compareSizeToMinimalEncoder || encoded2.len() <= encoded.len(), "{} <= {}", encoded2.len() , encoded.len());
visualize(&encoded) visualize(&encoded)
} }
@@ -553,14 +570,13 @@ lazy_static!{
*/ */
fn visualize(codewords: &str) -> String { fn visualize(codewords: &str) -> String {
let mut sb = String::new(); let mut sb = String::new();
for i in 0..codewords.len() { for i in 0..codewords.chars().count() {
// for (int i = 0; i < codewords.length(); i++) { // for (int i = 0; i < codewords.length(); i++) {
if (i > 0) { if i > 0 {
sb.push(' '); sb.push(' ');
} }
sb.push_str(&format!("{}", codewords.chars().nth(i).unwrap() as u32); sb.push_str(&format!("{}", codewords.chars().nth(i).unwrap() as u32));
} }
sb sb
} }

4
src/datamatrix/encoder/mod.rs
View File

@@ -28,5 +28,5 @@ pub use edifact_encoder::*;
mod base256_encoder; mod base256_encoder;
pub use base256_encoder::*; pub use base256_encoder::*;
// #[cfg(test)] #[cfg(test)]
// mod high_level_encode_test_case; mod high_level_encode_test_case;