1 files changed, 46 insertions, 24 deletions

diff --git a/tests/src/com/android/gallery3d/exif/ExifReaderTest.java b/tests/src/com/android/gallery3d/exif/ExifReaderTest.java
index 30f34c09a..a05718626 100644
--- a/tests/src/com/android/gallery3d/exif/ExifReaderTest.java
+++ b/tests/src/com/android/gallery3d/exif/ExifReaderTest.java
@@ -24,6 +24,7 @@ import java.util.Map;
 public class ExifReaderTest extends ExifXmlDataTestCase {
     private static final String TAG = "ExifReaderTest";
 
+    private ExifInterface mInterface;
     private List<Map<Short, List<String>>> mGroundTruth;
 
     @Override
@@ -34,15 +35,17 @@ public class ExifReaderTest extends ExifXmlDataTestCase {
 
     public ExifReaderTest(int imgRes, int xmlRes) {
         super(imgRes, xmlRes);
+        mInterface = new ExifInterface();
     }
 
     public ExifReaderTest(String imgPath, String xmlPath) {
         super(imgPath, xmlPath);
+        mInterface = new ExifInterface();
     }
 
     public void testRead() throws Exception {
         try {
-            ExifReader reader = new ExifReader();
+            ExifReader reader = new ExifReader(mInterface);
             ExifData exifData = reader.read(getImageInputStream());
             for (int i = 0; i < IfdId.TYPE_IFD_COUNT; i++) {
                 checkIfd(exifData.getIfdData(i), mGroundTruth.get(i));
@@ -56,59 +59,76 @@ public class ExifReaderTest extends ExifXmlDataTestCase {
     private void checkThumbnail(ExifData exifData) {
         Map<Short, List<String>> ifd1Truth = mGroundTruth.get(IfdId.TYPE_IFD_1);
 
-        List<String> typeTagValue = ifd1Truth.get(ExifTag.TAG_COMPRESSION);
-        if (typeTagValue == null) return;
+        List<String> typeTagValue = ifd1Truth.get(ExifInterface.TAG_COMPRESSION);
+        if (typeTagValue == null)
+            return;
 
         IfdData ifd1 = exifData.getIfdData(IfdId.TYPE_IFD_1);
-        if (ifd1 == null) fail(getImageTitle() + ": failed to find IFD1");
+        if (ifd1 == null)
+            fail(getImageTitle() + ": failed to find IFD1");
 
         String typeTagTruth = typeTagValue.get(0);
 
-        int type = (int) ifd1.getTag(ExifTag.TAG_COMPRESSION).getValueAt(0);
+        int type = (int) ifd1.getTag(ExifInterface.getTrueTagKey(ExifInterface.TAG_COMPRESSION))
+                .getValueAt(0);
 
-        if (String.valueOf(ExifTag.Compression.JPEG).equals(typeTagTruth)) {
-            assertTrue(getImageTitle(), type == ExifTag.Compression.JPEG);
+        if (String.valueOf(ExifInterface.Compression.JPEG).equals(typeTagTruth)) {
+            assertTrue(getImageTitle(), type == ExifInterface.Compression.JPEG);
             assertTrue(getImageTitle(), exifData.hasCompressedThumbnail());
             byte[] thumbnail = exifData.getCompressedThumbnail();
             assertTrue(getImageTitle(),
                     BitmapFactory.decodeByteArray(thumbnail, 0, thumbnail.length) != null);
-        } else if (String.valueOf(ExifTag.Compression.UNCOMPRESSION).equals(typeTagTruth)) {
-            assertTrue(getImageTitle(), type == ExifTag.Compression.UNCOMPRESSION);
+        } else if (String.valueOf(ExifInterface.Compression.UNCOMPRESSION).equals(typeTagTruth)) {
+            assertTrue(getImageTitle(), type == ExifInterface.Compression.UNCOMPRESSION);
             // Try to check the strip count with the formula provided by EXIF spec.
-            int planarType = ExifTag.PlanarConfiguration.CHUNKY;
-            ExifTag planarTag = ifd1.getTag(ExifTag.TAG_PLANAR_CONFIGURATION);
+            int planarType = ExifInterface.PlanarConfiguration.CHUNKY;
+            ExifTag planarTag = ifd1.getTag(ExifInterface
+                    .getTrueTagKey(ExifInterface.TAG_PLANAR_CONFIGURATION));
             if (planarTag != null) {
                 planarType = (int) planarTag.getValueAt(0);
             }
 
-            if (!ifd1Truth.containsKey(ExifTag.TAG_IMAGE_LENGTH) ||
-                    !ifd1Truth.containsKey(ExifTag.TAG_ROWS_PER_STRIP)) return;
+            if (!ifd1Truth.containsKey(ExifInterface.TAG_IMAGE_LENGTH) ||
+                    !ifd1Truth.containsKey(ExifInterface.TAG_ROWS_PER_STRIP)) {
+                return;
+            }
 
-            ExifTag heightTag = ifd1.getTag(ExifTag.TAG_IMAGE_LENGTH);
-            ExifTag rowPerStripTag = ifd1.getTag(ExifTag.TAG_ROWS_PER_STRIP);
+            ExifTag heightTag = ifd1.getTag(ExifInterface
+                    .getTrueTagKey(ExifInterface.TAG_IMAGE_LENGTH));
+            ExifTag rowPerStripTag = ifd1.getTag(ExifInterface
+                    .getTrueTagKey(ExifInterface.TAG_ROWS_PER_STRIP));
 
             // Fail the test if required tags are missing
-            if (heightTag == null || rowPerStripTag == null) fail(getImageTitle());
+            if (heightTag == null || rowPerStripTag == null) {
+                fail(getImageTitle());
+            }
 
             int imageLength = (int) heightTag.getValueAt(0);
             int rowsPerStrip = (int) rowPerStripTag.getValueAt(0);
             int stripCount = ifd1.getTag(
-                    ExifTag.TAG_STRIP_OFFSETS).getComponentCount();
+                    ExifInterface.getTrueTagKey(ExifInterface.TAG_STRIP_OFFSETS))
+                    .getComponentCount();
 
-            if (planarType == ExifTag.PlanarConfiguration.CHUNKY) {
+            if (planarType == ExifInterface.PlanarConfiguration.CHUNKY) {
                 assertTrue(getImageTitle(),
                         stripCount == (imageLength + rowsPerStrip - 1) / rowsPerStrip);
             } else {
-                if (!ifd1Truth.containsKey(ExifTag.TAG_SAMPLES_PER_PIXEL)) return;
-                ExifTag samplePerPixelTag = ifd1.getTag(ExifTag.TAG_SAMPLES_PER_PIXEL);
+                if (!ifd1Truth.containsKey(ExifInterface.TAG_SAMPLES_PER_PIXEL)) {
+                    return;
+                }
+                ExifTag samplePerPixelTag = ifd1.getTag(ExifInterface
+                        .getTrueTagKey(ExifInterface.TAG_SAMPLES_PER_PIXEL));
                 int samplePerPixel = (int) samplePerPixelTag.getValueAt(0);
                 assertTrue(getImageTitle(),
                         stripCount ==
                         (imageLength + rowsPerStrip - 1) / rowsPerStrip * samplePerPixel);
             }
 
-            if (!ifd1Truth.containsKey(ExifTag.TAG_STRIP_BYTE_COUNTS)) return;
-            ExifTag byteCountTag = ifd1.getTag(ExifTag.TAG_STRIP_BYTE_COUNTS);
+            if (!ifd1Truth.containsKey(ExifInterface.TAG_STRIP_BYTE_COUNTS)) {
+                return;
+            }
+            ExifTag byteCountTag = ifd1.getTag(ExifInterface
+                    .getTrueTagKey(ExifInterface.TAG_STRIP_BYTE_COUNTS));
             short byteCountDataType = byteCountTag.getDataType();
             for (int i = 0; i < stripCount; i++) {
                 if (byteCountDataType == ExifTag.TYPE_UNSIGNED_SHORT) {
@@ -124,14 +144,16 @@ public class ExifReaderTest extends ExifXmlDataTestCase {
 
     private void checkIfd(IfdData ifd, Map<Short, List<String>> ifdValue) {
         if (ifd == null) {
-            assertEquals(getImageTitle(), 0 ,ifdValue.size());
+            assertEquals(getImageTitle(), 0, ifdValue.size());
             return;
         }
         ExifTag[] tags = ifd.getAllTags();
         for (ExifTag tag : tags) {
             List<String> truth = ifdValue.get(tag.getTagId());
             assertNotNull(String.format("Tag %x, ", tag.getTagId()) + getImageTitle(), truth);
-            if (truth.contains(null)) continue;
+            if (truth.contains(null)) {
+                continue;
+            }
             assertTrue(String.format("Tag %x, ", tag.getTagId()) + getImageTitle(),
                     truth.contains(Util.tagValueToString(tag).trim()));
         }