KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > TestBookXMLSchema


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 /*
21  * TestBookXMLSchema - test the basic features.
22  *
23  * The following test assumes that we know the content of the
24  * graph as we get elements, add and change them. Therefore, the TestBookXMLSchema.xml
25  * file and this java test should be kept in sync.
26  *
27  * Test the following:
28  *
29  * single String: get/set/remove/set/get
30  * boolean (from true): get/set true/get/set false/get/set true/get
31  * boolean (from false): get/set false/get/set true/get/set false/get
32  * String[]: get/set (null & !null)/add/remove
33  * Bean: remove/set(null)/create bean and graph of beans/set/add
34  *
35  */

36
37 import java.io.*;
38 import java.util.*;
39 import org.w3c.dom.*;
40
41 import org.netbeans.modules.schema2beans.*;
42 import book.*;
43
44
45 public class TestBookXMLSchema extends BaseTest {
46     public static void main(String JavaDoc[] argv) {
47         TestBookXMLSchema o = new TestBookXMLSchema();
48         if (argv.length > 0)
49             o.setDocumentDir(argv[0]);
50         try {
51             o.run();
52         } catch (Exception JavaDoc e) {
53             e.printStackTrace();
54             System.exit(1);
55         }
56         System.exit(0);
57     }
58     
59     public void run()
60     throws Exception JavaDoc {
61     Book book;
62     
63     this.readDocument();
64
65     out("creating the bean graph");
66     book = Book.createGraph(doc);
67     
68     // Check that we can read the graph an it is complete
69
out("bean graph created");
70     
71     //out(book.toString());
72
//out(book.clone().toString());
73
//((BaseBean)book.clone()).write(System.out);
74

75     //
76
// Single string test
77
//
78

79     String JavaDoc s1, s2;
80     
81     // Get a String element and change it
82
{
83         setTest("single String - get/set");
84         s1 = book.getSummary();
85         s1 += "Some more dynamic notes on the summary.";
86         book.setSummary(s1);
87         s2 = book.getSummary();
88         check(s1.equals(s2));
89     }
90     
91     // Remove a final string element
92
{
93         setTest("single String - remove");
94         book.setSummary(null);
95         s2 = book.getSummary();
96         check(s2==null);
97         out("should not have a 'summary' element:",
98         book.dumpDomNode("summary", 1));
99     }
100     
101     // Adding a final string
102
{
103         setTest("single String - set new");
104         book.setSummary(s1);
105         s2 = book.getSummary();
106         check(s1.equals(s2));
107         out("should have a 'summary' element:",
108         book.dumpDomNode("summary", 1));
109     }
110     
111     //
112
// Boolean test - from initial value true
113
//
114

115     {
116         boolean b1, b2;
117         setTest("boolean - get value (from true)");
118         b1 = book.isGood();
119         check(b1==true);
120         out("should have a 'good' element:",
121         book.dumpDomNode("good", 1));
122         
123         setTest("boolean - change to same value (true)");
124         book.setGood(b1);
125         check(b1==book.isGood());
126         out("should still have a 'good' element:",
127         book.dumpDomNode("good", 1));
128         
129         setTest("boolean - change to false");
130         book.setGood(!b1);
131         check(b1!=book.isGood());
132         out("should have a 'good' element:",
133         book.dumpDomNode("good", 1));
134         
135         setTest("boolean - change back to true");
136         book.setGood(b1);
137         check(b1==book.isGood());
138         out("should have a 'good' element:",
139         book.dumpDomNode("good", 1));
140     }
141     
142     //
143
// Boolean test - from initial value false
144
//
145
{
146         boolean b1, b2;
147         setTest("boolean - get value (from false)");
148         b1 = book.isAvailable();
149         check(b1==false);
150         out("should not have an 'available' element:",
151         book.dumpDomNode("available", 1));
152         
153         setTest("boolean - change to same value (false)");
154         book.setAvailable(b1);
155         check(b1==book.isAvailable());
156         out("should have an 'available' element:",
157         book.dumpDomNode("available", 1));
158         
159         setTest("boolean - change to true");
160         book.setAvailable(!b1);
161         check(b1!=book.isAvailable());
162         out("should have now an 'available' element:",
163         book.dumpDomNode("available", 1));
164         
165         setTest("boolean - change back to false");
166         book.setAvailable(b1);
167         check(b1==book.isAvailable());
168         out("should have an 'available' element:",
169         book.dumpDomNode("available", 1));
170     }
171     
172     
173     //
174
// Array of string test
175
//
176
// The tests are performed on the Paragraph string array,
177
// member of the Chapter bean.
178
// The book contains three chapter. There is one chapter
179
// with no paragraph, one with one paragraph and one with
180
// two paragraph. This convers the three cases: empty array,
181
// array with only one element, and array with more than one
182
// element.
183
//
184

185     {
186         out("String[] - search for the string arrays");
187         out("found " + book.sizeChapter() + " chapter in book");
188         for (int i=0; i<book.sizeChapter(); i++) {
189         Chapter c = book.getChapter(i);
190         out("chapter " + (i+1) + " has " + c.sizeParagraph() +
191         " paragraphs:", c.dumpDomNode("paragraph", 1));
192         }
193     }
194     
195     // Test array size = 0
196
{
197         Chapter c = null;
198         
199         setTest("String[0] - search for empty array");
200         for (int i=0; i<book.sizeChapter(); i++) {
201         Chapter c2 = book.getChapter(i);
202         if (c2.sizeParagraph() == 0) {
203             c = c2;
204             break;
205         }
206         }
207         check(c != null);
208         
209         int tmp[] = {-1, 0, 1, 999};
210         
211         // Check for out of bound exception
212
for (int i=0; i<tmp.length; i++) {
213         setTest("String[0] - out of bounds access [" + tmp[i] +
214         "]");
215         s1 = "This is a new paragraph";
216         try {
217             c.setParagraph(tmp[i], s1);
218             check(false, "didn't get an exception");
219         }
220         catch(IndexOutOfBoundsException JavaDoc e) {
221             check(true, "(IndexOutOfBoundsException)");
222         }
223         catch(Exception JavaDoc ee) {
224             check(false, ee.getMessage());
225         }
226         }
227         
228         // Adding an element
229
setTest("String[0] - add a string to the array");
230         c.addParagraph(s1);
231         if (c.sizeParagraph() != 1)
232         err("array size != 1");
233         s2 = c.getParagraph(0);
234         check(s1.equals(s2));
235         out("should contain one paragraph:",
236         c.dumpDomNode("paragraph", 1));
237         
238         setTest("String[0] - add another string to the array");
239         c.addParagraph(s1);
240         if (c.sizeParagraph() != 2)
241         err("array size != 2");
242         s2 = c.getParagraph(1);
243         check(s1.equals(s2));
244         out("should contain two paragraphs:",
245         c.dumpDomNode("paragraph", 1));
246         
247         setTest("String[0] - compare paragraphs");
248         s1 = c.getParagraph(0);
249         s2 = c.getParagraph(1);
250         check(s1.equals(s2), "(same content)");
251         check(s1 != s2, "(different instances)");
252         
253         setTest("String[0] - remove element");
254         c.setParagraph(0, null);
255         check(c.sizeParagraph() == 2);
256         out("should contain one paragraph:",
257         c.dumpDomNode("paragraph", 1));
258         
259         setTest("String[0] - access elements");
260         s2 = c.getParagraph(0);
261         check(s2 == null, "(first, should be null)");
262         s2 = c.getParagraph(1);
263         check(s2 != null, "(second, should be !null)");
264         
265         s1 = "This is another new paragraph";
266         setTest("String[0] - set again first element");
267         c.setParagraph(0, s1);
268         check(c.sizeParagraph() == 2);
269         out("should contain two paragraphs:",
270         c.dumpDomNode("paragraph", 1));
271         
272         setTest("String[0] - removing all elements");
273         s1 = c.getParagraph(1);
274         int i1 = c.removeParagraph(s1);
275         check(i1 == 1, "(removed correct index)");
276         check(c.sizeParagraph() == 1, "(size is now 1)");
277         s1 = c.getParagraph(0);
278         int i2 = c.removeParagraph(s1);
279         check(i2 == 0, "(removed correct index)");
280         check(c.sizeParagraph() == 0, "(size is now 0)");
281         out("should contain no paragraph:",
282         c.dumpDomNode("paragraph", 1));
283         
284     }
285     
286     // Test array size = 1
287
{
288         Chapter c = null;
289         s1 = "This is again another new paragraph";
290         
291         setTest("String[0] - search for array of size 1");
292         for (int i=0; i<book.sizeChapter(); i++) {
293         Chapter c2 = book.getChapter(i);
294         if (c2.sizeParagraph() == 1) {
295             c = c2;
296             break;
297         }
298         }
299         check(c != null);
300         
301         int tmp[] = {-1, 1, 999};
302         
303         // Check for out of bound exception
304
for (int i=0; i<tmp.length; i++) {
305         setTest("String[0] - out of bounds access [" + tmp[i] +
306         "]");
307         try {
308             c.setParagraph(tmp[i], s1);
309             check(false, "didn't get an exception");
310         }
311         catch(IndexOutOfBoundsException JavaDoc e) {
312             check(true, "(IndexOutOfBoundsException)");
313         }
314         catch(Exception JavaDoc ee) {
315             check(false, ee.getMessage());
316         }
317         }
318         
319         // Adding an element
320
setTest("String[0] - add a string to the array");
321         c.addParagraph(s1);
322         if (c.sizeParagraph() != 2)
323         err("array size != 2");
324         s2 = c.getParagraph(1);
325         check(s1.equals(s2));
326         out("should contain two paragraphs:",
327         c.dumpDomNode("paragraph", 1));
328         
329         setTest("String[0] - compare paragraphs");
330         s1 = c.getParagraph(0);
331         s2 = c.getParagraph(1);
332         check(!s1.equals(s2), "(different content)");
333         
334         setTest("String[0] - add more paragraphs");
335         s1 = "I always wanted to be a kind of a big paragraph " +
336         " as I always dreamed to fill an XML paragraph element " +
337         " only to make sure it could be large enough stuffed with " +
338         " useless characters.";
339         int size = 100;
340         for (int i=0; i<size; i++)
341         c.addParagraph(s1);
342         check(c.sizeParagraph() == size+2 ,
343         "(" + size + " new paragraphs)");
344         
345         setTest("String[0] - removing paragraphs (leaving 10)");
346         for (int i=0; i<size-8; i++)
347         c.removeParagraph(s1);
348         check(c.sizeParagraph() == 10);
349         out("should contain 10 paragraphs:",
350         c.dumpDomNode("paragraph", 1));
351     }
352     
353     
354     //
355
// Bean elements test
356
//
357
// The following tests that we can create a brand new bean,
358
// populate it with other beans an insert it into an existing
359
// bean graph.
360
//
361
// The bean elements test are using the Index and Ref beans
362
// of the Book bean graph:
363
//
364
// Book
365
// Index[1,n]
366
// Word - String
367
// Ref[1,n]
368
// Page - String
369
// Line - String
370
// ...
371
//
372
//
373
{
374         Index idx;
375         
376         int size = book.sizeIndex();
377         out("book has " + size + " Index beans",
378         book.dumpDomNode("index", 1));
379         
380         setTest("remove a bean w/ remove()");
381         idx = book.getIndex(0);
382         int i1 = book.removeIndex(idx);
383         check(i1==0, "(correct element removed)");
384         check(book.sizeIndex()==size-1, "(correct Index array size)");
385         out("book should have " + (size - 1) + " Index beans",
386         book.dumpDomNode("index", 1));
387         
388         setTest("remove another bean w/ set(null)");
389         idx = book.getIndex(0);
390         book.setIndex(0, null);
391         check(book.sizeIndex()==size-1, "(correct Index array size)");
392         out("book should have " + (size - 2) + " Index beans",
393         book.dumpDomNode("index", 1));
394         
395         setTest("add an empty bean to the graph");
396         idx = new Index();
397         book.addIndex(idx);
398         check(book.sizeIndex()==size, "(correct Index array size)");
399         out("book should have " + (size - 1) + " Index beans",
400         book.dumpDomNode("index", 1));
401         
402         setTest("add a subtree bean");
403         Ref r = new Ref();
404         r.setPage(122);
405         r.setLine(32);
406         idx = new Index();
407         idx.addRef(r);
408         r = new Ref();
409         r.setPage(1);
410         r.setLine(3);
411         idx.addRef(r);
412         idx.setWord("who");
413         book.setIndex(0, idx);
414         out("book should have " + size + " Index beans",
415         book.dumpDomNode("index", 1));
416         out("idx should have 2 refs",
417         idx.dumpDomNode(3));
418         check(book.sizeIndex() == size);
419         
420         setTest("add another subtree bean");
421         r = new Ref();
422         r.setPage(22);
423         r.setLine(2);
424         idx = new Index();
425         idx.setWord("what");
426         idx.addRef(r);
427         book.addIndex(idx);
428         out("book should have " + (size+1) + " Index beans",
429         book.dumpDomNode("index", 1));
430         out("idx should have 1 ref",
431         idx.dumpDomNode(3));
432         check(book.sizeIndex() == size+1);
433         
434         setTest("should failed adding the same instance subtree");
435         try {
436         book.addIndex(idx);
437         check(false, "didn't get an exception");
438         }
439         catch(IllegalArgumentException JavaDoc e) {
440         check(true, "\n >> caught: " + e);
441         }
442         catch(Exception JavaDoc ee) {
443             ee.printStackTrace();
444         check(false, "\n >> got wrong type of exception: " + ee);
445         }
446         
447         setTest("add the same cloned tree");
448         int i2 = book.addIndex((Index)book.getIndex(0).clone());
449         out("book should have " + (i2+1) + " Index beans",
450         book.dumpDomNode("index", 1));
451         
452         out("Initial Index is:",
453         book.getIndex(0).dumpDomNode(3));
454         out("New Index should be identical:",
455         book.getIndex(i2).dumpDomNode(3));
456         
457         check(book.sizeIndex() == i2+1);
458     }
459     
460     //
461
// Bean elements test 2
462
//
463
// The following tests that we can create, add, remove beans
464
// and values of a graph that is not attached to a DOM tree.
465
//
466
{
467         Index idx = new Index();
468         idx.setWord("oops");
469         setTest("add beans");
470         Ref r = new Ref();
471         r.setPage(999);
472         r.setLine(9);
473         idx.addRef(r);
474         r = new Ref();
475         r.setPage(888);
476         r.setLine(8);
477         idx.addRef(r);
478         check(idx.sizeRef()==2, "(correct size of array)");
479         out("should have nothing to print: ", idx.dumpDomNode(1));
480         setTest("remove an element");
481         idx.removeRef(r);
482         check(idx.sizeRef()==1, "(correct size of array)");
483         setTest("remove last element");
484         idx.setRef(0, null);
485         check(idx.sizeRef()==1, "(correct size)");
486         r = new Ref();
487         r.setPage(77);
488         r.setLine(7);
489         idx.setRef(0, r);
490         out("add an element and test getValues:", idx.dumpBeanNode());
491     }
492     
493     //
494
// The following test creates a brand new bean graph and therefore
495
// a new DOM graph.
496
//
497
setTest("creating the root for a brand new graph");
498     book = Book.createGraph();
499     check(book != null);
500     
501     setTest("populating the graph");
502     book.setGood(false);
503     book.setAvailable(true);
504     book.setSummary("This book is about avoiding summaries at the end of books");
505     Chapter c = new Chapter();
506     c.setComment("What's a good summary in chapter 1");
507     c.setComment2("Additional comment");
508     c.addParagraph("This is the first paragraph");
509     c.addParagraph("This is a second paragraph");
510     book.addChapter(c);
511     
512     c = new Chapter();
513     book.addChapter(c);
514     c.setComment("Yet another comment for chapter 2");
515     c.addParagraph("only one paragraph in this second chapter");
516     
517     c = new Chapter();
518     book.addChapter(c);
519     
520     Index i = new Index();
521     i.setWord("summary");
522     
523     Ref r = new Ref();
524     r.setPage(22);
525     r.setLine(12);
526     i.addRef(r);
527     
528     r = new Ref();
529     i.addRef(r);
530     r.setPage(4);
531     r.setLine(5);
532     
533     book.addIndex(i);
534     
535     check(true);
536     
537     out("print the new graph DOM nodes:",
538     book.dumpDomNode(9));
539     
540     out("Re-read the original XML file for array getter/setter testing");
541     this.readDocument();
542     book = Book.createGraph(doc);
543     out("bean graph created");
544     
545     {
546         setTest("check Index[] getter() method");
547         Index []a1 = book.getIndex();
548         check(a1.length == book.sizeIndex(), "(correct array size)");
549         check(a1[0] == book.getIndex(0), "(same first element)");
550         check(a1[1] == book.getIndex(1), "(same second element)");
551         check(a1[0] != book.getIndex(1), "([0] != [1])");
552         setTest("check Chapter[] getter() method");
553         Chapter []a2 = book.getChapter();
554         check(a2.length == book.sizeChapter(), "(correct array size)");
555         check(a2[0] == book.getChapter(0), "(same first element)");
556         check(a2[1] == book.getChapter(1), "(same second element)");
557         check(a2[2] == book.getChapter(2), "(same third element)");
558         check(a2[0] != book.getChapter(2), "([0] != [2])");
559         setTest("check Chapter.Paragraph getter() method");
560         String JavaDoc []p = a2[0].getParagraph();
561         check(p.length == book.getChapter(0).sizeParagraph(),
562         "(correct array size)");
563         p = a2[1].getParagraph();
564         check(p.length == book.getChapter(1).sizeParagraph(),
565         "(correct array size)");
566         p = a2[2].getParagraph();
567         check(p.length == book.getChapter(2).sizeParagraph(),
568         "(correct array size)");
569         setTest("change the Chapter[] order");
570         int []s = new int[3];
571         s[0] = a2[0].sizeParagraph();
572         s[1] = a2[1].sizeParagraph();
573         s[2] = a2[2].sizeParagraph();
574         Chapter []a3 = new Chapter[3];
575         a3[2] = (Chapter)a2[0];
576         a3[1] = (Chapter)a2[1];
577         a3[0] = (Chapter)a2[2];
578         book.setChapter(a3);
579         check(book.getChapter(2).sizeParagraph()==s[0],
580         "(reversed first element)");
581         check(book.getChapter(1).sizeParagraph()==s[1],
582         "(same second element)");
583         check(book.getChapter(0).sizeParagraph()==s[2],
584         "(reversed third element)");
585
586         setTest("Chapter going in and out of Book");
587         out("Make sure the contents of a Chapter object remain intact after removing that Chapter from the Book");
588         Chapter undecidedChapter = new Chapter();
589         undecidedChapter.setComment("This chapter may not make it into the book.");
590         out(undecidedChapter.getComment());
591         book.addChapter(undecidedChapter);
592         out(book.sizeChapter());
593         check(book.getChapter(book.sizeChapter()-1) == undecidedChapter, "undecided chapter is in there");
594         book.removeChapter(undecidedChapter);
595         out("make sure undecidedChapter is intact");
596         out(undecidedChapter.getComment());
597         out("make sure book is intact");
598         out(book.sizeChapter());
599         out("Put the chapter back in.");
600         book.addChapter(undecidedChapter);
601         out(book);
602     }
603     
604     // Read again the document and play with the choice properties
605
this.readDocument();
606     out("creating the bean graph");
607     book = Book.createGraph(doc);
608     
609     setTest("check if the root has any choice prop");
610     Iterator it = book.listChoiceProperties();
611     check(!it.hasNext(), "(none found)");
612     check(book.listChoiceProperties("Chapter") == null, "(none found on Chapter prop)");
613     check(book.listChoiceProperties("index") == null, "(none found on index prop)");
614     setTest("test extra prop");
615     
616     BaseProperty[] bps;
617     Extra e = book.getExtra();
618     it = e.listChoiceProperties();
619     check(it.hasNext(), "(at least one)");
620     //#90905: the iterator returns the elements in different order
621
// for jdk5 and 6, so we need to put them to a list to maintain the order.
622
List<BaseProperty[]> propertiesList = new ArrayList<BaseProperty[]>();
623         while (it.hasNext()) {
624         propertiesList.add((BaseProperty[])it.next());
625     }
626         Collections.sort(propertiesList, new Comparator<BaseProperty[]>(){
627             public int compare(BaseProperty[] o1, BaseProperty []o2) {
628                 return o1[0].getName().compareTo(o2[0].getName());
629             }});
630             
631         for (BaseProperty[] each : propertiesList){
632             out("Getting a set of choice properties:");
633         this.printChoiceProperties(each);
634         }
635     
636     out("Getting the same list 3 times:");
637     bps = e.listChoiceProperties("Size");
638     this.printChoiceProperties(bps);
639     bps = e.listChoiceProperties("size-cm");
640     this.printChoiceProperties(bps);
641     bps = e.listChoiceProperties("size-inches");
642     this.printChoiceProperties(bps);
643     
644     out("Getting twice the same list:");
645     bps = e.listChoiceProperties("WeightKg");
646     this.printChoiceProperties(bps);
647     bps = e.listChoiceProperties("weight-lb");
648     this.printChoiceProperties(bps);
649     
650     check(!e.isChoiceProperty("color"), " color not choice prop");
651     
652     //
653
// This tests the DDParser class
654
//
655
//this.out(book.dumpBeanNode());
656

657     this.parse(book, "/Book/Good");
658     this.parse(book, "/Good");
659     this.parse(book, "Summary/");
660     book.setSummary(null);
661     this.parse(book, "Summary");
662     this.parse(book, "Available");
663     this.parse(book, "Extra");
664     this.parse(book, "Chapter");
665     this.parse(book, "Chapter/Comment");
666     this.parse(book, "Chapter/Paragraph");
667     this.parse(book, "index/ref/line");
668     
669     out(book.dumpBeanNode());
670     this.parse(book, "/Book/Index.Word=E-Tools/Ref/Page");
671     this.parse(book, "/Book/Index.Word=E-Tool/Ref/Page");
672     this.parse(book, "/Book/Index.Word=E-Tool/Ref.Line=15/Page");
673     this.parse(book, "/Book/Index.Word=E-Tool/Ref.Line=15/Page=22");
674     this.parse(book, "/Book/Index.Word=E-Tool/Ref.Line=15/Page=5");
675     
676     book = new Book();
677     out(book.dumpBeanNode());
678     this.parse(book, "/Book/Index.Word=E-Tools/Ref.Line=15/Page!");
679     out(book.dumpBeanNode());
680     this.parse(book, "/Book/Chapter.Comment=My Comment");
681     out(book.dumpBeanNode());
682     this.parse(book, "/Book/Chapter.Comment=My Comment!");
683     out(book.dumpBeanNode());
684     this.parse(book, "/Book/Index.Word=the word/Ref.Line=10/Page=20!");
685     out(book.dumpBeanNode());
686     
687     // Make sure that we can merge (this test the case of merge
688
// without attribute which is covered by TestMerge)
689
setTest("simple merge");
690     this.readDocument();
691     out("creating the bean graph");
692     book = Book.createGraph(doc);
693     Book b2 = (Book)book.clone();
694     s1 = "Some more dynamic notes on the summary.";
695     b2.setSummary(s1);
696     b2.getChapter(0).setComment("New Comment");
697     book.merge(b2);
698     check(book.isEqualTo(b2), "identical graphs");
699
700     // Merge two elements that are not part of the graph
701
Chapter c1 = new Chapter();
702     Chapter c2 = new Chapter();
703     c1.merge(c2);
704
705     }
706     
707     
708     void parse(BaseBean bean, String JavaDoc parse) {
709     out("Parsing " + parse);
710     DDParser p = new DDParser(bean, parse);
711     while (p.hasNext()) {
712         Object JavaDoc o = p.next();
713         if (o != null) {
714         if (o instanceof BaseBean)
715             this.out(((BaseBean)o).dumpBeanNode());
716         else
717             this.out(o.toString());
718         }
719         else
720         this.out("null");
721     }
722     }
723     
724     void printChoiceProperties(BaseProperty[] bps) {
725     if (bps == null)
726         err("got null instead a BaseProperty[] instance");
727     else {
728         for (int l=0; l<bps.length; l++)
729         check(bps[l].isChoiceProperty(), bps[l].getDtdName());
730     }
731     }
732 }
733
734
Popular Tags