KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > nu > xom > tests > DocTypeTest


1 /* Copyright 2002-2004 Elliotte Rusty Harold
2    
3    This library is free software; you can redistribute it and/or modify
4    it under the terms of version 2.1 of the GNU Lesser General Public
5    License as published by the Free Software Foundation.
6    
7    This library is distributed in the hope that it will be useful,
8    but WITHOUT ANY WARRANTY; without even the implied warranty of
9    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10    GNU Lesser General Public License for more details.
11    
12    You should have received a copy of the GNU Lesser General Public
13    License along with this library; if not, write to the
14    Free Software Foundation, Inc., 59 Temple Place, Suite 330,
15    Boston, MA 02111-1307 USA
16    
17    You can contact Elliotte Rusty Harold by sending e-mail to
18    elharo@metalab.unc.edu. Please include the word "XOM" in the
19    subject line. The XOM home page is located at http://www.xom.nu/
20 */

21
22 package nu.xom.tests;
23
24 import java.io.IOException JavaDoc;
25
26 import org.xml.sax.SAXException JavaDoc;
27 import org.xml.sax.XMLFilter JavaDoc;
28 import org.xml.sax.helpers.XMLFilterImpl JavaDoc;
29 import org.xml.sax.helpers.XMLReaderFactory JavaDoc;
30
31 import nu.xom.Builder;
32 import nu.xom.DocType;
33 import nu.xom.Document;
34 import nu.xom.IllegalDataException;
35 import nu.xom.IllegalNameException;
36 import nu.xom.ParsingException;
37 import nu.xom.ValidityException;
38 import nu.xom.WellformednessException;
39
40 /**
41  * <p>
42  * Various tests for the <code>DocType</code> class.
43  * </p>
44  *
45  * @author Elliotte Rusty Harold
46  * @version 1.0
47  *
48  */

49 public class DocTypeTest extends XOMTestCase {
50
51     
52     public DocTypeTest(String JavaDoc name) {
53         super(name);
54     }
55     
56     
57     String JavaDoc name = "MyName";
58     String JavaDoc systemID = "http://www.w3.org/TR/some.dtd";
59     String JavaDoc publicID = "-//Me//some public ID";
60
61
62     private DocType doctypePublicID;
63     private DocType doctypeSystemID;
64     private DocType doctypeRootOnly;
65
66     
67     protected void setUp() {
68         doctypePublicID = new DocType(name, publicID, systemID);
69         doctypeSystemID = new DocType(name, systemID);
70         doctypeRootOnly = new DocType(name);
71     }
72
73     
74     public void testToXML() {
75         String JavaDoc expected
76           = "<!DOCTYPE " + name + " PUBLIC \""
77             + publicID + "\" \"" + systemID + "\">";
78         assertEquals(expected, doctypePublicID.toXML());
79         assertEquals(
80           "<!DOCTYPE " + name + " SYSTEM \"" + systemID + "\">",
81           doctypeSystemID.toXML()
82         );
83         assertEquals(
84           "<!DOCTYPE " + name + ">",
85           doctypeRootOnly.toXML()
86         );
87     }
88     
89     
90     public void testToXMLWithInternalDTDSubset()
91       throws ValidityException, ParsingException, IOException JavaDoc {
92         String JavaDoc data = "<?xml version=\"1.0\"?>\n"
93           + "<!DOCTYPE root [\n <!ELEMENT test (#PCDATA)>\n]>"
94           + "\n<test />\n";
95         Document doc = (new Builder()).build(data, null);
96         String JavaDoc result = doc.toXML();
97         assertEquals(data, result);
98         
99     }
100     
101     
102     public void testToXMLWithCommentsInInternalDTDSubset()
103       throws ValidityException, ParsingException, IOException JavaDoc {
104         
105         String JavaDoc data = "<?xml version=\"1.0\"?>\n"
106           + "<!DOCTYPE root [\n" +
107                 " <!--comment-->\n <!ELEMENT test (#PCDATA)>" +
108             "\n <!--comment-->\n]>"
109           + "\n<test />\n";
110         Document doc = (new Builder()).build(data, null);
111         String JavaDoc result = doc.toXML();
112         assertEquals(data, result);
113         
114     }
115     
116     
117     public void testToXMLWithCommentsInInternalDTDSubsetAndVerifyingBuilder()
118       throws ValidityException, ParsingException, IOException JavaDoc, SAXException JavaDoc {
119         
120         String JavaDoc data = "<?xml version=\"1.0\"?>\n"
121           + "<!DOCTYPE root [\n" +
122                 " <!--comment-->\n <!ELEMENT test (#PCDATA)>" +
123             "\n <!--comment-->\n]>"
124           + "\n<test />\n";
125         XMLFilter JavaDoc filter = new XMLFilterImpl JavaDoc();
126         filter.setParent(XMLReaderFactory.createXMLReader("org.apache.xerces.parsers.SAXParser"));
127         Document doc = (new Builder(filter)).build(data, null);
128         String JavaDoc result = doc.toXML();
129         assertEquals(data, result);
130         
131     }
132     
133     
134     public void testToXMLWithProcessingInstructionsInInternalDTDSubset()
135       throws ValidityException, ParsingException, IOException JavaDoc {
136         
137         String JavaDoc data = "<?xml version=\"1.0\"?>\n"
138           + "<!DOCTYPE root [\n" +
139                 " <?target data?>\n <!ELEMENT test (#PCDATA)>" +
140             "\n <?target?>\n]>"
141           + "\n<test />\n";
142         Document doc = (new Builder()).build(data, null);
143         String JavaDoc result = doc.toXML();
144         assertEquals(data, result);
145         
146     }
147     
148     
149     public void testToXMLWithProcessingInstructionsInInternalDTDSubsetAndNonverifyingBuilder()
150       throws ValidityException, ParsingException, IOException JavaDoc, SAXException JavaDoc {
151         
152         String JavaDoc data = "<?xml version=\"1.0\"?>\n"
153           + "<!DOCTYPE root [\n" +
154                 " <?target data?>\n <!ELEMENT test (#PCDATA)>" +
155             "\n <?target?>\n]>"
156           + "\n<test />\n";
157         XMLFilter JavaDoc filter = new XMLFilterImpl JavaDoc();
158         filter.setParent(XMLReaderFactory.createXMLReader("org.apache.xerces.parsers.SAXParser"));
159         Document doc = (new Builder(filter)).build(data, null);
160         String JavaDoc result = doc.toXML();
161         assertEquals(data, result);
162         
163     }
164     
165     
166     public void testInternalDTDSubset()
167       throws ParsingException, IOException JavaDoc {
168         
169         String JavaDoc data = "<!DOCTYPE root [ <!ELEMENT root EMPTY> ]><test/>";
170         Builder builder = new Builder();
171         Document doc = builder.build(data, "http://www.example.com");
172         DocType doctype = doc.getDocType();
173         assertEquals("root", doctype.getRootElementName());
174         String JavaDoc internalSubset = doctype.getInternalDTDSubset();
175         assertEquals(" <!ELEMENT root EMPTY>\n", internalSubset);
176         assertTrue(doctype.toXML().indexOf("[") > 0);
177         assertTrue(doctype.toXML().indexOf("]") > 0);
178         assertTrue(doctype.toXML().indexOf("<!ELEMENT root EMPTY>") > 0);
179         
180     }
181
182     
183     public void testToString() {
184         
185         String JavaDoc expected
186           = "[nu.xom.DocType: " + name + "]";
187         assertEquals(expected, doctypePublicID.toString());
188         
189     }
190
191     
192     public void testConstructor1Arg() {
193
194         String JavaDoc name = "MyName";
195         DocType doctype = new DocType(name);
196         assertEquals(name, doctype.getRootElementName());
197         assertEquals("", doctype.getInternalDTDSubset());
198         assertNull(doctype.getSystemID());
199         assertNull(doctype.getPublicID());
200
201         // legal to have a colon here
202
name = "try:MyName";
203         doctype = new DocType(name);
204         assertEquals("", doctype.getInternalDTDSubset());
205         assertEquals(name, doctype.getRootElementName());
206         assertNull(doctype.getSystemID());
207         assertNull(doctype.getPublicID());
208
209         // illegal name
210
try {
211             name = "try MyName";
212             doctype = new DocType(name);
213             fail("allowed root element name to contain spaces");
214         }
215         catch (IllegalNameException success) {
216             assertNotNull(success.getMessage());
217         }
218
219     }
220
221     
222     public void testNullRootElementName() {
223         
224         try {
225             new DocType((String JavaDoc) null);
226             fail("Allowed null root element name");
227         }
228         catch (IllegalNameException success) {
229             assertNotNull(success.getMessage());
230         }
231         
232     }
233
234     
235     public void testRootElementNameBeginsWithDigit() {
236         
237         try {
238             new DocType("1Data");
239             fail("Allowed non-namestart character in root element name");
240         }
241         catch (IllegalNameException success) {
242             assertNotNull(success.getMessage());
243         }
244         
245     }
246
247     
248     public void testRootElementNameBeginsWithColon() {
249         
250         try {
251             new DocType(":Data");
252             fail("Allowed colon to begin root element name");
253         }
254         catch (IllegalNameException success) {
255             assertNotNull(success.getMessage());
256         }
257         
258     }
259
260     
261     public void testSetRootElementName() {
262         
263         DocType doctype = new DocType("root");
264         doctype.setRootElementName("newname");
265         assertEquals("newname", doctype.getRootElementName());
266         doctype.setRootElementName("new:name");
267         assertEquals("new:name", doctype.getRootElementName());
268         try {
269             doctype.setRootElementName(":Data");
270             fail("Allowed colon to begin root element name");
271         }
272         catch (IllegalNameException success) {
273             assertNotNull(success.getMessage());
274         }
275         
276     }
277
278     
279     public void testEmptyRootElementName() {
280         
281         try {
282             new DocType("");
283             fail("Allowed empty string to be root element name");
284         }
285         catch (IllegalNameException success) {
286             assertNotNull(success.getMessage());
287         }
288         
289     }
290
291     
292     public void testNoChildren() {
293         
294         assertEquals(0, doctypePublicID.getChildCount());
295         assertEquals(0, doctypeSystemID.getChildCount());
296         assertEquals(0, doctypeRootOnly.getChildCount());
297         
298         try {
299             doctypePublicID.getChild(0);
300             fail("Got zeroth child");
301         }
302         catch (IndexOutOfBoundsException JavaDoc success) {
303             assertNotNull(success.getMessage());
304         }
305         
306     }
307     
308     
309     public void testConstructor2Arg() {
310
311         String JavaDoc name = "MyName";
312         String JavaDoc systemID = "http://www.w3.org/TR/some.dtd";
313         DocType doctype = new DocType(name, systemID);
314         assertEquals(name, doctype.getRootElementName());
315         assertEquals("", doctype.getInternalDTDSubset());
316         assertEquals(systemID, doctype.getSystemID());
317         assertNull(doctype.getPublicID());
318
319         // empty system ID
320
name = "try:MyName";
321         systemID = "";
322         doctype = new DocType(name, systemID);
323         assertEquals(name, doctype.getRootElementName());
324         assertEquals("", doctype.getInternalDTDSubset());
325         assertEquals(systemID, doctype.getSystemID());
326         assertNull(doctype.getPublicID());
327
328     }
329
330     
331     public void testConstructor3Arg() {
332
333         String JavaDoc name = "MyName";
334         String JavaDoc systemID = "http://www.w3.org/TR/some.dtd";
335         String JavaDoc publicID = "-//Me//some public ID";
336         DocType doctype = new DocType(name, publicID, systemID);
337         assertEquals(name, doctype.getRootElementName());
338         assertEquals("", doctype.getInternalDTDSubset());
339         assertEquals(systemID, doctype.getSystemID());
340         assertEquals(publicID, doctype.getPublicID());
341
342     }
343
344     
345     public void testEmptyStringForPublicID() {
346
347         String JavaDoc name = "MyName";
348         String JavaDoc systemID = "http://www.w3.org/TR/some.dtd";
349         String JavaDoc publicID = "";
350         DocType doctype = new DocType(name, publicID, systemID);
351         assertEquals(name, doctype.getRootElementName());
352         assertEquals("", doctype.getInternalDTDSubset());
353         assertEquals(systemID, doctype.getSystemID());
354         assertEquals(publicID, doctype.getPublicID());
355
356     }
357
358     
359     public void testEmptyStringForSystemID() {
360
361         String JavaDoc name = "MyName";
362         String JavaDoc systemID = "";
363         String JavaDoc publicID = "-//Me//some public ID";
364         DocType doctype = new DocType(name, publicID, systemID);
365         assertEquals(name, doctype.getRootElementName());
366         assertEquals("", doctype.getInternalDTDSubset());
367         assertEquals(systemID, doctype.getSystemID());
368         assertEquals(publicID, doctype.getPublicID());
369
370     }
371
372     
373     public void testIllegalPublicIDs() {
374
375         // PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
376
for (char c = 0; c <= 0x9; c++) {
377             try {
378                 checkPublicIDCharacter(c + "");
379                 fail("Allowed bad public ID character "
380                   + Integer.toHexString(c));
381             }
382             catch (WellformednessException success) {
383                 // successfully detected bad public ID
384
assertNotNull(success.getMessage());
385             }
386         }
387         for (char c = 0xB; c < 0xD; c++) {
388             try {
389                 checkPublicIDCharacter(c + "");
390                 fail("Allowed bad public ID character "
391                   + Integer.toHexString(c));
392             }
393             catch (WellformednessException success) {
394                 // successfully detected bad public ID
395
assertNotNull(success.getMessage());
396             }
397         }
398         for (char c = 0xE; c < 0x20; c++) {
399             try {
400                 checkPublicIDCharacter(c + "");
401                 fail("Allowed bad public ID character "
402                   + Integer.toHexString(c));
403             }
404             catch (WellformednessException success) {
405                 // successfully detected bad public ID
406
assertNotNull(success.getMessage());
407             }
408         }
409         for (char c = '~'; c < 1000; c++) {
410             try {
411                 checkPublicIDCharacter(c + "");
412                 fail("Allowed bad public ID character "
413                   + Integer.toHexString(c));
414             }
415             catch (WellformednessException success) {
416                 // successfully detected bad public ID
417
assertNotNull(success.getMessage());
418             }
419         }
420         
421         char[] illegalPunctuationMarks = "<>`^&\"[]{}|\\~".toCharArray();
422         for (int i = 0; i < illegalPunctuationMarks.length; i++) {
423             char c = illegalPunctuationMarks[i];
424             try {
425                 checkPublicIDCharacter(c + "");
426                 fail("Allowed bad public ID character "
427                   + Integer.toHexString(c));
428             }
429             catch (WellformednessException success) {
430                 // successfully detected bad public ID
431
assertNotNull(success.getMessage());
432             }
433         }
434
435     }
436     
437     
438     public void testLegalPublicIDs() {
439
440         // PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
441
// should public IDs allow initial and trailing space? No.
442
// These are normalized like attribute values according to
443
// section 4.2.2 of the XML spec.
444
// This also means charriage returns and linefeeds are
445
// not roundtrippable. They can appear in the document but not
446
// the infoset so XOM forbids them.
447
checkPublicIDCharacter("-'()+,./:=?;!*#@$_%");
448         for (char c = 'a'; c <= 'z'; c++) checkPublicIDCharacter(c + "");
449         for (char c = 'A'; c <= 'Z'; c++) checkPublicIDCharacter(c + "");
450         for (char c = '0'; c <= '9'; c++) checkPublicIDCharacter(c + "");
451
452     }
453     
454
455     public void testSpaceContainingPublicIDs() {
456
457         // According to section 4.2.2 of the XML spec, public IDs are
458
// normalized like attribute values of non-CDATA type
459
try {
460             new DocType("root", " test", "http://www.example.org");
461             fail("allowed initial space in public ID");
462         }
463         catch (WellformednessException success) {
464             assertNotNull(success.getMessage());
465         }
466
467         try {
468             new DocType("root", "test ", "http://www.example.org");
469             fail("allowed trailing space in public ID");
470         }
471         catch (WellformednessException success) {
472             assertNotNull(success.getMessage());
473         }
474
475         try {
476             new DocType("root", "test\ntest", "http://www.example.org");
477             fail("allowed linefeed public ID");
478         }
479         catch (WellformednessException success) {
480             assertNotNull(success.getMessage());
481         }
482
483         try {
484             new DocType("root", "test\rtest", "http://www.example.org");
485             fail("allowed carriage return in public ID");
486         }
487         catch (WellformednessException success) {
488             assertNotNull(success.getMessage());
489         }
490
491         try {
492             new DocType("root", "test\r\ntest", "http://www.example.org");
493             fail("allowed carriage return linefeed pair public ID");
494         }
495         catch (WellformednessException success) {
496             assertNotNull(success.getMessage());
497         }
498
499         try {
500             new DocType("root", "test test", "http://www.example.org");
501             fail("allowed multiple consecutive spaces in public ID");
502         }
503         catch (WellformednessException success) {
504             assertNotNull(success.getMessage());
505         }
506         
507         // one space is legal
508
DocType test = new DocType("root", "test test", "http://www.example.org");
509         assertEquals(test.getPublicID(), "test test");
510
511     }
512     
513     
514     public void testSystemIDWithDollarSignAndComma() {
515
516         String JavaDoc systemID = "http://www.example.com/test$red/limit,data.xml";
517         DocType doctype = new DocType("root", systemID);
518         assertEquals(systemID, doctype.getSystemID());
519         
520     }
521     
522     
523     public void testSystemIDWithSemicolon() {
524
525         String JavaDoc systemID = "smb://domain;user:pass@server/share/path/to/file";
526         DocType doctype = new DocType("root", systemID);
527         assertEquals(systemID, doctype.getSystemID());
528         
529     }
530     
531     
532     public void testIllegalSystemIDs() {
533
534         // "It is an error for a fragment identifier
535
// (beginning with a # character)
536
// to be part of a system identifier."
537
try {
538             new DocType("test", "http://www.example.com/index.html#test");
539             fail("Allowed system ID with fragment identifier");
540         }
541         catch (IllegalDataException success) {
542             // successfully detected bad system ID
543
assertNotNull(success.getMessage());
544         }
545         
546         try {
547             new DocType("test", "http://www.example.com/index.html#");
548             fail("Allowed # in system ID");
549         }
550         catch (IllegalDataException success) {
551             // successfully detected bad system ID
552
assertNotNull(success.getMessage());
553         }
554
555         try {
556             new DocType("test", "http://www.example.com/\u00A9.html#");
557             fail("Allowed non-ASCII character in system ID");
558         }
559         catch (IllegalDataException success) {
560             // successfully detected bad system ID
561
assertNotNull(success.getMessage());
562         }
563
564         try {
565             new DocType("test", "http://www.example.com/\u0007.html#");
566             fail("Allowed C0 control character in system ID");
567         }
568         catch (IllegalDataException success) {
569             // successfully detected bad system ID
570
assertNotNull(success.getMessage());
571         }
572
573         try {
574             new DocType("test", "test\" and ' in the same ID");
575             fail("Allowed both \" and ' in system ID");
576         }
577         catch (IllegalDataException success) {
578             // successfully detected bad system ID
579
assertNotNull(success.getMessage());
580         }
581
582     }
583     
584     
585     void checkPublicIDCharacter(String JavaDoc publicID) {
586         String JavaDoc name = "MyName";
587         String JavaDoc systemID = "http://www.w3.org/TR/some.dtd";
588         DocType doctype = new DocType(name, publicID, systemID);
589         assertEquals(publicID, doctype.getPublicID());
590     }
591
592     
593     public void testClone() {
594
595         String JavaDoc name = "MyName";
596         String JavaDoc systemID = "http://www.w3.org/TR/some.dtd";
597         String JavaDoc publicID = "-//Me//some public ID";
598         DocType doctype = new DocType(name, publicID, systemID);
599
600         DocType other = (DocType) doctype.copy();
601
602         assertEquals(
603           doctype.getRootElementName(),
604           other.getRootElementName());
605         assertEquals(
606           doctype.getInternalDTDSubset(),
607           other.getInternalDTDSubset()
608         );
609         assertEquals(doctype.getSystemID(), other.getSystemID());
610         assertEquals(doctype.getPublicID(), other.getPublicID());
611         assertTrue(!other.equals(doctype));
612
613     }
614
615     
616     public void testGetters() {
617
618         String JavaDoc name = "MyName";
619         String JavaDoc systemID = "http://www.w3.org/TR/some.dtd";
620         String JavaDoc publicID = "-//Me//some public ID";
621         DocType doctype = new DocType(name, publicID, systemID);
622
623         assertEquals("", doctype.getValue());
624
625     }
626
627     
628     public void testSystemIDRequiredForPublicID() {
629
630         String JavaDoc name = "MyName";
631         DocType doctype = new DocType(name);
632
633         try {
634             doctype.setPublicID("-//Me//some public ID");
635             fail("created a doctype with a public ID and no system ID");
636         }
637         catch (WellformednessException ex) {
638             // success
639
assertNotNull(ex.getMessage());
640         }
641
642     }
643
644     
645     public void testRemove() {
646
647         String JavaDoc name = "MyName";
648         String JavaDoc publicID = "-//Me//some public ID";
649         DocType doctype =
650           new DocType(name, publicID, "http://www.example.com");
651
652         doctype.setPublicID(null);
653         assertNull(doctype.getPublicID());
654         doctype.setPublicID(publicID);
655         assertEquals(publicID, doctype.getPublicID());
656
657         try {
658             doctype.setSystemID(null);
659             fail("removed system ID before removing public ID");
660         }
661         catch (WellformednessException success) {
662             assertNotNull(success.getMessage());
663         }
664
665         doctype.setPublicID(null);
666         assertNull(doctype.getPublicID());
667         doctype.setSystemID(null);
668         assertNull(doctype.getSystemID());
669
670     }
671
672         
673     public void testCarriageReturnInEntityReplacementTextInInternalDTDSubset()
674       throws ParsingException, IOException JavaDoc {
675      
676         Builder builder = new Builder();
677         String JavaDoc data = "<!DOCTYPE root ["
678           + "<!ENTITY CR '&#13;'>"
679           + "]><root/>";
680         Document doc = builder.build(data, null);
681         String JavaDoc internalDTDSubset = doc.getDocType().getInternalDTDSubset();
682         assertTrue(internalDTDSubset.indexOf("<!ENTITY CR \"&#x0D;\">") > 1);
683         
684     }
685
686     
687     public void testCarriageReturnInAttributeDefaultValueInInternalDTDSubset()
688       throws ParsingException, IOException JavaDoc {
689      
690         Builder builder = new Builder();
691         String JavaDoc data = "<!DOCTYPE root ["
692           + "<!ATTLIST root attribute CDATA '&#13;'>"
693           + "]><root/>";
694         Document doc = builder.build(data, null);
695         String JavaDoc internalDTDSubset = doc.getDocType().getInternalDTDSubset();
696         assertTrue(internalDTDSubset.indexOf("<!ATTLIST root attribute CDATA \"&#x0D;\">") > 1);
697         
698     }
699
700     
701     public void testAmpersandInEntityReplacementTextInInternalDTDSubset()
702       throws ParsingException, IOException JavaDoc {
703      
704         Builder builder = new Builder();
705         String JavaDoc data = "<!DOCTYPE root ["
706           + "<!ENTITY amp2 '&amp;'>"
707           + "]><root/>";
708         Document doc = builder.build(data, null);
709         String JavaDoc internalDTDSubset = doc.getDocType().getInternalDTDSubset();
710         assertTrue(internalDTDSubset.indexOf("<!ENTITY amp2 \"&amp;\">") > 1);
711         
712     }
713
714     
715     public void testAmpersandInAttributeDefaultValueInInternalDTDSubset()
716       throws ParsingException, IOException JavaDoc {
717      
718         Builder builder = new Builder();
719         String JavaDoc data = "<!DOCTYPE root ["
720           + "<!ATTLIST root attribute CDATA '&amp;'>"
721           + "]><root/>";
722         Document doc = builder.build(data, null);
723         String JavaDoc internalDTDSubset = doc.getDocType().getInternalDTDSubset();
724         assertTrue(internalDTDSubset.indexOf(
725           "<!ATTLIST root attribute CDATA \"&amp;\">") > 1
726         );
727         
728     }
729     
730     
731     public void testDoubleQuoteInAttributeDefaultValueInInternalDTDSubset()
732       throws ParsingException, IOException JavaDoc {
733      
734         Builder builder = new Builder();
735         String JavaDoc data = "<!DOCTYPE root ["
736           + "<!ATTLIST root attribute CDATA '&quot;'>"
737           + "]><root/>";
738         Document doc = builder.build(data, null);
739         String JavaDoc internalDTDSubset = doc.getDocType().getInternalDTDSubset();
740         assertTrue(internalDTDSubset.indexOf(
741           "<!ATTLIST root attribute CDATA \"&quot;\">") > 1
742         );
743         
744     }
745     
746     
747     public void testSingleQuoteInAttributeDefaultValueInInternalDTDSubset()
748       throws ParsingException, IOException JavaDoc {
749      
750         Builder builder = new Builder();
751         String JavaDoc data = "<!DOCTYPE root ["
752           + "<!ATTLIST root attribute CDATA '&apos;'>"
753           + "]><root/>";
754         Document doc = builder.build(data, null);
755         String JavaDoc internalDTDSubset = doc.getDocType().getInternalDTDSubset();
756         assertTrue(internalDTDSubset.indexOf(
757           "<!ATTLIST root attribute CDATA \"'\">") > 1
758         );
759         
760     }
761     
762     
763     public void testLessThanSignInAttributeDefaultValueInInternalDTDSubset()
764       throws ParsingException, IOException JavaDoc {
765      
766         Builder builder = new Builder();
767         String JavaDoc data = "<!DOCTYPE root ["
768           + "<!ATTLIST root attribute CDATA '&lt;'>"
769           + "]><root/>";
770         Document doc = builder.build(data, null);
771         String JavaDoc internalDTDSubset = doc.getDocType().getInternalDTDSubset();
772         assertTrue(internalDTDSubset.indexOf(
773           "<!ATTLIST root attribute CDATA \"&lt;\">") > 1
774         );
775         
776     }
777     
778     
779     public void testGreaterThanSignInAttributeDefaultValueInInternalDTDSubset()
780       throws ParsingException, IOException JavaDoc {
781      
782         Builder builder = new Builder();
783         String JavaDoc data = "<!DOCTYPE root ["
784           + "<!ATTLIST root attribute CDATA '>'>"
785           + "]><root/>";
786         Document doc = builder.build(data, null);
787         String JavaDoc internalDTDSubset = doc.getDocType().getInternalDTDSubset();
788         assertTrue(internalDTDSubset.indexOf(
789           "<!ATTLIST root attribute CDATA \">\">") > 1
790         );
791         
792     }
793     
794     
795     public void testDoubleQuoteInEntityReplacementTextInInternalDTDSubset()
796       throws ParsingException, IOException JavaDoc {
797      
798         Builder builder = new Builder();
799         String JavaDoc data = "<!DOCTYPE root ["
800           + "<!ENTITY q2 '&quot;'>"
801           + "]><root/>";
802         Document doc = builder.build(data, null);
803         String JavaDoc internalDTDSubset = doc.getDocType().getInternalDTDSubset();
804         assertTrue(internalDTDSubset.indexOf("<!ENTITY q2 \"&quot;\">") > 1);
805         
806     }
807     
808     
809 }
Popular Tags