| /* |
| * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /** |
| * @test |
| * @bug 8152183 8149562 8169725 8169728 |
| * @author a.stepanov |
| * @summary Some checks for TIFFField methods |
| * @run main TIFFFieldTest |
| */ |
| |
| import java.util.List; |
| import java.util.ArrayList; |
| import javax.imageio.metadata.IIOMetadataNode; |
| import javax.imageio.plugins.tiff.*; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| |
| public class TIFFFieldTest { |
| |
| private final static String NAME = "tag"; // tag name |
| private final static int NUM = 12345; // tag number |
| private final static int MIN_TYPE = TIFFTag.MIN_DATATYPE; |
| private final static int MAX_TYPE = TIFFTag.MAX_DATATYPE; |
| private final static String CONSTRUCT = "can construct TIFFField with "; |
| |
| private void check(boolean ok, String msg) { |
| if (!ok) { throw new RuntimeException(msg); } |
| } |
| |
| private void testConstructors() { |
| |
| // test constructors |
| |
| TIFFTag tag = new TIFFTag( |
| NAME, NUM, 1 << TIFFTag.TIFF_SHORT | 1 << TIFFTag.TIFF_LONG); |
| TIFFField f; |
| |
| // constructor: TIFFField(tag, value) |
| boolean ok = false; |
| try { new TIFFField(null, 0); } |
| catch (NullPointerException e) { ok = true; } |
| check(ok, CONSTRUCT + "null tag"); |
| |
| ok = false; |
| try { new TIFFField(tag, -1); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, CONSTRUCT + "negative value"); |
| |
| ok = false; |
| try { new TIFFField(tag, 1L << 32); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, CONSTRUCT + "value > 0xffffffff"); |
| |
| ok = false; |
| try { |
| TIFFTag t = new TIFFTag(NAME, NUM, 1 << TIFFTag.TIFF_SHORT); |
| new TIFFField(t, 0x10000); |
| } catch (IllegalArgumentException e) { ok = true; } |
| check(ok, CONSTRUCT + "value 0x10000 incompatible with TIFF_SHORT"); |
| |
| ok = false; |
| try { |
| TIFFTag t = new TIFFTag(NAME, NUM, 1 << TIFFTag.TIFF_LONG); |
| new TIFFField(t, 0xffff); |
| } catch (IllegalArgumentException e) { ok = true; } |
| check(ok, CONSTRUCT + "value 0xffff incompatible with TIFF_LONG"); |
| |
| // check value type recognition |
| int v = 1 << 16; |
| f = new TIFFField(tag, v - 1); |
| check(f.getType() == TIFFTag.TIFF_SHORT, "must be treated as short"); |
| check(f.isIntegral(), "must be integral"); |
| f = new TIFFField(tag, v); |
| check(f.getType() == TIFFTag.TIFF_LONG, "must be treated as long"); |
| |
| // other checks |
| check(f.getAsLongs().length == 1, "invalid long[] size"); |
| check(f.isIntegral(), "must be integral"); |
| check((f.getDirectory() == null) && !f.hasDirectory(), |
| "must not have directory"); |
| check(f.getValueAsString(0).equals(String.valueOf(v)), |
| "invalid string representation of value"); |
| check(f.getTag().getNumber() == f.getTagNumber(), |
| "invalid tag number"); |
| check(f.getCount() == 1, "invalid count"); |
| check(f.getTagNumber() == NUM, "invalid tag number"); |
| |
| // constructor: TIFFField(tag, type, count) |
| int type = TIFFTag.TIFF_SHORT; |
| |
| ok = false; |
| try { new TIFFField(null, type, 1); } |
| catch (NullPointerException e) { ok = true; } |
| check(ok, CONSTRUCT + "null tag"); |
| |
| ok = false; |
| try { new TIFFField(tag, MAX_TYPE + 1, 1); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, CONSTRUCT + "invalid type tag"); |
| |
| // check that count == 1 for TIFF_IFD_POINTER |
| ok = false; |
| try { new TIFFField(tag, TIFFTag.TIFF_IFD_POINTER, 0); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, "only count = 1 should be allowed for IFDPointer"); |
| |
| ok = false; |
| try { new TIFFField(tag, TIFFTag.TIFF_IFD_POINTER, 2); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, "only count = 1 should be allowed for IFDPointer"); |
| |
| // check that count == 0 is not allowed for TIFF_RATIONAL, TIFF_SRATIONAL |
| // (see fix for JDK-8149120) |
| ok = false; |
| try { new TIFFField(tag, TIFFTag.TIFF_RATIONAL, 0); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, "count = 0 should not be allowed for Rational"); |
| |
| ok = false; |
| try { new TIFFField(tag, TIFFTag.TIFF_SRATIONAL, 0); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, "count = 0 should not be allowed for SRational"); |
| |
| ok = false; |
| try { new TIFFField(tag, type, -1); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, CONSTRUCT + "with invalid data count"); |
| |
| f = new TIFFField(tag, type, 0); |
| check(f.getCount() == 0, "invalid count"); |
| check(!f.hasDirectory(), "must not have directory"); |
| |
| // constructor: TIFFField(tag, type, count, data) |
| double a[] = {0.1, 0.2, 0.3}; |
| ok = false; |
| try { new TIFFField(null, TIFFTag.TIFF_DOUBLE, a.length, a); } |
| catch (NullPointerException e) { ok = true; } |
| check(ok, CONSTRUCT + "null tag"); |
| |
| ok = false; |
| try { new TIFFField(tag, type, a.length - 1, a); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, CONSTRUCT + "invalid data count"); |
| |
| String a2[] = {"one", "two"}; |
| ok = false; |
| try { new TIFFField(tag, type, 2, a2); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, CONSTRUCT + "invalid data type"); |
| check((f.getDirectory() == null) && !f.hasDirectory(), |
| "must not have directory"); |
| |
| ok = false; |
| try { |
| TIFFTag t = new TIFFTag(NAME, NUM, 1 << TIFFTag.TIFF_RATIONAL); |
| long[][] tiffRationals = new long[6][3]; |
| new TIFFField(t, TIFFTag.TIFF_RATIONAL, tiffRationals.length, |
| tiffRationals); |
| } catch (IllegalArgumentException e) { |
| ok = true; |
| } |
| |
| ok = false; |
| try { |
| TIFFTag t = new TIFFTag(NAME, NUM, 1 << TIFFTag.TIFF_SRATIONAL); |
| int[][] tiffSRationals = new int[6][3]; |
| new TIFFField(t, TIFFTag.TIFF_SRATIONAL, tiffSRationals.length, |
| tiffSRationals); |
| } catch (IllegalArgumentException e) { |
| ok = true; |
| } |
| |
| ok = false; |
| try { |
| TIFFTag t = new TIFFTag(NAME, NUM, 1 << TIFFTag.TIFF_LONG); |
| long[] tiffLongs = new long[] {0, -7, 10}; |
| new TIFFField(t, TIFFTag.TIFF_LONG, tiffLongs.length, |
| tiffLongs); |
| } catch (IllegalArgumentException e) { |
| ok = true; |
| } |
| |
| ok = false; |
| try { |
| TIFFTag t = new TIFFTag(NAME, NUM, 1 << TIFFTag.TIFF_LONG); |
| long[] tiffLongs = new long[] {0, 7, 0x100000000L}; |
| new TIFFField(t, TIFFTag.TIFF_LONG, tiffLongs.length, |
| tiffLongs); |
| } catch (IllegalArgumentException e) { |
| ok = true; |
| } |
| |
| ok = false; |
| try { |
| TIFFTag t = new TIFFTag(NAME, NUM, 1 << TIFFTag.TIFF_IFD_POINTER); |
| long[] tiffLongs = new long[] {-7}; |
| new TIFFField(t, TIFFTag.TIFF_IFD_POINTER, tiffLongs.length, |
| tiffLongs); |
| } catch (IllegalArgumentException e) { |
| ok = true; |
| } |
| |
| ok = false; |
| try { |
| TIFFTag t = new TIFFTag(NAME, NUM, 1 << TIFFTag.TIFF_IFD_POINTER); |
| long[] tiffLongs = new long[] {0x100000000L}; |
| new TIFFField(t, TIFFTag.TIFF_IFD_POINTER, tiffLongs.length, |
| tiffLongs); |
| } catch (IllegalArgumentException e) { |
| ok = true; |
| } |
| |
| ok = false; |
| try { |
| TIFFTag t = new TIFFTag(NAME, NUM, 1 << TIFFTag.TIFF_RATIONAL); |
| long[][] tiffRationals = new long[][] { |
| {10, 2}, |
| {1, -3}, |
| {4, 7} |
| }; |
| new TIFFField(t, TIFFTag.TIFF_RATIONAL, tiffRationals.length, |
| tiffRationals); |
| } catch (IllegalArgumentException e) { |
| ok = true; |
| } |
| |
| ok = false; |
| try { |
| TIFFTag t = new TIFFTag(NAME, NUM, 1 << TIFFTag.TIFF_RATIONAL); |
| long[][] tiffRationals = new long[][] { |
| {10, 2}, |
| {0x100000000L, 3}, |
| {4, 7} |
| }; |
| new TIFFField(t, TIFFTag.TIFF_RATIONAL, tiffRationals.length, |
| tiffRationals); |
| } catch (IllegalArgumentException e) { |
| ok = true; |
| } |
| |
| // constructor: TIFFField(tag, type, offset, dir) |
| List<TIFFTag> tags = new ArrayList<>(); |
| tags.add(tag); |
| TIFFTagSet sets[] = {new TIFFTagSet(tags)}; |
| TIFFDirectory dir = new TIFFDirectory(sets, null); |
| |
| ok = false; |
| try { new TIFFField(null, type, 4L, dir); } |
| catch (NullPointerException e) { ok = true; } |
| check(ok, CONSTRUCT + "null tag"); |
| |
| ok = false; |
| try { new TIFFField(tag, type, 0L, dir); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, CONSTRUCT + "non-positive offset"); |
| |
| long offset = 4; |
| |
| for (int t = MIN_TYPE; t <= MAX_TYPE; t++) { |
| |
| tag = new TIFFTag(NAME, NUM, 1 << t); |
| |
| // only TIFF_LONG and TIFF_IFD_POINTER types are allowed |
| if (t == TIFFTag.TIFF_LONG || t == TIFFTag.TIFF_IFD_POINTER) { |
| |
| f = new TIFFField(tag, t, offset, dir); |
| check(f.hasDirectory(), "must have directory"); |
| |
| check(f.getDirectory().getTag(NUM).getName().equals(NAME), |
| "invalid tag name"); |
| |
| check(f.getCount() == 1, "invalid count"); |
| check(f.getAsLong(0) == offset, "invalid offset"); |
| } else { |
| ok = false; |
| try { new TIFFField(tag, t, offset, dir); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, CONSTRUCT + "invalid data type"); |
| } |
| } |
| |
| type = TIFFTag.TIFF_IFD_POINTER; |
| tag = new TIFFTag(NAME, NUM, 1 << type); |
| ok = false; |
| try { new TIFFField(tag, type, offset, null); } |
| catch (NullPointerException e) { ok = true; } |
| check(ok, CONSTRUCT + "null TIFFDirectory"); |
| |
| type = TIFFTag.TIFF_LONG; |
| tag = new TIFFTag(NAME, NUM, 1 << type); |
| ok = false; |
| try { new TIFFField(tag, type, offset, null); } |
| catch (NullPointerException e) { ok = true; } |
| check(ok, CONSTRUCT + "null TIFFDirectory"); |
| } |
| |
| private void testTypes() { |
| |
| // test getTypeName(), getTypeByName() methods |
| |
| boolean ok = false; |
| try { TIFFField.getTypeName(MIN_TYPE - 1); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, "invalid data type number used"); |
| |
| ok = false; |
| try { TIFFField.getTypeName(MAX_TYPE + 1); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, "invalid data type number used"); |
| |
| for (int type = MIN_TYPE; type <= MAX_TYPE; type++) { |
| String name = TIFFField.getTypeName(type); |
| check(TIFFField.getTypeByName(name) == type, "invalid type"); |
| } |
| |
| for (int type = MIN_TYPE; type <= MAX_TYPE; type++) { |
| |
| TIFFTag tag = new TIFFTag(NAME, NUM, 1 << type); |
| TIFFField f = new TIFFField(tag, type, 1); |
| check(f.getType() == type, "invalid type"); |
| |
| // check that invalid data types can not be used |
| for (int type2 = MIN_TYPE; type2 <= MAX_TYPE; ++type2) { |
| if (type2 != type) { |
| ok = false; |
| try { new TIFFField(tag, type2, 1); } // invalid type |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, "invalid type was successfully set"); |
| } |
| } |
| } |
| } |
| |
| private void testGetAs() { |
| |
| // test getAs...() methods |
| |
| int type = TIFFTag.TIFF_SHORT; |
| TIFFTag tag = new TIFFTag(NAME, NUM, 1 << TIFFTag.TIFF_SHORT); |
| |
| short v = 123; |
| TIFFField f = new TIFFField(tag, v); |
| |
| check(f.getAsInt(0) == (int) v, "invalid int value"); |
| check(f.getAsLong(0) == (long) v, "invalid long value"); |
| check(f.getAsFloat(0) == (float) v, "invalid float value"); |
| check(f.getAsDouble(0) == (double) v, "invalid double value"); |
| check(f.getValueAsString(0).equals(Short.toString(v)), |
| "invalid string representation"); |
| |
| check(f.getAsInts().length == 1, "inavlid array size"); |
| check((int) v == f.getAsInts()[0], "invalid int value"); |
| |
| float fa[] = {0.01f, 1.01f}; |
| type = TIFFTag.TIFF_FLOAT; |
| f = new TIFFField( |
| new TIFFTag(NAME, NUM, 1 << type), type, fa.length, fa); |
| check(f.getCount() == fa.length, "invalid count"); |
| float fa2[] = f.getAsFloats(); |
| check(fa2.length == fa.length, "invalid array size"); |
| |
| for (int i = 0; i < fa.length; i++) { |
| check(fa2[i] == fa[i], "invalid value"); |
| check(f.getAsDouble(i) == fa[i], "invalid value"); |
| check(f.getAsInt(i) == (int) fa[i], "invalid value"); // cast to int |
| check(f.getValueAsString(i).equals(Float.toString(fa[i])), |
| "invalid string representation"); |
| } |
| |
| byte ba[] = {-1, -10, -100}; |
| type = TIFFTag.TIFF_BYTE; |
| f = new TIFFField( |
| new TIFFTag(NAME, NUM, 1 << type), type, ba.length, ba); |
| check(f.getCount() == ba.length, "invalid count"); |
| byte ba2[] = f.getAsBytes(); |
| check(ba2.length == ba.length, "invalid count"); |
| |
| for (int i = 0; i < ba.length; i++) { |
| check(ba[i] == ba2[i], "invalid value"); |
| check(ba[i] == (byte) f.getAsDouble(i), "invalid value"); |
| check(ba[i] == (byte) f.getAsLong(i), "invalid value"); |
| |
| int unsigned = ba[i] & 0xff; |
| check(f.getAsInt(i) == unsigned, "must be treated as unsigned"); |
| } |
| |
| char ca[] = {'a', 'z', 0xffff}; |
| type = TIFFTag.TIFF_SHORT; |
| f = new TIFFField( |
| new TIFFTag(NAME, NUM, 1 << type), type, ca.length, ca); |
| check(f.getCount() == ca.length, "invalid count"); |
| char ca2[] = f.getAsChars(); |
| check(ba2.length == ba.length, "invalid count"); |
| |
| for (int i = 0; i < ca.length; i++) { |
| check(ca[i] == ca2[i], "invalid value"); |
| check(ca[i] == (char) f.getAsDouble(i), "invalid value"); |
| check(ca[i] == (char) f.getAsLong(i), "invalid value"); |
| check(ca[i] == (char) f.getAsInt(i), "invalid value"); |
| } |
| |
| type = TIFFTag.TIFF_DOUBLE; |
| double da[] = {0.1, 0.2, 0.3}; |
| f = new TIFFField( |
| new TIFFTag(NAME, NUM, 1 << type), type, da.length, da); |
| check(!f.isIntegral(), "isIntegral must be false"); |
| |
| double da2[] = f.getAsDoubles(); |
| check(f.getData() instanceof double[], "invalid data type"); |
| double da3[] = (double[]) f.getData(); |
| check((da.length == da2.length) && |
| (da.length == da2.length) && |
| (da.length == f.getCount()), |
| "invalid data count"); |
| for (int i = 0; i < da.length; ++i) { |
| check(da[i] == da2[i], "invalid data"); |
| check(da[i] == da3[i], "invalid data"); |
| } |
| |
| boolean ok = false; |
| try { f.getAsShorts(); } |
| catch (ClassCastException e) { ok = true; } |
| check(ok, "invalid data cast"); |
| |
| ok = false; |
| try { f.getAsRationals(); } |
| catch (ClassCastException e) { ok = true; } |
| check(ok, "invalid data cast"); |
| |
| ok = false; |
| try { TIFFField.createArrayForType(TIFFTag.MIN_DATATYPE - 1, 1); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, "can create array with invalid datatype"); |
| |
| ok = false; |
| try { TIFFField.createArrayForType(TIFFTag.MAX_DATATYPE + 1, 1); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, "can create array with invalid datatype"); |
| |
| ok = false; |
| try { TIFFField.createArrayForType(TIFFTag.TIFF_FLOAT, -1); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, "can create array with negative count"); |
| |
| int n = 3; |
| Object |
| RA = TIFFField.createArrayForType(TIFFTag.TIFF_RATIONAL, n), |
| SRA = TIFFField.createArrayForType(TIFFTag.TIFF_SRATIONAL, n); |
| check(RA instanceof long[][], "invalid data type"); |
| check(SRA instanceof int[][], "invalid data type"); |
| |
| long ra[][] = (long[][]) RA; |
| int sra[][] = (int[][]) SRA; |
| check((ra.length == n) && (sra.length == n), "invalid data size"); |
| for (int i = 0; i < n; i++) { |
| check((ra[i].length == 2) && (sra[i].length == 2), |
| "invalid data size"); |
| ra[i][0] = 1; ra[i][1] = 5 + i; |
| sra[i][0] = -1; sra[i][1] = 5 + i; |
| } |
| |
| type = TIFFTag.TIFF_RATIONAL; |
| TIFFField f1 = new TIFFField( |
| new TIFFTag(NAME, NUM, 1 << type), type, n, ra); |
| type = TIFFTag.TIFF_SRATIONAL; |
| TIFFField f2 = new TIFFField( |
| new TIFFTag(NAME, NUM, 1 << type), type, n, sra); |
| |
| check((f1.getCount() == ra.length) && (f2.getCount() == sra.length), |
| "invalid data count"); |
| |
| check(f1.getAsRationals().length == n, "invalid data count"); |
| check(f2.getAsSRationals().length == n, "invalid data count"); |
| for (int i = 0; i < n; i++) { |
| long r[] = f1.getAsRational(i); |
| check(r.length == 2, "invalid data format"); |
| check((r[0] == 1) && (r[1] == i + 5), "invalid data"); |
| |
| int sr[] = f2.getAsSRational(i); |
| check(sr.length == 2, "invalid data format"); |
| check((sr[0] == -1) && (sr[1] == i + 5), "invalid data"); |
| |
| // check string representation |
| String s = Long.toString(r[0]) + "/" + Long.toString(r[1]); |
| check(s.equals(f1.getValueAsString(i)), |
| "invalid string representation"); |
| |
| s = Integer.toString(sr[0]) + "/" + Integer.toString(sr[1]); |
| check(s.equals(f2.getValueAsString(i)), |
| "invalid string representation"); |
| |
| // see the documentation for getAsInt: |
| // TIFF_SRATIONAL or TIFF_RATIONAL format are evaluated |
| // by dividing the numerator into the denominator using |
| // double-precision arithmetic and then casting to int |
| check(f1.getAsInt(i) == (int)(r[0] / r[1]), |
| "invalid result for getAsInt"); |
| check(f2.getAsInt(i) == (int)(r[0] / r[1]), |
| "invalid result for getAsInt"); |
| } |
| |
| ok = false; |
| try { f1.getAsRational(ra.length); } |
| catch (ArrayIndexOutOfBoundsException e) { ok = true; } |
| check(ok, "invalid index"); |
| |
| String sa[] = {"-1.e-25", "22", "-1.23E5"}; |
| type = TIFFTag.TIFF_ASCII; |
| f = new TIFFField( |
| new TIFFTag(NAME, NUM, 1 << type), type, sa.length, sa); |
| |
| // test clone() method |
| TIFFField cloned = null; |
| try { cloned = f.clone(); } catch (CloneNotSupportedException e) { |
| throw new RuntimeException(e); |
| } |
| |
| check(f.getCount() == cloned.getCount(), "invalid cloned field count"); |
| |
| check(f.getCount() == sa.length, "invalid data count"); |
| for (int i = 0; i < sa.length; i++) { |
| check(sa[i].equals(f.getAsString(i)), "invalid data"); |
| // see docs: "data in TIFF_ASCII format will be parsed as by |
| // the Double.parseDouble method, with the result cast to int" |
| check(f.getAsInt(i) == |
| (int) Double.parseDouble(sa[i]), "invalid data"); |
| check(f.getAsDouble(i) == Double.parseDouble(sa[i]), "invalid data"); |
| |
| check(sa[i].equals(cloned.getAsString(i)), "invalid cloned data"); |
| } |
| } |
| |
| private void testCreateFromNode() { |
| |
| int type = TIFFTag.TIFF_LONG; |
| |
| List<TIFFTag> tags = new ArrayList<>(); |
| int v = 1234567; |
| TIFFTag tag = new TIFFTag(NAME, NUM, 1 << type); |
| tags.add(tag); |
| TIFFTagSet ts = new TIFFTagSet(tags); |
| |
| boolean ok = false; |
| try { |
| TIFFField.createFromMetadataNode(ts, null); |
| } catch (IllegalArgumentException e) { |
| // createFromMetadataNode() formerly threw a NullPointerException |
| // if its Node parameter was null, but the specification has been |
| // modified to allow only IllegalArgumentExceptions, perhaps with |
| // a cause set. In the present invocation the cause would be set |
| // to a NullPointerException but this is not explicitly specified |
| // hence not verified here. |
| ok = true; |
| } |
| check(ok, "can create TIFFField from a null node"); |
| |
| TIFFField f = new TIFFField(tag, v); |
| Node node = f.getAsNativeNode(); |
| check(node.getNodeName().equals(f.getClass().getSimpleName()), |
| "invalid node name"); |
| |
| NamedNodeMap attrs = node.getAttributes(); |
| for (int i = 0; i < attrs.getLength(); i++) { |
| String an = attrs.item(i).getNodeName().toLowerCase(); |
| String av = attrs.item(i).getNodeValue(); |
| if (an.contains("name")) { |
| check(av.equals(NAME), "invalid tag name"); |
| } else if (an.contains("number")) { |
| check(av.equals(Integer.toString(NUM)), "invalid tag number"); |
| } |
| } |
| |
| // invalid node |
| IIOMetadataNode nok = new IIOMetadataNode("NOK"); |
| |
| ok = false; |
| try { TIFFField.createFromMetadataNode(ts, nok); } |
| catch (IllegalArgumentException e) { ok = true; } |
| check(ok, CONSTRUCT + "invalid node name"); |
| |
| TIFFField f2 = TIFFField.createFromMetadataNode(ts, node); |
| check(f2.getType() == type, "invalid type"); |
| check(f2.getTagNumber() == NUM, "invalid tag number"); |
| check(f2.getTag().getName().equals(NAME), "invalid tag name"); |
| check(f2.getCount() == 1, "invalid count"); |
| check(f2.getAsInt(0) == v, "invalid value"); |
| } |
| |
| public static void main(String[] args) { |
| |
| TIFFFieldTest test = new TIFFFieldTest(); |
| test.testConstructors(); |
| test.testCreateFromNode(); |
| test.testTypes(); |
| test.testGetAs(); |
| } |
| } |
