--- /dev/null	2017-05-19 18:25:35.000000000 -0700
+++ new/test/javax/imageio/plugins/bmp/BMPCompressionTest.java	2017-05-19 18:25:34.000000000 -0700
@@ -0,0 +1,433 @@
+/*
+ * Copyright (c) 2003, 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 4641872
+ * @summary Tests writing compression modes of BMP plugin
+ * @modules java.desktop/com.sun.imageio.plugins.bmp
+ */
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Transparency;
+import java.awt.color.ColorSpace;
+import java.awt.image.BufferedImage;
+import java.awt.image.ColorModel;
+import java.awt.image.ComponentColorModel;
+import java.awt.image.DataBuffer;
+import java.awt.image.DirectColorModel;
+import java.awt.image.IndexColorModel;
+import java.awt.image.PixelInterleavedSampleModel;
+import java.awt.image.Raster;
+import java.awt.image.SampleModel;
+import java.awt.image.SinglePixelPackedSampleModel;
+import java.awt.image.WritableRaster;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.imageio.IIOImage;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageReader;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.ImageWriteParam;
+import javax.imageio.ImageWriter;
+import javax.imageio.metadata.IIOMetadata;
+import javax.imageio.plugins.bmp.BMPImageWriteParam;
+import javax.imageio.stream.ImageOutputStream;
+import javax.swing.JComponent;
+import javax.swing.JFrame;
+
+import com.sun.imageio.plugins.bmp.BMPMetadata;
+
+public class BMPCompressionTest {
+
+    static final String format = "BMP";
+
+    public static void main(String[] args) {
+
+        ImageWriter iw = null;
+        Iterator writers = ImageIO.getImageWritersByFormatName(format);
+        if (!writers.hasNext()) {
+            throw new RuntimeException("No available Image writer for "+format);
+        }
+        iw = (ImageWriter)writers.next();
+
+
+        Iterator tests = Test.createTestSet(iw);
+
+        while(tests.hasNext()) {
+
+            Test t = (Test)tests.next();
+            System.out.println(t.getDescription());
+            t.doTest();
+        }
+
+    }
+
+
+    static class Test {
+        static ImageWriter iw;
+        private BufferedImage img;
+        private String description;
+        private BMPImageWriteParam param;
+        private IIOMetadata meta;
+
+
+        public static Iterator createTestSet(ImageWriter w) {
+            List l = new LinkedList();
+
+            Test.iw = w;
+
+            // variate compression types
+            BMPImageWriteParam param = (BMPImageWriteParam)iw.getDefaultWriteParam();
+            param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
+            param.setCompressionType("BI_RGB");
+            if (param.canWriteCompressed()) {
+                String[] cTypes = param.getCompressionTypes();
+                String[] cDescr = param.getCompressionQualityDescriptions();
+                float[] cValues = param.getCompressionQualityValues();
+
+                if (cDescr == null) {
+                    System.out.println("There are no compression quality description!");
+                } else {
+                    for(int i=0; i<cDescr.length; i++) {
+                        System.out.println("Quality[" + i + "]=\""+cDescr[i]+"\"");
+                    }
+                }
+                if (cValues == null) {
+                    System.out.println("There are no compression quality values!");
+                } else {
+                    for(int i=0; i<cValues.length; i++) {
+                        System.out.println("Value["+i+"]=\""+cValues[i]+"\"");
+                    }
+                }
+
+                for(int i=0; i<cTypes.length; i++) {
+                    String compressionType = cTypes[i];
+                    BufferedImage img = null;
+
+                    int type = BufferedImage.TYPE_INT_BGR;
+                    try {
+                        img = createTestImage(type);
+                        if (compressionType.equals("BI_RLE8")) {
+                            img = createTestImage2(8, DataBuffer.TYPE_BYTE);
+                        } else if (compressionType.equals("BI_RLE4")) {
+                            img = createTestImage3(4, DataBuffer.TYPE_BYTE);
+                        } else if (compressionType.equals("BI_BITFIELDS")) {
+                            img = createTestImage4(32);
+                        }
+
+                    } catch (IOException ex) {
+                        throw new RuntimeException("Unable to create test image");
+                    }
+                    BMPImageWriteParam p = (BMPImageWriteParam)iw.getDefaultWriteParam();
+                    System.out.println("Current compression type is \""+cTypes[i]+"\"");
+                    p.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
+                    p.setCompressionType(compressionType);
+
+                    IIOMetadata md = iw.getDefaultImageMetadata(new ImageTypeSpecifier(img), p);
+
+                    l.add( new Test(p, md, img));
+                }
+            }
+            //     }
+            return l.iterator();
+
+        }
+
+        private Test(BMPImageWriteParam p, IIOMetadata md, BufferedImage i) {
+            param = p;
+            meta = md;
+            img = i;
+
+
+            description = "Compression type is " + p.getCompressionType();
+        }
+
+        public String getDescription() {
+            return description;
+        }
+
+        public void doTest() {
+            try {
+                System.out.println(this.getDescription());
+                if (param.getCompressionMode() != ImageWriteParam.MODE_EXPLICIT) {
+                    System.out.println("Warning: compression mode is not MODE_EXPLICIT");
+                }
+                // change metadata according to ImageWriteParam
+                IIOMetadata new_meta = iw.convertImageMetadata(meta, new ImageTypeSpecifier(img), param);
+
+                IIOImage iio_img = new IIOImage(img, null, new_meta);
+
+                ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                ImageOutputStream ios = ImageIO.createImageOutputStream(baos);
+                iw.setOutput(ios);
+                System.out.print("write image...");
+                System.out.println("Current compression Type is \""+param.getCompressionType()+"\"");
+                iw.write(new_meta, iio_img, param);
+                //iw.write(iio_img);
+                System.out.println("OK");
+                System.out.print("read image ... ");
+                ios.flush();
+
+                byte[] ba_image = baos.toByteArray();
+
+                System.out.println("Array length=" + ba_image.length);
+                FileOutputStream fos = new FileOutputStream(new File(param.getCompressionType()+".bmp"));
+                fos.write(ba_image);
+                fos.flush();
+                fos = null;
+                ByteArrayInputStream bais = new ByteArrayInputStream(ba_image);
+
+                ImageReader ir = ImageIO.getImageReader(iw);
+                ir.setInput(ImageIO.createImageInputStream(bais));
+
+                BufferedImage res = ir.read(0);
+                System.out.println("OK");
+
+                if (!param.getCompressionType().equals("BI_JPEG")) {
+                    System.out.print("compare images ... ");
+                    boolean r = compare(img,res);
+                    System.out.println(r?"OK":"FAILED");
+                    if (!r) {
+                        throw new RuntimeException("Compared images are not equals. Test failed.");
+                    }
+                }
+
+
+                BMPMetadata mdata = (BMPMetadata)ir.getImageMetadata(0);
+
+                if (!param.getCompressionType().equals(param.getCompressionTypes()[mdata.compression])) {
+                    throw new RuntimeException("Different compression value");
+                }
+
+            } catch (Exception ex) {
+                ex.printStackTrace();
+                throw new RuntimeException("Unexpected exception: " + ex);
+            }
+
+        }
+
+        private boolean compare(final BufferedImage in, final BufferedImage out) {
+
+            final int width = in.getWidth();
+            int height = in.getHeight();
+            if (out.getWidth() != width || out.getHeight() != height) {
+                throw new RuntimeException("Dimensions changed!");
+            }
+
+            Raster oldras = in.getRaster();
+            ColorModel oldcm = in.getColorModel();
+            Raster newras = out.getRaster();
+            ColorModel newcm = out.getColorModel();
+
+            for (int j = 0; j < height; j++) {
+                for (int i = 0; i < width; i++) {
+                    Object oldpixel = oldras.getDataElements(i, j, null);
+                    int oldrgb = oldcm.getRGB(oldpixel);
+                    int oldalpha = oldcm.getAlpha(oldpixel);
+
+                    Object newpixel = newras.getDataElements(i, j, null);
+                    int newrgb = newcm.getRGB(newpixel);
+                    int newalpha = newcm.getAlpha(newpixel);
+
+                    if (newrgb != oldrgb ||
+                        newalpha != oldalpha) {
+                        // showDiff(in, out);
+                        throw new RuntimeException("Pixels differ at " + i +
+                                                   ", " + j + " new = " + Integer.toHexString(newrgb) + " old = " + Integer.toHexString(oldrgb));
+                    }
+                }
+            }
+            return true;
+        }
+
+        private static BufferedImage createTestImage2(int nbits, int transfertype) {
+            final int colorShift = 2;
+            int SIZE = 256;
+            BufferedImage image = null;
+
+            ColorSpace colorSpace =
+                ColorSpace.getInstance(ColorSpace.CS_GRAY);
+            ColorModel colorModel =
+                new ComponentColorModel(colorSpace,
+                                        new int[] {nbits},
+                                        false,
+                                        false,
+                                        Transparency.OPAQUE,
+                                        transfertype);
+
+            SampleModel sampleModel =
+                new PixelInterleavedSampleModel(transfertype,
+                                                SIZE,
+                                                SIZE,
+                                                1,
+                                                SIZE,
+                                                new int[] {0});
+
+            image =
+                new BufferedImage(colorModel,
+                                  Raster.createWritableRaster(sampleModel, null),
+                                  false, null);
+            WritableRaster raster = image.getWritableTile(0, 0);
+            int[] samples = raster.getSamples(0, 0, SIZE, SIZE, 0, (int[])null);
+            int off = 0;
+            int[] row = new int[SIZE];
+            for(int i = 0; i < SIZE; i++) {
+                Arrays.fill(row, i << colorShift);
+                System.arraycopy(row, 0, samples, off, SIZE);
+                off += SIZE;
+            }
+            raster.setSamples(0, 0, SIZE, SIZE, 0, samples);
+
+            return image;
+        }
+
+
+        private static BufferedImage createTestImage3(int nbits, int transfertype) {
+            final int colorShift = 2;
+            int SIZE = 256;
+            BufferedImage image = null;
+
+            ColorSpace colorSpace =
+                ColorSpace.getInstance(ColorSpace.CS_sRGB);
+            ColorModel colorModel =
+                new IndexColorModel(nbits,
+                                    4,
+                                    new byte[] { (byte)255,   0,   0, (byte)255},
+                                    new byte[] {   0, (byte)255,   0, (byte)255},
+                                    new byte[] {   0,   0, (byte)255, (byte)255});
+
+            SampleModel sampleModel =
+                new PixelInterleavedSampleModel(transfertype,
+                                                SIZE,
+                                                SIZE,
+                                                1,
+                                                SIZE,
+                                                new int[] {0});
+
+            image =
+                new BufferedImage(colorModel,
+                                  Raster.createWritableRaster(sampleModel, null),
+
+                                  false, null);
+
+            Graphics2D g = image.createGraphics();
+            g.setColor(Color.white);
+            g.fillRect(0,0, SIZE, SIZE);
+            g.setColor(Color.red);
+            g.fillOval(10, 10, SIZE -20, SIZE-20);
+
+            return image;
+        }
+
+        private static BufferedImage createTestImage4(int nbits) {
+            int SIZE = 10;
+
+
+            BufferedImage image = null;
+
+            ColorSpace colorSpace =
+                ColorSpace.getInstance(ColorSpace.CS_sRGB);
+            ColorModel colorModel =
+                new DirectColorModel(colorSpace,
+                                     nbits, 0xff0000, 0x00ff00, 0x0000ff, 0x000000, false, DataBuffer.TYPE_INT);
+
+            SampleModel sampleModel =
+                new SinglePixelPackedSampleModel(DataBuffer.TYPE_INT,
+                                                SIZE,
+                                                SIZE,
+                                      new int[] { 0xff0000, 0x00ff00, 0x0000ff} );
+
+
+            image =
+                new BufferedImage(colorModel,
+                                  Raster.createWritableRaster(sampleModel, null),
+
+                                  false, null);
+
+            Graphics2D g = image.createGraphics();
+            g.setColor(Color.red);
+            g.fillRect(0,0, SIZE, SIZE);
+            g.setColor(Color.green);
+            //g.fillOval(10, 10, SIZE -20, SIZE-20);
+            g.drawLine(7, 0, 7, SIZE);
+            g.setColor(Color.blue);
+            g.drawLine(1, 0, 1, SIZE);
+            g.setColor(Color.white);
+            g.drawLine(3, 0, 3, SIZE);
+            g.setColor(Color.yellow);
+            g.drawLine(5, 0, 5, SIZE);
+            return image;
+        }
+
+        private static BufferedImage createTestImage(int type)
+          throws IOException {
+
+            int w = 200;
+            int h = 200;
+            BufferedImage b = new BufferedImage(w, h, type);
+            Graphics2D g = b.createGraphics();
+            g.setColor(Color.white);
+            g.fillRect(0,0, w, h);
+            g.setColor(Color.black);
+            g.fillOval(10, 10, w -20, h-20);
+
+            return b;
+        }
+
+
+    }
+
+    private static void showDiff(final BufferedImage in,
+                                 final BufferedImage out) {
+        final int width = in.getWidth();
+        final int height = in.getHeight();
+
+        JFrame f = new JFrame("");
+        f.getContentPane().add( new JComponent() {
+                public Dimension getPreferredSize() {
+                    return new Dimension(2*width+2, height);
+                }
+                public void paintComponent(Graphics g) {
+                    g.setColor(Color.black);
+                    g.drawImage(in, 0,0, null);
+
+                    g.drawImage(out, width+2, 0, null);
+                }
+            });
+        f.pack();
+        f.setVisible(true);
+    }
+
+}