--- /dev/null	2016-09-21 11:07:59.981876000 +0530
+++ new/test/javax/imageio/WriteAbortTest.java	2016-09-21 11:13:39.658117999 +0530
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2016, 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     8164931
+ * @summary Test verifies that if we call ImageWriter.abort() in
+ *          IIOWriteProgressListener.imageStarted() or
+ *          IIOWriteProgressListener.imageProgress() are we
+ *          calling IIOWriteProgressListener.readAborted() for all readers.
+ * @run     main WriteAbortTest
+ */
+import java.awt.image.BufferedImage;
+import java.io.File;
+import javax.imageio.ImageIO;
+import javax.imageio.stream.ImageInputStream;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.nio.file.Files;
+import javax.imageio.ImageWriter;
+import javax.imageio.event.IIOWriteProgressListener;
+import javax.imageio.stream.ImageOutputStream;
+
+public class WriteAbortTest implements IIOWriteProgressListener {
+
+    ImageWriter writer = null;
+    ImageOutputStream ios = null;
+    BufferedImage bimg = null;
+    File file;
+    boolean startAbort = false;
+    boolean startAborted = false;
+    boolean progressAbort = false;
+    boolean progressAborted = false;
+    Color srccolor = Color.red;
+    int width = 100;
+    int heght = 100;
+
+    public WriteAbortTest(String format) throws Exception {
+        try {
+            System.out.println("Test for format " + format);
+            bimg = new BufferedImage(width, heght,
+                    BufferedImage.TYPE_INT_RGB);
+
+            Graphics2D g = bimg.createGraphics();
+            g.setColor(srccolor);
+            g.fillRect(0, 0, width, heght);
+            g.dispose();
+
+            file = File.createTempFile("src_", "." + format, new File("."));
+            ImageInputStream ios = ImageIO.createImageOutputStream(file);
+
+            ImageWriter writer =
+                    ImageIO.getImageWritersByFormatName(format).next();
+
+            writer.setOutput(ios);
+            writer.addIIOWriteProgressListener(this);
+
+            // Abort writing in IIOWriteProgressListener.imageStarted().
+            startAbort = true;
+            writer.write(bimg);
+            startAbort = false;
+
+            // Abort writing in IIOWriteProgressListener.imageProgress().
+            progressAbort = true;
+            writer.write(bimg);
+            progressAbort = false;
+
+            ios.close();
+            /*
+             * All abort requests from imageStarted,imageProgress
+             * from IIOWriteProgressListener should be reached
+             * otherwise throw RuntimeException.
+             */
+            if (!(startAborted
+                    && progressAborted)) {
+                throw new RuntimeException("All IIOWriteProgressListener abort"
+                        + " requests are not processed for format "
+                        + format);
+            }
+        } finally {
+            Files.delete(file.toPath());
+        }
+    }
+
+    /*
+     * Abstract methods that we need to implement from
+     * IIOWriteProgressListener, and relevant for this test case.
+     */
+    @Override
+    public void imageStarted(ImageWriter source, int imageIndex) {
+        System.out.println("imageStarted called");
+        if (startAbort) {
+            source.abort();
+        }
+    }
+
+    @Override
+    public void imageProgress(ImageWriter source, float percentageDone) {
+        System.out.println("imageProgress called");
+        if (progressAbort) {
+            source.abort();
+        }
+    }
+
+    @Override
+    public void writeAborted(ImageWriter source) {
+        System.out.println("writeAborted called");
+        // Verify IIOWriteProgressListener.imageStarted() abort request.
+        if (startAbort) {
+            System.out.println("imageStarted aborted ");
+            startAborted = true;
+        }
+
+        // Verify IIOWriteProgressListener.imageProgress() abort request.
+        if (progressAbort) {
+            System.out.println("imageProgress aborted ");
+            progressAborted = true;
+        }
+    }
+
+    public static void main(String args[]) throws Exception {
+        final String[] formats = {"bmp", "png", "gif", "jpg", "tif"};
+        for (String format : formats) {
+            new WriteAbortTest(format);
+        }
+    }
+
+    /*
+     * Remaining abstract methods that we need to implement from
+     * IIOWriteProgressListener, but not relevant for this test case.
+     */
+    @Override
+    public void imageComplete(ImageWriter source) {
+    }
+
+    @Override
+    public void thumbnailStarted(ImageWriter source, int imageIndex,
+                                 int thumbnailIndex) {
+    }
+
+    @Override
+    public void thumbnailProgress(ImageWriter source, float percentageDone) {
+    }
+
+    @Override
+    public void thumbnailComplete(ImageWriter source) {
+    }
+}
+