| /* |
| * Copyright (c) 2001, 2017, 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 4395376 |
| * @summary Performs various sanity checks on Spi class constructors and get |
| * methods |
| */ |
| |
| import java.util.Iterator; |
| import java.util.Locale; |
| |
| import javax.imageio.ImageReader; |
| import javax.imageio.ImageTypeSpecifier; |
| import javax.imageio.ImageWriter; |
| import javax.imageio.spi.IIORegistry; |
| import javax.imageio.spi.IIOServiceProvider; |
| import javax.imageio.spi.ImageReaderSpi; |
| import javax.imageio.spi.ImageReaderWriterSpi; |
| import javax.imageio.spi.ImageWriterSpi; |
| import javax.imageio.spi.ServiceRegistry; |
| |
| public class SpiTest { |
| |
| String vendorName = null; |
| String version = null; |
| String[] names = null; |
| String[] suffixes = null; |
| String[] MIMETypes = null; |
| String readerClassName = null; |
| String writerClassName = null; |
| Class[] inputTypes = null; |
| Class[] outputTypes = null; |
| String[] writerSpiNames = null; |
| String[] readerSpiNames = null; |
| String nativeStreamMetadataFormatName = null; |
| String nativeStreamMetadataFormatClassName = null; |
| String[] extraStreamMetadataFormatNames = null; |
| String[] extraStreamMetadataFormatClassNames = null; |
| String nativeImageMetadataFormatName = null; |
| String nativeImageMetadataFormatClassName = null; |
| String[] extraImageMetadataFormatNames = null; |
| String[] extraImageMetadataFormatClassNames = null; |
| |
| private void error(String message) { |
| // System.out.println("Error: " + message); |
| throw new RuntimeException(message); |
| } |
| |
| private void testSpi(IIOServiceProvider spi) { |
| if (spi.getVendorName() == null) { |
| error(spi + " getVendorName == null!"); |
| } |
| if (spi.getVersion() == null) { |
| error(spi + " getVersion == null!"); |
| } |
| } |
| |
| private void testSpi(ImageReaderWriterSpi spi) { |
| testSpi((IIOServiceProvider)spi); |
| if (spi.getFormatNames() == null) { |
| error("spi.getFormatNames == null!"); |
| } |
| String[] suffixes = spi.getFileSuffixes(); |
| if (suffixes != null && suffixes.length == 0) { |
| error("suffixes.length == 0!"); |
| } |
| String[] MIMETypes = spi.getMIMETypes(); |
| if (MIMETypes != null && MIMETypes.length == 0) { |
| error("MIMETypes.length == 0!"); |
| } |
| if (spi.getPluginClassName() == null) { |
| error("spi.getPluginClassName == null!"); |
| } |
| String[] extraStreamMetadataFormatNames = |
| spi.getExtraStreamMetadataFormatNames(); |
| if (extraStreamMetadataFormatNames != null && |
| extraStreamMetadataFormatNames.length == 0) { |
| error("extraStreamMetadataFormatNames.length == 0!"); |
| } |
| String[] extraImageMetadataFormatNames = |
| spi.getExtraImageMetadataFormatNames(); |
| if (extraImageMetadataFormatNames != null && |
| extraImageMetadataFormatNames.length == 0) { |
| error("extraImageMetadataFormatNames.length == 0!"); |
| } |
| } |
| |
| public void testSpi(ImageReaderSpi spi) { |
| testSpi((ImageReaderWriterSpi)spi); |
| Class[] inputTypes = spi.getInputTypes(); |
| if (inputTypes == null) { |
| error("inputTypes == null!"); |
| } |
| if (inputTypes.length == 0) { |
| error("inputTypes.length == 0!"); |
| } |
| String[] writerSpiNames = spi.getImageWriterSpiNames(); |
| if (writerSpiNames != null && writerSpiNames.length == 0) { |
| error("writerSpiNames.length == 0!"); |
| } |
| } |
| |
| public void testSpi(ImageWriterSpi spi) { |
| testSpi((ImageReaderWriterSpi)spi); |
| Class[] outputTypes = spi.getOutputTypes(); |
| if (outputTypes == null) { |
| error("outputTypes == null!"); |
| } |
| if (outputTypes.length == 0) { |
| error("outputTypes.length == 0!"); |
| } |
| String[] readerSpiNames = spi.getImageReaderSpiNames(); |
| if (readerSpiNames != null && readerSpiNames.length == 0) { |
| error("readerSpiNames.length == 0!"); |
| } |
| } |
| |
| private void resetConstructorArguments() { |
| vendorName = null; |
| version = null; |
| names = null; |
| suffixes = null; |
| MIMETypes = null; |
| readerClassName = null; |
| inputTypes = null; |
| outputTypes = null; |
| writerSpiNames = null; |
| readerSpiNames = null; |
| nativeStreamMetadataFormatName = null; |
| nativeStreamMetadataFormatClassName = null; |
| extraStreamMetadataFormatNames = null; |
| extraStreamMetadataFormatClassNames = null; |
| nativeImageMetadataFormatName = null; |
| nativeImageMetadataFormatClassName = null; |
| extraImageMetadataFormatNames = null; |
| extraImageMetadataFormatClassNames = null; |
| } |
| |
| private ImageReaderSpi constructImageReaderSpi() { |
| return new ImageReaderSpi(vendorName, |
| version, |
| names, |
| suffixes, |
| MIMETypes, |
| readerClassName, |
| inputTypes, |
| writerSpiNames, |
| false, |
| nativeStreamMetadataFormatName, |
| nativeStreamMetadataFormatClassName, |
| extraStreamMetadataFormatNames, |
| extraStreamMetadataFormatClassNames, |
| false, |
| nativeImageMetadataFormatName, |
| nativeImageMetadataFormatClassName, |
| extraImageMetadataFormatNames, |
| extraImageMetadataFormatClassNames) { |
| |
| public String getDescription(Locale locale) { |
| return null; |
| } |
| |
| public boolean canDecodeInput(Object source) { |
| return false; |
| } |
| |
| public ImageReader createReaderInstance(Object extension) { |
| return null; |
| } |
| }; |
| } |
| |
| private ImageWriterSpi constructImageWriterSpi() { |
| return new ImageWriterSpi(vendorName, |
| version, |
| names, |
| suffixes, |
| MIMETypes, |
| writerClassName, |
| outputTypes, |
| readerSpiNames, |
| false, |
| nativeStreamMetadataFormatName, |
| nativeStreamMetadataFormatClassName, |
| extraStreamMetadataFormatNames, |
| extraStreamMetadataFormatClassNames, |
| false, |
| nativeImageMetadataFormatName, |
| nativeImageMetadataFormatClassName, |
| extraImageMetadataFormatNames, |
| extraImageMetadataFormatClassNames) { |
| |
| public String getDescription(Locale locale) { |
| return null; |
| } |
| |
| public boolean canEncodeImage(ImageTypeSpecifier type) { |
| return false; |
| } |
| |
| public ImageWriter createWriterInstance(Object extension) { |
| return null; |
| } |
| }; |
| } |
| |
| private void checkImageReaderSpiConstructor(boolean shouldFail) { |
| boolean gotIAE = false; |
| try { |
| constructImageReaderSpi(); |
| } catch (Exception e) { |
| if (!(e instanceof IllegalArgumentException)) { |
| error("Got exception " + e); |
| } else { |
| gotIAE = true; |
| } |
| } |
| if (gotIAE != shouldFail) { |
| if (gotIAE) { |
| error("ImageReaderSpi constructor threw an IAE!"); |
| } else { |
| error("ImageReaderSpi constructor didn't throw an IAE!"); |
| } |
| } |
| } |
| |
| private void checkImageWriterSpiConstructor(boolean shouldFail) { |
| boolean gotIAE = false; |
| try { |
| constructImageWriterSpi(); |
| } catch (Exception e) { |
| if (!(e instanceof IllegalArgumentException)) { |
| error("Got exception " + e); |
| } else { |
| gotIAE = true; |
| } |
| } |
| if (gotIAE != shouldFail) { |
| if (gotIAE) { |
| error("ImageWriterSpi constructor threw an IAE!"); |
| } else { |
| error("ImageWriterSpi constructor didn't throw an IAE!"); |
| } |
| } |
| } |
| |
| public void testImageReaderSpiConstructor() { |
| resetConstructorArguments(); |
| |
| checkImageReaderSpiConstructor(true); |
| vendorName = "My Vendor"; |
| checkImageReaderSpiConstructor(true); |
| version = "My Version"; |
| checkImageReaderSpiConstructor(true); |
| names = new String[0]; |
| checkImageReaderSpiConstructor(true); |
| names = new String[1]; |
| names[0] = "My Format Name"; |
| checkImageReaderSpiConstructor(true); |
| readerClassName = "com.mycompany.Reader"; |
| checkImageReaderSpiConstructor(true); |
| inputTypes = new Class[0]; |
| checkImageReaderSpiConstructor(true); |
| inputTypes = new Class[1]; |
| inputTypes[0] = Object.class; |
| // Now it should work |
| checkImageReaderSpiConstructor(false); |
| |
| // Test normalization of zero-length arrays |
| suffixes = new String[0]; |
| MIMETypes = new String[0]; |
| writerSpiNames = new String[0]; |
| extraStreamMetadataFormatNames = new String[0]; |
| extraImageMetadataFormatNames = new String[0]; |
| |
| ImageReaderSpi spi = constructImageReaderSpi(); |
| if (spi.getFileSuffixes() != null) { |
| error("Failed to normalize suffixes!"); |
| } |
| if (spi.getMIMETypes() != null) { |
| error("Failed to normalize MIMETypes!"); |
| } |
| if (spi.getImageWriterSpiNames() != null) { |
| error("Failed to normalize writerSpiNames!"); |
| } |
| if (spi.getExtraStreamMetadataFormatNames() != null) { |
| error("Failed to normalize extraStreamMetadataFormatNames!"); |
| } |
| if (spi.getExtraImageMetadataFormatNames() != null) { |
| error("Failed to normalize extraImageMetadataFormatNames!"); |
| } |
| } |
| |
| public void testImageWriterSpiConstructor() { |
| resetConstructorArguments(); |
| |
| checkImageWriterSpiConstructor(true); |
| vendorName = "My Vendor"; |
| checkImageWriterSpiConstructor(true); |
| version = "My Version"; |
| checkImageWriterSpiConstructor(true); |
| names = new String[0]; |
| checkImageWriterSpiConstructor(true); |
| names = new String[1]; |
| names[0] = "My Format Name"; |
| checkImageWriterSpiConstructor(true); |
| writerClassName = "com.mycompany.Writer"; |
| checkImageWriterSpiConstructor(true); |
| outputTypes = new Class[0]; |
| checkImageWriterSpiConstructor(true); |
| outputTypes = new Class[1]; |
| outputTypes[0] = Object.class; |
| // Now it should work |
| checkImageWriterSpiConstructor(false); |
| |
| // Test normalization of zero-length arrays |
| suffixes = new String[0]; |
| MIMETypes = new String[0]; |
| readerSpiNames = new String[0]; |
| extraStreamMetadataFormatNames = new String[0]; |
| extraStreamMetadataFormatClassNames = new String[0]; |
| extraImageMetadataFormatNames = new String[0]; |
| extraImageMetadataFormatClassNames = new String[0]; |
| |
| ImageWriterSpi spi = constructImageWriterSpi(); |
| if (spi.getFileSuffixes() != null) { |
| error("Failed to normalize suffixes!"); |
| } |
| if (spi.getMIMETypes() != null) { |
| error("Failed to normalize MIMETypes!"); |
| } |
| if (spi.getImageReaderSpiNames() != null) { |
| error("Failed to normalize readerSpiNames!"); |
| } |
| if (spi.getExtraStreamMetadataFormatNames() != null) { |
| error("Failed to normalize extraStreamMetadataFormatNames!"); |
| } |
| if (spi.getExtraImageMetadataFormatNames() != null) { |
| error("Failed to normalize extraImageMetadataFormatNames!"); |
| } |
| } |
| |
| public SpiTest() { |
| testImageReaderSpiConstructor(); |
| testImageWriterSpiConstructor(); |
| |
| ServiceRegistry registry = IIORegistry.getDefaultInstance(); |
| Iterator readers = registry.getServiceProviders(ImageReaderSpi.class, |
| false); |
| while (readers.hasNext()) { |
| ImageReaderSpi rspi = (ImageReaderSpi)readers.next(); |
| System.out.println("*** Testing " + rspi.getClass().getName()); |
| testSpi(rspi); |
| } |
| |
| Iterator writers = registry.getServiceProviders(ImageWriterSpi.class, |
| false); |
| while (writers.hasNext()) { |
| ImageWriterSpi wspi = (ImageWriterSpi)writers.next(); |
| System.out.println("*** Testing " + wspi.getClass().getName()); |
| testSpi(wspi); |
| } |
| } |
| |
| public static void main(String[] args) { |
| new SpiTest(); |
| } |
| } |