1 /*
   2  * Copyright (c) 2001, 2017, 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 4429934 4429950 4430991 4430993
  27  * @summary Checks various aspects of ImageTypeSpecifier functionality
  28  */
  29 
  30 import java.awt.color.ColorSpace;
  31 import java.awt.image.BufferedImage;
  32 import java.awt.image.ColorModel;
  33 import java.awt.image.DataBuffer;
  34 import java.awt.image.SampleModel;
  35 
  36 import javax.imageio.ImageTypeSpecifier;
  37 
  38 public class ImageTypeSpecifierTest {
  39 
  40     private static void fail(String message) {
  41         throw new RuntimeException(message);
  42     }
  43 
  44     private static void test4429934() {
  45         try {
  46             ImageTypeSpecifier itspecifier =
  47                 new ImageTypeSpecifier(null, null);
  48             fail("Failed to get IAE!");
  49         } catch( IllegalArgumentException e ) {
  50         }
  51 
  52         try {
  53             ImageTypeSpecifier itspecifier = new ImageTypeSpecifier(null);
  54             fail("Failed to get IAE!");
  55         } catch (IllegalArgumentException e ) {
  56         }
  57     }
  58 
  59     private static void test4429950() {
  60         createPackedTest();
  61         createInterleavedTest();
  62         createBandedTest();
  63         createIndexedTest();
  64     }
  65 
  66     public static void createPackedTest() {
  67         ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
  68         int rmask = 0x00ff0000;
  69         int gmask = 0x0000ff00;
  70         int bmask = 0x000000ff;
  71         int amask = 0xff000000;
  72         try {
  73             ImageTypeSpecifier.createPacked(null, rmask, gmask, bmask, amask, 0,
  74 false);
  75             fail("Failed to get IAE!");
  76         } catch (IllegalArgumentException e) {
  77         }
  78 
  79         ColorSpace cs1 = ColorSpace.getInstance(ColorSpace.CS_GRAY);
  80         try {
  81             ImageTypeSpecifier.createPacked
  82                 (cs1, rmask, gmask, bmask, amask, 0, false);
  83             fail("Failed to get IAE!");
  84         } catch (IllegalArgumentException e) {
  85         }
  86 
  87         try {
  88             ImageTypeSpecifier.createPacked(cs, 0, 0, 0, 0, 0, false);
  89             fail("Failed to get IAE!");
  90         } catch (IllegalArgumentException e) {
  91         }
  92 
  93         try {
  94             ImageTypeSpecifier.createPacked(cs, rmask, gmask, bmask, amask, -1,
  95 false);
  96             fail("Failed to get IAE!");
  97         } catch (IllegalArgumentException e) {
  98         }
  99     }
 100 
 101     public static void createInterleavedTest() {
 102         ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
 103         int[] bandOffsets = {0,0,0,0};
 104         int dataType = 0;
 105         boolean hasAlpha = true;
 106         boolean isAlphaPremultiplied = true;
 107 
 108         try {
 109             ImageTypeSpecifier.createInterleaved
 110                 (null, bandOffsets, dataType, hasAlpha, isAlphaPremultiplied);
 111             fail("Failed to get IAE!");
 112         } catch (IllegalArgumentException e) {
 113         }
 114 
 115         try {
 116             ImageTypeSpecifier.createInterleaved
 117                 (cs, null, dataType, hasAlpha, isAlphaPremultiplied);
 118             fail("Failed to get IAE!");
 119         } catch (IllegalArgumentException e) {
 120         }
 121 
 122         int[] bad_bandOffsets = {0,100,1000};
 123         try {
 124             ImageTypeSpecifier.createInterleaved
 125                 (cs, bad_bandOffsets, dataType, hasAlpha, isAlphaPremultiplied);
 126             fail("Failed to get IAE!");
 127         } catch (IllegalArgumentException e) {
 128         }
 129 
 130         int[] bad_bandOffsets_1 = {};
 131         try {
 132             ImageTypeSpecifier.createInterleaved
 133                 (cs, bad_bandOffsets_1, dataType, hasAlpha, isAlphaPremultiplied);
 134             fail("Failed to get IAE!");
 135         } catch (IllegalArgumentException e) {
 136         }
 137     }
 138 
 139     public static void createBandedTest() {
 140         ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
 141         int[] bankIndices = {0, 100, 1000, 10000};
 142         int[] bandOffsets = {0, 100, 1000, 10000};
 143         int dataType = 0;
 144         boolean hasAlpha = true;
 145         boolean isAlphaPremultiplied = true;
 146 
 147         try {
 148             ImageTypeSpecifier.createBanded(null, bankIndices, bandOffsets,
 149                 dataType, hasAlpha, isAlphaPremultiplied);
 150             fail("Failed to get IAE!");
 151         } catch (IllegalArgumentException e) {
 152         }
 153 
 154         int[] bad_bankIndices = {};
 155         int[] bad_bandOffsets = {};
 156         try {
 157             ImageTypeSpecifier.createBanded(cs, bad_bankIndices, bad_bandOffsets,
 158                 dataType, hasAlpha, isAlphaPremultiplied);
 159             fail("Failed to get IAE!");
 160         } catch (IllegalArgumentException e) {
 161         }
 162 
 163         try {
 164             ImageTypeSpecifier.createBanded(cs, bankIndices, bandOffsets,
 165                 99999, hasAlpha, isAlphaPremultiplied);
 166             fail("Failed to get IAE!");
 167         } catch (IllegalArgumentException e) {
 168         }
 169     }
 170 
 171     public static void createGrayscaleTest() {
 172         int bits = 8;
 173         int dataType = DataBuffer.TYPE_BYTE;
 174         boolean isSigned = true;
 175         // testcase 1
 176         try {
 177             ImageTypeSpecifier.createGrayscale(100, dataType, isSigned);
 178             fail("Failed to get IAE!");
 179         } catch (IllegalArgumentException e) {
 180         }
 181 
 182         try {
 183             ImageTypeSpecifier.createGrayscale(10, dataType, isSigned);
 184             fail("Failed to get IAE!");
 185         } catch (IllegalArgumentException e) {
 186         }
 187 
 188         try {
 189             ImageTypeSpecifier.createGrayscale(bits, 100, isSigned);
 190             fail("Failed to get IAE!");
 191         } catch (IllegalArgumentException e) {
 192         }
 193    }
 194 
 195    public static void createIndexedTest() {
 196         byte[] redLUT = {0};
 197         byte[] greenLUT = {0};
 198         byte[] blueLUT = {0};
 199         byte[] alphaLUT = {0};
 200         int bits = 8;
 201         int dataType = DataBuffer.TYPE_BYTE;
 202 
 203         try {
 204             ImageTypeSpecifier.createIndexed(redLUT, greenLUT,
 205                 blueLUT, alphaLUT, 0, dataType);
 206             fail("Failed to get IAE!");
 207         } catch (IllegalArgumentException e) {
 208         }
 209 
 210         try {
 211             ImageTypeSpecifier.createIndexed(redLUT, greenLUT,
 212                 blueLUT, alphaLUT, 17, dataType);
 213             fail("Failed to get IAE!");
 214         } catch (IllegalArgumentException e) {
 215         }
 216 
 217         try {
 218             ImageTypeSpecifier.createIndexed(redLUT, greenLUT,
 219                 blueLUT, alphaLUT, 10, dataType);
 220             fail("Failed to get IAE!");
 221         } catch (IllegalArgumentException e) {
 222         }
 223 
 224         byte[] greenLUT_4 = {};
 225         try {
 226             ImageTypeSpecifier.createIndexed(redLUT, greenLUT_4,
 227                 blueLUT, alphaLUT, bits, dataType);
 228             fail("Failed to get IAE!");
 229         } catch (IllegalArgumentException e) {
 230         }
 231 
 232         byte[] redLUT_5 = {};
 233         try {
 234             ImageTypeSpecifier.createIndexed(redLUT_5, greenLUT,
 235                 blueLUT, alphaLUT, bits, dataType);
 236             fail("Failed to get IAE!");
 237         } catch (IllegalArgumentException e) {
 238         }
 239 
 240         byte[] alphaLUT_6 = {};
 241         try {
 242             ImageTypeSpecifier.createIndexed(redLUT, greenLUT,
 243                 blueLUT, alphaLUT_6 , bits, dataType);
 244             fail("Failed to get IAE!");
 245         } catch (IllegalArgumentException e) {
 246         }
 247 
 248         try {
 249             ImageTypeSpecifier.createIndexed(redLUT, greenLUT,
 250                 blueLUT, alphaLUT , bits, 100);
 251             fail("Failed to get IAE!");
 252         } catch (IllegalArgumentException e) {
 253         }
 254     }
 255 
 256     private static void test4430991() {
 257         ImageTypeSpecifier itspecifier;
 258 
 259         itspecifier = ImageTypeSpecifier.createFromBufferedImageType
 260             (BufferedImage.TYPE_INT_RGB);
 261 
 262         try {
 263             itspecifier.createBufferedImage(Integer.MAX_VALUE,
 264                                             Integer.MAX_VALUE);
 265             fail("Failed to get IAE!");
 266         } catch (IllegalArgumentException e) {
 267         }
 268 
 269         try {
 270             itspecifier.getSampleModel(Integer.MAX_VALUE, Integer.MAX_VALUE);
 271             fail("Failed to get IAE!");
 272         } catch (IllegalArgumentException e) {
 273         }
 274     }
 275 
 276     private static void test4430993() {
 277         ImageTypeSpecifier itspecifier;
 278 
 279         int bits = 32;
 280         int rmask = 0x00ff0000;
 281         int gmask = 0x0000ff00;
 282         int bmask = 0x000000ff;
 283         ColorModel dcm = new java.awt.image.DirectColorModel
 284             (bits, rmask, gmask, bmask);
 285         int[] bandOffsets = new int[2];
 286         bandOffsets[1] = 1;
 287         SampleModel sm = new java.awt.image.ComponentSampleModel
 288             (DataBuffer.TYPE_SHORT, 1, 1, 2, 2, bandOffsets);
 289 
 290         try {
 291             itspecifier = new ImageTypeSpecifier(dcm, sm);
 292             fail("Failed to get IAE!");
 293         } catch (IllegalArgumentException e) {
 294         }
 295     }
 296 
 297     public static void main(String[] args) {
 298         try {
 299             test4429934();
 300             test4429950();
 301             test4430991();
 302             test4430993();
 303         } catch (RuntimeException e) {
 304             throw e;
 305         } catch (Exception e) {
 306             e.printStackTrace();
 307             System.out.println("Unexpected exception: " + e);
 308         }
 309     }
 310 }