"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "core/src/test/java/com/google/zxing/pdf417/decoder/PDF417DecoderTestCase.java" between
zxing-zxing-3.4.1.tar.gz and zxing-zxing-3.5.0.tar.gz

About: ZXing ("zebra crossing") is a multi-format 1D/2D barcode image processing library implemented in Java, with ports to other languages. Info: Project is in maintenance mode (no active development).

PDF417DecoderTestCase.java  (zxing-zxing-3.4.1):PDF417DecoderTestCase.java  (zxing-zxing-3.5.0)
skipping to change at line 20 skipping to change at line 20
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
package com.google.zxing.pdf417.decoder; package com.google.zxing.pdf417.decoder;
import com.google.zxing.FormatException; import com.google.zxing.FormatException;
import com.google.zxing.WriterException;
import com.google.zxing.pdf417.PDF417ResultMetadata; import com.google.zxing.pdf417.PDF417ResultMetadata;
import com.google.zxing.common.DecoderResult;
import com.google.zxing.pdf417.encoder.Compaction;
import com.google.zxing.pdf417.encoder.PDF417HighLevelEncoderTestAdapter;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Test; import org.junit.Test;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Random;
/** /**
* Tests {@link DecodedBitStreamParser}. * Tests {@link DecodedBitStreamParser}.
*/ */
public class PDF417DecoderTestCase extends Assert { public class PDF417DecoderTestCase extends Assert {
/** /**
* Tests the first sample given in ISO/IEC 15438:2015(E) - Annex H.4 * Tests the first sample given in ISO/IEC 15438:2015(E) - Annex H.4
*/ */
@Test @Test
public void testStandardSample1() throws FormatException { public void testStandardSample1() throws FormatException {
PDF417ResultMetadata resultMetadata = new PDF417ResultMetadata(); PDF417ResultMetadata resultMetadata = new PDF417ResultMetadata();
int[] sampleCodes = {20, 928, 111, 100, 17, 53, 923, 1, 111, 104, 923, 3, 64 , 416, 34, 923, 4, 258, 446, 67, int[] sampleCodes = {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 // we should never reach these
1000, 1000, 1000}; 1000, 1000, 1000};
DecodedBitStreamParser.decodeMacroBlock(sampleCodes, 2, resultMetadata); DecodedBitStreamParser.decodeMacroBlock(sampleCodes, 2, resultMetadata);
assertEquals(0, resultMetadata.getSegmentIndex()); assertEquals(0, resultMetadata.getSegmentIndex());
assertEquals("ARBX", resultMetadata.getFileId()); assertEquals("017053", resultMetadata.getFileId());
assertFalse(resultMetadata.isLastSegment()); assertFalse(resultMetadata.isLastSegment());
assertEquals(4, resultMetadata.getSegmentCount()); assertEquals(4, resultMetadata.getSegmentCount());
assertEquals("CEN BE", resultMetadata.getSender()); assertEquals("CEN BE", resultMetadata.getSender());
assertEquals("ISO CH", resultMetadata.getAddressee()); assertEquals("ISO CH", resultMetadata.getAddressee());
@SuppressWarnings("deprecation") @SuppressWarnings("deprecation")
int[] optionalData = resultMetadata.getOptionalData(); int[] optionalData = resultMetadata.getOptionalData();
assertEquals("first element of optional array should be the first field iden tifier", 1, optionalData[0]); assertEquals("first element of optional array should be the first field iden tifier", 1, optionalData[0]);
assertEquals("last element of optional array should be the last codeword of the last field", assertEquals("last element of optional array should be the last codeword of the last field",
67, optionalData[optionalData.length - 1]); 67, optionalData[optionalData.length - 1]);
skipping to change at line 68 skipping to change at line 76
@Test @Test
public void testStandardSample2() throws FormatException { public void testStandardSample2() throws FormatException {
PDF417ResultMetadata resultMetadata = new PDF417ResultMetadata(); PDF417ResultMetadata resultMetadata = new PDF417ResultMetadata();
int[] sampleCodes = {11, 928, 111, 103, 17, 53, 923, 1, 111, 104, 922, int[] sampleCodes = {11, 928, 111, 103, 17, 53, 923, 1, 111, 104, 922,
// we should never reach these // we should never reach these
1000, 1000, 1000}; 1000, 1000, 1000};
DecodedBitStreamParser.decodeMacroBlock(sampleCodes, 2, resultMetadata); DecodedBitStreamParser.decodeMacroBlock(sampleCodes, 2, resultMetadata);
assertEquals(3, resultMetadata.getSegmentIndex()); assertEquals(3, resultMetadata.getSegmentIndex());
assertEquals("ARBX", resultMetadata.getFileId()); assertEquals("017053", resultMetadata.getFileId());
assertTrue(resultMetadata.isLastSegment()); assertTrue(resultMetadata.isLastSegment());
assertEquals(4, resultMetadata.getSegmentCount()); assertEquals(4, resultMetadata.getSegmentCount());
assertNull(resultMetadata.getAddressee()); assertNull(resultMetadata.getAddressee());
assertNull(resultMetadata.getSender()); assertNull(resultMetadata.getSender());
@SuppressWarnings("deprecation") @SuppressWarnings("deprecation")
int[] optionalData = resultMetadata.getOptionalData(); int[] optionalData = resultMetadata.getOptionalData();
assertEquals("first element of optional array should be the first field iden tifier", 1, optionalData[0]); assertEquals("first element of optional array should be the first field iden tifier", 1, optionalData[0]);
assertEquals("last element of optional array should be the last codeword of the last field", assertEquals("last element of optional array should be the last codeword of the last field",
104, optionalData[optionalData.length - 1]); 104, optionalData[optionalData.length - 1]);
} }
/**
* Tests the example given in ISO/IEC 15438:2015(E) - Annex H.6
*/
@Test
public void testStandardSample3() throws FormatException {
PDF417ResultMetadata resultMetadata = new PDF417ResultMetadata();
int[] sampleCodes = {7, 928, 111, 100, 100, 200, 300,
0}; // Final dummy ECC codeword required to avoid ArrayIndexOutOfBounds
DecodedBitStreamParser.decodeMacroBlock(sampleCodes, 2, resultMetadata);
assertEquals(0, resultMetadata.getSegmentIndex());
assertEquals("100200300", resultMetadata.getFileId());
assertFalse(resultMetadata.isLastSegment());
assertEquals(-1, resultMetadata.getSegmentCount());
assertNull(resultMetadata.getAddressee());
assertNull(resultMetadata.getSender());
assertNull(resultMetadata.getOptionalData());
// Check that symbol containing no data except Macro is accepted (see note i
n Annex H.2)
DecoderResult decoderResult = DecodedBitStreamParser.decode(sampleCodes, "0"
);
assertEquals("", decoderResult.getText());
assertNotNull(decoderResult.getOther());
}
@Test @Test
public void testSampleWithFilename() throws FormatException { public void testSampleWithFilename() throws FormatException {
int[] sampleCodes = {23, 477, 928, 111, 100, 0, 252, 21, 86, 923, 0, 815, 25 1, 133, 12, 148, 537, 593, int[] sampleCodes = {23, 477, 928, 111, 100, 0, 252, 21, 86, 923, 0, 815, 25 1, 133, 12, 148, 537, 593,
599, 923, 1, 111, 102, 98, 311, 355, 522, 920, 779, 40, 628, 33, 749, 26 7, 506, 213, 928, 465, 248, 599, 923, 1, 111, 102, 98, 311, 355, 522, 920, 779, 40, 628, 33, 749, 26 7, 506, 213, 928, 465, 248,
493, 72, 780, 699, 780, 493, 755, 84, 198, 628, 368, 156, 198, 809, 19, 113}; 493, 72, 780, 699, 780, 493, 755, 84, 198, 628, 368, 156, 198, 809, 19, 113};
PDF417ResultMetadata resultMetadata = new PDF417ResultMetadata(); PDF417ResultMetadata resultMetadata = new PDF417ResultMetadata();
DecodedBitStreamParser.decodeMacroBlock(sampleCodes, 3, resultMetadata); DecodedBitStreamParser.decodeMacroBlock(sampleCodes, 3, resultMetadata);
assertEquals(0, resultMetadata.getSegmentIndex()); assertEquals(0, resultMetadata.getSegmentIndex());
assertEquals("AAIMAVC ", resultMetadata.getFileId()); assertEquals("000252021086", resultMetadata.getFileId());
assertFalse(resultMetadata.isLastSegment()); assertFalse(resultMetadata.isLastSegment());
assertEquals(2, resultMetadata.getSegmentCount()); assertEquals(2, resultMetadata.getSegmentCount());
assertNull(resultMetadata.getAddressee()); assertNull(resultMetadata.getAddressee());
assertNull(resultMetadata.getSender()); assertNull(resultMetadata.getSender());
assertEquals("filename.txt", resultMetadata.getFileName()); assertEquals("filename.txt", resultMetadata.getFileName());
} }
@Test @Test
public void testSampleWithNumericValues() throws FormatException { public void testSampleWithNumericValues() throws FormatException {
int[] sampleCodes = {25, 477, 928, 111, 100, 0, 252, 21, 86, 923, 2, 2, 0, 1 , 0, 0, 0, 923, 5, 130, 923, int[] sampleCodes = {25, 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}; 6, 1, 500, 13, 0};
PDF417ResultMetadata resultMetadata = new PDF417ResultMetadata(); PDF417ResultMetadata resultMetadata = new PDF417ResultMetadata();
DecodedBitStreamParser.decodeMacroBlock(sampleCodes, 3, resultMetadata); DecodedBitStreamParser.decodeMacroBlock(sampleCodes, 3, resultMetadata);
assertEquals(0, resultMetadata.getSegmentIndex()); assertEquals(0, resultMetadata.getSegmentIndex());
assertEquals("AAIMAVC ", resultMetadata.getFileId()); assertEquals("000252021086", resultMetadata.getFileId());
assertFalse(resultMetadata.isLastSegment()); assertFalse(resultMetadata.isLastSegment());
assertEquals(180980729000000L, resultMetadata.getTimestamp()); assertEquals(180980729000000L, resultMetadata.getTimestamp());
assertEquals(30, resultMetadata.getFileSize()); assertEquals(30, resultMetadata.getFileSize());
assertEquals(260013, resultMetadata.getChecksum()); assertEquals(260013, resultMetadata.getChecksum());
} }
@Test
public void testSampleWithMacroTerminatorOnly() throws FormatException {
int[] sampleCodes = {7, 477, 928, 222, 198, 0, 922};
PDF417ResultMetadata resultMetadata = new PDF417ResultMetadata();
DecodedBitStreamParser.decodeMacroBlock(sampleCodes, 3, resultMetadata);
assertEquals(99998, resultMetadata.getSegmentIndex());
assertEquals("000", resultMetadata.getFileId());
assertTrue(resultMetadata.isLastSegment());
assertEquals(-1, resultMetadata.getSegmentCount());
assertNull(resultMetadata.getOptionalData());
}
@Test(expected = FormatException.class)
public void testSampleWithBadSequenceIndexMacro() throws FormatException {
int[] sampleCodes = {3, 928, 222, 0};
PDF417ResultMetadata resultMetadata = new PDF417ResultMetadata();
DecodedBitStreamParser.decodeMacroBlock(sampleCodes, 2, resultMetadata);
}
@Test(expected = FormatException.class)
public void testSampleWithNoFileIdMacro() throws FormatException {
int[] sampleCodes = {4, 928, 222, 198, 0};
PDF417ResultMetadata resultMetadata = new PDF417ResultMetadata();
DecodedBitStreamParser.decodeMacroBlock(sampleCodes, 2, resultMetadata);
}
@Test(expected = FormatException.class)
public void testSampleWithNoDataNoMacro() throws FormatException {
int[] sampleCodes = {3, 899, 899, 0};
DecodedBitStreamParser.decode(sampleCodes, "0");
}
@Test
public void testUppercase() throws WriterException, FormatException {
//encodeDecode("", 0);
performEncodeTest('A', new int[] { 3, 4, 5, 6, 4, 4, 5, 5});
}
@Test
public void testNumeric() throws WriterException, FormatException {
performEncodeTest('1', new int[] { 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 7, 7,
8, 8, 8, 9, 9, 9, 10, 10});
}
@Test
public void testByte() throws WriterException, FormatException {
performEncodeTest('\u00c4', new int[] { 3, 4, 5, 6, 7, 7, 8});
}
@Test
public void testUppercaseLowercaseMix1() throws WriterException, FormatExcepti
on {
encodeDecode("aA", 4);
encodeDecode("aAa", 5);
encodeDecode("Aa", 4);
encodeDecode("Aaa", 5);
encodeDecode("AaA", 5);
encodeDecode("AaaA", 6);
encodeDecode("Aaaa", 6);
encodeDecode("AaAaA", 5);
encodeDecode("AaaAaaA", 6);
encodeDecode("AaaAAaaA", 7);
}
@Test
public void testPunctuation() throws WriterException, FormatException {
performEncodeTest(';', new int[] { 3, 4, 5, 6, 6, 7, 8});
encodeDecode(";;;;;;;;;;;;;;;;", 17);
}
@Test
public void testUppercaseLowercaseMix2() throws WriterException, FormatExcepti
on {
performPermutationTest(new char[] {'A', 'a'}, 10, 8972);
}
@Test
public void testUppercaseNumericMix() throws WriterException, FormatException
{
performPermutationTest(new char[] {'A', '1'}, 14, 192510);
}
@Test
public void testUppercaseMixedMix() throws WriterException, FormatException {
performPermutationTest(new char[] {'A', '1', ' ', ';'}, 7, 106060);
}
@Test
public void testUppercasePunctuationMix() throws WriterException, FormatExcept
ion {
performPermutationTest(new char[] {'A', ';'}, 10, 8967);
}
@Test
public void testUppercaseByteMix() throws WriterException, FormatException {
performPermutationTest(new char[] {'A', '\u00c4'}, 10, 11222);
}
@Test
public void testLowercaseByteMix() throws WriterException, FormatException {
performPermutationTest(new char[] {'a', '\u00c4'}, 10, 11233);
}
public void testUppercaseLowercaseNumericMix() throws WriterException, FormatE
xception {
performPermutationTest(new char[] {'A', 'a', '1'}, 7, 15491);
}
@Test
public void testUppercaseLowercasePunctuationMix() throws WriterException, For
matException {
performPermutationTest(new char[] {'A', 'a', ';'}, 7, 15491);
}
@Test
public void testUppercaseLowercaseByteMix() throws WriterException, FormatExce
ption {
performPermutationTest(new char[] {'A', 'a', '\u00c4'}, 7, 17288);
}
@Test
public void testLowercasePunctuationByteMix() throws WriterException, FormatEx
ception {
performPermutationTest(new char[] {'a', ';', '\u00c4'}, 7, 17427);
}
@Test
public void testUppercaseLowercaseNumericPunctuationMix() throws WriterExcepti
on, FormatException {
performPermutationTest(new char[] {'A', 'a', '1', ';'}, 7, 120479);
}
@Test
public void testBinaryData() throws WriterException, FormatException {
byte[] bytes = new byte[500];
Random random = new Random(0);
int total = 0;
for (int i = 0; i < 10000; i++) {
random.nextBytes(bytes);
total += encodeDecode(new String(bytes, StandardCharsets.ISO_8859_1));
}
assertEquals(4190044, total);
}
@Test
public void testECIEnglishHiragana() throws Exception {
//multi ECI UTF-8, UTF-16 and ISO-8859-1
performECITest(new char[] {'a', '1', '\u3040'}, new float[] {20f, 1f, 10f},
105825, 110914);
}
@Test
public void testECIEnglishKatakana() throws Exception {
//multi ECI UTF-8, UTF-16 and ISO-8859-1
performECITest(new char[] {'a', '1', '\u30a0'}, new float[] {20f, 1f, 10f},
109177, 110914);
}
@Test
public void testECIEnglishHalfWidthKatakana() throws Exception {
//single ECI
performECITest(new char[] {'a', '1', '\uff80'}, new float[] {20f, 1f, 10f},
80617, 110914);
}
@Test
public void testECIEnglishChinese() throws Exception {
//single ECI
performECITest(new char[] {'a', '1', '\u4e00'}, new float[] {20f, 1f, 10f},
95797, 110914);
}
@Test
public void testECIGermanCyrillic() throws Exception {
//single ECI since the German Umlaut is in ISO-8859-1
performECITest(new char[] {'a', '1', '\u00c4', '\u042f'}, new float[] {20f,
1f, 1f, 10f}, 80755, 96007);
}
@Test
public void testECIEnglishCzechCyrillic1() throws Exception {
//multi ECI between ISO-8859-2 and ISO-8859-5
performECITest(new char[] {'a', '1', '\u010c', '\u042f'}, new float[] {10f,
1f, 10f, 10f}, 102824, 124525);
}
@Test
public void testECIEnglishCzechCyrillic2() throws Exception {
//multi ECI between ISO-8859-2 and ISO-8859-5
performECITest(new char[] {'a', '1', '\u010c', '\u042f'}, new float[] {40f,
1f, 10f, 10f}, 81321, 88236);
}
@Test
public void testECIEnglishArabicCyrillic() throws Exception {
//multi ECI between UTF-8 (ISO-8859-6 is excluded in CharacterSetECI) and IS
O-8859-5
performECITest(new char[] {'a', '1', '\u0620', '\u042f'}, new float[] {10f,
1f, 10f, 10f}, 118510, 124525);
}
@Test
public void testBinaryMultiECI() throws Exception {
//Test the cases described in 5.5.5.3 "ECI and Byte Compaction mode using la
tch 924 and 901"
performDecodeTest(new int[] {5, 927, 4, 913, 200}, "\u010c");
performDecodeTest(new int[] {9, 927, 4, 913, 200, 927, 7, 913, 207}, "\u010c
\u042f");
performDecodeTest(new int[] {9, 927, 4, 901, 200, 927, 7, 901, 207}, "\u010c
\u042f");
performDecodeTest(new int[] {8, 927, 4, 901, 200, 927, 7, 207}, "\u010c\u042
f");
performDecodeTest(new int[] {14, 927, 4, 901, 200, 927, 7, 207, 927, 4, 200,
927, 7, 207},
"\u010c\u042f\u010c\u042f");
performDecodeTest(new int[] {16, 927, 4, 924, 336, 432, 197, 51, 300, 927, 7
, 348, 231, 311, 858, 567},
"\u010c\u010c\u010c\u010c\u010c\u010c\u042f\u042f\u042f\u042f\u042f\u042
f");
}
private static void encodeDecode(String input, int expectedLength) throws Writ
erException, FormatException {
assertEquals(expectedLength, encodeDecode(input));
}
private static int encodeDecode(String input) throws WriterException, FormatEx
ception {
return encodeDecode(input, null, false, true);
}
private static int encodeDecode(String input, Charset charset, boolean autoECI
, boolean decode)
throws WriterException, FormatException {
String s = PDF417HighLevelEncoderTestAdapter.encodeHighLevel(input, Compacti
on.AUTO, charset, autoECI);
if (decode) {
int[] codewords = new int[s.length() + 1];
codewords[0] = codewords.length;
for (int i = 1; i < codewords.length; i++) {
codewords[i] = s.charAt(i - 1);
}
performDecodeTest(codewords, input);
}
return s.length() + 1;
}
private static int getEndIndex(int length, char[] chars) {
double decimalLength = Math.log10(chars.length);
return (int) Math.ceil(Math.pow(10, decimalLength * length));
}
private static String generatePermutation(int index, int length, char[] chars)
{
int N = chars.length;
String baseNNumber = Integer.toString(index, N);
while (baseNNumber.length() < length) {
baseNNumber = "0" + baseNNumber;
}
String prefix = "";
for (int i = 0; i < baseNNumber.length(); i++) {
prefix += chars[baseNNumber.charAt(i) - '0'];
}
return prefix;
}
private static void performPermutationTest(char[] chars, int length, int expec
tedTotal) throws WriterException,
FormatException {
int endIndex = getEndIndex(length, chars);
int total = 0;
for (int i = 0; i < endIndex; i++) {
total += encodeDecode(generatePermutation(i, length, chars));
}
assertEquals(expectedTotal, total);
}
private static void performEncodeTest(char c, int[] expectedLengths) throws Wr
iterException, FormatException {
for (int i = 0; i < expectedLengths.length; i++) {
StringBuilder sb = new StringBuilder();
for (int j = 0; j <= i; j++) {
sb.append(c);
}
encodeDecode(sb.toString(), expectedLengths[i]);
}
}
private static void performDecodeTest(int[] codewords, String expectedResult)
throws FormatException {
DecoderResult result = DecodedBitStreamParser.decode(codewords, "0");
assertEquals(expectedResult, result.getText());
}
private static void performECITest(char[] chars,
float[] weights,
int expectedMinLength,
int expectedUTFLength) throws WriterException, Fo
rmatException {
Random random = new Random(0);
int minLength = 0;
int utfLength = 0;
for (int i = 0; i < 1000; i++) {
String s = generateText(random, 100, chars, weights);
minLength += encodeDecode(s, null, true, true);
utfLength += encodeDecode(s, StandardCharsets.UTF_8, false, true);
}
assertEquals(expectedMinLength, minLength);
assertEquals(expectedUTFLength, utfLength);
}
private static String generateText(Random random, int maxWidth, char[] chars,
float[] weights) {
StringBuilder result = new StringBuilder();
final int maxWordWidth = 7;
float total = 0;
for (int i = 0; i < weights.length; i++) {
total += weights[i];
}
for (int i = 0; i < weights.length; i++) {
weights[i] /= total;
}
int cnt = 0;
do {
float maxValue = 0;
int maxIndex = 0;
for (int j = 0; j < weights.length; j++) {
float value = random.nextFloat() * weights[j];
if (value > maxValue) {
maxValue = value;
maxIndex = j;
}
}
final float wordLength = maxWordWidth * random.nextFloat();
if (wordLength > 0 && result.length() > 0) {
result.append(' ');
}
for (int j = 0; j < wordLength; j++) {
char c = chars[maxIndex];
if (j == 0 && c >= 'a' && c <= 'z' && random.nextBoolean()) {
c = (char) (c - 'a' + 'A');
}
result.append(c);
}
if (cnt % 2 != 0 && random.nextBoolean()) {
result.append('.');
}
cnt++;
} while (result.length() < maxWidth - maxWordWidth);
return result.toString();
}
} }
 End of changes. 9 change blocks. 
4 lines changed or deleted 392 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)