diff options
Diffstat (limited to 'tests/src/com/android')
11 files changed, 768 insertions, 366 deletions
diff --git a/tests/src/com/android/gallery3d/exif/ExifDataTest.java b/tests/src/com/android/gallery3d/exif/ExifDataTest.java index ba656bfa8..fed8e1eaf 100644 --- a/tests/src/com/android/gallery3d/exif/ExifDataTest.java +++ b/tests/src/com/android/gallery3d/exif/ExifDataTest.java @@ -42,13 +42,13 @@ public class ExifDataTest extends TestCase { // check data assertEquals("test", exifData.getTag(ExifTag.TAG_MAKE).getString()); - assertEquals(1000, exifData.getTag(ExifTag.TAG_IMAGE_WIDTH).getUnsignedLong(0)); - assertEquals(1, exifData.getTag(ExifTag.TAG_ISO_SPEED_RATINGS).getUnsignedShort(0)); + assertEquals(1000, (int) exifData.getTag(ExifTag.TAG_IMAGE_WIDTH).getValueAt(0)); + assertEquals(1, (int) exifData.getTag(ExifTag.TAG_ISO_SPEED_RATINGS).getValueAt(0)); assertEquals(new Rational(10, 100), exifData.getTag(ExifTag.TAG_GPS_ALTITUDE).getRational(0)); assertEquals("inter_test", exifData.getInteroperabilityTag(ExifTag.TAG_INTEROPERABILITY_INDEX).getString()); assertEquals("test_thumb", exifData.getThumbnailTag(ExifTag.TAG_MAKE).getString()); - assertEquals(100, exifData.getThumbnailTag(ExifTag.TAG_IMAGE_WIDTH).getUnsignedLong(0)); + assertEquals(100, (int) exifData.getThumbnailTag(ExifTag.TAG_IMAGE_WIDTH).getValueAt(0)); } } diff --git a/tests/src/com/android/gallery3d/exif/ExifOutputStreamTest.java b/tests/src/com/android/gallery3d/exif/ExifOutputStreamTest.java index ad603df39..8c98fa037 100644 --- a/tests/src/com/android/gallery3d/exif/ExifOutputStreamTest.java +++ b/tests/src/com/android/gallery3d/exif/ExifOutputStreamTest.java @@ -19,6 +19,8 @@ package com.android.gallery3d.exif; import android.graphics.Bitmap; import android.graphics.BitmapFactory; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; @@ -26,48 +28,82 @@ import java.io.IOException; import java.io.InputStream; public class ExifOutputStreamTest extends ExifXmlDataTestCase { - public ExifOutputStreamTest(int imageResourceId, int xmlResourceId) { - super(imageResourceId, xmlResourceId); + + private File mTmpFile; + + @Override + public void setUp() throws Exception { + super.setUp(); + mTmpFile = File.createTempFile("exif_test", ".jpg"); + } + + public ExifOutputStreamTest(int imgRes, int xmlRes) { + super(imgRes, xmlRes); } - public void testExifOutputStream() throws IOException, ExifInvalidFormatException { - File file = File.createTempFile("exif_test", ".jpg"); + public ExifOutputStreamTest(String imgPath, String xmlPath) { + super(imgPath, xmlPath); + } + + public void testExifOutputStream() throws Exception { InputStream imageInputStream = null; InputStream exifInputStream = null; FileInputStream reDecodeInputStream = null; FileInputStream reParseInputStream = null; try { - // Read the image - imageInputStream = getInstrumentation() - .getContext().getResources().openRawResource(mImageResourceId); - Bitmap bmp = BitmapFactory.decodeStream(imageInputStream); - - // Read exif data - exifInputStream = getInstrumentation() - .getContext().getResources().openRawResource(mImageResourceId); - ExifData exifData = new ExifReader().read(exifInputStream); - - // Encode the image with the exif data - FileOutputStream outputStream = new FileOutputStream(file); - ExifOutputStream exifOutputStream = new ExifOutputStream(outputStream); - exifOutputStream.setExifData(exifData); - bmp.compress(Bitmap.CompressFormat.JPEG, 100, exifOutputStream); - exifOutputStream.close(); - - // Re-decode the temp file and check the data. - reDecodeInputStream = new FileInputStream(file); - Bitmap decodedBmp = BitmapFactory.decodeStream(reDecodeInputStream); - assertNotNull(decodedBmp); - - // Re-parse the temp file the check EXIF tag - reParseInputStream = new FileInputStream(file); - ExifData reExifData = new ExifReader().read(reParseInputStream); - assertEquals(exifData, reExifData); - } finally { - Util.closeSilently(imageInputStream); - Util.closeSilently(exifInputStream); - Util.closeSilently(reDecodeInputStream); - Util.closeSilently(reParseInputStream); + try { + byte[] imgData = readToByteArray(getImageInputStream()); + imageInputStream = new ByteArrayInputStream(imgData); + exifInputStream = new ByteArrayInputStream(imgData); + + // Read the image data + Bitmap bmp = BitmapFactory.decodeStream(imageInputStream); + // The image is invalid + if (bmp == null) return; + + // Read exif data + ExifData exifData = new ExifReader().read(exifInputStream); + + // Encode the image with the exif data + FileOutputStream outputStream = new FileOutputStream(mTmpFile); + ExifOutputStream exifOutputStream = new ExifOutputStream(outputStream); + exifOutputStream.setExifData(exifData); + bmp.compress(Bitmap.CompressFormat.JPEG, 100, exifOutputStream); + exifOutputStream.close(); + + // Re-decode the temp file and check the data. + reDecodeInputStream = new FileInputStream(mTmpFile); + Bitmap decodedBmp = BitmapFactory.decodeStream(reDecodeInputStream); + assertNotNull(getImageTitle(), decodedBmp); + + // Re-parse the temp file the check EXIF tag + reParseInputStream = new FileInputStream(mTmpFile); + ExifData reExifData = new ExifReader().read(reParseInputStream); + assertEquals(getImageTitle(), exifData, reExifData); + } finally { + Util.closeSilently(imageInputStream); + Util.closeSilently(exifInputStream); + Util.closeSilently(reDecodeInputStream); + Util.closeSilently(reParseInputStream); + } + } catch (Exception e) { + throw new Exception(getImageTitle(), e); + } + } + + private byte[] readToByteArray(InputStream is) throws IOException { + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + int len; + byte[] buf = new byte[1024]; + while ((len = is.read(buf)) > -1) { + bos.write(buf, 0, len); } + bos.flush(); + return bos.toByteArray(); + } + + @Override + public void tearDown() { + mTmpFile.delete(); } -}
\ No newline at end of file +} diff --git a/tests/src/com/android/gallery3d/exif/ExifParserTest.java b/tests/src/com/android/gallery3d/exif/ExifParserTest.java index c1ad8341b..7a9d6e631 100644 --- a/tests/src/com/android/gallery3d/exif/ExifParserTest.java +++ b/tests/src/com/android/gallery3d/exif/ExifParserTest.java @@ -16,219 +16,210 @@ package com.android.gallery3d.exif; -import android.content.res.XmlResourceParser; import android.graphics.Bitmap; import android.graphics.BitmapFactory; -import java.io.IOException; -import java.io.InputStream; -import java.util.HashMap; +import java.util.List; +import java.util.Map; public class ExifParserTest extends ExifXmlDataTestCase { private static final String TAG = "ExifParserTest"; - private HashMap<Short, String> mIfd0Value = new HashMap<Short, String>(); - private HashMap<Short, String> mIfd1Value = new HashMap<Short, String>(); - private HashMap<Short, String> mExifIfdValue = new HashMap<Short, String>(); - private HashMap<Short, String> mInteroperabilityIfdValue = new HashMap<Short, String>(); - - private InputStream mImageInputStream; - - public ExifParserTest(int imageResourceId, int xmlResourceId) { - super(imageResourceId, xmlResourceId); + public ExifParserTest(int imgRes, int xmlRes) { + super(imgRes, xmlRes); } - @Override - protected void setUp() throws Exception { - mImageInputStream = getInstrumentation() - .getContext().getResources().openRawResource(mImageResourceId); + public ExifParserTest(String imgPath, String xmlPath) { + super(imgPath, xmlPath); + } - XmlResourceParser parser = - getInstrumentation().getContext().getResources().getXml(mXmlResourceId); + private List<Map<Short, List<String>>> mGroundTruth; - ExifXmlReader.readXml(parser, mIfd0Value, mIfd1Value, mExifIfdValue - , mInteroperabilityIfdValue); - parser.close(); + @Override + public void setUp() throws Exception { + super.setUp(); + mGroundTruth = ExifXmlReader.readXml(getXmlParser()); } - public void testParse() throws IOException, ExifInvalidFormatException { - ExifParser parser = ExifParser.parse(mImageInputStream); - int event = parser.next(); - while (event != ExifParser.EVENT_END) { - switch (event) { - case ExifParser.EVENT_START_OF_IFD: - break; - case ExifParser.EVENT_NEW_TAG: - ExifTag tag = parser.getTag(); - if (!tag.hasValue()) { - parser.registerForTagValue(tag); - } else { + public void testParse() throws Exception { + try { + ExifParser parser = ExifParser.parse(getImageInputStream()); + int event = parser.next(); + while (event != ExifParser.EVENT_END) { + switch (event) { + case ExifParser.EVENT_START_OF_IFD: + break; + case ExifParser.EVENT_NEW_TAG: + ExifTag tag = parser.getTag(); + if (!tag.hasValue()) { + parser.registerForTagValue(tag); + } else { + checkTag(tag); + } + break; + case ExifParser.EVENT_VALUE_OF_REGISTERED_TAG: + tag = parser.getTag(); + if (tag.getDataType() == ExifTag.TYPE_UNDEFINED) { + byte[] buf = new byte[tag.getComponentCount()]; + parser.read(buf); + tag.setValue(buf); + } checkTag(tag); - } - break; - case ExifParser.EVENT_VALUE_OF_REGISTERED_TAG: - tag = parser.getTag(); - if (tag.getDataType() == ExifTag.TYPE_UNDEFINED) { - byte[] buf = new byte[tag.getComponentCount()]; - parser.read(buf); - tag.setValue(buf); - } - checkTag(tag); - break; + break; + } + event = parser.next(); } - event = parser.next(); + } catch (Exception e) { + throw new Exception(getImageTitle(), e); } } private void checkTag(ExifTag tag) { - HashMap<Short, String> truth = null; - switch (tag.getIfd()) { - case IfdId.TYPE_IFD_0: - truth = mIfd0Value; - break; - case IfdId.TYPE_IFD_1: - truth = mIfd1Value; - break; - case IfdId.TYPE_IFD_EXIF: - truth = mExifIfdValue; - break; - case IfdId.TYPE_IFD_INTEROPERABILITY: - truth = mInteroperabilityIfdValue; - break; - } + List<String> truth = mGroundTruth.get(tag.getIfd()).get(tag.getTagId()); - String truthString = truth.get(tag.getTagId()); - String dataString = tag.valueToString().trim(); - if (truthString == null) { - fail(String.format("Unknown Tag %02x", tag.getTagId())); + if (truth == null) { + fail(String.format("Unknown Tag %02x", tag.getTagId()) + ", " + getImageTitle()); } - assertEquals(String.format("Tag %02x", tag.getTagId()), truthString, dataString); + + // No value from exiftool. + if (truth.contains(null)) return; + + String dataString = Util.tagValueToString(tag).trim(); + assertTrue(String.format("Tag %02x", tag.getTagId()) + ", " + getImageTitle() + + ": " + dataString, + truth.contains(dataString)); } - private void parseOneIfd(int ifd, int options, HashMap<Short, String> expectedResult) - throws IOException, ExifInvalidFormatException { - int numOfTag = 0; - ExifParser parser = ExifParser.parse(mImageInputStream, options); - int event = parser.next(); - while(event != ExifParser.EVENT_END) { - switch (event) { - case ExifParser.EVENT_START_OF_IFD: - assertEquals(ifd, parser.getCurrentIfd()); - break; - case ExifParser.EVENT_NEW_TAG: - numOfTag++; - ExifTag tag = parser.getTag(); - if (tag.hasValue()) { + private void parseOneIfd(int ifd, int options) throws Exception { + try { + Map<Short, List<String>> expectedResult = mGroundTruth.get(ifd); + int numOfTag = 0; + ExifParser parser = ExifParser.parse(getImageInputStream(), options); + int event = parser.next(); + while(event != ExifParser.EVENT_END) { + switch (event) { + case ExifParser.EVENT_START_OF_IFD: + assertEquals(getImageTitle(), ifd, parser.getCurrentIfd()); + break; + case ExifParser.EVENT_NEW_TAG: + ExifTag tag = parser.getTag(); + numOfTag++; + if (tag.hasValue()) { + checkTag(tag); + } else { + parser.registerForTagValue(tag); + } + break; + case ExifParser.EVENT_VALUE_OF_REGISTERED_TAG: + tag = parser.getTag(); + if (tag.getDataType() == ExifTag.TYPE_UNDEFINED) { + byte[] buf = new byte[tag.getComponentCount()]; + parser.read(buf); + tag.setValue(buf); + } checkTag(tag); - } else { - parser.registerForTagValue(tag); - } - break; - case ExifParser.EVENT_VALUE_OF_REGISTERED_TAG: - tag = parser.getTag(); - if (tag.getDataType() == ExifTag.TYPE_UNDEFINED) { - byte[] buf = new byte[tag.getComponentCount()]; - parser.read(buf); - tag.setValue(buf); - } - checkTag(tag); - break; - case ExifParser.EVENT_COMPRESSED_IMAGE: - case ExifParser.EVENT_UNCOMPRESSED_STRIP: - fail("Invalid Event type: " + event); - break; + break; + case ExifParser.EVENT_COMPRESSED_IMAGE: + case ExifParser.EVENT_UNCOMPRESSED_STRIP: + fail("Invalid Event type: " + event + ", " + getImageTitle()); + break; + } + event = parser.next(); } - event = parser.next(); + assertEquals(getImageTitle(), ExifXmlReader.getTrueTagNumber(expectedResult), numOfTag); + } catch (Exception e) { + throw new Exception(getImageTitle(), e); } - assertEquals(expectedResult.size(), numOfTag); } - public void testOnlyExifIfd() throws IOException, ExifInvalidFormatException { - parseOneIfd(IfdId.TYPE_IFD_EXIF, ExifParser.OPTION_IFD_EXIF, mExifIfdValue); + public void testOnlyExifIfd() throws Exception { + parseOneIfd(IfdId.TYPE_IFD_EXIF, ExifParser.OPTION_IFD_EXIF); } - public void testOnlyIfd0() throws IOException, ExifInvalidFormatException { - parseOneIfd(IfdId.TYPE_IFD_0, ExifParser.OPTION_IFD_0, mIfd0Value); + public void testOnlyIfd0() throws Exception { + parseOneIfd(IfdId.TYPE_IFD_0, ExifParser.OPTION_IFD_0); } - public void testOnlyIfd1() throws IOException, ExifInvalidFormatException { - parseOneIfd(IfdId.TYPE_IFD_1, ExifParser.OPTION_IFD_1, mIfd1Value); + public void testOnlyIfd1() throws Exception { + parseOneIfd(IfdId.TYPE_IFD_1, ExifParser.OPTION_IFD_1); } - public void testOnlyInteroperabilityIfd() throws IOException, ExifInvalidFormatException { - parseOneIfd(IfdId.TYPE_IFD_INTEROPERABILITY, ExifParser.OPTION_IFD_INTEROPERABILITY - , mInteroperabilityIfdValue); + public void testOnlyInteroperabilityIfd() throws Exception { + parseOneIfd(IfdId.TYPE_IFD_INTEROPERABILITY, ExifParser.OPTION_IFD_INTEROPERABILITY); } - public void testOnlyReadSomeTag() throws IOException, ExifInvalidFormatException { - ExifParser parser = ExifParser.parse(mImageInputStream, ExifParser.OPTION_IFD_0); - int event = parser.next(); - boolean isTagFound = false; - while (event != ExifParser.EVENT_END) { - switch (event) { - case ExifParser.EVENT_START_OF_IFD: - assertEquals(IfdId.TYPE_IFD_0, parser.getCurrentIfd()); - break; - case ExifParser.EVENT_NEW_TAG: - ExifTag tag = parser.getTag(); - if (tag.getTagId() == ExifTag.TAG_MODEL) { - if (tag.hasValue()) { - isTagFound = true; - checkTag(tag); - } else { - parser.registerForTagValue(tag); + public void testOnlyReadSomeTag() throws Exception { + // Do not do this test if there is no model tag. + if (mGroundTruth.get(IfdId.TYPE_IFD_0).get(ExifTag.TAG_MODEL) == null) return; + + try { + ExifParser parser = ExifParser.parse(getImageInputStream(), ExifParser.OPTION_IFD_0); + int event = parser.next(); + boolean isTagFound = false; + while (event != ExifParser.EVENT_END) { + switch (event) { + case ExifParser.EVENT_START_OF_IFD: + assertEquals(getImageTitle(), IfdId.TYPE_IFD_0, parser.getCurrentIfd()); + break; + case ExifParser.EVENT_NEW_TAG: + ExifTag tag = parser.getTag(); + if (tag.getTagId() == ExifTag.TAG_MODEL) { + if (tag.hasValue()) { + isTagFound = true; + checkTag(tag); + } else { + parser.registerForTagValue(tag); + } + parser.skipRemainingTagsInCurrentIfd(); } - parser.skipRemainingTagsInCurrentIfd(); - } - break; - case ExifParser.EVENT_VALUE_OF_REGISTERED_TAG: - tag = parser.getTag(); - assertEquals(ExifTag.TAG_MODEL, tag.getTagId()); - checkTag(tag); - isTagFound = true; - break; + break; + case ExifParser.EVENT_VALUE_OF_REGISTERED_TAG: + tag = parser.getTag(); + assertEquals(getImageTitle(), ExifTag.TAG_MODEL, tag.getTagId()); + checkTag(tag); + isTagFound = true; + break; + } + event = parser.next(); } - event = parser.next(); + assertTrue(getImageTitle(), isTagFound); + } catch (Exception e) { + throw new Exception(getImageTitle(), e); } - assertTrue(isTagFound); } - public void testReadThumbnail() throws ExifInvalidFormatException, IOException { - ExifParser parser = ExifParser.parse(mImageInputStream, - ExifParser.OPTION_IFD_1 | ExifParser.OPTION_THUMBNAIL); - - int event = parser.next(); - Bitmap bmp = null; - boolean mIsContainCompressedImage = false; - while (event != ExifParser.EVENT_END) { - switch (event) { - case ExifParser.EVENT_NEW_TAG: - ExifTag tag = parser.getTag(); - if (tag.getTagId() == ExifTag.TAG_COMPRESSION) { - if (tag.getUnsignedShort(0) == ExifTag.Compression.JPEG) { - mIsContainCompressedImage = true; + public void testReadThumbnail() throws Exception { + try { + ExifParser parser = ExifParser.parse(getImageInputStream(), + ExifParser.OPTION_IFD_1 | ExifParser.OPTION_THUMBNAIL); + + int event = parser.next(); + Bitmap bmp = null; + boolean mIsContainCompressedImage = false; + while (event != ExifParser.EVENT_END) { + switch (event) { + case ExifParser.EVENT_NEW_TAG: + ExifTag tag = parser.getTag(); + if (tag.getTagId() == ExifTag.TAG_COMPRESSION) { + if (tag.getValueAt(0) == ExifTag.Compression.JPEG) { + mIsContainCompressedImage = true; + } } - } - break; - case ExifParser.EVENT_COMPRESSED_IMAGE: - int imageSize = parser.getCompressedImageSize(); - byte buf[] = new byte[imageSize]; - parser.read(buf); - bmp = BitmapFactory.decodeByteArray(buf, 0, imageSize); - break; + break; + case ExifParser.EVENT_COMPRESSED_IMAGE: + int imageSize = parser.getCompressedImageSize(); + byte buf[] = new byte[imageSize]; + parser.read(buf); + bmp = BitmapFactory.decodeByteArray(buf, 0, imageSize); + break; + } + event = parser.next(); } - event = parser.next(); - } - if (mIsContainCompressedImage) { - assertNotNull(bmp); + if (mIsContainCompressedImage) { + assertNotNull(getImageTitle(), bmp); + } + } catch (Exception e) { + throw new Exception(getImageTitle(), e); } } - - @Override - protected void tearDown() throws IOException { - mImageInputStream.close(); - mIfd0Value.clear(); - mIfd1Value.clear(); - mExifIfdValue.clear(); - } -}
\ No newline at end of file +} diff --git a/tests/src/com/android/gallery3d/exif/ExifReaderTest.java b/tests/src/com/android/gallery3d/exif/ExifReaderTest.java index 269120870..30f34c09a 100644 --- a/tests/src/com/android/gallery3d/exif/ExifReaderTest.java +++ b/tests/src/com/android/gallery3d/exif/ExifReaderTest.java @@ -16,119 +16,125 @@ package com.android.gallery3d.exif; -import android.content.res.XmlResourceParser; import android.graphics.BitmapFactory; -import java.io.IOException; -import java.io.InputStream; -import java.util.HashMap; +import java.util.List; +import java.util.Map; public class ExifReaderTest extends ExifXmlDataTestCase { private static final String TAG = "ExifReaderTest"; - private final HashMap<Short, String> mIfd0Value = new HashMap<Short, String>(); - private final HashMap<Short, String> mIfd1Value = new HashMap<Short, String>(); - private final HashMap<Short, String> mExifIfdValue = new HashMap<Short, String>(); - private final HashMap<Short, String> mInteroperabilityIfdValue = new HashMap<Short, String>(); - - private InputStream mImageInputStream; - - public ExifReaderTest(int imageResourceId, int xmlResourceId) { - super(imageResourceId, xmlResourceId); - } + private List<Map<Short, List<String>>> mGroundTruth; @Override public void setUp() throws Exception { - mImageInputStream = getInstrumentation() - .getContext().getResources().openRawResource(mImageResourceId); + super.setUp(); + mGroundTruth = ExifXmlReader.readXml(getXmlParser()); + } - XmlResourceParser parser = - getInstrumentation().getContext().getResources().getXml(mXmlResourceId); + public ExifReaderTest(int imgRes, int xmlRes) { + super(imgRes, xmlRes); + } - ExifXmlReader.readXml(parser, mIfd0Value, mIfd1Value, mExifIfdValue - , mInteroperabilityIfdValue); - parser.close(); + public ExifReaderTest(String imgPath, String xmlPath) { + super(imgPath, xmlPath); } - public void testRead() throws ExifInvalidFormatException, IOException { - ExifReader reader = new ExifReader(); - ExifData exifData = reader.read(mImageInputStream); - checkIfd(exifData.getIfdData(IfdId.TYPE_IFD_0), mIfd0Value); - checkIfd(exifData.getIfdData(IfdId.TYPE_IFD_1), mIfd1Value); - checkIfd(exifData.getIfdData(IfdId.TYPE_IFD_EXIF), mExifIfdValue); - checkIfd(exifData.getIfdData(IfdId.TYPE_IFD_INTEROPERABILITY), - mInteroperabilityIfdValue); - checkThumbnail(exifData); + public void testRead() throws Exception { + try { + ExifReader reader = new ExifReader(); + ExifData exifData = reader.read(getImageInputStream()); + for (int i = 0; i < IfdId.TYPE_IFD_COUNT; i++) { + checkIfd(exifData.getIfdData(i), mGroundTruth.get(i)); + } + checkThumbnail(exifData); + } catch (Exception e) { + throw new Exception(getImageTitle(), e); + } } 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; + IfdData ifd1 = exifData.getIfdData(IfdId.TYPE_IFD_1); - if (ifd1 != null) { - if (ifd1.getTag(ExifTag.TAG_COMPRESSION).getUnsignedShort(0) == - ExifTag.Compression.JPEG) { - assertTrue(exifData.hasCompressedThumbnail()); - byte[] thumbnail = exifData.getCompressedThumbnail(); - assertTrue(BitmapFactory.decodeByteArray(thumbnail, 0, thumbnail.length) != null); - } else { - // 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); - if (planarTag != null) { - planarType = planarTag.getUnsignedShort(0); - } + if (ifd1 == null) fail(getImageTitle() + ": failed to find IFD1"); + + String typeTagTruth = typeTagValue.get(0); + + int type = (int) ifd1.getTag(ExifTag.TAG_COMPRESSION).getValueAt(0); + + if (String.valueOf(ExifTag.Compression.JPEG).equals(typeTagTruth)) { + assertTrue(getImageTitle(), type == ExifTag.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); + // 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); + if (planarTag != null) { + planarType = (int) planarTag.getValueAt(0); + } - ExifTag heightTag = ifd1.getTag(ExifTag.TAG_IMAGE_LENGTH); - ExifTag rowPerStripTag = ifd1.getTag(ExifTag.TAG_ROWS_PER_STRIP); + if (!ifd1Truth.containsKey(ExifTag.TAG_IMAGE_LENGTH) || + !ifd1Truth.containsKey(ExifTag.TAG_ROWS_PER_STRIP)) return; - int imageLength = getUnsignedIntOrShort(heightTag); - int rowsPerStrip = getUnsignedIntOrShort(rowPerStripTag); - int stripCount = ifd1.getTag( - ExifTag.TAG_STRIP_OFFSETS).getComponentCount(); + ExifTag heightTag = ifd1.getTag(ExifTag.TAG_IMAGE_LENGTH); + ExifTag rowPerStripTag = ifd1.getTag(ExifTag.TAG_ROWS_PER_STRIP); - if (planarType == ExifTag.PlanarConfiguration.CHUNKY) { - assertTrue(stripCount == (imageLength + rowsPerStrip - 1) / rowsPerStrip); - } else { - ExifTag samplePerPixelTag = ifd1.getTag(ExifTag.TAG_SAMPLES_PER_PIXEL); - int samplePerPixel = samplePerPixelTag.getUnsignedShort(0); - assertTrue(stripCount == - (imageLength + rowsPerStrip - 1) / rowsPerStrip * samplePerPixel); - } + // Fail the test if required tags are missing + if (heightTag == null || rowPerStripTag == null) fail(getImageTitle()); - for (int i = 0; i < stripCount; i++) { - ExifTag byteCountTag = ifd1.getTag(ExifTag.TAG_STRIP_BYTE_COUNTS); - if (byteCountTag.getDataType() == ExifTag.TYPE_UNSIGNED_SHORT) { - assertEquals(byteCountTag.getUnsignedShort(i), exifData.getStrip(i).length); - } else { - assertEquals( - byteCountTag.getUnsignedLong(i), exifData.getStrip(i).length); - } - } + int imageLength = (int) heightTag.getValueAt(0); + int rowsPerStrip = (int) rowPerStripTag.getValueAt(0); + int stripCount = ifd1.getTag( + ExifTag.TAG_STRIP_OFFSETS).getComponentCount(); + + if (planarType == ExifTag.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); + int samplePerPixel = (int) samplePerPixelTag.getValueAt(0); + assertTrue(getImageTitle(), + stripCount == + (imageLength + rowsPerStrip - 1) / rowsPerStrip * samplePerPixel); } - } - } - private int getUnsignedIntOrShort(ExifTag tag) { - if (tag.getDataType() == ExifTag.TYPE_UNSIGNED_SHORT) { - return tag.getUnsignedShort(0); - } else { - return (int) tag.getUnsignedLong(0); + if (!ifd1Truth.containsKey(ExifTag.TAG_STRIP_BYTE_COUNTS)) return; + ExifTag byteCountTag = ifd1.getTag(ExifTag.TAG_STRIP_BYTE_COUNTS); + short byteCountDataType = byteCountTag.getDataType(); + for (int i = 0; i < stripCount; i++) { + if (byteCountDataType == ExifTag.TYPE_UNSIGNED_SHORT) { + assertEquals(getImageTitle(), + byteCountTag.getValueAt(i), exifData.getStrip(i).length); + } else { + assertEquals(getImageTitle(), + byteCountTag.getValueAt(i), exifData.getStrip(i).length); + } + } } } - private void checkIfd(IfdData ifd, HashMap<Short, String> ifdValue) { + private void checkIfd(IfdData ifd, Map<Short, List<String>> ifdValue) { if (ifd == null) { - assertEquals(0 ,ifdValue.size()); + assertEquals(getImageTitle(), 0 ,ifdValue.size()); return; } ExifTag[] tags = ifd.getAllTags(); for (ExifTag tag : tags) { - assertEquals(ifdValue.get(tag.getTagId()), tag.valueToString().trim()); + List<String> truth = ifdValue.get(tag.getTagId()); + assertNotNull(String.format("Tag %x, ", tag.getTagId()) + getImageTitle(), truth); + if (truth.contains(null)) continue; + assertTrue(String.format("Tag %x, ", tag.getTagId()) + getImageTitle(), + truth.contains(Util.tagValueToString(tag).trim())); } - assertEquals(ifdValue.size(), tags.length); - } - - @Override - public void tearDown() throws Exception { - mImageInputStream.close(); + assertEquals(getImageTitle(), ifdValue.size(), tags.length); } } diff --git a/tests/src/com/android/gallery3d/exif/ExifTestRunner.java b/tests/src/com/android/gallery3d/exif/ExifTestRunner.java index 57a7111ad..519e87107 100644 --- a/tests/src/com/android/gallery3d/exif/ExifTestRunner.java +++ b/tests/src/com/android/gallery3d/exif/ExifTestRunner.java @@ -16,6 +16,8 @@ package com.android.gallery3d.exif; +import android.content.Context; +import android.os.Environment; import android.test.InstrumentationTestRunner; import android.test.InstrumentationTestSuite; import android.util.Log; @@ -25,8 +27,11 @@ import com.android.gallery3d.tests.R; import junit.framework.TestCase; import junit.framework.TestSuite; +import java.io.File; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.List; public class ExifTestRunner extends InstrumentationTestRunner { private static final String TAG = "ExifTestRunner"; @@ -34,12 +39,17 @@ public class ExifTestRunner extends InstrumentationTestRunner { private static final int[] IMG_RESOURCE = { R.raw.galaxy_nexus }; + private static final int[] EXIF_DATA_RESOURCE = { R.xml.galaxy_nexus }; + private static List<String> mTestImgPath = new ArrayList<String>(); + private static List<String> mTestXmlPath = new ArrayList<String>(); + @Override public TestSuite getAllTests() { + getTestImagePath(); TestSuite suite = new InstrumentationTestSuite(this); suite.addTestSuite(ExifDataTest.class); suite.addTestSuite(ExifTagTest.class); @@ -49,6 +59,25 @@ public class ExifTestRunner extends InstrumentationTestRunner { return suite; } + private void getTestImagePath() { + Context context = getContext(); + File imgDir = context.getExternalFilesDir(Environment.DIRECTORY_PICTURES); + File xmlDir = new File(context.getExternalFilesDir(null).getPath(), "Xml"); + + if (imgDir != null && xmlDir != null) { + String[] imgs = imgDir.list(); + if (imgs == null) return; + for (String imgName: imgs) { + String xmlName = imgName.substring(0, imgName.lastIndexOf('.')) + ".xml"; + File xmlFile = new File(xmlDir, xmlName); + if (xmlFile.exists()) { + mTestImgPath.add(new File(imgDir, imgName).getAbsolutePath()); + mTestXmlPath.add(xmlFile.getAbsolutePath()); + } + } + } + } + private void addAllTestsFromExifTestCase(Class<? extends ExifXmlDataTestCase> testClass, TestSuite suite) { for (Method method : testClass.getDeclaredMethods()) { @@ -72,6 +101,25 @@ public class ExifTestRunner extends InstrumentationTestRunner { Log.e(TAG, "Failed to create test case", e); } } + for (int i = 0, n = mTestImgPath.size(); i < n; i++) { + TestCase test; + try { + test = testClass.getDeclaredConstructor(String.class, String.class). + newInstance(mTestImgPath.get(i), mTestXmlPath.get(i)); + test.setName(method.getName()); + suite.addTest(test); + } catch (IllegalArgumentException e) { + Log.e(TAG, "Failed to create test case", e); + } catch (InstantiationException e) { + Log.e(TAG, "Failed to create test case", e); + } catch (IllegalAccessException e) { + Log.e(TAG, "Failed to create test case", e); + } catch (InvocationTargetException e) { + Log.e(TAG, "Failed to create test case", e); + } catch (NoSuchMethodException e) { + Log.e(TAG, "Failed to create test case", e); + } + } } } } diff --git a/tests/src/com/android/gallery3d/exif/ExifXmlDataTestCase.java b/tests/src/com/android/gallery3d/exif/ExifXmlDataTestCase.java index 41b315181..811b0a6c3 100644 --- a/tests/src/com/android/gallery3d/exif/ExifXmlDataTestCase.java +++ b/tests/src/com/android/gallery3d/exif/ExifXmlDataTestCase.java @@ -17,14 +17,80 @@ package com.android.gallery3d.exif; +import android.content.res.Resources; import android.test.InstrumentationTestCase; +import android.util.Xml; + +import org.xmlpull.v1.XmlPullParser; + +import java.io.FileInputStream; +import java.io.InputStream; +import java.io.InputStreamReader; public class ExifXmlDataTestCase extends InstrumentationTestCase { - protected final int mImageResourceId; - protected final int mXmlResourceId; + + private static final String RES_ID_TITLE = "Resource ID: %x"; + + private InputStream mImageInputStream; + private InputStream mXmlInputStream; + private XmlPullParser mXmlParser; + private final String mImagePath; + private final String mXmlPath; + private final int mImageResourceId; + private final int mXmlResourceId; public ExifXmlDataTestCase(int imageRes, int xmlRes) { + mImagePath = null; + mXmlPath = null; mImageResourceId = imageRes; mXmlResourceId = xmlRes; } + + public ExifXmlDataTestCase(String imagePath, String xmlPath) { + mImagePath = imagePath; + mXmlPath = xmlPath; + mImageResourceId = 0; + mXmlResourceId = 0; + } + + protected InputStream getImageInputStream() { + return mImageInputStream; + } + + protected XmlPullParser getXmlParser() { + return mXmlParser; + } + + @Override + public void setUp() throws Exception { + try { + if (mImagePath != null) { + mImageInputStream = new FileInputStream(mImagePath); + mXmlInputStream = new FileInputStream(mXmlPath); + mXmlParser = Xml.newPullParser(); + mXmlParser.setInput(new InputStreamReader(mXmlInputStream)); + } else { + Resources res = getInstrumentation().getContext().getResources(); + mImageInputStream = res.openRawResource(mImageResourceId); + mXmlParser = res.getXml(mXmlResourceId); + } + } catch (Exception e) { + throw new Exception(getImageTitle(), e); + } + } + + @Override + public void tearDown() throws Exception { + Util.closeSilently(mImageInputStream); + Util.closeSilently(mXmlInputStream); + mXmlParser = null; + } + + protected String getImageTitle() { + if (mImagePath != null) { + return mImagePath; + } else { + return String.format(RES_ID_TITLE, mImageResourceId); + } + } } diff --git a/tests/src/com/android/gallery3d/exif/ExifXmlReader.java b/tests/src/com/android/gallery3d/exif/ExifXmlReader.java index 72dd31373..bb08ccd1c 100644 --- a/tests/src/com/android/gallery3d/exif/ExifXmlReader.java +++ b/tests/src/com/android/gallery3d/exif/ExifXmlReader.java @@ -20,78 +20,106 @@ import org.xmlpull.v1.XmlPullParser; import org.xmlpull.v1.XmlPullParserException; import java.io.IOException; +import java.util.ArrayList; import java.util.HashMap; +import java.util.List; +import java.util.Map; public class ExifXmlReader { + private static final String TAG_EXIF = "exif"; + private static final String TAG_TAG = "tag"; - private static final String XML_EXIF_TAG = "exif"; - private static final String XML_IFD_TAG = "ifd"; - private static final String XML_IFD_NAME = "name"; - private static final String XML_TAG = "tag"; - private static final String XML_IFD0 = "ifd0"; - private static final String XML_IFD1 = "ifd1"; - private static final String XML_EXIF_IFD = "exif-ifd"; - private static final String XML_INTEROPERABILITY_IFD = "interoperability-ifd"; - private static final String XML_TAG_ID = "id"; - - public static void readXml(XmlPullParser parser, HashMap<Short, String> ifd0, - HashMap<Short, String> ifd1, HashMap<Short, String> exifIfd, - HashMap<Short, String> interoperabilityIfd) throws XmlPullParserException, - IOException { + private static final String IFD0 = "IFD0"; + private static final String EXIF_IFD = "ExifIFD"; + private static final String GPS_IFD = "GPS"; + private static final String IFD1 = "IFD1"; + private static final String INTEROP_IFD = "InteropIFD"; + + private static final String ATTR_ID = "id"; + private static final String ATTR_IFD = "ifd"; + + private static final String NO_VALUE = "NO_VALUE"; + + /** + * This function read the ground truth XML. + * + * @throws XmlPullParserException + * @throws IOException + */ + static public List<Map<Short, List<String>>> readXml(XmlPullParser parser) + throws XmlPullParserException, IOException { + + List<Map<Short, List<String>>> exifData = + new ArrayList<Map<Short, List<String>>>(IfdId.TYPE_IFD_COUNT); + for (int i = 0; i < IfdId.TYPE_IFD_COUNT; i++) { + exifData.add(new HashMap<Short, List<String>>()); + } while (parser.next() != XmlPullParser.END_DOCUMENT) { if (parser.getEventType() == XmlPullParser.START_TAG) { break; } } + parser.require(XmlPullParser.START_TAG, null, TAG_EXIF); - assert(parser.getName().equals(XML_EXIF_TAG)); - - parser.require(XmlPullParser.START_TAG, null, XML_EXIF_TAG); while (parser.next() != XmlPullParser.END_TAG) { - if (parser.getEventType() == XmlPullParser.START_TAG) { - readXmlIfd(parser, ifd0, ifd1, exifIfd, interoperabilityIfd); + if (parser.getEventType() != XmlPullParser.START_TAG) { + continue; + } + + parser.require(XmlPullParser.START_TAG, null, TAG_TAG); + + int ifdId = getIfdIdFromString(parser.getAttributeValue(null, ATTR_IFD)); + short id = Integer.decode(parser.getAttributeValue(null, ATTR_ID)).shortValue(); + + String value = ""; + if (parser.next() == XmlPullParser.TEXT) { + value = parser.getText(); + parser.next(); } + + if (ifdId < 0) { + // TODO: the MarkerNote segment. + } else { + List<String> tagData = exifData.get(ifdId).get(id); + if (tagData == null) { + tagData = new ArrayList<String>(); + exifData.get(ifdId).put(id, tagData); + } + if (NO_VALUE.equals(value)) { + tagData.add(null); + } else { + tagData.add(value.trim()); + } + } + + parser.require(XmlPullParser.END_TAG, null, null); } - parser.require(XmlPullParser.END_TAG, null, XML_EXIF_TAG); + return exifData; } - private static void readXmlIfd(XmlPullParser parser, HashMap<Short, String> ifd0, - HashMap<Short, String> ifd1, HashMap<Short, String> exifIfd, - HashMap<Short, String> interoperabilityIfd) throws XmlPullParserException, - IOException { - parser.require(XmlPullParser.START_TAG, null, XML_IFD_TAG); - String name = parser.getAttributeValue(null, XML_IFD_NAME); - HashMap<Short, String> ifdData = null; - if (XML_IFD0.equals(name)) { - ifdData = ifd0; - } else if (XML_IFD1.equals(name)) { - ifdData = ifd1; - } else if (XML_EXIF_IFD.equals(name)) { - ifdData = exifIfd; - } else if (XML_INTEROPERABILITY_IFD.equals(name)) { - ifdData = interoperabilityIfd; + static private int getIfdIdFromString(String prefix) { + if (IFD0.equals(prefix)) { + return IfdId.TYPE_IFD_0; + } else if (EXIF_IFD.equals(prefix)) { + return IfdId.TYPE_IFD_EXIF; + } else if (GPS_IFD.equals(prefix)) { + return IfdId.TYPE_IFD_GPS; + } else if (IFD1.equals(prefix)) { + return IfdId.TYPE_IFD_1; + } else if (INTEROP_IFD.equals(prefix)) { + return IfdId.TYPE_IFD_INTEROPERABILITY; } else { - throw new RuntimeException("Unknown IFD name in xml file: " + name); - } - while (parser.next() != XmlPullParser.END_TAG) { - if (parser.getEventType() == XmlPullParser.START_TAG) { - readXmlTag(parser, ifdData); - } + assert(false); + return -1; } - parser.require(XmlPullParser.END_TAG, null, XML_IFD_TAG); } - private static void readXmlTag(XmlPullParser parser, HashMap<Short, String> data) - throws XmlPullParserException, IOException { - parser.require(XmlPullParser.START_TAG, null, XML_TAG); - short id = Integer.decode(parser.getAttributeValue(null, XML_TAG_ID)).shortValue(); - String value = ""; - if (parser.next() == XmlPullParser.TEXT) { - value = parser.getText(); - parser.next(); + static public int getTrueTagNumber(Map<Short, List<String>> ifdData) { + int size = 0; + for (List<String> tag: ifdData.values()) { + size += tag.size(); } - data.put(id, value); - parser.require(XmlPullParser.END_TAG, null, XML_TAG); + return size; } -}
\ No newline at end of file +} diff --git a/tests/src/com/android/gallery3d/exif/Util.java b/tests/src/com/android/gallery3d/exif/Util.java new file mode 100644 index 000000000..0e51fd7bf --- /dev/null +++ b/tests/src/com/android/gallery3d/exif/Util.java @@ -0,0 +1,145 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * 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. + */ + +package com.android.gallery3d.exif; + +import java.io.Closeable; + +class Util { + public static boolean equals(Object a, Object b) { + return (a == b) || (a == null ? false : a.equals(b)); + } + + public static void closeSilently(Closeable c) { + if (c == null) return; + try { + c.close(); + } catch (Throwable t) { + // do nothing + } + } + + /** + * Tags that are not defined in the spec. + */ + static final short TAG_XP_TITLE = (short) 0x9c9b; + static final short TAG_XP_COMMENT = (short) 0x9c9c; + static final short TAG_XP_AUTHOR = (short) 0x9c9d; + static final short TAG_XP_KEYWORDS = (short) 0x9c9e; + static final short TAG_XP_SUBJECT = (short) 0x9c9f; + + private static String tagUndefinedTypeValueToString(ExifTag tag) { + StringBuilder sbuilder = new StringBuilder(); + byte[] buf = new byte[tag.getComponentCount()]; + tag.getBytes(buf); + switch (tag.getTagId()) { + case ExifTag.TAG_COMPONENTS_CONFIGURATION: + for(int i = 0, n = tag.getComponentCount(); i < n; i++) { + if(i != 0) sbuilder.append(" "); + sbuilder.append(buf[i]); + } + break; + default: + if (buf.length == 1) { + sbuilder.append(buf[0]); + } else { + for (int i = 0, n = buf.length; i < n; i++) { + byte code = buf[i]; + if (code == 0) continue; + if (code > 31 && code < 127) { + sbuilder.append((char) code); + } else { + sbuilder.append('.'); + } + } + } + } + return sbuilder.toString(); + } + + /** + * Returns a string representation of the value of this tag. + */ + public static String tagValueToString(ExifTag tag) { + StringBuilder sbuilder = new StringBuilder(); + short id = tag.getTagId(); + switch (tag.getDataType()) { + case ExifTag.TYPE_UNDEFINED: + sbuilder.append(tagUndefinedTypeValueToString(tag)); + break; + case ExifTag.TYPE_UNSIGNED_BYTE: + if (id == ExifTag.TAG_MAKER_NOTE || id == TAG_XP_TITLE || + id == TAG_XP_COMMENT || id == TAG_XP_AUTHOR || + id == TAG_XP_KEYWORDS || id == TAG_XP_SUBJECT) { + sbuilder.append(tagUndefinedTypeValueToString(tag)); + } else { + byte[] buf = new byte[tag.getComponentCount()]; + tag.getBytes(buf); + for(int i = 0, n = tag.getComponentCount(); i < n; i++) { + if(i != 0) sbuilder.append(" "); + sbuilder.append(buf[i]); + } + } + break; + case ExifTag.TYPE_ASCII: + byte[] buf = tag.getStringByte(); + for (int i = 0, n = buf.length; i < n; i++) { + byte code = buf[i]; + if (code == 0) { + // Treat some tag as undefined type data. + if (id == ExifTag.TAG_COPYRIGHT || id == ExifTag.TAG_GPS_DATE_STAMP) { + continue; + } else { + break; + } + } + if (code > 31 && code < 127) { + sbuilder.append((char) code); + } else { + sbuilder.append('.'); + } + } + break; + case ExifTag.TYPE_UNSIGNED_LONG: + for(int i = 0, n = tag.getComponentCount(); i < n; i++) { + if(i != 0) sbuilder.append(" "); + sbuilder.append(tag.getValueAt(i)); + } + break; + case ExifTag.TYPE_RATIONAL: + case ExifTag.TYPE_UNSIGNED_RATIONAL: + for(int i = 0, n = tag.getComponentCount(); i < n; i++) { + Rational r = tag.getRational(i); + if(i != 0) sbuilder.append(" "); + sbuilder.append(r.getNominator()).append("/").append(r.getDenominator()); + } + break; + case ExifTag.TYPE_UNSIGNED_SHORT: + for(int i = 0, n = tag.getComponentCount(); i < n; i++) { + if(i != 0) sbuilder.append(" "); + sbuilder.append((int) tag.getValueAt(i)); + } + break; + case ExifTag.TYPE_LONG: + for(int i = 0, n = tag.getComponentCount(); i < n; i++) { + if(i != 0) sbuilder.append(" "); + sbuilder.append((int) tag.getValueAt(i)); + } + break; + } + return sbuilder.toString(); + } +} diff --git a/tests/src/com/android/gallery3d/ui/GLCanvasStub.java b/tests/src/com/android/gallery3d/ui/GLCanvasStub.java index 5a08b8599..e9932239b 100644 --- a/tests/src/com/android/gallery3d/ui/GLCanvasStub.java +++ b/tests/src/com/android/gallery3d/ui/GLCanvasStub.java @@ -16,52 +16,77 @@ package com.android.gallery3d.ui; +import android.graphics.Bitmap; import android.graphics.RectF; +import java.nio.ByteBuffer; +import java.nio.FloatBuffer; + import javax.microedition.khronos.opengles.GL11; -public class GLCanvasStub implements GLCanvas { +public class GLCanvasStub extends GLCanvas { + @Override public void setSize(int width, int height) {} + @Override public void clearBuffer() {} + @Override public void clearBuffer(float[] argb) {} public void setCurrentAnimationTimeMillis(long time) {} public long currentAnimationTimeMillis() { throw new UnsupportedOperationException(); } + @Override public void setAlpha(float alpha) {} + @Override public float getAlpha() { throw new UnsupportedOperationException(); } + @Override public void multiplyAlpha(float alpha) {} + @Override public void translate(float x, float y, float z) {} + @Override public void translate(float x, float y) {} + @Override public void scale(float sx, float sy, float sz) {} + @Override public void rotate(float angle, float x, float y, float z) {} public boolean clipRect(int left, int top, int right, int bottom) { throw new UnsupportedOperationException(); } + @Override public void save() { throw new UnsupportedOperationException(); } + @Override public void save(int saveFlags) { throw new UnsupportedOperationException(); } public void setBlendEnabled(boolean enabled) {} + @Override public void restore() {} + @Override public void drawLine(float x1, float y1, float x2, float y2, GLPaint paint) {} + @Override public void drawRect(float x1, float y1, float x2, float y2, GLPaint paint) {} + @Override public void fillRect(float x, float y, float width, float height, int color) {} + @Override public void drawTexture( BasicTexture texture, int x, int y, int width, int height) {} + @Override public void drawMesh(BasicTexture tex, int x, int y, int xyBuffer, int uvBuffer, int indexBuffer, int indexCount) {} public void drawTexture(BasicTexture texture, int x, int y, int width, int height, float alpha) {} + @Override public void drawTexture(BasicTexture texture, RectF source, RectF target) {} + @Override public void drawTexture(BasicTexture texture, float[] mTextureTransform, int x, int y, int w, int h) {} public void drawMixed(BasicTexture from, BasicTexture to, float ratio, int x, int y, int w, int h) {} + @Override public void drawMixed(BasicTexture from, int to, float ratio, int x, int y, int w, int h) {} public void drawMixed(BasicTexture from, BasicTexture to, @@ -72,17 +97,68 @@ public class GLCanvasStub implements GLCanvas { public GL11 getGLInstance() { throw new UnsupportedOperationException(); } + @Override public boolean unloadTexture(BasicTexture texture) { throw new UnsupportedOperationException(); } + @Override public void deleteBuffer(int bufferId) { throw new UnsupportedOperationException(); } + @Override public void deleteRecycledResources() {} + @Override public void multiplyMatrix(float[] mMatrix, int offset) {} + @Override public void dumpStatisticsAndClear() {} + @Override public void beginRenderTarget(RawTexture texture) {} + @Override public void endRenderTarget() {} + @Override public void drawMixed(BasicTexture from, int toColor, float ratio, RectF src, RectF target) {} + + @Override + public void setTextureParameters(BasicTexture texture) { + } + @Override + public void initializeTextureSize(BasicTexture texture, int format, int type) { + } + @Override + public void initializeTexture(BasicTexture texture, Bitmap bitmap) { + } + @Override + public void texSubImage2D(BasicTexture texture, int xOffset, int yOffset, Bitmap bitmap, + int format, int type) { + } + @Override + public int uploadBuffer(ByteBuffer buffer) { + return 0; + } + @Override + public int uploadBuffer(FloatBuffer buffer) { + return 0; + } + @Override + public void setBlending(Blending blending) { + } + @Override + public void enableStencil() { + } + @Override + public void disableStencil() { + } + @Override + public void clearStencilBuffer() { + } + @Override + public void updateStencil(boolean update) { + } + @Override + public void drawOnlyOutsideStencil(boolean onlyOutside) { + } + @Override + public void initialize(GL11 gl) { + } } diff --git a/tests/src/com/android/gallery3d/ui/GLCanvasTest.java b/tests/src/com/android/gallery3d/ui/GLCanvasTest.java index 72ccbfb96..ddbddad17 100644 --- a/tests/src/com/android/gallery3d/ui/GLCanvasTest.java +++ b/tests/src/com/android/gallery3d/ui/GLCanvasTest.java @@ -39,7 +39,8 @@ public class GLCanvasTest extends TestCase { @SmallTest public void testSetSize() { GL11 glStub = new GLStub(); - GLCanvas canvas = new GLCanvasImpl(glStub); + GLCanvas canvas = new GLCanvasImpl(); + canvas.initialize(glStub); canvas.setSize(100, 200); canvas.setSize(1000, 100); try { @@ -57,7 +58,8 @@ public class GLCanvasTest extends TestCase { private static class ClearBufferTest extends GLMock { void run() { - GLCanvas canvas = new GLCanvasImpl(this); + GLCanvas canvas = new GLCanvasImpl(); + canvas.initialize(this); assertEquals(0, mGLClearCalled); canvas.clearBuffer(); assertEquals(GL10.GL_COLOR_BUFFER_BIT, mGLClearMask); @@ -79,7 +81,8 @@ public class GLCanvasTest extends TestCase { 0x7F010101, 0xFEFEFDFC, 0x017F8081, 0x027F8081, 0x2ADE4C4D }; - GLCanvas canvas = new GLCanvasImpl(this); + GLCanvas canvas = new GLCanvasImpl(); + canvas.initialize(this); canvas.setSize(400, 300); // Test one color to make sure blend function is set. assertEquals(0, mGLColorCalled); @@ -107,7 +110,8 @@ public class GLCanvasTest extends TestCase { @SmallTest public void testSetGetMultiplyAlpha() { GL11 glStub = new GLStub(); - GLCanvas canvas = new GLCanvasImpl(glStub); + GLCanvas canvas = new GLCanvasImpl(); + canvas.initialize(glStub); canvas.setAlpha(1f); assertEquals(1f, canvas.getAlpha()); @@ -146,7 +150,8 @@ public class GLCanvasTest extends TestCase { private static class AlphaTest extends GLMock { void run() { - GLCanvas canvas = new GLCanvasImpl(this); + GLCanvas canvas = new GLCanvasImpl(); + canvas.initialize(this); canvas.setSize(400, 300); assertEquals(0, mGLColorCalled); @@ -188,7 +193,8 @@ public class GLCanvasTest extends TestCase { } void run() { - GLCanvas canvas = new GLCanvasImpl(this); + GLCanvas canvas = new GLCanvasImpl(); + canvas.initialize(this); canvas.setSize(400, 300); canvas.drawLine(2, 7, 1, 8, newColorPaint(0) /* color */); assertTrue(mGLVertexArrayEnabled); @@ -232,7 +238,8 @@ public class GLCanvasTest extends TestCase { } void run() { - GLCanvas canvas = new GLCanvasImpl(this); + GLCanvas canvas = new GLCanvasImpl(); + canvas.initialize(this); canvas.setSize(400, 300); canvas.fillRect(2, 7, 1, 8, 0 /* color */); assertTrue(mGLVertexArrayEnabled); @@ -294,7 +301,8 @@ public class GLCanvasTest extends TestCase { } void run() { - GLCanvas canvas = new GLCanvasImpl(this); + GLCanvas canvas = new GLCanvasImpl(); + canvas.initialize(this); canvas.setSize(40, 50); int color = 0; @@ -359,13 +367,6 @@ public class GLCanvasTest extends TestCase { } } - @SmallTest - public void testGetGLInstance() { - GL11 glStub = new GLStub(); - GLCanvas canvas = new GLCanvasImpl(glStub); - assertSame(glStub, canvas.getGLInstance()); - } - private static void assertPremultipliedBlending(GLMock mock) { assertTrue(mock.mGLBlendFuncCalled > 0); assertTrue(mock.mGLBlendEnabled); diff --git a/tests/src/com/android/gallery3d/ui/TextureTest.java b/tests/src/com/android/gallery3d/ui/TextureTest.java index 36446b389..361bf7b84 100644 --- a/tests/src/com/android/gallery3d/ui/TextureTest.java +++ b/tests/src/com/android/gallery3d/ui/TextureTest.java @@ -48,6 +48,7 @@ public class TextureTest extends TestCase { return GL11.GL_TEXTURE_2D; } + @Override public boolean isOpaque() { mOpaqueCalled++; return true; @@ -61,7 +62,8 @@ public class TextureTest extends TestCase { @SmallTest public void testBasicTexture() { GL11 glStub = new GLStub(); - GLCanvas canvas = new GLCanvasImpl(glStub); + GLCanvas canvas = new GLCanvasImpl(); + canvas.initialize(glStub); MyBasicTexture texture = new MyBasicTexture(canvas, 47); assertEquals(47, texture.getId()); @@ -81,7 +83,8 @@ public class TextureTest extends TestCase { assertTrue(texture.isLoaded()); // For a different GL, it's not loaded. - GLCanvas canvas2 = new GLCanvasImpl(new GLStub()); + GLCanvas canvas2 = new GLCanvasImpl(); + canvas2.initialize(glStub); assertFalse(texture.isLoaded()); assertEquals(0, texture.mOnBindCalled); @@ -135,7 +138,8 @@ public class TextureTest extends TestCase { @SmallTest public void testUploadedTexture() { GL11 glStub = new GLStub(); - GLCanvas canvas = new GLCanvasImpl(glStub); + GLCanvas canvas = new GLCanvasImpl(); + canvas.initialize(glStub); MyUploadedTexture texture = new MyUploadedTexture(); // draw it and the bitmap should be fetched. @@ -181,6 +185,7 @@ public class TextureTest extends TestCase { return GL11.GL_TEXTURE_2D; } + @Override public boolean isOpaque() { return true; } |