1 /*
   2  * Copyright (c) 2015, 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 import java.awt.Color;
  25 import java.awt.Graphics2D;
  26 import java.awt.image.BufferedImage;
  27 import java.io.File;
  28 import java.io.FileNotFoundException;
  29 import java.io.FileOutputStream;
  30 import java.io.IOException;
  31 import java.util.Iterator;

  32 
  33 import javax.imageio.ImageIO;
  34 import javax.imageio.ImageWriter;
  35 import javax.imageio.event.IIOWriteProgressListener;
  36 import javax.imageio.spi.IIORegistry;
  37 import javax.imageio.spi.ImageWriterSpi;
  38 import javax.imageio.stream.ImageOutputStream;
  39 
  40 import static java.awt.image.BufferedImage.TYPE_BYTE_BINARY;
  41 
  42 /**
  43  * @test
  44  * @bug 4952954
  45  * @summary abortFlag must be cleared for every ImageWriter.write operation
  46  * @author Sergey Bylokhov
  47  */
  48 public final class WriteAfterAbort implements IIOWriteProgressListener {
  49 
  50     private volatile boolean abortFlag = true;
  51     private volatile boolean isAbortCalled;
  52     private volatile boolean isCompleteCalled;
  53     private volatile boolean isProgressCalled;
  54     private volatile boolean isStartedCalled;
  55     private static final int WIDTH = 100;
  56     private static final int HEIGHT = 100;









  57 
  58     private void test(final ImageWriter writer) throws IOException {
  59         // Image initialization
  60         final BufferedImage imageWrite = new BufferedImage(WIDTH, HEIGHT,
  61                                                            TYPE_BYTE_BINARY);
  62         final Graphics2D g = imageWrite.createGraphics();
  63         g.setColor(Color.WHITE);
  64         g.fillRect(0, 0, WIDTH, HEIGHT);
  65         g.dispose();
  66 
  67         // File initialization
  68         final File file = File.createTempFile("temp", ".img");
  69         file.deleteOnExit();
  70         final FileOutputStream fos = new SkipWriteOnAbortOutputStream(file);




  71         final ImageOutputStream ios = ImageIO.createImageOutputStream(fos);
  72         writer.setOutput(ios);
  73         writer.addIIOWriteProgressListener(this);
  74 
  75         // This write will be aborted, and file will not be touched
  76         writer.write(imageWrite);
  77         if (!isStartedCalled) {

  78             throw new RuntimeException("Started should be called");
  79         }
  80         if (!isProgressCalled) {

  81             throw new RuntimeException("Progress should be called");
  82         }
  83         if (!isAbortCalled) {

  84             throw new RuntimeException("Abort should be called");
  85         }
  86         if (isCompleteCalled) {

  87             throw new RuntimeException("Complete should not be called");
  88         }
  89         // Flush aborted data
  90         ios.flush();
  91 
  92         // This write should be completed successfully and the file should
  93         // contain correct image data.
  94         abortFlag = false;
  95         isAbortCalled = false;
  96         isCompleteCalled = false;
  97         isProgressCalled = false;
  98         isStartedCalled = false;
  99         writer.write(imageWrite);
 100 
 101         if (!isStartedCalled) {

 102             throw new RuntimeException("Started should be called");
 103         }
 104         if (!isProgressCalled) {

 105             throw new RuntimeException("Progress should be called");
 106         }
 107         if (isAbortCalled) {

 108             throw new RuntimeException("Abort should not be called");
 109         }
 110         if (!isCompleteCalled) {

 111             throw new RuntimeException("Complete should be called");
 112         }
 113         writer.dispose();
 114         ios.close();
 115 

 116         // Validates content of the file.
 117         final BufferedImage imageRead = ImageIO.read(file);

 118         for (int x = 0; x < WIDTH; ++x) {
 119             for (int y = 0; y < HEIGHT; ++y) {
 120                 if (imageRead.getRGB(x, y) != imageWrite.getRGB(x, y)) {
 121                     throw new RuntimeException("Test failed.");
 122                 }
 123             }
 124         }
 125     }
 126 
 127     public static void main(final String[] args) throws IOException {
 128         final IIORegistry registry = IIORegistry.getDefaultInstance();
 129         final Iterator<ImageWriterSpi> iter = registry.getServiceProviders(
 130                 ImageWriterSpi.class, provider -> true, true);
 131 
 132         // Validates all supported ImageWriters
 133         int numFailures = 0;
 134         while (iter.hasNext()) {
 135             final WriteAfterAbort writeAfterAbort = new WriteAfterAbort();
 136             final ImageWriter writer = iter.next().createWriterInstance();
 137             System.out.println("ImageWriter = " + writer);
 138             try {
 139                 writeAfterAbort.test(writer);
 140             } catch (Exception e) {

 141                 System.err.println("Test failed for \""
 142                     + writer.getOriginatingProvider().getFormatNames()[0]
 143                     + "\" format.");
 144                 numFailures++;
 145             }
 146         }
 147         if (numFailures == 0) {
 148             System.out.println("Test passed.");
 149         } else {
 150             throw new RuntimeException("Test failed.");
 151         }
 152     }
 153 
 154     // Callbacks
 155 
 156     @Override
 157     public void imageComplete(ImageWriter source) {
 158         isCompleteCalled = true;
 159     }
 160 

   1 /*
   2  * Copyright (c) 2015, 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 import java.awt.Color;
  25 import java.awt.Graphics2D;
  26 import java.awt.image.BufferedImage;
  27 import java.io.File;
  28 import java.io.FileNotFoundException;
  29 import java.io.FileOutputStream;
  30 import java.io.IOException;
  31 import java.util.Iterator;
  32 import java.nio.file.Files;
  33 
  34 import javax.imageio.ImageIO;
  35 import javax.imageio.ImageWriter;
  36 import javax.imageio.event.IIOWriteProgressListener;
  37 import javax.imageio.spi.IIORegistry;
  38 import javax.imageio.spi.ImageWriterSpi;
  39 import javax.imageio.stream.ImageOutputStream;
  40 
  41 import static java.awt.image.BufferedImage.TYPE_BYTE_BINARY;
  42 
  43 /**
  44  * @test
  45  * @bug 4952954 8183349
  46  * @summary abortFlag must be cleared for every ImageWriter.write operation
  47  * @run     main/manual WriteAfterAbort
  48  */
  49 public final class WriteAfterAbort implements IIOWriteProgressListener {
  50 
  51     private volatile boolean abortFlag = true;
  52     private volatile boolean isAbortCalled;
  53     private volatile boolean isCompleteCalled;
  54     private volatile boolean isProgressCalled;
  55     private volatile boolean isStartedCalled;
  56     private static final int WIDTH = 100;
  57     private static final int HEIGHT = 100;
  58     private static ImageWriter writer;
  59     private static FileOutputStream fos;
  60     private static File file;
  61 
  62     private void deleteTestFile() throws IOException {
  63         writer.dispose();
  64         fos.close();
  65         Files.delete(file.toPath());
  66     }
  67 
  68     private void test(final ImageWriter writer) throws IOException {
  69         // Image initialization
  70         final BufferedImage imageWrite = new BufferedImage(WIDTH, HEIGHT,
  71                                                            TYPE_BYTE_BINARY);
  72         final Graphics2D g = imageWrite.createGraphics();
  73         g.setColor(Color.WHITE);
  74         g.fillRect(0, 0, WIDTH, HEIGHT);
  75         g.dispose();
  76 
  77         // File initialization
  78         String sep = System.getProperty("file.separator");
  79         String dir = System.getProperty("test.src", ".");
  80         String filePath = dir+sep;
  81         File directory = new File(filePath);
  82         file = File.createTempFile("temp", ".img", directory);
  83         directory.delete();
  84         fos = new SkipWriteOnAbortOutputStream(file);
  85         final ImageOutputStream ios = ImageIO.createImageOutputStream(fos);
  86         writer.setOutput(ios);
  87         writer.addIIOWriteProgressListener(this);
  88 
  89         // This write will be aborted, and file will not be touched
  90         writer.write(imageWrite);
  91         if (!isStartedCalled) {
  92             deleteTestFile();
  93             throw new RuntimeException("Started should be called");
  94         }
  95         if (!isProgressCalled) {
  96             deleteTestFile();
  97             throw new RuntimeException("Progress should be called");
  98         }
  99         if (!isAbortCalled) {
 100             deleteTestFile();
 101             throw new RuntimeException("Abort should be called");
 102         }
 103         if (isCompleteCalled) {
 104             deleteTestFile();
 105             throw new RuntimeException("Complete should not be called");
 106         }
 107         // Flush aborted data
 108         ios.flush();
 109 
 110         // This write should be completed successfully and the file should
 111         // contain correct image data.
 112         abortFlag = false;
 113         isAbortCalled = false;
 114         isCompleteCalled = false;
 115         isProgressCalled = false;
 116         isStartedCalled = false;
 117         writer.write(imageWrite);
 118 
 119         if (!isStartedCalled) {
 120             deleteTestFile();
 121             throw new RuntimeException("Started should be called");
 122         }
 123         if (!isProgressCalled) {
 124             deleteTestFile();
 125             throw new RuntimeException("Progress should be called");
 126         }
 127         if (isAbortCalled) {
 128             deleteTestFile();
 129             throw new RuntimeException("Abort should not be called");
 130         }
 131         if (!isCompleteCalled) {
 132             deleteTestFile();
 133             throw new RuntimeException("Complete should be called");
 134         }


 135 
 136         ios.close();
 137         // Validates content of the file.
 138         final BufferedImage imageRead = ImageIO.read(file);
 139         deleteTestFile();
 140         for (int x = 0; x < WIDTH; ++x) {
 141             for (int y = 0; y < HEIGHT; ++y) {
 142                 if (imageRead.getRGB(x, y) != imageWrite.getRGB(x, y)) {
 143                     throw new RuntimeException("Test failed.");
 144                 }
 145             }
 146         }
 147     }
 148 
 149     public static void main(final String[] args) throws IOException {
 150         final IIORegistry registry = IIORegistry.getDefaultInstance();
 151         final Iterator<ImageWriterSpi> iter = registry.getServiceProviders(
 152                 ImageWriterSpi.class, provider -> true, true);
 153 
 154         // Validates all supported ImageWriters
 155         int numFailures = 0;
 156         while (iter.hasNext()) {
 157             final WriteAfterAbort writeAfterAbort = new WriteAfterAbort();
 158             writer = iter.next().createWriterInstance();
 159             System.out.println("ImageWriter = " + writer);
 160             try {
 161                 writeAfterAbort.test(writer);
 162             } catch (Exception e) {
 163                 writeAfterAbort.deleteTestFile();
 164                 System.err.println("Test failed for \""
 165                     + writer.getOriginatingProvider().getFormatNames()[0]
 166                     + "\" format.");
 167                 numFailures++;
 168             }
 169         }
 170         if (numFailures == 0) {
 171             System.out.println("Test passed.");
 172         } else {
 173             throw new RuntimeException("Test failed.");
 174         }
 175     }
 176 
 177     // Callbacks
 178 
 179     @Override
 180     public void imageComplete(ImageWriter source) {
 181         isCompleteCalled = true;
 182     }
 183