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.KeyEvent;
045: import java.util.Iterator;
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.operators.JTreeOperator;
052:
053: import org.netbeans.junit.NbTestSuite; //import qa.uml.UMLClassOperator;
054: import org.netbeans.test.umllib.DiagramElementOperator;
055: import org.netbeans.test.umllib.DiagramOperator;
056: import org.netbeans.test.umllib.DrawingAreaOperator;
057: import org.netbeans.test.umllib.ElementTypes;
058: import org.netbeans.test.umllib.LinkOperator;
059: import org.netbeans.test.umllib.LinkTypes;
060: import org.netbeans.test.umllib.NewDiagramWizardOperator;
061: import org.netbeans.test.umllib.UMLPaletteOperator;
062: import org.netbeans.test.umllib.exceptions.NotFoundException;
063: import org.netbeans.test.umllib.testcases.UMLTestCase;
064:
065: /**
066: *
067: * @author psb
068: * @spec uml/UML-EditControl.xml
069: */
070: public class PlaceMultipleLinks extends UMLTestCase {
071: //
072: private int counter = 0;
073: //some system properties
074: private static String contextPropItemName = "Properties";
075: private static String umlPropertyWindowTitle = "Project Properties";
076: private static String umlSourcePackagesLabel = "Source Packages";
077: private static String umlSourcePackagesColumn = "Folder Label";
078: private static String umlSourceUsageColumn = "Model?";
079: private static String mainTreeTabName = "Projects";
080: //common test properties
081: private static String prName = "componentDiagramProjectML";
082: private static String project = prName + "|Model";
083: private static String sourceProject = "source";
084: private static boolean codeSync = false;
085: private static String defaultNewElementName = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultNewElementName;
086: private static String defaultReturnType = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultReturnType;
087: private static String defaultAttributeType = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultAttributeType;
088: private static String defaultAttributeVisibility = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultAttributeVisibility;
089: private static String defaultOperationVisibility = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultOperationVisibility;
090: private ProjectsTabOperator pto = null;
091: private Node lastDiagramNode = null;
092: private JTreeOperator prTree = null;
093: private static String workdir = System.getProperty("xtest.workdir");
094: private String lastTestCase = null;
095: //--
096: private static String componentDiagramName1 = "cpD1";
097: private static String workPkg1 = "pkg1";
098: private static String element1 = "Generalization";
099: private static String treeNode1 = element1;
100: private static String elementName1 = "";
101: private static LinkTypes elementType1 = LinkTypes.GENERALIZATION;
102: private static ElementTypes fromType1 = ElementTypes.CLASS;
103: private static ElementTypes toType1 = ElementTypes.CLASS;
104: private static boolean eIO1 = false;
105: //--
106: private static String componentDiagramName2 = "cpD2";
107: private static String workPkg2 = "pkg2";
108: private static String element2 = "Implementation";
109: private static String treeNode2 = element2;
110: private static String elementName2 = "";
111: private static LinkTypes elementType2 = LinkTypes.IMPLEMENTATION;
112: private static ElementTypes fromType2 = ElementTypes.CLASS;
113: private static ElementTypes toType2 = ElementTypes.INTERFACE;
114: private static boolean eIO2 = false;
115: //--
116: //SPECIAL CASE
117: /* private static String componentDiagramName3 = "cpD3";
118: private static String workPkg3 = "pkg3";
119: private static String element3="Nested Link";
120: private static String treeNode3=element3;
121: private static String elementName3=defaultNewElementName;
122: private static LinkTypes elementType3=LinkTypes.NESTED_LINK;
123: private static ElementTypes fromType3=ElementTypes.CLASS;
124: private static ElementTypes toType3=ElementTypes.CLASS;
125: private static boolean eIO3=false;*/
126: //--
127: private static String componentDiagramName4 = "cpD4";
128: private static String workPkg4 = "pkg4";
129: private static String element4 = "Delegate";
130: private static String treeNode4 = element4;
131: private static String elementName4 = "";
132: private static LinkTypes elementType4 = LinkTypes.DELEGATE;
133: private static ElementTypes fromType4 = ElementTypes.CLASS;
134: private static ElementTypes toType4 = ElementTypes.COMPONENT;
135: private static boolean eIO4 = false;
136: //--
137: //SPECIAL CASE
138: /*private static String componentDiagramName5 = "cpD5";
139: private static String workPkg5 = "pkg5";
140: private static String element5="Assembly Connector";
141: private static String treeNode5=element5;
142: private static String elementName5="";
143: private static LinkTypes elementType5=LinkTypes.USAGE;
144: private static ElementTypes fromType5=ElementTypes.COMPONENT;
145: private static ElementTypes toType5=ElementTypes.INTERFACE;
146: private static boolean eIO5=false;*/
147: //--
148: private static String componentDiagramName6 = "cpD6";
149: private static String workPkg6 = "pkg6";
150: private static String element6 = "Derivation Edge";
151: private static String treeNode6 = element6;
152: private static String elementName6 = "";
153: private static LinkTypes elementType6 = LinkTypes.DERIVATION_EDGE;
154: private static ElementTypes fromType6 = ElementTypes.DERIVATION_CLASSIFIER;
155: private static ElementTypes toType6 = ElementTypes.TEMPLATE_CLASS;
156: private static boolean eIO6 = false;
157: //--
158: private static String componentDiagramName7 = "cpD7";
159: private static String workPkg7 = "pkg7";
160: private static String element7 = "Association";
161: private static String treeNode7 = element7;
162: private static String elementName7 = "";
163: private static LinkTypes elementType7 = LinkTypes.ASSOCIATION;
164: private static ElementTypes fromType7 = ElementTypes.COMPONENT;
165: private static ElementTypes toType7 = ElementTypes.CLASS;
166: private static boolean eIO7 = false;
167: //--
168: private static String componentDiagramName8 = "cpD8";
169: private static String workPkg8 = "pkg8";
170: private static String element8 = "Composition";
171: private static String treeNode8 = element8;
172: private static String elementName8 = "";
173: private static LinkTypes elementType8 = LinkTypes.COMPOSITION;
174: private static ElementTypes fromType8 = ElementTypes.COMPONENT;
175: private static ElementTypes toType8 = ElementTypes.CLASS;
176: private static boolean eIO8 = false;
177: //--
178: private static String componentDiagramName9 = "cpD9";
179: private static String workPkg9 = "pkg9";
180: private static String element9 = "Navigable Composition";
181: private static String treeNode9 = "Composition";
182: private static String elementName9 = "";
183: private static LinkTypes elementType9 = LinkTypes.NAVIGABLE_COMPOSITION;
184: private static ElementTypes fromType9 = ElementTypes.COMPONENT;
185: private static ElementTypes toType9 = ElementTypes.CLASS;
186: private static boolean eIO9 = false;
187: //--
188: private static String componentDiagramName10 = "cpD10";
189: private static String workPkg10 = "pkg10";
190: private static String element10 = "Aggregation";
191: private static String treeNode10 = element10;
192: private static String elementName10 = "";
193: private static LinkTypes elementType10 = LinkTypes.AGGREGATION;
194: private static ElementTypes fromType10 = ElementTypes.COMPONENT;
195: private static ElementTypes toType10 = ElementTypes.CLASS;
196: private static boolean eIO10 = false;
197: //--
198: private static String componentDiagramName11 = "cpD11";
199: private static String workPkg11 = "pkg11";
200: private static String element11 = "Navigable Aggregation";
201: private static String treeNode11 = element11;
202: private static String elementName11 = "";
203: private static LinkTypes elementType11 = LinkTypes.NAVIGABLE_AGGREGATION;
204: private static ElementTypes fromType11 = ElementTypes.COMPONENT;
205: private static ElementTypes toType11 = ElementTypes.CLASS;
206: private static boolean eIO11 = false;
207: //--
208: private static String componentDiagramName12 = "cpD12";
209: private static String workPkg12 = "pkg12";
210: private static String element12 = "Navigable Association";
211: private static String treeNode12 = element12;
212: private static String elementName12 = "";
213: private static LinkTypes elementType12 = LinkTypes.NAVIGABLE_ASSOCIATION;
214: private static ElementTypes fromType12 = ElementTypes.COMPONENT;
215: private static ElementTypes toType12 = ElementTypes.CLASS;
216: private static boolean eIO12 = false;
217:
218: //--
219: //SPECIAL CASE
220: /*private static String componentDiagramName13 = "cpD13";
221: private static String workPkg13 = "pkg13";
222: private static String element13="Association Class";
223: private static String treeNode13=element13;
224: private static String elementName13="";
225: private static LinkTypes elementType13=LinkTypes.ASSOCIATION_CLASS;
226: private static ElementTypes fromType13=ElementTypes.COMPONENT;
227: private static ElementTypes toType13=ElementTypes.CLASS;
228: private static boolean eIO13=false;*/
229: //--
230: //Special case
231: /* private static String componentDiagramName14 = "cpD14";
232: private static String workPkg14 = "pkg14";
233: private static String element14="Role Binding";
234: private static String treeNode14=element14;
235: private static String elementName14=defaultNewElementName;
236: private static LinkTypes elementType14=LinkTypes.ROLE_BINDING;
237: private static ElementTypes fromType14=ElementTypes.DESIGN_PATTERN;
238: private static ElementTypes toType14=ElementTypes.ACTOR_ROLE;
239: private static boolean eIO14=false;*/
240: //--
241: //Special case
242: /*private static String componentDiagramName15 = "cpD15";
243: private static String workPkg15 = "pkg15";
244: private static String element15="Link Comment";
245: private static String treeNode15=element15;
246: private static String elementName15="";
247: private static LinkTypes elementType15=LinkTypes.LINK_COMMENT;
248: private static ElementTypes fromType14=ElementTypes.CLASS;
249: private static ElementTypes toType14=ElementTypes.COMMENT;
250: private static boolean eIO14=false;*/
251:
252: /** Need to be defined because of JUnit */
253: public PlaceMultipleLinks(String name) {
254: super (name);
255: }
256:
257: public static NbTestSuite suite() {
258: NbTestSuite suite = new NbTestSuite(
259: org.netbeans.test.uml.componentdiagram.PlaceMultipleLinks.class);
260: return suite;
261: }
262:
263: private DiagramOperator createOrOpenDiagram(String project,
264: String workPkg, String diagram) {
265: //
266: org.netbeans.test.umllib.Utils.RetAll rt = org.netbeans.test.umllib.Utils
267: .createOrOpenDiagram(project, workPkg, diagram,
268: NewDiagramWizardOperator.COMPONENT_DIAGRAM);
269: pto = rt.pto;
270: prTree = new JTreeOperator(pto);
271: lastDiagramNode = rt.lastDiagramNode;
272: return rt.dOp;
273: }
274:
275: public void testCreateLink1() {
276: lastTestCase = getCurrentTestMethodName();
277: testLinkPlace(workPkg1, componentDiagramName1, fromType1,
278: toType1, element1, elementName1, elementType1,
279: treeNode1, eIO1, false);
280: testLinkPlace(workPkg1, componentDiagramName1, fromType1,
281: toType1, element1, elementName1, elementType1,
282: treeNode1, eIO1, true);
283: }
284:
285: public void testCreateLink2() {
286: lastTestCase = getCurrentTestMethodName();
287: testLinkPlace(workPkg2, componentDiagramName2, fromType2,
288: toType2, element2, elementName2, elementType2,
289: treeNode2, eIO2, false);
290: testLinkPlace(workPkg2, componentDiagramName2, fromType2,
291: toType2, element2, elementName2, elementType2,
292: treeNode2, eIO2, true);
293: }
294:
295: /* public void testCreateLink3() {
296: testLinkPlace(workPkg3,componentDiagramName3, fromType3, toType3,element3,elementName3,elementType3,treeNode3,eIO3);
297: }*/
298: public void testCreateLink4() {
299: lastTestCase = getCurrentTestMethodName();
300: testLinkPlace(workPkg4, componentDiagramName4, fromType4,
301: toType4, element4, elementName4, elementType4,
302: treeNode4, eIO4, false);
303: testLinkPlace(workPkg4, componentDiagramName4, fromType4,
304: toType4, element4, elementName4, elementType4,
305: treeNode4, eIO4, true);
306: }
307:
308: /*public void testCreateLink5() {
309: testLinkPlace(workPkg5,componentDiagramName5, fromType5, toType5,element5,elementName5,elementType5,treeNode5,eIO5);
310: }*/
311: public void testCreateLink6() {
312: lastTestCase = getCurrentTestMethodName();
313: testLinkPlace(workPkg6, componentDiagramName6, fromType6,
314: toType6, element6, elementName6, elementType6,
315: treeNode6, eIO6, false);
316: testLinkPlace(workPkg6, componentDiagramName6, fromType6,
317: toType6, element6, elementName6, elementType6,
318: treeNode6, eIO6, true);
319: }
320:
321: public void testCreateLink7() {
322: lastTestCase = getCurrentTestMethodName();
323: testLinkPlace(workPkg7, componentDiagramName7, fromType7,
324: toType7, element7, elementName7, elementType7,
325: treeNode7, eIO7, false);
326: testLinkPlace(workPkg7, componentDiagramName7, fromType7,
327: toType7, element7, elementName7, elementType7,
328: treeNode7, eIO7, true);
329: }
330:
331: public void testCreateLink8() {
332: lastTestCase = getCurrentTestMethodName();
333: testLinkPlace(workPkg8, componentDiagramName8, fromType8,
334: toType8, element8, elementName8, elementType8,
335: treeNode8, eIO8, false);
336: testLinkPlace(workPkg8, componentDiagramName8, fromType8,
337: toType8, element8, elementName8, elementType8,
338: treeNode8, eIO8, true);
339: }
340:
341: public void testCreateLink9() {
342: lastTestCase = getCurrentTestMethodName();
343: testLinkPlace(workPkg9, componentDiagramName9, fromType9,
344: toType9, element9, elementName9, elementType9,
345: treeNode1, eIO9, false);
346: testLinkPlace(workPkg9, componentDiagramName9, fromType9,
347: toType9, element9, elementName9, elementType9,
348: treeNode1, eIO9, true);
349: }
350:
351: public void testCreateLink10() {
352: lastTestCase = getCurrentTestMethodName();
353: testLinkPlace(workPkg10, componentDiagramName10, fromType10,
354: toType10, element10, elementName10, elementType10,
355: treeNode1, eIO10, false);
356: testLinkPlace(workPkg10, componentDiagramName10, fromType10,
357: toType10, element10, elementName10, elementType10,
358: treeNode1, eIO10, true);
359: }
360:
361: public void testCreateLink11() {
362: lastTestCase = getCurrentTestMethodName();
363: testLinkPlace(workPkg11, componentDiagramName11, fromType11,
364: toType11, element11, elementName11, elementType11,
365: treeNode1, eIO11, false);
366: testLinkPlace(workPkg11, componentDiagramName11, fromType11,
367: toType11, element11, elementName11, elementType11,
368: treeNode1, eIO11, true);
369: }
370:
371: public void testCreateLink12() {
372: lastTestCase = getCurrentTestMethodName();
373: testLinkPlace(workPkg12, componentDiagramName12, fromType12,
374: toType12, element12, elementName12, elementType12,
375: treeNode12, eIO12, false);
376: testLinkPlace(workPkg12, componentDiagramName12, fromType12,
377: toType12, element12, elementName12, elementType12,
378: treeNode12, eIO12, true);
379: }
380:
381: /*public void testCreateLink13() {
382: testLinkPlace(workPkg13,componentDiagramName13, fromType13, toType13,element13,elementName13,elementType13,treeNode13,eIO13);
383: }*/
384: /*public void testCreateLink14() {
385: testLinkPlace(workPkg14,componentDiagramName14, fromType14, toType14,element14,elementName14,elementType14,treeNode14,eIO14);
386: }*/
387: /*public void testCreateLink15() {
388: testLinkPlace(workPkg15,componentDiagramName15, fromType15, toType15,element15,elementName15,elementType15,treeNode15,eIO15);
389: }*/
390:
391: public void setUp() {
392: System.out.println("######## " + getName() + " #######");
393: pto = ProjectsTabOperator.invoke();
394: if (!codeSync) {
395: org.netbeans.test.uml.componentdiagram.utils.Utils
396: .commonComponentDiagramSetup(workdir, prName);
397: //
398: codeSync = true;
399: }
400:
401: }
402:
403: public void tearDown() {
404: org.netbeans.test.umllib.util.Utils
405: .makeScreenShot(lastTestCase);
406: //popup protection
407: MainWindowOperator.getDefault().pushKey(KeyEvent.VK_ESCAPE);
408: new EventTool().waitNoEvent(1000);
409: //
410: closeAllModal();
411: org.netbeans.test.umllib.util.Utils.saveAll();
412: if (lastDiagramNode != null) {
413: lastDiagramNode.collapse();
414: new Node(lastDiagramNode.tree(), lastDiagramNode
415: .getParentPath()).collapse();
416: }
417: try {
418: DiagramOperator d = new DiagramOperator("cpD");
419: d.closeAllDocuments();
420: d.waitClosed();
421: new EventTool().waitNoEvent(1000);
422: } catch (Exception ex) {
423: }
424: ;
425: closeAllModal();
426: //save
427: org.netbeans.test.umllib.util.Utils.tearDown();
428: }
429:
430: private void testLinkPlace(String workPkg, String diagramName,
431: ElementTypes fromType, ElementTypes toType, String element,
432: String elementName, LinkTypes elementType, String treeNode,
433: boolean useIO, boolean second) {
434: log("---START, SECOND: " + second);
435: String localElName1 = "El1";
436: String localElName2 = "El2";
437: String newName = "LinkName" + counter++;
438: //
439: DiagramOperator d = createOrOpenDiagram(project, workPkg,
440: diagramName);
441: //
442: Node pkgNode = new Node(prTree, lastDiagramNode.getParentPath());
443: int numChild = pkgNode.getChildren().length;
444: //
445: UMLPaletteOperator pl = new UMLPaletteOperator();
446: DrawingAreaOperator drAr = d.getDrawingArea();
447: //
448: java.awt.Point a = drAr.getFreePoint();
449: DiagramElementOperator dE1 = null, dE2 = null;
450: if (second) {
451: try {
452: Thread.sleep(1000);
453: } catch (Exception ex) {
454: }
455: dE1 = new DiagramElementOperator(d, localElName1);
456: dE2 = new DiagramElementOperator(d, localElName2);
457: } else {
458: dE1 = d.putElementOnDiagram(localElName1, fromType, a.x,
459: a.y);
460: a = drAr.getFreePoint(200);
461: dE2 = d.putElementOnDiagram(localElName2, toType, a.x, a.y);
462: }
463: //
464: try {
465: pl.selectTool(element);
466: } catch (NotFoundException ex) {
467: fail("BLOCKING: Can't find '" + element + "' in paletter");
468: }
469: //
470: drAr.clickMouse(dE1.getCenterPoint().x, dE1.getCenterPoint().y,
471: 1);
472: drAr.clickMouse(dE1.getCenterPoint().x + (second ? 50 : -50),
473: (dE1.getCenterPoint().y + dE2.getCenterPoint().y) / 2,
474: 1);
475: drAr.clickMouse(dE2.getCenterPoint().x, dE2.getCenterPoint().y,
476: 1);
477: //
478: new EventTool().waitNoEvent(2000);
479: drAr.pushKey(KeyEvent.VK_ESCAPE);
480: new EventTool().waitNoEvent(1000);
481: try {
482: Thread.sleep(1000);
483: } catch (Exception ex) {
484: }
485: //refresh
486: dE1 = new DiagramElementOperator(d, localElName1);
487: dE2 = new DiagramElementOperator(d, localElName2);
488: //
489: LinkOperator testedlink = null;
490: LinkTypes elementTypeInProjectTree = null;
491: try {
492: for (int i = 0; i < 20 && testedlink == null; i++) {
493: /* In netbeans6.0 composition and navigable composition link are shown as aggregation in
494: * project view as they are special form of aggregation. See Issue 116868
495: * Similar to navigable aggregation and navigable association.The default name
496: * aggrgation and association are used in project modle.
497: * As workaround for test, here set type to their default type.
498: */
499: elementTypeInProjectTree = elementType;
500: if ((elementType == LinkTypes.COMPOSITION)
501: || (elementType == LinkTypes.NAVIGABLE_COMPOSITION))
502: elementTypeInProjectTree = LinkTypes.AGGREGATION;
503: if (elementType == LinkTypes.NAVIGABLE_AGGREGATION)
504: elementTypeInProjectTree = LinkTypes.AGGREGATION;
505: if (elementType == LinkTypes.NAVIGABLE_ASSOCIATION)
506: elementTypeInProjectTree = LinkTypes.ASSOCIATION;
507:
508: testedlink = LinkOperator.findLink(dE1, dE2,
509: new LinkOperator.LinkByTypeChooser(
510: elementTypeInProjectTree), second ? 1
511: : 0);
512: try {
513: Thread.sleep(200);
514: } catch (Exception ex) {
515: }
516: }
517: } catch (Exception ex) {
518: fail(element + " of type " + elementType
519: + " wasn't added to diagram:" + ex);
520: }
521: //
522: if (second
523: && (LinkTypes.IMPLEMENTATION.equals(elementType) || LinkTypes.GENERALIZATION
524: .equals(elementType))) {
525: assertTrue("Second " + LinkTypes.IMPLEMENTATION
526: + " appears on diagram.", testedlink == null);
527: return;
528: } else {
529: assertTrue(
530: "Can't find link number " + (second ? "2" : "1"),
531: testedlink != null);
532: assertTrue(
533: "There should be " + (second ? "2" : "1")
534: + " links, now :" + dE1.getLinks().size()
535: + " - " + dE2.getLinks().size(),
536: dE1.getLinks().size() == (second ? 2 : 1)
537: && dE2.getLinks().size() == (second ? 2 : 1));
538: }
539: //correct link if second goes with index 0
540: log("NEED CORRECTION " + testedlink.getSource() + "? NAME: "
541: + testedlink.getName());
542: if (second
543: && !(testedlink.getName() == null
544: || testedlink.getName().equals("") || testedlink
545: .getName().equals(defaultNewElementName))) {
546: testedlink = LinkOperator.findLink(dE1, dE2,
547: new LinkOperator.LinkByTypeChooser(elementType), 0);
548: log("CORRECTION: " + testedlink.getSource() + ':'
549: + testedlink.getName());
550: }
551: //
552: testedlink.select();
553: //
554: PropertySheetOperator ps = null;
555: try {
556: ps = new PropertySheetOperator(elementType
557: + " - Properties");
558: } catch (org.netbeans.jemmy.TimeoutExpiredException ex) {
559: ps = new PropertySheetOperator();
560: throw ex;
561: }
562: org.netbeans.test.uml.componentdiagram.utils.Utils
563: .setTextProperty("Name", newName);
564: new EventTool().waitNoEvent(500);
565: //
566: if (!LinkTypes.DERIVATION_EDGE.equals(elementType)) {
567: boolean good_name = newName.equals(testedlink.getName());
568: log("LINK NAME:" + testedlink.getName());
569: log("GOOD/SECOND:" + good_name + "/" + second);
570: if (!good_name && second) {
571: //try to find 0th link
572: try {
573: testedlink = LinkOperator.findLink(dE1, dE2,
574: new LinkOperator.LinkByTypeChooser(
575: elementType), 0);
576: } catch (Exception ex) {
577: fail(element + " of type " + elementType
578: + " wasn't added to diagram:" + ex);
579: }
580: if (testedlink != null) {
581: good_name = newName.equals(testedlink.getName());
582: log("LINK 2ND ATTEMPT NAME:" + testedlink.getName());
583: log("2ND ATTEMPT SECOND/GOOD:" + good_name + "/"
584: + second);
585: }
586: }
587: if (!good_name) {
588: log("start more invesigation");
589: //TBD need more investigations
590: String res = "Num Links Fo 1st: "
591: + dE1.getLinks().size() + ", out: "
592: + dE1.getOutLinks().size() + ", out: "
593: + dE1.getInLinks().size();
594: log("res1");
595: {
596: Iterator<LinkOperator> it = dE1.getLinks()
597: .iterator();
598: for (LinkOperator tmp = null;;) {
599: if (it.hasNext())
600: tmp = it.next();
601: else
602: break;
603: res += "\nlink_1: " + tmp.getName() + ":"
604: + tmp.getType() + ";";
605: }
606: }
607: res += "\nNum Links Fo 2nd: " + dE2.getLinks().size()
608: + ", out: " + dE2.getOutLinks().size()
609: + ", out: " + dE2.getInLinks().size();
610: {
611: Iterator<LinkOperator> it = dE2.getLinks()
612: .iterator();
613: for (LinkOperator tmp = null;;) {
614: if (it.hasNext())
615: tmp = it.next();
616: else
617: break;
618: res += "\nlink_2: " + tmp.getName() + ":"
619: + tmp.getType() + ";";
620: }
621: }
622: log("end more invesigation");
623: //*
624: fail("Link name isn't correct: " + testedlink.getName()
625: + ", should be: " + newName + "//\n" + res);
626: }
627: }
628: log("start nodes check");
629: //
630: Node n1 = new Node(pkgNode, localElName1);
631: Node n2 = new Node(pkgNode, localElName2);
632: Node rel1 = new Node(n1, "Relationships");
633: Node rel2 = new Node(n2, "Relationships");
634: new EventTool().waitNoEvent(500);
635: if (useIO) {
636: fail("unsupported testcase");
637: } else {
638: assertTrue("There should be " + newName
639: + " node within Relationships node of "
640: + localElName1, rel1.isChildPresent(newName));
641: assertTrue("There should be " + newName
642: + " node within Relationships node of "
643: + localElName2, rel2.isChildPresent(newName));
644: if (second) {
645: assertTrue("There should be second " + newName
646: + " node within Relationships node of "
647: + localElName1, rel1.isChildPresent("LinkName"
648: + (counter - 1)));
649: assertTrue("There should be second " + newName
650: + " node within Relationships node of "
651: + localElName2, rel2.isChildPresent("LinkName"
652: + (counter - 1)));
653: }
654: Node rn1 = new Node(rel1, newName);
655: Node rn2 = new Node(rel2, newName);
656: new EventTool().waitNoEvent(500);
657: if (!second) {
658: log("more first nodes");
659: {
660: if (LinkTypes.DELEGATE.equals(elementType)) {
661: assertTrue(
662: 86374,
663: "there is no nodes within delegate node",
664: rn1.getChildren().length > 0);
665: assertTrue(
666: 86374,
667: "there is no nodes within delegate node",
668: rn2.getChildren().length > 0);
669: }
670: assertTrue("There should be only one node within "
671: + newName + " node, now: "
672: + rn1.getChildren().length, rn1
673: .getChildren().length == 1);
674: assertTrue("There should be only one node within "
675: + newName + " node, now: "
676: + rn2.getChildren().length, rn2
677: .getChildren().length == 1);
678: Node de1 = new Node(rn1, localElName2);
679: Node de2 = new Node(rn2, localElName1);
680: }
681: } else {
682: log("more second nodes");
683: if (LinkTypes.DELEGATE.equals(elementType)) {
684: assertTrue(86374,
685: "there is no nodes within delegate node",
686: rn1.getChildren().length > 0);
687: assertTrue(86374,
688: "there is no nodes within delegate node",
689: rn2.getChildren().length > 0);
690: }
691: assertTrue("There should be only one node within "
692: + newName + " node, now: "
693: + rn1.getChildren().length,
694: rn1.getChildren().length == 1);
695: assertTrue("There should be only one node within "
696: + newName + " node, now: "
697: + rn2.getChildren().length,
698: rn2.getChildren().length == 1);
699: Node de1 = new Node(rn1, localElName2);
700: Node de2 = new Node(rn2, localElName1);
701: }
702: }
703: log("finished second: " + second);
704: }
705: }
|