1 /*

     2  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 /**

    25  * @test

    26  * @bug     8152183

    27  * @author  a.stepanov

    28  * @summary Some checks for TIFFField methods

    29  * @run     main TIFFFieldTest

    30  */

    31 

    32 import java.util.List;

    33 import java.util.ArrayList;

    34 import javax.imageio.metadata.IIOMetadataNode;

    35 import javax.imageio.plugins.tiff.*;

    36 import org.w3c.dom.NamedNodeMap;

    37 import org.w3c.dom.Node;

    38 

    39 public class TIFFFieldTest {

    40 

    41     private final static String NAME = "tag"; // tag name

    42     private final static int    NUM  = 12345; // tag number

    43     private final static int MIN_TYPE = TIFFTag.MIN_DATATYPE;

    44     private final static int MAX_TYPE = TIFFTag.MAX_DATATYPE;

    45     private final static String CONSTRUCT = "can construct TIFFField with ";

    46 

    47     private void check(boolean ok, String msg) {

    48         if (!ok) { throw new RuntimeException(msg); }

    49     }

    50 

    51     private void testConstructors() {

    52 

    53         // test constructors

    54 

    55         TIFFTag tag = new TIFFTag(

    56             NAME, NUM, 1 << TIFFTag.TIFF_SHORT | 1 << TIFFTag.TIFF_LONG);

    57         TIFFField f;

    58 

    59         // constructor: TIFFField(tag, value)

    60         boolean ok = false;

    61         try { new TIFFField(null, 0); }

    62         catch (NullPointerException e) { ok = true; }

    63         check(ok, CONSTRUCT + "null tag");

    64 

    65         ok = false;

    66         try { new TIFFField(tag, -1); }

    67         catch (IllegalArgumentException e) { ok = true; }

    68         check(ok, CONSTRUCT + "invalid count");

    69 

    70         // check value type recognition

    71         int v = 1 << 16;

    72         f = new TIFFField(tag, v - 1);

    73         check(f.getType() == TIFFTag.TIFF_SHORT, "must be treated as short");

    74         check(f.isIntegral(), "must be integral");

    75         f = new TIFFField(tag, v);

    76         check(f.getType() == TIFFTag.TIFF_LONG, "must be treated as long");

    77 

    78         // other checks

    79         check(f.getAsLongs().length == 1, "invalid long[] size");

    80         check(f.isIntegral(), "must be integral");

    81         check((f.getDirectory() == null) && !f.hasDirectory(),

    82             "must not have directory");

    83         check(f.getValueAsString(0).equals(String.valueOf(v)),

    84             "invalid string representation of value");

    85         check(f.getTag().getNumber() == f.getTagNumber(),

    86             "invalid tag number");

    87         check(f.getCount() == 1, "invalid count");

    88         check(f.getTagNumber() == NUM, "invalid tag number");

    89 

    90         // constructor: TIFFField(tag, type, count)

    91         int type = TIFFTag.TIFF_SHORT;

    92 

    93         ok = false;

    94         try { new TIFFField(null, type, 1); }

    95         catch (NullPointerException e) { ok = true; }

    96         check(ok, CONSTRUCT + "null tag");

    97 

    98         ok = false;

    99         try { new TIFFField(tag, MAX_TYPE + 1, 1); }

   100         catch (IllegalArgumentException e) { ok = true; }

   101         check(ok, CONSTRUCT + "invalid type tag");

   102 

   103         // check that count == 1 for TIFF_IFD_POINTER

   104         ok = false;

   105         try { new TIFFField(tag, TIFFTag.TIFF_IFD_POINTER, 0); }

   106         catch (IllegalArgumentException e) { ok = true; }

   107         check(ok, "only count = 1 should be allowed for IFDPointer");

   108 

   109         ok = false;

   110         try { new TIFFField(tag, TIFFTag.TIFF_IFD_POINTER, 2); }

   111         catch (IllegalArgumentException e) { ok = true; }

   112         check(ok, "only count = 1 should be allowed for IFDPointer");

   113 

   114         // check that count == 0 is not allowed for TIFF_RATIONAL, TIFF_SRATIONAL

   115         // (see fix for JDK-8149120)

   116         ok = false;

   117         try { new TIFFField(tag, TIFFTag.TIFF_RATIONAL, 0); }

   118         catch (IllegalArgumentException e) { ok = true; }

   119         check(ok, "count = 0 should not be allowed for Rational");

   120 

   121         ok = false;

   122         try { new TIFFField(tag, TIFFTag.TIFF_SRATIONAL, 0); }

   123         catch (IllegalArgumentException e) { ok = true; }

   124         check(ok, "count = 0 should not be allowed for SRational");

   125 

   126         ok = false;

   127         try { new TIFFField(tag, type, -1); }

   128         catch (IllegalArgumentException e) { ok = true; }

   129         check(ok, CONSTRUCT + "with invalid data count");

   130 

   131         f = new TIFFField(tag, type, 0);

   132         check(f.getCount() == 0, "invalid count");

   133         check(!f.hasDirectory(), "must not have directory");

   134 

   135         // constructor: TIFFField(tag, type, count, data)

   136         double a[] = {0.1, 0.2, 0.3};

   137         ok = false;

   138         try { new TIFFField(null, TIFFTag.TIFF_DOUBLE, a.length, a); }

   139         catch (NullPointerException e) { ok = true; }

   140         check(ok, CONSTRUCT + "null tag");

   141 

   142         ok = false;

   143         try { new TIFFField(tag, type, a.length - 1, a); }

   144         catch (IllegalArgumentException e) { ok = true; }

   145         check(ok, CONSTRUCT + "invalid data count");

   146 

   147         String a2[] = {"one", "two"};

   148         ok = false;

   149         try { new TIFFField(tag, type, 2, a2); }

   150         catch (IllegalArgumentException e) { ok = true; }

   151         check(ok, CONSTRUCT + "invalid data type");

   152         check((f.getDirectory() == null) && !f.hasDirectory(),

   153             "must not have directory");

   154 

   155         // constructor: TIFFField(tag, type, offset, dir)

   156         List<TIFFTag> tags = new ArrayList<>();

   157         tags.add(tag);

   158         TIFFTagSet sets[] = {new TIFFTagSet(tags)};

   159         TIFFDirectory dir = new TIFFDirectory(sets, null);

   160 

   161         ok = false;

   162         try { new TIFFField(null, type, 4L, dir); }

   163         catch (NullPointerException e) { ok = true; }

   164         check(ok, CONSTRUCT + "null tag");

   165 

   166         ok = false;

   167         try { new TIFFField(tag, type, 0L, dir); }

   168         catch (IllegalArgumentException e) { ok = true; }

   169         check(ok, CONSTRUCT + "non-positive offset");

   170 

   171         long offset = 4;

   172 

   173         for (int t = MIN_TYPE; t <= MAX_TYPE; t++) {

   174 

   175             tag = new TIFFTag(NAME, NUM, 1 << t);

   176 

   177             // only TIFF_LONG and TIFF_IFD_POINTER types are allowed

   178             if (t == TIFFTag.TIFF_LONG || t == TIFFTag.TIFF_IFD_POINTER) {

   179 

   180                 f = new TIFFField(tag, t, offset, dir);

   181                 check(f.hasDirectory(), "must have directory");

   182 

   183                 check(f.getDirectory().getTag(NUM).getName().equals(NAME),

   184                     "invalid tag name");

   185 

   186                 check(f.getCount() == 1, "invalid count");

   187                 check(f.getAsLong(0) == offset, "invalid offset");

   188             } else {

   189                 ok = false;

   190                 try { new TIFFField(tag, t, offset, dir); }

   191                 catch (IllegalArgumentException e) { ok = true; }

   192                 check(ok, CONSTRUCT + "invalid data type");

   193             }

   194         }

   195 

   196         type = TIFFTag.TIFF_IFD_POINTER;

   197         tag = new TIFFTag(NAME, NUM, 1 << type);

   198         ok = false;

   199         try { new TIFFField(tag, type, offset, null); }

   200         catch (NullPointerException e) { ok = true; }

   201         check(ok, CONSTRUCT + "null TIFFDirectory");

   202 

   203         type = TIFFTag.TIFF_LONG;

   204         tag = new TIFFTag(NAME, NUM, 1 << type);

   205         ok = false;

   206         try { new TIFFField(tag, type, offset, null); }

   207         catch (NullPointerException e) { ok = true; }

   208         check(ok, CONSTRUCT + "null TIFFDirectory");

   209     }

   210 

   211     private void testTypes() {

   212 

   213         // test getTypeName(), getTypeByName() methods

   214 

   215         boolean ok = false;

   216         try { TIFFField.getTypeName(MIN_TYPE - 1); }

   217         catch (IllegalArgumentException e) { ok = true; }

   218         check(ok, "invalid data type number used");

   219 

   220         ok = false;

   221         try { TIFFField.getTypeName(MAX_TYPE + 1); }

   222         catch (IllegalArgumentException e) { ok = true; }

   223         check(ok, "invalid data type number used");

   224 

   225         for (int type = MIN_TYPE; type <= MAX_TYPE; type++) {

   226             String name = TIFFField.getTypeName(type);

   227             check(TIFFField.getTypeByName(name) == type, "invalid type");

   228         }

   229 

   230         for (int type = MIN_TYPE; type <= MAX_TYPE; type++) {

   231 

   232             TIFFTag tag = new TIFFTag(NAME, NUM, 1 << type);

   233             TIFFField f = new TIFFField(tag, type, 1);

   234             check(f.getType() == type, "invalid type");

   235 

   236             // check that invalid data types can not be used

   237             for (int type2 = MIN_TYPE; type2 <= MAX_TYPE; ++type2) {

   238                 if (type2 != type) {

   239                     ok = false;

   240                     try { new TIFFField(tag, type2, 1); } // invalid type

   241                     catch (IllegalArgumentException e) { ok = true; }

   242                     check(ok, "invalid type was successfully set");

   243                 }

   244             }

   245         }

   246     }

   247 

   248     private void testGetAs() {

   249 

   250         // test getAs...() methods

   251 

   252         int type = TIFFTag.TIFF_SHORT;

   253         TIFFTag tag = new TIFFTag(NAME, NUM, 1 << TIFFTag.TIFF_SHORT);

   254 

   255         short v = 123;

   256         TIFFField f = new TIFFField(tag, v);

   257 

   258         check(f.getAsInt(0)    ==    (int) v, "invalid int value");

   259         check(f.getAsLong(0)   ==   (long) v, "invalid long value");

   260         check(f.getAsFloat(0)  ==  (float) v, "invalid float value");

   261         check(f.getAsDouble(0) == (double) v, "invalid double value");

   262         check(f.getValueAsString(0).equals(Short.toString(v)),

   263             "invalid string representation");

   264 

   265         check(f.getAsInts().length == 1, "inavlid array size");

   266         check((int) v == f.getAsInts()[0], "invalid int value");

   267 

   268         float fa[] = {0.01f, 1.01f};

   269         type = TIFFTag.TIFF_FLOAT;

   270         f = new TIFFField(

   271             new TIFFTag(NAME, NUM, 1 << type), type, fa.length, fa);

   272         check(f.getCount() == fa.length, "invalid count");

   273         float fa2[] = f.getAsFloats();

   274         check(fa2.length == fa.length, "invalid array size");

   275 

   276         for (int i = 0; i < fa.length; i++) {

   277             check(fa2[i] == fa[i], "invalid value");

   278             check(f.getAsDouble(i) == fa[i], "invalid value");

   279             check(f.getAsInt(i) == (int) fa[i], "invalid value"); // cast to int

   280             check(f.getValueAsString(i).equals(Float.toString(fa[i])),

   281             "invalid string representation");

   282         }

   283 

   284         byte ba[] = {-1, -10, -100};

   285         type = TIFFTag.TIFF_BYTE;

   286         f = new TIFFField(

   287             new TIFFTag(NAME, NUM, 1 << type), type, ba.length, ba);

   288         check(f.getCount() == ba.length, "invalid count");

   289         byte ba2[] = f.getAsBytes();

   290         check(ba2.length == ba.length, "invalid count");

   291 

   292         for (int i = 0; i < ba.length; i++) {

   293             check(ba[i] == ba2[i], "invalid value");

   294             check(ba[i] == (byte) f.getAsDouble(i), "invalid value");

   295             check(ba[i] == (byte) f.getAsLong(i),   "invalid value");

   296 

   297             int unsigned = ba[i] & 0xff;

   298             check(f.getAsInt(i) == unsigned, "must be treated as unsigned");

   299         }

   300 

   301         char ca[] = {'a', 'z', 0xffff};

   302         type = TIFFTag.TIFF_SHORT;

   303         f = new TIFFField(

   304             new TIFFTag(NAME, NUM, 1 << type), type, ca.length, ca);

   305         check(f.getCount() == ca.length, "invalid count");

   306         char ca2[] = f.getAsChars();

   307         check(ba2.length == ba.length, "invalid count");

   308 

   309         for (int i = 0; i < ca.length; i++) {

   310             check(ca[i] == ca2[i], "invalid value");

   311             check(ca[i] == (char) f.getAsDouble(i), "invalid value");

   312             check(ca[i] == (char) f.getAsLong(i), "invalid value");

   313             check(ca[i] == (char) f.getAsInt(i), "invalid value");

   314         }

   315 

   316         type = TIFFTag.TIFF_DOUBLE;

   317         double da[] = {0.1, 0.2, 0.3};

   318         f = new TIFFField(

   319             new TIFFTag(NAME, NUM, 1 << type), type, da.length, da);

   320         check(!f.isIntegral(), "isIntegral must be false");

   321 

   322         double da2[] = f.getAsDoubles();

   323         check(f.getData() instanceof double[], "invalid data type");

   324         double da3[] = (double[]) f.getData();

   325         check((da.length == da2.length) &&

   326               (da.length == da2.length) &&

   327               (da.length == f.getCount()),

   328                "invalid data count");

   329         for (int i = 0; i < da.length; ++i) {

   330             check(da[i] == da2[i], "invalid data");

   331             check(da[i] == da3[i], "invalid data");

   332         }

   333 

   334         boolean ok = false;

   335         try { f.getAsShorts(); }

   336         catch (ClassCastException e) { ok = true; }

   337         check(ok, "invalid data cast");

   338 

   339         ok = false;

   340         try { f.getAsRationals(); }

   341         catch (ClassCastException e) { ok = true; }

   342         check(ok, "invalid data cast");

   343 

   344         ok = false;

   345         try { TIFFField.createArrayForType(TIFFTag.MIN_DATATYPE - 1, 1); }

   346         catch (IllegalArgumentException e) { ok = true; }

   347         check(ok, "can create array with invalid datatype");

   348 

   349         ok = false;

   350         try { TIFFField.createArrayForType(TIFFTag.MAX_DATATYPE + 1, 1); }

   351         catch (IllegalArgumentException e) { ok = true; }

   352         check(ok, "can create array with invalid datatype");

   353 

   354         ok = false;

   355         try { TIFFField.createArrayForType(TIFFTag.TIFF_FLOAT, -1); }

   356         catch (IllegalArgumentException e) { ok = true; }

   357         check(ok, "can create array with negative count");

   358 

   359         int n = 3;

   360         Object

   361             RA  = TIFFField.createArrayForType(TIFFTag.TIFF_RATIONAL,  n),

   362             SRA = TIFFField.createArrayForType(TIFFTag.TIFF_SRATIONAL, n);

   363         check(RA  instanceof long[][], "invalid data type");

   364         check(SRA instanceof  int[][], "invalid data type");

   365 

   366         long ra[][] = (long[][]) RA;

   367         int sra[][] = (int[][]) SRA;

   368         check((ra.length == n) && (sra.length == n), "invalid data size");

   369         for (int i = 0; i < n; i++) {

   370             check((ra[i].length == 2) && (sra[i].length == 2),

   371                 "invalid data size");

   372             ra[i][0]  =  1;  ra[i][1]  = 5 + i;

   373             sra[i][0] = -1;  sra[i][1] = 5 + i;

   374         }

   375 

   376         type = TIFFTag.TIFF_RATIONAL;

   377         TIFFField f1 = new TIFFField(

   378             new TIFFTag(NAME, NUM, 1 << type), type, n, ra);

   379         type = TIFFTag.TIFF_SRATIONAL;

   380         TIFFField f2 = new TIFFField(

   381             new TIFFTag(NAME, NUM, 1 << type), type, n, sra);

   382 

   383         check((f1.getCount() == ra.length) && (f2.getCount() == sra.length),

   384             "invalid data count");

   385 

   386         check(f1.getAsRationals().length  == n, "invalid data count");

   387         check(f2.getAsSRationals().length == n, "invalid data count");

   388         for (int i = 0; i < n; i++) {

   389             long r[] = f1.getAsRational(i);

   390             check(r.length == 2, "invalid data format");

   391             check((r[0] == 1) && (r[1] == i + 5), "invalid data");

   392 

   393             int sr[] = f2.getAsSRational(i);

   394             check(sr.length == 2, "invalid data format");

   395             check((sr[0] == -1) && (sr[1] == i + 5), "invalid data");

   396 

   397             // check string representation

   398             String s = Long.toString(r[0]) + "/" + Long.toString(r[1]);

   399             check(s.equals(f1.getValueAsString(i)),

   400                 "invalid string representation");

   401 

   402             s = Integer.toString(sr[0]) + "/" + Integer.toString(sr[1]);

   403             check(s.equals(f2.getValueAsString(i)),

   404                 "invalid string representation");

   405 

   406             // see the documentation for getAsInt:

   407             // TIFF_SRATIONAL or TIFF_RATIONAL format are evaluated

   408             // by dividing the numerator into the denominator using

   409             // double-precision arithmetic and then casting to int

   410             check(f1.getAsInt(i) == (int)(r[0] / r[1]),

   411                 "invalid result for getAsInt");

   412             check(f2.getAsInt(i) == (int)(r[0] / r[1]),

   413                 "invalid result for getAsInt");

   414         }

   415 

   416         ok = false;

   417         try { f1.getAsRational(ra.length); }

   418         catch (ArrayIndexOutOfBoundsException e) { ok = true; }

   419         check(ok, "invalid index");

   420 

   421         String sa[] = {"-1.e-25", "22", "-1.23E5"};

   422         type = TIFFTag.TIFF_ASCII;

   423         f = new TIFFField(

   424             new TIFFTag(NAME, NUM, 1 << type), type, sa.length, sa);

   425 

   426         // test clone() method

   427         TIFFField cloned = null;

   428         try { cloned = f.clone(); } catch (CloneNotSupportedException e) {

   429             throw new RuntimeException(e);

   430         }

   431 

   432         check(f.getCount() == cloned.getCount(), "invalid cloned field count");

   433 

   434         check(f.getCount() == sa.length, "invalid data count");

   435         for (int i = 0; i < sa.length; i++) {

   436             check(sa[i].equals(f.getAsString(i)), "invalid data");

   437             // see docs: "data in TIFF_ASCII format will be parsed as by

   438             // the Double.parseDouble method, with the result cast to int"

   439             check(f.getAsInt(i) ==

   440                 (int) Double.parseDouble(sa[i]), "invalid data");

   441             check(f.getAsDouble(i) == Double.parseDouble(sa[i]), "invalid data");

   442 

   443             check(sa[i].equals(cloned.getAsString(i)), "invalid cloned data");

   444         }

   445     }

   446 

   447     private void testCreateFromNode() {

   448 

   449         int type = TIFFTag.TIFF_LONG;

   450 

   451         List<TIFFTag> tags = new ArrayList<>();

   452         int v = 1234567;

   453         TIFFTag tag = new TIFFTag(NAME, NUM, 1 << type);

   454         tags.add(tag);

   455         TIFFTagSet ts = new TIFFTagSet(tags);

   456 

   457         boolean ok = false;

   458         try { TIFFField.createFromMetadataNode(ts, null); }

   459         catch (NullPointerException e) { ok = true; }

   460         check(ok, "can create TIFFField from a null node");

   461 

   462         TIFFField f = new TIFFField(tag, v);

   463         Node node = f.getAsNativeNode();

   464         check(node.getNodeName().equals(f.getClass().getSimpleName()),

   465             "invalid node name");

   466 

   467         NamedNodeMap attrs = node.getAttributes();

   468         for (int i = 0; i < attrs.getLength(); i++) {

   469             String an = attrs.item(i).getNodeName().toLowerCase();

   470             String av = attrs.item(i).getNodeValue();

   471             if (an.contains("name")) {

   472                 check(av.equals(NAME), "invalid tag name");

   473             } else if (an.contains("number")) {

   474                 check(av.equals(Integer.toString(NUM)), "invalid tag number");

   475             }

   476         }

   477 

   478         // invalid node

   479         IIOMetadataNode nok = new IIOMetadataNode("NOK");

   480 

   481         ok = false;

   482         try { TIFFField.createFromMetadataNode(ts, nok); }

   483         catch (IllegalArgumentException e) { ok = true; }

   484         check(ok, CONSTRUCT + "invalid node name");

   485 

   486         TIFFField f2 = TIFFField.createFromMetadataNode(ts, node);

   487         check(f2.getType() == type, "invalid type");

   488         check(f2.getTagNumber() == NUM, "invalid tag number");

   489         check(f2.getTag().getName().equals(NAME), "invalid tag name");

   490         check(f2.getCount()  == 1, "invalid count");

   491         check(f2.getAsInt(0) == v, "invalid value");

   492     }

   493 

   494     public static void main(String[] args) {

   495 

   496         TIFFFieldTest test = new TIFFFieldTest();

   497         test.testConstructors();

   498         test.testCreateFromNode();

   499         test.testTypes();

   500         test.testGetAs();

   501     }

   502 }