KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > validation > Utils


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */
19 package validation;
20
21 import java.awt.Component JavaDoc;
22 import java.io.BufferedReader JavaDoc;
23 import java.io.IOException JavaDoc;
24 import java.io.InputStream JavaDoc;
25 import java.io.InputStreamReader JavaDoc;
26 import java.net.ServerSocket JavaDoc;
27 import java.net.URI JavaDoc;
28 import java.net.URLConnection JavaDoc;
29 import java.util.Random JavaDoc;
30 import javax.swing.JComboBox JavaDoc;
31 import javax.swing.JComponent JavaDoc;
32 import org.netbeans.jellytools.Bundle;
33 import org.netbeans.jellytools.EditorOperator;
34 import org.netbeans.jellytools.JellyTestCase;
35 import org.netbeans.jellytools.MainWindowOperator;
36 import org.netbeans.jellytools.NbDialogOperator;
37 import org.netbeans.jellytools.OptionsOperator;
38 import org.netbeans.jellytools.OutputTabOperator;
39 import org.netbeans.jellytools.OutputTabOperator;
40 import org.netbeans.jellytools.actions.ActionNoBlock;
41 import org.netbeans.jellytools.modules.debugger.actions.FinishDebuggerAction;
42 import org.netbeans.jellytools.modules.debugger.actions.ToggleBreakpointAction;
43 import org.netbeans.jellytools.modules.j2ee.nodes.J2eeServerNode;
44 import org.netbeans.jellytools.nodes.Node;
45 import org.netbeans.jemmy.ComponentChooser;
46 import org.netbeans.jemmy.EventTool;
47 import org.netbeans.jemmy.JemmyException;
48 import org.netbeans.jemmy.Waitable;
49 import org.netbeans.jemmy.Waiter;
50 import org.netbeans.jemmy.operators.ContainerOperator;
51 import org.netbeans.jemmy.operators.JComboBoxOperator;
52 import org.netbeans.jemmy.operators.JLabelOperator;
53 import org.netbeans.jemmy.operators.JRadioButtonOperator;
54 import org.netbeans.jemmy.operators.JSpinnerOperator;
55 import org.netbeans.jemmy.operators.JTabbedPaneOperator;
56 import org.netbeans.jemmy.operators.JTreeOperator;
57
58 /** Utility methods useful for testing of debugging.
59  * @author Jiri..Skrivanek@sun.com
60  */
61 public class Utils {
62     
63     /** Default value for Sun App Server. If we test Tomcat, it is
64      * overridden in setTomcatProperties() method. */
65     private static int socketPort = 9009;
66     public static final String JavaDoc SUN_APP_SERVER = "Sun";
67     public static final String JavaDoc TOMCAT = "Tomcat";
68     public static final String JavaDoc DEFAULT_SERVER = SUN_APP_SERVER;
69     
70     /** Sets a random port for Tomcat server and socket debugger transport. */
71     public static void setTomcatProperties() throws Exception JavaDoc {
72         // "Tools"
73 String JavaDoc toolsItem = Bundle.getStringTrimmed("org.netbeans.core.Bundle", "Menu/Tools"); // NOI18N
74 // "Server Manager"
75 String JavaDoc serverManagerItem = Bundle.getStringTrimmed(
76                 "org.netbeans.modules.j2ee.deployment.impl.ui.actions.Bundle",
77                 "CTL_ServerManager");
78         new ActionNoBlock(toolsItem+"|"+serverManagerItem, null).perform();
79         // "Server Manager"
80 String JavaDoc serverManagerTitle = Bundle.getString(
81                 "org.netbeans.modules.j2ee.deployment.devmodules.api.Bundle",
82                 "TXT_ServerManager");
83         NbDialogOperator serverManagerOper = new NbDialogOperator(serverManagerTitle);
84         String JavaDoc j2eeLabel = Bundle.getString(
85                 "org.netbeans.modules.j2ee.deployment.impl.ui.Bundle",
86                 "LBL_J2eeServersNode");
87         new Node(new JTreeOperator(serverManagerOper), j2eeLabel+"|"+"Bundled Tomcat").select(); // NOI18N
88 // set server port
89 JSpinnerOperator serverPortOper = new JSpinnerOperator(serverManagerOper, 0);
90         // satisfy focus on spinner which causes changes are reflected
91 serverPortOper.getNumberSpinner().scrollToValue((Number JavaDoc)serverPortOper.getNextValue());
92         serverPortOper.setValue(new Integer JavaDoc(getPort()));
93         // set shutdown port
94 JSpinnerOperator shutdownPortOper = new JSpinnerOperator(serverManagerOper, 1);
95         // satisfy focus on spinner which causes changes are reflected
96 shutdownPortOper.getNumberSpinner().scrollToValue((Number JavaDoc)shutdownPortOper.getNextValue());
97         shutdownPortOper.setValue(new Integer JavaDoc(getPort()));
98         
99         // set socket debugger transport
100 // "Startup"
101 String JavaDoc startupLabel = Bundle.getString("org.netbeans.modules.tomcat5.customizer.Bundle", "TXT_Startup");
102         new JTabbedPaneOperator(serverManagerOper).selectPage(startupLabel);
103         // "Socket Port:
104 String JavaDoc socketPortLabel = Bundle.getString("org.netbeans.modules.tomcat5.customizer.Bundle", "TXT_SocketPort");
105         new JRadioButtonOperator(serverManagerOper, socketPortLabel).setSelected(true);
106         // set socket port number
107 JSpinnerOperator socketPortOper = new JSpinnerOperator(serverManagerOper, 0);
108         // satisfy focus on spinner which causes changes are reflected
109 socketPortOper.getNumberSpinner().scrollToValue((Number JavaDoc)socketPortOper.getNextValue());
110         socketPort = getPort();
111         socketPortOper.setValue(new Integer JavaDoc(socketPort));
112         
113         serverManagerOper.close();
114     }
115     
116     /** Returns socket port set in setTomcatProperties method.
117      * @return socket port used for debugger transport
118      */
119     public static String JavaDoc getSocketPort() {
120         return Integer.toString(socketPort);
121     }
122     
123     /** Returns unique free port number within range of dynamic or private ports
124      * (see http://www.iana.org/assignments/port-numbers)
125      */
126     private static int getPort() throws Exception JavaDoc {
127         int port = 0;
128         boolean notfree = true;
129         while(notfree) {
130             port = 49152+new Random JavaDoc().nextInt(16383);
131             // test whether port is already used
132 ServerSocket JavaDoc socket = null;
133             try {
134                 socket = new ServerSocket JavaDoc(port);
135                 socket.close();
136                 // found a free port
137 notfree = false;
138             } catch (IOException JavaDoc ioe) {
139                 // BindException: Address already in use thrown
140 }
141         }
142         return port;
143     }
144     
145     /** Finishes debugger and wait until it finishes. */
146     public static void finishDebugger() {
147         ContainerOperator debugToolbarOper = getDebugToolbar();
148         new FinishDebuggerAction().perform();
149         // wait until Debug toolbar dismiss
150 debugToolbarOper.waitComponentVisible(false);
151         // wait until server is not in transient state
152 J2eeServerNode serverNode = new J2eeServerNode(DEFAULT_SERVER);
153         serverNode.waitFinished();
154         new EventTool().waitNoEvent(2000);
155
156         /* cannot be used because of this issue 71263 ('User program finished' not printed to output)
157         MainWindowOperator.StatusTextTracer stt = MainWindowOperator.getDefault().getStatusTextTracer();
158         // start to track Main Window status bar
159         stt.start();
160         new FinishDebuggerAction().perform();
161         String programFinishedLabel = Bundle.getString("org.netbeans.modules.debugger.jpda.ui.Bundle", "CTL_Debugger_finished");
162         stt.waitText(programFinishedLabel);
163         stt.stop();
164         */
165     }
166     
167     /** Returns ContainerOperator representing Debug toolbar.
168      * @return ContainerOperator representing Debug toolbar
169      */
170     public static ContainerOperator getDebugToolbar() {
171         String JavaDoc debugToolbarLabel = Bundle.getString("org.netbeans.modules.debugger.jpda.ui.Bundle", "Toolbars/Debug");
172         return MainWindowOperator.getDefault().getToolbar(debugToolbarLabel);
173     }
174     
175     public static class ToolTipChooser implements ComponentChooser {
176         private String JavaDoc tooltip;
177         public ToolTipChooser(String JavaDoc tooltip) {
178             this.tooltip = tooltip;
179         }
180         public boolean checkComponent(Component JavaDoc comp) {
181             return tooltip.equals(((JComponent JavaDoc)comp).getToolTipText());
182         }
183         public String JavaDoc getDescription() {
184             return("ToolTip equals to "+tooltip);
185         }
186     }
187     
188     /** Sets breakpoint in editor on line with specified text.
189      * @param eo EditorOperator instance where to set breakpoint
190      * @param text text to find for setting breakpoint
191      * @return line number where breakpoint was set (starts from 1)
192      */
193     public static int setBreakpoint(EditorOperator eo, String JavaDoc text) throws Exception JavaDoc {
194         eo.select(text); // NOI18N
195 final int line = eo.getLineNumber();
196         // toggle breakpoint via pop-up menu
197 new ToggleBreakpointAction().perform(eo.txtEditorPane());
198         // wait breakpoint established
199 new Waiter(new Waitable() {
200             public Object JavaDoc actionProduced(Object JavaDoc editorOper) {
201                 Object JavaDoc[] annotations = ((EditorOperator)editorOper).getAnnotations(line);
202                 for (int i = 0; i < annotations.length; i++) {
203                     if("Breakpoint".equals(((EditorOperator)editorOper).getAnnotationType(annotations[i]))) { // NOI18N
204 return Boolean.TRUE;
205                     }
206                 }
207                 return null;
208             }
209             public String JavaDoc getDescription() {
210                 return("Wait breakpoint established on line "+line); // NOI18N
211 }
212         }).waitAction(eo);
213         return line;
214     }
215     
216     /** Gets URL of default server. */
217     public static String JavaDoc getDefaultUrl() {
218         if(DEFAULT_SERVER.equals(SUN_APP_SERVER)) {
219             return "http://localhost:8080/";
220         } else {
221             return "http://localhost:8084/";
222         }
223     }
224     
225     /** Opens URL connection to server with given urlSuffix.
226      * @param urlSuffix suffix added to server URL
227      */
228     public static void reloadPage(final String JavaDoc urlSuffix) {
229         new Thread JavaDoc(new Runnable JavaDoc() {
230             public void run() {
231                 try {
232                     new URI JavaDoc(getDefaultUrl()+urlSuffix).toURL().openStream();
233                 } catch (Exception JavaDoc e) {
234                     e.printStackTrace();
235                 }
236             }
237         }).start();
238     }
239     
240     /** Opens URL connection and waits for given text. It thows TimeoutExpiredException
241      * if timeout expires.
242      * @param urlSuffix suffix added to server URL
243      * @param timeout time to wait
244      * @param text text to be found
245      */
246     public static void waitText(final String JavaDoc urlSuffix, final long timeout, final String JavaDoc text) {
247         Waitable waitable = new Waitable() {
248             public Object JavaDoc actionProduced(Object JavaDoc obj) {
249                 InputStream JavaDoc is = null;
250                 try {
251                     URLConnection JavaDoc connection = new URI JavaDoc(getDefaultUrl()+urlSuffix).toURL().openConnection();
252                     connection.setReadTimeout(Long.valueOf(timeout).intValue());
253                     is = connection.getInputStream();
254                     BufferedReader JavaDoc br = new BufferedReader JavaDoc(new InputStreamReader JavaDoc(is));
255                     String JavaDoc line = br.readLine();
256                     while(line != null) {
257                         if(line.indexOf(text) > -1) {
258                             return Boolean.TRUE;
259                         }
260                         line = br.readLine();
261                     }
262                     is.close();
263                 } catch (Exception JavaDoc e) {
264                     e.printStackTrace();;
265                     return null;
266                 } finally {
267                     if(is != null) {
268                         try {
269                             is.close();
270                         } catch (IOException JavaDoc e) {
271                             // ignore
272 }
273                     }
274                 }
275                 return null;
276             }
277             public String JavaDoc getDescription() {
278                 return("Text \""+text+"\" at "+getDefaultUrl()+urlSuffix);
279             }
280         };
281         Waiter waiter = new Waiter(waitable);
282         waiter.getTimeouts().setTimeout("Waiter.WaitingTime", timeout);
283         try {
284             waiter.waitAction(null);
285         } catch (InterruptedException JavaDoc e) {
286             throw new JemmyException("Exception while waiting for connection.", e);
287         }
288     }
289     
290     /** Increases timeout and waits until deployment is finished.
291      * @param test instance of JellyTestCase to get access to logs
292      * @param projectName name of deployed project
293      * @param target executed target
294      */
295     public static void waitFinished(JellyTestCase test, String JavaDoc projectName, String JavaDoc target) {
296         long oldTimeout = MainWindowOperator.getDefault().getTimeouts().getTimeout("Waiter.WaitingTime");
297         try {
298             // increase time to wait to 240 second (it fails on slower machines)
299 MainWindowOperator.getDefault().getTimeouts().setTimeout("Waiter.WaitingTime", 240000);
300             MainWindowOperator.getDefault().waitStatusText("Finished building "+projectName+" ("+target+")");
301         } finally {
302             // start status text tracer again because we use it further
303 MainWindowOperator.getDefault().getStatusTextTracer().start();
304             // restore default timeout
305 MainWindowOperator.getDefault().getTimeouts().setTimeout("Waiter.WaitingTime", oldTimeout);
306             // log messages from output
307 test.getLog("ServerMessages").print(new OutputTabOperator(Utils.DEFAULT_SERVER).getText()); // NOI18N
308 test.getLog("RunOutput").print(new OutputTabOperator(projectName).getText()); // NOI18N
309 }
310     }
311 }
312
Popular Tags