X-Git-Url: http://git.rot13.org/?a=blobdiff_plain;f=core%2Ftest%2Fsrc%2Fcom%2Fgoogle%2Fzxing%2Fcommon%2FAbstractBlackBoxTestCase.java;h=2ef12b43dda2e70a5b990fc345b97a2920d57f37;hb=608fe313d82bb79f0f5a96856697bdfb4a6305d3;hp=9d4017ead94901fe438559aba8dbfd11aa04eb92;hpb=7d63fd5b1c4e8136b4ca5833445f9e587c85a400;p=zxing.git diff --git a/core/test/src/com/google/zxing/common/AbstractBlackBoxTestCase.java b/core/test/src/com/google/zxing/common/AbstractBlackBoxTestCase.java index 9d4017ea..2ef12b43 100644 --- a/core/test/src/com/google/zxing/common/AbstractBlackBoxTestCase.java +++ b/core/test/src/com/google/zxing/common/AbstractBlackBoxTestCase.java @@ -17,15 +17,16 @@ package com.google.zxing.common; import com.google.zxing.BarcodeFormat; +import com.google.zxing.BinaryBitmap; import com.google.zxing.DecodeHintType; -import com.google.zxing.MonochromeBitmapSource; +import com.google.zxing.LuminanceSource; import com.google.zxing.Reader; import com.google.zxing.ReaderException; import com.google.zxing.Result; -import com.google.zxing.client.j2se.BufferedImageMonochromeBitmapSource; +import com.google.zxing.client.j2se.BufferedImageLuminanceSource; + import junit.framework.TestCase; -import javax.imageio.ImageIO; import java.awt.geom.AffineTransform; import java.awt.image.AffineTransformOp; import java.awt.image.BufferedImage; @@ -35,10 +36,12 @@ import java.io.FileInputStream; import java.io.FilenameFilter; import java.io.IOException; import java.io.InputStreamReader; +import java.nio.charset.Charset; +import java.util.ArrayList; import java.util.Hashtable; import java.util.List; -import java.util.ArrayList; -import java.nio.charset.Charset; + +import javax.imageio.ImageIO; /** * @author Sean Owen @@ -60,6 +63,35 @@ public abstract class AbstractBlackBoxTestCase extends TestCase { } }; + public static class SummaryResults { + private int totalFound; + private int totalMustPass; + private int totalTests; + + public SummaryResults() { + totalFound = 0; + totalMustPass = 0; + totalTests = 0; + } + + public SummaryResults(int found, int mustPass, int total) { + totalFound = found; + totalMustPass = mustPass; + totalTests = total; + } + + public void add(SummaryResults other) { + totalFound += other.totalFound; + totalMustPass += other.totalMustPass; + totalTests += other.totalTests; + } + + public String toString() { + return "\nSUMMARY RESULTS:\n Decoded " + totalFound + " images out of " + totalTests + + " (" + (totalFound * 100 / totalTests) + "%, " + totalMustPass + " required)"; + } + } + private static class TestResult { private final int mustPassCount; private final int tryHarderCount; @@ -86,9 +118,15 @@ public abstract class AbstractBlackBoxTestCase extends TestCase { private final BarcodeFormat expectedFormat; private final List testResults; - protected AbstractBlackBoxTestCase(File testBase, + protected AbstractBlackBoxTestCase(String testBasePathSuffix, Reader barcodeReader, BarcodeFormat expectedFormat) { + // A little workaround to prevent aggravation in my IDE + File testBase = new File(testBasePathSuffix); + if (!testBase.exists()) { + // try starting with 'core' since the test base is often given as the project root + testBase = new File("core/" + testBasePathSuffix); + } this.testBase = testBase; this.barcodeReader = barcodeReader; this.expectedFormat = expectedFormat; @@ -115,7 +153,17 @@ public abstract class AbstractBlackBoxTestCase extends TestCase { return barcodeReader; } + protected Hashtable getHints() { + return null; + } + + // This workaround is used because AbstractNegativeBlackBoxTestCase overrides this method but does + // not return SummaryResults. public void testBlackBox() throws IOException { + testBlackBoxCountingResults(true); + } + + public SummaryResults testBlackBoxCountingResults(boolean assertOnFailure) throws IOException { assertFalse(testResults.isEmpty()); File[] imageFiles = getImageFiles(); @@ -135,17 +183,20 @@ public abstract class AbstractBlackBoxTestCase extends TestCase { for (int x = 0; x < testCount; x++) { float rotation = testResults.get(x).getRotation(); BufferedImage rotatedImage = rotateImage(image, rotation); - MonochromeBitmapSource source = new BufferedImageMonochromeBitmapSource(rotatedImage); - if (decode(source, rotation, expectedText, false)) { + LuminanceSource source = new BufferedImageLuminanceSource(rotatedImage); + BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source)); + if (decode(bitmap, rotation, expectedText, false)) { passedCounts[x]++; } - if (decode(source, rotation, expectedText, true)) { + if (decode(bitmap, rotation, expectedText, true)) { tryHarderCounts[x]++; } } } // Print the results of all tests first + int totalFound = 0; + int totalMustPass = 0; for (int x = 0; x < testCount; x++) { System.out.println("Rotation " + testResults.get(x).getRotation() + " degrees:"); System.out.println(" " + passedCounts[x] + " of " + imageFiles.length + " images passed (" @@ -153,26 +204,50 @@ public abstract class AbstractBlackBoxTestCase extends TestCase { System.out.println(" " + tryHarderCounts[x] + " of " + imageFiles.length + " images passed with try harder (" + testResults.get(x).getTryHarderCount() + " required)"); + totalFound += passedCounts[x]; + totalFound += tryHarderCounts[x]; + totalMustPass += testResults.get(x).getMustPassCount(); + totalMustPass += testResults.get(x).getTryHarderCount(); + } + + int totalTests = imageFiles.length * testCount * 2; + System.out.println("TOTALS:\n Decoded " + totalFound + " images out of " + totalTests + + " (" + (totalFound * 100 / totalTests) + "%, " + totalMustPass + " required)"); + if (totalFound > totalMustPass) { + System.out.println(" *** Test too lax by " + (totalFound - totalMustPass) + " images"); + } else if (totalFound < totalMustPass) { + System.out.println(" *** Test failed by " + (totalMustPass - totalFound) + " images"); } // Then run through again and assert if any failed - for (int x = 0; x < testCount; x++) { - assertTrue("Rotation " + testResults.get(x).getRotation() + - " degrees: Too many images failed", - passedCounts[x] >= testResults.get(x).getMustPassCount()); - assertTrue("Try harder, Rotation " + testResults.get(x).getRotation() + - " degrees: Too many images failed", - tryHarderCounts[x] >= testResults.get(x).getTryHarderCount()); + if (assertOnFailure) { + for (int x = 0; x < testCount; x++) { + assertTrue("Rotation " + testResults.get(x).getRotation() + + " degrees: Too many images failed", + passedCounts[x] >= testResults.get(x).getMustPassCount()); + assertTrue("Try harder, Rotation " + testResults.get(x).getRotation() + + " degrees: Too many images failed", + tryHarderCounts[x] >= testResults.get(x).getTryHarderCount()); + } } + return new SummaryResults(totalFound, totalMustPass, totalTests); } - private boolean decode(MonochromeBitmapSource source, float rotation, String expectedText, + private boolean decode(BinaryBitmap source, float rotation, String expectedText, boolean tryHarder) { Result result; String suffix = " (" + (tryHarder ? "try harder, " : "") + "rotation: " + rotation + ')'; try { - result = barcodeReader.decode(source, tryHarder ? TRY_HARDER_HINT : null); + Hashtable hints = getHints(); + if (tryHarder) { + if (hints == null) { + hints = TRY_HARDER_HINT; + } else { + hints.put(DecodeHintType.TRY_HARDER, Boolean.TRUE); + } + } + result = barcodeReader.decode(source, hints); } catch (ReaderException re) { System.out.println(re + suffix); return false; @@ -180,14 +255,14 @@ public abstract class AbstractBlackBoxTestCase extends TestCase { if (!expectedFormat.equals(result.getBarcodeFormat())) { System.out.println("Format mismatch: expected '" + expectedFormat + "' but got '" + - result.getBarcodeFormat() + "'" + suffix); + result.getBarcodeFormat() + '\'' + suffix); return false; } String resultText = result.getText(); if (!expectedText.equals(resultText)) { System.out.println("Mismatch: expected '" + expectedText + "' but got '" + resultText + - "'" + suffix); + '\'' + suffix); return false; } return true; @@ -213,10 +288,10 @@ public abstract class AbstractBlackBoxTestCase extends TestCase { return original; } else { AffineTransform at = new AffineTransform(); - at.rotate(Math.toRadians(degrees), original.getWidth() / 2.0f, original.getHeight() / 2.0f); + at.rotate(Math.toRadians(degrees), original.getWidth() / 2.0, original.getHeight() / 2.0); BufferedImageOp op = new AffineTransformOp(at, AffineTransformOp.TYPE_BICUBIC); return op.filter(original, null); } } -} \ No newline at end of file +}