diff -r 4ebc2e2fb97c -r 71c04702a3d5 test/jdk/javax/imageio/ReadAbortTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/jdk/javax/imageio/ReadAbortTest.java	Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,181 @@
+/*
+ * 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     4924727
+ * @summary Test verifies that if we call ImageReader.abort() in
+ *          IIOReadProgressListener.imageStarted() or
+ *          IIOReadProgressListener.imageProgress() are we
+ *          calling IIOReadProgressListener.readAborted() for all readers.
+ * @run     main ReadAbortTest
+ */
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.util.Iterator;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReader;
+import javax.imageio.event.IIOReadProgressListener;
+import javax.imageio.stream.ImageInputStream;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.nio.file.Files;
+
+public class ReadAbortTest implements IIOReadProgressListener {
+
+    ImageReader reader = null;
+    ImageInputStream iis = 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 ReadAbortTest(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("."));
+            ImageIO.write(bimg, format, file);
+            ImageInputStream iis = ImageIO.createImageInputStream(file);
+
+            Iterator iter = ImageIO.getImageReaders(iis);
+            while (iter.hasNext()) {
+                reader = (ImageReader) iter.next();
+                break;
+            }
+            reader.setInput(iis);
+            reader.addIIOReadProgressListener(this);
+
+            // Abort reading in IIOReadProgressListener.imageStarted().
+            startAbort = true;
+            bimg = reader.read(0);
+            startAbort = false;
+
+            // Abort reading in IIOReadProgressListener.imageProgress().
+            progressAbort = true;
+            bimg = reader.read(0);
+            progressAbort = false;
+
+            iis.close();
+            /*
+             * All abort requests from imageStarted,imageProgress and
+             * imageComplete from IIOReadProgressListener should be reached
+             * otherwise throw RuntimeException.
+             */
+            if (!(startAborted
+                    && progressAborted)) {
+                throw new RuntimeException("All IIOReadProgressListener abort"
+                        + " requests are not processed for format "
+                        + format);
+            }
+        } catch (Exception e) {
+            throw e;
+        } finally {
+            Files.delete(file.toPath());
+        }
+    }
+
+    /*
+     * Abstract methods that we need to implement from
+     * IIOReadProgressListener, and relevant for this test case.
+     */
+    @Override
+    public void imageStarted(ImageReader source, int imageIndex) {
+        System.out.println("imageStarted called");
+        if (startAbort) {
+            source.abort();
+        }
+    }
+
+    @Override
+    public void imageProgress(ImageReader source, float percentageDone) {
+        System.out.println("imageProgress called");
+        if (progressAbort) {
+            source.abort();
+        }
+    }
+
+    @Override
+    public void readAborted(ImageReader source) {
+        System.out.println("readAborted called");
+        // Verify IIOReadProgressListener.imageStarted() abort request.
+        if (startAbort) {
+            System.out.println("imageStarted aborted ");
+            startAborted = true;
+        }
+
+        // Verify IIOReadProgressListener.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 ReadAbortTest(format);
+        }
+    }
+
+    /*
+     * Remaining abstract methods that we need to implement from
+     * IIOReadProgressListener, but not relevant for this test case.
+     */
+    @Override
+    public void imageComplete(ImageReader source) {
+    }
+
+    @Override
+    public void sequenceStarted(ImageReader reader, int i) {
+    }
+
+    @Override
+    public void sequenceComplete(ImageReader reader) {
+    }
+
+    @Override
+    public void thumbnailStarted(ImageReader reader, int i, int i1) {
+    }
+
+    @Override
+    public void thumbnailProgress(ImageReader reader, float f) {
+    }
+
+    @Override
+    public void thumbnailComplete(ImageReader reader) {
+    }
+}
+