dnd/ImageTransferTest/ImageTransferTest.java

/*
 * Copyright (c) 2014, 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
  @key headful
  @bug 4397404 4720930
  @summary tests that images of all supported native image formats are transfered properly
  @library ../../../../lib/testlibrary
  @library ../../regtesthelpers/process/
  @build jdk.testlibrary.OSInfo ProcessResults ProcessCommunicator
  @author gas@sparc.spb.su area=Clipboard
  @run main ImageTransferTest
*/

import test.java.awt.regtesthelpers.process.ProcessCommunicator;
import test.java.awt.regtesthelpers.process.ProcessResults;
import jdk.testlibrary.OSInfo;

import java.awt.*;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.SystemFlavorMap;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.dnd.DnDConstants;
import java.awt.dnd.DragSource;
import java.awt.dnd.DragSourceAdapter;
import java.awt.dnd.DragSourceDropEvent;
import java.awt.dnd.DragSourceListener;
import java.awt.dnd.DropTarget;
import java.awt.dnd.DropTargetAdapter;
import java.awt.dnd.DropTargetDropEvent;
import java.awt.event.InputEvent;
import java.awt.image.BufferedImage;
import java.awt.image.MemoryImageSource;
import java.util.stream.Stream;

public class ImageTransferTest {
    public static void main(String[] arg) throws Exception {
        ImageDragSource ids = new ImageDragSource();
        ids.frame.setLocation(100, 100);
        ids.frame.setVisible(true);
        Util.sync();
        String classpath = System.getProperty("java.class.path");
        String[] args = new String[ids.formats.length + 4];
        args[0] = "200";
        args[1] = "100";
        args[2] = args[3] = "150";

        System.arraycopy(ids.formats, 0, args, 4, ids.formats.length);
        ProcessResults pres = ProcessCommunicator.executeChildProcess(ImageDropTarget.class, classpath, args);

        if (pres.getStdErr() != null && pres.getStdErr().length() > 0) {
            System.err.println("========= Child VM System.err ========");
            System.err.print(pres.getStdErr());
            System.err.println("======================================");
        }

        if (pres.getStdOut() != null && pres.getStdOut().length() > 0) {
            System.err.println("========= Child VM System.out ========");
            System.err.print(pres.getStdOut());
            System.err.println("======================================");
        }

        boolean failed = false;
        String passedFormats = "";
        String failedFormats = "";

        for (int i = 0; i < ids.passedArray.length; i++) {
            if (ids.passedArray[i]) passedFormats += ids.formats[i] + " ";
            else {
                failed = true;
                failedFormats += ids.formats[i] + " ";
            }
        }

        if (failed) {
            throw new RuntimeException("test failed: images in following " +
                    "native formats are not transferred properly: " + failedFormats);
        } else {
            System.err.println("images in following " +
                    "native formats are transferred properly: " + passedFormats);
        }
    }
}


class Util {
    private static Robot srobot = null;
    public static void sync() {
        try {
            if(srobot == null) {
                srobot = new Robot();
            }
            srobot.waitForIdle();
            Thread.sleep(500);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

abstract class ImageTransferer {
    Image image;
    String[] formats;
    int fi; // current format index
    Frame frame = new Frame();


    ImageTransferer() {
        image = createImage();
        frame.setSize(100, 100);
    }

    private static Image createImage() {
        int w = 100;
        int h = 100;
        int[] pix = new int[w * h];

        int index = 0;
        for (int y = 0; y < h; y++) {
            for (int x = 0; x < w; x++) {
                int red = 127;
                int green = 127;
                int blue = y > h / 2 ? 127 : 0;
                int alpha = 255;
                if (x < w / 4 && y < h / 4) {
                    alpha = 0;
                    red = 0;
                }
                pix[index++] = (alpha << 24) | (red << 16) | (green << 8) | blue;
            }
        }
        return Toolkit.getDefaultToolkit().createImage(new MemoryImageSource(w, h, pix, 0, w));
    }


    static String[] retrieveFormatsToTest() {
        SystemFlavorMap sfm = (SystemFlavorMap) SystemFlavorMap.getDefaultFlavorMap();
        java.util.List<String> ln = sfm.getNativesForFlavor(DataFlavor.imageFlavor);
        if (OSInfo.OSType.WINDOWS.equals(OSInfo.getOSType()) && !ln.contains("METAFILEPICT")) {
            // for test failing on JDK without this fix
            ln.add("METAFILEPICT");
        }
        return ln.toArray(new String[ln.size()]);
    }

    static void leaveFormat(String format) {
        SystemFlavorMap sfm = (SystemFlavorMap) SystemFlavorMap.getDefaultFlavorMap();
        sfm.setFlavorsForNative(format, new DataFlavor[]{DataFlavor.imageFlavor});
        sfm.setNativesForFlavor(DataFlavor.imageFlavor, new String[]{format});
    }


    boolean areImagesIdentical(Image im1, Image im2) {
        if (formats[fi].equals("JFIF") || formats[fi].equals("image/jpeg") ||
                formats[fi].equals("GIF") || formats[fi].equals("image/gif")) {
            // JFIF and GIF are lossy formats
            return true;
        }
        int[] ib1 = getImageData(im1);
        int[] ib2 = getImageData(im2);

        if (ib1.length != ib2.length) {
            return false;
        }

        if (formats[fi].equals("PNG") ||
                formats[fi].equals("image/png") ||
                formats[fi].equals("image/x-png")) {
            // check alpha as well
            for (int i = 0; i < ib1.length; i++) {
                if (ib1[i] != ib2[i]) {
                    System.err.println("different pixels: " +
                            Integer.toHexString(ib1[i]) + " " +
                            Integer.toHexString(ib2[i]));
                    return false;
                }
            }
        } else {
            for (int i = 0; i < ib1.length; i++) {
                if ((ib1[i] & 0x00FFFFFF) != (ib2[i] & 0x00FFFFFF)) {
                    System.err.println("different pixels: " +
                            Integer.toHexString(ib1[i]) + " " +
                            Integer.toHexString(ib2[i]));
                    return false;
                }
            }
        }
        return true;
    }

    private static int[] getImageData(Image image) {
        int width = image.getWidth(null);
        int height = image.getHeight(null);
        BufferedImage bimage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
        Graphics2D g2d = bimage.createGraphics();
        try {
            g2d.drawImage(image, 0, 0, width, height, null);
        } finally {
            g2d.dispose();
        }
        return bimage.getRGB(0, 0, width, height, null, 0, width);
    }

    public static int sign(int n) {
        return n < 0 ? -1 : n == 0 ? 0 : 1;
    }

}


class ImageDragSource extends ImageTransferer {
    boolean[] passedArray;

    ImageDragSource() {
        formats = retrieveFormatsToTest();
        passedArray = new boolean[formats.length];
        final DragSourceListener dsl = new DragSourceAdapter() {
            public void dragDropEnd(DragSourceDropEvent e) {
                System.err.println("Drop was successful=" + e.getDropSuccess());
                notifyTransferSuccess(e.getDropSuccess());
                if (++fi < formats.length) {
                    leaveFormat(formats[fi]);
                }
            }
        };

        new DragSource().createDefaultDragGestureRecognizer(frame,
                DnDConstants.ACTION_COPY,
                dge -> dge.startDrag(null, new ImageSelection(image), dsl));
        leaveFormat(formats[fi]);
    }


    void notifyTransferSuccess(boolean status) {
        passedArray[fi] = status;
    }
}


class ImageDropTarget extends ImageTransferer {
    private final Robot robot;
    private static Point startPoint, endPoint = new Point(250, 150);

    ImageDropTarget() throws AWTException {
        DropTargetAdapter dropTargetAdapter = new DropTargetAdapter() {
            @Override
            public void drop(DropTargetDropEvent dtde) {
                checkImage(dtde);
                startImageDrag();
            }
        };
        new DropTarget(frame, dropTargetAdapter);
        robot = new Robot();
    }


    void checkImage(DropTargetDropEvent dtde) {
        final Transferable t = dtde.getTransferable();
        if (t.isDataFlavorSupported(DataFlavor.imageFlavor)) {
            dtde.acceptDrop(DnDConstants.ACTION_COPY);
            Image im;
            try {
                im = (Image) t.getTransferData(DataFlavor.imageFlavor);
                System.err.println("getTransferData was successful");
            } catch (Exception e) {
                System.err.println("Can't getTransferData: " + e);
                dtde.dropComplete(false);
                notifyTransferSuccess(false);
                return;
            }

            if (im == null) {
                System.err.println("getTransferData returned null");
                dtde.dropComplete(false);
                notifyTransferSuccess(false);
            } else if (areImagesIdentical(image, im)) {
                dtde.dropComplete(true);
                notifyTransferSuccess(true);
            } else {
                System.err.println("transferred image is different from initial image");
                dtde.dropComplete(false);
                notifyTransferSuccess(false);
            }

        } else {
            System.err.println("imageFlavor is not supported by Transferable");
            dtde.rejectDrop();
            notifyTransferSuccess(false);
        }
    }

    void startImageDrag() {
        leaveFormat(formats[fi]);
        new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                // Exit from the child process
                System.exit(1);
            }
            robot.mouseMove(startPoint.x, startPoint.y);
            robot.mousePress(InputEvent.BUTTON1_MASK);
            for (Point p = new Point(startPoint); !p.equals(endPoint);
                 p.translate(sign(endPoint.x - p.x), sign(endPoint.y - p.y))) {
                robot.mouseMove(p.x, p.y);
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            robot.mouseRelease(InputEvent.BUTTON1_MASK);
        }).start();
    }

    void notifyTransferSuccess(boolean status) {
        if (status) {
            System.err.println("format passed: " + formats[fi]);
        } else {
            System.err.println("format failed: " + formats[fi]);
            System.exit(1);
        }
        if (fi < formats.length - 1) {
            leaveFormat(formats[++fi]);
        } else {
            new Thread(() -> {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.exit(0);
            }).start();
        }
    }


    public static void main(String[] args) {
        try {
            ImageDropTarget idt = new ImageDropTarget();

            int x = Integer.parseInt(args[0]);
            int y = Integer.parseInt(args[1]);
            startPoint = new Point(Integer.parseInt(args[2]), Integer.parseInt(args[3]));

            idt.formats = new String[args.length - 4];
            System.arraycopy(args, 4, idt.formats, 0, args.length - 4);
            leaveFormat(idt.formats[0]);

            idt.frame.setLocation(x, y);
            idt.frame.setVisible(true);
            Util.sync();

            idt.startImageDrag();
        } catch (Throwable e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

}


class ImageSelection implements Transferable {
    private static final int IMAGE = 0;
    private static final DataFlavor[] flavors = {DataFlavor.imageFlavor};
    private Image data;

    public ImageSelection(Image data) {
        this.data = data;
    }

    @Override
    public DataFlavor[] getTransferDataFlavors() {
        // returning flavors itself would allow client code to modify
        // our internal behavior
        return flavors.clone();
    }

    @Override
    public boolean isDataFlavorSupported(DataFlavor flavor) {
        return Stream.of(flavor).anyMatch(flavor::equals);
    }

    @Override
    public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException {
        if (flavor.equals(flavors[IMAGE])) {
            return data;
        } else {
            throw new UnsupportedFlavorException(flavor);
        }
    }
}