doc/examples/testWriter.c

   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: <äöü>",
 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("<äöü>", 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üller", 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örg", 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: <äöü>",
 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("<äöü>", 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üller", 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örg", 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: <äöü>",
 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("<äöü>", 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üller", 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örg", 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: <äöü>",
 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("<äöü>", 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üller", 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örg", 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