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: package org.netbeans.test.uml.componentdiagram;
043:
044: import java.awt.event.InputEvent;
045: import java.awt.event.KeyEvent;
046: import org.netbeans.jellytools.MainWindowOperator;
047: import org.netbeans.jellytools.ProjectsTabOperator;
048: import org.netbeans.jellytools.nodes.Node;
049: import org.netbeans.jellytools.properties.PropertySheetOperator;
050: import org.netbeans.jemmy.EventTool;
051: import org.netbeans.jemmy.JemmyException;
052: import org.netbeans.jemmy.JemmyProperties;
053: import org.netbeans.jemmy.operators.JButtonOperator;
054: import org.netbeans.jemmy.operators.JDialogOperator;
055: import org.netbeans.jemmy.operators.JMenuItemOperator;
056: import org.netbeans.jemmy.operators.JPopupMenuOperator;
057: import org.netbeans.jemmy.operators.JTreeOperator;
058: import org.netbeans.junit.NbTestSuite;
059: import org.netbeans.test.umllib.DiagramElementOperator;
060: import org.netbeans.test.umllib.DiagramOperator;
061: import org.netbeans.test.umllib.DrawingAreaOperator;
062: import org.netbeans.test.umllib.ElementTypes;
063: import org.netbeans.test.umllib.ExpandedElementTypes;
064: import org.netbeans.test.umllib.LinkOperator;
065: import org.netbeans.test.umllib.LinkTypes;
066: import org.netbeans.test.umllib.NewDiagramWizardOperator;
067: import org.netbeans.test.umllib.UMLPaletteOperator;
068: import org.netbeans.test.umllib.exceptions.NotFoundException;
069: import org.netbeans.test.umllib.testcases.UMLTestCase;
070: import org.netbeans.test.umllib.util.LabelsAndTitles;
071: import org.netbeans.test.umllib.util.LibProperties;
072:
073: /**
074: *
075: * @author psb
076: * @spec UML/ComponentDiagram.xml
077: */
078: public class ComponentDiagramElementsContextMenu2 extends UMLTestCase {
079:
080: //some system properties
081: private static String contextPropItemName = "Properties";
082: private static String umlPropertyWindowTitle = "Project Properties";
083: private static String umlSourcePackagesLabel = "Source Packages";
084: private static String umlSourcePackagesColumn = "Folder Label";
085: private static String umlSourceUsageColumn = "Model?";
086: private static String mainTreeTabName = "Projects";
087: //common test properties
088: private static String prName = "ComponentDiagramProjectECM2";
089: private static String project = prName + "|Model";
090: private static String sourceProject = "source";
091: private static boolean codeSync = false;
092: private static String defaultNewElementName = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultNewElementName;
093: private static String defaultReturnType = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultReturnType;
094: private static String defaultAttributeType = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultAttributeType;
095: private static String defaultAttributeVisibility = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultAttributeVisibility;
096: private static String defaultOperationVisibility = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultOperationVisibility;
097: private ProjectsTabOperator pto = null;
098: private Node lastDiagramNode = null;
099: private String lastTestCase = null;
100: private static String workdir = System.getProperty("xtest.workdir");
101: //
102: private static String activityDiagramName0 = "cpD";
103: private static String workPkg0 = "pkg";
104: private static long counter = 0;
105: //--
106: private static ExpandedElementTypes elementType1 = ExpandedElementTypes.COMPONENT;
107: private static String[] menuItems1 = { "Edit|Lock Edit",
108: "Resize Element to Contents", "Reset Edges",
109: "Hide|Parents|One Level", "Hide|Parents|All Levels",
110: "Hide|Children|One Level", "Hide|Children|All Levels",
111: "Show|Parents|One Level", "Show|Parents|All Levels",
112: "Show|Children|One Level", "Show|Children|All Levels",
113: "Generate Dependency Diagram",
114: elementType1.toString() + "|Font",
115: elementType1.toString() + "|Font Color",
116: elementType1.toString() + "|Background Color",
117: elementType1.toString() + "|Border Color" };
118: //--
119: private static LinkTypes elementType17 = LinkTypes.NESTED_LINK
120: .NESTED_LINK(LibProperties
121: .getCurrentToolName(ExpandedElementTypes.CLASS));
122: private static ExpandedElementTypes[] elements17 = {
123: ExpandedElementTypes.CLASS, ExpandedElementTypes.CLASS };
124: private static String[] menuItems17 = { "Redefine Operations",
125: "Find|Source Element", "Find|Target Element",
126: elementType17.toString() + "|Border Color" };
127: //--
128: private static LinkTypes elementType18 = LinkTypes.DELEGATE;
129: private static ExpandedElementTypes[] elements18 = {
130: ExpandedElementTypes.CLASS, ExpandedElementTypes.CLASS };
131: private static String[] menuItems18 = { "Labels|Reset Labels",
132: "Find|Source Element", "Find|Target Element",
133: elementType18.toString() + "|Border Color" };
134: //--
135: private static LinkTypes elementType19 = LinkTypes.ASSEMBLY;
136: private static ExpandedElementTypes[] elements19 = {
137: ExpandedElementTypes.COMPONENT,
138: ExpandedElementTypes.INTERFACE };
139: private static String[] menuItems19 = { "Labels|Reset Labels",
140: "Find|Source Element", "Find|Target Element",
141: LinkTypes.USAGE.toString() + "|Border Color" };
142: //--
143: private static LinkTypes elementType20 = LinkTypes.DEPENDENCY;
144: private static ExpandedElementTypes[] elements20 = {
145: ExpandedElementTypes.CLASS, ExpandedElementTypes.CLASS };
146: private static String[] menuItems20 = { "Labels|Name",
147: "Labels|Reset Labels", "Find|Source Element",
148: "Find|Target Element",
149: elementType20.toString() + "|Border Color" };
150: //
151: private static LinkTypes elementType21 = LinkTypes.COMMENT;
152: private static String[] menuItems21 = { "Find|Source Element",
153: "Find|Target Element",
154: elementType21.toString() + "|Border Color" };
155: //--
156: private static LinkTypes elementType22 = LinkTypes.REALIZE;
157: private static ExpandedElementTypes[] elements22 = {
158: ExpandedElementTypes.CLASS, ExpandedElementTypes.CLASS };
159: private static String[] menuItems22 = { "Labels|Name",
160: "Labels|Reset Labels", "Labels|Stereotype",
161: "Find|Source Element", "Find|Target Element",
162: elementType22.toString() + "|Border Color" };
163: //--
164: private static LinkTypes elementType23 = LinkTypes.USAGE;
165: private static ExpandedElementTypes[] elements23 = {
166: ExpandedElementTypes.CLASS, ExpandedElementTypes.CLASS };
167: private static String[] menuItems23 = { "Labels|Name",
168: "Labels|Reset Labels", "Labels|Stereotype",
169: "Find|Source Element", "Find|Target Element",
170: elementType23.toString() + "|Border Color" };
171: //--
172: private static LinkTypes elementType24 = LinkTypes.PERMISSION;
173: private static ExpandedElementTypes[] elements24 = {
174: ExpandedElementTypes.CLASS, ExpandedElementTypes.CLASS };
175: private static String[] menuItems24 = { "Labels|Name",
176: "Labels|Reset Labels", "Labels|Stereotype",
177: "Find|Source Element", "Find|Target Element",
178: elementType24.toString() + "|Border Color" };
179: //--
180: private static LinkTypes elementType25 = LinkTypes.ABSTRACTION;
181: private static ExpandedElementTypes[] elements25 = {
182: ExpandedElementTypes.CLASS, ExpandedElementTypes.CLASS };
183: private static String[] menuItems25 = { "Labels|Name",
184: "Labels|Reset Labels", "Labels|Stereotype",
185: "Find|Source Element", "Find|Target Element",
186: elementType25.toString() + "|Border Color" };
187: //--
188: private static LinkTypes elementType26 = LinkTypes.DERIVATION_EDGE;
189: private static ExpandedElementTypes[] elements26 = {
190: ExpandedElementTypes.DERIVATION_CLASSIFIER,
191: ExpandedElementTypes.TEMPLATE_CLASS };
192: private static String[] menuItems26 = { "Labels|Reset Labels",
193: "Labels|Binding", "Find|Source Element",
194: "Find|Target Element",
195: elementType26.toString() + "|Border Color" };
196: //--
197: private static LinkTypes elementType27 = LinkTypes.ASSOCIATION;
198: private static ExpandedElementTypes[] elements27 = {
199: ExpandedElementTypes.CLASS, ExpandedElementTypes.CLASS };
200: private static String[] menuItems27 = { "Labels|Link Name",
201: "Labels|Reset Labels", "Labels|Both End Names",
202: "Labels|Both End Multiplicities", "Find|Source Element",
203: "Find|Target Element",
204: elementType27.toString() + "|Border Color",
205: "Transform|To Ordinary Aggregate",
206: "Transform|To Composite Aggregate",
207: "Transform|Remove Aggregate", "Transform|Navigable",
208: "Transform|Reverse Ends" };
209: //--
210: private static LinkTypes elementType28 = LinkTypes.AGGREGATION;
211: private static ExpandedElementTypes[] elements28 = {
212: ExpandedElementTypes.CLASS, ExpandedElementTypes.CLASS };
213: private static String[] menuItems28 = { "Labels|Link Name",
214: "Labels|Reset Labels", "Labels|Both End Names",
215: "Labels|Both End Multiplicities", "Find|Source Element",
216: "Find|Target Element",
217: elementType28.toString() + "|Border Color",
218: "Transform|To Ordinary Aggregate",
219: "Transform|To Composite Aggregate",
220: "Transform|Remove Aggregate", "Transform|Navigable",
221: "Transform|Reverse Ends" };
222: //--
223: private static LinkTypes elementType29 = LinkTypes.COMPOSITION;
224: private static ExpandedElementTypes[] elements29 = {
225: ExpandedElementTypes.CLASS, ExpandedElementTypes.CLASS };
226: private static String[] menuItems29 = { "Labels|Link Name",
227: "Labels|Reset Labels", "Labels|Both End Names",
228: "Labels|Both End Multiplicities", "Find|Source Element",
229: "Find|Target Element",
230: elementType29.toString() + "|Border Color",
231: "Transform|To Ordinary Aggregate",
232: "Transform|To Composite Aggregate",
233: "Transform|Remove Aggregate", "Transform|Navigable",
234: "Transform|Reverse Ends" };
235: //--
236: private static LinkTypes elementType30 = LinkTypes.NAVIGABLE_ASSOCIATION;
237: private static ExpandedElementTypes[] elements30 = {
238: ExpandedElementTypes.CLASS, ExpandedElementTypes.CLASS };
239: private static String[] menuItems30 = { "Labels|Link Name",
240: "Labels|Reset Labels", "Labels|Both End Names",
241: "Labels|Both End Multiplicities", "Find|Source Element",
242: "Find|Target Element",
243: elementType30.toString() + "|Border Color",
244: "Transform|To Ordinary Aggregate",
245: "Transform|To Composite Aggregate",
246: "Transform|Remove Aggregate", "Transform|Navigable",
247: "Transform|Reverse Ends" };
248: //--
249: private static LinkTypes elementType31 = LinkTypes.NAVIGABLE_AGGREGATION;
250: private static ExpandedElementTypes[] elements31 = {
251: ExpandedElementTypes.CLASS, ExpandedElementTypes.CLASS };
252: private static String[] menuItems31 = { "Labels|Link Name",
253: "Labels|Reset Labels", "Labels|Both End Names",
254: "Labels|Both End Multiplicities", "Find|Source Element",
255: "Find|Target Element",
256: elementType31.toString() + "|Border Color",
257: "Transform|To Ordinary Aggregate",
258: "Transform|To Composite Aggregate",
259: "Transform|Remove Aggregate", "Transform|Navigable",
260: "Transform|Reverse Ends" };
261: //--
262: private static LinkTypes elementType32 = LinkTypes.NAVIGABLE_COMPOSITION;
263: private static ExpandedElementTypes[] elements32 = {
264: ExpandedElementTypes.CLASS, ExpandedElementTypes.CLASS };
265: private static String[] menuItems32 = { "Labels|Link Name",
266: "Labels|Reset Labels", "Labels|Both End Names",
267: "Labels|Both End Multiplicities", "Find|Source Element",
268: "Find|Target Element",
269: elementType32.toString() + "|Border Color",
270: "Transform|To Ordinary Aggregate",
271: "Transform|To Composite Aggregate",
272: "Transform|Remove Aggregate", "Transform|Navigable",
273: "Transform|Reverse Ends" };
274: //--
275: private static LinkTypes elementType33 = LinkTypes.ROLE_BINDING;
276: private static ExpandedElementTypes[] elements33 = {
277: ExpandedElementTypes.CLASS_ROLE,
278: ExpandedElementTypes.DESIGN_PATTERN };
279: private static String[] menuItems33 = { "Find|Source Element",
280: "Find|Target Element", "Class|Border Color" };
281: //common
282: private static String[] commonMenuItems = { "Edit|Copy",
283: "Edit|Cut", "Edit|Delete", "Edit|Paste", "Edit|Select All",
284: "Edit|Invert Selection",
285: "Edit|Select All Similar Elements",
286: "Synchronize Element with Data", "Select in Model",
287: "Properties", "Associate With...",
288: "Apply Design Pattern..." };
289: //
290: JTreeOperator prTree;
291:
292: /** Need to be defined because of JUnit */
293: public ComponentDiagramElementsContextMenu2(String name) {
294: super (name);
295: }
296:
297: public static NbTestSuite suite() {
298: NbTestSuite suite = new NbTestSuite(
299: org.netbeans.test.uml.componentdiagram.ComponentDiagramElementsContextMenu2.class);
300: return suite;
301: }
302:
303: private DiagramOperator createDiagram(String project,
304: String workPkg, String diagram) {
305: //
306: org.netbeans.test.umllib.Utils.RetAll rt = org.netbeans.test.umllib.Utils
307: .createDiagram(project, workPkg, diagram,
308: NewDiagramWizardOperator.COMPONENT_DIAGRAM);
309: pto = rt.pto;
310: prTree = new JTreeOperator(pto);
311: lastDiagramNode = rt.lastDiagramNode;
312: return rt.dOp;
313: }
314:
315: public void testCreate17() {
316: testLinkContext(elementType17, elements17, menuItems17);
317: }
318:
319: public void testCreate18() {
320: testLinkContext(elementType18, elements18, menuItems18);
321: }
322:
323: public void testCreate19() {
324: testLinkContext(elementType19, elements19, menuItems19);
325: }
326:
327: public void testCreate20() {
328: testLinkContext(elementType20, elements20, menuItems20);
329: }
330:
331: public void testCreate22() {
332: testLinkContext(elementType22, elements22, menuItems22);
333: }
334:
335: public void testCreate23() {
336: testLinkContext(elementType23, elements23, menuItems23);
337: }
338:
339: public void testCreate24() {
340: testLinkContext(elementType24, elements24, menuItems24);
341: }
342:
343: public void testCreate25() {
344: testLinkContext(elementType25, elements25, menuItems25);
345: }
346:
347: public void testCreate26() {
348: testLinkContext(elementType26, elements26, menuItems26);
349: }
350:
351: public void testCreate27() {
352: testLinkContext(elementType27, elements27, menuItems27);
353: }
354:
355: public void testCreate28() {
356: testLinkContext(elementType28, elements28, menuItems28);
357: }
358:
359: public void testCreate29() {
360: testLinkContext(elementType29, elements29, menuItems29);
361: }
362:
363: public void testCreate30() {
364: testLinkContext(elementType30, elements30, menuItems30);
365: }
366:
367: public void testCreate31() {
368: testLinkContext(elementType31, elements31, menuItems31);
369: }
370:
371: public void testCreate32() {
372: testLinkContext(elementType32, elements32, menuItems32);
373: }
374:
375: public void testCreate33() {
376: testLinkContext(elementType33, elements33, menuItems33);
377: }
378:
379: public void testLinkComment() {
380: lastTestCase = getCurrentTestMethodName();
381: String[] customMenuItems = menuItems21;
382: String element = LibProperties.getProperties()
383: .getCurrentToolName(elementType21);
384: LinkTypes elementType = elementType21;
385: //
386: String workPkg = workPkg0 + counter;
387: String diagramName = activityDiagramName0 + counter;
388: counter++;
389: String localElName1 = "El1";
390: //
391: DiagramOperator d = createDiagram(project, workPkg, diagramName);
392: //
393: UMLPaletteOperator pl = new UMLPaletteOperator();
394: DrawingAreaOperator drAr = d.getDrawingArea();
395: //
396: java.awt.Point a = drAr.getFreePoint();
397: DiagramElementOperator dE1 = null;
398: DiagramElementOperator dE2 = null;
399: dE1 = d.putElementOnDiagram(localElName1, elementType1, a.x,
400: a.y);
401: //
402: pl.selectTool(element);
403: //
404: drAr.clickMouse(dE1.getCenterPoint().x, dE1.getCenterPoint().y,
405: 1);
406: a = drAr.getFreePoint(150);
407: drAr.clickMouse(a.x, a.y, 1);
408: dE2 = new DiagramElementOperator(d, "",
409: ElementTypes.LINK_COMMENT);
410: //
411: drAr.pushKey(KeyEvent.VK_ESCAPE);
412: pl.waitSelection(element, false);
413: new EventTool().waitNoEvent(500);
414: //
415: try {
416: Thread.sleep(500);
417: } catch (Exception ex) {
418: }
419: a = drAr.getFreePoint(100);
420: drAr.clickMouse(a.x, a.y, 1, InputEvent.BUTTON3_MASK);
421: drAr.pushKey(KeyEvent.VK_ESCAPE);
422: //
423: LinkOperator testedlink = LinkOperator.findLink(dE1, dE2,
424: new LinkOperator.LinkByTypeChooser(elementType), 0);
425: if (testedlink == null) {
426: LinkOperator altLink = null;
427: try {
428: altLink = LinkOperator.findLink(dE1, dE2,
429: new LinkOperator.LinkByTypeChooser(
430: LinkTypes.ANY), 0);
431: } catch (Exception ex) {
432: fail("any link find failed.");
433: }
434: if (altLink != null) {
435: fail("Can't find " + elementType
436: + " link between elements, but the is "
437: + altLink.getType() + " link.");
438: }
439: }
440: //
441: assertTrue("Can't find " + elementType
442: + " link between elements", testedlink != null);
443: drAr.clickMouse(testedlink.getNearCenterPoint().x, testedlink
444: .getNearCenterPoint().y, 1, InputEvent.BUTTON3_MASK);
445: verify(customMenuItems);
446: }
447:
448: public void setUp() {
449: System.out.println("######## " + getName() + " #######");
450: pto = ProjectsTabOperator.invoke();
451: if (!codeSync) {
452: org.netbeans.test.uml.componentdiagram.utils.Utils
453: .commonComponentDiagramSetup(workdir, prName);
454: //
455: codeSync = true;
456: }
457: }
458:
459: public void tearDown() {
460: org.netbeans.test.umllib.util.Utils
461: .makeScreenShot(lastTestCase);
462: //popup protection
463: MainWindowOperator.getDefault().pushKey(KeyEvent.VK_ESCAPE);
464: new EventTool().waitNoEvent(1000);
465: //
466: closeAllModal();
467: org.netbeans.test.umllib.util.Utils.saveAll();
468: if (lastDiagramNode != null) {
469: lastDiagramNode.collapse();
470: new Node(lastDiagramNode.tree(), lastDiagramNode
471: .getParentPath()).collapse();
472: }
473: try {
474: DiagramOperator d = new DiagramOperator("cpD");
475: d.closeAllDocuments();
476: d.waitClosed();
477: new EventTool().waitNoEvent(1000);
478: } catch (Exception ex) {
479: }
480: ;
481: closeAllModal();
482: //save
483: org.netbeans.test.umllib.util.Utils.tearDown();
484: }
485:
486: private void testElementContext(ExpandedElementTypes elementType,
487: String[] customMenuItems) {
488: lastTestCase = getCurrentTestNamesWithCheck()[1];
489: String elementName = LibProperties
490: .getCurrentDefaultName(elementType);
491: String element = LibProperties.getProperties()
492: .getCurrentToolName(elementType);
493: //
494: String workPkg = workPkg0 + counter;
495: String diagramName = activityDiagramName0 + counter;
496: counter++;
497: //
498: DiagramOperator d = createDiagram(project, workPkg, diagramName);
499: //
500: int numChild = lastDiagramNode.getChildren().length;
501: //
502: UMLPaletteOperator pl = new UMLPaletteOperator();
503: pl.waitComponentShowing(true);
504: pl.waitComponentVisible(true);
505: //
506: try {
507: pl.selectTool(element);
508: } catch (NotFoundException ex) {
509: fail("BLOCKING: Can't find '" + element + "' in paletter");
510: }
511: //
512: DrawingAreaOperator drAr = d.getDrawingArea();
513: java.awt.Point a = drAr.getFreePoint();
514: drAr.clickMouse(a.x, a.y, 1);
515: drAr.pushKey(KeyEvent.VK_ESCAPE);
516: pl.waitSelection(element, false);
517: new EventTool().waitNoEvent(500);
518: //
519: try {
520: Thread.sleep(500);
521: } catch (Exception ex) {
522: }
523: a = drAr.getFreePoint(100);
524: drAr.clickMouse(a.x, a.y, 1, InputEvent.BUTTON3_MASK);
525: drAr.pushKey(KeyEvent.VK_ESCAPE);
526: //
527: DiagramElementOperator dEl = null;
528: try {
529: dEl = new DiagramElementOperator(d, elementName,
530: elementType, 0);
531: } catch (Exception ex) {
532: try {
533: fail(element
534: + " wasn't added to diagram, but object with type:"
535: + new DiagramElementOperator(d, elementName)
536: .getType()
537: + ": and element type :"
538: + new DiagramElementOperator(d, elementName)
539: .getElementType()
540: + ": was added whyle type should be :"
541: + elementType + ": was added");
542: } catch (Exception ex2) {
543: }
544: fail(element + " wasn't added to diagram.");
545: }
546: dEl.select();
547: //call popup
548: drAr.clickMouse(dEl.getCenterPoint().x, dEl.getCenterPoint().y,
549: 1, InputEvent.BUTTON3_MASK);
550: verify(customMenuItems);
551: }
552:
553: private void testLinkContext(LinkTypes elementType,
554: ExpandedElementTypes[] elements, String[] customMenuItems) {
555: lastTestCase = getCurrentTestNamesWithCheck()[1];
556: String elementName = LibProperties
557: .getCurrentDefaultName(elementType);
558: String element = LibProperties.getCurrentToolName(elementType);
559: //
560: String workPkg = workPkg0 + counter;
561: String diagramName = activityDiagramName0 + counter;
562: counter++;
563: String localElName1 = "El1";
564: String localElName2 = "El2";
565: //
566: DiagramOperator d = createDiagram(project, workPkg, diagramName);
567: //
568: UMLPaletteOperator pl = new UMLPaletteOperator();
569: DrawingAreaOperator drAr = d.getDrawingArea();
570: //
571: java.awt.Point a = drAr.getFreePoint();
572: DiagramElementOperator dE1 = null;
573: DiagramElementOperator dE2 = null;
574: dE1 = d
575: .putElementOnDiagram(localElName1, elements[0], a.x,
576: a.y);
577: a = drAr.getFreePoint(150);
578: dE2 = d
579: .putElementOnDiagram(localElName2, elements[1], a.x,
580: a.y);
581: //
582: try {
583: pl.selectTool(element);
584: } catch (NotFoundException ex) {
585: fail("BLOCKING: Can't find '" + element + "' in paletter");
586: }
587: //
588: drAr.clickMouse(dE1.getCenterPoint().x, dE1.getCenterPoint().y,
589: 1);
590: drAr.clickMouse(dE2.getCenterPoint().x, dE2.getCenterPoint().y,
591: 1);
592: //
593: drAr.pushKey(KeyEvent.VK_ESCAPE);
594: pl.waitSelection(element, false);
595: new EventTool().waitNoEvent(500);
596: //
597: try {
598: Thread.sleep(500);
599: } catch (Exception ex) {
600: }
601: a = drAr.getFreePoint(100);
602: drAr.clickMouse(a.x, a.y, 1, InputEvent.BUTTON3_MASK);
603: drAr.pushKey(KeyEvent.VK_ESCAPE);
604: //"workaround for assembly connector"
605: if (elementType.equals(LinkTypes.ASSEMBLY)) {
606: dE1 = new DiagramElementOperator(d, "",
607: ExpandedElementTypes.PORT, 0);
608: elementType = LinkTypes.USAGE;
609: }
610: //
611: LinkOperator testedlink = null;
612: try {
613: /* In netbeans6.0 composition and navigable composition link are shown as aggregation in
614: * project view as they are special form of aggregation. See Issue 116868
615: * Similar to navigable aggregation and navigable association.The default name
616: * aggrgation and association are used in project modle.
617: * As workaround for test, here set type to their default type.
618: */
619: LinkTypes elementTypeInProjectTree = elementType;
620: if ((elementType == LinkTypes.COMPOSITION)
621: || (elementType == LinkTypes.NAVIGABLE_COMPOSITION))
622: elementTypeInProjectTree = LinkTypes.AGGREGATION;
623: if (elementType == LinkTypes.NAVIGABLE_AGGREGATION)
624: elementTypeInProjectTree = LinkTypes.AGGREGATION;
625: if (elementType == LinkTypes.NAVIGABLE_ASSOCIATION)
626: elementTypeInProjectTree = LinkTypes.ASSOCIATION;
627: testedlink = LinkOperator.findLink(dE1, dE2,
628: new LinkOperator.LinkByTypeChooser(
629: elementTypeInProjectTree), 0);
630: } catch (Exception ex) {
631: fail(element + " of type " + elementType
632: + " wasn't added to diagram.");
633: }
634: if (testedlink == null) {
635: LinkOperator altLink = null;
636: try {
637: altLink = LinkOperator.findLink(dE1, dE2,
638: new LinkOperator.LinkByTypeChooser(
639: LinkTypes.ANY), 0);
640: } catch (Exception ex) {
641: fail("any link find failed.");
642: }
643: if (altLink != null) {
644: fail("Can't find " + elementType
645: + " link between elements, but the is "
646: + altLink.getType() + " link.");
647: }
648: }
649: //
650: if (testedlink == null
651: && elementType.equals(LinkTypes.ACTIVITY_EDGE)) {
652: //fail("Can't find Activity Edge/MultiFlow link between elemens, may be test library limitation, please recheck manually.");
653: } else {
654: assertTrue("Can't find " + elementType
655: + " link between elements", testedlink != null);
656: }
657: //
658: if (elementType.equals(LinkTypes.ACTIVITY_EDGE)) {
659: //tried to get popup for activity edge
660: drAr
661: .clickMouse((dE1.getCenterPoint().x + dE2
662: .getCenterPoint().x) / 2,
663: (dE1.getCenterPoint().y + dE2
664: .getCenterPoint().y) / 2, 1,
665: InputEvent.BUTTON3_MASK);
666: } else {
667: drAr.clickMouse(testedlink.getNearCenterPoint().x,
668: testedlink.getNearCenterPoint().y, 1,
669: InputEvent.BUTTON3_MASK);
670: }
671: verify(customMenuItems);
672: }
673:
674: private void verify(String[] add) {
675: JPopupMenuOperator pop = new JPopupMenuOperator();
676: pop.waitComponentShowing(true);
677: try {
678: Thread.sleep(500);
679: } catch (Exception ex) {
680: }
681: //workaround for 78301
682: pop.pushKey(KeyEvent.VK_LEFT);
683: //
684: try {
685: Thread.sleep(500);
686: } catch (Exception ex) {
687: }
688: //
689: pop = new JPopupMenuOperator();
690: //
691: String fails = "";
692: for (int i = 0; i < commonMenuItems.length; i++) {
693: JMenuItemOperator it = null;
694: try {
695: it = pop.showMenuItem(commonMenuItems[i]);
696: if (it == null) {
697: fails += "Null item " + commonMenuItems[i] + ";\n";
698: org.netbeans.test.umllib.util.Utils
699: .makeScreenShot();
700: }
701: } catch (Exception ex) {
702: fails += "Timeout on selection of "
703: + commonMenuItems[i] + ";\n";
704: org.netbeans.test.umllib.util.Utils.makeScreenShot();
705: }
706: //returns back from inner popup
707: if (commonMenuItems[i].indexOf("|") > -1) {
708: new EventTool().waitNoEvent(500);
709: pop.pushKey(KeyEvent.VK_LEFT);
710: new EventTool().waitNoEvent(500);
711: pop.pushKey(KeyEvent.VK_LEFT);
712: }
713: }
714: if (add != null) {
715: for (int i = 0; i < add.length; i++) {
716: JMenuItemOperator it = null;
717: try {
718: it = pop.showMenuItem(add[i]);
719: if (it == null) {
720: fails += "Null item " + add[i] + ";\n";
721: org.netbeans.test.umllib.util.Utils
722: .makeScreenShot(lastTestCase);
723: }
724: } catch (Exception ex) {
725: fails += "Timeout on selection of " + add[i]
726: + ";\n";
727: org.netbeans.test.umllib.util.Utils
728: .makeScreenShot(lastTestCase);
729: }
730: //returns back from inner popup
731: if (add[i].indexOf("|") > -1) {
732: new EventTool().waitNoEvent(500);
733: pop.pushKey(KeyEvent.VK_LEFT);
734: new EventTool().waitNoEvent(500);
735: pop.pushKey(KeyEvent.VK_LEFT);
736: }
737: }
738: }
739: //
740: assertTrue("There are some problems with context menu: "
741: + fails, fails.length() == 0);
742: }
743: }
|