java-topology/test/jdk/java/awt/Graphics2D/CopyAreaOOB.java

/*
 * Copyright (c) 2015, 2025, 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 6430601 8198613
 * @summary Verifies that copyArea() works properly when the
 *          destination parameters are outside the destination bounds.
 * @library /test/lib
 * @build jdk.test.lib.Platform
 * @run main/othervm CopyAreaOOB
 */

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.awt.image.MultiResolutionImage;
import java.awt.image.RenderedImage;
import java.io.File;
import java.io.IOException;
import java.util.List;
import javax.imageio.ImageIO;
import jdk.test.lib.Platform;

public class CopyAreaOOB extends Canvas {
    private static final int PRIMARY_TOLERANCE = 2;
    private static int TOLERANCE = 30;
    private static final boolean DEBUG = false;
    private static Frame frame;
    private static Robot robot;
    private static BufferedImage captureImg;

    private static final StringBuffer errorLog = new StringBuffer();

    private static final Point OFF_FRAME_LOC = new Point(50, 50);
    private static final int SIZE = 400;

    public static void main(String[] args) throws Exception {
        try {
            if (!Platform.isOSX()) {
                TOLERANCE = PRIMARY_TOLERANCE;
            }

            robot = new Robot();
            // added to move mouse pointer away from test UI
            // so that it is not captured in the screenshot
            robot.mouseMove(OFF_FRAME_LOC.x, OFF_FRAME_LOC.y);
            robot.waitForIdle();
            robot.delay(100);

            createTestUI();
            robot.delay(1000);

            if (!errorLog.isEmpty()) {
                saveImages();
                throw new RuntimeException("Test failed for the following region(s)" + errorLog);
            }
        } finally {
            if (frame != null) {
                frame.dispose();
            }
        }
    }

    private static void createTestUI() {
        CopyAreaOOB canvas = new CopyAreaOOB();
        frame = new Frame();
        frame.setUndecorated(true);
        frame.add(canvas);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    public void paint(Graphics g) {
        int w = getWidth();
        int h = getHeight();

        Graphics2D g2d = (Graphics2D)g;
        g2d.setColor(Color.BLUE);
        g2d.fillRect(0, 0, w, h);

        g2d.setColor(Color.GREEN);
        g2d.fillRect(0, 0, w, 10);

        g2d.setColor(Color.RED);
        g2d.fillRect(0, 10, 50, h - 10);

        // copy the region such that part of it goes below the bottom of the
        // destination surface
        g2d.copyArea(0, 10, 50, h - 10, 60, 10);

        Toolkit.getDefaultToolkit().sync();

        robot.delay(500);

        Point pt1 = this.getLocationOnScreen();
        Rectangle rect = new Rectangle(pt1.x, pt1.y, SIZE, SIZE);
        captureImg = robot.createScreenCapture(rect);

        // Test pixels
        testRegion("green", 0, 0, 400, 10, Color.GREEN);
        testRegion("original-red", 0, 10, 50, 400, Color.RED);
        testRegion("background", 50, 10, 60, 400, Color.BLUE);
        testRegion("in-between", 60, 10, 110, 20, Color.BLUE);
        testRegion("copied-red", 60, 20, 110, 400, Color.RED);
        testRegion("background", 110, 10, 400, 400, Color.BLUE);
    }

    public Dimension getPreferredSize() {
        return new Dimension(SIZE, SIZE);
    }

    private static void testRegion(String region,
                                   int x1, int y1, int x2, int y2,
                                   Color expected) {
        for (int y = y1; y < y2; y++) {
            for (int x = x1; x < x2; x++) {
                Color actual = new Color(captureImg.getRGB(x, y));
                if (DEBUG) {
                    System.out.println("Actual color: " + actual);
                }
                if (!compareColor(expected, actual)) {
                    errorLog.append("\nTest region: " + region + " Status: FAILED!!!\n");
                    errorLog.append("Test failed at x : " + x + " y : " + y + "\n"
                                    + "Expected Color: " + expected + "\n"
                                    + "Actual Color: " + actual + "\n");
                    return;
                }
            }
        }
        System.out.println("Test region: " + region + " Status: PASSED");
    }

    private static void saveImages() {
        GraphicsConfiguration ge = GraphicsEnvironment.getLocalGraphicsEnvironment()
                                                      .getDefaultScreenDevice()
                                                      .getDefaultConfiguration();

        MultiResolutionImage mrImage = robot.createMultiResolutionScreenCapture(ge.getBounds());
        List<Image> variants = mrImage.getResolutionVariants();
        RenderedImage screenCapture = (RenderedImage) variants.get(variants.size() - 1);

        try {
            ImageIO.write(screenCapture, "png", new File("fullscreen.png"));
            ImageIO.write(captureImg, "png", new File("canvas.png"));
        } catch (IOException e) {
            System.err.println("Can't write image " + e);
        }
    }

    private static boolean compareColor(Color expected, Color actual) {
            return Math.abs(expected.getRed() - actual.getRed())
                   < (expected.equals(Color.RED) ? PRIMARY_TOLERANCE : TOLERANCE)
                   && Math.abs(expected.getGreen() - actual.getGreen())
                      < (expected.equals(Color.GREEN) ? PRIMARY_TOLERANCE : TOLERANCE)
                   && Math.abs(expected.getBlue() - actual.getBlue())
                      < (expected.equals(Color.BLUE) ? PRIMARY_TOLERANCE : TOLERANCE);
    }
}