--- /dev/null 2017-05-19 18:26:29.000000000 -0700 +++ new/test/javax/imageio/spi/SpiTest.java 2017-05-19 18:26:29.000000000 -0700 @@ -0,0 +1,390 @@ +/* + * 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(); + } +}