axiom/test/om/test_om.cc - 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 <gtest/gtest.h>

 #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>

 /* FIXME
  * These tests exercise code, but don't actually check that the output is
  * correct.  They didn't when they were in the old test format, either.
  */

 class TestOM: public ::testing::Test
 {

     protected:
         void SetUp()
         {

             m_allocator = axutil_allocator_init(NULL);
             m_axis_log = axutil_log_create(m_allocator, NULL, NULL);
             m_error = axutil_error_create(m_allocator);

             m_env = axutil_env_create_with_error_log(m_allocator, m_error, m_axis_log);

         }

         void TearDown()
         {
             axutil_env_free(m_env);
         }


         axutil_allocator_t *m_allocator = NULL;
         axutil_env_t *m_env = NULL;
         axutil_error_t *m_error = NULL;
         axutil_log_t *m_axis_log = NULL;

 };

 TEST_F(TestOM, test_om_build) {

     char *filename = "../resources/xml/om/test.xml";

     FILE *f = NULL;
     axiom_element_t *ele1 = NULL;
     axiom_element_t *ele2 = NULL;
     axiom_stax_builder_t *builder = NULL;
     axiom_text_t *text = NULL;
     axiom_document_t *document = NULL;
     axiom_node_t *node1 = NULL;
     axiom_node_t *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;

     /** create pull parser */
     reader =
         axiom_xml_reader_create_for_file(m_env, filename, NULL);
     ASSERT_NE(reader, nullptr);

      /** create axiom_stax_builder by parsing pull_parser struct */
     builder = axiom_stax_builder_create(m_env, reader);
     ASSERT_NE(builder, nullptr);

     /**
         create an om document
         document is the container of om model created using builder
     */
     document = axiom_stax_builder_get_document(builder, m_env);
     ASSERT_NE(document, nullptr);

     node1 = axiom_document_get_root_element(document, m_env);
     ASSERT_NE(node1, nullptr);
     if (node1)
     {
         /** print root node information */
         ele1 = (axiom_element_t*)axiom_node_get_data_element(node1, m_env);
         if (ele1)
         {
             printf("root localname %s\n",
                    axiom_element_get_localname(ele1, m_env));

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

         ns = axiom_element_get_namespace(ele1, m_env, node1);

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

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

     }

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

     node2 = axiom_document_build_next(document, m_env);
     do
     {

         if (!node2)
             break;

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

             }


             if (!node3)
                 node3 = node2;

             break;
         case AXIOM_TEXT:

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

         default:
             break;
         }

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

     printf("Serialize pulled document\n");

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

     axiom_node_serialize_sub_tree(node3, m_env, om_output);

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

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

     axiom_output_free(om_output, m_env);

     axiom_stax_builder_free(builder, m_env);

     printf("\nend test_om_build\n");
 }


 TEST_F(TestOM, 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(m_env,
                                "http://ws.apache.org/axis2/c/om", "axiom");
     ns2 = axiom_namespace_create(m_env, "urn:ISBN:0-395-74341-6", "isbn");
     ele1 = axiom_element_create(m_env, NULL, "book", ns1, &node1);
     axiom_element_declare_namespace(ele1, m_env, node1, ns2);

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

     axiom_element_add_attribute(ele2, m_env, attr1, node2);

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

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

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

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

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

     axiom_element_add_attribute(ele4, m_env, attr1, node6);

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

     axiom_element_add_attribute(ele4, m_env, attr2, node6);

     data_source = axiom_data_source_create(m_env, node1, &node6);
     stream = axiom_data_source_get_stream(data_source, m_env);
     if (stream)
     {
         axutil_stream_write(stream, m_env,
                             "<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(m_env, NULL, AXIS2_TRUE, 0,
                                            AXIS2_XML_PARSER_TYPE_BUFFER);
     om_output = axiom_output_create(m_env, writer);

     printf("Serialize built document\n");
     status = axiom_node_serialize(node1, m_env, om_output);
     ASSERT_EQ(status, AXIS2_SUCCESS);

     printf("\naxiom_node_serialize success\n");
     /* end serializing stuff */

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

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

     printf("\nend test_om_serialize\n");

     axiom_namespace_free(ns1, m_env);
     axiom_namespace_free(ns2, m_env);
 }


 TEST_F(TestOM, 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(m_env, xml);

     output = axiom_node_to_string(om_node,m_env);

     ASSERT_EQ(0, axutil_strcmp(xml,xml_unaltered));

     ASSERT_EQ(0, axutil_strcmp(output,xml_unaltered));

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

     printf("\nend test_om_bufer\n");

     return;
 }

 /* AXIS2C-1627 */
 TEST_F(TestOM, test_attr_special_chars)
 {
      axiom_namespace_t * ns = axiom_namespace_create(m_env, "namespace", "ns");

      char * attribute;
      axiom_node_t * node;
      axiom_node_t * deserialized_node;
      axiom_attribute_t * attr;
      axiom_element_t * element = axiom_element_create(m_env, NULL, "el", ns, &node);

      axiom_element_set_text(element, m_env, "T1 & T2", node);
      attr = axiom_attribute_create(m_env, "name", "A1 & A2", NULL);
      axiom_element_add_attribute(element, m_env, attr, node);

      axis2_char_t * xml = axiom_node_to_string(node, m_env);

      //TODO with libxml2, the order of the attrs is different, so this test fails.
      ASSERT_STREQ(xml, "<ns:el xmlns:ns=\"namespace\" name=\"A1 &amp; A2\">T1 &amp; T2</ns:el>");

      deserialized_node = axiom_node_create_from_buffer(m_env, xml);

      axiom_element_t * deserialized_element = (axiom_element_t*)axiom_node_get_data_element(deserialized_node, m_env);

      attribute = axiom_element_get_attribute_value_by_name(deserialized_element, m_env,"name");
      char * text = axiom_element_get_text(deserialized_element, m_env, deserialized_node);

      ASSERT_STREQ(attribute, "A1 & A2");
      ASSERT_STREQ(text, "T1 & T2");

      axiom_node_free_tree(deserialized_node, m_env);
      axiom_node_free_tree(node, m_env);
      axiom_namespace_free(ns, m_env);
      AXIS2_FREE(m_allocator, xml);
 }

 TEST_F(TestOM, test_attribute)
 {
     axiom_attribute_t *attr;
     axiom_namespace_t * ns1;
     axiom_namespace_t * ns2;

     ns1 = axiom_namespace_create(m_env, "urn:123456", "abc");
     ASSERT_NE(ns1, nullptr);

     attr = axiom_attribute_create(m_env, "foo", "bar", ns1);
     ASSERT_NE(attr, nullptr);

     ASSERT_STREQ("foo", axiom_attribute_get_localname(attr, m_env));
     ASSERT_STREQ("bar", axiom_attribute_get_value(attr, m_env));
     ns2 = axiom_attribute_get_namespace(attr, m_env);
     ASSERT_STREQ("abc", axiom_namespace_get_prefix(ns2, m_env));
     ASSERT_STREQ("urn:123456", axiom_namespace_get_uri(ns2, m_env));


     //TODO set/check name, value, namespace
     //TODO set/check string functions?
     //TODO test clone

     //TODO free?  Also trace down other invalid free(s) in test (per valgrind)


 }

	/*
	* 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 <gtest/gtest.h>

	#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>

	/* FIXME
	* These tests exercise code, but don't actually check that the output is
	* correct. They didn't when they were in the old test format, either.
	*/

	class TestOM: public ::testing::Test
	{

	protected:
	void SetUp()
	{

	m_allocator = axutil_allocator_init(NULL);
	m_axis_log = axutil_log_create(m_allocator, NULL, NULL);
	m_error = axutil_error_create(m_allocator);

	m_env = axutil_env_create_with_error_log(m_allocator, m_error, m_axis_log);

	}

	void TearDown()
	{
	axutil_env_free(m_env);
	}


	axutil_allocator_t *m_allocator = NULL;
	axutil_env_t *m_env = NULL;
	axutil_error_t *m_error = NULL;
	axutil_log_t *m_axis_log = NULL;

	};

	TEST_F(TestOM, test_om_build) {

	char *filename = "../resources/xml/om/test.xml";

	FILE *f = NULL;
	axiom_element_t *ele1 = NULL;
	axiom_element_t *ele2 = NULL;
	axiom_stax_builder_t *builder = NULL;
	axiom_text_t *text = NULL;
	axiom_document_t *document = NULL;
	axiom_node_t *node1 = NULL;
	axiom_node_t *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;

	/** create pull parser */
	reader =
	axiom_xml_reader_create_for_file(m_env, filename, NULL);
	ASSERT_NE(reader, nullptr);

	/** create axiom_stax_builder by parsing pull_parser struct */
	builder = axiom_stax_builder_create(m_env, reader);
	ASSERT_NE(builder, nullptr);

	/**
	create an om document
	document is the container of om model created using builder
	*/
	document = axiom_stax_builder_get_document(builder, m_env);
	ASSERT_NE(document, nullptr);

	node1 = axiom_document_get_root_element(document, m_env);
	ASSERT_NE(node1, nullptr);
	if (node1)
	{
	/** print root node information */
	ele1 = (axiom_element_t*)axiom_node_get_data_element(node1, m_env);
	if (ele1)
	{
	printf("root localname %s\n",
	axiom_element_get_localname(ele1, m_env));

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

	ns = axiom_element_get_namespace(ele1, m_env, node1);

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

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

	}

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

	node2 = axiom_document_build_next(document, m_env);
	do
	{

	if (!node2)
	break;

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

	}



	if (!node3)
	node3 = node2;

	break;
	case AXIOM_TEXT:

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

	default:
	break;
	}

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

	printf("Serialize pulled document\n");

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

	axiom_node_serialize_sub_tree(node3, m_env, om_output);

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

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

	axiom_output_free(om_output, m_env);

	axiom_stax_builder_free(builder, m_env);

	printf("\nend test_om_build\n");
	}


	TEST_F(TestOM, 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(m_env,
	"http://ws.apache.org/axis2/c/om", "axiom");
	ns2 = axiom_namespace_create(m_env, "urn:ISBN:0-395-74341-6", "isbn");
	ele1 = axiom_element_create(m_env, NULL, "book", ns1, &node1);
	axiom_element_declare_namespace(ele1, m_env, node1, ns2);

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

	axiom_element_add_attribute(ele2, m_env, attr1, node2);

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

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

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

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

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

	axiom_element_add_attribute(ele4, m_env, attr1, node6);

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

	axiom_element_add_attribute(ele4, m_env, attr2, node6);

	data_source = axiom_data_source_create(m_env, node1, &node6);
	stream = axiom_data_source_get_stream(data_source, m_env);
	if (stream)
	{
	axutil_stream_write(stream, m_env,
	"<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(m_env, NULL, AXIS2_TRUE, 0,
	AXIS2_XML_PARSER_TYPE_BUFFER);
	om_output = axiom_output_create(m_env, writer);

	printf("Serialize built document\n");
	status = axiom_node_serialize(node1, m_env, om_output);
	ASSERT_EQ(status, AXIS2_SUCCESS);

	printf("\naxiom_node_serialize success\n");
	/* end serializing stuff */

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

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

	printf("\nend test_om_serialize\n");

	axiom_namespace_free(ns1, m_env);
	axiom_namespace_free(ns2, m_env);
	}


	TEST_F(TestOM, 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(m_env, xml);

	output = axiom_node_to_string(om_node,m_env);

	ASSERT_EQ(0, axutil_strcmp(xml,xml_unaltered));

	ASSERT_EQ(0, axutil_strcmp(output,xml_unaltered));

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

	printf("\nend test_om_bufer\n");

	return;
	}

	/* AXIS2C-1627 */
	TEST_F(TestOM, test_attr_special_chars)
	{
	axiom_namespace_t * ns = axiom_namespace_create(m_env, "namespace", "ns");

	char * attribute;
	axiom_node_t * node;
	axiom_node_t * deserialized_node;
	axiom_attribute_t * attr;
	axiom_element_t * element = axiom_element_create(m_env, NULL, "el", ns, &node);

	axiom_element_set_text(element, m_env, "T1 & T2", node);
	attr = axiom_attribute_create(m_env, "name", "A1 & A2", NULL);
	axiom_element_add_attribute(element, m_env, attr, node);

	axis2_char_t * xml = axiom_node_to_string(node, m_env);

	//TODO with libxml2, the order of the attrs is different, so this test fails.
	ASSERT_STREQ(xml, "<ns:el xmlns:ns=\"namespace\" name=\"A1 & A2\">T1 & T2</ns:el>");

	deserialized_node = axiom_node_create_from_buffer(m_env, xml);

	axiom_element_t * deserialized_element = (axiom_element_t*)axiom_node_get_data_element(deserialized_node, m_env);

	attribute = axiom_element_get_attribute_value_by_name(deserialized_element, m_env,"name");
	char * text = axiom_element_get_text(deserialized_element, m_env, deserialized_node);

	ASSERT_STREQ(attribute, "A1 & A2");
	ASSERT_STREQ(text, "T1 & T2");

	axiom_node_free_tree(deserialized_node, m_env);
	axiom_node_free_tree(node, m_env);
	axiom_namespace_free(ns, m_env);
	AXIS2_FREE(m_allocator, xml);
	}

	TEST_F(TestOM, test_attribute)
	{
	axiom_attribute_t *attr;
	axiom_namespace_t * ns1;
	axiom_namespace_t * ns2;

	ns1 = axiom_namespace_create(m_env, "urn:123456", "abc");
	ASSERT_NE(ns1, nullptr);

	attr = axiom_attribute_create(m_env, "foo", "bar", ns1);
	ASSERT_NE(attr, nullptr);

	ASSERT_STREQ("foo", axiom_attribute_get_localname(attr, m_env));
	ASSERT_STREQ("bar", axiom_attribute_get_value(attr, m_env));
	ns2 = axiom_attribute_get_namespace(attr, m_env);
	ASSERT_STREQ("abc", axiom_namespace_get_prefix(ns2, m_env));
	ASSERT_STREQ("urn:123456", axiom_namespace_get_uri(ns2, m_env));



	//TODO set/check name, value, namespace
	//TODO set/check string functions?
	//TODO test clone

	//TODO free? Also trace down other invalid free(s) in test (per valgrind)


	}