001: /*
002: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
003: *
004: * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
005: *
006: * The contents of this file are subject to the terms of either the GNU
007: * General Public License Version 2 only ("GPL") or the Common
008: * Development and Distribution License("CDDL") (collectively, the
009: * "License"). You may not use this file except in compliance with the
010: * License. You can obtain a copy of the License at
011: * http://www.netbeans.org/cddl-gplv2.html
012: * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
013: * specific language governing permissions and limitations under the
014: * License. When distributing the software, include this License Header
015: * Notice in each file and include the License file at
016: * nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
017: * particular file as subject to the "Classpath" exception as provided
018: * by Sun in the GPL Version 2 section of the License file that
019: * accompanied this code. If applicable, add the following below the
020: * License Header, with the fields enclosed by brackets [] replaced by
021: * your own identifying information:
022: * "Portions Copyrighted [year] [name of copyright owner]"
023: *
024: * Contributor(s):
025: *
026: * The Original Software is NetBeans. The Initial Developer of the Original
027: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
028: * Microsystems, Inc. All Rights Reserved.
029: *
030: * If you wish your version of this file to be governed by only the CDDL
031: * or only the GPL Version 2, indicate your decision by adding
032: * "[Contributor] elects to include this software in this distribution
033: * under the [CDDL or GPL Version 2] license." If you do not indicate a
034: * single choice of license, a recipient has the option to distribute
035: * your version of this file under either the CDDL, the GPL Version 2 or
036: * to extend the choice of license to its licensees as provided above.
037: * However, if you add GPL Version 2 code and therefore, elected the GPL
038: * Version 2 license, then the option applies only if the new code is
039: * made subject to such option by the copyright holder.
040: */
041:
042: /**
043: * Utils.java
044: *
045: * Created on February 10, 2005, 6:38 PM
046: *
047: * This Utils is used for UML related functions (use qa.uml.util.Utils for common functions)
048: */package org.netbeans.test.umllib;
049:
050: import javax.swing.SwingUtilities;
051:
052: import org.netbeans.jellytools.ProjectsTabOperator;
053: import org.netbeans.jellytools.nodes.Node;
054: import org.netbeans.jellytools.nodes.ProjectRootNode;
055: import org.netbeans.jemmy.EventTool;
056: import org.netbeans.jemmy.JemmyProperties;
057: import org.netbeans.jemmy.operators.JButtonOperator;
058: import org.netbeans.jemmy.operators.JDialogOperator;
059: import org.netbeans.jemmy.operators.JPopupMenuOperator;
060: import org.netbeans.test.umllib.project.ProjectType;
061: import org.netbeans.test.umllib.project.UMLProject;
062:
063: /**
064: *
065: * @author Alexei Mokeev
066: */
067: public class Utils {
068:
069: /** Creates a new instance of Utils */
070: public Utils() {
071: }
072:
073: private static EventTool eventTool = new EventTool();
074: private final static String DONE_BTN = "Done";
075: private final static String OK_BTN = "OK";
076: private final static String FINISH_BTN = "Finish";
077: private final static String CANCEL_BTN = "Cancel";
078:
079: public static void waitSwing() {
080: try {
081: SwingUtilities.invokeAndWait(new Runnable() {
082: public void run() {
083: try {
084: Thread.sleep(50);
085: } catch (InterruptedException e) {
086: }
087: }
088: });
089: } catch (Exception e) {
090: e.printStackTrace();
091: }
092: }
093:
094: /**
095: *
096: * @deprecated use createProject from qa.uml.project.UMLProject class directly
097: * @param projectName
098: * @param javaProject
099: * @param projectPath
100: */
101: public static void createUMLProjectFromJavaProject(
102: String projectName, String javaProject, String projectPath) {
103: UMLProject.createProject(projectName,
104: ProjectType.UML_JAVA_REVERSE_ENGINEERING, projectPath,
105: javaProject);
106: }
107:
108: /**
109: *
110: * @deprecated use createProject from qa.uml.project.UMLProject class directly
111: * @param pName
112: * @param path
113: */
114: public static void createJavaUMLProject(String pName, String path) {
115: UMLProject.createProject(pName,
116: ProjectType.UML_JAVA_PLATFORM_MODEL, path);
117: }
118:
119: /**
120: *
121: * @deprecated use createProject from qa.uml.project.UMLProject class directly
122: * @param pName
123: * @param path
124: */
125: public static void createAnalysisUMLProject(String pName,
126: String path) {
127: UMLProject.createProject(pName,
128: ProjectType.UML_PLATFORM_INDEPENDET_MODEL, path);
129: }
130:
131: /**
132: *
133: * @deprecated use createProject from qa.uml.project.UMLProject class directly
134: * @param projectName
135: * @param javaProject
136: * @param projectPath
137: */
138:
139: public static void createReverseEngineeringUMLProject(
140: String projectName, String javaProject, String projectPath) {
141: UMLProject.createProject(projectName,
142: ProjectType.UML_JAVA_REVERSE_ENGINEERING, projectPath,
143: javaProject);
144: }
145:
146: /**
147: *
148: * @deprecated it's common action and should be moved to qa.uml.util.Utils
149: */
150:
151: public static void closeSaveDlg() {
152: new Thread(new Runnable() {
153: public void run() {
154: long timeoutValDlg = JemmyProperties
155: .getCurrentTimeout("DialogWaiter.WaitDialogTimeout");
156: try {
157: new EventTool().waitNoEvent(3000);
158: //Thread.sleep(3000);
159: JemmyProperties.setCurrentTimeout(
160: "DialogWaiter.WaitDialogTimeout", 10000);
161: JDialogOperator saveDlg = new JDialogOperator(
162: "Save");
163: new JButtonOperator(saveDlg, "Save All")
164: .pushNoBlock();
165: } catch (Exception e) {
166: } finally {
167: JemmyProperties.setCurrentTimeout(
168: "DialogWaiter.WaitDialogTimeout",
169: timeoutValDlg);
170: }
171: }
172: }).start();
173: }
174:
175: /**
176: * creates diagram in top level package of project, create package if there is no package with name
177: *
178: * @param project
179: * @param workPkg
180: * @param diagram
181: * @param diagramType
182: * @return
183: */
184: public static RetAll createDiagram(String project, String workPkg,
185: String diagram, String diagramType) {
186: return createOrOpenDiagram(project, workPkg, diagram,
187: diagramType, true);
188: }
189:
190: /**
191: * creates diagram in top level package of project, create package if there is no package with name
192: *
193: * @param project
194: * @param workPkg
195: * @param diagram
196: * @param diagramType
197: * @param createonly
198: * @return
199: */
200: private static RetAll createOrOpenDiagram(String project,
201: String workPkg, String diagram, String diagramType,
202: boolean createonly) {
203: //user can pass project name or name with |Model, we need prName|Model in method
204: if (project.lastIndexOf("|Model") != (project.length() - "|Model"
205: .length())
206: || project.lastIndexOf("|Model") == -1)
207: project = project + "|Model";
208: ProjectsTabOperator pto = ProjectsTabOperator.invoke();
209: new EventTool().waitNoEvent(1000);
210: ProjectRootNode root = new ProjectRootNode(pto.tree(), project);
211: //*workaround for some fails in jelly
212: root.tree().waitVisible(root.getTreePath());
213: root.tree().expandPath(root.getTreePath());
214: root.tree().waitExpanded(root.getTreePath());
215: try {
216: Thread.sleep(1000);
217: } catch (Exception ex) {
218: }
219: java.awt.Rectangle pth = root.tree().getPathBounds(
220: root.getTreePath());
221: root.tree().moveMouse(pth.x + pth.width / 3,
222: pth.y + pth.height / 2);
223: new EventTool().waitNoEvent(1000);
224: //*workaround finished
225: root.select();
226: root.tree().waitSelected(root.getTreePath());
227: if (root.isChildPresent(workPkg)) {
228: if ((!createonly)
229: && new Node(root, workPkg).isChildPresent(diagram)) {
230: new Node(root, workPkg + "|" + diagram).callPopup()
231: .pushMenu("Open");
232: } else {
233: Node pkgN = new Node(root, workPkg);
234: pkgN.callPopup().pushMenuNoBlock("New|Diagram");
235: NewDiagramWizardOperator nw = new NewDiagramWizardOperator();
236: nw.setDiagramType(diagramType);
237: nw.setDiagramName(diagram);
238: nw.clickFinish();
239: }
240: } else {
241: JPopupMenuOperator pop = root.callPopup();
242: pop.waitComponentVisible(true);
243: pop.waitComponentShowing(true);
244: pop.pushMenuNoBlock("New|Package");
245: NewPackageWizardOperator nw = new NewPackageWizardOperator();
246: nw.setScopedDiagram(workPkg, diagram, diagramType);
247: nw.clickFinish();
248: }
249: new EventTool().waitNoEvent(500);
250: try {
251: Thread.sleep(500);
252: } catch (Exception ex) {
253: }
254: DiagramOperator ret = null;
255: ret = new DiagramOperator(diagram);
256: ret.waitComponentShowing(true);
257: Node lastDiagramNode = new Node(root, workPkg + "|" + diagram);
258: new EventTool().waitNoEvent(500);
259: try {
260: Thread.sleep(500);
261: } catch (Exception ex) {
262: }
263: return new RetAll(pto, lastDiagramNode, ret);
264: }
265:
266: /**
267: * creates diagram in top level package of project, create package if there is no package with name
268: *
269: * @param project
270: * @param workPkg
271: * @param diagram
272: * @param diagramType
273: * @return
274: */
275: public static RetAll createOrOpenDiagram(String project,
276: String workPkg, String diagram, String diagramType) {
277: return createOrOpenDiagram(project, workPkg, diagram,
278: diagramType, false);
279: }
280:
281: /**
282: * creates create top level package if there is no package with name
283: *
284: * @param project
285: * @param workPkg
286:
287: * @return
288: */
289: public static Node createPackage(String project, String workPkg) {
290: //user can pass project name or name with |Model, we need prName|Model in method
291: if (project.lastIndexOf("|Model") != (project.length() - "|Model"
292: .length()))
293: project = project + "|Model";
294: //
295: ProjectsTabOperator pto = ProjectsTabOperator.invoke();
296: new EventTool().waitNoEvent(1000);
297: ProjectRootNode root = new ProjectRootNode(pto.tree(), project);
298: //*workaround for some fails in jelly
299: root.tree().waitVisible(root.getTreePath());
300: root.tree().expandPath(root.getTreePath());
301: root.tree().waitExpanded(root.getTreePath());
302: try {
303: Thread.sleep(1000);
304: } catch (Exception ex) {
305: }
306: java.awt.Rectangle pth = root.tree().getPathBounds(
307: root.getTreePath());
308: root.tree().moveMouse(pth.x + pth.width / 3,
309: pth.y + pth.height / 2);
310: new EventTool().waitNoEvent(1000);
311: //*workaround finished
312: root.select();
313: root.tree().waitSelected(root.getTreePath());
314: if (root.isChildPresent(workPkg)) {
315: } else {
316: JPopupMenuOperator pop = root.callPopup();
317: pop.waitComponentVisible(true);
318: pop.waitComponentShowing(true);
319: pop.pushMenuNoBlock("New|Package");
320: NewPackageWizardOperator nw = new NewPackageWizardOperator();
321: nw.setPackageName(workPkg);
322: nw.clickFinish();
323: }
324: new EventTool().waitNoEvent(500);
325: Node lastDiagramNode = new Node(root, workPkg);
326: new EventTool().waitNoEvent(500);
327: return lastDiagramNode;
328: }
329:
330: /**
331: * helper class to return several values from createDiagram
332: */
333: public static class RetAll {
334: public ProjectsTabOperator pto;
335: /**
336: * diagram's node in project tree
337: */
338: public Node lastDiagramNode;
339: /**
340: * diagram operator
341: */
342: public DiagramOperator dOp;
343:
344: /**
345: *
346: * @param pto
347: * @param lastDiagramNode
348: * @param dOp
349: */
350: RetAll(ProjectsTabOperator pto, Node lastDiagramNode,
351: DiagramOperator dOp) {
352: this.pto = pto;
353: this.lastDiagramNode = lastDiagramNode;
354: this.dOp = dOp;
355: }
356: }
357: }
|