1  /**
   2   * section: xmlWriter
   3   * synopsis: use various APIs for the xmlWriter
   4   * purpose: tests a number of APIs for the xmlWriter, especially
   5   *          the various methods to write to a filename, to a memory
   6   *          buffer, to a new document, or to a subtree. It shows how to
   7   *          do encoding string conversions too. The resulting
   8   *          documents are then serialized.
   9   * usage: testWriter
  10   * test: testWriter && for i in 1 2 3 4 ; do diff $(srcdir)/writer.xml writer$$i.tmp || break ; done
  11   * author: Alfred Mickautsch
  12   * copy: see Copyright for the status of this software.
  13   */
  14  #include <stdio.h>
  15  #include <string.h>
  16  #include <libxml/encoding.h>
  17  #include <libxml/xmlwriter.h>
  18  
  19  #if defined(LIBXML_WRITER_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
  20  
  21  #define MY_ENCODING "ISO-8859-1"
  22  
  23  void testXmlwriterFilename(const char *uri);
  24  void testXmlwriterMemory(const char *file);
  25  void testXmlwriterDoc(const char *file);
  26  void testXmlwriterTree(const char *file);
  27  xmlChar *ConvertInput(const char *in, const char *encoding);
  28  
  29  int
  30  main(void)
  31  {
  32      /*
  33       * this initialize the library and check potential ABI mismatches
  34       * between the version it was compiled for and the actual shared
  35       * library used.
  36       */
  37      LIBXML_TEST_VERSION
  38  
  39      /* first, the file version */
  40      testXmlwriterFilename("writer1.tmp");
  41  
  42      /* next, the memory version */
  43      testXmlwriterMemory("writer2.tmp");
  44  
  45      /* next, the DOM version */
  46      testXmlwriterDoc("writer3.tmp");
  47  
  48      /* next, the tree version */
  49      testXmlwriterTree("writer4.tmp");
  50  
  51      /*
  52       * Cleanup function for the XML library.
  53       */
  54      xmlCleanupParser();
  55      /*
  56       * this is to debug memory for regression tests
  57       */
  58      xmlMemoryDump();
  59      return 0;
  60  }
  61  
  62  /**
  63   * testXmlwriterFilename:
  64   * @uri: the output URI
  65   *
  66   * test the xmlWriter interface when writing to a new file
  67   */
  68  void
  69  testXmlwriterFilename(const char *uri)
  70  {
  71      int rc;
  72      xmlTextWriterPtr writer;
  73      xmlChar *tmp;
  74  
  75      /* Create a new XmlWriter for uri, with no compression. */
  76      writer = xmlNewTextWriterFilename(uri, 0);
  77      if (writer == NULL) {
  78          printf("testXmlwriterFilename: Error creating the xml writer\n");
  79          return;
  80      }
  81  
  82      /* Start the document with the xml default for the version,
  83       * encoding ISO 8859-1 and the default for the standalone
  84       * declaration. */
  85      rc = xmlTextWriterStartDocument(writer, NULL, MY_ENCODING, NULL);
  86      if (rc < 0) {
  87          printf
  88              ("testXmlwriterFilename: Error at xmlTextWriterStartDocument\n");
  89          return;
  90      }
  91  
  92      /* Start an element named "EXAMPLE". Since thist is the first
  93       * element, this will be the root element of the document. */
  94      rc = xmlTextWriterStartElement(writer, BAD_CAST "EXAMPLE");
  95      if (rc < 0) {
  96          printf
  97              ("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
  98          return;
  99      }
 100  
 101      /* Write a comment as child of EXAMPLE.
 102       * Please observe, that the input to the xmlTextWriter functions
 103       * HAS to be in UTF-8, even if the output XML is encoded
 104       * in iso-8859-1 */
 105      tmp = ConvertInput("This is a comment with special chars: <\xE4\xF6\xFC>",
 106                         MY_ENCODING);
 107      rc = xmlTextWriterWriteComment(writer, tmp);
 108      if (rc < 0) {
 109          printf
 110              ("testXmlwriterFilename: Error at xmlTextWriterWriteComment\n");
 111          return;
 112      }
 113      if (tmp != NULL) xmlFree(tmp);
 114  
 115      /* Start an element named "ORDER" as child of EXAMPLE. */
 116      rc = xmlTextWriterStartElement(writer, BAD_CAST "ORDER");
 117      if (rc < 0) {
 118          printf
 119              ("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
 120          return;
 121      }
 122  
 123      /* Add an attribute with name "version" and value "1.0" to ORDER. */
 124      rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "version",
 125                                       BAD_CAST "1.0");
 126      if (rc < 0) {
 127          printf
 128              ("testXmlwriterFilename: Error at xmlTextWriterWriteAttribute\n");
 129          return;
 130      }
 131  
 132      /* Add an attribute with name "xml:lang" and value "de" to ORDER. */
 133      rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xml:lang",
 134                                       BAD_CAST "de");
 135      if (rc < 0) {
 136          printf
 137              ("testXmlwriterFilename: Error at xmlTextWriterWriteAttribute\n");
 138          return;
 139      }
 140  
 141      /* Write a comment as child of ORDER */
 142      tmp = ConvertInput("<\xE4\xF6\xFC>", MY_ENCODING);
 143      rc = xmlTextWriterWriteFormatComment(writer,
 144  		     "This is another comment with special chars: %s",
 145  		     tmp);
 146      if (rc < 0) {
 147          printf
 148              ("testXmlwriterFilename: Error at xmlTextWriterWriteFormatComment\n");
 149          return;
 150      }
 151      if (tmp != NULL) xmlFree(tmp);
 152  
 153      /* Start an element named "HEADER" as child of ORDER. */
 154      rc = xmlTextWriterStartElement(writer, BAD_CAST "HEADER");
 155      if (rc < 0) {
 156          printf
 157              ("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
 158          return;
 159      }
 160  
 161      /* Write an element named "X_ORDER_ID" as child of HEADER. */
 162      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "X_ORDER_ID",
 163                                           "%010d", 53535);
 164      if (rc < 0) {
 165          printf
 166              ("testXmlwriterFilename: Error at xmlTextWriterWriteFormatElement\n");
 167          return;
 168      }
 169  
 170      /* Write an element named "CUSTOMER_ID" as child of HEADER. */
 171      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "CUSTOMER_ID",
 172                                           "%d", 1010);
 173      if (rc < 0) {
 174          printf
 175              ("testXmlwriterFilename: Error at xmlTextWriterWriteFormatElement\n");
 176          return;
 177      }
 178  
 179      /* Write an element named "NAME_1" as child of HEADER. */
 180      tmp = ConvertInput("M\xFCller", MY_ENCODING);
 181      rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_1", tmp);
 182      if (rc < 0) {
 183          printf
 184              ("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
 185          return;
 186      }
 187      if (tmp != NULL) xmlFree(tmp);
 188  
 189      /* Write an element named "NAME_2" as child of HEADER. */
 190      tmp = ConvertInput("J\xF6rg", MY_ENCODING);
 191      rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_2", tmp);
 192      if (rc < 0) {
 193          printf
 194              ("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
 195          return;
 196      }
 197      if (tmp != NULL) xmlFree(tmp);
 198  
 199      /* Close the element named HEADER. */
 200      rc = xmlTextWriterEndElement(writer);
 201      if (rc < 0) {
 202          printf
 203              ("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
 204          return;
 205      }
 206  
 207      /* Start an element named "ENTRIES" as child of ORDER. */
 208      rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRIES");
 209      if (rc < 0) {
 210          printf
 211              ("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
 212          return;
 213      }
 214  
 215      /* Start an element named "ENTRY" as child of ENTRIES. */
 216      rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
 217      if (rc < 0) {
 218          printf
 219              ("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
 220          return;
 221      }
 222  
 223      /* Write an element named "ARTICLE" as child of ENTRY. */
 224      rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
 225                                     BAD_CAST "<Test>");
 226      if (rc < 0) {
 227          printf
 228              ("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
 229          return;
 230      }
 231  
 232      /* Write an element named "ENTRY_NO" as child of ENTRY. */
 233      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
 234                                           10);
 235      if (rc < 0) {
 236          printf
 237              ("testXmlwriterFilename: Error at xmlTextWriterWriteFormatElement\n");
 238          return;
 239      }
 240  
 241      /* Close the element named ENTRY. */
 242      rc = xmlTextWriterEndElement(writer);
 243      if (rc < 0) {
 244          printf
 245              ("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
 246          return;
 247      }
 248  
 249      /* Start an element named "ENTRY" as child of ENTRIES. */
 250      rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
 251      if (rc < 0) {
 252          printf
 253              ("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
 254          return;
 255      }
 256  
 257      /* Write an element named "ARTICLE" as child of ENTRY. */
 258      rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
 259                                     BAD_CAST "<Test 2>");
 260      if (rc < 0) {
 261          printf
 262              ("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
 263          return;
 264      }
 265  
 266      /* Write an element named "ENTRY_NO" as child of ENTRY. */
 267      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
 268                                           20);
 269      if (rc < 0) {
 270          printf
 271              ("testXmlwriterFilename: Error at xmlTextWriterWriteFormatElement\n");
 272          return;
 273      }
 274  
 275      /* Close the element named ENTRY. */
 276      rc = xmlTextWriterEndElement(writer);
 277      if (rc < 0) {
 278          printf
 279              ("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
 280          return;
 281      }
 282  
 283      /* Close the element named ENTRIES. */
 284      rc = xmlTextWriterEndElement(writer);
 285      if (rc < 0) {
 286          printf
 287              ("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
 288          return;
 289      }
 290  
 291      /* Start an element named "FOOTER" as child of ORDER. */
 292      rc = xmlTextWriterStartElement(writer, BAD_CAST "FOOTER");
 293      if (rc < 0) {
 294          printf
 295              ("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
 296          return;
 297      }
 298  
 299      /* Write an element named "TEXT" as child of FOOTER. */
 300      rc = xmlTextWriterWriteElement(writer, BAD_CAST "TEXT",
 301                                     BAD_CAST "This is a text.");
 302      if (rc < 0) {
 303          printf
 304              ("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
 305          return;
 306      }
 307  
 308      /* Close the element named FOOTER. */
 309      rc = xmlTextWriterEndElement(writer);
 310      if (rc < 0) {
 311          printf
 312              ("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
 313          return;
 314      }
 315  
 316      /* Here we could close the elements ORDER and EXAMPLE using the
 317       * function xmlTextWriterEndElement, but since we do not want to
 318       * write any other elements, we simply call xmlTextWriterEndDocument,
 319       * which will do all the work. */
 320      rc = xmlTextWriterEndDocument(writer);
 321      if (rc < 0) {
 322          printf
 323              ("testXmlwriterFilename: Error at xmlTextWriterEndDocument\n");
 324          return;
 325      }
 326  
 327      xmlFreeTextWriter(writer);
 328  }
 329  
 330  /**
 331   * testXmlwriterMemory:
 332   * @file: the output file
 333   *
 334   * test the xmlWriter interface when writing to memory
 335   */
 336  void
 337  testXmlwriterMemory(const char *file)
 338  {
 339      int rc;
 340      xmlTextWriterPtr writer;
 341      xmlBufferPtr buf;
 342      xmlChar *tmp;
 343      FILE *fp;
 344  
 345      /* Create a new XML buffer, to which the XML document will be
 346       * written */
 347      buf = xmlBufferCreate();
 348      if (buf == NULL) {
 349          printf("testXmlwriterMemory: Error creating the xml buffer\n");
 350          return;
 351      }
 352  
 353      /* Create a new XmlWriter for memory, with no compression.
 354       * Remark: there is no compression for this kind of xmlTextWriter */
 355      writer = xmlNewTextWriterMemory(buf, 0);
 356      if (writer == NULL) {
 357          printf("testXmlwriterMemory: Error creating the xml writer\n");
 358          return;
 359      }
 360  
 361      /* Start the document with the xml default for the version,
 362       * encoding ISO 8859-1 and the default for the standalone
 363       * declaration. */
 364      rc = xmlTextWriterStartDocument(writer, NULL, MY_ENCODING, NULL);
 365      if (rc < 0) {
 366          printf
 367              ("testXmlwriterMemory: Error at xmlTextWriterStartDocument\n");
 368          return;
 369      }
 370  
 371      /* Start an element named "EXAMPLE". Since thist is the first
 372       * element, this will be the root element of the document. */
 373      rc = xmlTextWriterStartElement(writer, BAD_CAST "EXAMPLE");
 374      if (rc < 0) {
 375          printf
 376              ("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
 377          return;
 378      }
 379  
 380      /* Write a comment as child of EXAMPLE.
 381       * Please observe, that the input to the xmlTextWriter functions
 382       * HAS to be in UTF-8, even if the output XML is encoded
 383       * in iso-8859-1 */
 384      tmp = ConvertInput("This is a comment with special chars: <\xE4\xF6\xFC>",
 385                         MY_ENCODING);
 386      rc = xmlTextWriterWriteComment(writer, tmp);
 387      if (rc < 0) {
 388          printf
 389              ("testXmlwriterMemory: Error at xmlTextWriterWriteComment\n");
 390          return;
 391      }
 392      if (tmp != NULL) xmlFree(tmp);
 393  
 394      /* Start an element named "ORDER" as child of EXAMPLE. */
 395      rc = xmlTextWriterStartElement(writer, BAD_CAST "ORDER");
 396      if (rc < 0) {
 397          printf
 398              ("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
 399          return;
 400      }
 401  
 402      /* Add an attribute with name "version" and value "1.0" to ORDER. */
 403      rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "version",
 404                                       BAD_CAST "1.0");
 405      if (rc < 0) {
 406          printf
 407              ("testXmlwriterMemory: Error at xmlTextWriterWriteAttribute\n");
 408          return;
 409      }
 410  
 411      /* Add an attribute with name "xml:lang" and value "de" to ORDER. */
 412      rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xml:lang",
 413                                       BAD_CAST "de");
 414      if (rc < 0) {
 415          printf
 416              ("testXmlwriterMemory: Error at xmlTextWriterWriteAttribute\n");
 417          return;
 418      }
 419  
 420      /* Write a comment as child of ORDER */
 421      tmp = ConvertInput("<\xE4\xF6\xFC>", MY_ENCODING);
 422      rc = xmlTextWriterWriteFormatComment(writer,
 423  		     "This is another comment with special chars: %s",
 424                                           tmp);
 425      if (rc < 0) {
 426          printf
 427              ("testXmlwriterMemory: Error at xmlTextWriterWriteFormatComment\n");
 428          return;
 429      }
 430      if (tmp != NULL) xmlFree(tmp);
 431  
 432      /* Start an element named "HEADER" as child of ORDER. */
 433      rc = xmlTextWriterStartElement(writer, BAD_CAST "HEADER");
 434      if (rc < 0) {
 435          printf
 436              ("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
 437          return;
 438      }
 439  
 440      /* Write an element named "X_ORDER_ID" as child of HEADER. */
 441      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "X_ORDER_ID",
 442                                           "%010d", 53535);
 443      if (rc < 0) {
 444          printf
 445              ("testXmlwriterMemory: Error at xmlTextWriterWriteFormatElement\n");
 446          return;
 447      }
 448  
 449      /* Write an element named "CUSTOMER_ID" as child of HEADER. */
 450      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "CUSTOMER_ID",
 451                                           "%d", 1010);
 452      if (rc < 0) {
 453          printf
 454              ("testXmlwriterMemory: Error at xmlTextWriterWriteFormatElement\n");
 455          return;
 456      }
 457  
 458      /* Write an element named "NAME_1" as child of HEADER. */
 459      tmp = ConvertInput("M\xFCller", MY_ENCODING);
 460      rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_1", tmp);
 461      if (rc < 0) {
 462          printf
 463              ("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
 464          return;
 465      }
 466      if (tmp != NULL) xmlFree(tmp);
 467  
 468      /* Write an element named "NAME_2" as child of HEADER. */
 469      tmp = ConvertInput("J\xF6rg", MY_ENCODING);
 470      rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_2", tmp);
 471  
 472      if (rc < 0) {
 473          printf
 474              ("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
 475          return;
 476      }
 477      if (tmp != NULL) xmlFree(tmp);
 478  
 479      /* Close the element named HEADER. */
 480      rc = xmlTextWriterEndElement(writer);
 481      if (rc < 0) {
 482          printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
 483          return;
 484      }
 485  
 486      /* Start an element named "ENTRIES" as child of ORDER. */
 487      rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRIES");
 488      if (rc < 0) {
 489          printf
 490              ("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
 491          return;
 492      }
 493  
 494      /* Start an element named "ENTRY" as child of ENTRIES. */
 495      rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
 496      if (rc < 0) {
 497          printf
 498              ("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
 499          return;
 500      }
 501  
 502      /* Write an element named "ARTICLE" as child of ENTRY. */
 503      rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
 504                                     BAD_CAST "<Test>");
 505      if (rc < 0) {
 506          printf
 507              ("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
 508          return;
 509      }
 510  
 511      /* Write an element named "ENTRY_NO" as child of ENTRY. */
 512      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
 513                                           10);
 514      if (rc < 0) {
 515          printf
 516              ("testXmlwriterMemory: Error at xmlTextWriterWriteFormatElement\n");
 517          return;
 518      }
 519  
 520      /* Close the element named ENTRY. */
 521      rc = xmlTextWriterEndElement(writer);
 522      if (rc < 0) {
 523          printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
 524          return;
 525      }
 526  
 527      /* Start an element named "ENTRY" as child of ENTRIES. */
 528      rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
 529      if (rc < 0) {
 530          printf
 531              ("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
 532          return;
 533      }
 534  
 535      /* Write an element named "ARTICLE" as child of ENTRY. */
 536      rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
 537                                     BAD_CAST "<Test 2>");
 538      if (rc < 0) {
 539          printf
 540              ("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
 541          return;
 542      }
 543  
 544      /* Write an element named "ENTRY_NO" as child of ENTRY. */
 545      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
 546                                           20);
 547      if (rc < 0) {
 548          printf
 549              ("testXmlwriterMemory: Error at xmlTextWriterWriteFormatElement\n");
 550          return;
 551      }
 552  
 553      /* Close the element named ENTRY. */
 554      rc = xmlTextWriterEndElement(writer);
 555      if (rc < 0) {
 556          printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
 557          return;
 558      }
 559  
 560      /* Close the element named ENTRIES. */
 561      rc = xmlTextWriterEndElement(writer);
 562      if (rc < 0) {
 563          printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
 564          return;
 565      }
 566  
 567      /* Start an element named "FOOTER" as child of ORDER. */
 568      rc = xmlTextWriterStartElement(writer, BAD_CAST "FOOTER");
 569      if (rc < 0) {
 570          printf
 571              ("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
 572          return;
 573      }
 574  
 575      /* Write an element named "TEXT" as child of FOOTER. */
 576      rc = xmlTextWriterWriteElement(writer, BAD_CAST "TEXT",
 577                                     BAD_CAST "This is a text.");
 578      if (rc < 0) {
 579          printf
 580              ("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
 581          return;
 582      }
 583  
 584      /* Close the element named FOOTER. */
 585      rc = xmlTextWriterEndElement(writer);
 586      if (rc < 0) {
 587          printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
 588          return;
 589      }
 590  
 591      /* Here we could close the elements ORDER and EXAMPLE using the
 592       * function xmlTextWriterEndElement, but since we do not want to
 593       * write any other elements, we simply call xmlTextWriterEndDocument,
 594       * which will do all the work. */
 595      rc = xmlTextWriterEndDocument(writer);
 596      if (rc < 0) {
 597          printf("testXmlwriterMemory: Error at xmlTextWriterEndDocument\n");
 598          return;
 599      }
 600  
 601      xmlFreeTextWriter(writer);
 602  
 603      fp = fopen(file, "w");
 604      if (fp == NULL) {
 605          printf("testXmlwriterMemory: Error at fopen\n");
 606          return;
 607      }
 608  
 609      fprintf(fp, "%s", (const char *) buf->content);
 610  
 611      fclose(fp);
 612  
 613      xmlBufferFree(buf);
 614  }
 615  
 616  /**
 617   * testXmlwriterDoc:
 618   * @file: the output file
 619   *
 620   * test the xmlWriter interface when creating a new document
 621   */
 622  void
 623  testXmlwriterDoc(const char *file)
 624  {
 625      int rc;
 626      xmlTextWriterPtr writer;
 627      xmlChar *tmp;
 628      xmlDocPtr doc;
 629  
 630  
 631      /* Create a new XmlWriter for DOM, with no compression. */
 632      writer = xmlNewTextWriterDoc(&doc, 0);
 633      if (writer == NULL) {
 634          printf("testXmlwriterDoc: Error creating the xml writer\n");
 635          return;
 636      }
 637  
 638      /* Start the document with the xml default for the version,
 639       * encoding ISO 8859-1 and the default for the standalone
 640       * declaration. */
 641      rc = xmlTextWriterStartDocument(writer, NULL, MY_ENCODING, NULL);
 642      if (rc < 0) {
 643          printf("testXmlwriterDoc: Error at xmlTextWriterStartDocument\n");
 644          return;
 645      }
 646  
 647      /* Start an element named "EXAMPLE". Since thist is the first
 648       * element, this will be the root element of the document. */
 649      rc = xmlTextWriterStartElement(writer, BAD_CAST "EXAMPLE");
 650      if (rc < 0) {
 651          printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
 652          return;
 653      }
 654  
 655      /* Write a comment as child of EXAMPLE.
 656       * Please observe, that the input to the xmlTextWriter functions
 657       * HAS to be in UTF-8, even if the output XML is encoded
 658       * in iso-8859-1 */
 659      tmp = ConvertInput("This is a comment with special chars: <\xE4\xF6\xFC>",
 660                         MY_ENCODING);
 661      rc = xmlTextWriterWriteComment(writer, tmp);
 662      if (rc < 0) {
 663          printf("testXmlwriterDoc: Error at xmlTextWriterWriteComment\n");
 664          return;
 665      }
 666      if (tmp != NULL) xmlFree(tmp);
 667  
 668      /* Start an element named "ORDER" as child of EXAMPLE. */
 669      rc = xmlTextWriterStartElement(writer, BAD_CAST "ORDER");
 670      if (rc < 0) {
 671          printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
 672          return;
 673      }
 674  
 675      /* Add an attribute with name "version" and value "1.0" to ORDER. */
 676      rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "version",
 677                                       BAD_CAST "1.0");
 678      if (rc < 0) {
 679          printf("testXmlwriterDoc: Error at xmlTextWriterWriteAttribute\n");
 680          return;
 681      }
 682  
 683      /* Add an attribute with name "xml:lang" and value "de" to ORDER. */
 684      rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xml:lang",
 685                                       BAD_CAST "de");
 686      if (rc < 0) {
 687          printf("testXmlwriterDoc: Error at xmlTextWriterWriteAttribute\n");
 688          return;
 689      }
 690  
 691      /* Write a comment as child of ORDER */
 692      tmp = ConvertInput("<\xE4\xF6\xFC>", MY_ENCODING);
 693      rc = xmlTextWriterWriteFormatComment(writer,
 694  		 "This is another comment with special chars: %s",
 695  		                         tmp);
 696      if (rc < 0) {
 697          printf
 698              ("testXmlwriterDoc: Error at xmlTextWriterWriteFormatComment\n");
 699          return;
 700      }
 701      if (tmp != NULL) xmlFree(tmp);
 702  
 703      /* Start an element named "HEADER" as child of ORDER. */
 704      rc = xmlTextWriterStartElement(writer, BAD_CAST "HEADER");
 705      if (rc < 0) {
 706          printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
 707          return;
 708      }
 709  
 710      /* Write an element named "X_ORDER_ID" as child of HEADER. */
 711      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "X_ORDER_ID",
 712                                           "%010d", 53535);
 713      if (rc < 0) {
 714          printf
 715              ("testXmlwriterDoc: Error at xmlTextWriterWriteFormatElement\n");
 716          return;
 717      }
 718  
 719      /* Write an element named "CUSTOMER_ID" as child of HEADER. */
 720      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "CUSTOMER_ID",
 721                                           "%d", 1010);
 722      if (rc < 0) {
 723          printf
 724              ("testXmlwriterDoc: Error at xmlTextWriterWriteFormatElement\n");
 725          return;
 726      }
 727  
 728      /* Write an element named "NAME_1" as child of HEADER. */
 729      tmp = ConvertInput("M\xFCller", MY_ENCODING);
 730      rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_1", tmp);
 731      if (rc < 0) {
 732          printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
 733          return;
 734      }
 735      if (tmp != NULL) xmlFree(tmp);
 736  
 737      /* Write an element named "NAME_2" as child of HEADER. */
 738      tmp = ConvertInput("J\xF6rg", MY_ENCODING);
 739      rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_2", tmp);
 740      if (rc < 0) {
 741          printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
 742          return;
 743      }
 744      if (tmp != NULL) xmlFree(tmp);
 745  
 746      /* Close the element named HEADER. */
 747      rc = xmlTextWriterEndElement(writer);
 748      if (rc < 0) {
 749          printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
 750          return;
 751      }
 752  
 753      /* Start an element named "ENTRIES" as child of ORDER. */
 754      rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRIES");
 755      if (rc < 0) {
 756          printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
 757          return;
 758      }
 759  
 760      /* Start an element named "ENTRY" as child of ENTRIES. */
 761      rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
 762      if (rc < 0) {
 763          printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
 764          return;
 765      }
 766  
 767      /* Write an element named "ARTICLE" as child of ENTRY. */
 768      rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
 769                                     BAD_CAST "<Test>");
 770      if (rc < 0) {
 771          printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
 772          return;
 773      }
 774  
 775      /* Write an element named "ENTRY_NO" as child of ENTRY. */
 776      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
 777                                           10);
 778      if (rc < 0) {
 779          printf
 780              ("testXmlwriterDoc: Error at xmlTextWriterWriteFormatElement\n");
 781          return;
 782      }
 783  
 784      /* Close the element named ENTRY. */
 785      rc = xmlTextWriterEndElement(writer);
 786      if (rc < 0) {
 787          printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
 788          return;
 789      }
 790  
 791      /* Start an element named "ENTRY" as child of ENTRIES. */
 792      rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
 793      if (rc < 0) {
 794          printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
 795          return;
 796      }
 797  
 798      /* Write an element named "ARTICLE" as child of ENTRY. */
 799      rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
 800                                     BAD_CAST "<Test 2>");
 801      if (rc < 0) {
 802          printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
 803          return;
 804      }
 805  
 806      /* Write an element named "ENTRY_NO" as child of ENTRY. */
 807      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
 808                                           20);
 809      if (rc < 0) {
 810          printf
 811              ("testXmlwriterDoc: Error at xmlTextWriterWriteFormatElement\n");
 812          return;
 813      }
 814  
 815      /* Close the element named ENTRY. */
 816      rc = xmlTextWriterEndElement(writer);
 817      if (rc < 0) {
 818          printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
 819          return;
 820      }
 821  
 822      /* Close the element named ENTRIES. */
 823      rc = xmlTextWriterEndElement(writer);
 824      if (rc < 0) {
 825          printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
 826          return;
 827      }
 828  
 829      /* Start an element named "FOOTER" as child of ORDER. */
 830      rc = xmlTextWriterStartElement(writer, BAD_CAST "FOOTER");
 831      if (rc < 0) {
 832          printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
 833          return;
 834      }
 835  
 836      /* Write an element named "TEXT" as child of FOOTER. */
 837      rc = xmlTextWriterWriteElement(writer, BAD_CAST "TEXT",
 838                                     BAD_CAST "This is a text.");
 839      if (rc < 0) {
 840          printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
 841          return;
 842      }
 843  
 844      /* Close the element named FOOTER. */
 845      rc = xmlTextWriterEndElement(writer);
 846      if (rc < 0) {
 847          printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
 848          return;
 849      }
 850  
 851      /* Here we could close the elements ORDER and EXAMPLE using the
 852       * function xmlTextWriterEndElement, but since we do not want to
 853       * write any other elements, we simply call xmlTextWriterEndDocument,
 854       * which will do all the work. */
 855      rc = xmlTextWriterEndDocument(writer);
 856      if (rc < 0) {
 857          printf("testXmlwriterDoc: Error at xmlTextWriterEndDocument\n");
 858          return;
 859      }
 860  
 861      xmlFreeTextWriter(writer);
 862  
 863      xmlSaveFileEnc(file, doc, MY_ENCODING);
 864  
 865      xmlFreeDoc(doc);
 866  }
 867  
 868  /**
 869   * testXmlwriterTree:
 870   * @file: the output file
 871   *
 872   * test the xmlWriter interface when writing to a subtree
 873   */
 874  void
 875  testXmlwriterTree(const char *file)
 876  {
 877      int rc;
 878      xmlTextWriterPtr writer;
 879      xmlDocPtr doc;
 880      xmlNodePtr node;
 881      xmlChar *tmp;
 882  
 883      /* Create a new XML DOM tree, to which the XML document will be
 884       * written */
 885      doc = xmlNewDoc(BAD_CAST XML_DEFAULT_VERSION);
 886      if (doc == NULL) {
 887          printf
 888              ("testXmlwriterTree: Error creating the xml document tree\n");
 889          return;
 890      }
 891  
 892      /* Create a new XML node, to which the XML document will be
 893       * appended */
 894      node = xmlNewDocNode(doc, NULL, BAD_CAST "EXAMPLE", NULL);
 895      if (node == NULL) {
 896          printf("testXmlwriterTree: Error creating the xml node\n");
 897          return;
 898      }
 899  
 900      /* Make ELEMENT the root node of the tree */
 901      xmlDocSetRootElement(doc, node);
 902  
 903      /* Create a new XmlWriter for DOM tree, with no compression. */
 904      writer = xmlNewTextWriterTree(doc, node, 0);
 905      if (writer == NULL) {
 906          printf("testXmlwriterTree: Error creating the xml writer\n");
 907          return;
 908      }
 909  
 910      /* Start the document with the xml default for the version,
 911       * encoding ISO 8859-1 and the default for the standalone
 912       * declaration. */
 913      rc = xmlTextWriterStartDocument(writer, NULL, MY_ENCODING, NULL);
 914      if (rc < 0) {
 915          printf("testXmlwriterTree: Error at xmlTextWriterStartDocument\n");
 916          return;
 917      }
 918  
 919      /* Write a comment as child of EXAMPLE.
 920       * Please observe, that the input to the xmlTextWriter functions
 921       * HAS to be in UTF-8, even if the output XML is encoded
 922       * in iso-8859-1 */
 923      tmp = ConvertInput("This is a comment with special chars: <\xE4\xF6\xFC>",
 924                         MY_ENCODING);
 925      rc = xmlTextWriterWriteComment(writer, tmp);
 926      if (rc < 0) {
 927          printf("testXmlwriterTree: Error at xmlTextWriterWriteComment\n");
 928          return;
 929      }
 930      if (tmp != NULL) xmlFree(tmp);
 931  
 932      /* Start an element named "ORDER" as child of EXAMPLE. */
 933      rc = xmlTextWriterStartElement(writer, BAD_CAST "ORDER");
 934      if (rc < 0) {
 935          printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
 936          return;
 937      }
 938  
 939      /* Add an attribute with name "version" and value "1.0" to ORDER. */
 940      rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "version",
 941                                       BAD_CAST "1.0");
 942      if (rc < 0) {
 943          printf
 944              ("testXmlwriterTree: Error at xmlTextWriterWriteAttribute\n");
 945          return;
 946      }
 947  
 948      /* Add an attribute with name "xml:lang" and value "de" to ORDER. */
 949      rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xml:lang",
 950                                       BAD_CAST "de");
 951      if (rc < 0) {
 952          printf
 953              ("testXmlwriterTree: Error at xmlTextWriterWriteAttribute\n");
 954          return;
 955      }
 956  
 957      /* Write a comment as child of ORDER */
 958      tmp = ConvertInput("<\xE4\xF6\xFC>", MY_ENCODING);
 959      rc = xmlTextWriterWriteFormatComment(writer,
 960  			 "This is another comment with special chars: %s",
 961  					  tmp);
 962      if (rc < 0) {
 963          printf
 964              ("testXmlwriterTree: Error at xmlTextWriterWriteFormatComment\n");
 965          return;
 966      }
 967      if (tmp != NULL) xmlFree(tmp);
 968  
 969      /* Start an element named "HEADER" as child of ORDER. */
 970      rc = xmlTextWriterStartElement(writer, BAD_CAST "HEADER");
 971      if (rc < 0) {
 972          printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
 973          return;
 974      }
 975  
 976      /* Write an element named "X_ORDER_ID" as child of HEADER. */
 977      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "X_ORDER_ID",
 978                                           "%010d", 53535);
 979      if (rc < 0) {
 980          printf
 981              ("testXmlwriterTree: Error at xmlTextWriterWriteFormatElement\n");
 982          return;
 983      }
 984  
 985      /* Write an element named "CUSTOMER_ID" as child of HEADER. */
 986      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "CUSTOMER_ID",
 987                                           "%d", 1010);
 988      if (rc < 0) {
 989          printf
 990              ("testXmlwriterTree: Error at xmlTextWriterWriteFormatElement\n");
 991          return;
 992      }
 993  
 994      /* Write an element named "NAME_1" as child of HEADER. */
 995      tmp = ConvertInput("M\xFCller", MY_ENCODING);
 996      rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_1", tmp);
 997      if (rc < 0) {
 998          printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
 999          return;
1000      }
1001      if (tmp != NULL) xmlFree(tmp);
1002  
1003      /* Write an element named "NAME_2" as child of HEADER. */
1004      tmp = ConvertInput("J\xF6rg", MY_ENCODING);
1005      rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_2", tmp);
1006      if (rc < 0) {
1007          printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
1008          return;
1009      }
1010      if (tmp != NULL) xmlFree(tmp);
1011  
1012      /* Close the element named HEADER. */
1013      rc = xmlTextWriterEndElement(writer);
1014      if (rc < 0) {
1015          printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
1016          return;
1017      }
1018  
1019      /* Start an element named "ENTRIES" as child of ORDER. */
1020      rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRIES");
1021      if (rc < 0) {
1022          printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
1023          return;
1024      }
1025  
1026      /* Start an element named "ENTRY" as child of ENTRIES. */
1027      rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
1028      if (rc < 0) {
1029          printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
1030          return;
1031      }
1032  
1033      /* Write an element named "ARTICLE" as child of ENTRY. */
1034      rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
1035                                     BAD_CAST "<Test>");
1036      if (rc < 0) {
1037          printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
1038          return;
1039      }
1040  
1041      /* Write an element named "ENTRY_NO" as child of ENTRY. */
1042      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
1043                                           10);
1044      if (rc < 0) {
1045          printf
1046              ("testXmlwriterTree: Error at xmlTextWriterWriteFormatElement\n");
1047          return;
1048      }
1049  
1050      /* Close the element named ENTRY. */
1051      rc = xmlTextWriterEndElement(writer);
1052      if (rc < 0) {
1053          printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
1054          return;
1055      }
1056  
1057      /* Start an element named "ENTRY" as child of ENTRIES. */
1058      rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
1059      if (rc < 0) {
1060          printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
1061          return;
1062      }
1063  
1064      /* Write an element named "ARTICLE" as child of ENTRY. */
1065      rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
1066                                     BAD_CAST "<Test 2>");
1067      if (rc < 0) {
1068          printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
1069          return;
1070      }
1071  
1072      /* Write an element named "ENTRY_NO" as child of ENTRY. */
1073      rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
1074                                           20);
1075      if (rc < 0) {
1076          printf
1077              ("testXmlwriterTree: Error at xmlTextWriterWriteFormatElement\n");
1078          return;
1079      }
1080  
1081      /* Close the element named ENTRY. */
1082      rc = xmlTextWriterEndElement(writer);
1083      if (rc < 0) {
1084          printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
1085          return;
1086      }
1087  
1088      /* Close the element named ENTRIES. */
1089      rc = xmlTextWriterEndElement(writer);
1090      if (rc < 0) {
1091          printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
1092          return;
1093      }
1094  
1095      /* Start an element named "FOOTER" as child of ORDER. */
1096      rc = xmlTextWriterStartElement(writer, BAD_CAST "FOOTER");
1097      if (rc < 0) {
1098          printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
1099          return;
1100      }
1101  
1102      /* Write an element named "TEXT" as child of FOOTER. */
1103      rc = xmlTextWriterWriteElement(writer, BAD_CAST "TEXT",
1104                                     BAD_CAST "This is a text.");
1105      if (rc < 0) {
1106          printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
1107          return;
1108      }
1109  
1110      /* Close the element named FOOTER. */
1111      rc = xmlTextWriterEndElement(writer);
1112      if (rc < 0) {
1113          printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
1114          return;
1115      }
1116  
1117      /* Here we could close the elements ORDER and EXAMPLE using the
1118       * function xmlTextWriterEndElement, but since we do not want to
1119       * write any other elements, we simply call xmlTextWriterEndDocument,
1120       * which will do all the work. */
1121      rc = xmlTextWriterEndDocument(writer);
1122      if (rc < 0) {
1123          printf("testXmlwriterTree: Error at xmlTextWriterEndDocument\n");
1124          return;
1125      }
1126  
1127      xmlFreeTextWriter(writer);
1128  
1129      xmlSaveFileEnc(file, doc, MY_ENCODING);
1130  
1131      xmlFreeDoc(doc);
1132  }
1133  
1134  /**
1135   * ConvertInput:
1136   * @in: string in a given encoding
1137   * @encoding: the encoding used
1138   *
1139   * Converts @in into UTF-8 for processing with libxml2 APIs
1140   *
1141   * Returns the converted UTF-8 string, or NULL in case of error.
1142   */
1143  xmlChar *
1144  ConvertInput(const char *in, const char *encoding)
1145  {
1146      xmlChar *out;
1147      int ret;
1148      int size;
1149      int out_size;
1150      int temp;
1151      xmlCharEncodingHandlerPtr handler;
1152  
1153      if (in == 0)
1154          return 0;
1155  
1156      handler = xmlFindCharEncodingHandler(encoding);
1157  
1158      if (!handler) {
1159          printf("ConvertInput: no encoding handler found for '%s'\n",
1160                 encoding ? encoding : "");
1161          return 0;
1162      }
1163  
1164      size = (int) strlen(in) + 1;
1165      out_size = size * 2 - 1;
1166      out = (unsigned char *) xmlMalloc((size_t) out_size);
1167  
1168      if (out != 0) {
1169          temp = size - 1;
1170          ret = handler->input(out, &out_size, (const xmlChar *) in, &temp);
1171          if ((ret < 0) || (temp - size + 1)) {
1172              if (ret < 0) {
1173                  printf("ConvertInput: conversion wasn't successful.\n");
1174              } else {
1175                  printf
1176                      ("ConvertInput: conversion wasn't successful. converted: %i octets.\n",
1177                       temp);
1178              }
1179  
1180              xmlFree(out);
1181              out = 0;
1182          } else {
1183              out = (unsigned char *) xmlRealloc(out, out_size + 1);
1184              out[out_size] = 0;  /*null terminating out */
1185          }
1186      } else {
1187          printf("ConvertInput: no mem\n");
1188      }
1189  
1190      return out;
1191  }
1192  
1193  #else
1194  int main(void) {
1195      fprintf(stderr, "Writer or output support not compiled in\n");
1196      exit(1);
1197  }
1198  #endif