Clover coverage report - Clover results for XOM 1.2d1
Coverage timestamp: Wed Feb 8 2006 08:31:33 EST
file stats: LOC: 2,735   Methods: 149
NCLOC: 1,985   Classes: 6
Warning
The source file used to generate this report was changed after Clover generated coverage information. The coverage reported may not match the source lines. You should regenerate the coverage information and the report to ensure the files are in sync.
 
 Source file Conditionals Statements Methods TOTAL
SerializerTest.java 90% 98.8% 100% 98.8%
coverage coverage
 1    /* Copyright 2002-2006 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 nu.xom.Elements;
 25    import nu.xom.Namespace;
 26    import nu.xom.Node;
 27    import nu.xom.Serializer;
 28    import nu.xom.Element;
 29    import nu.xom.DocType;
 30    import nu.xom.Document;
 31    import nu.xom.Builder;
 32    import nu.xom.Comment;
 33    import nu.xom.ParsingException;
 34    import nu.xom.ProcessingInstruction;
 35    import nu.xom.Attribute;
 36    import nu.xom.Text;
 37    import nu.xom.UnavailableCharacterException;
 38    import nu.xom.ValidityException;
 39    import nu.xom.XMLException;
 40   
 41    import java.io.ByteArrayInputStream;
 42    import java.io.ByteArrayOutputStream;
 43    import java.io.File;
 44    import java.io.IOException;
 45    import java.io.BufferedReader;
 46    import java.io.InputStream;
 47    import java.io.OutputStream;
 48    import java.io.StringReader;
 49    import java.io.UnsupportedEncodingException;
 50   
 51    /**
 52    * <p>
 53    * Tests for <code>Serializer</code> functionality.
 54    * </p>
 55    *
 56    * @author Elliotte Rusty Harold
 57    * @version 1.2d1
 58    *
 59    */
 60    public class SerializerTest extends XOMTestCase {
 61   
 62   
 63    private Builder parser;
 64    private final static double version = Double.parseDouble(
 65    System.getProperty("java.version").substring(0,3)
 66    );
 67    Element root = new Element("root");
 68    Document doc = new Document(root);
 69    ByteArrayOutputStream out = new ByteArrayOutputStream();
 70   
 71   
 72  131 public SerializerTest(String name) {
 73  131 super(name);
 74    }
 75   
 76   
 77  131 protected void setUp() {
 78  131 parser = new Builder();
 79    }
 80   
 81   
 82  1 public void testNFC88592() throws IOException, ParsingException {
 83   
 84  1 String data = " Ą˘Ł¤ĽŚ§¨ŠŞŤŹ­ŽŻ°ą˛ł´ľśˇ¸šşťź˝žżŔÁÂĂÄĹĆÇČÉĘËĚÍÎĎĐŃŇÓÔŐÖ×ŘŮÚŰÜÝŢßŕáâăäĺćçčéęëěíîďđńňóôőö÷řůúűüýţ˙";
 85  1 Element root = new Element("a");
 86  1 root.appendChild(data);
 87  1 Document doc = new Document(root);
 88   
 89    // try with 8859-2 encoding on serializer
 90  1 Serializer serializer = new Serializer(out);
 91  1 serializer.setUnicodeNormalizationFormC(true);
 92  1 serializer.write(doc);
 93  1 serializer.flush();
 94  1 out.close();
 95  1 byte[] temp = out.toByteArray();
 96  1 Document roundTrip = parser.build(new ByteArrayInputStream(temp));
 97   
 98  1 assertEquals(data, roundTrip.getValue());
 99   
 100    }
 101   
 102   
 103  1 public void testMultipleCombiningCharactersWithNFC()
 104    throws ParsingException, IOException {
 105   
 106    // LATIN CAPITAL LETTER D WITH DOT BELOW, COMBINING DOT ABOVE
 107  1 String input = "<a>&#x1E0A;&#x0323;</a>";
 108    // LATIN CAPITAL LETTER D WITH DOT ABOVE, COMBINING DOT BELOW
 109  1 String output = "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>\r\n"
 110    + "<a>&#x1E0C;&#x307;</a>\r\n";
 111   
 112  1 Document doc = parser.build(input, null);
 113  1 Serializer serializer = new Serializer(out, "US-ASCII");
 114  1 serializer.setUnicodeNormalizationFormC(true);
 115  1 serializer.write(doc);
 116  1 serializer.flush();
 117  1 String result = out.toString("US-ASCII");
 118  1 assertEquals(output, result);
 119   
 120    }
 121   
 122   
 123  1 public void testMultipleCombiningCharactersWithDifferentCombiningClassesNFC()
 124    throws ParsingException, IOException {
 125   
 126    // LATIN SMALL LETTER A, COMBINING GRAVE ACCENT, HEBREW ACCENT ZINOR,
 127    // MUSICAL SYMBOL COMBINING AUGMENTATION DOT, HEBREW ACCENT ZINOR,
 128    // LATIN SMALL LETTER B
 129  1 String input = "<a>&#x0061;&#x0300;&#x05AE;&#x1D16D;&#x05AE;&#x0062;</a>";
 130    // There was a bug where 1D16D was not listed as a combining character
 131  1 String output = "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>\r\n"
 132    + "<a>&#xE0;&#x1D16D;&#x5AE;&#x5AE;b</a>\r\n";
 133   
 134  1 Document doc = parser.build(input, null);
 135  1 Serializer serializer = new Serializer(out, "US-ASCII");
 136  1 serializer.setUnicodeNormalizationFormC(true);
 137  1 serializer.write(doc);
 138  1 serializer.flush();
 139  1 String result = out.toString("US-ASCII");
 140  1 assertEquals(output, result);
 141   
 142    }
 143   
 144   
 145  1 public void testEWithCombiningMacron()
 146    throws ParsingException, IOException {
 147   
 148    // LATIN CAPITAL LETTER E WITH COMBINING MACRON
 149  1 String input = "<a>&#x45;&#x0304;</a>";
 150  1 String output = "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>\r\n<a>&#x112;</a>\r\n";
 151   
 152  1 Document doc = parser.build(input, null);
 153  1 Serializer serializer = new Serializer(out, "US-ASCII");
 154  1 serializer.setUnicodeNormalizationFormC(true);
 155  1 serializer.write(doc);
 156  1 serializer.flush();
 157  1 String result = out.toString("US-ASCII");
 158  1 assertEquals(output, result);
 159   
 160    }
 161   
 162   
 163  1 public void testEWithCombiningMacronAndGrave()
 164    throws ParsingException, IOException {
 165   
 166    // LATIN CAPITAL LETTER E WITH COMBINING MACRON and grave
 167  1 String input = "<a>&#x0045;&#x0304;&#x0300;</a>";
 168  1 String output = "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>\r\n<a>&#x1E14;</a>\r\n";
 169   
 170  1 Document doc = parser.build(input, null);
 171  1 Serializer serializer = new Serializer(out, "US-ASCII");
 172  1 serializer.setUnicodeNormalizationFormC(true);
 173  1 serializer.write(doc);
 174  1 serializer.flush();
 175  1 String result = out.toString("US-ASCII");
 176  1 assertEquals(output, result);
 177   
 178    }
 179   
 180   
 181  1 public void testParenthesizedOjeon()
 182    throws ParsingException, IOException {
 183   
 184    // (Initial consonant Medial Vowel Initial consonant Medial Vowel Final Consonant)
 185  1 String input = "<a>&#x0028;&#x110B;&#x1169;&#x110C;&#x1165;&#x11AB;&#x0029;</a>";
 186  1 String output = "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>\r\n<a>(&#xC624;&#xC804;)</a>\r\n";
 187   
 188  1 Document doc = parser.build(input, null);
 189  1 Serializer serializer = new Serializer(out, "US-ASCII");
 190  1 serializer.setUnicodeNormalizationFormC(true);
 191  1 serializer.write(doc);
 192  1 serializer.flush();
 193  1 String result = out.toString("US-ASCII");
 194  1 assertEquals(output, result);
 195   
 196    }
 197   
 198   
 199  1 public void testNonParenthesizedOjeon()
 200    throws ParsingException, IOException {
 201   
 202    // Initial consonant Medial Vowel Initial consonant Medial Vowel Final Consonant
 203  1 String input = "<a>&#x110B;&#x1169;&#x110C;&#x1165;&#x11AB;</a>";
 204  1 String output = "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>\r\n<a>&#xC624;&#xC804;</a>\r\n";
 205   
 206  1 Document doc = parser.build(input, null);
 207  1 Serializer serializer = new Serializer(out, "US-ASCII");
 208  1 serializer.setUnicodeNormalizationFormC(true);
 209  1 serializer.write(doc);
 210  1 serializer.flush();
 211  1 String result = out.toString("US-ASCII");
 212  1 assertEquals(output, result);
 213   
 214    }
 215   
 216   
 217  1 public void testOjeon()
 218    throws ParsingException, IOException {
 219   
 220    // (Initial consonant Medial Vowel Initial consonant Medial Vowel Final Consonant)
 221  1 String input = "<a>&#x110C;&#x1165;&#x11AB;</a>";
 222  1 String output = "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>\r\n<a>&#xC804;</a>\r\n";
 223   
 224  1 Document doc = parser.build(input, null);
 225  1 Serializer serializer = new Serializer(out, "US-ASCII");
 226  1 serializer.setUnicodeNormalizationFormC(true);
 227  1 serializer.write(doc);
 228  1 serializer.flush();
 229  1 String result = out.toString("US-ASCII");
 230  1 assertEquals(output, result);
 231   
 232    }
 233   
 234   
 235  1 public void testKannadaVowelSignOO()
 236    throws ParsingException, IOException {
 237   
 238  1 String input = "<a>&#x0CC6;&#x0CC2;&#x0CD5;</a>";
 239  1 String output = "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>\r\n<a>&#xCCB;</a>\r\n";
 240   
 241  1 Document doc = parser.build(input, null);
 242  1 Serializer serializer = new Serializer(out, "US-ASCII");
 243  1 serializer.setUnicodeNormalizationFormC(true);
 244  1 serializer.write(doc);
 245  1 serializer.flush();
 246  1 String result = out.toString("US-ASCII");
 247  1 assertEquals(output, result);
 248   
 249    }
 250   
 251   
 252  1 public void testCDATASectionEndDelimiter() throws IOException {
 253   
 254  1 root.appendChild("]]>");
 255  1 Serializer serializer = new Serializer(out, "UTF-8");
 256  1 serializer.setMaxLength(20);
 257  1 serializer.write(doc);
 258  1 String result = out.toString("UTF-8");
 259  1 assertTrue(result.indexOf("]]&gt;") > 0);
 260   
 261    }
 262   
 263   
 264  1 public void testXMLSpacePreserve() throws IOException {
 265   
 266  1 root.addAttribute(
 267    new Attribute(
 268    "xml:space",
 269    "http://www.w3.org/XML/1998/namespace",
 270    "preserve"));
 271  1 String value =
 272    "This is a long sentence with plenty of opportunities for " +
 273    "breaking from beginning to end.";
 274  1 root.appendChild(value);
 275  1 Serializer serializer = new Serializer(out, "UTF-8");
 276  1 serializer.setMaxLength(20);
 277  1 serializer.write(doc);
 278  1 String result = out.toString("UTF-8");
 279  1 assertTrue(result.indexOf(value) > 0);
 280   
 281    }
 282   
 283   
 284    /**
 285    * <p>
 286    * Check that the UTF-16LE encoding omits the byte-order mark.
 287    * </p>
 288    *
 289    * @throws IOException
 290    */
 291  1 public void testUTF16LEBOM() throws IOException {
 292   
 293  1 if (version >= 1.3) {
 294    // UTF-16LE only supported in 1.3 and later
 295  1 Serializer serializer = new Serializer(out, "UTF-16LE");
 296  1 serializer.write(doc);
 297  1 serializer.flush();
 298  1 out.flush();
 299  1 out.close();
 300  1 byte[] data = out.toByteArray();
 301  1 assertEquals('<', (char) data[0]);
 302  1 assertEquals((byte) 0, data[1]);
 303    }
 304   
 305    }
 306   
 307   
 308    /**
 309    * <p>
 310    * Check that the UTF-16 encoding outputs a byte-order mark.
 311    * </p>
 312    *
 313    * @throws IOException
 314    */
 315  1 public void testUTF16BOM() throws IOException {
 316   
 317  1 Serializer serializer = new Serializer(out, "UTF-16");
 318  1 serializer.write(doc);
 319  1 serializer.flush();
 320  1 out.flush();
 321  1 out.close();
 322  1 byte[] data = out.toByteArray();
 323  1 assertEquals((byte) 0xFE, data[0]);
 324  1 assertEquals((byte) 0xFF, data[1]);
 325  1 assertEquals((byte) 0, data[2]);
 326  1 assertEquals('<', (char) data[3]);
 327   
 328    }
 329   
 330   
 331    /**
 332    * <p>
 333    * Check that the UTF-16BE encoding omits the byte-order mark.
 334    * </p>
 335    *
 336    * @throws IOException
 337    */
 338  1 public void testUTF16BEBOM() throws IOException {
 339   
 340  1 if (version >= 1.3) {
 341    // UTF-16LE only supported in 1.3 and later
 342  1 Serializer serializer = new Serializer(out, "UTF-16BE");
 343  1 serializer.write(doc);
 344  1 serializer.flush();
 345  1 out.flush();
 346  1 out.close();
 347  1 byte[] data = out.toByteArray();
 348  1 assertEquals((byte) 0, data[0]);
 349  1 assertEquals('<', (char) data[1]);
 350    }
 351   
 352    }
 353   
 354   
 355  1 public void testXMLSpaceDefault() throws IOException {
 356   
 357  1 root.addAttribute(
 358    new Attribute(
 359    "xml:space",
 360    "http://www.w3.org/XML/1998/namespace",
 361    "preserve"));
 362  1 Element child1 = new Element("preserve");
 363  1 String value =
 364    "This is a long sentence with plenty of opportunities for " +
 365    "breaking from beginning to end.";
 366  1 child1.appendChild(value);
 367  1 Element child2 = new Element("default");
 368  1 root.appendChild(child1);
 369  1 root.appendChild(child2);
 370  1 child2.addAttribute(
 371    new Attribute(
 372    "xml:space",
 373    "http://www.w3.org/XML/1998/namespace",
 374    "default"));
 375  1 String value2 =
 376    "This is another very long sentence with plenty" +
 377    " of opportunities for breaking from beginning to end.";
 378  1 child2.appendChild(value2);
 379   
 380  1 String value3 =
 381    "This is still another very long sentence with plenty of " +
 382    "opportunities for breaking from beginning to end.";
 383  1 Element preserveAgain = new Element("test");
 384  1 preserveAgain.appendChild(value3);
 385  1 child2.appendChild(preserveAgain);
 386  1 preserveAgain.addAttribute(
 387    new Attribute(
 388    "xml:space",
 389    "http://www.w3.org/XML/1998/namespace",
 390    "preserve"));
 391   
 392   
 393  1 Serializer serializer = new Serializer(out, "UTF-8");
 394  1 serializer.setMaxLength(20);
 395  1 serializer.write(doc);
 396  1 String result = out.toString("UTF-8");
 397  1 assertTrue(result.indexOf(value) > 0);
 398  1 assertTrue(result.indexOf(value3) > 0);
 399  1 assertEquals(-1, result.indexOf(value2));
 400   
 401    }
 402   
 403   
 404  1 public void testXMLSpacePreserveWithIndenting()
 405    throws IOException {
 406   
 407  1 root.addAttribute(
 408    new Attribute(
 409    "xml:space",
 410    "http://www.w3.org/XML/1998/namespace",
 411    "preserve"));
 412  1 root.appendChild(new Element("sameline"));
 413  1 ByteArrayOutputStream out = new ByteArrayOutputStream();
 414  1 Serializer serializer = new Serializer(out, "UTF-8");
 415  1 serializer.setIndent(4);
 416  1 serializer.write(doc);
 417  1 String result = out.toString("UTF-8");
 418  1 assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 419    + "<root xml:space=\"preserve\"><sameline/></root>\r\n",
 420    result);
 421   
 422    }
 423   
 424   
 425  1 public void testXMLSpaceUnspecifiedValueWithIndenting()
 426    throws IOException {
 427   
 428  1 root.addAttribute(
 429    new Attribute(
 430    "xml:space",
 431    "http://www.w3.org/XML/1998/namespace",
 432    "undefined"));
 433  1 root.appendChild(new Element("sameline"));
 434  1 Serializer serializer = new Serializer(out, "UTF-8");
 435  1 serializer.setIndent(4);
 436  1 serializer.write(doc);
 437  1 String result = out.toString("UTF-8");
 438  1 assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 439    + "<root xml:space=\"undefined\">\r\n <sameline/>\r\n</root>\r\n",
 440    result);
 441   
 442    }
 443   
 444   
 445  1 public void testXMLSpaceDefaultWithIndenting() throws IOException {
 446   
 447  1 root.addAttribute(
 448    new Attribute(
 449    "xml:space",
 450    "http://www.w3.org/XML/1998/namespace",
 451    "preserve"));
 452  1 Element child = new Element("child");
 453  1 child.addAttribute(
 454    new Attribute(
 455    "xml:space",
 456    "http://www.w3.org/XML/1998/namespace",
 457    "default"));
 458  1 root.appendChild(child);
 459  1 Serializer serializer = new Serializer(out, "UTF-8");
 460  1 serializer.setIndent(4);
 461  1 serializer.write(doc);
 462  1 String result = out.toString("UTF-8");
 463  1 assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 464    + "<root xml:space=\"preserve\">" +
 465    "<child xml:space=\"default\"/></root>\r\n",
 466    result);
 467   
 468    }
 469   
 470   
 471  1 public void testXMLSpaceDefaultWithIndentingAndGrandchildren()
 472    throws IOException {
 473   
 474  1 root.addAttribute(
 475    new Attribute(
 476    "xml:space",
 477    "http://www.w3.org/XML/1998/namespace",
 478    "preserve"));
 479  1 Element child = new Element("child");
 480  1 child.addAttribute(
 481    new Attribute(
 482    "xml:space",
 483    "http://www.w3.org/XML/1998/namespace",
 484    "default"));
 485  1 root.appendChild(child);
 486  1 child.appendChild(new Element("differentLine"));
 487  1 Serializer serializer = new Serializer(out, "UTF-8");
 488  1 serializer.setIndent(2);
 489  1 serializer.write(doc);
 490  1 String result = out.toString("UTF-8");
 491  1 assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 492    + "<root xml:space=\"preserve\">" +
 493    "<child xml:space=\"default\">\r\n <differentLine/>\r\n" +
 494    " </child></root>\r\n",
 495    result);
 496   
 497    }
 498   
 499   
 500  1 public void testDontSerializeXMLNamespace() throws IOException {
 501   
 502  1 Element root
 503    = new Element("html", "http://www.w3.org/1999/xhtml");
 504  1 root.addAttribute(
 505    new Attribute(
 506    "xml:lang", "http://www.w3.org/XML/1998/namespace", "en"));
 507  1 Document doc = new Document(root);
 508  1 Serializer serializer = new Serializer(out, "UTF-8");
 509  1 serializer.write(doc);
 510  1 String result = out.toString("UTF-8");
 511  1 assertEquals(-1, result.indexOf("xmlns:xml"));
 512  1 assertTrue(result.indexOf("xml:lang=") > 1);
 513   
 514    }
 515   
 516  1 public void testDontSerializeNoNamespace() throws IOException {
 517   
 518  1 Serializer serializer = new Serializer(out, "UTF-8");
 519  1 serializer.write(doc);
 520  1 String result = out.toString("UTF-8");
 521  1 assertEquals(-1, result.indexOf("xmlns="));
 522   
 523    }
 524   
 525   
 526  1 public void testDefaultNamespace() throws IOException {
 527   
 528  1 Element root = new Element("root", "http://www.example.com");
 529  1 Document doc = new Document(root);
 530  1 Serializer serializer = new Serializer(out, "UTF-8");
 531  1 serializer.write(doc);
 532  1 String result = out.toString("UTF-8");
 533  1 assertTrue(result.indexOf("xmlns=") > 1);
 534  1 assertTrue(result.indexOf("http://www.example.com") > 1);
 535   
 536    }
 537   
 538   
 539  1 public void testEmptyElement() throws IOException {
 540   
 541  1 Serializer serializer = new Serializer(out, "UTF-8");
 542  1 serializer.write(doc);
 543  1 String result = out.toString("UTF-8");
 544  1 assertEquals(
 545    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<root/>\r\n",
 546    result
 547    );
 548   
 549    }
 550   
 551   
 552  1 public void testElementWithText() throws IOException {
 553   
 554  1 String data = " test \n\n \n \n hello again";
 555  1 root.appendChild(data);
 556  1 Serializer serializer = new Serializer(out, "UTF-8");
 557  1 serializer.write(doc);
 558  1 String result = out.toString("UTF-8");
 559   
 560  1 assertEquals(
 561    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<root>"
 562    + data + "</root>\r\n",
 563    result);
 564   
 565    }
 566   
 567   
 568  1 public void testStaticElementWithText()
 569    throws IOException {
 570   
 571  1 String data = " test \n\n \n \n hello again";
 572  1 root.appendChild(data);
 573  1 Serializer serializer = new Serializer(out);
 574  1 serializer.write(doc);
 575  1 String result = out.toString("UTF-8");
 576   
 577  1 assertEquals(
 578    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<root>"
 579    + data + "</root>\r\n",
 580    result);
 581   
 582    }
 583   
 584   
 585  1 public void testElementWithTextAndCarriageReturns()
 586    throws IOException {
 587   
 588  1 String data = " test \r\n \n \r hello again";
 589  1 root.appendChild(data);
 590  1 Serializer serializer = new Serializer(out, "UTF-8");
 591  1 serializer.write(doc);
 592  1 String result = out.toString("UTF-8");
 593   
 594  1 assertEquals(
 595    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<root>"
 596    + " test &#x0D;\n \n &#x0D; hello again"
 597    + "</root>\r\n",
 598    result);
 599   
 600    }
 601   
 602   
 603  29 private void serializeParseAndCompare(Document doc)
 604    throws IOException, ParsingException {
 605   
 606  29 ByteArrayOutputStream out = new ByteArrayOutputStream();
 607  29 Serializer serializer = new Serializer(out, "UTF-8");
 608  29 serializer.write(doc);
 609  29 String result = out.toString("UTF-8");
 610   
 611  29 Document resultDoc = parser.build(result, null);
 612  29 XOMTestCase.assertEquals(doc, resultDoc);
 613   
 614  29 setOutputStreamSerializeParseAndCompare(doc);
 615   
 616    }
 617   
 618   
 619  29 private void setOutputStreamSerializeParseAndCompare(Document doc)
 620    throws IOException, ParsingException {
 621   
 622  29 Serializer serializer = new Serializer(out);
 623  29 serializer.write(doc);
 624  29 ByteArrayOutputStream out2 = new ByteArrayOutputStream();
 625  29 serializer.setOutputStream(out2);
 626  29 serializer.write(doc);
 627  29 String result = out2.toString("UTF-8");
 628   
 629  29 Document resultDoc = parser.build(result, null);
 630  29 XOMTestCase.assertEquals(doc, resultDoc);
 631   
 632    }
 633   
 634   
 635  1 public void testComment()
 636    throws IOException, ParsingException {
 637   
 638  1 String data = " <>&amp;&entity; test \n hello again";
 639  1 root.appendChild(new Comment(data));
 640  1 serializeParseAndCompare(doc);
 641   
 642    }
 643   
 644   
 645  1 public void testProcessingInstruction()
 646    throws IOException, ParsingException {
 647   
 648  1 String data = "<>&amp;&entity; test \n hello again";
 649  1 root.appendChild(new ProcessingInstruction("target", data));
 650  1 serializeParseAndCompare(doc);
 651   
 652    }
 653   
 654  1 public void testBasicElementWithText()
 655    throws IOException, ParsingException {
 656   
 657  1 String data = " test \n hello again";
 658  1 root.appendChild(data);
 659  1 serializeParseAndCompare(doc);
 660   
 661    }
 662   
 663   
 664  1 public void testAttributes()
 665    throws IOException, ParsingException {
 666   
 667  1 root.addAttribute(new Attribute("test", "sadlkhasdk"));
 668  1 String data = " test \n hello again";
 669  1 root.appendChild(data);
 670  1 serializeParseAndCompare(doc);
 671   
 672  1 root.addAttribute(new Attribute("test2", "sadlkhasdk"));
 673  1 serializeParseAndCompare(doc);
 674   
 675  1 root.addAttribute(new Attribute("test3", " s adl khasdk "));
 676  1 serializeParseAndCompare(doc);
 677   
 678  1 root.addAttribute(new Attribute("xlink:type",
 679    "http://www.w3.org/2001/xlink", " s adl khasdk "));
 680  1 serializeParseAndCompare(doc);
 681   
 682    }
 683   
 684   
 685  1 public void testChildElements()
 686    throws IOException, ParsingException {
 687   
 688  1 serializeParseAndCompare(doc);
 689   
 690  1 Element child1 = new Element("child");
 691  1 Element child2 = new Element("child");
 692  1 Element child3 = new Element("child");
 693  1 serializeParseAndCompare(doc);
 694  1 root.appendChild(child1);
 695  1 serializeParseAndCompare(doc);
 696  1 child1.appendChild(child2);
 697  1 serializeParseAndCompare(doc);
 698  1 root.appendChild(child3);
 699  1 serializeParseAndCompare(doc);
 700  1 child3.appendChild("some data");
 701  1 serializeParseAndCompare(doc);
 702  1 child2.appendChild("\nsome data with \n line breaks\n");
 703  1 serializeParseAndCompare(doc);
 704  1 root.insertChild("now let's have some mixed content", 0);
 705  1 serializeParseAndCompare(doc);
 706   
 707  1 root.setNamespaceURI("http://www.example.org/");
 708  1 serializeParseAndCompare(doc);
 709  1 child1.setNamespaceURI("http://www.example.org/");
 710  1 serializeParseAndCompare(doc);
 711  1 child2.setNamespaceURI("http://www.example.org/");
 712  1 serializeParseAndCompare(doc);
 713  1 child3.setNamespaceURI("http://www.example.org/");
 714  1 serializeParseAndCompare(doc);
 715  1 child1.setNamespacePrefix("example");
 716  1 serializeParseAndCompare(doc);
 717  1 child2.setNamespacePrefix("perverse");
 718  1 serializeParseAndCompare(doc);
 719   
 720    }
 721   
 722   
 723  1 public void testChildElementInNoNamespaceParentInDefaultNamespace()
 724    throws IOException, ParsingException {
 725   
 726  1 Element root = new Element("root", "http://www.example.org/");
 727  1 Element child1 = new Element("child");
 728  1 root.appendChild(child1);
 729  1 Document doc = new Document(root);
 730  1 ByteArrayOutputStream out = new ByteArrayOutputStream();
 731  1 Serializer serializer = new Serializer(out);
 732  1 serializer.write(doc);
 733  1 serializer.flush();
 734  1 String s = out.toString("UTF-8");
 735  1 assertTrue(s.indexOf("xmlns=\"\"") > 0);
 736   
 737    }
 738   
 739   
 740  1 public void testSimpleSerialize()
 741    throws IOException, ParsingException {
 742   
 743  1 Element root = new Element("root");
 744  1 Document doc = new Document(root);
 745  1 ByteArrayOutputStream out = new ByteArrayOutputStream();
 746  1 Serializer serializer = new Serializer(out);
 747  1 serializer.write(doc);
 748  1 serializer.flush();
 749  1 String s = out.toString("UTF-8");
 750  1 assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<root/>\r\n", s);
 751   
 752    }
 753   
 754   
 755  1 public void testPrologAndEpilog()
 756    throws IOException, ParsingException {
 757   
 758  1 serializeParseAndCompare(doc);
 759   
 760  1 doc.insertChild(new Comment("Hello"), 0);
 761  1 serializeParseAndCompare(doc);
 762  1 doc.insertChild(new DocType("root"), 0);
 763  1 serializeParseAndCompare(doc);
 764  1 doc.insertChild(new ProcessingInstruction("test", "some data"),
 765    0);
 766  1 serializeParseAndCompare(doc);
 767  1 doc.insertChild(new Comment("Goodbye"), 0);
 768  1 serializeParseAndCompare(doc);
 769  1 doc.insertChild(
 770    new ProcessingInstruction("goodbye", "some data"), 0);
 771  1 serializeParseAndCompare(doc);
 772  1 doc.appendChild(new Comment("Hello"));
 773  1 serializeParseAndCompare(doc);
 774  1 doc.appendChild(
 775    new ProcessingInstruction("test", "some data"));
 776  1 serializeParseAndCompare(doc);
 777   
 778    }
 779   
 780   
 781  1 public void testChangeLineSeparator() throws IOException {
 782   
 783  1 String breaks =
 784    "This\nstring\rcontains\r\nseveral\r\rweird line breaks.";
 785  1 root.appendChild(breaks);
 786  1 root.addAttribute(new Attribute("test", breaks));
 787   
 788  1 Serializer serializer = new Serializer(out, "UTF-8");
 789  1 serializer.setLineSeparator("\n");
 790  1 serializer.write(doc);
 791  1 String result = out.toString("UTF-8");
 792  1 assertTrue(result.indexOf('\n') > 0);
 793  1 assertTrue(result + "**\n" + result.indexOf('\r'),
 794    result.indexOf('\r') == -1);
 795   
 796  1 out = new ByteArrayOutputStream();
 797  1 serializer = new Serializer(out, "UTF-8");
 798  1 serializer.setLineSeparator("\r");
 799  1 serializer.write(doc);
 800  1 result = out.toString("UTF-8");
 801  1 assertTrue(result.indexOf('\r') > 0);
 802  1 assertTrue(result.indexOf('\n') == -1);
 803   
 804  1 out = new ByteArrayOutputStream();
 805  1 serializer = new Serializer(out, "UTF-8");
 806  1 serializer.setLineSeparator("\r\n");
 807  1 serializer.write(doc);
 808  1 result = out.toString("UTF-8");
 809  1 assertTrue(result.indexOf("\r\n") > 0);
 810  1 for (int i = 0; i < result.length(); i++) {
 811  219 int c = result.charAt(i);
 812  7 if (c == '\r') assertTrue(result.charAt(i+1) == '\n');
 813    }
 814   
 815    }
 816   
 817   
 818  1 public void testSettingOutputStreamDoesNotSetLineSeparator()
 819    throws IOException {
 820   
 821  1 root.appendChild("This\rstring");
 822  1 Serializer serializer = new Serializer(System.out, "UTF-8");
 823   
 824  1 serializer.setOutputStream(out);
 825   
 826  1 serializer.write(doc);
 827  1 String result = out.toString("UTF-8");
 828  1 assertTrue(result.indexOf("This&#x0D;string") > 0);
 829   
 830    }
 831   
 832   
 833  1 public void testSettingOutputStreamDoesNotUnnecessarilyEscapeLineBreaks()
 834    throws IOException {
 835   
 836  1 root.appendChild("This\rstring");
 837  1 Serializer serializer = new Serializer(System.out, "UTF-8");
 838   
 839  1 serializer.setOutputStream(out);
 840  1 serializer.setLineSeparator("\r\n");
 841  1 serializer.write(doc);
 842  1 String result = out.toString("UTF-8");
 843  1 assertTrue(result.indexOf("This\r\nstring") > 0);
 844   
 845    }
 846   
 847   
 848  1 public void testDontChangeLineSeparator() throws IOException {
 849   
 850  1 String breaks
 851    = "This\nstring\rcontains\r\rseveral\n\nweird line breaks.";
 852  1 String breaksHalfEscaped
 853    = "This\nstring&#x0D;contains&#x0D;&#x0D;several" +
 854    "\n\nweird line breaks.";
 855  1 String breaksEscaped
 856    = "This&#x0A;string&#x0D;contains&#x0D;&#x0D;several" +
 857    "&#x0A;&#x0A;weird line breaks.";
 858  1 root.appendChild(breaks);
 859   
 860  1 Serializer serializer = new Serializer(out, "UTF-8");
 861  1 serializer.write(doc);
 862  1 String result = out.toString("UTF-8");
 863  1 assertTrue(result.indexOf(breaksHalfEscaped) > 0);
 864   
 865  1 root = new Element("root");
 866  1 doc = new Document(root);
 867  1 root.addAttribute(new Attribute("test", breaks));
 868   
 869  1 out = new ByteArrayOutputStream();
 870  1 serializer = new Serializer(out, "UTF-8");
 871  1 serializer.write(doc);
 872  1 result = out.toString("UTF-8");
 873  1 assertTrue(result.indexOf(breaksEscaped) > 0);
 874   
 875    }
 876   
 877   
 878  1 public void testPreserveBaseURI() throws IOException {
 879   
 880  1 Serializer serializer = new Serializer(out, "UTF-8");
 881  1 serializer.setPreserveBaseURI(true);
 882  1 serializer.write(doc);
 883  1 String result = out.toString("UTF-8");
 884  1 assertTrue(result.indexOf("<root") > 1);
 885  1 doc.setBaseURI("http://www.example.com/index.xml");
 886  1 serializer.write(doc);
 887  1 result = out.toString("UTF-8");
 888  1 assertTrue(result.indexOf("<root ") > 1);
 889  1 assertTrue(result.indexOf("xml:base=") > 1);
 890  1 assertTrue(
 891    result.indexOf("http://www.example.com/index.xml") > 1
 892    );
 893   
 894    }
 895   
 896   
 897  1 public void testPreserveBaseURIWithChildren() throws IOException {
 898   
 899  1 String base = "http://www.example.com/index.xml";
 900  1 root.setBaseURI(base);
 901  1 Element child = new Element("child");
 902  1 child.setBaseURI(base);
 903  1 root.appendChild(child);
 904  1 Serializer serializer = new Serializer(out, "UTF-8");
 905  1 serializer.setPreserveBaseURI(true);
 906  1 serializer.write(doc);
 907  1 String result = out.toString("UTF-8");
 908  1 assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 909    + "<root xml:base=\"" + base + "\"><child/></root>\r\n", result);
 910   
 911    }
 912   
 913   
 914  1 public void testPreserveBaseURIDoesntOverrideXMLBase()
 915    throws IOException {
 916   
 917  1 root.addAttribute(new Attribute("xml:base",
 918    "http://www.w3.org/XML/1998/namespace",
 919    "http://www.cafeconleche.org/"));
 920  1 Serializer serializer = new Serializer(out, "UTF-8");
 921  1 serializer.setPreserveBaseURI(true);
 922  1 serializer.write(doc);
 923  1 String result = out.toString("UTF-8");
 924  1 assertTrue(result.indexOf("<root") > 1);
 925  1 doc.setBaseURI("http://www.example.com/index.xml");
 926  1 serializer.write(doc);
 927  1 result = out.toString("UTF-8");
 928  1 assertTrue(result.indexOf("<root ") > 1);
 929  1 assertTrue(result.indexOf("xml:base=") > 1);
 930  1 assertTrue(result.indexOf("http://www.cafeconleche.org/") > 1);
 931  1 assertEquals(-1, result.indexOf("http://www.example.com/index.xml"));
 932   
 933    }
 934   
 935   
 936  1 public void testSetLineSeparator() {
 937   
 938  1 Serializer serializer = new Serializer(System.out);
 939   
 940  1 serializer.setLineSeparator("\r");
 941  1 assertEquals("\r", serializer.getLineSeparator());
 942  1 serializer.setLineSeparator("\n");
 943  1 assertEquals("\n", serializer.getLineSeparator());
 944  1 serializer.setLineSeparator("\r\n");
 945  1 assertEquals("\r\n", serializer.getLineSeparator());
 946   
 947  1 try {
 948  1 serializer.setLineSeparator("r");
 949  0 fail("Allowed illegal separator character");
 950    }
 951    catch (IllegalArgumentException success) {
 952  1 assertNotNull(success.getMessage());
 953    }
 954   
 955  1 try {
 956  1 serializer.setLineSeparator("n");
 957  0 fail("Allowed illegal separator character");
 958    }
 959    catch (IllegalArgumentException success) {
 960  1 assertNotNull(success.getMessage());
 961    }
 962   
 963  1 try {
 964  1 serializer.setLineSeparator(" ");
 965  0 fail("Allowed illegal separator character");
 966    }
 967    catch (IllegalArgumentException success) {
 968  1 assertNotNull(success.getMessage());
 969    }
 970   
 971  1 try {
 972  1 serializer.setLineSeparator("rn");
 973  0 fail("Allowed illegal separator character");
 974    }
 975    catch (IllegalArgumentException success) {
 976  1 assertNotNull(success.getMessage());
 977    }
 978   
 979  1 try {
 980  1 serializer.setLineSeparator("<");
 981  0 fail("Allowed illegal separator character");
 982    }
 983    catch (IllegalArgumentException success) {
 984  1 assertNotNull(success.getMessage());
 985    }
 986   
 987  1 try {
 988  1 serializer.setLineSeparator("\u0085");
 989  0 fail("Allowed NEL separator character");
 990    }
 991    catch (IllegalArgumentException success) {
 992  1 assertNotNull(success.getMessage());
 993    }
 994   
 995    }
 996   
 997   
 998  1 public void testLowerLimitOfUnicodeInCharacterData()
 999    throws IOException {
 1000   
 1001  1 root.appendChild("\uD800\uDC00");
 1002  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1003  1 serializer.write(doc);
 1004  1 String result = out.toString("ISO-8859-1");
 1005  1 assertTrue(result, result.indexOf("&#x10000;") > 12);
 1006   
 1007    }
 1008   
 1009   
 1010  1 public void testUpperLimitOfUnicodeInCharacterData()
 1011    throws IOException {
 1012   
 1013  1 root.appendChild("\uDBFF\uDFFD");
 1014  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1015  1 serializer.write(doc);
 1016  1 String result = out.toString("ISO-8859-1");
 1017  1 assertTrue(result, result.indexOf("&#x10FFFD;") > 12);
 1018   
 1019    }
 1020   
 1021   
 1022  1 public void testSerializePlane1CharacterInAttributeValue()
 1023    throws IOException {
 1024   
 1025  1 root.addAttribute(new Attribute("test", "\uD834\uDD1E"));
 1026  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1027  1 serializer.write(doc);
 1028  1 String result = out.toString("ISO-8859-1");
 1029  1 assertTrue(result, result.indexOf("&#x1D11E;") > 12);
 1030   
 1031    }
 1032   
 1033  1 public void testSerializePlane1CharacterInCharacterData()
 1034    throws IOException {
 1035   
 1036  1 root.appendChild("\uD834\uDD1E");
 1037  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1038  1 serializer.write(doc);
 1039  1 String result = out.toString("ISO-8859-1");
 1040  1 assertTrue(result, result.indexOf("&#x1D11E;") > 12);
 1041   
 1042    }
 1043   
 1044   
 1045  1 public void testSurrogatePairCountsAsOneCharacterForColumnCount()
 1046    throws IOException {
 1047   
 1048  1 Element root = new Element("r");
 1049  1 root.appendChild("\uD834\uDD1E");
 1050  1 Document doc = new Document(root);
 1051  1 Serializer serializer = new ColumnSerializer(out);
 1052  1 serializer.write(doc);
 1053   
 1054    }
 1055   
 1056   
 1057    private static class ColumnSerializer extends Serializer {
 1058   
 1059   
 1060  1 ColumnSerializer(OutputStream out) {
 1061  1 super(out);
 1062    }
 1063   
 1064   
 1065  1 public void write(Document doc) throws IOException {
 1066   
 1067  1 for (int i = 0; i < doc.getChildCount(); i++) {
 1068  1 writeChild(doc.getChild(i));
 1069    }
 1070  1 super.flush();
 1071  1 assertEquals(8, super.getColumnNumber());
 1072   
 1073    }
 1074   
 1075   
 1076    }
 1077   
 1078   
 1079  1 public void testEscapeAttributeValue() throws IOException {
 1080   
 1081  1 root.addAttribute(new Attribute("test", "\u0110"));
 1082  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1083  1 serializer.write(doc);
 1084  1 String result = out.toString("ISO-8859-1");
 1085  1 assertTrue(result, result.indexOf("&#x110;") > 5);
 1086   
 1087    }
 1088   
 1089   
 1090  1 public void testLineFeedInAttributeValueWithDefaultOptions()
 1091    throws IOException, ParsingException {
 1092   
 1093  1 root.addAttribute(new Attribute("test", "\n"));
 1094  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1095  1 serializer.write(doc);
 1096  1 out.close();
 1097  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1098  1 Document reparsed = parser.build(in);
 1099  1 assertEquals(doc, reparsed);
 1100   
 1101    }
 1102   
 1103   
 1104  1 public void testCarriageReturnInAttributeValueWithDefaultOptions()
 1105    throws IOException, ParsingException {
 1106   
 1107  1 root.addAttribute(new Attribute("test", "\r"));
 1108  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1109  1 serializer.write(doc);
 1110  1 out.close();
 1111  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1112  1 Document reparsed = parser.build(in);
 1113  1 assertEquals(doc, reparsed);
 1114   
 1115    }
 1116   
 1117   
 1118  1 public void testCarriageReturnInTextWithDefaultOptions()
 1119    throws IOException, ParsingException {
 1120   
 1121  1 root.appendChild("\r");
 1122  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1123  1 serializer.write(doc);
 1124  1 out.close();
 1125  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1126  1 Document reparsed = parser.build(in);
 1127  1 assertEquals(doc, reparsed);
 1128   
 1129    }
 1130   
 1131   
 1132  1 public void testTabInAttributeValueWithDefaultOptions()
 1133    throws IOException, ParsingException {
 1134   
 1135  1 root.addAttribute(new Attribute("test", "\t"));
 1136  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1137  1 serializer.write(doc);
 1138  1 out.close();
 1139  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1140  1 Document reparsed = parser.build(in);
 1141  1 assertEquals(doc, reparsed);
 1142   
 1143    }
 1144   
 1145   
 1146    /**
 1147    * <p>
 1148    * Test that tabs in attribute values are escaped even when
 1149    * a line separator is set.
 1150    * </p>
 1151    */
 1152  1 public void testTabInAttributeValueWithLineSeparator()
 1153    throws IOException, ParsingException {
 1154   
 1155  1 root.addAttribute(new Attribute("test", "\t"));
 1156  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1157  1 serializer.setLineSeparator("\r");
 1158  1 serializer.write(doc);
 1159  1 out.close();
 1160  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1161  1 Document reparsed = parser.build(in);
 1162  1 assertEquals(doc, reparsed);
 1163   
 1164    }
 1165   
 1166   
 1167   
 1168    /**
 1169    * <p>
 1170    * Test that tabs in attribute values are not escaped when
 1171    * indenting.
 1172    * </p>
 1173    */
 1174  1 public void testTabInAttributeValueWithIndenting()
 1175    throws IOException, ParsingException {
 1176   
 1177  1 root.addAttribute(new Attribute("test", "\t"));
 1178  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1179  1 serializer.setIndent(2);
 1180  1 serializer.write(doc);
 1181  1 out.close();
 1182  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1183  1 Document reparsed = parser.build(in);
 1184  1 String result = reparsed.getRootElement().getAttributeValue("test");
 1185  1 assertEquals("Tab not normalized to space", " ", result);
 1186   
 1187    }
 1188   
 1189   
 1190  1 public void testCRLFInAttributeValueWithLineSeparatorCR()
 1191    throws IOException, ParsingException {
 1192   
 1193  1 root.addAttribute(new Attribute("test", "\r\n"));
 1194  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1195  1 serializer.setLineSeparator("\r");
 1196  1 serializer.write(doc);
 1197  1 out.close();
 1198  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1199  1 Document reparsed = parser.build(in);
 1200  1 String result = reparsed.getRootElement().getAttributeValue("test");
 1201  1 assertEquals("\r", result);
 1202   
 1203    }
 1204   
 1205   
 1206  1 public void testCRLFInAttributeValueWithLineSeparatorLF()
 1207    throws IOException, ParsingException {
 1208   
 1209  1 root.addAttribute(new Attribute("test", "\r\n"));
 1210  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1211  1 serializer.setLineSeparator("\n");
 1212  1 serializer.write(doc);
 1213  1 out.close();
 1214  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1215  1 Document reparsed = parser.build(in);
 1216  1 String result = reparsed.getRootElement().getAttributeValue("test");
 1217  1 assertEquals("\n", result);
 1218   
 1219    }
 1220   
 1221  1 public void testLFInAttributeValueWithLineSeparatorCRLF()
 1222    throws IOException, ParsingException {
 1223   
 1224  1 root.addAttribute(new Attribute("test", "\n"));
 1225  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1226  1 serializer.setLineSeparator("\r\n");
 1227  1 serializer.write(doc);
 1228  1 out.close();
 1229  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1230  1 Document reparsed = parser.build(in);
 1231  1 String result = reparsed.getRootElement().getAttributeValue("test");
 1232  1 assertEquals("\r\n", result);
 1233   
 1234    }
 1235   
 1236   
 1237  1 public void testNotEscapeLinefeedInTextContent()
 1238    throws IOException {
 1239   
 1240  1 root.appendChild("\r\n");
 1241  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1242  1 serializer.write(doc);
 1243  1 out.close();
 1244  1 String result = new String(out.toByteArray(), "ISO-8859-1");
 1245  1 assertEquals(
 1246    "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\r\n<root>&#x0D;\n</root>\r\n",
 1247    result
 1248    );
 1249   
 1250    }
 1251   
 1252   
 1253  1 public void testCRLFInAttributeValue()
 1254    throws IOException, ParsingException {
 1255   
 1256  1 root.addAttribute(new Attribute("test", "a\r\na"));
 1257  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1258  1 serializer.write(doc);
 1259  1 out.close();
 1260  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1261  1 Document reparsed = parser.build(in);
 1262  1 String result = reparsed.getRootElement().getAttributeValue("test");
 1263  1 assertEquals("CRLF not escaped", "a\r\na", result);
 1264   
 1265    }
 1266   
 1267   
 1268  1 public void testPunctuationInAttributeValueNonUnicode()
 1269    throws IOException, ParsingException {
 1270   
 1271  1 root.addAttribute(new Attribute("test", "$()*+,="));
 1272  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1273  1 serializer.write(doc);
 1274  1 out.close();
 1275  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1276  1 Document reparsed = parser.build(in);
 1277  1 String result = reparsed.getRootElement().getAttributeValue("test");
 1278  1 assertEquals("$()*+,=", result);
 1279   
 1280    }
 1281   
 1282   
 1283  1 public void testCRLFInAttributeValueWithIndenting()
 1284    throws IOException, ParsingException {
 1285   
 1286  1 root.addAttribute(new Attribute("test", "\r\n"));
 1287  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1288  1 serializer.setIndent(2);
 1289  1 serializer.write(doc);
 1290  1 out.close();
 1291  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1292  1 Document reparsed = parser.build(in);
 1293  1 String result = reparsed.getRootElement().getAttributeValue("test");
 1294  1 assertEquals("CRLF unnecessarily escaped", -1, result.indexOf('\r'));
 1295    // Need to figure out the serializer should indent this
 1296    // and write a unit test for that too.
 1297   
 1298    }
 1299   
 1300   
 1301  1 public void testCRLFInAttributeValueWithMaxLength()
 1302    throws IOException, ParsingException {
 1303   
 1304  1 root.addAttribute(new Attribute("test", "\r\n"));
 1305   
 1306  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1307  1 serializer.setMaxLength(64);
 1308  1 serializer.write(doc);
 1309  1 out.close();
 1310  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1311  1 Document reparsed = parser.build(in);
 1312  1 String result = reparsed.getRootElement().getAttributeValue("test");
 1313  1 assertEquals("CRLF unnecessarily escaped", " ", result);
 1314   
 1315    }
 1316   
 1317   
 1318  1 public void testCRInTextValueWithLineSeparator()
 1319    throws IOException, ParsingException {
 1320   
 1321  1 root.appendChild("\r");
 1322  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1323  1 serializer.setLineSeparator("\n");
 1324  1 serializer.write(doc);
 1325  1 out.close();
 1326  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1327  1 Document reparsed = parser.build(in);
 1328  1 String result = reparsed.getValue();
 1329  1 assertEquals("\n", result);
 1330   
 1331    }
 1332   
 1333   
 1334  1 public void testCRLFInTextValueWithLineSeparator()
 1335    throws IOException, ParsingException {
 1336   
 1337  1 root.appendChild("test \r\n test");
 1338  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1339  1 serializer.setLineSeparator("\n");
 1340  1 serializer.write(doc);
 1341  1 out.close();
 1342  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1343  1 Document reparsed = parser.build(in);
 1344  1 String result = reparsed.getValue();
 1345  1 assertEquals("test \n test", result);
 1346   
 1347    }
 1348   
 1349   
 1350  1 public void testCRInTextWithIndenting()
 1351    throws IOException, ParsingException {
 1352   
 1353  1 root.appendChild("\r");
 1354  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1355  1 serializer.setIndent(2);
 1356  1 serializer.write(doc);
 1357  1 out.close();
 1358  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1359  1 Document reparsed = parser.build(in);
 1360  1 String result = reparsed.getValue();
 1361  1 assertEquals("Carriage return unnecessarily escaped",
 1362    -1, result.indexOf('\r'));
 1363   
 1364    // really need to think about what the serializer should output here
 1365    // and write a test case for that; this is not ideal output
 1366   
 1367    }
 1368   
 1369   
 1370  1 public void testCRInTextWithMaxLength()
 1371    throws IOException, ParsingException {
 1372   
 1373  1 root.appendChild("\r");
 1374  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1375  1 serializer.setMaxLength(64);
 1376  1 serializer.write(doc);
 1377  1 out.close();
 1378  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1379  1 Document reparsed = parser.build(in);
 1380  1 String result = reparsed.getValue();
 1381  1 assertEquals("Carriage return unnecessarily escaped", "\n", result);
 1382   
 1383    }
 1384   
 1385   
 1386  1 public void testTabInAttributeValueWithMaxLength()
 1387    throws IOException, ParsingException {
 1388   
 1389  1 root.addAttribute(new Attribute("test", "\t"));
 1390  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1391  1 serializer.setMaxLength(64);
 1392  1 serializer.write(doc);
 1393  1 out.close();
 1394  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1395  1 Document reparsed = parser.build(in);
 1396  1 String result = reparsed.getRootElement().getAttributeValue("test");
 1397  1 assertEquals("Tab not normalized to space", " ", result);
 1398   
 1399    }
 1400   
 1401   
 1402    /**
 1403    * <p>
 1404    * Test that tabs in attribute values are escaped when
 1405    * max length is set to 0
 1406    * </p>
 1407    */
 1408  1 public void testTabInAttributeValueWithZeroMaxLength()
 1409    throws IOException, ParsingException {
 1410   
 1411  1 root.addAttribute(new Attribute("test", "\t"));
 1412  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 1413  1 serializer.setMaxLength(0);
 1414  1 serializer.write(doc);
 1415  1 out.close();
 1416  1 InputStream in = new ByteArrayInputStream(out.toByteArray());
 1417  1 Document reparsed = parser.build(in);
 1418  1 String result = reparsed.getRootElement().getAttributeValue("test");
 1419  1 assertEquals("Tab not normalized to space", "\t", result);
 1420   
 1421    }
 1422   
 1423   
 1424  1 public void testSetMaxLength() {
 1425  1 Serializer serializer = new Serializer(System.out);
 1426   
 1427  1 serializer.setMaxLength(72);
 1428  1 assertEquals(72, serializer.getMaxLength());
 1429  1 serializer.setMaxLength(720);
 1430  1 assertEquals(720, serializer.getMaxLength());
 1431  1 serializer.setMaxLength(1);
 1432  1 assertEquals(1, serializer.getMaxLength());
 1433  1 serializer.setMaxLength(0);
 1434  1 assertEquals(0, serializer.getMaxLength());
 1435  1 serializer.setMaxLength(-1);
 1436  1 assertEquals(0, serializer.getMaxLength());
 1437   
 1438    }
 1439   
 1440   
 1441  1 public void testSetIndent() {
 1442   
 1443  1 Serializer serializer = new Serializer(System.out);
 1444  1 serializer.setIndent(72);
 1445  1 assertEquals(72, serializer.getIndent());
 1446  1 serializer.setIndent(720);
 1447  1 assertEquals(720, serializer.getIndent());
 1448  1 serializer.setIndent(1);
 1449  1 assertEquals(1, serializer.getIndent());
 1450  1 serializer.setIndent(0);
 1451  1 assertEquals(0, serializer.getIndent());
 1452  1 try {
 1453  1 serializer.setIndent(-1);
 1454  0 fail("Allowed negative indent");
 1455    }
 1456    catch (IllegalArgumentException success) {
 1457  1 assertNotNull(success.getMessage());
 1458    }
 1459   
 1460    }
 1461   
 1462   
 1463  1 public void testReallyBigIndent() throws ValidityException, ParsingException, IOException {
 1464   
 1465  1 ByteArrayOutputStream out = new ByteArrayOutputStream();
 1466  1 Serializer serializer = new Serializer(out);
 1467  1 serializer.setIndent(100);
 1468  1 StringBuffer spaces = new StringBuffer(400);
 1469  400 for (int i = 0; i < 400; i++) spaces.append(' ');
 1470  1 String _400 = spaces.toString();
 1471  1 String _300 = spaces.substring(0, 300);
 1472  1 String _200 = spaces.substring(0, 200);
 1473  1 String _100 = spaces.substring(0, 100);
 1474   
 1475  1 String original ="<a><b><c><d><e>Hello</e></d></c></b></a>";
 1476  1 Document doc = parser.build(original, null);
 1477  1 serializer.write(doc);
 1478  1 String expected ="<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<a>\r\n"
 1479    + _100 + "<b>\r\n" + _200 + "<c>\r\n" + _300 + "<d>\r\n" + _400
 1480    + "<e>Hello</e>\r\n" + _300 + "</d>\r\n" + _200 + "</c>\r\n"
 1481    + _100 + "</b>\r\n</a>\r\n";
 1482  1 String result = new String(out.toByteArray(), "UTF-8");
 1483  1 assertEquals(expected, result);
 1484   
 1485    }
 1486   
 1487   
 1488  1 public void testLineLength() throws IOException {
 1489   
 1490  1 int length = 40;
 1491  1 String data = "This is a really long string that does not "
 1492    + "contain any line breaks. However, there is lots of "
 1493    + "white space so there shouldn't be any trouble wrapping it"
 1494    + " into 40 characters or less per line. ";
 1495  1 root.appendChild(data);
 1496  1 Serializer serializer = new Serializer(out, "UTF-8");
 1497  1 serializer.setMaxLength(length);
 1498  1 serializer.write(doc);
 1499  1 String result = out.toString("UTF-8");
 1500   
 1501  1 BufferedReader reader
 1502    = new BufferedReader(new StringReader(result));
 1503  1 for (String line = reader.readLine();
 1504  9 line != null;
 1505    line = reader.readLine()) {
 1506  8 assertTrue(line.length() + ": " + line,
 1507    line.length() <= length);
 1508    }
 1509   
 1510    }
 1511   
 1512   
 1513  1 public void testLineLengthWithSetOutputStream()
 1514    throws IOException {
 1515   
 1516  1 int length = 40;
 1517  1 String data = "This is a really long string that does not "
 1518    + "contain any line breaks. However, there is lots of "
 1519    + "white space so there shouldn't be any trouble wrapping it"
 1520    + " into 40 characters or less per line. ";
 1521  1 root.appendChild(data);
 1522  1 Serializer serializer = new Serializer(new ByteArrayOutputStream(), "UTF-8");
 1523  1 serializer.setMaxLength(length);
 1524  1 serializer.write(doc);
 1525  1 serializer.setOutputStream(out);
 1526  1 serializer.write(doc);
 1527  1 String result = out.toString("UTF-8");
 1528   
 1529  1 BufferedReader reader
 1530    = new BufferedReader(new StringReader(result));
 1531  1 for (String line = reader.readLine();
 1532  9 line != null;
 1533    line = reader.readLine()) {
 1534  8 assertTrue(line.length() + ": " + line,
 1535    line.length() <= length);
 1536    }
 1537   
 1538    }
 1539   
 1540   
 1541  1 public void testPrettyXML() throws IOException {
 1542   
 1543  1 Element items = new Element("itemSet");
 1544  1 items.appendChild(new Element("item1"));
 1545  1 items.appendChild(new Element("item2"));
 1546  1 Document doc = new Document(items);
 1547  1 Serializer serializer = new Serializer(out);
 1548  1 serializer.setIndent(4);
 1549  1 serializer.write(doc);
 1550  1 serializer.flush();
 1551  1 out.close();
 1552  1 String result = new String(out.toByteArray(), "UTF-8");
 1553  1 assertEquals(
 1554    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1555    + "<itemSet>\r\n <item1/>\r\n <item2/>\r\n"
 1556    + "</itemSet>\r\n",
 1557    result
 1558    );
 1559   
 1560    }
 1561   
 1562   
 1563  1 public void testIndentingFromSubclassThatAvoidsWriteElement()
 1564    throws IOException {
 1565   
 1566  1 Element items = new Element("itemSet");
 1567  1 items.appendChild(new Element("item1"));
 1568  1 items.appendChild(new Element("item2"));
 1569  1 Document doc = new Document(items);
 1570  1 Serializer serializer = new AvoidWriteElement(out);
 1571  1 serializer.setIndent(4);
 1572  1 serializer.write(doc);
 1573  1 serializer.flush();
 1574  1 out.close();
 1575  1 String result = new String(out.toByteArray(), "UTF-8");
 1576  1 assertEquals(
 1577    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1578    + "<itemSet>\r\n <item1></item1>\r\n <item2></item2>\r\n"
 1579    + "</itemSet>\r\n",
 1580    result
 1581    );
 1582   
 1583    }
 1584   
 1585   
 1586  1 public void testIndentingFromSubclassThatAvoidsWriteElementWithXMLSpace()
 1587    throws IOException {
 1588   
 1589  1 Element items = new Element("itemSet");
 1590  1 items.addAttribute(new Attribute("xml:space", Namespace.XML_NAMESPACE, "preserve"));
 1591  1 items.appendChild(new Element("item1"));
 1592  1 items.appendChild(new Element("item2"));
 1593  1 Document doc = new Document(items);
 1594  1 Serializer serializer = new AvoidWriteElement(out);
 1595  1 serializer.setIndent(4);
 1596  1 serializer.write(doc);
 1597  1 serializer.flush();
 1598  1 out.close();
 1599  1 String result = new String(out.toByteArray(), "UTF-8");
 1600  1 assertEquals(
 1601    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1602    + "<itemSet xml:space=\"preserve\"><item1></item1><item2></item2>"
 1603    + "</itemSet>\r\n",
 1604    result
 1605    );
 1606   
 1607    }
 1608   
 1609   
 1610    private static class AvoidWriteElement extends Serializer {
 1611   
 1612  2 public AvoidWriteElement(OutputStream out) {
 1613  2 super(out);
 1614    }
 1615   
 1616  6 protected void write(Element element) throws IOException {
 1617   
 1618  6 writeStartTag(element);
 1619  6 for (int i = 0; i < element.getChildCount(); i++) {
 1620  4 Node child = element.getChild(i);
 1621  4 writeChild(child);
 1622    }
 1623  6 writeEndTag(element);
 1624   
 1625    }
 1626   
 1627    }
 1628   
 1629   
 1630  1 public void testIndentAndBreakBeforeComment() throws IOException {
 1631   
 1632  1 Element items = new Element("itemSet");
 1633  1 items.appendChild(new Comment("item1"));
 1634  1 Document doc = new Document(items);
 1635  1 Serializer serializer = new Serializer(out);
 1636  1 serializer.setIndent(4);
 1637  1 serializer.write(doc);
 1638  1 serializer.flush();
 1639  1 out.close();
 1640  1 String result = new String(out.toByteArray(), "UTF-8");
 1641  1 assertEquals(
 1642    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1643    + "<itemSet>\r\n <!--item1-->\r\n"
 1644    + "</itemSet>\r\n",
 1645    result
 1646    );
 1647   
 1648    }
 1649   
 1650   
 1651  1 public void testOnlyXMLSpaceCountsAsBoundaryWhiteSpace()
 1652    throws IOException {
 1653   
 1654  1 String emSpace = "\u2003";
 1655  1 Element items = new Element("itemSet");
 1656  1 items.appendChild(emSpace);
 1657  1 items.appendChild(new Element("a"));
 1658   
 1659  1 Document doc = new Document(items);
 1660  1 Serializer serializer = new Serializer(out);
 1661  1 serializer.setIndent(4);
 1662  1 serializer.write(doc);
 1663  1 serializer.flush();
 1664  1 out.close();
 1665  1 String result = new String(out.toByteArray(), "UTF-8");
 1666  1 assertEquals(
 1667    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1668    + "<itemSet>\u2003\r\n <a/>\r\n</itemSet>\r\n",
 1669    result
 1670    );
 1671   
 1672    }
 1673   
 1674   
 1675  1 public void testWhiteSpaceBetweenCommentsIsBoundaryWhiteSpace()
 1676    throws IOException {
 1677   
 1678  1 Element items = new Element("itemSet");
 1679  1 items.appendChild(new Comment("item1"));
 1680  1 items.appendChild(" \r\n ");
 1681  1 items.appendChild(new Comment("item2"));
 1682  1 Document doc = new Document(items);
 1683  1 Serializer serializer = new Serializer(out);
 1684  1 serializer.setIndent(4);
 1685  1 serializer.write(doc);
 1686  1 serializer.flush();
 1687  1 out.close();
 1688  1 String result = new String(out.toByteArray(), "UTF-8");
 1689  1 assertEquals(
 1690    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1691    + "<itemSet>\r\n <!--item1-->\r\n <!--item2-->\r\n"
 1692    + "</itemSet>\r\n",
 1693    result
 1694    );
 1695   
 1696    }
 1697   
 1698   
 1699  1 public void testWhiteSpaceBeforeCommentIsBoundaryWhiteSpace()
 1700    throws IOException {
 1701   
 1702  1 Element items = new Element("itemSet");
 1703  1 items.appendChild(" \r\n ");
 1704  1 items.appendChild(new Comment("item1"));
 1705  1 items.appendChild(new Comment("item2"));
 1706  1 Document doc = new Document(items);
 1707  1 Serializer serializer = new Serializer(out);
 1708  1 serializer.setIndent(4);
 1709  1 serializer.write(doc);
 1710  1 serializer.flush();
 1711  1 out.close();
 1712  1 String result = new String(out.toByteArray(), "UTF-8");
 1713  1 assertEquals(
 1714    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1715    + "<itemSet>\r\n <!--item1-->\r\n <!--item2-->\r\n"
 1716    + "</itemSet>\r\n",
 1717    result
 1718    );
 1719   
 1720    }
 1721   
 1722   
 1723  1 public void testWhiteSpaceAfterCommentsIsBoundaryWhiteSpace()
 1724    throws IOException {
 1725   
 1726  1 Element items = new Element("itemSet");
 1727  1 items.appendChild(new Comment("item1"));
 1728  1 items.appendChild(new Comment("item2"));
 1729  1 items.appendChild(" \r\n ");
 1730  1 Document doc = new Document(items);
 1731  1 Serializer serializer = new Serializer(out);
 1732  1 serializer.setIndent(4);
 1733  1 serializer.write(doc);
 1734  1 serializer.flush();
 1735  1 out.close();
 1736  1 String result = new String(out.toByteArray(), "UTF-8");
 1737  1 assertEquals(
 1738    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1739    + "<itemSet>\r\n <!--item1-->\r\n <!--item2-->\r\n"
 1740    + "</itemSet>\r\n",
 1741    result
 1742    );
 1743   
 1744    }
 1745   
 1746   
 1747  1 public void testIndentAndBreakBeforeProcessingInstruction()
 1748    throws IOException {
 1749   
 1750  1 Element items = new Element("itemSet");
 1751  1 items.appendChild(new ProcessingInstruction("target", "value"));
 1752  1 Document doc = new Document(items);
 1753  1 Serializer serializer = new Serializer(out);
 1754  1 serializer.setIndent(4);
 1755  1 serializer.write(doc);
 1756  1 serializer.flush();
 1757  1 out.close();
 1758  1 String result = new String(out.toByteArray(), "UTF-8");
 1759  1 assertEquals(
 1760    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1761    + "<itemSet>\r\n <?target value?>\r\n"
 1762    + "</itemSet>\r\n",
 1763    result
 1764    );
 1765   
 1766    }
 1767   
 1768   
 1769  1 public void testDontBreakLineInElementWithSimpleContent()
 1770    throws IOException {
 1771   
 1772  1 Element items = new Element("itemSet");
 1773  1 Element item1 = new Element("item1");
 1774  1 items.appendChild(item1);
 1775  1 item1.appendChild("content");
 1776  1 Document doc = new Document(items);
 1777  1 Serializer serializer = new Serializer(out);
 1778  1 serializer.setIndent(4);
 1779  1 serializer.write(doc);
 1780  1 serializer.flush();
 1781  1 out.close();
 1782  1 String result = new String(out.toByteArray(), "UTF-8");
 1783  1 assertEquals(
 1784    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1785    + "<itemSet>\r\n <item1>content</item1>\r\n"
 1786    + "</itemSet>\r\n",
 1787    result
 1788    );
 1789   
 1790    }
 1791   
 1792   
 1793  1 public void testPrettyXMLWithSetOutputStream() throws IOException {
 1794   
 1795  1 Element items = new Element("itemSet");
 1796  1 items.appendChild(new Element("item1"));
 1797  1 items.appendChild(new Element("item2"));
 1798  1 Document doc = new Document(items);
 1799  1 Serializer serializer = new Serializer(new ByteArrayOutputStream());
 1800  1 serializer.setIndent(4);
 1801  1 serializer.setLineSeparator("\n");
 1802  1 serializer.write(doc);
 1803  1 serializer.setOutputStream(out);
 1804  1 serializer.write(doc);
 1805  1 serializer.flush();
 1806  1 out.close();
 1807  1 String result = new String(out.toByteArray(), "UTF-8");
 1808  1 assertEquals(
 1809    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 1810    + "<itemSet>\n <item1/>\n <item2/>\n"
 1811    + "</itemSet>\n",
 1812    result
 1813    );
 1814   
 1815    }
 1816   
 1817   
 1818  1 public void testAmpersandAndLessThanInText() throws IOException {
 1819   
 1820  1 root.appendChild("data<data&data");
 1821  1 Serializer serializer = new Serializer(out);
 1822  1 serializer.write(doc);
 1823  1 serializer.flush();
 1824  1 out.close();
 1825  1 String result = new String(out.toByteArray(), "UTF-8");
 1826  1 assertEquals(
 1827    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1828    + "<root>data&lt;data&amp;data"
 1829    + "</root>\r\n",
 1830    result
 1831    );
 1832   
 1833    }
 1834   
 1835   
 1836  1 public void testAmpersandAndAngleBracketsInAttributeValue()
 1837    throws IOException {
 1838   
 1839  1 root.addAttribute(new Attribute("b", "data<data>data&"));
 1840  1 Serializer serializer = new Serializer(out);
 1841  1 serializer.write(doc);
 1842  1 serializer.flush();
 1843  1 out.close();
 1844  1 String result = new String(out.toByteArray(), "UTF-8");
 1845  1 assertEquals(
 1846    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1847    + "<root b=\"data&lt;data&gt;data&amp;\"/>\r\n",
 1848    result
 1849    );
 1850   
 1851    }
 1852   
 1853   
 1854  1 public void testSetNFC() {
 1855   
 1856  1 Serializer serializer = new Serializer(System.out);
 1857  1 assertFalse(serializer.getUnicodeNormalizationFormC());
 1858  1 serializer.setUnicodeNormalizationFormC(true);
 1859  1 assertTrue(serializer.getUnicodeNormalizationFormC());
 1860   
 1861    }
 1862   
 1863   
 1864  1 public void testNFCInElementContent() throws IOException {
 1865   
 1866  1 Element root = new Element("a");
 1867  1 root.appendChild("c\u0327"); // c with combining cedilla
 1868  1 Document doc = new Document(root);
 1869  1 Serializer serializer = new Serializer(out);
 1870  1 serializer.setUnicodeNormalizationFormC(true);
 1871  1 serializer.write(doc);
 1872  1 serializer.flush();
 1873  1 out.close();
 1874  1 String result = new String(out.toByteArray(), "UTF-8");
 1875  1 assertEquals(
 1876    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1877    + "<a>\u00E7</a>\r\n",
 1878    result
 1879    );
 1880   
 1881    }
 1882   
 1883   
 1884  1 public void testNFCInConsecutiveTextNodes() throws IOException {
 1885   
 1886  1 Element root = new Element("a");
 1887  1 root.appendChild("c");
 1888  1 root.appendChild("\u0327"); // combining cedilla
 1889  1 Document doc = new Document(root);
 1890  1 Serializer serializer = new Serializer(out);
 1891  1 serializer.setUnicodeNormalizationFormC(true);
 1892  1 serializer.write(doc);
 1893  1 serializer.flush();
 1894  1 out.close();
 1895  1 String result = new String(out.toByteArray(), "UTF-8");
 1896  1 assertEquals(
 1897    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1898    + "<a>\u00E7</a>\r\n",
 1899    result
 1900    );
 1901   
 1902    }
 1903   
 1904   
 1905  1 public void testNoNFCByDefault() throws IOException {
 1906   
 1907  1 Element root = new Element("c\u0327");
 1908  1 root.appendChild("c\u0327"); // c with combining cedilla
 1909  1 Document doc = new Document(root);
 1910  1 Serializer serializer = new Serializer(out);
 1911  1 serializer.write(doc);
 1912  1 serializer.flush();
 1913  1 out.close();
 1914  1 String result = new String(out.toByteArray(), "UTF-8");
 1915  1 assertEquals(
 1916    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1917    + "<c\u0327>c\u0327</c\u0327>\r\n",
 1918    result
 1919    );
 1920   
 1921    }
 1922   
 1923   
 1924   
 1925  1 public void testNFCInAttribute() throws IOException {
 1926   
 1927  1 root.addAttribute(new Attribute("c\u0327", "c\u0327")); // c with combining cedilla
 1928  1 Serializer serializer = new Serializer(out);
 1929  1 serializer.setUnicodeNormalizationFormC(true);
 1930  1 serializer.write(doc);
 1931  1 serializer.flush();
 1932  1 out.close();
 1933  1 String result = new String(out.toByteArray(), "UTF-8");
 1934  1 assertEquals(
 1935    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1936    + "<root \u00E7=\"\u00E7\"/>\r\n",
 1937    result
 1938    );
 1939   
 1940    }
 1941   
 1942   
 1943  1 public void testNFCInElementName() throws IOException {
 1944   
 1945  1 Element root = new Element("c\u0327"); // c with combining cedilla
 1946  1 Document doc = new Document(root);
 1947  1 Serializer serializer = new Serializer(out);
 1948  1 serializer.setUnicodeNormalizationFormC(true);
 1949  1 serializer.write(doc);
 1950  1 serializer.flush();
 1951  1 out.close();
 1952  1 String result = new String(out.toByteArray(), "UTF-8");
 1953  1 assertEquals(
 1954    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1955    + "<\u00E7/>\r\n",
 1956    result
 1957    );
 1958   
 1959    }
 1960   
 1961   
 1962  1 public void testNFCInComment() throws IOException {
 1963   
 1964  1 Element root = new Element("a");
 1965  1 Document doc = new Document(root);
 1966  1 doc.insertChild(new Comment("c\u0327hat"), 0); // c with combining cedilla
 1967  1 Serializer serializer = new Serializer(out);
 1968  1 serializer.setUnicodeNormalizationFormC(true);
 1969  1 serializer.write(doc);
 1970  1 serializer.flush();
 1971  1 out.close();
 1972  1 String result = new String(out.toByteArray(), "UTF-8");
 1973  1 assertEquals(
 1974    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1975    + "<!--\u00E7hat-->\r\n"
 1976    + "<a/>\r\n",
 1977    result
 1978    );
 1979   
 1980    }
 1981   
 1982   
 1983  1 public void testNFCInProcessingInstruction() throws IOException {
 1984   
 1985  1 doc.appendChild(new ProcessingInstruction("c\u0327hat", "c\u0327hat"));
 1986  1 Serializer serializer = new Serializer(out);
 1987  1 serializer.setUnicodeNormalizationFormC(true);
 1988  1 serializer.write(doc);
 1989  1 serializer.flush();
 1990  1 out.close();
 1991  1 String result = new String(out.toByteArray(), "UTF-8");
 1992  1 assertEquals(
 1993    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 1994    + "<root/>\r\n"
 1995    + "<?\u00E7hat \u00E7hat?>\r\n",
 1996    result
 1997    );
 1998   
 1999    }
 2000   
 2001   
 2002  1 public void testNFCInElementContentWithNonUnicodeEncoding()
 2003    throws IOException {
 2004   
 2005  1 root.appendChild("c\u0327"); // c with combining cedilla
 2006  1 Serializer serializer = new Serializer(out, "ISO-8859-5");
 2007  1 serializer.setUnicodeNormalizationFormC(true);
 2008  1 serializer.write(doc);
 2009  1 serializer.flush();
 2010  1 out.close();
 2011  1 String result = new String(out.toByteArray(), "ISO-8859-5");
 2012  1 assertEquals(
 2013    "<?xml version=\"1.0\" encoding=\"ISO-8859-5\"?>\r\n"
 2014    + "<root>&#xE7;</root>\r\n",
 2015    result
 2016    );
 2017   
 2018    }
 2019   
 2020   
 2021  1 public void testNFCFollowingEntityReference()
 2022    throws IOException {
 2023   
 2024  1 root.appendChild("<\u0338"); // < followed by not
 2025  1 Serializer serializer = new Serializer(out);
 2026  1 serializer.setUnicodeNormalizationFormC(true);
 2027  1 serializer.write(doc);
 2028  1 serializer.flush();
 2029  1 out.close();
 2030  1 String result = new String(out.toByteArray(), "UTF-8");
 2031  1 assertEquals(
 2032    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 2033    + "<root>\u226E</root>\r\n",
 2034    result
 2035    );
 2036   
 2037    }
 2038   
 2039   
 2040  1 public void testNFCWithSetOutputStream()
 2041    throws IOException {
 2042   
 2043  1 root.appendChild("c\u0327"); // c with combining cedilla
 2044  1 Serializer serializer = new Serializer(new ByteArrayOutputStream(), "ISO-8859-5");
 2045  1 serializer.setUnicodeNormalizationFormC(true);
 2046  1 serializer.write(doc);
 2047  1 serializer.setOutputStream(out);
 2048  1 serializer.write(doc);
 2049  1 serializer.flush();
 2050  1 out.close();
 2051  1 String result = new String(out.toByteArray(), "ISO-8859-5");
 2052  1 assertEquals(
 2053    "<?xml version=\"1.0\" encoding=\"ISO-8859-5\"?>\r\n"
 2054    + "<root>&#xE7;</root>\r\n",
 2055    result
 2056    );
 2057   
 2058    }
 2059   
 2060   
 2061  1 public void testNFCWithKoreanCharacter()
 2062    throws IOException {
 2063   
 2064  1 root.appendChild("\u1111\u1171\u11B6"); // see p. 88 of Unicode 4.0 book
 2065  1 Serializer serializer = new Serializer(new ByteArrayOutputStream());
 2066  1 serializer.setUnicodeNormalizationFormC(true);
 2067  1 serializer.write(doc);
 2068  1 serializer.setOutputStream(out);
 2069  1 serializer.write(doc);
 2070  1 serializer.flush();
 2071  1 out.close();
 2072  1 String result = new String(out.toByteArray(), "UTF-8");
 2073  1 assertEquals(
 2074    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 2075    + "<root>\uD4DB</root>\r\n",
 2076    result
 2077    );
 2078   
 2079    }
 2080   
 2081   
 2082  1 public void testNullOutputStream() {
 2083   
 2084  1 try {
 2085  1 new Serializer(null);
 2086  0 fail("Allowed null output stream");
 2087    }
 2088    catch (NullPointerException success) {
 2089  1 assertNotNull(success.getMessage());
 2090    }
 2091   
 2092    }
 2093   
 2094   
 2095  1 public void testNullOutputStreamWithEncoding()
 2096    throws UnsupportedEncodingException {
 2097   
 2098  1 try {
 2099  1 new Serializer(null, "UTF-8");
 2100  0 fail("Allowed null output stream");
 2101    }
 2102    catch (NullPointerException success) {
 2103  1 assertNotNull(success.getMessage());
 2104    }
 2105   
 2106    }
 2107   
 2108   
 2109  1 public void testNullEncoding()
 2110    throws UnsupportedEncodingException {
 2111   
 2112  1 try {
 2113  1 new Serializer(System.out, null);
 2114  0 fail("Allowed null encoding");
 2115    }
 2116    catch (NullPointerException success) {
 2117  1 assertNotNull(success.getMessage());
 2118    }
 2119   
 2120    }
 2121   
 2122   
 2123    // make sure null pointer exception doesn't cause any output
 2124  1 public void testNullDocument() throws IOException {
 2125   
 2126  1 Serializer serializer = new Serializer(out, "UTF-16");
 2127  1 try {
 2128  1 serializer.write(null);
 2129  0 fail("Wrote null document");
 2130    }
 2131    catch (NullPointerException success) {
 2132    // success
 2133    }
 2134  1 byte[] result = out.toByteArray();
 2135  1 assertEquals(0, result.length);
 2136   
 2137    }
 2138   
 2139   
 2140  1 public void testGetEncoding()
 2141    throws UnsupportedEncodingException {
 2142   
 2143  1 Serializer serializer = new Serializer(System.out, "ISO-8859-1");
 2144  1 assertEquals("ISO-8859-1", serializer.getEncoding());
 2145   
 2146    }
 2147   
 2148   
 2149  1 public void testGetPreserveBaseURI()
 2150    throws UnsupportedEncodingException {
 2151   
 2152  1 Serializer serializer = new Serializer(System.out, "ISO-8859-1");
 2153  1 assertFalse(serializer.getPreserveBaseURI());
 2154  1 serializer.setPreserveBaseURI(true);
 2155  1 assertTrue(serializer.getPreserveBaseURI());
 2156  1 serializer.setPreserveBaseURI(false);
 2157  1 assertFalse(serializer.getPreserveBaseURI());
 2158   
 2159    }
 2160   
 2161   
 2162  1 public void testSerializeDocTypeWithSystemID()
 2163    throws IOException {
 2164   
 2165  1 Serializer serializer = new Serializer(out);
 2166  1 Document doc = new Document(new Element("a"));
 2167  1 doc.setDocType(new DocType("b", "example.dtd"));
 2168  1 serializer.write(doc);
 2169  1 String result = out.toString("UTF-8");
 2170  1 assertTrue(result.endsWith("<a/>\r\n"));
 2171  1 assertTrue(result.indexOf("<!DOCTYPE b SYSTEM \"example.dtd\">") > 0);
 2172   
 2173    }
 2174   
 2175   
 2176  1 public void testSerializeDocTypeWithPublicAndSystemID()
 2177    throws IOException {
 2178   
 2179  1 Serializer serializer = new Serializer(out);
 2180  1 Document doc = new Document(new Element("a"));
 2181  1 doc.setDocType(new DocType("b",
 2182    "-//W3C//DTD XHTML 1.0 Transitional//EN", "example.dtd"));
 2183  1 serializer.write(doc);
 2184  1 String result = out.toString("UTF-8");
 2185  1 assertTrue(result.endsWith("<a/>\r\n"));
 2186  1 assertTrue(result.indexOf(
 2187    "<!DOCTYPE b PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"example.dtd\">") > 0);
 2188   
 2189    }
 2190   
 2191   
 2192  1 public void testSerializeXMLNamespaceDeclaration()
 2193    throws ParsingException, IOException {
 2194   
 2195  1 Serializer serializer = new Serializer(out);
 2196  1 Element root = new Element("root");
 2197  1 root.addNamespaceDeclaration("xml", Namespace.XML_NAMESPACE);
 2198  1 Document doc = new Document(root);
 2199  1 serializer.write(doc);
 2200  1 String result = out.toString("UTF-8");
 2201  1 assertTrue(result.endsWith("<root/>\r\n"));
 2202   
 2203    }
 2204   
 2205   
 2206  1 public void testSerializeDocTypeWithInternalDTDSubset()
 2207    throws ParsingException, IOException {
 2208   
 2209  1 Serializer serializer = new Serializer(out);
 2210  1 String data = "<!DOCTYPE root [ <!ELEMENT root EMPTY> ]><test/>";
 2211  1 Builder builder = new Builder();
 2212  1 Document doc = builder.build(data, "http://www.example.com");
 2213  1 serializer.write(doc);
 2214  1 String result = out.toString("UTF-8");
 2215  1 assertTrue(result.endsWith("<test/>\r\n"));
 2216  1 assertTrue(result.indexOf("<!DOCTYPE root [\r\n") > 0);
 2217  1 assertTrue(result.indexOf("\r\n]>\r\n") > 0);
 2218  1 assertTrue(result.indexOf("<!ELEMENT root EMPTY>\r\n") > 0);
 2219   
 2220    }
 2221   
 2222   
 2223  1 public void testSerializeInternalDTDSubsetContainingUnavailableCharacter()
 2224    throws ParsingException, IOException {
 2225   
 2226  1 Serializer serializer = new Serializer(out, "US-ASCII");
 2227  1 String data = "<!DOCTYPE root ["
 2228    + "<!ELEMENT root EMPTY> "
 2229    + "<!ATTLIST root attr CDATA 'café creme'> "
 2230    + "]><test/>";
 2231  1 Builder builder = new Builder();
 2232  1 Document doc = builder.build(data, "http://www.example.com");
 2233  1 try {
 2234  1 serializer.write(doc);
 2235  0 fail("How'd you serialize é in ASCII?");
 2236    }
 2237    catch (UnavailableCharacterException success) {
 2238  1 assertTrue(success.getMessage().indexOf("é (&#xE9;)") > 1);
 2239    }
 2240   
 2241    }
 2242   
 2243   
 2244  1 public void testLineBreaksInInternalDTDSubset()
 2245    throws ParsingException, IOException {
 2246   
 2247  1 Serializer serializer = new Serializer(out);
 2248  1 serializer.setLineSeparator("\r");
 2249  1 String data = "<!DOCTYPE root [ <!ELEMENT root EMPTY> <!ELEMENT data EMPTY> ]><test/>";
 2250  1 Builder builder = new Builder();
 2251  1 Document doc = builder.build(data, "http://www.example.com");
 2252  1 serializer.write(doc);
 2253  1 String result = out.toString("UTF-8");
 2254  1 assertTrue(result.endsWith("<test/>\r"));
 2255  1 assertTrue(result.indexOf("<!DOCTYPE root [\r") > 0);
 2256  1 assertTrue(result.indexOf("\r]>\r") > 0);
 2257  1 assertTrue(result.indexOf("<!ELEMENT root EMPTY>\r") > 0);
 2258  1 assertTrue(result.indexOf("<!ELEMENT data EMPTY>\r") > 0);
 2259  1 assertEquals(-1, result.indexOf("<!ELEMENT data EMPTY>\r\n"));
 2260  1 assertEquals(-1, result.indexOf("<!ELEMENT root EMPTY>\r\n"));
 2261  1 assertEquals(-1, result.indexOf("<!ELEMENT data EMPTY>\r\r"));
 2262  1 assertEquals(-1, result.indexOf("<!ELEMENT root EMPTY>\r\r"));
 2263  1 assertEquals(-1, result.indexOf('\n'));
 2264   
 2265    }
 2266   
 2267   
 2268  1 public void testSerializeQuoteInAttributeValue()
 2269    throws IOException {
 2270   
 2271  1 Serializer serializer = new Serializer(out);
 2272  1 root.addAttribute(new Attribute("name", "\""));
 2273  1 serializer.write(doc);
 2274  1 String result = out.toString("UTF-8");
 2275  1 assertTrue(result.endsWith("<root name=\"&quot;\"/>\r\n"));
 2276   
 2277    }
 2278   
 2279   
 2280  1 public void testSerializeUnavailableCharacterInMarkup()
 2281    throws IOException {
 2282   
 2283  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 2284  1 Element root = new Element("\u0419");
 2285  1 Document doc = new Document(root);
 2286  1 try {
 2287  1 serializer.write(doc);
 2288  0 fail("Wrote bad character: " + out.toString("ISO-8859-1"));
 2289    }
 2290    catch (UnavailableCharacterException success) {
 2291  1 assertNotNull(success.getMessage());
 2292  1 assertEquals('\u0419', success.getCharacter());
 2293  1 assertEquals("ISO-8859-1", success.getEncoding());
 2294    }
 2295   
 2296    }
 2297   
 2298   
 2299  1 public void testTurnLineFeedInAttributeValueIntoSpaceWhenIndenting()
 2300    throws IOException {
 2301   
 2302  1 Element root = new Element("a");
 2303  1 root.appendChild("c");
 2304  1 root.addAttribute(new Attribute("name", "value1\nvalue2"));
 2305  1 Document doc = new Document(root);
 2306  1 Serializer serializer = new Serializer(out);
 2307  1 serializer.setMaxLength(245);
 2308  1 serializer.setIndent(4);
 2309  1 serializer.write(doc);
 2310  1 serializer.flush();
 2311  1 out.close();
 2312  1 String result = new String(out.toByteArray(), "UTF-8");
 2313  1 assertEquals(
 2314    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
 2315    + "<a name=\"value1 value2\">c</a>\r\n",
 2316    result
 2317    );
 2318   
 2319    }
 2320   
 2321   
 2322  1 public void testConflictBetweenMaxLengthAndIndent()
 2323    throws IOException {
 2324   
 2325  1 Element root = new Element("a");
 2326  1 Element b = new Element("b");
 2327  1 Element c = new Element("c");
 2328  1 Element d = new Element("d");
 2329  1 b.appendChild(c);
 2330  1 root.appendChild(b);
 2331  1 c.appendChild(d);
 2332  1 d.appendChild("data");
 2333  1 Document doc = new Document(root);
 2334  1 Serializer serializer = new Serializer(out);
 2335  1 serializer.setMaxLength(16);
 2336  1 serializer.setIndent(4);
 2337  1 serializer.write(doc);
 2338  1 serializer.flush();
 2339  1 out.close();
 2340  1 String result = new String(out.toByteArray(), "UTF-8");
 2341  1 assertEquals(
 2342    "<?xml version=\"1.0\"\r\nencoding=\"UTF-8\"?>\r\n"
 2343    + "<a>\r\n <b>\r\n <c>\r\n <d>data</d>\r\n </c>\r\n </b>\r\n</a>\r\n",
 2344    result
 2345    );
 2346   
 2347    }
 2348   
 2349   
 2350  1 public void testWriteChild() throws IOException {
 2351   
 2352  1 ExposingSerializer serializer = new ExposingSerializer(out, "UTF-8");
 2353  1 try {
 2354  1 serializer.writeChild(doc);
 2355  0 fail("writeChild wrote a document");
 2356    }
 2357    catch (XMLException success) {
 2358  1 assertNotNull(success.getMessage());
 2359    }
 2360  1 try {
 2361  1 serializer.writeChild(new Attribute("name", "value"));
 2362  0 fail("writeChild wrote an attribute");
 2363    }
 2364    catch (XMLException success) {
 2365  1 assertNotNull(success.getMessage());
 2366    }
 2367   
 2368    }
 2369   
 2370   
 2371    // just so we can test protected methods
 2372    private static class ExposingSerializer extends Serializer {
 2373   
 2374  4 ExposingSerializer(OutputStream out, String encoding)
 2375    throws UnsupportedEncodingException {
 2376  4 super(out, encoding);
 2377    }
 2378   
 2379  2 public void writeChild(Node node) throws IOException {
 2380  2 super.writeChild(node);
 2381    }
 2382   
 2383  1 public void exposedWriteRaw(String text) throws IOException {
 2384  1 writeRaw(text);
 2385    }
 2386   
 2387  1 public void exposedWriteEscaped(String text) throws IOException {
 2388  1 writeEscaped(text);
 2389    }
 2390   
 2391  1 public void exposedWriteAttributeValue(String text) throws IOException {
 2392  1 writeAttributeValue(text);
 2393    }
 2394   
 2395  3 public int exposeGetColumnNumber() {
 2396  3 return super.getColumnNumber();
 2397    }
 2398   
 2399    }
 2400   
 2401   
 2402    private static class ElementSerializer extends Serializer {
 2403   
 2404  2 ElementSerializer(OutputStream out, String encoding)
 2405    throws UnsupportedEncodingException {
 2406  2 super(out, encoding);
 2407    }
 2408   
 2409  2 protected void write(Element element) throws IOException {
 2410  2 super.write(element);
 2411    }
 2412   
 2413    }
 2414   
 2415   
 2416    private static class TextSerializer extends Serializer {
 2417   
 2418  3 TextSerializer(OutputStream out) {
 2419  3 super(out);
 2420    }
 2421   
 2422  3 protected void write(Text text) throws IOException {
 2423  3 super.write(text);
 2424    }
 2425   
 2426    }
 2427   
 2428   
 2429  1 public void testWriteParentlessTextNode() throws IOException {
 2430   
 2431  1 Text t = new Text("Hello");
 2432  1 ByteArrayOutputStream out = new ByteArrayOutputStream();
 2433  1 TextSerializer serializer = new TextSerializer(out);
 2434  1 serializer.write(t);
 2435  1 serializer.flush();
 2436  1 byte[] result = out.toByteArray();
 2437  1 String s = new String(result, "UTF-8");
 2438  1 assertEquals(s, t.getValue());
 2439   
 2440    }
 2441   
 2442   
 2443  1 public void testWriteParentlessTextNodeWhileIndenting() throws IOException {
 2444   
 2445  1 Text t = new Text("Hello");
 2446  1 ByteArrayOutputStream out = new ByteArrayOutputStream();
 2447  1 TextSerializer serializer = new TextSerializer(out);
 2448  1 serializer.setIndent(2);
 2449  1 serializer.write(t);
 2450  1 serializer.flush();
 2451  1 byte[] result = out.toByteArray();
 2452  1 String s = new String(result, "UTF-8");
 2453  1 assertEquals(s, t.getValue());
 2454   
 2455    }
 2456   
 2457   
 2458  1 public void testWriteWhiteSpaceOnlyTextNodeWhileIndenting() throws IOException {
 2459   
 2460  1 Text t = new Text(" \r\n ");
 2461  1 ByteArrayOutputStream out = new ByteArrayOutputStream();
 2462  1 TextSerializer serializer = new TextSerializer(out);
 2463  1 serializer.setIndent(2);
 2464  1 serializer.write(t);
 2465  1 serializer.flush();
 2466  1 byte[] result = out.toByteArray();
 2467  1 assertEquals(0, result.length);
 2468   
 2469    }
 2470   
 2471   
 2472  1 public void testWriteRaw() throws IOException {
 2473   
 2474  1 ExposingSerializer serializer = new ExposingSerializer(out, "UTF-8");
 2475  1 serializer.exposedWriteRaw("<>&\"'");
 2476  1 assertEquals(5, serializer.exposeGetColumnNumber());
 2477  1 serializer.flush();
 2478  1 String result = out.toString("UTF-8");
 2479  1 assertEquals("<>&\"'", result);
 2480   
 2481    }
 2482   
 2483   
 2484  1 public void testWriteParentlessElementInANamespace() throws IOException {
 2485   
 2486  1 ElementSerializer serializer = new ElementSerializer(out, "UTF-8");
 2487  1 Element element = new Element("a", "http://www.example.org");
 2488  1 serializer.write(element);
 2489  1 serializer.flush();
 2490  1 String result = out.toString("UTF-8");
 2491  1 assertEquals("<a xmlns=\"http://www.example.org\"/>", result);
 2492   
 2493    }
 2494   
 2495   
 2496  1 public void testWriteParentedElementInANamespace() throws IOException {
 2497   
 2498  1 ElementSerializer serializer = new ElementSerializer(out, "UTF-8");
 2499  1 Element a = new Element("a", "http://www.example.org");
 2500  1 Element b = new Element("b", "http://www.example.org");
 2501  1 b.appendChild(a);
 2502  1 serializer.write(a);
 2503  1 serializer.flush();
 2504  1 String result = out.toString("UTF-8");
 2505  1 assertEquals("<a xmlns=\"http://www.example.org\"/>", result);
 2506   
 2507    }
 2508   
 2509   
 2510  1 public void testWriteEscaped() throws IOException {
 2511   
 2512  1 ExposingSerializer serializer = new ExposingSerializer(out, "UTF-8");
 2513  1 serializer.exposedWriteEscaped("<>&\"'");
 2514  1 assertEquals(15, serializer.exposeGetColumnNumber());
 2515  1 serializer.flush();
 2516  1 byte[] data = out.toByteArray();
 2517  1 String result = new String(data, "UTF-8");
 2518  1 assertEquals("&lt;&gt;&amp;\"'", result);
 2519   
 2520    }
 2521   
 2522   
 2523  1 public void testWriteAttributeValue() throws IOException {
 2524   
 2525  1 ExposingSerializer serializer = new ExposingSerializer(out, "UTF-8");
 2526  1 serializer.exposedWriteAttributeValue("<>&\"'");
 2527  1 assertEquals(20, serializer.exposeGetColumnNumber());
 2528  1 serializer.flush();
 2529  1 String result = out.toString("UTF-8");
 2530  1 assertEquals("&lt;&gt;&amp;&quot;'", result);
 2531   
 2532    }
 2533   
 2534   
 2535    // This test case reproduces a bug that
 2536    // showed up while working on SAX conformance testing.
 2537  1 public void testElementsThatOnlyContainsAnEmptyTextNodeShouldBeOutputWithAnEmptyElementTag()
 2538    throws IOException {
 2539   
 2540  1 Element child = new Element("b");
 2541  1 child.appendChild("");
 2542  1 root.appendChild(child);
 2543   
 2544  1 Serializer serializer = new Serializer(out);
 2545  1 serializer.write(doc);
 2546   
 2547  1 serializer.flush();
 2548  1 String result = out.toString("UTF-8");
 2549  1 assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n" +
 2550    "<root><b/></root>\r\n", result);
 2551   
 2552    }
 2553   
 2554   
 2555    // This test case reproduces a bug that
 2556    // showed up while working on SAX conformance testing.
 2557  1 public void testElementsThatOnlyContainEmptyTextNodesShouldBeOutputWithAnEmptyElementTag()
 2558    throws IOException {
 2559   
 2560  1 Element root = new Element("a");
 2561  1 Element child = new Element("b");
 2562  1 child.appendChild("");
 2563  1 child.appendChild("");
 2564  1 child.appendChild("");
 2565  1 root.appendChild(child);
 2566   
 2567  1 Document doc = new Document(root);
 2568   
 2569  1 Serializer serializer = new Serializer(out);
 2570  1 serializer.write(doc);
 2571   
 2572  1 serializer.flush();
 2573  1 String result = out.toString("UTF-8");
 2574  1 assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n" +
 2575    "<a><b/></a>\r\n", result);
 2576   
 2577    }
 2578   
 2579   
 2580    // This test case reproduces a bug that
 2581    // showed up while working on SAX conformance testing.
 2582  1 public void testElementsThatOnlyContainASingleSpaceShouldNotBeSplitWhileIndenting()
 2583    throws IOException {
 2584   
 2585  1 Element root = new Element("a");
 2586  1 Element child = new Element("b");
 2587  1 child.appendChild(" ");
 2588  1 root.appendChild(child);
 2589   
 2590  1 Document doc = new Document(root);
 2591   
 2592  1 Serializer serializer = new Serializer(out);
 2593  1 serializer.setIndent(4);
 2594  1 serializer.write(doc);
 2595   
 2596  1 serializer.flush();
 2597  1 String result = out.toString("UTF-8");
 2598  1 assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n" +
 2599    "<a>\r\n <b> </b>\r\n</a>\r\n", result);
 2600   
 2601    }
 2602   
 2603   
 2604  1 public void testElementsThatOnlyContainTextNodesWithBoundaryWhiteSpaceShouldNotBeSplitWhileIndenting()
 2605    throws IOException {
 2606   
 2607  1 Element root = new Element("a");
 2608  1 Element child = new Element("b");
 2609  1 child.appendChild(" ");
 2610  1 child.appendChild(" ");
 2611  1 root.appendChild(child);
 2612   
 2613  1 Document doc = new Document(root);
 2614   
 2615  1 Serializer serializer = new Serializer(out);
 2616  1 serializer.setIndent(4);
 2617  1 serializer.write(doc);
 2618   
 2619  1 serializer.flush();
 2620  1 String result = out.toString("UTF-8");
 2621  1 assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n" +
 2622    "<a>\r\n <b> </b>\r\n</a>\r\n", result);
 2623   
 2624    }
 2625   
 2626   
 2627  1 public void testElementsThatOnlyContainASingleLinefeedShouldNotBeSplitWhileIndenting()
 2628    throws IOException {
 2629   
 2630  1 Element root = new Element("a");
 2631  1 Element child = new Element("b");
 2632  1 child.appendChild("\n");
 2633  1 root.appendChild(child);
 2634   
 2635  1 Document doc = new Document(root);
 2636   
 2637  1 Serializer serializer = new Serializer(out);
 2638  1 serializer.setIndent(4);
 2639  1 serializer.write(doc);
 2640   
 2641  1 serializer.flush();
 2642  1 String result = out.toString("UTF-8");
 2643  1 assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n" +
 2644    "<a>\r\n <b> </b>\r\n</a>\r\n", result);
 2645   
 2646    }
 2647   
 2648   
 2649  1 public void testEndTagsOfElementsWithContentGoOnSeparateLine()
 2650    throws ParsingException, IOException {
 2651   
 2652  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 2653  1 serializer.setIndent(4);
 2654  1 serializer.setPreserveBaseURI(true);
 2655  1 serializer.flush();
 2656   
 2657  1 File f = new File("data");
 2658  1 f = new File(f, "prettyxml.xml");
 2659  1 Builder builder = new Builder();
 2660  1 Document doc = builder.build(f);
 2661  1 serializer.write(doc);
 2662  1 String result = out.toString("UTF-8");
 2663  1 assertTrue(result.endsWith("\r\n</html>\r\n"));
 2664   
 2665    }
 2666   
 2667   
 2668  1 public void testDontDoubleBreak()
 2669    throws ParsingException, IOException {
 2670   
 2671  1 Serializer serializer = new Serializer(out, "ISO-8859-1");
 2672  1 serializer.setIndent(4);
 2673  1 serializer.setMaxLength(64);
 2674   
 2675  1 File f = new File("data");
 2676  1 f = new File(f, "prettytest.xml");
 2677  1 Builder builder = new Builder();
 2678  1 Document doc = builder.build(f);
 2679  1 serializer.write(doc);
 2680  1 String result = out.toString("UTF-8");
 2681  1 assertEquals("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\r\n" +
 2682    "<html a=\"AReallyLongNameWithNoOpportunitiesToBreakToPutUsPastTheMaxLineLengthAndForceABreak\">\r\n" +
 2683    " <head> </head>\r\n" +
 2684    "</html>\r\n", result);
 2685   
 2686    }
 2687   
 2688   
 2689  1 public void testUnicodeNFCTestSuite()
 2690    throws ParsingException, IOException {
 2691   
 2692  1 Builder builder = new Builder();
 2693  1 Document doc = builder.build("data/nfctests.xml");
 2694  1 Elements tests = doc.getRootElement().getChildElements("test");
 2695  1 int size = tests.size();
 2696  1 for (int i = 0; i < size; i++) {
 2697    // System.out.println(i);
 2698  17123 Element test = tests.get(i);
 2699  17123 test.detach();
 2700  17123 Document testdoc = new Document(test);
 2701  17123 ByteArrayOutputStream out = new ByteArrayOutputStream();
 2702  17123 Serializer serializer = new Serializer(out);
 2703  17123 serializer.setUnicodeNormalizationFormC(true);
 2704  17123 serializer.write(testdoc);
 2705  17123 serializer.flush();
 2706  17123 String result = new String(out.toByteArray(), "UTF-8");
 2707  17123 Document resultDoc = builder.build(result, null);
 2708  17123 Element root = resultDoc.getRootElement();
 2709  17123 String c1 = root.getAttributeValue("c1");
 2710  17123 String c2 = root.getAttributeValue("c2");
 2711  17123 String c3 = root.getAttributeValue("c3");
 2712  17123 String c4 = root.getAttributeValue("c4");
 2713  17123 String c5 = root.getAttributeValue("c5");
 2714    /* String v1 = root.getAttributeValue("v1");
 2715    String v2 = root.getAttributeValue("v2");
 2716    String v3 = root.getAttributeValue("v3");
 2717    String v4 = root.getAttributeValue("v4");
 2718    String v5 = root.getAttributeValue("v5"); */
 2719   
 2720  17123 assertEquals(root.getValue(), c1, c2);
 2721  17123 assertEquals(c2, c3);
 2722    // I'm not sure the v's are correct past the BMP
 2723    //assertEquals(root.getValue(), c1, v1);
 2724    // assertEquals(c1, v2);
 2725    // assertEquals(c1, v3);
 2726   
 2727  17123 assertEquals(c4, c5);
 2728    // assertEquals(c4, v4);
 2729    // assertEquals(c4, v5);
 2730   
 2731    }
 2732   
 2733    }
 2734   
 2735    }