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.dependencydiagram.utils;
043:
044: import java.awt.Point;
045: import java.awt.event.InputEvent;
046: import java.io.PrintStream;
047: import java.awt.event.KeyEvent;
048: import java.util.ArrayList;
049: import javax.swing.JMenuItem;
050: import javax.swing.MenuElement;
051: import org.netbeans.jellytools.MainWindowOperator;
052: import org.netbeans.jellytools.ProjectsTabOperator;
053: import org.netbeans.jellytools.actions.ActionNoBlock;
054: import org.netbeans.jellytools.nodes.Node;
055: import org.netbeans.jellytools.nodes.ProjectRootNode;
056: import org.netbeans.jemmy.EventTool;
057: import org.netbeans.jemmy.JemmyProperties;
058: import org.netbeans.jemmy.TimeoutExpiredException;
059: import org.netbeans.jemmy.operators.JPopupMenuOperator;
060: import org.netbeans.test.umllib.DiagramElementOperator;
061: import org.netbeans.test.umllib.DiagramOperator;
062: import org.netbeans.test.umllib.ElementTypes;
063: import org.netbeans.test.umllib.LinkOperator;
064: import org.netbeans.test.umllib.LinkTypes;
065: import org.netbeans.test.umllib.customelements.ClassOperator;
066: import org.netbeans.test.umllib.exceptions.ElementVerificationException;
067: import org.netbeans.test.umllib.exceptions.NotFoundException;
068: import org.netbeans.test.umllib.exceptions.NotFoundOnDiagramException;
069: import org.netbeans.test.umllib.exceptions.UnexpectedMenuItemStatusException;
070: import org.netbeans.test.umllib.util.JPopupByPointChooser;
071: import org.netbeans.test.umllib.util.PopupConstants;
072: import org.netbeans.test.umllib.vrf.GenericVerifier;
073:
074: public class DependencyDiagramVerifier extends GenericVerifier {
075:
076: public static int COUNT = 1;
077:
078: public static final String DEP_DIAGRAM_FOOTER = "Dependencies";
079:
080: private EventTool eventTool = new EventTool();
081:
082: public DependencyDiagramVerifier(DiagramOperator dia,
083: PrintStream log) {
084: super (dia, log);
085: }
086:
087: public DiagramElementOperator createElement(String name,
088: ElementTypes elementType) throws NotFoundException {
089: Point p = dia.getDrawingArea().getFreePoint(100);
090: return createElement(name, elementType, p.x, p.y);
091: }
092:
093: /**
094: * testcase: Generated dependency diagram of class A w/ two operations: public X op1() and public void op2(Y y)
095: * <br/>
096: * RESULT: Classes A, X, and Y created
097: */
098: public void testAssociatedDatatypes() {
099: String elementNameClass = "ClassEl";
100: String elementNameDatatype1 = "Dtt1";
101: String elementNameDatatype2 = "Dtt2";
102:
103: ElementTypes elementTypeClass = ElementTypes.CLASS;
104: ElementTypes elementTypeDatatype1 = ElementTypes.DATATYPE;
105: ElementTypes elementTypeDatatype2 = ElementTypes.DATATYPE;
106: // create elements on src diagram
107: DiagramOperator srcDiagram = new DiagramOperator(dia.getName());
108: createElement(elementNameClass, elementTypeClass);
109: ClassOperator elementClass = new ClassOperator(dia,
110: elementNameClass);
111: elementClass.insertOperation(null, elementNameDatatype1,
112: "oper1", null, true);
113: elementClass.insertOperation(null, null, "oper2",
114: elementNameDatatype2 + " param", true);
115:
116: // start dependency creation
117: checkIfDependencyGenerationAvailable(elementClass);
118: // create dependency diagram
119: createDependencyOnDiagramElement(elementClass);
120:
121: DiagramOperator depDiagram = new DiagramOperator(
122: elementNameClass + DEP_DIAGRAM_FOOTER);
123: if (depDiagram == null)
124: throw new NotFoundException(elementNameClass
125: + DEP_DIAGRAM_FOOTER
126: + " dependency diagram wasn't found for "
127: + elementNameClass);
128:
129: // find expected elements on diagram
130: DiagramElementOperator depElementClass = new DiagramElementOperator(
131: depDiagram, elementNameClass, elementTypeClass);
132: DiagramElementOperator depElementDatatype1 = new DiagramElementOperator(
133: depDiagram, elementNameDatatype1, elementTypeDatatype1);
134: DiagramElementOperator depElementDatatype2 = new DiagramElementOperator(
135: depDiagram, elementNameDatatype2, elementTypeDatatype2);
136: checkDiagramHasExactElements(new DiagramElementOperator[] {
137: depElementClass, depElementDatatype1,
138: depElementDatatype2 }, depDiagram);
139: }
140:
141: /**
142: * Drop and name a new class on the dependency diagram. Add attribute and operation to it.
143: * <br/>
144: * RESULT: Class should be created in correct namespace
145: */
146: public void testAddNewClassOnDependencyDiagram(String projectName) {
147: String elementNameSrc = "ClassElSrc2";
148: String elementNameDep = "ClassElDep2";
149:
150: ElementTypes elementTypeSrc = ElementTypes.CLASS;
151: ElementTypes elementTypeDep = ElementTypes.CLASS;
152:
153: testAddNewElementOnDependencyDiagram(elementNameSrc,
154: elementTypeSrc, elementNameDep, elementTypeDep);
155:
156: // check if element created on dependency diagram is nested for original element
157: ProjectsTabOperator pto = ProjectsTabOperator.invoke();
158: ProjectRootNode root = new ProjectRootNode(pto.tree(),
159: projectName);
160: Node nodeClassSrc = new Node(root, "Model|" + elementNameSrc);
161: if (!nodeClassSrc.isChildPresent(elementNameDep))
162: throw new NotFoundException(
163: elementNameDep
164: + " created on "
165: + elementNameSrc
166: + DEP_DIAGRAM_FOOTER
167: + " dependency diagram wasn't created as nested node of "
168: + elementNameSrc);
169: }
170:
171: public void testAddNewElementOnDependencyDiagram(
172: String elementNameSrc, ElementTypes elementTypeSrc,
173: String elementNameDep, ElementTypes elementTypeDep) {
174:
175: DiagramOperator srcDiagram = new DiagramOperator(dia.getName());
176: DiagramElementOperator elementSrc = createElement(
177: elementNameSrc, elementTypeSrc);
178:
179: // do not spent time on this?
180: checkIfDependencyGenerationAvailable(elementSrc);
181: // create dependency diagram
182: createDependencyOnDiagramElement(elementSrc);
183:
184: DiagramOperator depDiagram = new DiagramOperator(elementNameSrc
185: + DEP_DIAGRAM_FOOTER);
186: if (depDiagram == null)
187: throw new NotFoundException(elementNameSrc
188: + DEP_DIAGRAM_FOOTER
189: + " dependency diagram wasn't found for "
190: + elementNameSrc);
191:
192: // check elements on diagram
193: DiagramElementOperator depElementSrc = new DiagramElementOperator(
194: depDiagram, elementNameSrc, elementTypeSrc);
195: checkDiagramHasExactElements(
196: new DiagramElementOperator[] { depElementSrc },
197: depDiagram);
198:
199: // Add new element on dependency diagram
200: Point p = depDiagram.getDrawingArea().getFreePoint(100);
201: DiagramElementOperator depElementDep = depDiagram
202: .putElementOnDiagram(elementNameDep, elementTypeDep,
203: p.x, p.y);
204:
205: checkDiagramHasExactElements(new DiagramElementOperator[] {
206: depElementSrc, depElementDep }, depDiagram);
207: }
208:
209: /**
210: * Make changes to diagram by dropping new elements onto diagram, then save
211: * <br/>
212: * All changes to diagram should be saved
213: */
214: public void testModifiedDependencySaving(String projectName) {
215: String elementNameSrc = "ClassElSrc3";
216: String elementNameDep = "ClassElDep3";
217:
218: ElementTypes elementTypeSrc = ElementTypes.CLASS;
219: ElementTypes elementTypeDep = ElementTypes.CLASS;
220:
221: testAddNewElementOnDependencyDiagram(elementNameSrc,
222: elementTypeSrc, elementNameDep, elementTypeDep);
223:
224: // find dependency diagram
225: String depDiagramName = elementNameSrc + DEP_DIAGRAM_FOOTER;
226: DiagramOperator depDiagram = new DiagramOperator(depDiagramName);
227: if (depDiagram == null) {
228: throw new NotFoundException(elementNameSrc
229: + DEP_DIAGRAM_FOOTER
230: + " dependency diagram wasn't found for "
231: + elementNameSrc);
232: }
233:
234: // save and close modified diagram
235: depDiagram.saveDocument();
236: depDiagram.closeWindow();
237:
238: // find in tree and reopen dependency diagram
239: ProjectsTabOperator pto = ProjectsTabOperator.invoke();
240: ProjectRootNode root = new ProjectRootNode(pto.tree(),
241: projectName);
242: Node nodeDiagrams = new Node(root, "Diagrams");
243: Node nodeDiagram = new Node(nodeDiagrams, depDiagramName);
244: pto.tree().clickOnPath(nodeDiagram.getTreePath(), 2);
245: new EventTool().waitNoEvent(1000);
246:
247: DiagramOperator reopenDepDiagram = new DiagramOperator(
248: depDiagramName);
249: if (reopenDepDiagram == null) {
250: throw new NotFoundException(depDiagramName
251: + " dependency diagram wasn't reopened");
252: }
253:
254: // check elements on diagram
255: DiagramElementOperator depElementSrc = new DiagramElementOperator(
256: reopenDepDiagram, elementNameSrc, elementTypeSrc);
257: DiagramElementOperator depElementDep = new DiagramElementOperator(
258: reopenDepDiagram, elementNameDep, elementTypeDep);
259: checkDiagramHasExactElements(new DiagramElementOperator[] {
260: depElementSrc, depElementDep }, reopenDepDiagram);
261:
262: }
263:
264: public void testSrcOf2LinkedElements(ElementTypes elementTypeSrc,
265: ElementTypes elementTypeDst, LinkTypes linkType) {
266: COUNT++;
267: String elementNameSrc = "DepElSrc" + COUNT;
268: String elementNameDst = "DepElDst" + COUNT;
269:
270: // special processing for nested link
271: if (linkType.equals(LinkTypes.NESTED_LINK))
272: linkType = linkType.NESTED_LINK(elementTypeDst.toString());
273:
274: // draw elements and links on diagram
275: DiagramOperator srcDiagram = new DiagramOperator(dia.getName());
276: DiagramElementOperator elementSrc = createElement(
277: elementNameSrc, elementTypeSrc);
278: DiagramElementOperator elementDst = createElement(
279: elementNameDst, elementTypeDst);
280: eventTool.waitNoEvent(500);
281: LinkOperator link = srcDiagram.createLinkOnDiagram(linkType,
282: elementSrc, elementDst);
283:
284: // do not spent time on this?
285: checkIfDependencyGenerationAvailable(elementSrc);
286: // create dependency diagram
287: createDependencyOnDiagramElement(elementSrc);
288:
289: DiagramOperator depDiagram = new DiagramOperator(elementNameSrc
290: + DEP_DIAGRAM_FOOTER);
291: if (depDiagram == null)
292: throw new NotFoundException(elementNameSrc
293: + DEP_DIAGRAM_FOOTER
294: + " dependency diagram wasn't found for "
295: + elementNameSrc);
296:
297: // check elements on diagram
298: DiagramElementOperator depElementSrc = new DiagramElementOperator(
299: depDiagram, elementNameSrc, elementTypeSrc);
300:
301: // if link should be drawn on dependency diagram or not
302: if (isNotDependencyRelation(linkType)) {
303: checkDiagramHasExactElements(
304: new DiagramElementOperator[] { depElementSrc },
305: depDiagram);
306:
307: if (depElementSrc.getLinks().size() > 0) {
308: throw new ElementVerificationException(
309: "Unnecessary links are created on Diagram",
310: null);
311: }
312:
313: } else {
314: DiagramElementOperator depElementDst = new DiagramElementOperator(
315: depDiagram, elementNameDst, elementTypeDst);
316: checkDiagramHasExactElements(new DiagramElementOperator[] {
317: depElementSrc, depElementDst }, depDiagram);
318: LinkTypes lType = linkType;
319: if (linkType.equals(LinkTypes.COMPOSITION)
320: || linkType.equals(LinkTypes.NAVIGABLE_COMPOSITION)
321: || linkType.equals(LinkTypes.NAVIGABLE_AGGREGATION))
322: lType = LinkTypes.AGGREGATION;
323: else if (linkType.equals(LinkTypes.NAVIGABLE_ASSOCIATION))
324: lType = LinkTypes.ASSOCIATION;
325: checkDiagramHasLink(depElementSrc, depElementDst, lType);
326:
327: if (depElementSrc.getLinks().size() > 1) {
328: throw new ElementVerificationException(
329: "Unnecessary links are created on Diagram",
330: null);
331: }
332: }
333: }
334:
335: public void testSrcOf4LinkedElements(ElementTypes elementTypeSrc,
336: ElementTypes elementTypeDst1, LinkTypes linkType1,
337: ElementTypes elementTypeDst2, LinkTypes linkType2,
338: ElementTypes elementTypeDst3, LinkTypes linkType3) {
339:
340: COUNT++;
341: // diagram elements names
342: String elementNameSrc = "DepElSrc" + COUNT;
343: String elementNameDst1 = "DepElDst1" + COUNT;
344: String elementNameDst2 = "DepElDst2" + COUNT;
345: String elementNameDst3 = "DepElDst3" + COUNT;
346: String realLinkType1 = null;
347: String realLinkType2 = null;
348: String realLinkType3 = null;
349:
350: // process Nested links in special way
351: if (linkType1.equals(LinkTypes.NESTED_LINK)) {
352: realLinkType1 = elementTypeDst1.toString();
353: linkType1 = LinkTypes.NESTED_LINK
354: .NESTED_LINK(elementTypeDst1.toString());
355: }
356: if (linkType2.equals(LinkTypes.NESTED_LINK)) {
357: realLinkType2 = elementTypeDst2.toString();
358: linkType2 = LinkTypes.NESTED_LINK
359: .NESTED_LINK(elementTypeDst2.toString());
360: }
361: if (linkType3.equals(LinkTypes.NESTED_LINK)) {
362: realLinkType3 = elementTypeDst3.toString();
363: linkType3 = LinkTypes.NESTED_LINK
364: .NESTED_LINK(elementTypeDst3.toString());
365: }
366: // create elements on original diagram.
367: DiagramOperator srcDiagram = new DiagramOperator(dia.getName());
368: DiagramElementOperator elementSrc = createElement(
369: elementNameSrc, elementTypeSrc);
370:
371: DiagramElementOperator elementDst1 = createElement(
372: elementNameDst1, elementTypeDst1);
373: if (realLinkType1 != null)
374: linkType1 = linkType1.NESTED_LINK(realLinkType1);
375: eventTool.waitNoEvent(500);
376: LinkOperator link1 = srcDiagram.createLinkOnDiagram(linkType1,
377: elementSrc, elementDst1);
378:
379: DiagramElementOperator elementDst2 = createElement(
380: elementNameDst2, elementTypeDst2);
381: if (realLinkType2 != null)
382: linkType2 = linkType2.NESTED_LINK(realLinkType2);
383: eventTool.waitNoEvent(500);
384: LinkOperator link2 = srcDiagram.createLinkOnDiagram(linkType2,
385: elementSrc, elementDst2);
386:
387: DiagramElementOperator elementDst3 = createElement(
388: elementNameDst3, elementTypeDst3);
389: if (realLinkType3 != null)
390: linkType3 = linkType3.NESTED_LINK(realLinkType3);
391: eventTool.waitNoEvent(500);
392: LinkOperator link3 = srcDiagram.createLinkOnDiagram(linkType3,
393: elementSrc, elementDst3);
394:
395: // do not spent time on this?
396: checkIfDependencyGenerationAvailable(elementSrc);
397: // generate dependency diagram
398: createDependencyOnDiagramElement(elementSrc);
399:
400: // check elements and links on dependency diagram
401: DiagramOperator depDiagram = new DiagramOperator(elementNameSrc
402: + DEP_DIAGRAM_FOOTER);
403: if (depDiagram == null)
404: throw new NotFoundException(elementNameSrc
405: + DEP_DIAGRAM_FOOTER
406: + " dependency diagram wasn't found for "
407: + elementNameSrc);
408: // this array will contain elements with relation that should be drawn on dependency diagram
409: ArrayList<String> depElementNames = new ArrayList();
410: if (!isNotDependencyRelation(linkType1)) {
411: depElementNames.add(elementNameDst1);
412: if (realLinkType1 != null)
413: linkType1 = linkType1.NESTED_LINK(realLinkType1);
414:
415: if (linkType1.equals(LinkTypes.COMPOSITION)
416: || linkType1
417: .equals(LinkTypes.NAVIGABLE_COMPOSITION)
418: || linkType1
419: .equals(LinkTypes.NAVIGABLE_AGGREGATION))
420: linkType1 = LinkTypes.AGGREGATION;
421: else if (linkType1.equals(LinkTypes.NAVIGABLE_ASSOCIATION))
422: linkType1 = LinkTypes.ASSOCIATION;
423: checkDiagramHasLink(elementNameSrc, elementNameDst1,
424: linkType1, depDiagram);
425: }
426: if (!isNotDependencyRelation(linkType2)) {
427: depElementNames.add(elementNameDst2);
428: if (realLinkType2 != null)
429: linkType2 = linkType2.NESTED_LINK(realLinkType2);
430: if (linkType2.equals(LinkTypes.COMPOSITION)
431: || linkType2
432: .equals(LinkTypes.NAVIGABLE_COMPOSITION)
433: || linkType2
434: .equals(LinkTypes.NAVIGABLE_AGGREGATION))
435: linkType2 = LinkTypes.AGGREGATION;
436: else if (linkType2.equals(LinkTypes.NAVIGABLE_ASSOCIATION))
437: linkType2 = LinkTypes.ASSOCIATION;
438: checkDiagramHasLink(elementNameSrc, elementNameDst2,
439: linkType2, depDiagram);
440: }
441: if (!isNotDependencyRelation(linkType3)) {
442: depElementNames.add(elementNameDst3);
443: if (realLinkType3 != null)
444: linkType3 = linkType3.NESTED_LINK(realLinkType3);
445: if (linkType3.equals(LinkTypes.COMPOSITION)
446: || linkType3
447: .equals(LinkTypes.NAVIGABLE_COMPOSITION)
448: || linkType3
449: .equals(LinkTypes.NAVIGABLE_AGGREGATION))
450: linkType3 = LinkTypes.AGGREGATION;
451: else if (linkType3.equals(LinkTypes.NAVIGABLE_ASSOCIATION))
452: linkType3 = LinkTypes.ASSOCIATION;
453: checkDiagramHasLink(elementNameSrc, elementNameDst3,
454: linkType3, depDiagram);
455: }
456: DiagramElementOperator depElementSrc = new DiagramElementOperator(
457: depDiagram, elementNameSrc, elementTypeSrc);
458:
459: // if there were link that should be drawn on dependency diagram or not
460: if (depElementNames.size() == 0) {
461: if (depElementSrc.getLinks().size() > 0) {
462: throw new ElementVerificationException(
463: "Unnecessary links are created on Diagram",
464: null);
465: }
466: checkDiagramHasExactElements(
467: new String[] { elementNameSrc }, depDiagram);
468: } else {
469: if (depElementSrc.getLinks().size() > depElementNames
470: .size()) {
471: throw new ElementVerificationException(
472: "Unnecessary links are created on Diagram",
473: null);
474: }
475: // to check that src also exists on diagram
476: depElementNames.add(elementNameSrc);
477: checkDiagramHasExactElements(depElementNames
478: .toArray(new String[0]), depDiagram);
479: }
480: }
481:
482: public void testDependencyGenerationAvailability(
483: ElementTypes elementTypeSrc) {
484: String elementNameSrc = "DepElSrc";
485:
486: // draw elements and links on diagram
487: DiagramOperator srcDiagram = new DiagramOperator(dia.getName());
488: DiagramElementOperator elementSrc = createElement(
489: elementNameSrc, elementTypeSrc);
490:
491: checkIfDependencyGenerationAvailable(elementSrc);
492: }
493:
494: public void testDependencyGenerationAbsence(
495: ElementTypes elementTypeSrc) {
496: String elementNameSrc = "DepElSrc";
497:
498: // draw elements and links on diagram
499: DiagramOperator srcDiagram = new DiagramOperator(dia.getName());
500: DiagramElementOperator elementSrc = createElement(
501: elementNameSrc, elementTypeSrc);
502:
503: checkIfDependencyGenerationAbsent(elementSrc);
504: }
505:
506: /**
507: * checks if link shouldn't be generated on dependency diagram
508: *
509: * @param linkType link that should be checked
510: * @return true if link shouldn't be generated on dependency diagram, otherwise false.
511: */
512: private boolean isNotDependencyRelation(LinkTypes linkType) {
513: return linkType.equals(LinkTypes.NESTED_LINK)
514: || linkType.equals(LinkTypes.DELEGATE)
515: || linkType.equals(LinkTypes.INCLUDE)
516: || linkType.equals(LinkTypes.EXTEND)
517: || linkType.equals(LinkTypes.COMPOSITION)
518: || linkType.equals(LinkTypes.AGGREGATION)
519: || linkType.equals(LinkTypes.ASSOCIATION);
520: }
521:
522: public void createDependencyOnNode(Node node) {
523: new ActionNoBlock(null,
524: PopupConstants.GENERATE_DEPENDENCY_DIAGRAM)
525: .performPopup(node);
526: eventTool.waitNoEvent(2000);
527:
528: }
529:
530: public void checkIfDependencyGenerationAvailable(
531: DiagramElementOperator element) {
532: if (!isDependencyGenerationMenuItemExists(element))
533: throw new UnexpectedMenuItemStatusException(
534: PopupConstants.GENERATE_DEPENDENCY_DIAGRAM
535: + " menu item is absent on "
536: + element.getType() + " element named "
537: + element.getName(),
538: UnexpectedMenuItemStatusException.Status.ABSENT,
539: UnexpectedMenuItemStatusException.MenuType.DIAGRAMELEMENT_POPUP);
540: }
541:
542: public void checkIfDependencyGenerationAbsent(
543: DiagramElementOperator element) {
544: if (isDependencyGenerationMenuItemExists(element))
545: throw new UnexpectedMenuItemStatusException(
546: PopupConstants.GENERATE_DEPENDENCY_DIAGRAM
547: + " menu item is unexpectedly exists on "
548: + element.getType() + " element named "
549: + element.getName(),
550: UnexpectedMenuItemStatusException.Status.EXIST,
551: UnexpectedMenuItemStatusException.MenuType.DIAGRAMELEMENT_POPUP);
552: }
553:
554: public boolean isDependencyGenerationMenuItemExists(
555: DiagramElementOperator element) {
556: boolean isAvailable = false;
557:
558: //JPopupMenuOperator popup = element.getPopup();
559: JPopupMenuOperator popup = element.getGeneralPopup();
560: MenuElement[] elements = popup.getSubElements();
561: for (int i = 0; i < elements.length; i++) {
562: if (elements[i] instanceof JMenuItem) {
563: if (((JMenuItem) elements[i])
564: .getText()
565: .equalsIgnoreCase(
566: PopupConstants.GENERATE_DEPENDENCY_DIAGRAM)) {
567: isAvailable = true;
568: break;
569: }
570: }
571: }
572: // close popup menu
573: popup.pushKey(KeyEvent.VK_ESCAPE);
574: return isAvailable;
575: }
576:
577: public void createDependencyOnDiagramElement(
578: DiagramElementOperator element) {
579: JPopupMenuOperator popup = element.getGeneralPopup();
580:
581: boolean isBug = false;
582: try { // known bug on Unix OSs
583: popup.pushMenu(PopupConstants.GENERATE_DEPENDENCY_DIAGRAM);
584: } catch (TimeoutExpiredException e) {
585: isBug = true;
586: }
587: if (isBug) { // try to open popup menu again for Unix
588: element.select();
589: popup = element.getPopup();
590: popup.pushMenu(PopupConstants.GENERATE_DEPENDENCY_DIAGRAM);
591: }
592:
593: eventTool.waitNoEvent(2000);
594: }
595:
596: public void checkDiagramHasExactElements(String[] elementNames,
597: DiagramOperator dia) {
598: DiagramElementOperator[] els = new DiagramElementOperator[elementNames.length];
599: for (int i = 0; i < elementNames.length; i++) {
600: els[i] = new DiagramElementOperator(dia, elementNames[i]);
601: }
602: checkDiagramHasExactElements(els, dia);
603: }
604:
605: public void checkDiagramHasExactElements(
606: DiagramElementOperator[] elements, DiagramOperator dia) {
607: ArrayList<DiagramElementOperator> expectedElmts = new ArrayList<DiagramElementOperator>();
608: for (int i = 0; i < elements.length; i++) {
609: expectedElmts.add(elements[i]);
610: }
611:
612: ArrayList<DiagramElementOperator> diaElmts = dia
613: .getDiagramElements();
614: for (int i = 0; i < expectedElmts.size(); i++) {
615: int index = diaElmts.indexOf(expectedElmts.get(i));
616: if (index < 0) {
617: throw new NotFoundOnDiagramException(
618: ElementTypes.valueOf(expectedElmts.get(i)
619: .getElementType()),
620: NotFoundOnDiagramException.ActionTypes.DEPENDENCY);
621: }
622: diaElmts.remove(index);
623: }
624:
625: if (diaElmts.size() > 0) {
626: throw new ElementVerificationException("Unnecessary "
627: + diaElmts.size() + " elements left on Diagram",
628: null);
629: }
630: }
631:
632: public void checkDiagramHasLink(DiagramElementOperator source,
633: DiagramElementOperator destination, LinkTypes linkType) {
634: LinkOperator link = new LinkOperator(source, destination,
635: linkType);
636: }
637:
638: public void checkDiagramHasLink(String sourceName,
639: String destinationName, LinkTypes linkType,
640: DiagramOperator dia) {
641: DiagramElementOperator source = new DiagramElementOperator(dia,
642: sourceName);
643: DiagramElementOperator destination = new DiagramElementOperator(
644: dia, destinationName);
645: checkDiagramHasLink(source, destination, linkType);
646: }
647:
648: ///////////////////////
649: public Node getNode(String projectName, String nodePath) {
650: ProjectsTabOperator pto = ProjectsTabOperator.invoke();
651: ProjectRootNode root = new ProjectRootNode(pto.tree(),
652: projectName);
653:
654: Node node = new Node(root, nodePath);
655: return node;
656: }
657:
658: public void selectNode(String projectName, String nodePath) {
659: Node node = getNode(projectName, nodePath);
660: node.select();
661: }
662:
663: public boolean nodeExists(String projectName, String path) {
664: long waitNodeTime = JemmyProperties.getCurrentTimeouts()
665: .getTimeout("JTreeOperator.WaitNextNodeTimeout");
666: JemmyProperties.setCurrentTimeout(
667: "JTreeOperator.WaitNextNodeTimeout", 2000);
668: try {
669: Node node = getNode(projectName, path);
670: node.select();
671: return true;
672: } catch (Exception e) {
673: return false;
674: } finally {
675: JemmyProperties.setCurrentTimeout(
676: "JTreeOperator.WaitNextNodeTimeout", waitNodeTime);
677: }
678: }
679:
680: public boolean allNodesExist(String projectName, String parentPath,
681: String[] nodeLabels) {
682: for (int i = 0; i < nodeLabels.length; i++) {
683: if (!nodeExists(projectName, parentPath + "|"
684: + nodeLabels[i])) {
685: return false;
686: }
687: }
688: return true;
689: }
690:
691: }
|