axiom/test/om/test_om.c - axis-axis2-c-core - Git at Google


 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <axiom_stax_builder.h>
 #include <axiom_document.h>
 #include <axiom_node.h>
 #include <axiom_element.h>
 #include <axiom_text.h>
 #include <axiom_data_source.h>
 #include <axutil_stream.h>
 #include <axutil_log_default.h>
 #include <axutil_error_default.h>
 #include <axiom_xml_reader.h>
 #include <stdio.h>
 #include <axiom_xml_writer.h>
 #include <axutil_env.h>

 /**
    Define the environment related variables globally so that they are available
    for both functions
 */

 axutil_allocator_t *allocator = NULL;
 axutil_env_t *environment = NULL;
 axutil_stream_t *stream = NULL;
 axutil_error_t *error = NULL;
 axutil_log_t *axis_log = NULL;
 FILE *f = NULL;

 /** a method that demonstrate creating a om model using an xml file */

 int AXIS2_CALL
 read_input(
     char *buffer,
     int size,
     void *ctx)
 {
     int len = 0;
     char *pos = NULL;
     len = fread(buffer, sizeof(char), size, f);
     if (buffer)
         pos = strstr(buffer, "---");
     if (pos)
     {
         len = pos - buffer;
         *pos = '\0';
     }
     return len;
 }

 int
 test_om_build(
     const char *filename)
 {
     axiom_element_t *ele1 = NULL,
         *ele2 = NULL;
     axiom_stax_builder_t *builder = NULL;
     axiom_text_t *text = NULL;
     axiom_document_t *document = NULL;
     axiom_node_t *node1 = NULL,
         *node2 = NULL;
     axiom_node_t *node3 = NULL;
     axiom_output_t *om_output = NULL;
     axiom_namespace_t *ns = NULL;
     axiom_xml_reader_t *reader = NULL;
     axiom_xml_writer_t *writer = NULL;

     char *buffer = NULL;
     axutil_hash_t* hash = NULL;

     printf("\nstart test_om_build\n");

     f = fopen(filename, "r");
     if (!f)
     {
         printf("FILE COULDN'T BE OPENED %s \n",filename);
         return -1;
     }

     /** create pull parser */
     reader =
         axiom_xml_reader_create_for_io(environment, read_input, NULL, NULL,
                                        NULL);

     if (!reader)
     {
         printf("ERROR CREATING PULLPARSER");
         return -1;
     }

      /** create axiom_stax_builder by parsing pull_parser struct */

     builder = axiom_stax_builder_create(environment, reader);

     if (!builder)
     {
         printf("ERROR CREATING PULL PARSER");
         return -1;
     }

     /**
         create an om document
         document is the container of om model created using builder
     */

     document = axiom_stax_builder_get_document(builder, environment);

     /**
         get root element , building starts hear
      */
     if (!document)
     {
         printf("COULDN'T BUILD DOCUMENT");
         return -1;
     }

     node1 = axiom_document_get_root_element(document, environment);
     if (!node1)
     {
         printf(" root element null ");
         axiom_stax_builder_free(builder, environment);
         return -1;
     }
     if (node1)
     {

         /** print root node information */

         ele1 = axiom_node_get_data_element(node1, environment);
         if (ele1)
         {
             printf("root localname %s\n",
                    axiom_element_get_localname(ele1, environment));

             hash = axiom_element_get_all_attributes(ele1,environment);
             if(hash)
             {
                 axutil_hash_index_t *hi;
                 const void *key= NULL;
                 void *val = NULL;
                 for (hi = axutil_hash_first(hash,environment); hi; hi = axutil_hash_next(environment, hi))
                 {
                     axutil_hash_this(hi, &key, NULL,&val);
                     if(val)
                     {
                         printf(" Attribute name: %s",
                             axiom_attribute_get_localname((axiom_attribute_t *)val,environment));
                         printf("   value: %s\n",
                             axiom_attribute_get_value((axiom_attribute_t *)val,environment));
                     }
                 }
             }
         }

         ns = axiom_element_get_namespace(ele1, environment, node1);

         if (ns)
         {
             printf("root ns prefix %s\n",
                    axiom_namespace_get_prefix(ns, environment));
             printf("root ns uri %s\n",
                    axiom_namespace_get_uri(ns, environment));
                         printf("=============================================");

         }
         else
             printf("=============================================");

     }

     /** build the document continuously untill all the xml file is built in to a om model */

     node2 = axiom_document_build_next(document, environment);
     do
     {

         if (!node2)
             break;

         switch (axiom_node_get_node_type(node2, environment))
         {
         case AXIOM_ELEMENT:
             ele2 =
                 (axiom_element_t *) axiom_node_get_data_element(node2,
                                                                 environment);
                     printf("=============================================");
             if (ele2 && axiom_element_get_localname(ele2, environment))
             {
                 printf("\n localname %s\n",
                            axiom_element_get_localname(ele2, environment));
                 hash = axiom_element_get_all_attributes(ele2,environment);
                 if(hash)
                 {
                     axutil_hash_index_t *hi;
                     const void *key= NULL;
                     void *val = NULL;
                     for (hi = axutil_hash_first(hash,environment); hi; hi = axutil_hash_next(environment, hi))
                     {
                         axutil_hash_this(hi, &key, NULL,&val);
                         if(val)
                         {
                             printf(" Attribute name: %s",
                                 axiom_attribute_get_localname((axiom_attribute_t *)val,environment));
                             printf("   value: %s\n",
                                 axiom_attribute_get_value((axiom_attribute_t *)val,environment));
                         }
                     }
                 }

             }


             if (!node3)
                 node3 = node2;

             break;
         case AXIOM_TEXT:

             text =
                 (axiom_text_t *) axiom_node_get_data_element(node2,
                                                              environment);
             if (text && axiom_text_get_value(text, environment))
                 printf("\n text value  %s \n",
                        axiom_text_get_value(text, environment));
             break;

         default:
             break;
         }

         node2 = axiom_document_build_next(document, environment);
     }
     while (node2);
     printf("END: pull document\n");

     printf("Serialize pulled document\n");

     writer =
         axiom_xml_writer_create_for_memory(environment, NULL, AXIS2_TRUE, 0,
                                            AXIS2_XML_PARSER_TYPE_BUFFER);
     om_output = axiom_output_create(environment, writer);

     axiom_node_serialize_sub_tree(node3, environment, om_output);

     buffer = (axis2_char_t *) axiom_xml_writer_get_xml(writer, environment);

     if (buffer)
         printf("Sub Tree = %s\n", buffer);

     axiom_output_free(om_output, environment);

     axiom_stax_builder_free(builder, environment);

 /*     if (buffer) */

 /*         AXIS2_FREE(environment->allocator, buffer); */
     printf("\nend test_om_build\n");
     fclose(f);
     return 0;
 }


 int test_om_buffer()
 {
     /*AXIS2C-1628 buffer modified by axiom_node_create_from_buffer */
     axis2_char_t * output;

     char * xml = strdup("<foo>T1 &amp; T2</foo>");
     char * xml_unaltered= strdup("<foo>T1 &amp; T2</foo>");

     printf("\nstart test_om_bufer\n");

     axiom_node_t * om_node = axiom_node_create_from_buffer(environment, xml);

     output = axiom_node_to_string(om_node,environment);

     if(axutil_strcmp(xml,xml_unaltered))
     {
         printf("ERROR BUFFER MODIFIED\n");
         return -1;
     }

     if(axutil_strcmp(output,xml_unaltered))
     {
         printf("ERROR OUTPUT DOESNT MATCH\n");
         return -1;
     }

     axiom_node_free_tree(om_node,environment);
     AXIS2_FREE(environment->allocator, output);
     AXIS2_FREE(environment->allocator, xml);
     AXIS2_FREE(environment->allocator, xml_unaltered);

     printf("\nend test_om_bufer\n");

     return 0;
 }


 int
 test_om_serialize(
     )
 {

     /*
        <book xmlns:axiomc="http://ws.apache.org/axis2/c/om" xmlns:isbn="urn:ISBN:0-395-74341-6">
        <title>Axis2/C OM HOWTO</title>
        <isbn:number>1748491379</isbn:number>
        <author title="Mr" name="Axitoc Oman" />
        <notes>
        <p xmlns="urn:w3-org-ns:HTML">
        This is <i>vey good</i> book on OM!
        </p>
        </notes>
        </book>
      */
     int status;
     axiom_element_t *ele1 = NULL,
         *ele2 = NULL,
         *ele3 = NULL,
         *ele4 = NULL;
     axiom_node_t *node1 = NULL,
         *node2 = NULL,
         *node3 = NULL,
         *node4 = NULL,
         *node5 = NULL,
         *node6 = NULL;
     axiom_data_source_t *data_source = NULL;
     axutil_stream_t *stream = NULL;
     axiom_attribute_t *attr1 = NULL,
         *attr2 = NULL;
     axiom_namespace_t *ns1 = NULL,
         *ns2 = NULL;
     axiom_text_t *text1 = NULL;
     axiom_output_t *om_output = NULL;
     axiom_xml_writer_t *writer = NULL;
     axis2_char_t *output_buffer = NULL;

     printf("\nstart test_om_serialize\n");

     ns1 =
         axiom_namespace_create(environment,
                                "http://ws.apache.org/axis2/c/om", "axiom");
     ns2 = axiom_namespace_create(environment, "urn:ISBN:0-395-74341-6", "isbn");
     ele1 = axiom_element_create(environment, NULL, "book", ns1, &node1);
     axiom_element_declare_namespace(ele1, environment, node1, ns2);

     ele2 = axiom_element_create(environment, node1, "title", ns1, &node2);
     attr1 = axiom_attribute_create(environment, "title22", NULL, NULL);

     axiom_element_add_attribute(ele2, environment, attr1, node2);

     text1 = axiom_text_create(environment, node2, "Axis2/C OM HOWTO", &node3);

     ele3 = axiom_element_create(environment, node1, "number", ns2, &node4);

     text1 = axiom_text_create(environment, node4, "1748491379", &node5);

     ele4 = axiom_element_create(environment, node1, "author", ns1, &node6);

     attr1 = axiom_attribute_create(environment, "title", "Mr", ns1);

     axiom_element_add_attribute(ele4, environment, attr1, node6);

     attr2 = axiom_attribute_create(environment, "name", "Axitoc Oman", ns1);

     axiom_element_add_attribute(ele4, environment, attr2, node6);

     data_source = axiom_data_source_create(environment, node1, &node6);
     stream = axiom_data_source_get_stream(data_source, environment);
     if (stream)
     {
         axutil_stream_write(stream, environment,
                             "<this xmlns:axiom=\"http://ws.apache.org/axis2/c/om\">is a test</this>",
                             axutil_strlen
                             ("<this xmlns:axiom=\"http://ws.apache.org/axis2/c/om\">is a test</this>"));
     }

     /* serializing stuff */
     writer =
         axiom_xml_writer_create_for_memory(environment, NULL, AXIS2_TRUE, 0,
                                            AXIS2_XML_PARSER_TYPE_BUFFER);
     om_output = axiom_output_create(environment, writer);

     printf("Serialize built document\n");
     status = axiom_node_serialize(node1, environment, om_output);
     if (status != AXIS2_SUCCESS)
     {
         printf("\naxiom_node_serialize failed\n");
         return status;
     }
     else
         printf("\naxiom_node_serialize success\n");
     /* end serializing stuff */

     axiom_node_free_tree(node1, environment);
     output_buffer =
         (axis2_char_t *) axiom_xml_writer_get_xml(writer, environment);

     axiom_output_free(om_output, environment);
     /*    if (output_buffer) */
     /*     { */
     /*         printf("%s", output_buffer); */
     /*         AXIS2_FREE(environment->allocator, output_buffer); */
     /*     } */

     printf("\nend test_om_serialize\n");

     return 0;
 }

 int
 main(
     int argc,
     char *argv[])
  {
     const char *file_name = "../../resources/xml/om/test.xml";
     if (argc > 1)
         file_name = argv[1];
     allocator = axutil_allocator_init(NULL);
     axis_log = axutil_log_create(allocator, NULL, NULL);
     error = axutil_error_create(allocator);

     environment = axutil_env_create_with_error_log(allocator, error, axis_log);
     test_om_build(file_name);
     test_om_serialize();
     test_om_buffer();

     axutil_env_free(environment);
     return 0;
 }

	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <axiom_stax_builder.h>
	#include <axiom_document.h>
	#include <axiom_node.h>
	#include <axiom_element.h>
	#include <axiom_text.h>
	#include <axiom_data_source.h>
	#include <axutil_stream.h>
	#include <axutil_log_default.h>
	#include <axutil_error_default.h>
	#include <axiom_xml_reader.h>
	#include <stdio.h>
	#include <axiom_xml_writer.h>
	#include <axutil_env.h>

	/**
	Define the environment related variables globally so that they are available
	for both functions
	*/

	axutil_allocator_t *allocator = NULL;
	axutil_env_t *environment = NULL;
	axutil_stream_t *stream = NULL;
	axutil_error_t *error = NULL;
	axutil_log_t *axis_log = NULL;
	FILE *f = NULL;

	/** a method that demonstrate creating a om model using an xml file */

	int AXIS2_CALL
	read_input(
	char *buffer,
	int size,
	void *ctx)
	{
	int len = 0;
	char *pos = NULL;
	len = fread(buffer, sizeof(char), size, f);
	if (buffer)
	pos = strstr(buffer, "---");
	if (pos)
	{
	len = pos - buffer;
	*pos = '\0';
	}
	return len;
	}

	int
	test_om_build(
	const char *filename)
	{
	axiom_element_t *ele1 = NULL,
	*ele2 = NULL;
	axiom_stax_builder_t *builder = NULL;
	axiom_text_t *text = NULL;
	axiom_document_t *document = NULL;
	axiom_node_t *node1 = NULL,
	*node2 = NULL;
	axiom_node_t *node3 = NULL;
	axiom_output_t *om_output = NULL;
	axiom_namespace_t *ns = NULL;
	axiom_xml_reader_t *reader = NULL;
	axiom_xml_writer_t *writer = NULL;

	char *buffer = NULL;
	axutil_hash_t* hash = NULL;

	printf("\nstart test_om_build\n");

	f = fopen(filename, "r");
	if (!f)
	{
	printf("FILE COULDN'T BE OPENED %s \n",filename);
	return -1;
	}

	/** create pull parser */
	reader =
	axiom_xml_reader_create_for_io(environment, read_input, NULL, NULL,
	NULL);

	if (!reader)
	{
	printf("ERROR CREATING PULLPARSER");
	return -1;
	}

	/** create axiom_stax_builder by parsing pull_parser struct */

	builder = axiom_stax_builder_create(environment, reader);

	if (!builder)
	{
	printf("ERROR CREATING PULL PARSER");
	return -1;
	}

	/**
	create an om document
	document is the container of om model created using builder
	*/

	document = axiom_stax_builder_get_document(builder, environment);

	/**
	get root element , building starts hear
	*/
	if (!document)
	{
	printf("COULDN'T BUILD DOCUMENT");
	return -1;
	}

	node1 = axiom_document_get_root_element(document, environment);
	if (!node1)
	{
	printf(" root element null ");
	axiom_stax_builder_free(builder, environment);
	return -1;
	}
	if (node1)
	{

	/** print root node information */

	ele1 = axiom_node_get_data_element(node1, environment);
	if (ele1)
	{
	printf("root localname %s\n",
	axiom_element_get_localname(ele1, environment));

	hash = axiom_element_get_all_attributes(ele1,environment);
	if(hash)
	{
	axutil_hash_index_t *hi;
	const void *key= NULL;
	void *val = NULL;
	for (hi = axutil_hash_first(hash,environment); hi; hi = axutil_hash_next(environment, hi))
	{
	axutil_hash_this(hi, &key, NULL,&val);
	if(val)
	{
	printf(" Attribute name: %s",
	axiom_attribute_get_localname((axiom_attribute_t *)val,environment));
	printf(" value: %s\n",
	axiom_attribute_get_value((axiom_attribute_t *)val,environment));
	}
	}
	}
	}

	ns = axiom_element_get_namespace(ele1, environment, node1);

	if (ns)
	{
	printf("root ns prefix %s\n",
	axiom_namespace_get_prefix(ns, environment));
	printf("root ns uri %s\n",
	axiom_namespace_get_uri(ns, environment));
	printf("=============================================");

	}
	else
	printf("=============================================");

	}

	/** build the document continuously untill all the xml file is built in to a om model */

	node2 = axiom_document_build_next(document, environment);
	do
	{

	if (!node2)
	break;

	switch (axiom_node_get_node_type(node2, environment))
	{
	case AXIOM_ELEMENT:
	ele2 =
	(axiom_element_t *) axiom_node_get_data_element(node2,
	environment);
	printf("=============================================");
	if (ele2 && axiom_element_get_localname(ele2, environment))
	{
	printf("\n localname %s\n",
	axiom_element_get_localname(ele2, environment));
	hash = axiom_element_get_all_attributes(ele2,environment);
	if(hash)
	{
	axutil_hash_index_t *hi;
	const void *key= NULL;
	void *val = NULL;
	for (hi = axutil_hash_first(hash,environment); hi; hi = axutil_hash_next(environment, hi))
	{
	axutil_hash_this(hi, &key, NULL,&val);
	if(val)
	{
	printf(" Attribute name: %s",
	axiom_attribute_get_localname((axiom_attribute_t *)val,environment));
	printf(" value: %s\n",
	axiom_attribute_get_value((axiom_attribute_t *)val,environment));
	}
	}
	}

	}



	if (!node3)
	node3 = node2;

	break;
	case AXIOM_TEXT:

	text =
	(axiom_text_t *) axiom_node_get_data_element(node2,
	environment);
	if (text && axiom_text_get_value(text, environment))
	printf("\n text value %s \n",
	axiom_text_get_value(text, environment));
	break;

	default:
	break;
	}

	node2 = axiom_document_build_next(document, environment);
	}
	while (node2);
	printf("END: pull document\n");

	printf("Serialize pulled document\n");

	writer =
	axiom_xml_writer_create_for_memory(environment, NULL, AXIS2_TRUE, 0,
	AXIS2_XML_PARSER_TYPE_BUFFER);
	om_output = axiom_output_create(environment, writer);

	axiom_node_serialize_sub_tree(node3, environment, om_output);

	buffer = (axis2_char_t *) axiom_xml_writer_get_xml(writer, environment);

	if (buffer)
	printf("Sub Tree = %s\n", buffer);

	axiom_output_free(om_output, environment);

	axiom_stax_builder_free(builder, environment);

	/* if (buffer) */

	/* AXIS2_FREE(environment->allocator, buffer); */
	printf("\nend test_om_build\n");
	fclose(f);
	return 0;
	}


	int test_om_buffer()
	{
	/AXIS2C-1628 buffer modified by axiom_node_create_from_buffer /
	axis2_char_t * output;

	char * xml = strdup("<foo>T1 & T2</foo>");
	char * xml_unaltered= strdup("<foo>T1 & T2</foo>");

	printf("\nstart test_om_bufer\n");

	axiom_node_t * om_node = axiom_node_create_from_buffer(environment, xml);

	output = axiom_node_to_string(om_node,environment);

	if(axutil_strcmp(xml,xml_unaltered))
	{
	printf("ERROR BUFFER MODIFIED\n");
	return -1;
	}

	if(axutil_strcmp(output,xml_unaltered))
	{
	printf("ERROR OUTPUT DOESNT MATCH\n");
	return -1;
	}

	axiom_node_free_tree(om_node,environment);
	AXIS2_FREE(environment->allocator, output);
	AXIS2_FREE(environment->allocator, xml);
	AXIS2_FREE(environment->allocator, xml_unaltered);

	printf("\nend test_om_bufer\n");

	return 0;
	}


	int
	test_om_serialize(
	)
	{

	/*
	<book xmlns:axiomc="http://ws.apache.org/axis2/c/om" xmlns:isbn="urn:ISBN:0-395-74341-6">
	<title>Axis2/C OM HOWTO</title>
	<isbn:number>1748491379</isbn:number>
	<author title="Mr" name="Axitoc Oman" />
	<notes>
	<p xmlns="urn:w3-org-ns:HTML">
	This is <i>vey good</i> book on OM!
	</p>
	</notes>
	</book>
	*/
	int status;
	axiom_element_t *ele1 = NULL,
	*ele2 = NULL,
	*ele3 = NULL,
	*ele4 = NULL;
	axiom_node_t *node1 = NULL,
	*node2 = NULL,
	*node3 = NULL,
	*node4 = NULL,
	*node5 = NULL,
	*node6 = NULL;
	axiom_data_source_t *data_source = NULL;
	axutil_stream_t *stream = NULL;
	axiom_attribute_t *attr1 = NULL,
	*attr2 = NULL;
	axiom_namespace_t *ns1 = NULL,
	*ns2 = NULL;
	axiom_text_t *text1 = NULL;
	axiom_output_t *om_output = NULL;
	axiom_xml_writer_t *writer = NULL;
	axis2_char_t *output_buffer = NULL;

	printf("\nstart test_om_serialize\n");

	ns1 =
	axiom_namespace_create(environment,
	"http://ws.apache.org/axis2/c/om", "axiom");
	ns2 = axiom_namespace_create(environment, "urn:ISBN:0-395-74341-6", "isbn");
	ele1 = axiom_element_create(environment, NULL, "book", ns1, &node1);
	axiom_element_declare_namespace(ele1, environment, node1, ns2);

	ele2 = axiom_element_create(environment, node1, "title", ns1, &node2);
	attr1 = axiom_attribute_create(environment, "title22", NULL, NULL);

	axiom_element_add_attribute(ele2, environment, attr1, node2);

	text1 = axiom_text_create(environment, node2, "Axis2/C OM HOWTO", &node3);

	ele3 = axiom_element_create(environment, node1, "number", ns2, &node4);

	text1 = axiom_text_create(environment, node4, "1748491379", &node5);

	ele4 = axiom_element_create(environment, node1, "author", ns1, &node6);

	attr1 = axiom_attribute_create(environment, "title", "Mr", ns1);

	axiom_element_add_attribute(ele4, environment, attr1, node6);

	attr2 = axiom_attribute_create(environment, "name", "Axitoc Oman", ns1);

	axiom_element_add_attribute(ele4, environment, attr2, node6);

	data_source = axiom_data_source_create(environment, node1, &node6);
	stream = axiom_data_source_get_stream(data_source, environment);
	if (stream)
	{
	axutil_stream_write(stream, environment,
	"<this xmlns:axiom=\"http://ws.apache.org/axis2/c/om\">is a test</this>",
	axutil_strlen
	("<this xmlns:axiom=\"http://ws.apache.org/axis2/c/om\">is a test</this>"));
	}

	/* serializing stuff */
	writer =
	axiom_xml_writer_create_for_memory(environment, NULL, AXIS2_TRUE, 0,
	AXIS2_XML_PARSER_TYPE_BUFFER);
	om_output = axiom_output_create(environment, writer);

	printf("Serialize built document\n");
	status = axiom_node_serialize(node1, environment, om_output);
	if (status != AXIS2_SUCCESS)
	{
	printf("\naxiom_node_serialize failed\n");
	return status;
	}
	else
	printf("\naxiom_node_serialize success\n");
	/* end serializing stuff */

	axiom_node_free_tree(node1, environment);
	output_buffer =
	(axis2_char_t *) axiom_xml_writer_get_xml(writer, environment);

	axiom_output_free(om_output, environment);
	/* if (output_buffer) */
	/* { */
	/* printf("%s", output_buffer); */
	/* AXIS2_FREE(environment->allocator, output_buffer); */
	/* } */

	printf("\nend test_om_serialize\n");

	return 0;
	}

	int
	main(
	int argc,
	char *argv[])
	{
	const char *file_name = "../../resources/xml/om/test.xml";
	if (argc > 1)
	file_name = argv[1];
	allocator = axutil_allocator_init(NULL);
	axis_log = axutil_log_create(allocator, NULL, NULL);
	error = axutil_error_create(allocator);

	environment = axutil_env_create_with_error_log(allocator, error, axis_log);
	test_om_build(file_name);
	test_om_serialize();
	test_om_buffer();

	axutil_env_free(environment);
	return 0;
	}