src/third_party/webrtc/libjingle/xmllite/xmlelement_unittest.cc

   1 /*
   2  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include <iostream>
  12 #include <sstream>
  13 #include <string>
  14 #include "webrtc/libjingle/xmllite/xmlelement.h"
  15 #include "webrtc/base/common.h"
  16 #include "webrtc/base/gunit.h"
  17 #include "webrtc/base/thread.h"
  18 #include "webrtc/test/testsupport/gtest_disable.h"
  19
  20 using buzz::QName;
  21 using buzz::XmlAttr;
  22 using buzz::XmlChild;
  23 using buzz::XmlElement;
  24
  25 std::ostream& operator<<(std::ostream& os, const QName& name) {
  26   os << name.Namespace() << ":" << name.LocalPart();
  27   return os;
  28 }
  29
  30 TEST(XmlElementTest, TestConstructors) {
  31   XmlElement elt(QName("google:test", "first"));
  32   EXPECT_EQ("<test:first xmlns:test=\"google:test\"/>", elt.Str());
  33
  34   XmlElement elt2(QName("google:test", "first"), true);
  35   EXPECT_EQ("<first xmlns=\"google:test\"/>", elt2.Str());
  36 }
  37
  38 TEST(XmlElementTest, TestAdd) {
  39   XmlElement elt(QName("google:test", "root"), true);
  40   elt.AddElement(new XmlElement(QName("google:test", "first")));
  41   elt.AddElement(new XmlElement(QName("google:test", "nested")), 1);
  42   elt.AddText("nested-value", 2);
  43   elt.AddText("between-", 1);
  44   elt.AddText("value", 1);
  45   elt.AddElement(new XmlElement(QName("google:test", "nested2")), 1);
  46   elt.AddElement(new XmlElement(QName("google:test", "second")));
  47   elt.AddText("init-value", 1);
  48   elt.AddElement(new XmlElement(QName("google:test", "nested3")), 1);
  49   elt.AddText("trailing-value", 1);
  50
  51   // make sure it looks ok overall
  52   EXPECT_EQ("<root xmlns=\"google:test\">"
  53         "<first><nested>nested-value</nested>between-value<nested2/></first>"
  54         "<second>init-value<nested3/>trailing-value</second></root>",
  55         elt.Str());
  56
  57   // make sure text was concatenated
  58   XmlChild * pchild =
  59     elt.FirstChild()->AsElement()->FirstChild()->NextChild();
  60   EXPECT_TRUE(pchild->IsText());
  61   EXPECT_EQ("between-value", pchild->AsText()->Text());
  62 }
  63
  64 TEST(XmlElementTest, TestAttrs) {
  65   XmlElement elt(QName("", "root"));
  66   elt.SetAttr(QName("", "a"), "avalue");
  67   EXPECT_EQ("<root a=\"avalue\"/>", elt.Str());
  68
  69   elt.SetAttr(QName("", "b"), "bvalue");
  70   EXPECT_EQ("<root a=\"avalue\" b=\"bvalue\"/>", elt.Str());
  71
  72   elt.SetAttr(QName("", "a"), "avalue2");
  73   EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue\"/>", elt.Str());
  74
  75   elt.SetAttr(QName("", "b"), "bvalue2");
  76   EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\"/>", elt.Str());
  77
  78   elt.SetAttr(QName("", "c"), "cvalue");
  79   EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\" c=\"cvalue\"/>", elt.Str());
  80
  81   XmlAttr * patt = elt.FirstAttr();
  82   EXPECT_EQ(QName("", "a"), patt->Name());
  83   EXPECT_EQ("avalue2", patt->Value());
  84
  85   patt = patt->NextAttr();
  86   EXPECT_EQ(QName("", "b"), patt->Name());
  87   EXPECT_EQ("bvalue2", patt->Value());
  88
  89   patt = patt->NextAttr();
  90   EXPECT_EQ(QName("", "c"), patt->Name());
  91   EXPECT_EQ("cvalue", patt->Value());
  92
  93   patt = patt->NextAttr();
  94   EXPECT_TRUE(NULL == patt);
  95
  96   EXPECT_TRUE(elt.HasAttr(QName("", "a")));
  97   EXPECT_TRUE(elt.HasAttr(QName("", "b")));
  98   EXPECT_TRUE(elt.HasAttr(QName("", "c")));
  99   EXPECT_FALSE(elt.HasAttr(QName("", "d")));
 100
 101   elt.SetAttr(QName("", "d"), "dvalue");
 102   EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\" c=\"cvalue\" d=\"dvalue\"/>",
 103       elt.Str());
 104   EXPECT_TRUE(elt.HasAttr(QName("", "d")));
 105
 106   elt.ClearAttr(QName("", "z"));  // not found, no effect
 107   EXPECT_EQ("<root a=\"avalue2\" b=\"bvalue2\" c=\"cvalue\" d=\"dvalue\"/>",
 108       elt.Str());
 109
 110   elt.ClearAttr(QName("", "b"));
 111   EXPECT_EQ("<root a=\"avalue2\" c=\"cvalue\" d=\"dvalue\"/>", elt.Str());
 112
 113   elt.ClearAttr(QName("", "a"));
 114   EXPECT_EQ("<root c=\"cvalue\" d=\"dvalue\"/>", elt.Str());
 115
 116   elt.ClearAttr(QName("", "d"));
 117   EXPECT_EQ("<root c=\"cvalue\"/>", elt.Str());
 118
 119   elt.ClearAttr(QName("", "c"));
 120   EXPECT_EQ("<root/>", elt.Str());
 121 }
 122
 123 TEST(XmlElementTest, TestBodyText) {
 124   XmlElement elt(QName("", "root"));
 125   EXPECT_EQ("", elt.BodyText());
 126
 127   elt.AddText("body value text");
 128
 129   EXPECT_EQ("body value text", elt.BodyText());
 130
 131   elt.ClearChildren();
 132   elt.AddText("more value ");
 133   elt.AddText("text");
 134
 135   EXPECT_EQ("more value text", elt.BodyText());
 136
 137   elt.ClearChildren();
 138   elt.AddText("decoy");
 139   elt.AddElement(new XmlElement(QName("", "dummy")));
 140   EXPECT_EQ("", elt.BodyText());
 141
 142   elt.SetBodyText("replacement");
 143   EXPECT_EQ("replacement", elt.BodyText());
 144
 145   elt.SetBodyText("");
 146   EXPECT_TRUE(NULL == elt.FirstChild());
 147
 148   elt.SetBodyText("goodbye");
 149   EXPECT_EQ("goodbye", elt.FirstChild()->AsText()->Text());
 150   EXPECT_EQ("goodbye", elt.BodyText());
 151 }
 152
 153 TEST(XmlElementTest, TestCopyConstructor) {
 154   XmlElement * element = XmlElement::ForStr(
 155       "<root xmlns='test-foo'>This is a <em a='avalue' b='bvalue'>"
 156       "little <b>little</b></em> test</root>");
 157
 158   XmlElement * pelCopy = new XmlElement(*element);
 159   EXPECT_EQ("<root xmlns=\"test-foo\">This is a <em a=\"avalue\" b=\"bvalue\">"
 160       "little <b>little</b></em> test</root>", pelCopy->Str());
 161   delete pelCopy;
 162
 163   pelCopy = new XmlElement(*(element->FirstChild()->NextChild()->AsElement()));
 164   EXPECT_EQ("<foo:em a=\"avalue\" b=\"bvalue\" xmlns:foo=\"test-foo\">"
 165       "little <foo:b>little</foo:b></foo:em>", pelCopy->Str());
 166
 167   XmlAttr * patt = pelCopy->FirstAttr();
 168   EXPECT_EQ(QName("", "a"), patt->Name());
 169   EXPECT_EQ("avalue", patt->Value());
 170
 171   patt = patt->NextAttr();
 172   EXPECT_EQ(QName("", "b"), patt->Name());
 173   EXPECT_EQ("bvalue", patt->Value());
 174
 175   patt = patt->NextAttr();
 176   EXPECT_TRUE(NULL == patt);
 177   delete pelCopy;
 178   delete element;
 179 }
 180
 181 TEST(XmlElementTest, TestNameSearch) {
 182   XmlElement * element = XmlElement::ForStr(
 183     "<root xmlns='test-foo'>"
 184       "<firstname>George</firstname>"
 185       "<middlename>X.</middlename>"
 186       "some text"
 187       "<lastname>Harrison</lastname>"
 188       "<firstname>John</firstname>"
 189       "<middlename>Y.</middlename>"
 190       "<lastname>Lennon</lastname>"
 191     "</root>");
 192   EXPECT_TRUE(NULL ==
 193       element->FirstNamed(QName("", "firstname")));
 194   EXPECT_EQ(element->FirstChild(),
 195       element->FirstNamed(QName("test-foo", "firstname")));
 196   EXPECT_EQ(element->FirstChild()->NextChild(),
 197       element->FirstNamed(QName("test-foo", "middlename")));
 198   EXPECT_EQ(element->FirstElement()->NextElement(),
 199       element->FirstNamed(QName("test-foo", "middlename")));
 200   EXPECT_EQ("Harrison",
 201       element->TextNamed(QName("test-foo", "lastname")));
 202   EXPECT_EQ(element->FirstElement()->NextElement()->NextElement(),
 203       element->FirstNamed(QName("test-foo", "lastname")));
 204   EXPECT_EQ("John", element->FirstNamed(QName("test-foo", "firstname"))->
 205       NextNamed(QName("test-foo", "firstname"))->BodyText());
 206   EXPECT_EQ("Y.", element->FirstNamed(QName("test-foo", "middlename"))->
 207       NextNamed(QName("test-foo", "middlename"))->BodyText());
 208   EXPECT_EQ("Lennon", element->FirstNamed(QName("test-foo", "lastname"))->
 209       NextNamed(QName("test-foo", "lastname"))->BodyText());
 210   EXPECT_TRUE(NULL == element->FirstNamed(QName("test-foo", "firstname"))->
 211       NextNamed(QName("test-foo", "firstname"))->
 212       NextNamed(QName("test-foo", "firstname")));
 213
 214   delete element;
 215 }
 216
 217 class XmlElementCreatorThread : public rtc::Thread {
 218  public:
 219   XmlElementCreatorThread(int count, buzz::QName qname) :
 220       count_(count), qname_(qname) {}
 221
 222   virtual ~XmlElementCreatorThread() {
 223     Stop();
 224   }
 225
 226   virtual void Run() {
 227     std::vector<buzz::XmlElement*> elems;
 228     for (int i = 0; i < count_; i++) {
 229       elems.push_back(new XmlElement(qname_));
 230     }
 231     for (int i = 0; i < count_; i++) {
 232       delete elems[i];
 233     }
 234   }
 235
 236  private:
 237   int count_;
 238   buzz::QName qname_;
 239 };
 240
 241 // If XmlElement creation and destruction isn't thread safe,
 242 // this test should crash.
 243 TEST(XmlElementTest, TestMultithread) {
 244   int thread_count = 2;  // Was 100, but that's too slow.
 245   int elem_count = 100;  // Was 100000, but that's too slow.
 246   buzz::QName qname("foo", "bar");
 247
 248   std::vector<rtc::Thread*> threads;
 249   for (int i = 0; i < thread_count; i++) {
 250     threads.push_back(
 251         new XmlElementCreatorThread(elem_count, qname));
 252     threads[i]->Start();
 253   }
 254
 255   for (int i = 0; i < thread_count; i++) {
 256     threads[i]->Stop();
 257     delete threads[i];
 258   }
 259 }