KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > xml > axi > sync > SimulationTest


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */
19
20 package org.netbeans.modules.xml.axi.sync;
21
22 import java.beans.PropertyChangeEvent JavaDoc;
23 import java.beans.PropertyChangeListener JavaDoc;
24 import java.io.IOException JavaDoc;
25 import java.util.ArrayList JavaDoc;
26 import java.util.List JavaDoc;
27 import junit.framework.*;
28 import org.netbeans.modules.xml.axi.AXIDocument;
29 import org.netbeans.modules.xml.axi.AXIModel;
30 import org.netbeans.modules.xml.axi.AXIType;
31 import org.netbeans.modules.xml.axi.Attribute;
32 import org.netbeans.modules.xml.axi.Compositor;
33 import org.netbeans.modules.xml.axi.Compositor.CompositorType;
34 import org.netbeans.modules.xml.axi.ContentModel;
35 import org.netbeans.modules.xml.axi.Element;
36 import org.netbeans.modules.xml.axi.SchemaGenerator.Pattern;
37 import org.netbeans.modules.xml.axi.datatype.Datatype;
38 import org.netbeans.modules.xml.axi.datatype.DatatypeFactory;
39 import org.netbeans.modules.xml.axi.impl.AttributeProxy;
40 import org.netbeans.modules.xml.axi.impl.CompositorProxy;
41 import org.netbeans.modules.xml.axi.impl.ElementImpl;
42 import org.netbeans.modules.xml.axi.impl.ElementImpl.AnonymousType;
43 import org.netbeans.modules.xml.axi.impl.ElementProxy;
44 import org.netbeans.modules.xml.axi.impl.ElementRef;
45 import org.netbeans.modules.xml.axi.util.SimulationHelper;
46 import org.netbeans.modules.xml.xam.ComponentEvent;
47 import org.netbeans.modules.xml.xam.ComponentListener;
48
49
50 /**
51  * The unit test covers various use cases of sync on Element
52  * and ElementRef.
53  *
54  * @author Samaresh (Samaresh.Panda@Sun.Com)
55  */
56 public class SimulationTest extends AbstractSyncTestCase {
57     
58     public static final String JavaDoc TEST_XSD = "resources/empty.xsd";
59     private SimulationHelper helper;
60     private AXIModel model;
61     private AXIDocument doc;
62     private ComponentEventListener componentListener;
63     private ModelPCL pcl;
64     
65     /**
66      * SimulationTest
67      */
68     public SimulationTest(String JavaDoc testName) {
69     super(testName, TEST_XSD, null);
70     }
71
72     protected void setUp() throws Exception JavaDoc {
73         super.setUp();
74         this.model = getAXIModel();
75         this.doc = model.getRoot();
76         this.helper = new SimulationHelper(model);
77         this.componentListener = new ComponentEventListener();
78         this.pcl = new ModelPCL();
79     }
80     
81     public static Test suite() {
82     TestSuite suite = new TestSuite(SimulationTest.class);
83     return suite;
84     }
85     
86     private void init(Pattern pattern) {
87         helper.clearAll();
88         model.setSchemaDesignPattern(pattern);
89         assert(doc.getChildren().size() == 0);
90         getAXIModel().removeComponentListener(componentListener);
91         componentListener.clear();
92         pcl.clear();
93     }
94     
95     public void testVarious() throws Exception JavaDoc {
96         simulateChangeElementsType1();
97         simulateChangeElementsType2();
98         simulateChangeElementsType3();
99         simulateChangeElementsType4();
100         //simulateChangeCompositor1();
101 //simulateChangeCompositor2();
102 //simulateChangeCompositor3();
103 simulateDropOnRussianDoll();
104         simulateRenameElementAndCheckReference();
105     }
106     
107     //drop E1, add E2 to E1, drop GCT1, add A1, A2 to GCT1 then
108 //change the type of E1 to GCT1. Verify the results.
109 public void simulateChangeElementsType1() throws Exception JavaDoc {
110         init(Pattern.RUSSIAN_DOLL);
111         
112         //drop a global element E1
113 Element e1 = helper.dropGlobalElement("E1");
114         Element e2 = helper.dropElement(e1, "E2");
115         assert(doc.getChildren().size() == 1);
116         assert(model.getSchemaModel().getSchema().getChildren().size() == 1);
117         assert(helper.inModel(e1) && helper.inModel(e2));
118         //assert(e1.getType() instanceof AnonymousType);
119 assert(e1.getType() == null);
120         
121         //drop a GCT named GCT1
122 ContentModel gct1 = helper.dropGlobalComplexType("GCT1");
123         assert(doc.getChildren().size() == 2);
124         assert(model.getSchemaModel().getSchema().getChildren().size() == 2);
125         Element a1 = helper.dropElement(gct1, "A1");
126         Element a2 = helper.dropElement(gct1, "A2");
127         assert(helper.inModel(gct1) && helper.inModel(a1) && helper.inModel(a2));
128         assert(gct1.getChildElements().size() == 2);
129         
130         //set the element's type to "GCT1"
131 helper.setElementType(e1, gct1);
132         CompositorProxy cP = (CompositorProxy)e1.getChildren().get(0);
133         ElementProxy ep1 = (ElementProxy)cP.getChildren().get(0);
134         ElementProxy ep2 = (ElementProxy)cP.getChildren().get(1);
135         assert(e1.getChildElements().size() == 2);
136         assert(ep1.getName().equals("A1") && ep2.getName().equals("A2"));
137         assert(ep1.getOriginal() == a1 && ep2.getOriginal() == a2);
138         assert(e1.getType() instanceof ContentModel && e1.getType() == gct1);
139     }
140     
141     //drop E1, set the type to some simple type. drop GCT1, change the type of E1
142 //to GCT1. Add an element E2 to GCT1. Verify the results.
143 public void simulateChangeElementsType2() throws Exception JavaDoc {
144         init(Pattern.RUSSIAN_DOLL);
145         //drop a global element E1
146 Element e1 = helper.dropGlobalElement("E1");
147         AXIType type = DatatypeFactory.getDefault().createPrimitive(Datatype.Kind.ANYURI.getName());
148         helper.setElementType(e1, type);
149         assert(doc.getChildren().size() == 1);
150         assert(model.getSchemaModel().getSchema().getChildren().size() == 1);
151         assert(helper.inModel(e1));
152         assert(e1.getType() instanceof Datatype);
153         
154         //drop a GCT named GCT1
155 ContentModel gct1 = helper.dropGlobalComplexType("GCT1");
156         assert(doc.getChildren().size() == 2);
157         assert(model.getSchemaModel().getSchema().getChildren().size() == 2);
158         
159         //set the element's type to "GCT1"
160 helper.setElementType(e1, gct1);
161         assert(e1.getChildElements().size() == 0);
162         assert(e1.getType() instanceof ContentModel && e1.getType() == gct1);
163
164         //getAXIModel().addComponentListener(listener);
165 Element a1 = helper.dropElement(gct1, "A1");
166         assert(helper.inModel(a1));
167         assert(gct1.getChildElements().size() == 1);
168         //assert(listener.getAddedCount() == 3);
169
170         Compositor c = (Compositor)gct1.getChildren().get(0);
171         CompositorProxy cP = (CompositorProxy)e1.getChildren().get(0);
172         ElementProxy ep1 = (ElementProxy)cP.getChildren().get(0);
173         assert(e1.getChildElements().size() == 1);
174         assert(ep1.getName().equals("A1"));
175         assert(ep1.getOriginal() == a1);
176     }
177     
178     //drop E1, set the type to some simple type.
179 //Add an element E2 to E1. Verify the results.
180 public void simulateChangeElementsType3() throws Exception JavaDoc {
181         init(Pattern.RUSSIAN_DOLL);
182         //drop a global element E1
183 Element e1 = helper.dropGlobalElement("E1");
184         AXIType type = DatatypeFactory.getDefault().createPrimitive(Datatype.Kind.ANYURI.getName());
185         helper.setElementType(e1, type);
186         assert(helper.inModel(e1));
187         assert(doc.getChildren().size() == 1);
188         assert(model.getSchemaModel().getSchema().getChildren().size() == 1);
189         assert(e1.getType() instanceof Datatype);
190         Element e2 = helper.dropElement(e1, "E2");
191         assert(helper.inModel(e2));
192         assert(e1.getChildElements().size() == 1);
193         assert(e1.getType() instanceof AnonymousType);
194         Compositor c = (Compositor)e1.getChildren().get(0);
195         assert(c.getChildren().get(0) == e2);
196     }
197     
198     //drop a GCT 'PAR', drop an element 'PAR', change the type of
199 //element to 'PAR' and then drop an element on element 'PAR'
200 //now delete the element.
201 public void simulateChangeElementsType4() throws Exception JavaDoc {
202         init(Pattern.RUSSIAN_DOLL);
203         //drop a global element E1
204 ContentModel cm = helper.dropGlobalComplexType("PAR");
205         Element e1 = helper.dropGlobalElement("PAR");
206         assert(helper.inModel(cm) && helper.inModel(e1));
207         helper.setElementType(e1, cm);
208         assert(helper.inModel(e1));
209         assert(doc.getChildren().size() == 2);
210         assert(model.getSchemaModel().getSchema().getChildren().size() == 2);
211         assert(e1.getType() instanceof ContentModel);
212         
213         Element e2 = helper.dropElement(e1, "E2");
214         assert(helper.inModel(e2));
215         assert(e1.getChildElements().size() == 1);
216         assert(e1.getType() instanceof ContentModel);
217         CompositorProxy cp = (CompositorProxy)e1.getChildren().get(0);
218         assert(cp.getChildren().get(0).getOriginal() == e2);
219     }
220     
221     //drop E1, add a sequence to E1, add two children E11, E12 to sequence
222 //change the sequence to a choice, verify the result.
223 public void simulateChangeCompositor1() throws Exception JavaDoc {
224         init(Pattern.RUSSIAN_DOLL);
225         int count = 0;
226         //drop a global element E1
227 Element e1 = helper.dropGlobalElement("E1");
228         assert(helper.inModel(e1));
229         assert(doc.getChildren().size() == 1);
230         assert(model.getSchemaModel().getSchema().getChildren().size() == 1);
231         
232         Compositor sequence = helper.dropCompositor(e1, CompositorType.SEQUENCE);
233         assert(helper.inModel(sequence));
234         assert(e1.getType() instanceof AnonymousType);
235         
236         Element e11 = helper.dropElementOnCompositor(sequence, "E11");
237         Element e12 = helper.dropElementOnCompositor(sequence, "E12");
238         assert(helper.inModel(e11) && helper.inModel(e12));
239         assert(e1.getChildElements().size() == 2);
240         
241         e1.addPropertyChangeListener(pcl);
242         helper.setCompositorType(sequence, CompositorType.CHOICE);
243         assert(pcl.getEvents().size() == 2);
244         PropertyChangeEvent JavaDoc evt1 = pcl.getEvents().get(0);
245         PropertyChangeEvent JavaDoc evt2 = pcl.getEvents().get(1);
246         assert(evt1.getPropertyName().equals(Compositor.PROP_COMPOSITOR)
247             && (evt1.getOldValue() == sequence) && (evt1.getNewValue() == null));
248         assert(evt2.getPropertyName().equals(Compositor.PROP_COMPOSITOR)
249             && (evt2.getOldValue() == null) && (evt2.getNewValue() != null));
250         assert(!helper.inModel(sequence));
251         assert(!helper.inModel(e11) && !helper.inModel(e12));
252         assert(e1.getChildElements().size() == 2);
253     }
254     
255     //drop E1, add a sequence to E1, add a child E2 to sequence
256 //add one more child choice to sequence, add a child E3 to choice.
257 //change the sequence to a choice, verify the result.
258 public void simulateChangeCompositor2() throws Exception JavaDoc {
259         init(Pattern.RUSSIAN_DOLL);
260         //drop a global element E1
261 Element e1 = helper.dropGlobalElement("E1");
262         assert(helper.inModel(e1));
263         assert(doc.getChildren().size() == 1);
264         assert(model.getSchemaModel().getSchema().getChildren().size() == 1);
265         
266         Compositor sequence = helper.dropCompositor(e1, CompositorType.SEQUENCE);
267         assert(helper.inModel(sequence));
268         //assert(e1.getType() instanceof AnonymousType);
269 assert(e1.getType() == null);
270         
271         Element e2 = helper.dropElementOnCompositor(sequence, "E2");
272         assert(helper.inModel(e2));
273         
274         //drop a choice
275 Compositor choice = getAXIModel().getComponentFactory().createChoice();
276         helper.dropChildAtIndex(sequence, choice, 0);
277         assert(helper.inModel(choice));
278         assert(sequence.getChildren().size() == 2);
279         Element e3 = helper.dropElementOnCompositor(choice, "E3");
280         assert(helper.inModel(e3));
281         assert(e1.getChildElements().size() == 2);
282         
283         e1.addPropertyChangeListener(pcl);
284         helper.setCompositorType(sequence, CompositorType.CHOICE);
285         assert(pcl.getEvents().size() == 2);
286         PropertyChangeEvent JavaDoc evt1 = pcl.getEvents().get(0);
287         PropertyChangeEvent JavaDoc evt2 = pcl.getEvents().get(1);
288         assert(evt1.getPropertyName().equals(Compositor.PROP_COMPOSITOR)
289             && (evt1.getOldValue() == sequence) && (evt1.getNewValue() == null));
290         assert(evt2.getPropertyName().equals(Compositor.PROP_COMPOSITOR)
291             && (evt2.getOldValue() == null) && (evt2.getNewValue() != null));
292         assert(!helper.inModel(sequence) && !helper.inModel(e2) && !helper.inModel(choice));
293         assert(e1.getChildElements().size() == 2);
294     }
295     
296     public void simulateChangeCompositor3() throws Exception JavaDoc {
297         init(Pattern.RUSSIAN_DOLL);
298         //drop a global element E1
299 Element ge = helper.dropGlobalElement("GE1");
300         assert(helper.inModel(ge));
301         assert(doc.getChildren().size() == 1);
302         assert(model.getSchemaModel().getSchema().getChildren().size() == 1);
303         
304         ContentModel cm = helper.dropGlobalComplexType("GCT1");
305         assert(helper.inModel(cm));
306         assert(doc.getChildren().size() == 2);
307         assert(model.getSchemaModel().getSchema().getChildren().size() == 2);
308         //drop an element E1 on GCT1
309 Element e1 = helper.dropElement(cm, "E1");
310         helper.dropElement(e1, "E11");
311         helper.dropElement(e1, "E12");
312         Element e2 = helper.dropElement(cm, "E2");
313         helper.dropElement(e2, "E21");
314         helper.dropElement(e2, "E22");
315         Compositor compositor = (Compositor)cm.getChildren().get(0);
316         assert(cm.getChildElements().size() == 2);
317                 
318         assert(ge.getChildElements().size() == 0);
319         helper.setElementType(ge, cm);
320         assert(ge.getChildElements().size() == 2);
321         
322         Compositor proxy = (Compositor)ge.getChildren().get(0);
323         assert(proxy instanceof CompositorProxy && proxy.getOriginal() == compositor);
324         helper.setCompositorType(proxy, CompositorType.CHOICE);
325         assert(!helper.inModel(compositor) && !helper.inModel(proxy));
326         assert(ge.getChildren().size() == 1);
327         assert(cm.getChildren().size() == 1);
328         assert(cm.getChildElements().size() == 2);
329         assert(ge.getChildElements().size() == 2);
330         
331         compositor = (Compositor)cm.getChildren().get(0);
332         proxy = (Compositor)ge.getChildren().get(0);
333         assert(proxy instanceof CompositorProxy && proxy.getOriginal() == compositor);
334         helper.setCompositorType(proxy, CompositorType.ALL);
335         assert(!helper.inModel(compositor) && !helper.inModel(proxy));
336         assert(ge.getChildren().size() == 1);
337         assert(cm.getChildren().size() == 1);
338         assert(cm.getChildElements().size() == 2);
339         assert(ge.getChildElements().size() == 2);
340     }
341     
342     public void simulateDropOnRussianDoll() throws IOException JavaDoc {
343         init(Pattern.RUSSIAN_DOLL);
344         
345         //drop a global element E1
346 Element e1 = helper.dropGlobalElement("E1");
347         //model looks like: GCT1(SEQ(E1))
348 assert(doc.getChildren().size() == 1);
349         assert(model.getSchemaModel().getSchema().getChildren().size() == 1);
350         assert(helper.inModel(e1));
351         
352         //drop a GCT named GCT1
353 ContentModel cm = helper.dropGlobalComplexType("GCT1");
354         assert(doc.getChildren().size() == 2);
355         assert(model.getSchemaModel().getSchema().getChildren().size() == 2);
356         assert(helper.inModel(cm));
357         
358         //set the element's type to "GCT1"
359 helper.setElementType(e1, cm);
360         assert(e1.getType() instanceof ContentModel && e1.getType() == cm);
361         
362         //drop an attribute A1 on E1. This should get added to GCT1 instead.
363 Attribute a1 = helper.dropAttributeOnElement(e1, "A1");
364         assert(helper.inModel(a1));
365         AttributeProxy aP = (AttributeProxy)e1.getChildren().get(0);
366         assert(doc.getChildren().size() == 2);
367         assert(model.getSchemaModel().getSchema().getChildren().size() == 2);
368         assert(aP.getOriginal() == a1);
369         
370         //delete the attribute that appears in E1
371 helper.delete(aP);
372         assert(cm.getChildren().size() == 0);
373     }
374     
375     public void simulateDropOnGardenOfEden() throws IOException JavaDoc {
376         init(Pattern.GARDEN_OF_EDEN);
377         //drop a GCT named GCT1
378 ContentModel cm = helper.dropGlobalComplexType("GCT1");
379         //drop an element E1 on GCT1
380 Element e1 = helper.dropElement(cm, "E1");
381         //codegen mutated schema model which now should look like E1, GCT1(SEQ(ref(E1)))
382 assert(model.getSchemaModel().getSchema().getChildren().size() == 2);
383         //post sync axi model should look like E1, GCT1(SEQ(ref(E1)))
384 assert(doc.getChildren().size() == 2);
385         assert(doc.getContentModels().size() == 1);
386         ElementRef ref1 = (ElementRef)cm.getCompositor().getChildren().get(0);
387         assert(ref1.getReferent().isGlobal());
388         assert(ref1.getReferent() instanceof ElementImpl);
389         assert(ref1.getReferent().getName().equals("E1"));
390         Element e2 = helper.dropElement(ref1, "E2");
391         //codegen mutated schema model which looks like E1, GCT1(SEQ(ref(E1)))
392 assert(model.getSchemaModel().getSchema().getChildren().size() == 4);
393         //model.sync();
394 assert(doc.getChildren().size() == 4);
395         ContentModel cm2 = doc.getContentModels().get(1);
396         assert(cm2.getName().equals("E1Type"));
397         ElementRef ref2 = (ElementRef)cm2.getCompositor().getChildren().get(0);
398         assert(ref2.getReferent().isGlobal());
399         assert(ref2.getReferent() instanceof ElementImpl);
400         assert(ref2.getReferent().getName().equals("E2"));
401     }
402     
403     //drop E1, add a sequence to E1, add two children E11, E12 to sequence
404 //change the sequence to a choice, verify the result.
405 public void simulateRenameElementAndCheckReference() throws Exception JavaDoc {
406         init(Pattern.RUSSIAN_DOLL);
407         class Status {
408             boolean status = false;
409             public boolean getStatus() {return status;}
410             public void setStatus(boolean status) {this.status = status;}
411         }
412         final Status status = new Status();
413         //drop two global elements
414 final Element e1 = helper.dropGlobalElement("E1");
415         Element e2 = helper.dropGlobalElement("E2");
416         assert(helper.inModel(e1) && helper.inModel(e2));
417         assert(doc.getChildren().size() == 2);
418         assert(model.getSchemaModel().getSchema().getChildren().size() == 2);
419         Element e3 = helper.dropElement(e2, "E3");
420         helper.setElementType(e3, e1);
421         final Element e4 = (Element)e2.getChildren().get(0).getChildren().get(0);
422         assert(!helper.inModel(e3) && helper.inModel(e4) && e4.isReference());
423         e4.addPropertyChangeListener(new PropertyChangeListener JavaDoc() {
424             public void propertyChange(PropertyChangeEvent JavaDoc evt) {
425                 if(evt.getPropertyName().equals(Element.PROP_NAME)) {
426                     assert(evt.getSource() == e4);
427                     assert(e4.getReferent() == e1);
428                     status.setStatus(true);
429                 }
430             }
431         });
432         helper.refactorRename(e1, "xxx");
433         while(!status.getStatus()) {
434             Thread.sleep(2000);
435         }
436         assert(status.getStatus());
437     }
438         
439     public static class ModelPCL implements PropertyChangeListener JavaDoc {
440         public void propertyChange(PropertyChangeEvent JavaDoc event) {
441             events.add(event);
442         }
443         public List JavaDoc<PropertyChangeEvent JavaDoc> getEvents() {
444             return events;
445         }
446         
447         public void clear() {
448             events.clear();
449         }
450                         
451         private List JavaDoc<PropertyChangeEvent JavaDoc> events = new ArrayList JavaDoc<PropertyChangeEvent JavaDoc>();
452     }
453     
454     public static class ComponentEventListener implements ComponentListener {
455         
456         public void valueChanged(ComponentEvent event) {
457             //deleted.add(event);
458 }
459         
460         public void childrenDeleted(ComponentEvent event) {
461             deleted.add(event);
462         }
463         
464         public void childrenAdded(ComponentEvent event) {
465             added.add(event);
466         }
467         
468         public int getAddedCount() {
469             return added.size();
470         }
471         
472         public int getDeletedCount() {
473             return deleted.size();
474         }
475
476         public void clear() {
477             added.clear();
478             deleted.clear();
479         }
480                         
481         private List JavaDoc<ComponentEvent> added = new ArrayList JavaDoc<ComponentEvent>();
482         private List JavaDoc<ComponentEvent> deleted = new ArrayList JavaDoc<ComponentEvent>();
483     }
484 }
485
Popular Tags