MovedResizedTwiceTest.java revision 11018:66682f651425 
1/*
2 * Copyright (c) 2005, 2014, 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.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26/*
27  @test
28  @bug 5025858
29  @summary Tests that after programmatically moving or resizing a component,
30corresponding ComponentEvents are generated only once
31  @author artem.ananiev: area=awt.event
32  @run main/manual MovedResizedTwiceTest
33*/
34
35import java.awt.*;
36import java.awt.event.*;
37
38/*
39  IMPORTANT: this test is made manual as some window managers may generate
40  strange events and that would lead to the test to fail. However, on most
41  popular platforms (windows, linux w/ KDE or GNOME, solaris w/ CDE or
42  GNOME) it usually passes successfully.
43*/
44
45public class MovedResizedTwiceTest
46{
47    private static volatile int componentMovedCount;
48    private static volatile int componentResizedCount;
49
50    private static volatile int rightX, rightY;
51
52    private static volatile boolean failed = false;
53
54    private static void init()
55    {
56        componentMovedCount = componentResizedCount = 0;
57
58        Robot robot;
59        try {
60            robot = new Robot();
61        }catch(Exception ex) {
62            ex.printStackTrace();
63            throw new RuntimeException("Cannot create Robot: failure");
64        }
65
66        Frame f = new Frame("Frame F");
67        f.setLayout(null);
68        f.setBounds(100, 100, 100, 100);
69        f.add(new Button("Button"));
70
71        f.setVisible(true);
72        robot.waitForIdle();
73
74        ComponentListener cl = new ComponentAdapter()
75        {
76            public void componentMoved(ComponentEvent e)
77            {
78                componentMovedCount++;
79                Component c = (Component)e.getSource();
80                if (!(c instanceof Window))
81                {
82                    return;
83                }
84                Point p = c.getLocationOnScreen();
85                if ((p.x != rightX) || (p.y != rightY))
86                {
87                    System.err.println("Error: wrong location on screen after COMPONENT_MOVED");
88                    System.err.println("Location on screen is (" + p.x + ", " + p.y + ") against right location (" + rightX + ", " + rightY + ")");
89                    failed = true;
90                }
91            }
92            public void componentResized(ComponentEvent e)
93            {
94                componentResizedCount++;
95            }
96        };
97
98        f.addComponentListener(cl);
99
100        componentResizedCount = componentMovedCount = 0;
101        rightX = 100;
102        rightY = 100;
103        f.setSize(200, 200);
104        robot.waitForIdle();
105        checkResized("setSize", f);
106
107        componentResizedCount = componentMovedCount = 0;
108        rightX = 200;
109        rightY = 200;
110        f.setLocation(200, 200);
111        robot.waitForIdle();
112        checkMoved("setLocation", f);
113
114        componentResizedCount = componentMovedCount = 0;
115        rightX = 150;
116        rightY = 150;
117        f.setBounds(150, 150, 100, 100);
118        robot.waitForIdle();
119        checkResized("setBounds", f);
120        checkMoved("setBounds", f);
121
122        Button b = new Button("B");
123        b.setBounds(10, 10, 40, 40);
124        f.add(b);
125        robot.waitForIdle();
126
127        b.addComponentListener(cl);
128
129        componentResizedCount = componentMovedCount = 0;
130        b.setBounds(20, 20, 50, 50);
131        robot.waitForIdle();
132        checkMoved("setBounds", b);
133        checkResized("setBounds", b);
134        f.remove(b);
135
136        Component c = new Component() {};
137        c.setBounds(10, 10, 40, 40);
138        f.add(c);
139        robot.waitForIdle();
140
141        c.addComponentListener(cl);
142
143        componentResizedCount = componentMovedCount = 0;
144        c.setBounds(20, 20, 50, 50);
145        robot.waitForIdle();
146        checkMoved("setBounds", c);
147        checkResized("setBounds", c);
148        f.remove(c);
149
150        if (failed)
151        {
152            MovedResizedTwiceTest.fail("Test FAILED");
153        }
154        else
155        {
156            MovedResizedTwiceTest.pass();
157        }
158    }
159
160    private static void checkResized(String methodName, Component c)
161    {
162        String failMessage = null;
163        if (componentResizedCount == 1)
164        {
165            return;
166        }
167        else if (componentResizedCount == 0)
168        {
169            failMessage = "Test FAILED: COMPONENT_RESIZED is not sent after call to " + methodName + "()";
170        }
171        else
172        {
173            failMessage = "Test FAILED: COMPONENT_RESIZED is sent " + componentResizedCount + " + times after call to " + methodName + "()";
174        }
175        System.err.println("Failed component: " + c);
176        MovedResizedTwiceTest.fail(failMessage);
177    }
178
179    private static void checkMoved(String methodName, Component c)
180    {
181        String failMessage = null;
182        if (componentMovedCount == 1)
183        {
184            return;
185        }
186        if (componentMovedCount == 0)
187        {
188            failMessage = "Test FAILED: COMPONENT_MOVED is not sent after call to " + methodName + "()";
189        }
190        else
191        {
192            failMessage = "Test FAILED: COMPONENT_MOVED is sent " + componentMovedCount + " times after call to " + methodName + "()";
193        }
194        System.err.println("Failed component: " + c);
195        MovedResizedTwiceTest.fail(failMessage);
196    }
197
198    private static boolean theTestPassed = false;
199    private static boolean testGeneratedInterrupt = false;
200    private static String failureMessage = "";
201
202    private static Thread mainThread = null;
203
204    private static int sleepTime = 300000;
205
206    public static void main( String args[] ) throws InterruptedException
207    {
208        mainThread = Thread.currentThread();
209        try
210        {
211            init();
212        }
213        catch (TestPassedException e)
214        {
215            return;
216        }
217
218        try
219        {
220            Thread.sleep(sleepTime);
221            throw new RuntimeException( "Timed out after " + sleepTime/1000 + " seconds" );
222        }
223        catch (InterruptedException e)
224        {
225            if (!testGeneratedInterrupt)
226            {
227                throw e;
228            }
229
230            testGeneratedInterrupt = false;
231
232            if (!theTestPassed)
233            {
234                throw new RuntimeException( failureMessage );
235            }
236        }
237    }
238
239    public static synchronized void setTimeoutTo(int seconds)
240    {
241        sleepTime = seconds * 1000;
242    }
243
244    public static synchronized void pass()
245    {
246        if (mainThread == Thread.currentThread())
247        {
248            theTestPassed = true;
249            throw new TestPassedException();
250        }
251        theTestPassed = true;
252        testGeneratedInterrupt = true;
253        mainThread.interrupt();
254    }
255
256    public static synchronized void fail()
257    {
258        fail("it just plain failed! :-)");
259    }
260
261    public static synchronized void fail(String whyFailed)
262    {
263        if (mainThread == Thread.currentThread())
264        {
265            throw new RuntimeException(whyFailed);
266        }
267        theTestPassed = false;
268        testGeneratedInterrupt = true;
269        failureMessage = whyFailed;
270        mainThread.interrupt();
271    }
272}
273
274class TestPassedException extends RuntimeException
275{
276}
277