464 lines
17 KiB
Java
464 lines
17 KiB
Java
/*
|
|
* Copyright (c) 2012, 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 4929170
|
|
* @summary Tests that user-supplied IIOMetadata implementations loaded by
|
|
* system class loader (i.e. corresponding classes are available via
|
|
* classpath) is able to load correspnding IIOMetadataFormat
|
|
* implementations.
|
|
* @run main UserPluginMetadataFormatTest
|
|
*/
|
|
|
|
import java.awt.Rectangle;
|
|
import java.awt.image.BufferedImage;
|
|
import java.io.IOException;
|
|
import java.io.ByteArrayInputStream;
|
|
import java.util.Iterator;
|
|
import java.util.ListResourceBundle;
|
|
import java.util.Locale;
|
|
import java.util.MissingResourceException;
|
|
import java.util.Objects;
|
|
import java.util.Vector;
|
|
import javax.imageio.ImageIO;
|
|
import javax.imageio.ImageReader;
|
|
import javax.imageio.ImageReadParam;
|
|
import javax.imageio.IIOException;
|
|
import javax.imageio.ImageTypeSpecifier;
|
|
import javax.imageio.event.IIOReadWarningListener;
|
|
import javax.imageio.metadata.IIOMetadata;
|
|
import javax.imageio.metadata.IIOMetadataFormat;
|
|
import javax.imageio.metadata.IIOMetadataFormatImpl;
|
|
import javax.imageio.metadata.IIOInvalidTreeException;
|
|
import javax.imageio.spi.ImageReaderSpi;
|
|
import org.w3c.dom.Node;
|
|
|
|
public class UserPluginMetadataFormatTest implements MetadataTest {
|
|
|
|
public static void main(String[] argv) throws IOException {
|
|
new UserPluginMetadataFormatTest().doTest();
|
|
}
|
|
|
|
public void doTest() throws IOException {
|
|
|
|
DummyImageReaderImpl reader;
|
|
|
|
reader = new DummyImageReaderImpl(new DummyImageReaderSpiImpl());
|
|
|
|
byte[] data = new byte[1024];
|
|
ByteArrayInputStream bais =
|
|
new ByteArrayInputStream(data);
|
|
|
|
reader.setInput(ImageIO.createImageInputStream(bais));
|
|
IIOMetadata metadata = reader.getImageMetadata(1);
|
|
if(metadata == null) {
|
|
throw new RuntimeException("IIOMetada is NULL");
|
|
}
|
|
|
|
String[] formatNames = metadata.getMetadataFormatNames();
|
|
|
|
for(int j=0; j<formatNames.length; j++) {
|
|
|
|
String formatName = formatNames[j];
|
|
System.out.println("\nFormat Names : " + formatName);
|
|
|
|
try {
|
|
IIOMetadataFormat metadataFormat =
|
|
metadata.getMetadataFormat(formatName);
|
|
System.out.println(" Class Name " +
|
|
metadataFormat.getClass());
|
|
} catch(IllegalStateException ise) {
|
|
Throwable t = ise;
|
|
t.printStackTrace();
|
|
while(t.getCause() != null) {
|
|
t = t.getCause();
|
|
t.printStackTrace();
|
|
}
|
|
// test failed!
|
|
// stop applet!
|
|
System.out.println("Test faied.");
|
|
throw new RuntimeException("Test failed.", ise);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class DummyImageReaderImpl extends ImageReader {
|
|
|
|
public DummyImageReaderImpl(ImageReaderSpi originatingProvider) {
|
|
super(originatingProvider);
|
|
}
|
|
|
|
public int getNumImages(boolean allowSearch) throws IOException {
|
|
return 5;
|
|
}
|
|
|
|
public int getWidth(int imageIndex) throws IOException {
|
|
if (input == null)
|
|
throw new IllegalStateException();
|
|
Objects.checkIndex(imageIndex, 5);
|
|
|
|
return 10;
|
|
}
|
|
|
|
public int getHeight(int imageIndex) throws IOException {
|
|
if (input == null)
|
|
throw new IllegalStateException();
|
|
Objects.checkIndex(imageIndex, 5);
|
|
|
|
return 15;
|
|
}
|
|
|
|
public Iterator getImageTypes(int imageIndex) throws IOException {
|
|
if (input == null)
|
|
throw new IllegalStateException();
|
|
Objects.checkIndex(imageIndex, 5);
|
|
|
|
Vector imageTypes = new Vector();
|
|
imageTypes.add(ImageTypeSpecifier.createFromBufferedImageType
|
|
(BufferedImage.TYPE_BYTE_GRAY ));
|
|
return imageTypes.iterator();
|
|
}
|
|
|
|
public IIOMetadata getStreamMetadata() throws IOException {
|
|
return new DummyIIOMetadataImpl(true, null, null, null, null);
|
|
}
|
|
|
|
public IIOMetadata getImageMetadata(int imageIndex) throws IOException {
|
|
|
|
if (input == null)
|
|
throw new IllegalStateException();
|
|
Objects.checkIndex(imageIndex, 5);
|
|
if (seekForwardOnly) {
|
|
if (imageIndex < minIndex)
|
|
throw new IndexOutOfBoundsException();
|
|
minIndex = imageIndex;
|
|
}
|
|
System.out.println("Current format class name " + DummyIIOMetadataFormatImpl.class.getName());
|
|
return new DummyIIOMetadataImpl(true,
|
|
DummyIIOMetadataFormatImpl.nativeMetadataFormatName,
|
|
DummyIIOMetadataFormatImpl.class.getName(),
|
|
null, null);
|
|
}
|
|
|
|
|
|
public BufferedImage read(int imageIndex, ImageReadParam param)
|
|
throws IOException {
|
|
if (input == null)
|
|
throw new IllegalStateException();
|
|
Objects.checkIndex(imageIndex, 5);
|
|
if (seekForwardOnly) {
|
|
if (imageIndex < minIndex)
|
|
throw new IndexOutOfBoundsException();
|
|
minIndex = imageIndex;
|
|
}
|
|
|
|
return getDestination(param, getImageTypes(imageIndex), 10, 15);
|
|
}
|
|
|
|
// protected methods - now public
|
|
|
|
public boolean abortRequested() {
|
|
return super.abortRequested();
|
|
}
|
|
|
|
public void clearAbortRequest() {
|
|
super.clearAbortRequest();
|
|
}
|
|
|
|
public void processImageComplete() {
|
|
super.processImageComplete();
|
|
}
|
|
|
|
public void processImageProgress(float percentageDone) {
|
|
super.processImageProgress(percentageDone);
|
|
}
|
|
|
|
public void processImageStarted(int imageIndex) {
|
|
super.processImageStarted(imageIndex);
|
|
}
|
|
|
|
public void processImageUpdate(BufferedImage theImage,
|
|
int minX,
|
|
int minY,
|
|
int width,
|
|
int height,
|
|
int periodX,
|
|
int periodY,
|
|
int[] bands) {
|
|
super.processImageUpdate(theImage,
|
|
minX,
|
|
minY,
|
|
width,
|
|
height,
|
|
periodX,
|
|
periodY,
|
|
bands);
|
|
}
|
|
|
|
public void processPassComplete(BufferedImage theImage) {
|
|
super. processPassComplete(theImage);
|
|
}
|
|
|
|
public void processPassStarted(BufferedImage theImage,
|
|
int pass, int minPass,
|
|
int maxPass,
|
|
int minX,
|
|
int minY,
|
|
int periodX,
|
|
int periodY,
|
|
int[] bands) {
|
|
super.processPassStarted(theImage,
|
|
pass,
|
|
minPass,
|
|
maxPass,
|
|
minX,
|
|
minY,
|
|
periodX,
|
|
periodY,
|
|
bands);
|
|
}
|
|
|
|
public void processReadAborted() {
|
|
super.processReadAborted();
|
|
}
|
|
|
|
public void processSequenceComplete() {
|
|
super.processSequenceComplete();
|
|
}
|
|
|
|
public void processSequenceStarted(int minIndex) {
|
|
super.processSequenceStarted(minIndex);
|
|
}
|
|
|
|
public void processThumbnailComplete() {
|
|
super.processThumbnailComplete();
|
|
}
|
|
|
|
public void processThumbnailPassComplete(BufferedImage theThumbnail) {
|
|
super.processThumbnailPassComplete(theThumbnail);
|
|
}
|
|
|
|
public void processThumbnailPassStarted(BufferedImage theThumbnail,
|
|
int pass,
|
|
int minPass,
|
|
int maxPass,
|
|
int minX,
|
|
int minY,
|
|
int periodX,
|
|
int periodY,
|
|
int[] bands) {
|
|
super.processThumbnailPassStarted(theThumbnail,
|
|
pass,
|
|
minPass,
|
|
maxPass,
|
|
minX,
|
|
minY,
|
|
periodX,
|
|
periodY,
|
|
bands);
|
|
}
|
|
|
|
public void processThumbnailProgress(float percentageDone) {
|
|
super.processThumbnailProgress(percentageDone);
|
|
}
|
|
|
|
public void processThumbnailStarted(int imageIndex, int thumbnailIndex) {
|
|
super.processThumbnailStarted(imageIndex, thumbnailIndex);
|
|
}
|
|
|
|
public void processThumbnailUpdate(BufferedImage theThumbnail,
|
|
int minX,
|
|
int minY,
|
|
int width,
|
|
int height,
|
|
int periodX,
|
|
int periodY,
|
|
int[] bands) {
|
|
super.processThumbnailUpdate(theThumbnail,
|
|
minX,
|
|
minY,
|
|
width,
|
|
height,
|
|
periodX,
|
|
periodY,
|
|
bands);
|
|
}
|
|
|
|
public void processWarningOccurred(String warning) {
|
|
super.processWarningOccurred(warning);
|
|
}
|
|
|
|
|
|
|
|
public static Rectangle getSourceRegion(ImageReadParam param,
|
|
int srcWidth,
|
|
int srcHeight) {
|
|
return ImageReader.getSourceRegion(param, srcWidth, srcHeight);
|
|
}
|
|
|
|
public static void computeRegions(ImageReadParam param,
|
|
int srcWidth,
|
|
int srcHeight,
|
|
BufferedImage image,
|
|
Rectangle srcRegion,
|
|
Rectangle destRegion) {
|
|
ImageReader.computeRegions(param,
|
|
srcWidth,
|
|
srcHeight,
|
|
image,
|
|
srcRegion,
|
|
destRegion);
|
|
}
|
|
|
|
public static void checkReadParamBandSettings(ImageReadParam param,
|
|
int numSrcBands,
|
|
int numDstBands) {
|
|
ImageReader.checkReadParamBandSettings( param,
|
|
numSrcBands,
|
|
numDstBands);
|
|
}
|
|
|
|
public static BufferedImage getDestination(ImageReadParam param,
|
|
Iterator imageTypes,
|
|
int width,
|
|
int height)
|
|
throws IIOException {
|
|
return ImageReader.getDestination(param,
|
|
imageTypes,
|
|
width,
|
|
height);
|
|
}
|
|
|
|
public void setAvailableLocales(Locale[] locales) {
|
|
if (locales == null || locales.length == 0)
|
|
availableLocales = null;
|
|
else
|
|
availableLocales = (Locale[])locales.clone();
|
|
}
|
|
|
|
public void processWarningOccurred(String baseName, String keyword) {
|
|
super.processWarningOccurred(baseName, keyword);
|
|
}
|
|
}
|
|
|
|
public static class DummyIIOMetadataFormatImpl
|
|
extends IIOMetadataFormatImpl {
|
|
public static String nativeMetadataFormatName =
|
|
"javax_imageio_dummy_1.0";
|
|
|
|
private static IIOMetadataFormat instance = null;
|
|
|
|
|
|
private DummyIIOMetadataFormatImpl() {
|
|
super(DummyIIOMetadataFormatImpl.nativeMetadataFormatName,
|
|
CHILD_POLICY_SOME);
|
|
}
|
|
|
|
public boolean canNodeAppear(String elementName,
|
|
ImageTypeSpecifier imageType) {
|
|
return false;
|
|
}
|
|
|
|
public static synchronized IIOMetadataFormat getInstance() {
|
|
if (instance == null) {
|
|
instance = new DummyIIOMetadataFormatImpl();
|
|
}
|
|
return instance;
|
|
}
|
|
}
|
|
|
|
public static class DummyIIOMetadataImpl extends IIOMetadata {
|
|
|
|
public DummyIIOMetadataImpl() {
|
|
super();
|
|
}
|
|
|
|
public DummyIIOMetadataImpl(boolean standardMetadataFormatSupported,
|
|
String nativeMetadataFormatName,
|
|
String nativeMetadataFormatClassName,
|
|
String[] extraMetadataFormatNames,
|
|
String[] extraMetadataFormatClassNames) {
|
|
super(standardMetadataFormatSupported,
|
|
nativeMetadataFormatName,
|
|
nativeMetadataFormatClassName,
|
|
extraMetadataFormatNames,
|
|
extraMetadataFormatClassNames);
|
|
}
|
|
|
|
public boolean isReadOnly() {
|
|
return true;
|
|
}
|
|
|
|
public Node getAsTree(String formatName) {
|
|
return null;
|
|
}
|
|
|
|
public void mergeTree(String formatName, Node root)
|
|
throws IIOInvalidTreeException {
|
|
throw new IllegalStateException();
|
|
}
|
|
|
|
public void reset() {
|
|
throw new IllegalStateException();
|
|
}
|
|
}
|
|
|
|
public static class DummyImageReaderSpiImpl extends ImageReaderSpi {
|
|
|
|
static final String[] names ={ "myformat" };
|
|
|
|
public DummyImageReaderSpiImpl() {
|
|
super("vendorName",
|
|
"version",
|
|
names,
|
|
null,
|
|
null,
|
|
"DummyImageReaderImpl",
|
|
STANDARD_INPUT_TYPE,
|
|
null,
|
|
true,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
true,
|
|
null,
|
|
null,
|
|
null,
|
|
null);
|
|
}
|
|
public boolean canDecodeInput(Object source)
|
|
throws IOException {
|
|
return true;
|
|
}
|
|
public ImageReader createReaderInstance(Object extension)
|
|
throws IOException {
|
|
return new DummyImageReaderImpl(this);
|
|
}
|
|
public String getDescription(Locale locale) {
|
|
return "DummyImageReaderSpiImpl";
|
|
}
|
|
}
|
|
}
|