|
1
57 package dom.range;
58 import java.io.StringReader  ;
59
60 import org.enhydra.apache.xerces.dom.DocumentImpl;
61 import org.enhydra.apache.xerces.parsers.DOMParser;
62 import org.w3c.dom.Attr ;
63 import org.w3c.dom.Document ;
64 import org.w3c.dom.DocumentFragment ;
65 import org.w3c.dom.NamedNodeMap ;
66 import org.w3c.dom.Node ;
67 import org.w3c.dom.NodeList ;
68 import org.w3c.dom.ranges.Range;
69 import org.xml.sax.InputSource ;
70
71 import dom.DOMWriter;
72
73
78 public class Test {
79
80 static final boolean DEBUG = false;
81
82 static final String [] tests = {
83 "<FOO>AB<MOO>CD</MOO>CD</FOO>",
84 "<FOO>A<MOO>BC</MOO>DE</FOO>",
85 "<FOO>XY<BAR>ZW</BAR>Q</FOO>",
86 "<FOO><BAR1>AB</BAR1><BAR2/><BAR3>CD</BAR3></FOO>",
87 "<A><B><M/><C><D/><E/><F/><HELLO/></C><N/><O/></B>"+
88 "<Z><X/><Y/></Z>"+
89 "<G/><Q><V/><W/></Q></A>"
90 };
91 static final String [] deleteResult = {
92 "<FOO>ACD</FOO>",
93 "<FOO>A<MOO>B</MOO>E</FOO>",
94 "<FOO>X<BAR>W</BAR>Q</FOO>",
95 "<FOO><BAR1>A</BAR1><BAR3>D</BAR3></FOO>",
96 "<A><B><M></M><C><D></D></C></B><Q><W></W></Q></A>"
97 };
98 static final String [] extractResult = {
99 "B<MOO>CD</MOO>",
100 "<MOO>C</MOO>D",
101 "Y<BAR>Z</BAR>",
102 "<BAR1>B</BAR1><BAR2></BAR2><BAR3>C</BAR3>",
103 "<B><C><E></E><F></F><HELLO></HELLO></C>"+
104 "<N></N><O></O></B><Z><X></X><Y></Y></Z><G></G><Q><V></V></Q>"
105 };
106
107 static final String INSERT="***";
108 static final String [] insertResult = {
109 "<FOO>A"+INSERT+"B<MOO>CD</MOO>CD</FOO>",
110 "<FOO>A<MOO>B"+INSERT+"C</MOO>DE</FOO>",
111 "<FOO>X"+INSERT+"Y<BAR>ZW</BAR>Q</FOO>",
112 "<FOO><BAR1>A"+INSERT+"B</BAR1><BAR2></BAR2><BAR3>CD</BAR3></FOO>",
113 "<A><B><M></M><C><D></D>"+INSERT+"<E></E><F></F><HELLO></HELLO></C>"+
114 "<N></N><O></O></B><Z><X></X><Y></Y></Z><G></G><Q><V></V><W></W></Q></A>"
115 };
116
117
118 static final String SURROUND="SURROUND";
119
120 static final String [] surroundResult = {
121 "<FOO>A<"+SURROUND+">B<MOO>CD</MOO>C</"+SURROUND+">D</FOO>",
122 "<FOO>A<MOO>B<"+SURROUND+">C</"+SURROUND+"></MOO>DE</FOO>",
123 "<FOO>X<"+SURROUND+">Y<BAR>ZW</BAR></"+SURROUND+">Q</FOO>",
124 "<FOO><BAR1>AB</BAR1><"+SURROUND+"><BAR2></BAR2></"+SURROUND+"><BAR3>CD</BAR3></FOO>",
125 "<A><B><M></M><C><D></D><E></E><F></F><HELLO></HELLO></C>"+
126 "<N></N><O></O></B><Z><"+SURROUND+"><X></X><Y></Y></"+SURROUND+"></Z>"+
127 "<G></G><Q><V></V><W></W></Q></A>"
128 };
129
130 static final String [] rangeDelete = {
131 "<P>Abcd efgh The Range ijkl</P>",
132 "<p>Abcd efgh The Range ijkl</p>",
133 "<P>ABCD efgh The <EM>Range</EM> ijkl</P>",
134 "<P>Abcd efgh The Range ijkl</P>",
135 "<P>Abcd <EM>efgh The Range ij</EM>kl</P>"
136 };
137 static final String [] rangeDeleteResult = {
139 "<P>Abcd ^Range ijkl</P>",
140 "<p>Abcd ^kl</p>",
141 "<P>ABCD ^<EM>ange</EM> ijkl</P>",
142 "<P>Abcd ^he Range ijkl</P>",
143 "<P>Abcd ^kl</P>"
144 };
145
146 static final String INSERT2="<P>Abcd efgh XY blah ijkl</P>";
147 static final String INSERTED_TEXT = "INSERTED TEXT";
148
149 static final String [] rangeInsertResult = {
150 "<P>Abcd efgh INSERTED TEXTXY blah ijkl</P>",
151 "<P>Abcd efgh XINSERTED TEXTY blah ijkl</P>",
152 "<P>Abcd efgh XYINSERTED TEXT blah ijkl</P>",
153 "<P>Abcd efgh XY blahINSERTED TEXT ijkl</P>"
154 };
155
156
157 public static void main(String args[]) {
158 if ( args.length == 0 ) {
160 printUsage();
161 System.exit(1);
162 }
163 new Test(args[0]);
164 }
165
166
167 private static void printUsage() {
168
169 System.err.println("usage: java dom.range.Test (options) ...");
170 System.err.println();
171 System.err.println("options:");
172 System.err.println(" all all tests");
173 System.err.println(" delete delete test");
174 System.err.println(" extract extract test");
175 System.err.println(" clone clone test");
176 System.err.println(" insert insert test");
177 System.err.println(" surround surround test");
178 System.err.println(" insert2 insert mutation test");
179 System.err.println(" delete2 delete mutation test");
180
181 }
183
184 public Test(String arg) {
185 if (arg.equals("all")) {
186 boolean all = false;
187 all = performTest("delete");
188 all = performTest("extract")&&all;
189 all = performTest("clone")&&all;
190 all = performTest("insert")&&all;
191 all = performTest("surround")&&all;
192 all = performTest("insert2")&&all;
193 all = performTest("delete2")&&all;
194 if (all)
195 System.out.println("*** ALL TESTS PASSED! ***");
196 else
197 System.out.println("*** ONE OR MORE TESTS FAILED! ***");
198
199 } else {
200 performTest(arg);
201 }
202 }
203
204 public boolean performTest(String arg) {
205 boolean passed = true;
206 try {
207 DOMWriter writer = new DOMWriter(false);
208 DOMParser parser = new DOMParser();
209 if (!arg.equals("delete2") && !arg.equals("insert2")) {
210 System.out.println("\n*************** Test == "+arg+" ***************");
211 for (int i = 0; i < tests.length; i++) {
212 System.out.println("\n\nTest["+i+"]");
213 System.out.println("\nBefore "+arg+": document="+tests[i]+":");
214 parser.parse(new InputSource (new StringReader (tests[i])));
215 DocumentImpl document = (DocumentImpl)parser.getDocument();
216 Range range = document.createRange();
217 Node root = document.getDocumentElement();
218 boolean surround = false;
219 Node surroundNode=document.createElement(SURROUND);
220 if (arg.equals("surround")) {
221 surround = true;
222 }
223
224 if (i == 0) {
225 range.setStart(root.getFirstChild(), 1);
226 range.setEndBefore(root.getLastChild());
227 if (surround)
228 range.setEnd(root.getLastChild(),1);
229
230 }
231 else if (i == 1) {
232 Node n1 = root.getFirstChild().getNextSibling().
233 getFirstChild();
234 range.setStart(n1, 1);
235 range.setEnd(root.getLastChild(), 1);
236 if (surround)
237 range.setEnd(n1,2);
238 }
239 else if (i == 2) {
240 range.setStart(root.getFirstChild(), 1);
241 Node n2 = root.getFirstChild().getNextSibling().getFirstChild();
242 range.setEnd(n2, 1);
243 if (surround)
244 range.setEndBefore(root.getLastChild());
245 }
246 else if (i == 3) {
247 Node n3 = root.getFirstChild().getFirstChild();
248 range.setStart(n3, 1);
249 range.setEnd(root.getLastChild().getFirstChild(), 1);
250 if (surround) {
251 range.selectNode(root.getFirstChild().getNextSibling());
252 }
253 }
254 else if (i == 4) {
255 Node n4 = root.getFirstChild().getFirstChild().getNextSibling().getFirstChild();
256 range.setStartAfter(n4);
257 range.setEndAfter(root.getLastChild().getFirstChild());
258 if (surround) {
259 range.selectNodeContents(root.getFirstChild().getNextSibling());
260 }
261 }
262
263 System.out.println("range.toString="+range.toString());
264 DocumentFragment frag = null;
265
266 if (arg.equals("surround")) {
267 try {
268 System.out.println("surroundNode="+surroundNode);
269 range.surroundContents(surroundNode);
270 } catch (org.w3c.dom.ranges.RangeException e) {
271 System.out.println(e);
272 }
273 String result = toString(document);
274 System.out.println("After surround: document="+result+":");
275 if (!result.equals(surroundResult[i])) {
276 System.out.println("Should be: document="+surroundResult[i]+":");
277 passed = false;
278 System.out.println("Test FAILED!");
279 System.out.println("*** Surround document Test["+i+"] FAILED!");
280 }
281 }
282
283 if (arg.equals("insert")) {
284 range.insertNode(document.createTextNode(INSERT));
285 String result = toString(document);
286 System.out.println("After insert: document="+result+":");
287 if (!result.equals(insertResult[i])) {
288 System.out.println("Should be: document="+insertResult[i]+":");
289 passed = false;
290 System.out.println("Test FAILED!");
291 System.out.println("*** Insert document Test["+i+"] FAILED!");
292 }
293
294 } else
295 if (arg.equals("delete")) {
296 range.deleteContents();
297 String result = toString(document);
298 System.out.println("After delete:"+result+":");
299 if (!result.equals(deleteResult[i])) {
300 System.out.println("Should be: document="+deleteResult[i]+":");
301 passed = false;
302 System.out.println("Test FAILED!");
303 System.out.println("*** Delete document Test["+i+"] FAILED!");
304 }
305 }
306 else
307 if (arg.equals("extract")) {
308 frag = range.extractContents();
309 String result = toString(document);
311 System.out.println("After extract: document="+result+":");
312 if (!result.equals(deleteResult[i])) {
313 System.out.println("Should be: document="+deleteResult[i]+":");
314 passed = false;
315 System.out.println("*** Extract document Test["+i+"] FAILED!");
316 }
317 String fragResult = toString(frag);
318 System.out.println("After extract: fragment="+fragResult+":");
319 if (!fragResult.equals(extractResult[i])) {
320 System.out.println("Should be: fragment="+extractResult[i]+":");
321 passed = false;
322 System.out.println("*** Extract Fragment Test["+i+"] FAILED!");
323 }
324 }
325
326 else
327 if (arg.equals("clone")) {
328 frag = range.cloneContents();
329 String fragResult = toString(frag);
330 System.out.println("After clone: fragment="+fragResult);
331 if (!fragResult.equals(extractResult[i])) {
332 System.out.println("Should be: fragment="+extractResult[i]+":");
333 passed = false;
334 System.out.println("*** Clone Fragment Test["+i+"] FAILED!");
335 }
336 }
337
338 }
339
340 } else
341 if (arg.equals("insert2")) {
342 System.out.println("\n*************** Test == "+arg+" ***************");
343 for (int i = 0; i < 4; i++) {
344
345 System.out.println("\n\nTest["+i+"]");
346 System.out.println("\nBefore "+arg+": document="+INSERT2+":");
347 parser.parse(new InputSource (new StringReader (INSERT2)));
348 DocumentImpl document = (DocumentImpl)parser.getDocument();
349 Node root = document.getDocumentElement();
350 Range range = document.createRange();
351 range.setStart(root.getFirstChild(),11);
352 range.setEnd(root.getFirstChild(),18);
353 Range rangei = document.createRange();
354 if (i == 0) {
355 rangei.setStart(root.getFirstChild(), 10);
356 rangei.setEnd(root.getFirstChild(), 10);
357 }
358 if (i == 1) {
359 rangei.setStart(root.getFirstChild(), 11);
360 rangei.setEnd(root.getFirstChild(), 11);
361 }
362 if (i == 2) {
363 rangei.setStart(root.getFirstChild(), 12);
364 rangei.setEnd(root.getFirstChild(), 12);
365 }
366 if (i == 3) {
367 rangei.setStart(root.getFirstChild(), 17);
368 rangei.setEnd(root.getFirstChild(), 17);
369 }
370
374 if (DEBUG) System.out.println("before insert start="+range.getStartOffset());
375 if (DEBUG) System.out.println("before insert end="+range.getEndOffset());
376 rangei.insertNode(document.createTextNode(INSERTED_TEXT));
377 if (DEBUG) System.out.println("after insert start="+range.getStartOffset());
378 if (DEBUG) System.out.println("after insert end="+range.getEndOffset());
379
380 String result = toString(document);
381 System.out.println("After insert2: document="+result+":");
382 if (!result.equals(rangeInsertResult[i])) {
383 System.out.println("Should be: document="+rangeInsertResult[i]+":");
384 passed = false;
385 System.out.println("Test FAILED!");
386 System.out.println("*** Delete Ranges document Test["+i+"] FAILED!");
387 }
388 }
389 } else
390 if (arg.equals("delete2")) {
391
395 System.out.println("\n*************** Test == "+arg+" ***************");
396 for (int i = 0; i < rangeDelete.length; i++) {
397 System.out.println("\n\nTest["+i+"]");
398 System.out.println("\nBefore "+arg+": document="+rangeDelete[i]+":");
399 parser.parse(new InputSource (new StringReader (rangeDelete[i])));
400 DocumentImpl document = (DocumentImpl)parser.getDocument();
401 Range range = document.createRange();
402 Range ranged = document.createRange();
403 Node root = document.getDocumentElement();
404 boolean surround = false;
405 Node surroundNode=document.createElement(SURROUND);
406 if (arg.equals("surround")) {
407 surround = true;
408 }
409
410 if (i == 0) {
411 ranged.setStart(root.getFirstChild(), 5);
412 ranged.setEnd(root.getFirstChild(), 14);
413
414 range.setStart(root.getFirstChild(), 11);
415 range.setEnd(root.getFirstChild(), 19);
416 }
417 else if (i == 1) {
418 ranged.setStart(root.getFirstChild(), 5);
419 ranged.setEnd(root.getFirstChild(), 22);
420
421 range.setStart(root.getFirstChild(), 11);
422 range.setEnd(root.getFirstChild(), 21);
423 }
424 else if (i == 2) {
425 ranged.setStart(root.getFirstChild(), 5);
426 ranged.setEnd(root.getFirstChild().getNextSibling()
427 .getFirstChild(), 1);
428
429 range.setStart(root.getFirstChild(), 11);
430
431 range.setEndAfter(root.getFirstChild().getNextSibling()
432 .getFirstChild());
433 }
434 else if (i == 3) {
435 ranged.setStart(root.getFirstChild(), 5);
436 ranged.setEnd(root.getFirstChild(), 11);
437
438 range.setStart(root.getFirstChild(), 11);
439 range.setEnd(root.getFirstChild(), 21);
440 }
441 else if (i == 4) {
442 ranged.selectNode(root.getFirstChild().getNextSibling());
443
444 range.setStart(root.getFirstChild().getNextSibling()
445 .getFirstChild(), 6);
446 range.setEnd(root.getFirstChild().getNextSibling()
447 .getFirstChild(), 15);
448 }
449
450 DocumentFragment frag = null;
451
452 if (arg.equals("delete2")) {
453 if (DEBUG) {
454 System.out.println("BEFORE deleteContents()");
455 System.out.println("ranged: startc="+ranged.getStartContainer());
456 System.out.println("ranged: starto="+ranged.getStartOffset());
457 System.out.println("ranged: endc="+ranged.getEndContainer());
458 System.out.println("ranged: endo="+ranged.getEndOffset());
459
460 System.out.println("range: startc="+range.getStartContainer());
461 System.out.println("range: starto="+range.getStartOffset());
462 System.out.println("range: endc="+range.getEndContainer());
463 System.out.println("range: endo="+range.getEndOffset());
464 }
465 ranged.deleteContents();
466 String result = null;
467 if (DEBUG) {
468 System.out.println("AFTER deleteContents()");
469 result = toString(document);
470 System.out.println("ranged: startc="+ranged.getStartContainer());
471 System.out.println("ranged: starto="+ranged.getStartOffset());
472 System.out.println("ranged: endc="+ranged.getEndContainer());
473 System.out.println("ranged: endo="+ranged.getEndOffset());
474
475 System.out.println("range: startc="+range.getStartContainer());
476 System.out.println("range: starto="+range.getStartOffset());
477 System.out.println("range: endc="+range.getEndContainer());
478 System.out.println("range: endo="+range.getEndOffset());
479 }
480
481 ranged.insertNode(document.createTextNode("^"));
482
483 result = toString(document);
484 System.out.println("After delete2: document="+result+":");
485 if (!result.equals(rangeDeleteResult[i])) {
486 System.out.println("Should be: document="+rangeDeleteResult[i]+":");
487 passed = false;
488 System.out.println("Test FAILED!");
489 System.out.println("*** Delete Ranges document Test["+i+"] FAILED!");
490 }
491 }
492 }
493
494 }
495
496
497 }
498 catch (org.xml.sax.SAXParseException spe) {
499 passed = false;
500 }
501 catch (org.xml.sax.SAXException se) {
502 if (se.getException() != null)
503 se.getException().printStackTrace(System.err);
504 else
505 se.printStackTrace(System.err);
506 passed = false;
507 }
508 catch (Exception e) {
509 e.printStackTrace(System.err);
510 passed = false;
511 }
512 if (!passed) System.out.println("*** The "+arg+" Test FAILED! ***");
513
514 return passed;
515 }
516 StringBuffer sb;
517 boolean canonical = true;
518
519 String toString(Node node) {
520 sb = new StringBuffer ();
521 return print(node);
522
523 }
524
525
526 public String print(Node node) {
527
528 if ( node == null ) {
530 return sb.toString();
531 }
532
533 int type = node.getNodeType();
534 switch ( type ) {
535 case Node.DOCUMENT_NODE: {
537 return print(((Document )node).getDocumentElement());
538 }
541
542 case Node.ELEMENT_NODE: {
544 sb.append('<');
545 sb.append(node.getNodeName());
546 Attr attrs[] = sortAttributes(node.getAttributes());
547 for ( int i = 0; i < attrs.length; i++ ) {
548 Attr attr = attrs[i];
549 sb.append(' ');
550 sb.append(attr.getNodeName());
551 sb.append("=\"");
552 sb.append(normalize(attr.getNodeValue()));
553 sb.append('"');
554 }
555 sb.append('>');
556 NodeList children = node.getChildNodes();
557 if ( children != null ) {
558 int len = children.getLength();
559 for ( int i = 0; i < len; i++ ) {
560 print(children.item(i));
561 }
562 }
563 break;
564 }
565
566 case Node.ENTITY_REFERENCE_NODE: {
568 if ( canonical ) {
569 NodeList children = node.getChildNodes();
570 if ( children != null ) {
571 int len = children.getLength();
572 for ( int i = 0; i < len; i++ ) {
573 print(children.item(i));
574 }
575 }
576 } else {
577 sb.append('&');
578 sb.append(node.getNodeName());
579 sb.append(';');
580 }
581 break;
582 }
583
584 case Node.CDATA_SECTION_NODE: {
586 if ( canonical ) {
587 sb.append(normalize(node.getNodeValue()));
588 } else {
589 sb.append("<![CDATA[");
590 sb.append(node.getNodeValue());
591 sb.append("]]>");
592 }
593 break;
594 }
595
596 case Node.TEXT_NODE: {
598 sb.append(normalize(node.getNodeValue()));
599 break;
600 }
601
602 case Node.PROCESSING_INSTRUCTION_NODE: {
604 sb.append("<?");
605 sb.append(node.getNodeName());
606 String data = node.getNodeValue();
607 if ( data != null && data.length() > 0 ) {
608 sb.append(' ');
609 sb.append(data);
610 }
611 sb.append("?>");
612 break;
613 }
614 case Node.DOCUMENT_FRAGMENT_NODE: {
616 NodeList children = node.getChildNodes();
617 if ( children != null ) {
618 int len = children.getLength();
619 for ( int i = 0; i < len; i++ ) {
620 print(children.item(i));
621 }
622 }
623 break;
624 }
625 }
626
627 if ( type == Node.ELEMENT_NODE ) {
628 sb.append("</");
629 sb.append(node.getNodeName());
630 sb.append('>');
631 }
632
633 return sb.toString();
634
635 }
637
638 protected Attr [] sortAttributes(NamedNodeMap attrs) {
639
640 int len = (attrs != null) ? attrs.getLength() : 0;
641 Attr array[] = new Attr [len];
642 for ( int i = 0; i < len; i++ ) {
643 array[i] = (Attr )attrs.item(i);
644 }
645 for ( int i = 0; i < len - 1; i++ ) {
646 String name = array[i].getNodeName();
647 int index = i;
648 for ( int j = i + 1; j < len; j++ ) {
649 String curName = array[j].getNodeName();
650 if ( curName.compareTo(name) < 0 ) {
651 name = curName;
652 index = j;
653 }
654 }
655 if ( index != i ) {
656 Attr temp = array[i];
657 array[i] = array[index];
658 array[index] = temp;
659 }
660 }
661
662 return (array);
663
664 }
666
667 protected String normalize(String s) {
668 StringBuffer str = new StringBuffer ();
669
670 int len = (s != null) ? s.length() : 0;
671 for ( int i = 0; i < len; i++ ) {
672 char ch = s.charAt(i);
673 switch ( ch ) {
674 case '<': {
675 str.append("<");
676 break;
677 }
678 case '>': {
679 str.append(">");
680 break;
681 }
682 case '&': {
683 str.append("&");
684 break;
685 }
686 case '"': {
687 str.append(""");
688 break;
689 }
690 case '\r':
691 case '\n': {
692 if ( canonical ) {
693 str.append("&#");
694 str.append(Integer.toString(ch));
695 str.append(';');
696 break;
697 }
698 }
700 default: {
701 str.append(ch);
702 }
703 }
704 }
705
706 return (str.toString());
707
708 }
710
711 }
712 |
Popular Tags |
Java API By Example, From Geeks To Geeks.