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 org.netbeans.jellytools.MainWindowOperator;
046: import org.netbeans.jellytools.ProjectsTabOperator;
047: import org.netbeans.jellytools.nodes.Node;
048: import org.netbeans.jellytools.properties.PropertySheetOperator;
049: import org.netbeans.jemmy.EventTool;
050: import org.netbeans.jemmy.operators.JTreeOperator;
051:
052: import org.netbeans.junit.NbTestSuite; //import qa.uml.UMLClassOperator;
053: import org.netbeans.test.umllib.DiagramElementOperator;
054: import org.netbeans.test.umllib.DiagramOperator;
055: import org.netbeans.test.umllib.DrawingAreaOperator;
056: import org.netbeans.test.umllib.ElementTypes;
057: import org.netbeans.test.umllib.NewDiagramWizardOperator;
058: import org.netbeans.test.umllib.testcases.UMLTestCase;
059:
060: /**
061: *
062: * @author psb
063: * @spec UML/ComponentDiagram.xml
064: */
065: public class PlaceMultipleElements extends UMLTestCase {
066:
067: //some system properties
068: private static String contextPropItemName = "Properties";
069: private static String umlPropertyWindowTitle = "Project Properties";
070: private static String umlSourcePackagesLabel = "Source Packages";
071: private static String umlSourcePackagesColumn = "Folder Label";
072: private static String umlSourceUsageColumn = "Model?";
073: private static String mainTreeTabName = "Projects";
074: //common test properties
075: private static String prName = "ComponentDiagramProjectPM";
076: private static String project = prName + "|Model";
077: private static String sourceProject = "source";
078: private static boolean codeSync = false;
079: private static String defaultNewElementName = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultNewElementName;
080: private static String defaultReturnType = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultReturnType;
081: private static String defaultAttributeType = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultAttributeType;
082: private static String defaultAttributeVisibility = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultAttributeVisibility;
083: private static String defaultOperationVisibility = org.netbeans.test.uml.componentdiagram.utils.Utils.defaultOperationVisibility;
084: private ProjectsTabOperator pto = null;
085: private Node lastDiagramNode = null;
086: private JTreeOperator prTree = null;
087: private static String workdir = System.getProperty("xtest.workdir");
088: private static int elCount = 0;
089: private String lastTestCase = null;
090: //
091: private static boolean CR_89368 = false;
092: //--
093: private static String diagramName1 = "cpD1";
094: private static String workPkg1 = "pkg1";
095: private static String element1 = "Component";
096: private static String elementName1 = defaultNewElementName;
097: private static ElementTypes elementType1 = ElementTypes.COMPONENT;
098: //--
099: private static String diagramName2 = "cpD2";
100: private static String workPkg2 = "pkg2";
101: private static String element2 = "Class";
102: private static String elementName2 = defaultNewElementName;
103: private static ElementTypes elementType2 = ElementTypes.CLASS;
104: //--
105: private static String diagramName3 = "cpD3";
106: private static String workPkg3 = "pkg3";
107: private static String element3 = "Interface";
108: private static String elementName3 = defaultNewElementName;
109: private static ElementTypes elementType3 = ElementTypes.INTERFACE;
110: //--
111: private static String diagramName4 = "cpD4";
112: private static String workPkg4 = "pkg4";
113: private static String element4 = "Package";
114: private static String elementName4 = defaultNewElementName;
115: private static ElementTypes elementType4 = ElementTypes.PACKAGE;
116: //--
117: private static String diagramName5 = "cpD5";
118: private static String workPkg5 = "pkg5";
119: private static String element5 = "Artifact";
120: private static String elementName5 = defaultNewElementName;
121: private static ElementTypes elementType5 = ElementTypes.ARTIFACT;
122: //--
123: private static String diagramName6 = "cpD6";
124: private static String workPkg6 = "pkg6";
125: private static String element6 = "Assembly Connector";
126: private static String elementName6 = defaultNewElementName;
127: private static ElementTypes elementType6 = ElementTypes.INTERFACE;
128: //--
129: private static String diagramName7 = "cpD7";
130: private static String workPkg7 = "pkg7";
131: private static String element7 = "Template Class";
132: private static String elementName7 = defaultNewElementName;
133: private static ElementTypes elementType7 = ElementTypes.TEMPLATE_CLASS;
134: //--
135: private static String diagramName8 = "cpD8";
136: private static String workPkg8 = "pkg8";
137: private static String element8 = "Derivation Classifier";
138: private static String elementName8 = defaultNewElementName;
139: private static ElementTypes elementType8 = ElementTypes.DERIVATION_CLASSIFIER;
140: //--
141: private static String diagramName9 = "cpD9";
142: private static String workPkg9 = "pkg9";
143: private static String element9 = "Design Pattern";
144: private static String elementName9 = defaultNewElementName;
145: private static ElementTypes elementType9 = ElementTypes.DESIGN_PATTERN;
146: //--
147: private static String diagramName10 = "cpD10";
148: private static String workPkg10 = "pkg10";
149: private static String element10 = "Role";
150: private static String elementName10 = defaultNewElementName;
151: private static ElementTypes elementType10 = ElementTypes.ROLE;
152: //--
153: private static String diagramName11 = "cpD11";
154: private static String workPkg11 = "pkg11";
155: private static String element11 = "Interface Role";
156: private static String elementName11 = defaultNewElementName;
157: private static ElementTypes elementType11 = ElementTypes.INTERFACE_ROLE;
158: //--
159: private static String diagramName12 = "cpD12";
160: private static String workPkg12 = "pkg12";
161: private static String element12 = "Actor Role";
162: private static String elementName12 = defaultNewElementName;
163: private static ElementTypes elementType12 = ElementTypes.ACTOR_ROLE;
164: //--
165: private static String diagramName13 = "cpD13";
166: private static String workPkg13 = "pkg13";
167: private static String element13 = "Class Role";
168: private static String elementName13 = defaultNewElementName;
169: private static ElementTypes elementType13 = ElementTypes.CLASS_ROLE;
170: //--
171: private static String diagramName14 = "cpD14";
172: private static String workPkg14 = "pkg14";
173: private static String element14 = "Use Case Role";
174: private static String elementName14 = defaultNewElementName;
175: private static ElementTypes elementType14 = ElementTypes.USE_CASE_ROLE;
176: //--
177: private static String diagramName15 = "cpD15";
178: private static String workPkg15 = "pkg15";
179: private static String element15 = "Role Binding";
180: private static String elementName15 = defaultNewElementName;
181: private static ElementTypes elementType15 = ElementTypes.ROLE_BINDING;
182: //--
183: private static String diagramName16 = "cpD16";
184: private static String workPkg16 = "pkg16";
185: private static String element16 = "Comment";
186: private static String elementName16 = "";
187: private static ElementTypes elementType16 = ElementTypes.COMMENT;
188: //--
189: private static String diagramName17 = "cpD17";
190: private static String workPkg17 = "pkg17";
191: private static String element17 = "Link Comment";
192: private static String elementName17 = "";
193: private static ElementTypes elementType17 = ElementTypes.LINK_COMMENT;
194:
195: //--
196: /* private static String diagramName15 = "cpD15";
197: private static String workPkg15 = "pkg15";
198: private static String element15="Activity Edge";
199: private static String treeNode15=element15;
200: private static String elementName15="";
201: private static LinkTypes elementType15=LinkTypes.ACTIVITY_EDGE;
202: private static boolean eIO15=true;
203: //--
204: private static String diagramName16 = "cpD16";
205: private static String workPkg16 = "pkg16";
206: private static String element16="Dependency";
207: private static String treeNode16=element16;
208: private static String elementName16="";
209: private static LinkTypes elementType16=LinkTypes.DEPENDENCY;
210: private static boolean eIO16=false;
211: //--
212: private static String diagramName17 = "cpD17";
213: private static String workPkg17 = "pkg17";
214: private static String element17="Realize";
215: private static String treeNode17="Realization";
216: private static String elementName17="";
217: private static LinkTypes elementType17=LinkTypes.REALIZE;
218: private static boolean eIO17=false;
219: //--
220: private static String diagramName18 = "cpD18";
221: private static String workPkg18 = "pkg18";
222: private static String element18="Usage";
223: private static String treeNode18=element18;
224: private static String elementName18="";
225: private static LinkTypes elementType18=LinkTypes.USAGE;
226: private static boolean eIO18=false;
227: //--
228: private static String diagramName19 = "cpD19";
229: private static String workPkg19 = "pkg19";
230: private static String element19="Permission";
231: private static String treeNode19=element19;
232: private static String elementName19="";
233: private static LinkTypes elementType19=LinkTypes.PERMISSION;
234: private static boolean eIO19=false;
235: //--
236: private static String diagramName20 = "cpD20";
237: private static String workPkg20 = "pkg20";
238: private static String element20="Abstraction";
239: private static String treeNode20=element20;
240: private static String elementName20="";
241: private static LinkTypes elementType20=LinkTypes.ABSTRACTION;
242: private static boolean eIO20=false;*/
243:
244: /** Need to be defined because of JUnit */
245: public PlaceMultipleElements(String name) {
246: super (name);
247: }
248:
249: public static NbTestSuite suite() {
250: NbTestSuite suite = new NbTestSuite(
251: org.netbeans.test.uml.componentdiagram.PlaceMultipleElements.class);
252: return suite;
253: }
254:
255: private DiagramOperator createOrOpenDiagram(String project,
256: String workPkg, String diagram) {
257: //
258: org.netbeans.test.umllib.Utils.RetAll rt = org.netbeans.test.umllib.Utils
259: .createOrOpenDiagram(project, workPkg, diagram,
260: NewDiagramWizardOperator.COMPONENT_DIAGRAM);
261: pto = rt.pto;
262: prTree = new JTreeOperator(pto);
263: lastDiagramNode = rt.lastDiagramNode;
264: return rt.dOp;
265: }
266:
267: public void testCreateAndName1() {
268: lastTestCase = getCurrentTestMethodName();
269: elCount = 0;
270: testElementPlaceAndName(workPkg1, diagramName1, element1,
271: elementName1, elementType1);
272: testElementPlaceAndName(workPkg1, diagramName1, element1,
273: elementName1, elementType1);
274: testElementPlaceAndName(workPkg1, diagramName1, element1,
275: elementName1, elementType1);
276: testElementPlaceAndName(workPkg1, diagramName1, element1,
277: elementName1, elementType1);
278: testElementPlaceAndName(workPkg1, diagramName1, element1,
279: elementName1, elementType1);
280: testElementPlaceAndName(workPkg1, diagramName1, element1,
281: elementName1, elementType1);
282: testElementPlaceAndName(workPkg1, diagramName1, element1,
283: elementName1, elementType1);
284: testElementPlaceAndName(workPkg1, diagramName1, element1,
285: elementName1, elementType1);
286: testElementPlaceAndName(workPkg1, diagramName1, element1,
287: elementName1, elementType1);
288: }
289:
290: public void testCreateAndName2() {
291: lastTestCase = getCurrentTestMethodName();
292: elCount = 0;
293: testElementPlaceAndName(workPkg2, diagramName2, element2,
294: elementName2, elementType2);
295: testElementPlaceAndName(workPkg2, diagramName2, element2,
296: elementName2, elementType2);
297: testElementPlaceAndName(workPkg2, diagramName2, element2,
298: elementName2, elementType2);
299: testElementPlaceAndName(workPkg2, diagramName2, element2,
300: elementName2, elementType2);
301: testElementPlaceAndName(workPkg2, diagramName2, element2,
302: elementName2, elementType2);
303: testElementPlaceAndName(workPkg2, diagramName2, element2,
304: elementName2, elementType2);
305: testElementPlaceAndName(workPkg2, diagramName2, element2,
306: elementName2, elementType2);
307: testElementPlaceAndName(workPkg2, diagramName2, element2,
308: elementName2, elementType2);
309: testElementPlaceAndName(workPkg2, diagramName2, element2,
310: elementName2, elementType2);
311: }
312:
313: public void testCreateAndName3() {
314: lastTestCase = getCurrentTestMethodName();
315: elCount = 0;
316: testElementPlaceAndName(workPkg3, diagramName3, element3,
317: elementName3, elementType3);
318: testElementPlaceAndName(workPkg3, diagramName3, element3,
319: elementName3, elementType3);
320: testElementPlaceAndName(workPkg3, diagramName3, element3,
321: elementName3, elementType3);
322: testElementPlaceAndName(workPkg3, diagramName3, element3,
323: elementName3, elementType3);
324: testElementPlaceAndName(workPkg3, diagramName3, element3,
325: elementName3, elementType3);
326: testElementPlaceAndName(workPkg3, diagramName3, element3,
327: elementName3, elementType3);
328: testElementPlaceAndName(workPkg3, diagramName3, element3,
329: elementName3, elementType3);
330: testElementPlaceAndName(workPkg3, diagramName3, element3,
331: elementName3, elementType3);
332: testElementPlaceAndName(workPkg3, diagramName3, element3,
333: elementName3, elementType3);
334: }
335:
336: public void testCreateAndName4() {
337: lastTestCase = getCurrentTestMethodName();
338: elCount = 0;
339: testElementPlaceAndName(workPkg4, diagramName4, element4,
340: elementName4, elementType4);
341: testElementPlaceAndName(workPkg4, diagramName4, element4,
342: elementName4, elementType4);
343: testElementPlaceAndName(workPkg4, diagramName4, element4,
344: elementName4, elementType4);
345: testElementPlaceAndName(workPkg4, diagramName4, element4,
346: elementName4, elementType4);
347: testElementPlaceAndName(workPkg4, diagramName4, element4,
348: elementName4, elementType4);
349: testElementPlaceAndName(workPkg4, diagramName4, element4,
350: elementName4, elementType4);
351: testElementPlaceAndName(workPkg4, diagramName4, element4,
352: elementName4, elementType4);
353: testElementPlaceAndName(workPkg4, diagramName4, element4,
354: elementName4, elementType4);
355: testElementPlaceAndName(workPkg4, diagramName4, element4,
356: elementName4, elementType4);
357: }
358:
359: public void testCreateAndName5() {
360: lastTestCase = getCurrentTestMethodName();
361: elCount = 0;
362: testElementPlaceAndName(workPkg5, diagramName5, element5,
363: elementName5, elementType5);
364: testElementPlaceAndName(workPkg5, diagramName5, element5,
365: elementName5, elementType5);
366: testElementPlaceAndName(workPkg5, diagramName5, element5,
367: elementName5, elementType5);
368: testElementPlaceAndName(workPkg5, diagramName5, element5,
369: elementName5, elementType5);
370: testElementPlaceAndName(workPkg5, diagramName5, element5,
371: elementName5, elementType5);
372: testElementPlaceAndName(workPkg5, diagramName5, element5,
373: elementName5, elementType5);
374: testElementPlaceAndName(workPkg5, diagramName5, element5,
375: elementName5, elementType5);
376: testElementPlaceAndName(workPkg5, diagramName5, element5,
377: elementName5, elementType5);
378: testElementPlaceAndName(workPkg5, diagramName5, element5,
379: elementName5, elementType5);
380: }
381:
382: public void testCreateAndName6() {
383: lastTestCase = getCurrentTestMethodName();
384: elCount = 0;
385: testElementPlaceAndName(workPkg6, diagramName6, element6,
386: elementName6, elementType6);
387: testElementPlaceAndName(workPkg6, diagramName6, element6,
388: elementName6, elementType6);
389: testElementPlaceAndName(workPkg6, diagramName6, element6,
390: elementName6, elementType6);
391: testElementPlaceAndName(workPkg6, diagramName6, element6,
392: elementName6, elementType6);
393: testElementPlaceAndName(workPkg6, diagramName6, element6,
394: elementName6, elementType6);
395: testElementPlaceAndName(workPkg6, diagramName6, element6,
396: elementName6, elementType6);
397: testElementPlaceAndName(workPkg6, diagramName6, element6,
398: elementName6, elementType6);
399: testElementPlaceAndName(workPkg6, diagramName6, element6,
400: elementName6, elementType6);
401: testElementPlaceAndName(workPkg6, diagramName6, element6,
402: elementName6, elementType6);
403: }
404:
405: public void testCreateAndName7() {
406: lastTestCase = getCurrentTestMethodName();
407: elCount = 0;
408: testElementPlaceAndName(workPkg7, diagramName7, element7,
409: elementName7, elementType7);
410: testElementPlaceAndName(workPkg7, diagramName7, element7,
411: elementName7, elementType7);
412: testElementPlaceAndName(workPkg7, diagramName7, element7,
413: elementName7, elementType7);
414: testElementPlaceAndName(workPkg7, diagramName7, element7,
415: elementName7, elementType7);
416: testElementPlaceAndName(workPkg7, diagramName7, element7,
417: elementName7, elementType7);
418: testElementPlaceAndName(workPkg7, diagramName7, element7,
419: elementName7, elementType7);
420: testElementPlaceAndName(workPkg7, diagramName7, element7,
421: elementName7, elementType7);
422: testElementPlaceAndName(workPkg7, diagramName7, element7,
423: elementName7, elementType7);
424: testElementPlaceAndName(workPkg7, diagramName7, element7,
425: elementName7, elementType7);
426: }
427:
428: public void testCreateAndName8() {
429: lastTestCase = getCurrentTestMethodName();
430: elCount = 0;
431: testElementPlaceAndName(workPkg8, diagramName8, element8,
432: elementName8, elementType8);
433: testElementPlaceAndName(workPkg8, diagramName8, element8,
434: elementName8, elementType8);
435: testElementPlaceAndName(workPkg8, diagramName8, element8,
436: elementName8, elementType8);
437: testElementPlaceAndName(workPkg8, diagramName8, element8,
438: elementName8, elementType8);
439: testElementPlaceAndName(workPkg8, diagramName8, element8,
440: elementName8, elementType8);
441: testElementPlaceAndName(workPkg8, diagramName8, element8,
442: elementName8, elementType8);
443: testElementPlaceAndName(workPkg8, diagramName8, element8,
444: elementName8, elementType8);
445: testElementPlaceAndName(workPkg8, diagramName8, element8,
446: elementName8, elementType8);
447: testElementPlaceAndName(workPkg8, diagramName8, element8,
448: elementName8, elementType8);
449: }
450:
451: public void testCreateAndName9() {
452: lastTestCase = getCurrentTestMethodName();
453: elCount = 0;
454: testElementPlaceAndName(workPkg9, diagramName9, element9,
455: elementName9, elementType9);
456: testElementPlaceAndName(workPkg9, diagramName9, element9,
457: elementName9, elementType9);
458: testElementPlaceAndName(workPkg9, diagramName9, element9,
459: elementName9, elementType9);
460: testElementPlaceAndName(workPkg9, diagramName9, element9,
461: elementName9, elementType9);
462: testElementPlaceAndName(workPkg9, diagramName9, element9,
463: elementName9, elementType9);
464: testElementPlaceAndName(workPkg9, diagramName9, element9,
465: elementName9, elementType9);
466: testElementPlaceAndName(workPkg9, diagramName9, element9,
467: elementName9, elementType9);
468: testElementPlaceAndName(workPkg9, diagramName9, element9,
469: elementName9, elementType9);
470: testElementPlaceAndName(workPkg9, diagramName9, element9,
471: elementName9, elementType9);
472: }
473:
474: public void testCreateAndName10() {
475: lastTestCase = getCurrentTestMethodName();
476: elCount = 0;
477: testElementPlaceAndName(workPkg10, diagramName10, element10,
478: elementName10, elementType10);
479: testElementPlaceAndName(workPkg10, diagramName10, element10,
480: elementName10, elementType10);
481: testElementPlaceAndName(workPkg10, diagramName10, element10,
482: elementName10, elementType10);
483: testElementPlaceAndName(workPkg10, diagramName10, element10,
484: elementName10, elementType10);
485: testElementPlaceAndName(workPkg10, diagramName10, element10,
486: elementName10, elementType10);
487: testElementPlaceAndName(workPkg10, diagramName10, element10,
488: elementName10, elementType10);
489: testElementPlaceAndName(workPkg10, diagramName10, element10,
490: elementName10, elementType10);
491: testElementPlaceAndName(workPkg10, diagramName10, element10,
492: elementName10, elementType10);
493: testElementPlaceAndName(workPkg10, diagramName10, element10,
494: elementName10, elementType10);
495: }
496:
497: public void testCreateAndName11() {
498: lastTestCase = getCurrentTestMethodName();
499: elCount = 0;
500: testElementPlaceAndName(workPkg11, diagramName11, element11,
501: elementName11, elementType11);
502: testElementPlaceAndName(workPkg11, diagramName11, element11,
503: elementName11, elementType11);
504: testElementPlaceAndName(workPkg11, diagramName11, element11,
505: elementName11, elementType11);
506: testElementPlaceAndName(workPkg11, diagramName11, element11,
507: elementName11, elementType11);
508: testElementPlaceAndName(workPkg11, diagramName11, element11,
509: elementName11, elementType11);
510: testElementPlaceAndName(workPkg11, diagramName11, element11,
511: elementName11, elementType11);
512: testElementPlaceAndName(workPkg11, diagramName11, element11,
513: elementName11, elementType11);
514: testElementPlaceAndName(workPkg11, diagramName11, element11,
515: elementName11, elementType11);
516: testElementPlaceAndName(workPkg11, diagramName11, element11,
517: elementName11, elementType11);
518: }
519:
520: public void testCreateAndName12() {
521: lastTestCase = getCurrentTestMethodName();
522: elCount = 0;
523: testElementPlaceAndName(workPkg12, diagramName12, element12,
524: elementName12, elementType12);
525: testElementPlaceAndName(workPkg12, diagramName12, element12,
526: elementName12, elementType12);
527: testElementPlaceAndName(workPkg12, diagramName12, element12,
528: elementName12, elementType12);
529: testElementPlaceAndName(workPkg12, diagramName12, element12,
530: elementName12, elementType12);
531: testElementPlaceAndName(workPkg12, diagramName12, element12,
532: elementName12, elementType12);
533: testElementPlaceAndName(workPkg12, diagramName12, element12,
534: elementName12, elementType12);
535: testElementPlaceAndName(workPkg12, diagramName12, element12,
536: elementName12, elementType12);
537: testElementPlaceAndName(workPkg12, diagramName12, element12,
538: elementName12, elementType12);
539: testElementPlaceAndName(workPkg12, diagramName12, element12,
540: elementName12, elementType12);
541: }
542:
543: public void testCreateAndName13() {
544: lastTestCase = getCurrentTestMethodName();
545: elCount = 0;
546: testElementPlaceAndName(workPkg13, diagramName13, element13,
547: elementName13, elementType13);
548: testElementPlaceAndName(workPkg13, diagramName13, element13,
549: elementName13, elementType13);
550: testElementPlaceAndName(workPkg13, diagramName13, element13,
551: elementName13, elementType13);
552: testElementPlaceAndName(workPkg13, diagramName13, element13,
553: elementName13, elementType13);
554: testElementPlaceAndName(workPkg13, diagramName13, element13,
555: elementName13, elementType13);
556: testElementPlaceAndName(workPkg13, diagramName13, element13,
557: elementName13, elementType13);
558: testElementPlaceAndName(workPkg13, diagramName13, element13,
559: elementName13, elementType13);
560: testElementPlaceAndName(workPkg13, diagramName13, element13,
561: elementName13, elementType13);
562: testElementPlaceAndName(workPkg13, diagramName13, element13,
563: elementName13, elementType13);
564: }
565:
566: public void testCreateAndName14() {
567: lastTestCase = getCurrentTestMethodName();
568: elCount = 0;
569: testElementPlaceAndName(workPkg14, diagramName14, element14,
570: elementName14, elementType14);
571: testElementPlaceAndName(workPkg14, diagramName14, element14,
572: elementName14, elementType14);
573: testElementPlaceAndName(workPkg14, diagramName14, element14,
574: elementName14, elementType14);
575: testElementPlaceAndName(workPkg14, diagramName14, element14,
576: elementName14, elementType14);
577: testElementPlaceAndName(workPkg14, diagramName14, element14,
578: elementName14, elementType14);
579: testElementPlaceAndName(workPkg14, diagramName14, element14,
580: elementName14, elementType14);
581: testElementPlaceAndName(workPkg14, diagramName14, element14,
582: elementName14, elementType14);
583: testElementPlaceAndName(workPkg14, diagramName14, element14,
584: elementName14, elementType14);
585: testElementPlaceAndName(workPkg14, diagramName14, element14,
586: elementName14, elementType14);
587: }
588:
589: public void testCreateAndName15() {
590: lastTestCase = getCurrentTestMethodName();
591: elCount = 0;
592: testElementPlaceAndName(workPkg15, diagramName15, element15,
593: elementName15, elementType15);
594: testElementPlaceAndName(workPkg15, diagramName15, element15,
595: elementName15, elementType15);
596: testElementPlaceAndName(workPkg15, diagramName15, element15,
597: elementName15, elementType15);
598: testElementPlaceAndName(workPkg15, diagramName15, element15,
599: elementName15, elementType15);
600: testElementPlaceAndName(workPkg15, diagramName15, element15,
601: elementName15, elementType15);
602: testElementPlaceAndName(workPkg15, diagramName15, element15,
603: elementName15, elementType15);
604: testElementPlaceAndName(workPkg15, diagramName15, element15,
605: elementName15, elementType15);
606: testElementPlaceAndName(workPkg15, diagramName15, element15,
607: elementName15, elementType15);
608: testElementPlaceAndName(workPkg15, diagramName15, element15,
609: elementName15, elementType15);
610: }
611:
612: public void testCreateAndName16() {
613: lastTestCase = getCurrentTestMethodName();
614: elCount = 0;
615: testElementPlaceAndName(workPkg16, diagramName16, element16,
616: elementName16, elementType16);
617: testElementPlaceAndName(workPkg16, diagramName16, element16,
618: elementName16, elementType16);
619: testElementPlaceAndName(workPkg16, diagramName16, element16,
620: elementName16, elementType16);
621: testElementPlaceAndName(workPkg16, diagramName16, element16,
622: elementName16, elementType16);
623: testElementPlaceAndName(workPkg16, diagramName16, element16,
624: elementName16, elementType16);
625: testElementPlaceAndName(workPkg16, diagramName16, element16,
626: elementName16, elementType16);
627: testElementPlaceAndName(workPkg16, diagramName16, element16,
628: elementName16, elementType16);
629: testElementPlaceAndName(workPkg16, diagramName16, element16,
630: elementName16, elementType16);
631: testElementPlaceAndName(workPkg16, diagramName16, element16,
632: elementName16, elementType16);
633: }
634:
635: public void testCreateAndName17() {
636: lastTestCase = getCurrentTestMethodName();
637: elCount = 0;
638: testElementPlaceAndName(workPkg17, diagramName17, element17,
639: elementName17, elementType17);
640: testElementPlaceAndName(workPkg17, diagramName17, element17,
641: elementName17, elementType17);
642: testElementPlaceAndName(workPkg17, diagramName17, element17,
643: elementName17, elementType17);
644: testElementPlaceAndName(workPkg17, diagramName17, element17,
645: elementName17, elementType17);
646: testElementPlaceAndName(workPkg17, diagramName17, element17,
647: elementName17, elementType17);
648: testElementPlaceAndName(workPkg17, diagramName17, element17,
649: elementName17, elementType17);
650: testElementPlaceAndName(workPkg17, diagramName17, element17,
651: elementName17, elementType17);
652: testElementPlaceAndName(workPkg17, diagramName17, element17,
653: elementName17, elementType17);
654: testElementPlaceAndName(workPkg17, diagramName17, element17,
655: elementName17, elementType17);
656: }
657:
658: public void setUp() {
659: System.out.println("######## " + getName() + " #######");
660: pto = ProjectsTabOperator.invoke();
661: if (!codeSync) {
662: org.netbeans.test.uml.componentdiagram.utils.Utils
663: .commonComponentDiagramSetup(workdir, prName);
664: //
665: codeSync = true;
666: }
667:
668: }
669:
670: public void tearDown() {
671: org.netbeans.test.umllib.util.Utils
672: .makeScreenShot(lastTestCase);
673: //popup protection
674: MainWindowOperator.getDefault().pushKey(KeyEvent.VK_ESCAPE);
675: new EventTool().waitNoEvent(1000);
676: //
677: closeAllModal();
678: org.netbeans.test.umllib.util.Utils.saveAll();
679: if (lastDiagramNode != null) {
680: lastDiagramNode.collapse();
681: new Node(lastDiagramNode.tree(), lastDiagramNode
682: .getParentPath()).collapse();
683: }
684: try {
685: DiagramOperator d = new DiagramOperator("cpD");
686: d.closeAllDocuments();
687: d.waitClosed();
688: new EventTool().waitNoEvent(1000);
689: } catch (Exception ex) {
690: }
691: ;
692: closeAllModal();
693: //save
694: org.netbeans.test.umllib.util.Utils.tearDown();
695: }
696:
697: private void testElementPlaceAndName(String workPkg,
698: String diagramName, String element, String elementName,
699: ElementTypes elementType, String newName) {
700: elCount++;
701: elementName = newName + "_" + elCount;
702: //
703: DiagramOperator d = null;
704: if (elCount <= 1)
705: d = createOrOpenDiagram(project, workPkg, diagramName);
706: else
707: d = new DiagramOperator(diagramName);
708: //
709: int numChild = new Node(prTree, lastDiagramNode.getParentPath())
710: .getChildren().length;
711: //
712: DrawingAreaOperator drAr = d.getDrawingArea();
713: java.awt.Point a = drAr.getFreePoint();
714: drAr.clickMouse(a.x, a.y, 1);
715: new EventTool().waitNoEvent(500);
716: DiagramElementOperator dEl = null;
717: //
718: try {
719: if (elementType.equals(ElementTypes.COMMENT)
720: || elementType.equals(ElementTypes.LINK_COMMENT)) {
721: dEl = d.putElementOnDiagram(elementName, elementType,
722: a.x, a.y,
723: new DiagramElementOperator.PropertyNamer());
724: } else {
725: dEl = d.putElementOnDiagram(elementName, elementType,
726: a.x, a.y);
727: }
728: } catch (Exception ex) {
729: try {
730: fail(element
731: + " with name "
732: + elementName
733: + " wasn't added to diagram, but object with type:"
734: + new DiagramElementOperator(d, elementName)
735: .getType()
736: + ": and element type :"
737: + new DiagramElementOperator(d, elementName)
738: .getElementType()
739: + ": was added whyle type should be :"
740: + elementType + ": was added");
741: } catch (Exception ex2) {
742:
743: }
744: fail(element + " with name " + elementName
745: + " wasn't added to diagram.");
746: }
747: //
748: new EventTool().waitNoEvent(500);
749: PropertySheetOperator ps = new PropertySheetOperator();
750: if (!CR_89368) {
751: CR_89368 = (defaultNewElementName + " - Properties")
752: .equals(ps.getName());
753: assertFalse(89368,
754: "Properties isn't updated on element naming",
755: CR_89368);
756: }
757: //WORKAROUND ??
758: java.awt.Point a2 = drAr.getFreePoint();
759: drAr.clickMouse(a2.x, a2.y, 1);
760: dEl.waitSelection(false);
761: dEl.clickOnCenter();
762: dEl.waitSelection(true);
763: //
764: ps = new PropertySheetOperator();
765: //
766: assertTrue("Property sheet isn't for " + elementType + " with "
767: + elementName + " name, but for " + ps.getName(),
768: (elementName + " - Properties").equals(ps.getName()));
769: //
770: int numChild2 = new Node(prTree, lastDiagramNode
771: .getParentPath()).getChildren().length;
772: assertTrue(
773: "There should be one more element in package, but now: "
774: + (numChild2 - numChild),
775: (numChild2 - numChild) == 1);
776:
777: assertTrue(
778: "No name propagated to node within diagram (in project tree)",
779: new Node(prTree, lastDiagramNode.getParentPath())
780: .isChildPresent(elementName));
781: }
782:
783: private void testElementPlaceAndName(String workPkg,
784: String diagramName, String element, String elementName,
785: ElementTypes elementType) {
786: testElementPlaceAndName(workPkg, diagramName, element,
787: elementName, elementType, "ElName");
788: }
789:
790: }
|