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;
043:
044: import org.netbeans.jemmy.EventTool;
045: import org.netbeans.jemmy.JemmyProperties;
046: import org.netbeans.jemmy.TimeoutExpiredException;
047: import org.netbeans.junit.NbTestSuite;
048: import org.netbeans.test.uml.dependencydiagram.utils.DependencyDiagramVerifier;
049: import org.netbeans.test.uml.dependencydiagram.utils.DependencyUtils;
050: import org.netbeans.test.umllib.DiagramOperator;
051: import org.netbeans.test.umllib.ElementTypes;
052: import org.netbeans.test.umllib.LinkTypes;
053: import org.netbeans.test.umllib.NewDiagramWizardOperator;
054: import org.netbeans.test.umllib.exceptions.UnexpectedMenuItemStatusException;
055: import org.netbeans.test.umllib.testcases.UMLTestCase;
056:
057: public class ClassDiagramBasicLinksTests extends UMLTestCase {
058: private final String projectName = "Depend_uml_cldB";
059: private String diagramNamePrefix = "test_diagram";
060: public static int COUNT = 0;
061: //public static boolean initialized = false;
062:
063: private static final String workDir = System
064: .getProperty("xtest.workdir");
065: private DiagramOperator diagram = null;
066: private DependencyDiagramVerifier verifier = null;
067:
068: private EventTool eventTool = new EventTool();
069:
070: public ClassDiagramBasicLinksTests(String name) {
071: super (name);
072: }
073:
074: public static NbTestSuite suite() {
075: NbTestSuite suite = new NbTestSuite(
076: ClassDiagramBasicLinksTests.class);
077: return suite;
078: }
079:
080: // GEneralization link tests
081:
082: public void testLifeline() {
083:
084: verifier
085: .testDependencyGenerationAbsence(ElementTypes.COLLABORATION_LIFELINE);
086:
087: }
088:
089: public void testPackage() {
090:
091: verifier.testDependencyGenerationAbsence(ElementTypes.PACKAGE);
092:
093: }
094:
095: public void testSrcClassClassGeneralization() {
096:
097: verifier.testSrcOf2LinkedElements(ElementTypes.CLASS,
098: ElementTypes.CLASS, LinkTypes.GENERALIZATION);
099:
100: }
101:
102: public void testSrcInterfaceInterfaceGeneralization() {
103:
104: verifier.testSrcOf2LinkedElements(ElementTypes.INTERFACE,
105: ElementTypes.INTERFACE, LinkTypes.GENERALIZATION);
106:
107: }
108:
109: public void testSrcEnumEnumGeneralization() {
110:
111: verifier.testSrcOf2LinkedElements(ElementTypes.ENUMERATION,
112: ElementTypes.ENUMERATION, LinkTypes.GENERALIZATION);
113:
114: }
115:
116: public void testSrcNodeNodeGeneralization() {
117:
118: verifier.testSrcOf2LinkedElements(ElementTypes.NODE,
119: ElementTypes.NODE, LinkTypes.GENERALIZATION);
120:
121: }
122:
123: public void testSrcDatatypeDatatypeGeneralization() {
124:
125: verifier.testSrcOf2LinkedElements(ElementTypes.DATATYPE,
126: ElementTypes.DATATYPE, LinkTypes.GENERALIZATION);
127:
128: }
129:
130: public void testSrcArtifactArtifactGeneralization() {
131:
132: verifier.testSrcOf2LinkedElements(ElementTypes.ARTIFACT,
133: ElementTypes.ARTIFACT, LinkTypes.GENERALIZATION);
134:
135: }
136:
137: public void testSrcAliasedAliasedGeneralization() {
138:
139: verifier.testSrcOf2LinkedElements(ElementTypes.ALIASED,
140: ElementTypes.ALIASED, LinkTypes.GENERALIZATION);
141:
142: }
143:
144: public void testSrcUtilityUtilityGeneralization() {
145:
146: verifier.testSrcOf2LinkedElements(ElementTypes.UTILITY_CLASS,
147: ElementTypes.UTILITY_CLASS, LinkTypes.GENERALIZATION);
148:
149: }
150:
151: public void testSrcActorActorGeneralization() {
152:
153: verifier.testSrcOf2LinkedElements(ElementTypes.ACTOR,
154: ElementTypes.ACTOR, LinkTypes.GENERALIZATION);
155:
156: }
157:
158: public void testSrcEnumClassGeneralization() {
159:
160: verifier.testSrcOf2LinkedElements(ElementTypes.ENUMERATION,
161: ElementTypes.CLASS, LinkTypes.GENERALIZATION);
162:
163: }
164:
165: public void testSrcActorInterfaceGeneralization() {
166: try {
167: verifier.testSrcOf2LinkedElements(ElementTypes.ACTOR,
168: ElementTypes.INTERFACE, LinkTypes.GENERALIZATION);
169: } catch (TimeoutExpiredException e) {
170: // It is expected to have no link created between component and interface
171: assertTrue(
172: "There should not be generalization link between actor and interface",
173: e
174: .getMessage()
175: .startsWith(
176: "Wait with link chooser: Chooser for link of type Generalization"));
177: }
178:
179: }
180:
181: public void testSrcAliasedDatatypeGeneralization() {
182:
183: verifier.testSrcOf2LinkedElements(ElementTypes.ALIASED,
184: ElementTypes.DATATYPE, LinkTypes.GENERALIZATION);
185:
186: }
187:
188: public void testSrcDatatypeInterfaceGeneralization() {
189: try {
190: verifier.testSrcOf2LinkedElements(ElementTypes.DATATYPE,
191: ElementTypes.INTERFACE, LinkTypes.GENERALIZATION);
192: } catch (TimeoutExpiredException e) {
193: // It is expected to have no link created between component and interface
194: assertTrue(
195: "There should not be generalization link between datatype and interface",
196: e
197: .getMessage()
198: .startsWith(
199: "Wait with link chooser: Chooser for link of type Generalization"));
200: }
201: }
202:
203: public void testSrcClassAliasedGeneralization() {
204:
205: verifier.testSrcOf2LinkedElements(ElementTypes.CLASS,
206: ElementTypes.ALIASED, LinkTypes.GENERALIZATION);
207:
208: }
209:
210: // Implementation link tests
211: public void testSrcClassInterfaceImplementation() {
212:
213: verifier.testSrcOf2LinkedElements(ElementTypes.CLASS,
214: ElementTypes.INTERFACE, LinkTypes.IMPLEMENTATION);
215:
216: }
217:
218: public void testSrcUtilityInterfaceImplementation() {
219:
220: verifier.testSrcOf2LinkedElements(ElementTypes.UTILITY_CLASS,
221: ElementTypes.INTERFACE, LinkTypes.IMPLEMENTATION);
222:
223: }
224:
225: // Nested link tests
226:
227: public void testSrcClassClassNested() {
228:
229: verifier.testSrcOf2LinkedElements(ElementTypes.CLASS,
230: ElementTypes.CLASS, LinkTypes.NESTED_LINK);
231:
232: }
233:
234: public void testSrcInterfaceInterfaceNested() {
235:
236: verifier.testSrcOf2LinkedElements(ElementTypes.INTERFACE,
237: ElementTypes.INTERFACE, LinkTypes.NESTED_LINK);
238:
239: }
240:
241: public void testSrcEnumEnumNested() {
242:
243: verifier.testSrcOf2LinkedElements(ElementTypes.ENUMERATION,
244: ElementTypes.ENUMERATION, LinkTypes.NESTED_LINK);
245:
246: }
247:
248: public void testSrcPackagePackageNested() {
249: try {
250: verifier.testSrcOf2LinkedElements(ElementTypes.PACKAGE,
251: ElementTypes.PACKAGE, LinkTypes.NESTED_LINK);
252: } catch (UnexpectedMenuItemStatusException ee) {
253: // it is expected not to have dependency menu item on package
254: }
255:
256: }
257:
258: public void testSrcNodeNodeNested() {
259:
260: verifier.testSrcOf2LinkedElements(ElementTypes.NODE,
261: ElementTypes.NODE, LinkTypes.NESTED_LINK);
262:
263: }
264:
265: public void testSrcLifelineLifelineNested() {
266: try {
267: verifier.testSrcOf2LinkedElements(
268: ElementTypes.COLLABORATION_LIFELINE,
269: ElementTypes.CLASS, LinkTypes.NESTED_LINK);
270: } catch (UnexpectedMenuItemStatusException ee) {
271: // it is expected not to have dependency menu item on COLLABORATION_LIFELINE
272: }
273:
274: }
275:
276: public void testSrcDatatypeDatatypeNested() {
277:
278: verifier.testSrcOf2LinkedElements(ElementTypes.DATATYPE,
279: ElementTypes.DATATYPE, LinkTypes.NESTED_LINK);
280:
281: }
282:
283: public void testSrcArtifactArtifactNested() {
284:
285: verifier.testSrcOf2LinkedElements(ElementTypes.ARTIFACT,
286: ElementTypes.ARTIFACT, LinkTypes.NESTED_LINK);
287:
288: }
289:
290: public void testSrcAliasedAliasedNested() {
291:
292: verifier.testSrcOf2LinkedElements(ElementTypes.ALIASED,
293: ElementTypes.ALIASED, LinkTypes.NESTED_LINK);
294:
295: }
296:
297: public void testSrcUtilityUtilityNested() {
298:
299: verifier.testSrcOf2LinkedElements(ElementTypes.UTILITY_CLASS,
300: ElementTypes.UTILITY_CLASS, LinkTypes.NESTED_LINK);
301:
302: }
303:
304: public void testSrcClassPackageNested() {
305:
306: verifier.testSrcOf2LinkedElements(ElementTypes.CLASS,
307: ElementTypes.PACKAGE, LinkTypes.NESTED_LINK);
308:
309: }
310:
311: public void testSrcEnumPackageNested() {
312:
313: verifier.testSrcOf2LinkedElements(ElementTypes.ENUMERATION,
314: ElementTypes.PACKAGE, LinkTypes.NESTED_LINK);
315:
316: }
317:
318: public void testSrcEnumClassNested() {
319:
320: verifier.testSrcOf2LinkedElements(ElementTypes.ENUMERATION,
321: ElementTypes.CLASS, LinkTypes.NESTED_LINK);
322:
323: }
324:
325: public void testSrcDatatypePackageNested() {
326:
327: verifier.testSrcOf2LinkedElements(ElementTypes.DATATYPE,
328: ElementTypes.PACKAGE, LinkTypes.NESTED_LINK);
329:
330: }
331:
332: public void testSrcArtifactPackageNested() {
333:
334: verifier.testSrcOf2LinkedElements(ElementTypes.ARTIFACT,
335: ElementTypes.PACKAGE, LinkTypes.NESTED_LINK);
336:
337: }
338:
339: // several elements with links
340: public void testMultipleLinks1() {
341:
342: verifier.testSrcOf4LinkedElements(ElementTypes.CLASS,
343: ElementTypes.CLASS, LinkTypes.GENERALIZATION,
344: ElementTypes.INTERFACE, LinkTypes.IMPLEMENTATION,
345: ElementTypes.CLASS, LinkTypes.NESTED_LINK);
346:
347: }
348:
349: public void testMultipleLinks2() {
350:
351: verifier.testSrcOf4LinkedElements(ElementTypes.ENUMERATION,
352: ElementTypes.CLASS, LinkTypes.GENERALIZATION,
353: ElementTypes.ENUMERATION, LinkTypes.GENERALIZATION,
354: ElementTypes.CLASS, LinkTypes.NESTED_LINK);
355:
356: }
357:
358: public void testMultipleLinks3() {
359:
360: verifier.testSrcOf4LinkedElements(ElementTypes.DATATYPE,
361: ElementTypes.CLASS, LinkTypes.NESTED_LINK,
362: ElementTypes.ALIASED, LinkTypes.GENERALIZATION,
363: ElementTypes.ACTOR, LinkTypes.GENERALIZATION);
364:
365: }
366:
367: public void testMultipleLinks4() {
368:
369: verifier.testSrcOf4LinkedElements(ElementTypes.ARTIFACT,
370: ElementTypes.CLASS, LinkTypes.GENERALIZATION,
371: ElementTypes.NODE, LinkTypes.GENERALIZATION,
372: ElementTypes.PACKAGE, LinkTypes.NESTED_LINK);
373:
374: }
375:
376: public void testMultipleLinks5() {
377:
378: verifier.testSrcOf4LinkedElements(ElementTypes.ACTOR,
379: ElementTypes.ARTIFACT, LinkTypes.GENERALIZATION,
380: ElementTypes.PACKAGE, LinkTypes.NESTED_LINK,
381: ElementTypes.ARTIFACT, LinkTypes.GENERALIZATION);
382:
383: }
384:
385: protected void setUp() {
386: JemmyProperties.setCurrentTimeout(
387: "DialogWaiter.WaitDialogTimeout", 5000);
388: JemmyProperties.setCurrentTimeout("Waiter.WaitingTime", 3000);
389: JemmyProperties.setCurrentTimeout(
390: "DiagramElementOperator.WaitDiagramElementTime", 5000);
391: //if (!initialized) { DependencyUtils.setDefaultPreferences(); initialized=true;}
392: COUNT++;
393: String diagramName = this .diagramNamePrefix + COUNT;
394: diagram = DependencyUtils.openDiagram(projectName, diagramName,
395: NewDiagramWizardOperator.CLASS_DIAGRAM, workDir);
396: if (diagram == null)
397: fail("Can't open diagram '" + diagramName + "', project '"
398: + projectName + "'.");
399:
400: verifier = new DependencyDiagramVerifier(diagram, this .getLog());
401: }
402:
403: public void tearDown() {
404: closeAllModal();
405: org.netbeans.test.umllib.util.Utils.tearDown();
406: new EventTool().waitNoEvent(1000);
407:
408: //close opened diagrams
409: diagram.closeAllDocuments();
410:
411: new EventTool().waitNoEvent(1000);
412: }
413:
414: }
|