RenderingToCachedGraphicsTest.java revision 14851:980da45565c8 
1/*
2 * Copyright (c) 2007, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24/*
25 * @test
26 * @key headful
27 * @bug 6648018 6652662
28 * @summary Verifies that rendering to a cached onscreen Graphics works
29 * @author Dmitri.Trembovetski@sun.com: area=Graphics
30 * @run main/othervm RenderingToCachedGraphicsTest
31 * @run main/othervm -Dsun.java2d.d3d=false RenderingToCachedGraphicsTest
32 */
33import java.awt.Canvas;
34import java.awt.Color;
35import java.awt.Frame;
36import java.awt.Graphics;
37import java.awt.GraphicsEnvironment;
38import java.awt.Point;
39import java.awt.Rectangle;
40import java.awt.Robot;
41import java.awt.Toolkit;
42import java.awt.event.WindowAdapter;
43import java.awt.event.WindowEvent;
44import java.awt.image.BufferStrategy;
45import java.awt.image.BufferedImage;
46import static java.awt.image.VolatileImage.*;
47import java.awt.image.VolatileImage;
48import java.io.File;
49import java.util.concurrent.CountDownLatch;
50import javax.imageio.ImageIO;
51
52public class RenderingToCachedGraphicsTest extends Frame {
53    private static volatile boolean failed = false;
54    private static volatile CountDownLatch latch;
55    private Graphics cachedGraphics;
56    private Canvas renderCanvas;
57
58    public RenderingToCachedGraphicsTest() {
59        super("Test starts in 2 seconds");
60        renderCanvas = new Canvas() {
61            @Override
62            public void paint(Graphics g) {
63                if (getWidth() < 100 || getHeight() < 100) {
64                    repaint();
65                    return;
66                }
67                // wait for a bit so that Vista's Window manager's animation
68                // effects on window's appearance are completed (6652662)
69                try { Thread.sleep(2000); } catch (InterruptedException ex) {}
70
71                try {
72                    runTest();
73                } catch (Throwable t) {
74                    failed = true;
75                } finally {
76                    latch.countDown();
77                }
78            }
79            @Override
80            public void update(Graphics g) {}
81        };
82
83        add("Center", renderCanvas);
84    }
85
86    private void runTest() {
87        // this will cause screen update manager to dump the accelerated surface
88        // for this canvas
89        renderCanvas.createBufferStrategy(2);
90        BufferStrategy bs = renderCanvas.getBufferStrategy();
91        do {
92            Graphics bsg = bs.getDrawGraphics();
93            bsg.setColor(Color.blue);
94            bsg.fillRect(0, 0,
95                         renderCanvas.getWidth(), renderCanvas.getHeight());
96        } while (bs.contentsLost() || bs.contentsRestored());
97
98        // grab the "unaccelerated" onscreen surface
99        cachedGraphics = renderCanvas.getGraphics();
100        cachedGraphics.setColor(Color.red);
101        cachedGraphics.fillRect(0, 0, getWidth(), getHeight());
102
103        bs.dispose();
104        bs = null;
105        // now the update manager should be able to accelerate onscreen
106        // rendering to it again
107
108        cachedGraphics.setColor(Color.green);
109        // this causes restoration  of the new accelerated onscreen surface
110        // (it is created in "lost" state)
111        cachedGraphics.fillRect(0, 0,
112                                renderCanvas.getWidth(),
113                                renderCanvas.getHeight());
114        Toolkit.getDefaultToolkit().sync();
115        // and now we should be able to render to it
116        cachedGraphics.fillRect(0, 0,
117                                renderCanvas.getWidth(),
118                                renderCanvas.getHeight());
119        Toolkit.getDefaultToolkit().sync();
120
121        Robot robot = null;
122        try {
123            robot = new Robot();
124        } catch (Exception e) {
125            e.printStackTrace();
126            failed = true;
127            return;
128        }
129
130        Point p = renderCanvas.getLocationOnScreen();
131        Rectangle r = new Rectangle(p.x, p.y,
132                                    renderCanvas.getWidth(),
133                                    renderCanvas.getHeight());
134        BufferedImage bi = robot.createScreenCapture(r);
135        for (int y = 0; y < bi.getHeight(); y++) {
136            for (int x = 0; x < bi.getWidth(); x++) {
137                if (bi.getRGB(x, y) != Color.green.getRGB()) {
138                    System.err.println("Colors mismatch!");
139                    String name = "RenderingToCachedGraphicsTest.png";
140                    try {
141                        ImageIO.write(bi, "png", new File(name));
142                        System.err.println("Dumped grabbed image to: "+name);
143                    } catch (Exception e) {}
144                    failed = true;
145                    return;
146                }
147            }
148        }
149    }
150
151    public static void main(String[] args) {
152        int depth = GraphicsEnvironment.getLocalGraphicsEnvironment().
153            getDefaultScreenDevice().getDefaultConfiguration().
154                getColorModel().getPixelSize();
155        if (depth < 16) {
156            System.out.println("Test PASSED (depth < 16bit)");
157            return;
158        }
159
160        latch = new CountDownLatch(1);
161        RenderingToCachedGraphicsTest t1 = new RenderingToCachedGraphicsTest();
162        t1.pack();
163        t1.setSize(300, 300);
164        t1.setVisible(true);
165
166        try { latch.await(); } catch (InterruptedException ex) {}
167        t1.dispose();
168
169        if (failed) {
170            throw new
171                RuntimeException("Failed: rendering didn't show up");
172        }
173        System.out.println("Test PASSED");
174    }
175}
176