diff options
Diffstat (limited to 'tests/src/com/android/gallery3d/exif/ExifTagTest.java')
| -rw-r--r-- | tests/src/com/android/gallery3d/exif/ExifTagTest.java | 219 |
1 files changed, 219 insertions, 0 deletions
diff --git a/tests/src/com/android/gallery3d/exif/ExifTagTest.java b/tests/src/com/android/gallery3d/exif/ExifTagTest.java new file mode 100644 index 000000000..e6a41ecfa --- /dev/null +++ b/tests/src/com/android/gallery3d/exif/ExifTagTest.java @@ -0,0 +1,219 @@ +/* + * 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 android.test.suitebuilder.annotation.SmallTest; + +import junit.framework.TestCase; + +import java.util.HashMap; +import java.util.Map; + +public class ExifTagTest extends TestCase { + + private static long MAX_UNSIGNED_LONG = (1L << 32) - 1; + private static int MAX_LONG = Integer.MAX_VALUE; + private static int MIN_LONG = Integer.MIN_VALUE; + + Map<Integer, ExifTag> mTestTags; + ExifInterface mInterface; + private ExifTag mVersionTag; + private ExifTag mGpsVersionTag; + private ExifTag mModelTag; + private ExifTag mDateTimeTag; + private ExifTag mCompressionTag; + private ExifTag mThumbnailFormatTag; + private ExifTag mLongitudeTag; + private ExifTag mShutterTag; + private ExifTag mInteropIndex; + + @Override + public void setUp() throws Exception { + super.setUp(); + mInterface = new ExifInterface(); + + // TYPE_UNDEFINED with 4 components + mVersionTag = mInterface.buildTag(ExifInterface.TAG_EXIF_VERSION, new byte[] { + 5, 4, 3, 2 + }); + // TYPE_UNSIGNED_BYTE with 4 components + mGpsVersionTag = mInterface.buildTag(ExifInterface.TAG_GPS_VERSION_ID, new byte[] { + 6, 7, 8, 9 + }); + // TYPE ASCII with arbitrary length + mModelTag = mInterface.buildTag(ExifInterface.TAG_MODEL, "helloworld"); + // TYPE_ASCII with 20 components + mDateTimeTag = mInterface.buildTag(ExifInterface.TAG_DATE_TIME, "2013:02:11 20:20:20"); + // TYPE_UNSIGNED_SHORT with 1 components + mCompressionTag = mInterface.buildTag(ExifInterface.TAG_COMPRESSION, 100); + // TYPE_UNSIGNED_LONG with 1 components + mThumbnailFormatTag = + mInterface.buildTag(ExifInterface.TAG_JPEG_INTERCHANGE_FORMAT, 100); + // TYPE_UNSIGNED_RATIONAL with 3 components + mLongitudeTag = mInterface.buildTag(ExifInterface.TAG_GPS_LONGITUDE, new Rational[] { + new Rational(2, 2), new Rational(11, 11), + new Rational(102, 102) + }); + // TYPE_RATIONAL with 1 components + mShutterTag = mInterface + .buildTag(ExifInterface.TAG_SHUTTER_SPEED_VALUE, new Rational(4, 6)); + // TYPE_ASCII with arbitrary length + mInteropIndex = mInterface.buildTag(ExifInterface.TAG_INTEROPERABILITY_INDEX, "foo"); + + mTestTags = new HashMap<Integer, ExifTag>(); + + mTestTags.put(ExifInterface.TAG_EXIF_VERSION, mVersionTag); + mTestTags.put(ExifInterface.TAG_GPS_VERSION_ID, mGpsVersionTag); + mTestTags.put(ExifInterface.TAG_MODEL, mModelTag); + mTestTags.put(ExifInterface.TAG_DATE_TIME, mDateTimeTag); + mTestTags.put(ExifInterface.TAG_COMPRESSION, mCompressionTag); + mTestTags.put(ExifInterface.TAG_JPEG_INTERCHANGE_FORMAT, mThumbnailFormatTag); + mTestTags.put(ExifInterface.TAG_GPS_LONGITUDE, mLongitudeTag); + mTestTags.put(ExifInterface.TAG_SHUTTER_SPEED_VALUE, mShutterTag); + mTestTags.put(ExifInterface.TAG_INTEROPERABILITY_INDEX, mInteropIndex); + } + + @Override + public void tearDown() throws Exception { + super.tearDown(); + mInterface = null; + mTestTags = null; + } + + @SmallTest + public void testValueType() { + for (ExifTag tag : mTestTags.values()) { + assertTrue(tag != null); + int count = tag.getComponentCount(); + int intBuf[] = new int[count]; + long longBuf[] = new long[count]; + byte byteBuf[] = new byte[count]; + Rational rationalBuf[] = new Rational[count]; + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < count; i++) { + intBuf[i] = 0; + longBuf[i] = 0; + byteBuf[i] = 0; + rationalBuf[i] = new Rational(0, 0); + // The string size should equal to component count - 1 + if (i != count - 1) { + sb.append("*"); + } else { + sb.append("\0"); + } + } + String strBuf = sb.toString(); + + checkTypeByte(tag, byteBuf); + checkTypeAscii(tag, strBuf); + checkTypeUnsignedShort(tag, intBuf); + checkTypeUnsignedLong(tag, intBuf, longBuf); + checkTypeLong(tag, intBuf); + checkTypeRational(tag, rationalBuf); + checkTypeUnsignedRational(tag, rationalBuf); + } + } + + private void checkTypeByte(ExifTag tag, byte[] buf) { + short type = tag.getDataType(); + assertFalse("\nTag: " + tag.toString(), tag.setValue(buf) + ^ (type == ExifTag.TYPE_UNDEFINED || type == ExifTag.TYPE_UNSIGNED_BYTE)); + } + + private void checkTypeAscii(ExifTag tag, String str) { + short type = tag.getDataType(); + assertFalse("\nTag: " + tag.toString(), tag.setValue(str) + ^ (type == ExifTag.TYPE_ASCII || type == ExifTag.TYPE_UNDEFINED)); + } + + private void checkTypeUnsignedShort(ExifTag tag, int[] intBuf) { + short type = tag.getDataType(); + assertFalse("\nTag: " + tag.toString(), + tag.setValue(intBuf) + ^ (type == ExifTag.TYPE_UNSIGNED_SHORT + || type == ExifTag.TYPE_UNSIGNED_LONG + || type == ExifTag.TYPE_LONG)); + } + + private void checkTypeUnsignedLong(ExifTag tag, int[] intBuf, long[] longBuf) { + + // Test value only for unsigned long. + int count = intBuf.length; + intBuf[count - 1] = MAX_LONG; + tag.setValue(intBuf); + longBuf[count - 1] = MAX_UNSIGNED_LONG; + + assertFalse("\nTag: " + tag.toString(), tag.setValue(longBuf) + ^ (tag.getDataType() == ExifTag.TYPE_UNSIGNED_LONG)); + + intBuf[count - 1] = 0; + // Test invalid value for all type. + longBuf[count - 1] = MAX_UNSIGNED_LONG + 1; + assertFalse(tag.setValue(longBuf)); + longBuf[count - 1] = 0; + } + + private void checkTypeLong(ExifTag tag, int[] intBuf) { + int count = intBuf.length; + intBuf[count - 1] = MAX_LONG; + tag.setValue(intBuf); + intBuf[count - 1] = MIN_LONG; + + assertFalse("\nTag: " + tag.toString(), tag.setValue(intBuf) + ^ (tag.getDataType() == ExifTag.TYPE_LONG)); + intBuf[count - 1] = 0; + } + + private void checkTypeRational(ExifTag tag, Rational rationalBuf[]) { + int count = rationalBuf.length; + Rational r = rationalBuf[count - 1]; + rationalBuf[count - 1] = new Rational(MAX_LONG, MIN_LONG); + + assertFalse("\nTag: " + tag.toString(), tag.setValue(rationalBuf) + ^ (tag.getDataType() == ExifTag.TYPE_RATIONAL)); + + if (tag.getDataType() == ExifTag.TYPE_RATIONAL) { + // check overflow + + rationalBuf[count - 1] = new Rational(MAX_LONG + 1L, MIN_LONG); + assertFalse(tag.setValue(rationalBuf)); + + rationalBuf[count - 1] = new Rational(MAX_LONG, MIN_LONG - 1L); + assertFalse(tag.setValue(rationalBuf)); + } + rationalBuf[count - 1] = r; + } + + private void checkTypeUnsignedRational(ExifTag tag, Rational rationalBuf[]) { + int count = rationalBuf.length; + Rational r = rationalBuf[count - 1]; + rationalBuf[count - 1] = new Rational(MAX_UNSIGNED_LONG, MAX_UNSIGNED_LONG); + + assertFalse("\nTag: " + tag.toString(), tag.setValue(rationalBuf) + ^ (tag.getDataType() == ExifTag.TYPE_UNSIGNED_RATIONAL)); + + if (tag.getDataType() == ExifTag.TYPE_UNSIGNED_RATIONAL) { + // check overflow + rationalBuf[count - 1] = new Rational(MAX_UNSIGNED_LONG + 1, 0); + assertFalse(tag.setValue(rationalBuf)); + + rationalBuf[count - 1] = new Rational(MAX_UNSIGNED_LONG, -1); + assertFalse(tag.setValue(rationalBuf)); + } + rationalBuf[count - 1] = r; + } +} |