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