third_party/libjingle/source/talk/xmllite/xmlelement_unittest.cc - vendor/opensource/webrtc - Git at Google

 /*
  * libjingle
  * Copyright 2004, Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
  *     this list of conditions and the following disclaimer in the documentation
  *     and/or other materials provided with the distribution.
  *  3. The name of the author may not be used to endorse or promote products
  *     derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include <string>
 #include <sstream>
 #include <iostream>
 #include "talk/base/common.h"
 #include "talk/base/gunit.h"
 #include "talk/base/thread.h"
 #include "talk/xmllite/xmlelement.h"

 using buzz::QName;
 using buzz::XmlAttr;
 using buzz::XmlChild;
 using buzz::XmlElement;

 std::ostream& operator<<(std::ostream& os, const QName& name) {
   os << name.Namespace() << ":" << name.LocalPart();
   return os;
 }

 TEST(XmlElementTest, TestConstructors) {
   XmlElement elt(QName("google:test", "first"));
   EXPECT_EQ("<test:first xmlns:test=\"google:test\"/>", elt.Str());

   XmlElement elt2(QName("google:test", "first"), true);
   EXPECT_EQ("<first xmlns=\"google:test\"/>", elt2.Str());
 }

 TEST(XmlElementTest, TestAdd) {
   XmlElement elt(QName("google:test", "root"), true);
   elt.AddElement(new XmlElement(QName("google:test", "first")));
   elt.AddElement(new XmlElement(QName("google:test", "nested")), 1);
   elt.AddText("nested-value", 2);
   elt.AddText("between-", 1);
   elt.AddText("value", 1);
   elt.AddElement(new XmlElement(QName("google:test", "nested2")), 1);
   elt.AddElement(new XmlElement(QName("google:test", "second")));
   elt.AddText("init-value", 1);
   elt.AddElement(new XmlElement(QName("google:test", "nested3")), 1);
   elt.AddText("trailing-value", 1);

   // make sure it looks ok overall
   EXPECT_EQ("<root xmlns=\"google:test\">"
         "<first><nested>nested-value</nested>between-value<nested2/></first>"
         "<second>init-value<nested3/>trailing-value</second></root>",
         elt.Str());

   // make sure text was concatenated
   XmlChild * pchild =
     elt.FirstChild()->AsElement()->FirstChild()->NextChild();
   EXPECT_TRUE(pchild->IsText());
   EXPECT_EQ("between-value", pchild->AsText()->Text());
 }

 TEST(XmlElementTest, TestAttrs) {
   XmlElement elt(QName("", "root"));
   elt.SetAttr(QName("", "a"), "avalue");
   EXPECT_EQ("<root a=\"avalue\"/>", elt.Str());

   elt.SetAttr(QName("", "b"), "bvalue");
   EXPECT_EQ("<root a=\"avalue\" b=\"bvalue\"/>", elt.Str());

   elt.SetAttr(QName("", "a"), "avalue2");
   EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue\"/>", elt.Str());

   elt.SetAttr(QName("", "b"), "bvalue2");
   EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\"/>", elt.Str());

   elt.SetAttr(QName("", "c"), "cvalue");
   EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\" c=\"cvalue\"/>", elt.Str());

   XmlAttr * patt = elt.FirstAttr();
   EXPECT_EQ(QName("", "a"), patt->Name());
   EXPECT_EQ("avalue2", patt->Value());

   patt = patt->NextAttr();
   EXPECT_EQ(QName("", "b"), patt->Name());
   EXPECT_EQ("bvalue2", patt->Value());

   patt = patt->NextAttr();
   EXPECT_EQ(QName("", "c"), patt->Name());
   EXPECT_EQ("cvalue", patt->Value());

   patt = patt->NextAttr();
   EXPECT_TRUE(NULL == patt);

   EXPECT_TRUE(elt.HasAttr(QName("", "a")));
   EXPECT_TRUE(elt.HasAttr(QName("", "b")));
   EXPECT_TRUE(elt.HasAttr(QName("", "c")));
   EXPECT_FALSE(elt.HasAttr(QName("", "d")));

   elt.SetAttr(QName("", "d"), "dvalue");
   EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\" c=\"cvalue\" d=\"dvalue\"/>",
       elt.Str());
   EXPECT_TRUE(elt.HasAttr(QName("", "d")));

   elt.ClearAttr(QName("", "z"));  // not found, no effect
   EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\" c=\"cvalue\" d=\"dvalue\"/>",
       elt.Str());

   elt.ClearAttr(QName("", "b"));
   EXPECT_EQ("<root a=\"avalue2\" c=\"cvalue\" d=\"dvalue\"/>", elt.Str());

   elt.ClearAttr(QName("", "a"));
   EXPECT_EQ("<root c=\"cvalue\" d=\"dvalue\"/>", elt.Str());

   elt.ClearAttr(QName("", "d"));
   EXPECT_EQ("<root c=\"cvalue\"/>", elt.Str());

   elt.ClearAttr(QName("", "c"));
   EXPECT_EQ("<root/>", elt.Str());
 }

 TEST(XmlElementTest, TestBodyText) {
   XmlElement elt(QName("", "root"));
   EXPECT_EQ("", elt.BodyText());

   elt.AddText("body value text");

   EXPECT_EQ("body value text", elt.BodyText());

   elt.ClearChildren();
   elt.AddText("more value ");
   elt.AddText("text");

   EXPECT_EQ("more value text", elt.BodyText());

   elt.ClearChildren();
   elt.AddText("decoy");
   elt.AddElement(new XmlElement(QName("", "dummy")));
   EXPECT_EQ("", elt.BodyText());

   elt.SetBodyText("replacement");
   EXPECT_EQ("replacement", elt.BodyText());

   elt.SetBodyText("");
   EXPECT_TRUE(NULL == elt.FirstChild());

   elt.SetBodyText("goodbye");
   EXPECT_EQ("goodbye", elt.FirstChild()->AsText()->Text());
   EXPECT_EQ("goodbye", elt.BodyText());
 }

 TEST(XmlElementTest, TestCopyConstructor) {
   XmlElement * element = XmlElement::ForStr(
       "<root xmlns='test-foo'>This is a <em a='avalue' b='bvalue'>"
       "little <b>little</b></em> test</root>");

   XmlElement * pelCopy = new XmlElement(*element);
   EXPECT_EQ("<root xmlns=\"test-foo\">This is a <em a=\"avalue\" b=\"bvalue\">"
       "little <b>little</b></em> test</root>", pelCopy->Str());
   delete pelCopy;

   pelCopy = new XmlElement(*(element->FirstChild()->NextChild()->AsElement()));
   EXPECT_EQ("<foo:em a=\"avalue\" b=\"bvalue\" xmlns:foo=\"test-foo\">"
       "little <foo:b>little</foo:b></foo:em>", pelCopy->Str());

   XmlAttr * patt = pelCopy->FirstAttr();
   EXPECT_EQ(QName("", "a"), patt->Name());
   EXPECT_EQ("avalue", patt->Value());

   patt = patt->NextAttr();
   EXPECT_EQ(QName("", "b"), patt->Name());
   EXPECT_EQ("bvalue", patt->Value());

   patt = patt->NextAttr();
   EXPECT_TRUE(NULL == patt);
   delete pelCopy;
   delete element;
 }

 TEST(XmlElementTest, TestNameSearch) {
   XmlElement * element = XmlElement::ForStr(
     "<root xmlns='test-foo'>"
       "<firstname>George</firstname>"
       "<middlename>X.</middlename>"
       "some text"
       "<lastname>Harrison</lastname>"
       "<firstname>John</firstname>"
       "<middlename>Y.</middlename>"
       "<lastname>Lennon</lastname>"
     "</root>");
   EXPECT_TRUE(NULL ==
       element->FirstNamed(QName("", "firstname")));
   EXPECT_EQ(element->FirstChild(),
       element->FirstNamed(QName("test-foo", "firstname")));
   EXPECT_EQ(element->FirstChild()->NextChild(),
       element->FirstNamed(QName("test-foo", "middlename")));
   EXPECT_EQ(element->FirstElement()->NextElement(),
       element->FirstNamed(QName("test-foo", "middlename")));
   EXPECT_EQ("Harrison",
       element->TextNamed(QName("test-foo", "lastname")));
   EXPECT_EQ(element->FirstElement()->NextElement()->NextElement(),
       element->FirstNamed(QName("test-foo", "lastname")));
   EXPECT_EQ("John", element->FirstNamed(QName("test-foo", "firstname"))->
       NextNamed(QName("test-foo", "firstname"))->BodyText());
   EXPECT_EQ("Y.", element->FirstNamed(QName("test-foo", "middlename"))->
       NextNamed(QName("test-foo", "middlename"))->BodyText());
   EXPECT_EQ("Lennon", element->FirstNamed(QName("test-foo", "lastname"))->
       NextNamed(QName("test-foo", "lastname"))->BodyText());
   EXPECT_TRUE(NULL == element->FirstNamed(QName("test-foo", "firstname"))->
       NextNamed(QName("test-foo", "firstname"))->
       NextNamed(QName("test-foo", "firstname")));

   delete element;
 }

 class XmlElementCreatorThread : public talk_base::Thread {
  public:
   XmlElementCreatorThread(int count, buzz::QName qname) :
       count_(count), qname_(qname) {}

   virtual void Run() {
     std::vector<buzz::XmlElement*> elems;
     for (int i = 0; i < count_; i++) {
       elems.push_back(new XmlElement(qname_));
     }
     for (int i = 0; i < count_; i++) {
       delete elems[i];
     }
   }

  private:
   int count_;
   buzz::QName qname_;
 };

 // If XmlElement creation and destruction isn't thread safe,
 // this test should crash.
 TEST(XmlElementTest, TestMultithread) {
   int thread_count = 2;  // Was 100, but that's too slow.
   int elem_count = 100;  // Was 100000, but that's too slow.
   buzz::QName qname("foo", "bar");

   std::vector<talk_base::Thread*> threads;
   for (int i = 0; i < thread_count; i++) {
     threads.push_back(
         new XmlElementCreatorThread(elem_count, qname));
     threads[i]->Start();
   }

   for (int i = 0; i < thread_count; i++) {
     threads[i]->Stop();
     delete threads[i];
   }
 }
	/*
	* libjingle
	* Copyright 2004, Google Inc.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* 1. Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	* 3. The name of the author may not be used to endorse or promote products
	* derived from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
	* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
	* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include <string>
	#include <sstream>
	#include <iostream>
	#include "talk/base/common.h"
	#include "talk/base/gunit.h"
	#include "talk/base/thread.h"
	#include "talk/xmllite/xmlelement.h"

	using buzz::QName;
	using buzz::XmlAttr;
	using buzz::XmlChild;
	using buzz::XmlElement;

	std::ostream& operator<<(std::ostream& os, const QName& name) {
	os << name.Namespace() << ":" << name.LocalPart();
	return os;
	}

	TEST(XmlElementTest, TestConstructors) {
	XmlElement elt(QName("google:test", "first"));
	EXPECT_EQ("<test:first xmlns:test=\"google:test\"/>", elt.Str());

	XmlElement elt2(QName("google:test", "first"), true);
	EXPECT_EQ("<first xmlns=\"google:test\"/>", elt2.Str());
	}

	TEST(XmlElementTest, TestAdd) {
	XmlElement elt(QName("google:test", "root"), true);
	elt.AddElement(new XmlElement(QName("google:test", "first")));
	elt.AddElement(new XmlElement(QName("google:test", "nested")), 1);
	elt.AddText("nested-value", 2);
	elt.AddText("between-", 1);
	elt.AddText("value", 1);
	elt.AddElement(new XmlElement(QName("google:test", "nested2")), 1);
	elt.AddElement(new XmlElement(QName("google:test", "second")));
	elt.AddText("init-value", 1);
	elt.AddElement(new XmlElement(QName("google:test", "nested3")), 1);
	elt.AddText("trailing-value", 1);

	// make sure it looks ok overall
	EXPECT_EQ("<root xmlns=\"google:test\">"
	"<first><nested>nested-value</nested>between-value<nested2/></first>"
	"<second>init-value<nested3/>trailing-value</second></root>",
	elt.Str());

	// make sure text was concatenated
	XmlChild * pchild =
	elt.FirstChild()->AsElement()->FirstChild()->NextChild();
	EXPECT_TRUE(pchild->IsText());
	EXPECT_EQ("between-value", pchild->AsText()->Text());
	}

	TEST(XmlElementTest, TestAttrs) {
	XmlElement elt(QName("", "root"));
	elt.SetAttr(QName("", "a"), "avalue");
	EXPECT_EQ("<root a=\"avalue\"/>", elt.Str());

	elt.SetAttr(QName("", "b"), "bvalue");
	EXPECT_EQ("<root a=\"avalue\" b=\"bvalue\"/>", elt.Str());

	elt.SetAttr(QName("", "a"), "avalue2");
	EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue\"/>", elt.Str());

	elt.SetAttr(QName("", "b"), "bvalue2");
	EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\"/>", elt.Str());

	elt.SetAttr(QName("", "c"), "cvalue");
	EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\" c=\"cvalue\"/>", elt.Str());

	XmlAttr * patt = elt.FirstAttr();
	EXPECT_EQ(QName("", "a"), patt->Name());
	EXPECT_EQ("avalue2", patt->Value());

	patt = patt->NextAttr();
	EXPECT_EQ(QName("", "b"), patt->Name());
	EXPECT_EQ("bvalue2", patt->Value());

	patt = patt->NextAttr();
	EXPECT_EQ(QName("", "c"), patt->Name());
	EXPECT_EQ("cvalue", patt->Value());

	patt = patt->NextAttr();
	EXPECT_TRUE(NULL == patt);

	EXPECT_TRUE(elt.HasAttr(QName("", "a")));
	EXPECT_TRUE(elt.HasAttr(QName("", "b")));
	EXPECT_TRUE(elt.HasAttr(QName("", "c")));
	EXPECT_FALSE(elt.HasAttr(QName("", "d")));

	elt.SetAttr(QName("", "d"), "dvalue");
	EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\" c=\"cvalue\" d=\"dvalue\"/>",
	elt.Str());
	EXPECT_TRUE(elt.HasAttr(QName("", "d")));

	elt.ClearAttr(QName("", "z")); // not found, no effect
	EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\" c=\"cvalue\" d=\"dvalue\"/>",
	elt.Str());

	elt.ClearAttr(QName("", "b"));
	EXPECT_EQ("<root a=\"avalue2\" c=\"cvalue\" d=\"dvalue\"/>", elt.Str());

	elt.ClearAttr(QName("", "a"));
	EXPECT_EQ("<root c=\"cvalue\" d=\"dvalue\"/>", elt.Str());

	elt.ClearAttr(QName("", "d"));
	EXPECT_EQ("<root c=\"cvalue\"/>", elt.Str());

	elt.ClearAttr(QName("", "c"));
	EXPECT_EQ("<root/>", elt.Str());
	}

	TEST(XmlElementTest, TestBodyText) {
	XmlElement elt(QName("", "root"));
	EXPECT_EQ("", elt.BodyText());

	elt.AddText("body value text");

	EXPECT_EQ("body value text", elt.BodyText());

	elt.ClearChildren();
	elt.AddText("more value ");
	elt.AddText("text");

	EXPECT_EQ("more value text", elt.BodyText());

	elt.ClearChildren();
	elt.AddText("decoy");
	elt.AddElement(new XmlElement(QName("", "dummy")));
	EXPECT_EQ("", elt.BodyText());

	elt.SetBodyText("replacement");
	EXPECT_EQ("replacement", elt.BodyText());

	elt.SetBodyText("");
	EXPECT_TRUE(NULL == elt.FirstChild());

	elt.SetBodyText("goodbye");
	EXPECT_EQ("goodbye", elt.FirstChild()->AsText()->Text());
	EXPECT_EQ("goodbye", elt.BodyText());
	}

	TEST(XmlElementTest, TestCopyConstructor) {
	XmlElement * element = XmlElement::ForStr(
	"<root xmlns='test-foo'>This is a <em a='avalue' b='bvalue'>"
	"little <b>little</b></em> test</root>");

	XmlElement * pelCopy = new XmlElement(*element);
	EXPECT_EQ("<root xmlns=\"test-foo\">This is a <em a=\"avalue\" b=\"bvalue\">"
	"little <b>little</b></em> test</root>", pelCopy->Str());
	delete pelCopy;

	pelCopy = new XmlElement(*(element->FirstChild()->NextChild()->AsElement()));
	EXPECT_EQ("<foo:em a=\"avalue\" b=\"bvalue\" xmlns:foo=\"test-foo\">"
	"little <foo:b>little</foo:b></foo:em>", pelCopy->Str());

	XmlAttr * patt = pelCopy->FirstAttr();
	EXPECT_EQ(QName("", "a"), patt->Name());
	EXPECT_EQ("avalue", patt->Value());

	patt = patt->NextAttr();
	EXPECT_EQ(QName("", "b"), patt->Name());
	EXPECT_EQ("bvalue", patt->Value());

	patt = patt->NextAttr();
	EXPECT_TRUE(NULL == patt);
	delete pelCopy;
	delete element;
	}

	TEST(XmlElementTest, TestNameSearch) {
	XmlElement * element = XmlElement::ForStr(
	"<root xmlns='test-foo'>"
	"<firstname>George</firstname>"
	"<middlename>X.</middlename>"
	"some text"
	"<lastname>Harrison</lastname>"
	"<firstname>John</firstname>"
	"<middlename>Y.</middlename>"
	"<lastname>Lennon</lastname>"
	"</root>");
	EXPECT_TRUE(NULL ==
	element->FirstNamed(QName("", "firstname")));
	EXPECT_EQ(element->FirstChild(),
	element->FirstNamed(QName("test-foo", "firstname")));
	EXPECT_EQ(element->FirstChild()->NextChild(),
	element->FirstNamed(QName("test-foo", "middlename")));
	EXPECT_EQ(element->FirstElement()->NextElement(),
	element->FirstNamed(QName("test-foo", "middlename")));
	EXPECT_EQ("Harrison",
	element->TextNamed(QName("test-foo", "lastname")));
	EXPECT_EQ(element->FirstElement()->NextElement()->NextElement(),
	element->FirstNamed(QName("test-foo", "lastname")));
	EXPECT_EQ("John", element->FirstNamed(QName("test-foo", "firstname"))->
	NextNamed(QName("test-foo", "firstname"))->BodyText());
	EXPECT_EQ("Y.", element->FirstNamed(QName("test-foo", "middlename"))->
	NextNamed(QName("test-foo", "middlename"))->BodyText());
	EXPECT_EQ("Lennon", element->FirstNamed(QName("test-foo", "lastname"))->
	NextNamed(QName("test-foo", "lastname"))->BodyText());
	EXPECT_TRUE(NULL == element->FirstNamed(QName("test-foo", "firstname"))->
	NextNamed(QName("test-foo", "firstname"))->
	NextNamed(QName("test-foo", "firstname")));

	delete element;
	}

	class XmlElementCreatorThread : public talk_base::Thread {
	public:
	XmlElementCreatorThread(int count, buzz::QName qname) :
	count_(count), qname_(qname) {}

	virtual void Run() {
	std::vector<buzz::XmlElement*> elems;
	for (int i = 0; i < count_; i++) {
	elems.push_back(new XmlElement(qname_));
	}
	for (int i = 0; i < count_; i++) {
	delete elems[i];
	}
	}

	private:
	int count_;
	buzz::QName qname_;
	};

	// If XmlElement creation and destruction isn't thread safe,
	// this test should crash.
	TEST(XmlElementTest, TestMultithread) {
	int thread_count = 2; // Was 100, but that's too slow.
	int elem_count = 100; // Was 100000, but that's too slow.
	buzz::QName qname("foo", "bar");

	std::vector<talk_base::Thread*> threads;
	for (int i = 0; i < thread_count; i++) {
	threads.push_back(
	new XmlElementCreatorThread(elem_count, qname));
	threads[i]->Start();
	}

	for (int i = 0; i < thread_count; i++) {
	threads[i]->Stop();
	delete threads[i];
	}
	}