lxml.tests.test_elementtree

Package lxml :: Package tests :: Module test_elementtree |
[hide private]
[frames] | no frames]

# Source Code for Module lxml.tests.test_elementtree

       1  # -*- coding: utf-8 -*-
       2
       3  """
       4  Tests for the ElementTree API
       5
       6  Only test cases that apply equally well to etree and ElementTree
       7  belong here. Note that there is a second test module called test_io.py
       8  for IO related test cases.
       9  """
      10
      11  import unittest
      12  import os, re, tempfile, copy, operator, gc, sys
      13
      14  this_dir = os.path.dirname(__file__)
      15  if this_dir not in sys.path:
      16      sys.path.insert(0, this_dir) # needed for Py3
      17
      18  from common_imports import StringIO, BytesIO, etree, ElementTree, cElementTree
      19  from common_imports import fileInTestDir, canonicalize, HelperTestCase
      20  from common_imports import _str, _bytes
      21
      22  if cElementTree is not None:
      23      if tuple([int(n) for n in
      24                getattr(cElementTree, "VERSION", "0.0").split(".")]) <= (1,0,7):
      25          cElementTree = None
      26
      27  try:
      28      reversed
      29  except NameError:
      30      # Python 2.3
      31 -    def reversed(seq):
      32          seq = list(seq)[::-1]
      33          return seq
      34
      35 -class ETreeTestCaseBase(HelperTestCase):
      36      etree = None
      37
      38 -    def test_element(self):
      39          for i in range(10):
      40              e = self.etree.Element('foo')
      41              self.assertEquals(e.tag, 'foo')
      42              self.assertEquals(e.text, None)
      43              self.assertEquals(e.tail, None)
      44
      45 -    def test_simple(self):
      46          Element = self.etree.Element
      47
      48          root = Element('root')
      49          root.append(Element('one'))
      50          root.append(Element('two'))
      51          root.append(Element('three'))
      52          self.assertEquals(3, len(root))
      53          self.assertEquals('one', root[0].tag)
      54          self.assertEquals('two', root[1].tag)
      55          self.assertEquals('three', root[2].tag)
      56          self.assertRaises(IndexError, operator.getitem, root, 3)
      57
      58      # test weird dictionary interaction leading to segfault previously
      59 -    def test_weird_dict_interaction(self):
      60          root = self.etree.Element('root')
      61          self.assertEquals(root.tag, "root")
      62          add = self.etree.ElementTree(file=BytesIO('<foo>Foo</foo>'))
      63          self.assertEquals(add.getroot().tag, "foo")
      64          self.assertEquals(add.getroot().text, "Foo")
      65          root.append(self.etree.Element('baz'))
      66          self.assertEquals(root.tag, "root")
      67          self.assertEquals(root[0].tag, "baz")
      68
      69 -    def test_subelement(self):
      70          Element = self.etree.Element
      71          SubElement = self.etree.SubElement
      72
      73          root = Element('root')
      74          SubElement(root, 'one')
      75          SubElement(root, 'two')
      76          SubElement(root, 'three')
      77          self.assertEquals(3, len(root))
      78          self.assertEquals('one', root[0].tag)
      79          self.assertEquals('two', root[1].tag)
      80          self.assertEquals('three', root[2].tag)
      81
      82 -    def test_element_contains(self):
      83          Element = self.etree.Element
      84          SubElement = self.etree.SubElement
      85
      86          root1 = Element('root')
      87          SubElement(root1, 'one')
      88          self.assert_(root1[0] in root1)
      89
      90          root2 = Element('root')
      91          SubElement(root2, 'two')
      92          SubElement(root2, 'three')
      93          self.assert_(root2[0] in root2)
      94          self.assert_(root2[1] in root2)
      95
      96          self.assertFalse(root1[0] in root2)
      97          self.assertFalse(root2[0] in root1)
      98          self.assertFalse(None in root2)
      99
     100 -    def test_element_indexing_with_text(self):
     101          ElementTree = self.etree.ElementTree
     102
     103          f = BytesIO('<doc>Test<one>One</one></doc>')
     104          doc = ElementTree(file=f)
     105          root = doc.getroot()
     106          self.assertEquals(1, len(root))
     107          self.assertEquals('one', root[0].tag)
     108          self.assertRaises(IndexError, operator.getitem, root, 1)
     109
     110 -    def test_element_indexing_with_text2(self):
     111          ElementTree = self.etree.ElementTree
     112
     113          f = BytesIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>')
     114          doc = ElementTree(file=f)
     115          root = doc.getroot()
     116          self.assertEquals(3, len(root))
     117          self.assertEquals('one', root[0].tag)
     118          self.assertEquals('two', root[1].tag)
     119          self.assertEquals('three', root[2].tag)
     120
     121 -    def test_element_indexing_only_text(self):
     122          ElementTree = self.etree.ElementTree
     123
     124          f = BytesIO('<doc>Test</doc>')
     125          doc = ElementTree(file=f)
     126          root = doc.getroot()
     127          self.assertEquals(0, len(root))
     128
     129 -    def test_element_indexing_negative(self):
     130          Element = self.etree.Element
     131          SubElement = self.etree.SubElement
     132          a = Element('a')
     133          b = SubElement(a, 'b')
     134          c = SubElement(a, 'c')
     135          d = SubElement(a, 'd')
     136          self.assertEquals(d, a[-1])
     137          self.assertEquals(c, a[-2])
     138          self.assertEquals(b, a[-3])
     139          self.assertRaises(IndexError, operator.getitem, a, -4)
     140          a[-1] = e = Element('e')
     141          self.assertEquals(e, a[-1])
     142          del a[-1]
     143          self.assertEquals(2, len(a))
     144
     145 -    def test_elementtree(self):
     146          ElementTree = self.etree.ElementTree
     147
     148          f = BytesIO('<doc><one>One</one><two>Two</two></doc>')
     149          doc = ElementTree(file=f)
     150          root = doc.getroot()
     151          self.assertEquals(2, len(root))
     152          self.assertEquals('one', root[0].tag)
     153          self.assertEquals('two', root[1].tag)
     154
     155 -    def test_text(self):
     156          ElementTree = self.etree.ElementTree
     157
     158          f = BytesIO('<doc>This is a text</doc>')
     159          doc = ElementTree(file=f)
     160          root = doc.getroot()
     161          self.assertEquals('This is a text', root.text)
     162
     163 -    def test_text_empty(self):
     164          ElementTree = self.etree.ElementTree
     165
     166          f = BytesIO('<doc></doc>')
     167          doc = ElementTree(file=f)
     168          root = doc.getroot()
     169          self.assertEquals(None, root.text)
     170
     171 -    def test_text_other(self):
     172          ElementTree = self.etree.ElementTree
     173
     174          f = BytesIO('<doc><one>One</one></doc>')
     175          doc = ElementTree(file=f)
     176          root = doc.getroot()
     177          self.assertEquals(None, root.text)
     178          self.assertEquals('One', root[0].text)
     179
     180 -    def test_text_escape_in(self):
     181          ElementTree = self.etree.ElementTree
     182
     183          f = BytesIO('<doc>This is &gt; than a text</doc>')
     184          doc = ElementTree(file=f)
     185          root = doc.getroot()
     186          self.assertEquals('This is > than a text', root.text)
     187
     188 -    def test_text_escape_out(self):
     189          Element = self.etree.Element
     190
     191          a = Element("a")
     192          a.text = "<>&"
     193          self.assertXML(_bytes('<a>&lt;&gt;&amp;</a>'),
     194                         a)
     195
     196 -    def test_text_escape_tostring(self):
     197          tostring = self.etree.tostring
     198          Element  = self.etree.Element
     199
     200          a = Element("a")
     201          a.text = "<>&"
     202          self.assertEquals(_bytes('<a>&lt;&gt;&amp;</a>'),
     203                           tostring(a))
     204
     205 -    def test_text_str_subclass(self):
     206          Element = self.etree.Element
     207
     208          class strTest(str):
     209              pass
     210
     211          a = Element("a")
     212          a.text = strTest("text")
     213          self.assertXML(_bytes('<a>text</a>'),
     214                         a)
     215
     216 -    def test_tail(self):
     217          ElementTree = self.etree.ElementTree
     218
     219          f = BytesIO('<doc>This is <i>mixed</i> content.</doc>')
     220          doc = ElementTree(file=f)
     221          root = doc.getroot()
     222          self.assertEquals(1, len(root))
     223          self.assertEquals('This is ', root.text)
     224          self.assertEquals(None, root.tail)
     225          self.assertEquals('mixed', root[0].text)
     226          self.assertEquals(' content.', root[0].tail)
     227
     228 -    def test_tail_str_subclass(self):
     229          Element = self.etree.Element
     230          SubElement = self.etree.SubElement
     231
     232          class strTest(str):
     233              pass
     234
     235          a = Element("a")
     236          SubElement(a, "t").tail = strTest("tail")
     237          self.assertXML(_bytes('<a><t></t>tail</a>'),
     238                         a)
     239
     240 -    def _test_del_tail(self):
     241          # this is discouraged for ET compat, should not be tested...
     242          XML = self.etree.XML
     243
     244          root = XML(_bytes('<doc>This is <i>mixed</i> content.</doc>'))
     245          self.assertEquals(1, len(root))
     246          self.assertEquals('This is ', root.text)
     247          self.assertEquals(None, root.tail)
     248          self.assertEquals('mixed', root[0].text)
     249          self.assertEquals(' content.', root[0].tail)
     250
     251          del root[0].tail
     252
     253          self.assertEquals(1, len(root))
     254          self.assertEquals('This is ', root.text)
     255          self.assertEquals(None, root.tail)
     256          self.assertEquals('mixed', root[0].text)
     257          self.assertEquals(None, root[0].tail)
     258
     259          root[0].tail = "TAIL"
     260
     261          self.assertEquals(1, len(root))
     262          self.assertEquals('This is ', root.text)
     263          self.assertEquals(None, root.tail)
     264          self.assertEquals('mixed', root[0].text)
     265          self.assertEquals('TAIL', root[0].tail)
     266
     267 -    def test_ElementTree(self):
     268          Element = self.etree.Element
     269          ElementTree = self.etree.ElementTree
     270
     271          el = Element('hoi')
     272          doc = ElementTree(el)
     273          root = doc.getroot()
     274          self.assertEquals(None, root.text)
     275          self.assertEquals('hoi', root.tag)
     276
     277 -    def test_attributes(self):
     278          ElementTree = self.etree.ElementTree
     279
     280          f = BytesIO('<doc one="One" two="Two"/>')
     281          doc = ElementTree(file=f)
     282          root = doc.getroot()
     283          self.assertEquals('One', root.attrib['one'])
     284          self.assertEquals('Two', root.attrib['two'])
     285          self.assertRaises(KeyError, operator.getitem, root.attrib, 'three')
     286
     287 -    def test_attributes2(self):
     288          ElementTree = self.etree.ElementTree
     289
     290          f = BytesIO('<doc one="One" two="Two"/>')
     291          doc = ElementTree(file=f)
     292          root = doc.getroot()
     293          self.assertEquals('One', root.attrib.get('one'))
     294          self.assertEquals('Two', root.attrib.get('two'))
     295          self.assertEquals(None, root.attrib.get('three'))
     296          self.assertEquals('foo', root.attrib.get('three', 'foo'))
     297
     298 -    def test_attributes3(self):
     299          ElementTree = self.etree.ElementTree
     300
     301          f = BytesIO('<doc one="One" two="Two"/>')
     302          doc = ElementTree(file=f)
     303          root = doc.getroot()
     304          self.assertEquals('One', root.get('one'))
     305          self.assertEquals('Two', root.get('two'))
     306          self.assertEquals(None, root.get('three'))
     307          self.assertEquals('foo', root.get('three', 'foo'))
     308
     309 -    def test_attrib_clear(self):
     310          XML = self.etree.XML
     311
     312          root = XML(_bytes('<doc one="One" two="Two"/>'))
     313          self.assertEquals('One', root.get('one'))
     314          self.assertEquals('Two', root.get('two'))
     315          root.attrib.clear()
     316          self.assertEquals(None, root.get('one'))
     317          self.assertEquals(None, root.get('two'))
     318
     319 -    def test_attrib_set_clear(self):
     320          Element = self.etree.Element
     321
     322          root = Element("root", one="One")
     323          root.set("two", "Two")
     324          self.assertEquals('One', root.get('one'))
     325          self.assertEquals('Two', root.get('two'))
     326          root.attrib.clear()
     327          self.assertEquals(None, root.get('one'))
     328          self.assertEquals(None, root.get('two'))
     329
     330 -    def test_attrib_ns_clear(self):
     331          Element = self.etree.Element
     332          SubElement = self.etree.SubElement
     333
     334          attribNS = '{http://foo/bar}x'
     335
     336          parent = Element('parent')
     337          parent.set(attribNS, 'a')
     338          child = SubElement(parent, 'child')
     339          child.set(attribNS, 'b')
     340
     341          self.assertEquals('a', parent.get(attribNS))
     342          self.assertEquals('b', child.get(attribNS))
     343
     344          parent.clear()
     345          self.assertEquals(None, parent.get(attribNS))
     346          self.assertEquals('b', child.get(attribNS))
     347
     348 -    def test_attrib_pop(self):
     349          ElementTree = self.etree.ElementTree
     350
     351          f = BytesIO('<doc one="One" two="Two"/>')
     352          doc = ElementTree(file=f)
     353          root = doc.getroot()
     354          self.assertEquals('One', root.attrib['one'])
     355          self.assertEquals('Two', root.attrib['two'])
     356
     357          self.assertEquals('One', root.attrib.pop('one'))
     358
     359          self.assertEquals(None, root.attrib.get('one'))
     360          self.assertEquals('Two', root.attrib['two'])
     361
     362 -    def test_attrib_pop_unknown(self):
     363          root = self.etree.XML(_bytes('<doc one="One" two="Two"/>'))
     364          self.assertRaises(KeyError, root.attrib.pop, 'NONE')
     365
     366          self.assertEquals('One', root.attrib['one'])
     367          self.assertEquals('Two', root.attrib['two'])
     368
     369 -    def test_attrib_pop_default(self):
     370          root = self.etree.XML(_bytes('<doc one="One" two="Two"/>'))
     371          self.assertEquals('Three', root.attrib.pop('three', 'Three'))
     372
     373 -    def test_attrib_pop_empty_default(self):
     374          root = self.etree.XML(_bytes('<doc/>'))
     375          self.assertEquals('Three', root.attrib.pop('three', 'Three'))
     376
     377 -    def test_attrib_pop_invalid_args(self):
     378          root = self.etree.XML(_bytes('<doc one="One" two="Two"/>'))
     379          self.assertRaises(TypeError, root.attrib.pop, 'One', None, None)
     380
     381 -    def test_attribute_update_dict(self):
     382          XML = self.etree.XML
     383
     384          root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>'))
     385          items = list(root.attrib.items())
     386          items.sort()
     387          self.assertEquals(
     388              [('alpha', 'Alpha'), ('beta', 'Beta')],
     389              items)
     390
     391          root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'})
     392
     393          items = list(root.attrib.items())
     394          items.sort()
     395          self.assertEquals(
     396              [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
     397              items)
     398
     399 -    def test_attribute_update_sequence(self):
     400          XML = self.etree.XML
     401
     402          root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>'))
     403          items = list(root.attrib.items())
     404          items.sort()
     405          self.assertEquals(
     406              [('alpha', 'Alpha'), ('beta', 'Beta')],
     407              items)
     408
     409          root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items())
     410
     411          items = list(root.attrib.items())
     412          items.sort()
     413          self.assertEquals(
     414              [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
     415              items)
     416
     417 -    def test_attribute_update_iter(self):
     418          XML = self.etree.XML
     419
     420          root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>'))
     421          items = list(root.attrib.items())
     422          items.sort()
     423          self.assertEquals(
     424              [('alpha', 'Alpha'), ('beta', 'Beta')],
     425              items)
     426
     427          root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items())
     428
     429          items = list(root.attrib.items())
     430          items.sort()
     431          self.assertEquals(
     432              [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')],
     433              items)
     434
     435 -    def test_attribute_keys(self):
     436          XML = self.etree.XML
     437
     438          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
     439          keys = root.attrib.keys()
     440          keys.sort()
     441          self.assertEquals(['alpha', 'beta', 'gamma'], keys)
     442
     443 -    def test_attribute_keys2(self):
     444          XML = self.etree.XML
     445
     446          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
     447          keys = root.keys()
     448          keys.sort()
     449          self.assertEquals(['alpha', 'beta', 'gamma'], keys)
     450
     451 -    def test_attribute_items2(self):
     452          XML = self.etree.XML
     453
     454          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
     455          items = list(root.items())
     456          items.sort()
     457          self.assertEquals(
     458              [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')],
     459              items)
     460
     461 -    def test_attribute_keys_ns(self):
     462          XML = self.etree.XML
     463
     464          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
     465          keys = root.keys()
     466          keys.sort()
     467          self.assertEquals(['bar', '{http://ns.codespeak.net/test}baz'],
     468                            keys)
     469
     470 -    def test_attribute_values(self):
     471          XML = self.etree.XML
     472
     473          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
     474          values = root.attrib.values()
     475          values.sort()
     476          self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)
     477
     478 -    def test_attribute_values_ns(self):
     479          XML = self.etree.XML
     480
     481          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
     482          values = root.attrib.values()
     483          values.sort()
     484          self.assertEquals(
     485              ['Bar', 'Baz'], values)
     486
     487 -    def test_attribute_items(self):
     488          XML = self.etree.XML
     489
     490          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
     491          items = list(root.attrib.items())
     492          items.sort()
     493          self.assertEquals([
     494              ('alpha', 'Alpha'),
     495              ('beta', 'Beta'),
     496              ('gamma', 'Gamma'),
     497              ],
     498              items)
     499
     500 -    def test_attribute_items_ns(self):
     501          XML = self.etree.XML
     502
     503          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
     504          items = list(root.attrib.items())
     505          items.sort()
     506          self.assertEquals(
     507              [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')],
     508              items)
     509
     510 -    def test_attribute_str(self):
     511          XML = self.etree.XML
     512
     513          expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}"
     514          alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}"
     515
     516          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
     517          try:
     518              self.assertEquals(expected, str(root.attrib))
     519          except AssertionError:
     520              self.assertEquals(alternative, str(root.attrib))
     521
     522 -    def test_attribute_has_key(self):
     523          XML = self.etree.XML
     524
     525          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
     526          self.assertEquals(
     527              True, root.attrib.has_key('bar'))
     528          self.assertEquals(
     529              False, root.attrib.has_key('baz'))
     530          self.assertEquals(
     531              False, root.attrib.has_key('hah'))
     532          self.assertEquals(
     533              True,
     534              root.attrib.has_key('{http://ns.codespeak.net/test}baz'))
     535
     536 -    def test_attribute_contains(self):
     537          XML = self.etree.XML
     538
     539          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
     540          self.assertEquals(
     541              True, 'bar' in root.attrib)
     542          self.assertEquals(
     543              False, 'baz' in root.attrib)
     544          self.assertEquals(
     545              False, 'hah' in root.attrib)
     546          self.assertEquals(
     547              True,
     548              '{http://ns.codespeak.net/test}baz' in root.attrib)
     549
     550 -    def test_attribute_set(self):
     551          Element = self.etree.Element
     552
     553          root = Element("root")
     554          root.set("attr", "TEST")
     555          self.assertEquals("TEST", root.get("attr"))
     556
     557 -    def test_del_attribute_ns(self):
     558          Element = self.etree.Element
     559
     560          a = Element('a')
     561          a.attrib['{http://a/}foo'] = 'Foo'
     562          a.attrib['{http://a/}bar'] = 'Bar'
     563          self.assertEquals(None, a.get('foo'))
     564          self.assertEquals('Foo', a.get('{http://a/}foo'))
     565          self.assertEquals('Foo', a.attrib['{http://a/}foo'])
     566
     567          self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo')
     568          self.assertEquals('Foo', a.attrib['{http://a/}foo'])
     569
     570          del a.attrib['{http://a/}foo']
     571          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
     572
     573 -    def test_del_attribute_ns_parsed(self):
     574          XML = self.etree.XML
     575
     576          a = XML(_bytes('<a xmlns:nsa="http://a/" nsa:foo="FooNS" foo="Foo" />'))
     577
     578          self.assertEquals('Foo', a.attrib['foo'])
     579          self.assertEquals('FooNS', a.attrib['{http://a/}foo'])
     580
     581          del a.attrib['foo']
     582          self.assertEquals('FooNS', a.attrib['{http://a/}foo'])
     583          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
     584          self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo')
     585
     586          del a.attrib['{http://a/}foo']
     587          self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo')
     588          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
     589
     590          a = XML(_bytes('<a xmlns:nsa="http://a/" foo="Foo" nsa:foo="FooNS" />'))
     591
     592          self.assertEquals('Foo', a.attrib['foo'])
     593          self.assertEquals('FooNS', a.attrib['{http://a/}foo'])
     594
     595          del a.attrib['foo']
     596          self.assertEquals('FooNS', a.attrib['{http://a/}foo'])
     597          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
     598
     599          del a.attrib['{http://a/}foo']
     600          self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo')
     601          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
     602
     603 -    def test_XML(self):
     604          XML = self.etree.XML
     605
     606          root = XML(_bytes('<doc>This is a text.</doc>'))
     607          self.assertEquals(0, len(root))
     608          self.assertEquals('This is a text.', root.text)
     609
     610 -    def test_XMLID(self):
     611          XMLID = self.etree.XMLID
     612          XML   = self.etree.XML
     613          xml_text = _bytes('''
     614          <document>
     615            <h1 id="chapter1">...</h1>
     616            <p id="note1" class="note">...</p>
     617            <p>Regular paragraph.</p>
     618            <p xml:id="xmlid">XML:ID paragraph.</p>
     619            <p id="warn1" class="warning">...</p>
     620          </document>
     621          ''')
     622
     623          root, dic = XMLID(xml_text)
     624          root2 = XML(xml_text)
     625          self.assertEquals(self._writeElement(root),
     626                            self._writeElement(root2))
     627          expected = {
     628              "chapter1" : root[0],
     629              "note1"    : root[1],
     630              "warn1"    : root[4]
     631              }
     632          self.assertEquals(dic, expected)
     633
     634 -    def test_fromstring(self):
     635          fromstring = self.etree.fromstring
     636
     637          root = fromstring('<doc>This is a text.</doc>')
     638          self.assertEquals(0, len(root))
     639          self.assertEquals('This is a text.', root.text)
     640
     641 -    def test_fromstringlist(self):
     642          fromstringlist = self.etree.fromstringlist
     643
     644          root = fromstringlist(["<do", "c>T", "hi", "s is",
     645                                 " a text.<", "/doc", ">"])
     646          self.assertEquals(0, len(root))
     647          self.assertEquals('This is a text.', root.text)
     648
     649 -    def test_fromstringlist_characters(self):
     650          fromstringlist = self.etree.fromstringlist
     651
     652          root = fromstringlist(list('<doc>This is a text.</doc>'))
     653          self.assertEquals(0, len(root))
     654          self.assertEquals('This is a text.', root.text)
     655
     656 -    def test_fromstringlist_single(self):
     657          fromstringlist = self.etree.fromstringlist
     658
     659          root = fromstringlist(['<doc>This is a text.</doc>'])
     660          self.assertEquals(0, len(root))
     661          self.assertEquals('This is a text.', root.text)
     662
     663 -    def test_iselement(self):
     664          iselement = self.etree.iselement
     665          Element = self.etree.Element
     666          ElementTree = self.etree.ElementTree
     667          XML = self.etree.XML
     668          Comment = self.etree.Comment
     669          ProcessingInstruction = self.etree.ProcessingInstruction
     670
     671          el = Element('hoi')
     672          self.assert_(iselement(el))
     673
     674          el2 = XML(_bytes('<foo/>'))
     675          self.assert_(iselement(el2))
     676
     677          tree = ElementTree(element=Element('dag'))
     678          self.assert_(not iselement(tree))
     679          self.assert_(iselement(tree.getroot()))
     680
     681          c = Comment('test')
     682          self.assert_(iselement(c))
     683
     684          p = ProcessingInstruction("test", "some text")
     685          self.assert_(iselement(p))
     686
     687 -    def test_iteration(self):
     688          XML = self.etree.XML
     689
     690          root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
     691          result = []
     692          for el in root:
     693              result.append(el.tag)
     694          self.assertEquals(['one', 'two', 'three'], result)
     695
     696 -    def test_iteration_empty(self):
     697          XML = self.etree.XML
     698
     699          root = XML(_bytes('<doc></doc>'))
     700          result = []
     701          for el in root:
     702              result.append(el.tag)
     703          self.assertEquals([], result)
     704
     705 -    def test_iteration_text_only(self):
     706          XML = self.etree.XML
     707
     708          root = XML(_bytes('<doc>Text</doc>'))
     709          result = []
     710          for el in root:
     711              result.append(el.tag)
     712          self.assertEquals([], result)
     713
     714 -    def test_iteration_crash(self):
     715          # this would cause a crash in the past
     716          fromstring = self.etree.fromstring
     717          root = etree.fromstring('<html><p></p>x</html>')
     718          for elem in root:
     719              elem.tail = ''
     720
     721 -    def test_iteration_reversed(self):
     722          XML = self.etree.XML
     723          root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
     724          result = []
     725          for el in reversed(root):
     726              result.append(el.tag)
     727          self.assertEquals(['three', 'two', 'one'], result)
     728
     729 -    def test_iteration_subelement(self):
     730          XML = self.etree.XML
     731
     732          root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
     733          result = []
     734          add = True
     735          for el in root:
     736              result.append(el.tag)
     737              if add:
     738                  self.etree.SubElement(root, 'four')
     739                  add = False
     740          self.assertEquals(['one', 'two', 'three', 'four'], result)
     741
     742 -    def test_iteration_del_child(self):
     743          XML = self.etree.XML
     744
     745          root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>'))
     746          result = []
     747          for el in root:
     748              result.append(el.tag)
     749              del root[-1]
     750          self.assertEquals(['one', 'two'], result)
     751
     752 -    def test_iteration_double(self):
     753          XML = self.etree.XML
     754
     755          root = XML(_bytes('<doc><one/><two/></doc>'))
     756          result = []
     757          for el0 in root:
     758              result.append(el0.tag)
     759              for el1 in root:
     760                  result.append(el1.tag)
     761          self.assertEquals(['one','one', 'two', 'two', 'one', 'two'], result)
     762
     763 -    def test_attribute_iterator(self):
     764          XML = self.etree.XML
     765
     766          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />'))
     767          result = []
     768          for key in root.attrib:
     769              result.append(key)
     770          result.sort()
     771          self.assertEquals(['alpha', 'beta', 'gamma'], result)
     772
     773 -    def test_itertext(self):
     774          # ET 1.3+
     775          XML = self.etree.XML
     776          root = XML(_bytes("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>"))
     777
     778          text = list(root.itertext())
     779          self.assertEquals(["RTEXT", "ATAIL", "CTEXT", "CTAIL"],
     780                            text)
     781
     782 -    def test_itertext_child(self):
     783          # ET 1.3+
     784          XML = self.etree.XML
     785          root = XML(_bytes("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>"))
     786
     787          text = list(root[2].itertext())
     788          self.assertEquals(["CTEXT"],
     789                            text)
     790
     791 -    def test_findall(self):
     792          XML = self.etree.XML
     793          root = XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>'))
     794          self.assertEquals(len(list(root.findall("c"))), 1)
     795          self.assertEquals(len(list(root.findall(".//c"))), 2)
     796          self.assertEquals(len(list(root.findall(".//b"))), 3)
     797          self.assertEquals(len(list(root.findall(".//b"))[0]), 1)
     798          self.assertEquals(len(list(root.findall(".//b"))[1]), 0)
     799          self.assertEquals(len(list(root.findall(".//b"))[2]), 0)
     800
     801 -    def test_findall_ns(self):
     802          XML = self.etree.XML
     803          root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>'))
     804          self.assertEquals(len(list(root.findall(".//{X}b"))), 2)
     805          self.assertEquals(len(list(root.findall(".//b"))), 3)
     806          self.assertEquals(len(list(root.findall("b"))), 2)
     807
     808 -    def test_element_with_attributes_keywords(self):
     809          Element = self.etree.Element
     810
     811          el = Element('tag', foo='Foo', bar='Bar')
     812          self.assertEquals('Foo', el.attrib['foo'])
     813          self.assertEquals('Bar', el.attrib['bar'])
     814
     815 -    def test_element_with_attributes(self):
     816          Element = self.etree.Element
     817
     818          el = Element('tag', {'foo':'Foo', 'bar':'Bar'})
     819          self.assertEquals('Foo', el.attrib['foo'])
     820          self.assertEquals('Bar', el.attrib['bar'])
     821
     822 -    def test_element_with_attributes_ns(self):
     823          Element = self.etree.Element
     824
     825          el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'})
     826          self.assertEquals('Foo', el.attrib['{ns1}foo'])
     827          self.assertEquals('Bar', el.attrib['{ns2}bar'])
     828
     829 -    def test_subelement_with_attributes(self):
     830          Element =  self.etree.Element
     831          SubElement = self.etree.SubElement
     832
     833          el = Element('tag')
     834          SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz")
     835          self.assertEquals("Baz", el[0].attrib['baz'])
     836          self.assertEquals('Foo', el[0].attrib['foo'])
     837
     838 -    def test_subelement_with_attributes_ns(self):
     839          Element = self.etree.Element
     840          SubElement = self.etree.SubElement
     841
     842          el = Element('tag')
     843          SubElement(el, 'foo', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'})
     844          self.assertEquals('Foo', el[0].attrib['{ns1}foo'])
     845          self.assertEquals('Bar', el[0].attrib['{ns2}bar'])
     846
     847 -    def test_write(self):
     848          ElementTree = self.etree.ElementTree
     849          XML = self.etree.XML
     850
     851          for i in range(10):
     852              f = BytesIO()
     853              root = XML(_bytes('<doc%s>This is a test.</doc%s>' % (i, i)))
     854              tree = ElementTree(element=root)
     855              tree.write(f)
     856              data = f.getvalue()
     857              self.assertEquals(
     858                  _bytes('<doc%s>This is a test.</doc%s>' % (i, i)),
     859                  canonicalize(data))
     860
     861 -    def test_write_method_html(self):
     862          ElementTree = self.etree.ElementTree
     863          Element = self.etree.Element
     864          SubElement = self.etree.SubElement
     865
     866          html = Element('html')
     867          body = SubElement(html, 'body')
     868          p = SubElement(body, 'p')
     869          p.text = "html"
     870          SubElement(p, 'br').tail = "test"
     871
     872          tree = ElementTree(element=html)
     873          f = BytesIO()
     874          tree.write(f, method="html")
     875          data = f.getvalue().replace(_bytes('\n'),_bytes(''))
     876
     877          self.assertEquals(_bytes('<html><body><p>html<br>test</p></body></html>'),
     878                            data)
     879
     880 -    def test_write_method_text(self):
     881          ElementTree = self.etree.ElementTree
     882          Element = self.etree.Element
     883          SubElement = self.etree.SubElement
     884
     885          a = Element('a')
     886          a.text = "A"
     887          a.tail = "tail"
     888          b = SubElement(a, 'b')
     889          b.text = "B"
     890          b.tail = "TAIL"
     891          c = SubElement(a, 'c')
     892          c.text = "C"
     893
     894          tree = ElementTree(element=a)
     895          f = BytesIO()
     896          tree.write(f, method="text")
     897          data = f.getvalue()
     898
     899          self.assertEquals(_bytes('ABTAILCtail'),
     900                            data)
     901
     902 -    def test_write_fail(self):
     903          ElementTree = self.etree.ElementTree
     904          XML = self.etree.XML
     905
     906          tree = ElementTree( XML(_bytes('<doc>This is a test.</doc>')) )
     907          self.assertRaises(IOError, tree.write,
     908                            "definitely////\\-\\nonexisting\\-\\////FILE")
     909
     910      # this could trigger a crash, apparently because the document
     911      # reference was prematurely garbage collected
     912 -    def test_crash(self):
     913          Element = self.etree.Element
     914
     915          element = Element('tag')
     916          for i in range(10):
     917              element.attrib['key'] = 'value'
     918              value = element.attrib['key']
     919              self.assertEquals(value, 'value')
     920
     921      # from doctest; for some reason this caused crashes too
     922 -    def test_write_ElementTreeDoctest(self):
     923          Element = self.etree.Element
     924          ElementTree = self.etree.ElementTree
     925
     926          f = BytesIO()
     927          for i in range(10):
     928              element = Element('tag%s' % i)
     929              self._check_element(element)
     930              tree = ElementTree(element)
     931              tree.write(f)
     932              self._check_element_tree(tree)
     933
     934 -    def test_subelement_reference(self):
     935          Element = self.etree.Element
     936          SubElement = self.etree.SubElement
     937
     938          el = Element('foo')
     939          el2 = SubElement(el, 'bar')
     940          el3 = SubElement(el2, 'baz')
     941
     942          al = Element('foo2')
     943          al2 = SubElement(al, 'bar2')
     944          al3 = SubElement(al2, 'baz2')
     945
     946          # now move al2 into el
     947          el.append(al2)
     948
     949          # now change al3 directly
     950          al3.text = 'baz2-modified'
     951
     952          # it should have changed through this route too
     953          self.assertEquals(
     954              'baz2-modified',
     955              el[1][0].text)
     956
     957 -    def test_set_text(self):
     958          Element = self.etree.Element
     959          SubElement = self.etree.SubElement
     960
     961          a = Element('a')
     962          b = SubElement(a, 'b')
     963          a.text = 'hoi'
     964          self.assertEquals(
     965              'hoi',
     966              a.text)
     967          self.assertEquals(
     968              'b',
     969              a[0].tag)
     970
     971 -    def test_set_text2(self):
     972          Element = self.etree.Element
     973          SubElement = self.etree.SubElement
     974
     975          a = Element('a')
     976          a.text = 'hoi'
     977          b = SubElement(a ,'b')
     978          self.assertEquals(
     979              'hoi',
     980              a.text)
     981          self.assertEquals(
     982              'b',
     983              a[0].tag)
     984
     985 -    def test_set_text_none(self):
     986          Element = self.etree.Element
     987
     988          a = Element('a')
     989
     990          a.text = 'foo'
     991          a.text = None
     992
     993          self.assertEquals(
     994              None,
     995              a.text)
     996          self.assertXML(_bytes('<a></a>'), a)
     997
     998 -    def test_set_text_empty(self):
     999          Element = self.etree.Element
    1000
    1001          a = Element('a')
    1002          self.assertEquals(None, a.text)
    1003
    1004          a.text = ''
    1005          self.assertEquals('', a.text)
    1006          self.assertXML(_bytes('<a></a>'), a)
    1007
    1008 -    def test_tail1(self):
    1009          Element = self.etree.Element
    1010          SubElement = self.etree.SubElement
    1011
    1012          a = Element('a')
    1013          a.tail = 'dag'
    1014          self.assertEquals('dag',
    1015                            a.tail)
    1016          b = SubElement(a, 'b')
    1017          b.tail = 'hoi'
    1018          self.assertEquals('hoi',
    1019                            b.tail)
    1020          self.assertEquals('dag',
    1021                            a.tail)
    1022
    1023 -    def test_tail_append(self):
    1024          Element = self.etree.Element
    1025
    1026          a = Element('a')
    1027          b = Element('b')
    1028          b.tail = 'b_tail'
    1029          a.append(b)
    1030          self.assertEquals('b_tail',
    1031                            b.tail)
    1032
    1033 -    def test_tail_set_twice(self):
    1034          Element = self.etree.Element
    1035          SubElement = self.etree.SubElement
    1036
    1037          a = Element('a')
    1038          b = SubElement(a, 'b')
    1039          b.tail = 'foo'
    1040          b.tail = 'bar'
    1041          self.assertEquals('bar',
    1042                            b.tail)
    1043          self.assertXML(_bytes('<a><b></b>bar</a>'), a)
    1044
    1045 -    def test_tail_set_none(self):
    1046          Element = self.etree.Element
    1047          a = Element('a')
    1048          a.tail = 'foo'
    1049          a.tail = None
    1050          self.assertEquals(
    1051              None,
    1052              a.tail)
    1053          self.assertXML(_bytes('<a></a>'), a)
    1054
    1055 -    def test_extend(self):
    1056          root = self.etree.Element('foo')
    1057          for i in range(3):
    1058              element = self.etree.SubElement(root, 'a%s' % i)
    1059              element.text = "text%d" % i
    1060              element.tail = "tail%d" % i
    1061
    1062          elements = []
    1063          for i in range(3):
    1064              new_element = self.etree.Element("test%s" % i)
    1065              new_element.text = "TEXT%s" % i
    1066              new_element.tail = "TAIL%s" % i
    1067              elements.append(new_element)
    1068
    1069          root.extend(elements)
    1070
    1071          self.assertEquals(
    1072              ["a0", "a1", "a2", "test0", "test1", "test2"],
    1073              [ el.tag for el in root ])
    1074          self.assertEquals(
    1075              ["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"],
    1076              [ el.text for el in root ])
    1077          self.assertEquals(
    1078              ["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"],
    1079              [ el.tail for el in root ])
    1080
    1081 -    def test_comment(self):
    1082          Element = self.etree.Element
    1083          SubElement = self.etree.SubElement
    1084          Comment = self.etree.Comment
    1085
    1086          a = Element('a')
    1087          a.append(Comment('foo'))
    1088          self.assertEquals(a[0].tag, Comment)
    1089          self.assertEquals(a[0].text, 'foo')
    1090
    1091      # ElementTree < 1.3 adds whitespace around comments
    1092 -    def test_comment_text(self):
    1093          Element = self.etree.Element
    1094          SubElement = self.etree.SubElement
    1095          Comment = self.etree.Comment
    1096          tostring = self.etree.tostring
    1097
    1098          a = Element('a')
    1099          a.append(Comment('foo'))
    1100          self.assertEquals(a[0].text, 'foo')
    1101
    1102          self.assertEquals(
    1103              _bytes('<a><!--foo--></a>'),
    1104              tostring(a))
    1105
    1106          a[0].text = "TEST"
    1107          self.assertEquals(a[0].text, 'TEST')
    1108
    1109          self.assertEquals(
    1110              _bytes('<a><!--TEST--></a>'),
    1111              tostring(a))
    1112
    1113      # ElementTree < 1.3 adds whitespace around comments
    1114 -    def test_comment_whitespace(self):
    1115          Element = self.etree.Element
    1116          SubElement = self.etree.SubElement
    1117          Comment = self.etree.Comment
    1118          tostring = self.etree.tostring
    1119
    1120          a = Element('a')
    1121          a.append(Comment(' foo  '))
    1122          self.assertEquals(a[0].text, ' foo  ')
    1123          self.assertEquals(
    1124              _bytes('<a><!-- foo  --></a>'),
    1125              tostring(a))
    1126
    1127 -    def test_comment_nonsense(self):
    1128          Comment = self.etree.Comment
    1129          c = Comment('foo')
    1130          self.assertEquals({}, c.attrib)
    1131          self.assertEquals([], list(c.keys()))
    1132          self.assertEquals([], list(c.items()))
    1133          self.assertEquals(None, c.get('hoi'))
    1134          self.assertEquals(0, len(c))
    1135          # should not iterate
    1136          for i in c:
    1137              pass
    1138
    1139 -    def test_pi(self):
    1140          # lxml.etree separates target and text
    1141          Element = self.etree.Element
    1142          SubElement = self.etree.SubElement
    1143          ProcessingInstruction = self.etree.ProcessingInstruction
    1144
    1145          a = Element('a')
    1146          a.append(ProcessingInstruction('foo', 'some more text'))
    1147          self.assertEquals(a[0].tag, ProcessingInstruction)
    1148          self.assertXML(_bytes("<a><?foo some more text?></a>"),
    1149                         a)
    1150
    1151 -    def test_processinginstruction(self):
    1152          # lxml.etree separates target and text
    1153          Element = self.etree.Element
    1154          SubElement = self.etree.SubElement
    1155          ProcessingInstruction = self.etree.PI
    1156
    1157          a = Element('a')
    1158          a.append(ProcessingInstruction('foo', 'some more text'))
    1159          self.assertEquals(a[0].tag, ProcessingInstruction)
    1160          self.assertXML(_bytes("<a><?foo some more text?></a>"),
    1161                         a)
    1162
    1163 -    def test_pi_nonsense(self):
    1164          ProcessingInstruction = self.etree.ProcessingInstruction
    1165          pi = ProcessingInstruction('foo')
    1166          self.assertEquals({}, pi.attrib)
    1167          self.assertEquals([], list(pi.keys()))
    1168          self.assertEquals([], list(pi.items()))
    1169          self.assertEquals(None, pi.get('hoi'))
    1170          self.assertEquals(0, len(pi))
    1171          # should not iterate
    1172          for i in pi:
    1173              pass
    1174
    1175 -    def test_setitem(self):
    1176          Element = self.etree.Element
    1177          SubElement = self.etree.SubElement
    1178
    1179          a = Element('a')
    1180          b = SubElement(a, 'b')
    1181          c = Element('c')
    1182          a[0] = c
    1183          self.assertEquals(
    1184              c,
    1185              a[0])
    1186          self.assertXML(_bytes('<a><c></c></a>'),
    1187                         a)
    1188          self.assertXML(_bytes('<b></b>'),
    1189                         b)
    1190
    1191 -    def test_setitem2(self):
    1192          Element = self.etree.Element
    1193          SubElement = self.etree.SubElement
    1194
    1195          a = Element('a')
    1196          for i in range(5):
    1197              b = SubElement(a, 'b%s' % i)
    1198              c = SubElement(b, 'c')
    1199          for i in range(5):
    1200              d = Element('d')
    1201              e = SubElement(d, 'e')
    1202              a[i] = d
    1203          self.assertXML(
    1204              _bytes('<a><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d></a>'),
    1205              a)
    1206          self.assertXML(_bytes('<c></c>'),
    1207                         c)
    1208
    1209 -    def test_setitem_replace(self):
    1210          Element = self.etree.Element
    1211          SubElement = self.etree.SubElement
    1212
    1213          a = Element('a')
    1214          SubElement(a, 'b')
    1215          d = Element('d')
    1216          a[0] = d
    1217          self.assertXML(_bytes('<a><d></d></a>'), a)
    1218
    1219 -    def test_setitem_indexerror(self):
    1220          Element = self.etree.Element
    1221          SubElement = self.etree.SubElement
    1222
    1223          a = Element('a')
    1224          b = SubElement(a, 'b')
    1225
    1226          self.assertRaises(IndexError, operator.setitem, a, 1, Element('c'))
    1227
    1228 -    def test_setitem_tail(self):
    1229          Element = self.etree.Element
    1230          SubElement = self.etree.SubElement
    1231
    1232          a = Element('a')
    1233          b = SubElement(a, 'b')
    1234          b.tail = 'B2'
    1235          c = Element('c')
    1236          c.tail = 'C2'
    1237
    1238          a[0] = c
    1239          self.assertXML(
    1240              _bytes('<a><c></c>C2</a>'),
    1241              a)
    1242
    1243 -    def test_tag_write(self):
    1244          Element = self.etree.Element
    1245          SubElement = self.etree.SubElement
    1246
    1247          a = Element('a')
    1248          b = SubElement(a, 'b')
    1249
    1250          a.tag = 'c'
    1251
    1252          self.assertEquals(
    1253              'c',
    1254              a.tag)
    1255
    1256          self.assertXML(
    1257              _bytes('<c><b></b></c>'),
    1258              a)
    1259
    1260 -    def test_tag_reset_ns(self):
    1261          Element = self.etree.Element
    1262          SubElement = self.etree.SubElement
    1263          tostring = self.etree.tostring
    1264
    1265          a = Element('{a}a')
    1266          b1 = SubElement(a, '{a}b')
    1267          b2 = SubElement(a, '{b}b')
    1268
    1269          self.assertEquals('{a}b',  b1.tag)
    1270
    1271          b1.tag = 'c'
    1272
    1273          # can't use C14N here!
    1274          self.assertEquals('c', b1.tag)
    1275          self.assertEquals(_bytes('<c'), tostring(b1)[:2])
    1276          self.assert_(_bytes('<c') in tostring(a))
    1277
    1278 -    def test_tag_reset_root_ns(self):
    1279          Element = self.etree.Element
    1280          SubElement = self.etree.SubElement
    1281          tostring = self.etree.tostring
    1282
    1283          a = Element('{a}a')
    1284          b1 = SubElement(a, '{a}b')
    1285          b2 = SubElement(a, '{b}b')
    1286
    1287          a.tag = 'c'
    1288
    1289          self.assertEquals(
    1290              'c',
    1291              a.tag)
    1292
    1293          # can't use C14N here!
    1294          self.assertEquals('c',  a.tag)
    1295          self.assertEquals(_bytes('<c'), tostring(a)[:2])
    1296
    1297 -    def test_tag_str_subclass(self):
    1298          Element = self.etree.Element
    1299
    1300          class strTest(str):
    1301              pass
    1302
    1303          a = Element("a")
    1304          a.tag = strTest("TAG")
    1305          self.assertXML(_bytes('<TAG></TAG>'),
    1306                         a)
    1307
    1308 -    def test_delitem(self):
    1309          Element = self.etree.Element
    1310          SubElement = self.etree.SubElement
    1311
    1312          a = Element('a')
    1313          b = SubElement(a, 'b')
    1314          c = SubElement(a, 'c')
    1315          d = SubElement(a, 'd')
    1316
    1317          del a[1]
    1318          self.assertXML(
    1319              _bytes('<a><b></b><d></d></a>'),
    1320              a)
    1321
    1322          del a[0]
    1323          self.assertXML(
    1324              _bytes('<a><d></d></a>'),
    1325              a)
    1326
    1327          del a[0]
    1328          self.assertXML(
    1329              _bytes('<a></a>'),
    1330              a)
    1331          # move deleted element into other tree afterwards
    1332          other = Element('other')
    1333          other.append(c)
    1334          self.assertXML(
    1335              _bytes('<other><c></c></other>'),
    1336              other)
    1337
    1338 -    def test_del_insert(self):
    1339          Element = self.etree.Element
    1340          SubElement = self.etree.SubElement
    1341
    1342          a = Element('a')
    1343          b = SubElement(a, 'b')
    1344          bs = SubElement(b, 'bs')
    1345          c = SubElement(a, 'c')
    1346          cs = SubElement(c, 'cs')
    1347
    1348          el = a[0]
    1349          self.assertXML(
    1350              _bytes('<a><b><bs></bs></b><c><cs></cs></c></a>'),
    1351              a)
    1352          self.assertXML(_bytes('<b><bs></bs></b>'), b)
    1353          self.assertXML(_bytes('<c><cs></cs></c>'), c)
    1354
    1355          del a[0]
    1356          self.assertXML(
    1357              _bytes('<a><c><cs></cs></c></a>'),
    1358              a)
    1359          self.assertXML(_bytes('<b><bs></bs></b>'), b)
    1360          self.assertXML(_bytes('<c><cs></cs></c>'), c)
    1361
    1362          a.insert(0, el)
    1363          self.assertXML(
    1364              _bytes('<a><b><bs></bs></b><c><cs></cs></c></a>'),
    1365              a)
    1366          self.assertXML(_bytes('<b><bs></bs></b>'), b)
    1367          self.assertXML(_bytes('<c><cs></cs></c>'), c)
    1368
    1369 -    def test_del_setitem(self):
    1370          Element = self.etree.Element
    1371          SubElement = self.etree.SubElement
    1372
    1373          a = Element('a')
    1374          b = SubElement(a, 'b')
    1375          bs = SubElement(b, 'bs')
    1376          c = SubElement(a, 'c')
    1377          cs = SubElement(c, 'cs')
    1378
    1379          el = a[0]
    1380          del a[0]
    1381          a[0] = el
    1382          self.assertXML(
    1383              _bytes('<a><b><bs></bs></b></a>'),
    1384              a)
    1385          self.assertXML(_bytes('<b><bs></bs></b>'), b)
    1386          self.assertXML(_bytes('<c><cs></cs></c>'), c)
    1387
    1388 -    def test_del_setslice(self):
    1389          Element = self.etree.Element
    1390          SubElement = self.etree.SubElement
    1391
    1392          a = Element('a')
    1393          b = SubElement(a, 'b')
    1394          bs = SubElement(b, 'bs')
    1395          c = SubElement(a, 'c')
    1396          cs = SubElement(c, 'cs')
    1397
    1398          el = a[0]
    1399          del a[0]
    1400          a[0:0] = [el]
    1401          self.assertXML(
    1402              _bytes('<a><b><bs></bs></b><c><cs></cs></c></a>'),
    1403              a)
    1404          self.assertXML(_bytes('<b><bs></bs></b>'), b)
    1405          self.assertXML(_bytes('<c><cs></cs></c>'), c)
    1406
    1407 -    def test_replace_slice_tail(self):
    1408          XML = self.etree.XML
    1409          a = XML(_bytes('<a><b></b>B2<c></c>C2</a>'))
    1410          b, c = a
    1411
    1412          a[:] = []
    1413
    1414          self.assertEquals("B2", b.tail)
    1415          self.assertEquals("C2", c.tail)
    1416
    1417 -    def test_merge_namespaced_subtree_as_slice(self):
    1418          XML = self.etree.XML
    1419          root = XML(_bytes(
    1420              '<foo><bar xmlns:baz="http://huhu"><puh><baz:bump1 /><baz:bump2 /></puh></bar></foo>'))
    1421          root[:] = root.findall('.//puh') # delete bar from hierarchy
    1422
    1423          # previously, this lost a namespace declaration on bump2
    1424          result = self.etree.tostring(root)
    1425          foo = self.etree.fromstring(result)
    1426
    1427          self.assertEquals('puh', foo[0].tag)
    1428          self.assertEquals('{http://huhu}bump1', foo[0][0].tag)
    1429          self.assertEquals('{http://huhu}bump2', foo[0][1].tag)
    1430
    1431 -    def test_delitem_tail(self):
    1432          ElementTree = self.etree.ElementTree
    1433          f = BytesIO('<a><b></b>B2<c></c>C2</a>')
    1434          doc = ElementTree(file=f)
    1435          a = doc.getroot()
    1436          del a[0]
    1437          self.assertXML(
    1438              _bytes('<a><c></c>C2</a>'),
    1439              a)
    1440
    1441 -    def test_clear(self):
    1442          Element = self.etree.Element
    1443
    1444          a = Element('a')
    1445          a.text = 'foo'
    1446          a.tail = 'bar'
    1447          a.set('hoi', 'dag')
    1448          a.clear()
    1449          self.assertEquals(None, a.text)
    1450          self.assertEquals(None, a.tail)
    1451          self.assertEquals(None, a.get('hoi'))
    1452          self.assertEquals('a', a.tag)
    1453
    1454 -    def test_clear_sub(self):
    1455          Element = self.etree.Element
    1456          SubElement = self.etree.SubElement
    1457
    1458          a = Element('a')
    1459          a.text = 'foo'
    1460          a.tail = 'bar'
    1461          a.set('hoi', 'dag')
    1462          b = SubElement(a, 'b')
    1463          c = SubElement(b, 'c')
    1464          a.clear()
    1465          self.assertEquals(None, a.text)
    1466          self.assertEquals(None, a.tail)
    1467          self.assertEquals(None, a.get('hoi'))
    1468          self.assertEquals('a', a.tag)
    1469          self.assertEquals(0, len(a))
    1470          self.assertXML(_bytes('<a></a>'),
    1471                         a)
    1472          self.assertXML(_bytes('<b><c></c></b>'),
    1473                         b)
    1474
    1475 -    def test_clear_tail(self):
    1476          ElementTree = self.etree.ElementTree
    1477          f = BytesIO('<a><b></b>B2<c></c>C2</a>')
    1478          doc = ElementTree(file=f)
    1479          a = doc.getroot()
    1480          a.clear()
    1481          self.assertXML(
    1482              _bytes('<a></a>'),
    1483              a)
    1484
    1485 -    def test_insert(self):
    1486          Element = self.etree.Element
    1487          SubElement = self.etree.SubElement
    1488
    1489          a = Element('a')
    1490          b = SubElement(a, 'b')
    1491          c = SubElement(a, 'c')
    1492          d = Element('d')
    1493          a.insert(0, d)
    1494
    1495          self.assertEquals(
    1496              d,
    1497              a[0])
    1498
    1499          self.assertXML(
    1500              _bytes('<a><d></d><b></b><c></c></a>'),
    1501              a)
    1502
    1503          e = Element('e')
    1504          a.insert(2, e)
    1505          self.assertEquals(
    1506              e,
    1507              a[2])
    1508          self.assertXML(
    1509              _bytes('<a><d></d><b></b><e></e><c></c></a>'),
    1510              a)
    1511
    1512 -    def test_insert_beyond_index(self):
    1513          Element = self.etree.Element
    1514          SubElement = self.etree.SubElement
    1515
    1516          a = Element('a')
    1517          b = SubElement(a, 'b')
    1518          c = Element('c')
    1519
    1520          a.insert(2, c)
    1521          self.assertEquals(
    1522              c,
    1523              a[1])
    1524          self.assertXML(
    1525              _bytes('<a><b></b><c></c></a>'),
    1526              a)
    1527
    1528 -    def test_insert_negative(self):
    1529          Element = self.etree.Element
    1530          SubElement = self.etree.SubElement
    1531
    1532          a = Element('a')
    1533          b = SubElement(a, 'b')
    1534          c = SubElement(a, 'c')
    1535
    1536          d = Element('d')
    1537          a.insert(-1, d)
    1538          self.assertEquals(
    1539              d,
    1540              a[-2])
    1541          self.assertXML(
    1542              _bytes('<a><b></b><d></d><c></c></a>'),
    1543              a)
    1544
    1545 -    def test_insert_tail(self):
    1546          Element = self.etree.Element
    1547          SubElement = self.etree.SubElement
    1548
    1549          a = Element('a')
    1550          b = SubElement(a, 'b')
    1551
    1552          c = Element('c')
    1553          c.tail = 'C2'
    1554
    1555          a.insert(0, c)
    1556          self.assertXML(
    1557              _bytes('<a><c></c>C2<b></b></a>'),
    1558              a)
    1559
    1560 -    def test_remove(self):
    1561          Element = self.etree.Element
    1562          SubElement = self.etree.SubElement
    1563
    1564          a = Element('a')
    1565          b = SubElement(a, 'b')
    1566          c = SubElement(a, 'c')
    1567
    1568          a.remove(b)
    1569          self.assertEquals(
    1570              c,
    1571              a[0])
    1572          self.assertXML(
    1573              _bytes('<a><c></c></a>'),
    1574              a)
    1575
    1576 -    def test_remove_ns(self):
    1577          Element = self.etree.Element
    1578          SubElement = self.etree.SubElement
    1579
    1580          a = Element('{http://test}a')
    1581          b = SubElement(a, '{http://test}b')
    1582          c = SubElement(a, '{http://test}c')
    1583
    1584          a.remove(b)
    1585          self.assertXML(
    1586              _bytes('<ns0:a xmlns:ns0="http://test"><ns0:c></ns0:c></ns0:a>'),
    1587              a)
    1588          self.assertXML(
    1589              _bytes('<ns0:b xmlns:ns0="http://test"></ns0:b>'),
    1590              b)
    1591
    1592 -    def test_remove_nonexisting(self):
    1593          Element = self.etree.Element
    1594          SubElement = self.etree.SubElement
    1595
    1596          a = Element('a')
    1597          b = SubElement(a, 'b')
    1598          c = SubElement(a, 'c')
    1599          d = Element('d')
    1600          self.assertRaises(
    1601              ValueError, a.remove, d)
    1602
    1603 -    def test_remove_tail(self):
    1604          Element = self.etree.Element
    1605          SubElement = self.etree.SubElement
    1606
    1607          a = Element('a')
    1608          b = SubElement(a, 'b')
    1609          b.tail = 'b2'
    1610          a.remove(b)
    1611          self.assertXML(
    1612              _bytes('<a></a>'),
    1613              a)
    1614          self.assertEquals('b2', b.tail)
    1615
    1616 -    def _test_getchildren(self):
    1617          Element = self.etree.Element
    1618          SubElement = self.etree.SubElement
    1619
    1620          a = Element('a')
    1621          b = SubElement(a, 'b')
    1622          c = SubElement(a, 'c')
    1623          d = SubElement(b, 'd')
    1624          e = SubElement(c, 'e')
    1625          self.assertXML(
    1626              _bytes('<a><b><d></d></b><c><e></e></c></a>'),
    1627              a)
    1628          self.assertEquals(
    1629              [b, c],
    1630              a.getchildren())
    1631          self.assertEquals(
    1632              [d],
    1633              b.getchildren())
    1634          self.assertEquals(
    1635              [],
    1636              d.getchildren())
    1637
    1638 -    def test_makeelement(self):
    1639          Element = self.etree.Element
    1640
    1641          a = Element('a')
    1642          b = a.makeelement('c', {'hoi':'dag'})
    1643          self.assertXML(
    1644              _bytes('<c hoi="dag"></c>'),
    1645              b)
    1646
    1647 -    def test_iter(self):
    1648          Element = self.etree.Element
    1649          SubElement = self.etree.SubElement
    1650
    1651          a = Element('a')
    1652          b = SubElement(a, 'b')
    1653          c = SubElement(a, 'c')
    1654          d = SubElement(b, 'd')
    1655          e = SubElement(c, 'e')
    1656
    1657          self.assertEquals(
    1658              [a, b, d, c, e],
    1659              list(a.iter()))
    1660          self.assertEquals(
    1661              [d],
    1662              list(d.iter()))
    1663
    1664 -    def test_getiterator(self):
    1665          Element = self.etree.Element
    1666          SubElement = self.etree.SubElement
    1667
    1668          a = Element('a')
    1669          b = SubElement(a, 'b')
    1670          c = SubElement(a, 'c')
    1671          d = SubElement(b, 'd')
    1672          e = SubElement(c, 'e')
    1673
    1674          self.assertEquals(
    1675              [a, b, d, c, e],
    1676              list(a.getiterator()))
    1677          self.assertEquals(
    1678              [d],
    1679              list(d.getiterator()))
    1680
    1681 -    def test_getiterator_empty(self):
    1682          Element = self.etree.Element
    1683          SubElement = self.etree.SubElement
    1684
    1685          a = Element('a')
    1686          b = SubElement(a, 'b')
    1687          c = SubElement(a, 'c')
    1688          d = SubElement(b, 'd')
    1689          e = SubElement(c, 'e')
    1690
    1691          self.assertEquals(
    1692              [],
    1693              list(a.getiterator('none')))
    1694          self.assertEquals(
    1695              [],
    1696              list(e.getiterator('none')))
    1697          self.assertEquals(
    1698              [e],
    1699              list(e.getiterator()))
    1700
    1701 -    def test_getiterator_filter(self):
    1702          Element = self.etree.Element
    1703          SubElement = self.etree.SubElement
    1704
    1705          a = Element('a')
    1706          b = SubElement(a, 'b')
    1707          c = SubElement(a, 'c')
    1708          d = SubElement(b, 'd')
    1709          e = SubElement(c, 'e')
    1710
    1711          self.assertEquals(
    1712              [a],
    1713              list(a.getiterator('a')))
    1714          a2 = SubElement(e, 'a')
    1715          self.assertEquals(
    1716              [a, a2],
    1717              list(a.getiterator('a')))
    1718          self.assertEquals(
    1719              [a2],
    1720              list(c.getiterator('a')))
    1721
    1722 -    def test_getiterator_filter_all(self):
    1723          Element = self.etree.Element
    1724          SubElement = self.etree.SubElement
    1725
    1726          a = Element('a')
    1727          b = SubElement(a, 'b')
    1728          c = SubElement(a, 'c')
    1729          d = SubElement(b, 'd')
    1730          e = SubElement(c, 'e')
    1731
    1732          self.assertEquals(
    1733              [a, b, d, c, e],
    1734              list(a.getiterator('*')))
    1735
    1736 -    def test_getiterator_filter_comment(self):
    1737          Element = self.etree.Element
    1738          Comment = self.etree.Comment
    1739          SubElement = self.etree.SubElement
    1740
    1741          a = Element('a')
    1742          b = SubElement(a, 'b')
    1743          comment_b = Comment("TEST-b")
    1744          b.append(comment_b)
    1745
    1746          self.assertEquals(
    1747              [comment_b],
    1748              list(a.getiterator(Comment)))
    1749
    1750          comment_a = Comment("TEST-a")
    1751          a.append(comment_a)
    1752
    1753          self.assertEquals(
    1754              [comment_b, comment_a],
    1755              list(a.getiterator(Comment)))
    1756
    1757          self.assertEquals(
    1758              [comment_b],
    1759              list(b.getiterator(Comment)))
    1760
    1761 -    def test_getiterator_filter_pi(self):
    1762          Element = self.etree.Element
    1763          PI = self.etree.ProcessingInstruction
    1764          SubElement = self.etree.SubElement
    1765
    1766          a = Element('a')
    1767          b = SubElement(a, 'b')
    1768          pi_b = PI("TEST-b")
    1769          b.append(pi_b)
    1770
    1771          self.assertEquals(
    1772              [pi_b],
    1773              list(a.getiterator(PI)))
    1774
    1775          pi_a = PI("TEST-a")
    1776          a.append(pi_a)
    1777
    1778          self.assertEquals(
    1779              [pi_b, pi_a],
    1780              list(a.getiterator(PI)))
    1781
    1782          self.assertEquals(
    1783              [pi_b],
    1784              list(b.getiterator(PI)))
    1785
    1786 -    def test_getiterator_with_text(self):
    1787          Element = self.etree.Element
    1788          SubElement = self.etree.SubElement
    1789
    1790          a = Element('a')
    1791          a.text = 'a'
    1792          b = SubElement(a, 'b')
    1793          b.text = 'b'
    1794          b.tail = 'b1'
    1795          c = SubElement(a, 'c')
    1796          c.text = 'c'
    1797          c.tail = 'c1'
    1798          d = SubElement(b, 'd')
    1799          c.text = 'd'
    1800          c.tail = 'd1'
    1801          e = SubElement(c, 'e')
    1802          e.text = 'e'
    1803          e.tail = 'e1'
    1804
    1805          self.assertEquals(
    1806              [a, b, d, c, e],
    1807              list(a.getiterator()))
    1808          #self.assertEquals(
    1809          #    [d],
    1810          #    list(d.getiterator()))
    1811
    1812 -    def test_getiterator_filter_with_text(self):
    1813          Element = self.etree.Element
    1814          SubElement = self.etree.SubElement
    1815
    1816          a = Element('a')
    1817          a.text = 'a'
    1818          b = SubElement(a, 'b')
    1819          b.text = 'b'
    1820          b.tail = 'b1'
    1821          c = SubElement(a, 'c')
    1822          c.text = 'c'
    1823          c.tail = 'c1'
    1824          d = SubElement(b, 'd')
    1825          c.text = 'd'
    1826          c.tail = 'd1'
    1827          e = SubElement(c, 'e')
    1828          e.text = 'e'
    1829          e.tail = 'e1'
    1830
    1831          self.assertEquals(
    1832              [a],
    1833              list(a.getiterator('a')))
    1834          a2 = SubElement(e, 'a')
    1835          self.assertEquals(
    1836              [a, a2],
    1837              list(a.getiterator('a')))
    1838          self.assertEquals(
    1839              [a2],
    1840              list(e.getiterator('a')))
    1841
    1842 -    def test_attribute_manipulation(self):
    1843          Element = self.etree.Element
    1844
    1845          a = Element('a')
    1846          a.attrib['foo'] = 'Foo'
    1847          a.attrib['bar'] = 'Bar'
    1848          self.assertEquals('Foo', a.attrib['foo'])
    1849          del a.attrib['foo']
    1850          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
    1851
    1852 -    def test_getslice(self):
    1853          Element = self.etree.Element
    1854          SubElement = self.etree.SubElement
    1855
    1856          a = Element('a')
    1857          b = SubElement(a, 'b')
    1858          c = SubElement(a, 'c')
    1859          d = SubElement(a, 'd')
    1860
    1861          self.assertEquals(
    1862              [b, c],
    1863              a[0:2])
    1864          self.assertEquals(
    1865              [b, c, d],
    1866              a[:])
    1867          self.assertEquals(
    1868              [b, c, d],
    1869              a[:10])
    1870          self.assertEquals(
    1871              [b],
    1872              a[0:1])
    1873          self.assertEquals(
    1874              [],
    1875              a[10:12])
    1876
    1877 -    def test_getslice_negative(self):
    1878          Element = self.etree.Element
    1879          SubElement = self.etree.SubElement
    1880
    1881          a = Element('a')
    1882          b = SubElement(a, 'b')
    1883          c = SubElement(a, 'c')
    1884          d = SubElement(a, 'd')
    1885
    1886          self.assertEquals(
    1887              [d],
    1888              a[-1:])
    1889          self.assertEquals(
    1890              [c, d],
    1891              a[-2:])
    1892          self.assertEquals(
    1893              [c],
    1894              a[-2:-1])
    1895          self.assertEquals(
    1896              [b, c],
    1897              a[-3:-1])
    1898          self.assertEquals(
    1899              [b, c],
    1900              a[-3:2])
    1901
    1902 -    def test_getslice_step(self):
    1903          Element = self.etree.Element
    1904          SubElement = self.etree.SubElement
    1905
    1906          a = Element('a')
    1907          b = SubElement(a, 'b')
    1908          c = SubElement(a, 'c')
    1909          d = SubElement(a, 'd')
    1910          e = SubElement(a, 'e')
    1911
    1912          self.assertEquals(
    1913              [e,d,c,b],
    1914              a[::-1])
    1915          self.assertEquals(
    1916              [b,d],
    1917              a[::2])
    1918          self.assertEquals(
    1919              [e,c],
    1920              a[::-2])
    1921          self.assertEquals(
    1922              [d,c],
    1923              a[-2:0:-1])
    1924          self.assertEquals(
    1925              [e],
    1926              a[:1:-2])
    1927
    1928 -    def test_getslice_text(self):
    1929          ElementTree = self.etree.ElementTree
    1930
    1931          f = BytesIO('<a><b>B</b>B1<c>C</c>C1</a>')
    1932          doc = ElementTree(file=f)
    1933          a = doc.getroot()
    1934          b = a[0]
    1935          c = a[1]
    1936          self.assertEquals(
    1937              [b, c],
    1938              a[:])
    1939          self.assertEquals(
    1940              [b],
    1941              a[0:1])
    1942          self.assertEquals(
    1943              [c],
    1944              a[1:])
    1945
    1946 -    def test_comment_getitem_getslice(self):
    1947          Element = self.etree.Element
    1948          Comment = self.etree.Comment
    1949          SubElement = self.etree.SubElement
    1950
    1951          a = Element('a')
    1952          b = SubElement(a, 'b')
    1953          foo = Comment('foo')
    1954          a.append(foo)
    1955          c = SubElement(a, 'c')
    1956          self.assertEquals(
    1957              [b, foo, c],
    1958              a[:])
    1959          self.assertEquals(
    1960              foo,
    1961              a[1])
    1962          a[1] = new = Element('new')
    1963          self.assertEquals(
    1964              new,
    1965              a[1])
    1966          self.assertXML(
    1967              _bytes('<a><b></b><new></new><c></c></a>'),
    1968              a)
    1969
    1970 -    def test_delslice(self):
    1971          Element = self.etree.Element
    1972          SubElement = self.etree.SubElement
    1973
    1974          a = Element('a')
    1975          b = SubElement(a, 'b')
    1976          c = SubElement(a, 'c')
    1977          d = SubElement(a, 'd')
    1978          e = SubElement(a, 'e')
    1979
    1980          del a[1:3]
    1981          self.assertEquals(
    1982              [b, e],
    1983              list(a))
    1984
    1985 -    def test_delslice_negative1(self):
    1986          Element = self.etree.Element
    1987          SubElement = self.etree.SubElement
    1988
    1989          a = Element('a')
    1990          b = SubElement(a, 'b')
    1991          c = SubElement(a, 'c')
    1992          d = SubElement(a, 'd')
    1993          e = SubElement(a, 'e')
    1994
    1995          del a[1:-1]
    1996          self.assertEquals(
    1997              [b, e],
    1998              list(a))
    1999
    2000 -    def test_delslice_negative2(self):
    2001          Element = self.etree.Element
    2002          SubElement = self.etree.SubElement
    2003
    2004          a = Element('a')
    2005          b = SubElement(a, 'b')
    2006          c = SubElement(a, 'c')
    2007          d = SubElement(a, 'd')
    2008          e = SubElement(a, 'e')
    2009
    2010          del a[-3:-1]
    2011          self.assertEquals(
    2012              [b, e],
    2013              list(a))
    2014
    2015 -    def test_delslice_step(self):
    2016          Element = self.etree.Element
    2017          SubElement = self.etree.SubElement
    2018
    2019          a = Element('a')
    2020          b = SubElement(a, 'b')
    2021          c = SubElement(a, 'c')
    2022          d = SubElement(a, 'd')
    2023          e = SubElement(a, 'e')
    2024
    2025          del a[1::2]
    2026          self.assertEquals(
    2027              [b, d],
    2028              list(a))
    2029
    2030 -    def test_delslice_step_negative(self):
    2031          Element = self.etree.Element
    2032          SubElement = self.etree.SubElement
    2033
    2034          a = Element('a')
    2035          b = SubElement(a, 'b')
    2036          c = SubElement(a, 'c')
    2037          d = SubElement(a, 'd')
    2038          e = SubElement(a, 'e')
    2039
    2040          del a[::-1]
    2041          self.assertEquals(
    2042              [],
    2043              list(a))
    2044
    2045 -    def test_delslice_step_negative2(self):
    2046          Element = self.etree.Element
    2047          SubElement = self.etree.SubElement
    2048
    2049          a = Element('a')
    2050          b = SubElement(a, 'b')
    2051          c = SubElement(a, 'c')
    2052          d = SubElement(a, 'd')
    2053          e = SubElement(a, 'e')
    2054
    2055          del a[::-2]
    2056          self.assertEquals(
    2057              [b, d],
    2058              list(a))
    2059
    2060 -    def test_delslice_child_tail(self):
    2061          ElementTree = self.etree.ElementTree
    2062          f = BytesIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>')
    2063          doc = ElementTree(file=f)
    2064          a = doc.getroot()
    2065          del a[1:3]
    2066          self.assertXML(
    2067              _bytes('<a><b></b>B2<e></e>E2</a>'),
    2068              a)
    2069
    2070 -    def test_delslice_tail(self):
    2071          XML = self.etree.XML
    2072          a = XML(_bytes('<a><b></b>B2<c></c>C2</a>'))
    2073          b, c = a
    2074
    2075          del a[:]
    2076
    2077          self.assertEquals("B2", b.tail)
    2078          self.assertEquals("C2", c.tail)
    2079
    2080 -    def test_delslice_memory(self):
    2081          # this could trigger a crash
    2082          Element = self.etree.Element
    2083          SubElement = self.etree.SubElement
    2084          a = Element('a')
    2085          b = SubElement(a, 'b')
    2086          c = SubElement(b, 'c')
    2087          del b # no more reference to b
    2088          del a[:]
    2089          self.assertEquals('c', c.tag)
    2090
    2091 -    def test_setslice(self):
    2092          Element = self.etree.Element
    2093          SubElement = self.etree.SubElement
    2094
    2095          a = Element('a')
    2096          b = SubElement(a, 'b')
    2097          c = SubElement(a, 'c')
    2098          d = SubElement(a, 'd')
    2099
    2100          e = Element('e')
    2101          f = Element('f')
    2102          g = Element('g')
    2103
    2104          s = [e, f, g]
    2105          a[1:2] = s
    2106          self.assertEquals(
    2107              [b, e, f, g, d],
    2108              list(a))
    2109
    2110 -    def test_setslice_all(self):
    2111          Element = self.etree.Element
    2112          SubElement = self.etree.SubElement
    2113
    2114          a = Element('a')
    2115          b = SubElement(a, 'b')
    2116          c = SubElement(a, 'c')
    2117
    2118          e = Element('e')
    2119          f = Element('f')
    2120          g = Element('g')
    2121
    2122          s = [e, f, g]
    2123          a[:] = s
    2124          self.assertEquals(
    2125              [e, f, g],
    2126              list(a))
    2127
    2128 -    def test_setslice_all_empty(self):
    2129          Element = self.etree.Element
    2130          SubElement = self.etree.SubElement
    2131
    2132          a = Element('a')
    2133
    2134          e = Element('e')
    2135          f = Element('f')
    2136          g = Element('g')
    2137
    2138          s = [e, f, g]
    2139          a[:] = s
    2140          self.assertEquals(
    2141              [e, f, g],
    2142              list(a))
    2143
    2144 -    def test_setslice_all_replace(self):
    2145          Element = self.etree.Element
    2146          SubElement = self.etree.SubElement
    2147
    2148          a = Element('a')
    2149          b = SubElement(a, 'b')
    2150          c = SubElement(a, 'c')
    2151          d = SubElement(a, 'd')
    2152
    2153          s = [b, c, d]
    2154          a[:] = s
    2155          self.assertEquals(
    2156              [b, c, d],
    2157              list(a))
    2158
    2159 -    def test_setslice_all_replace_reversed(self):
    2160          Element = self.etree.Element
    2161          SubElement = self.etree.SubElement
    2162
    2163          a = Element('a')
    2164          b = SubElement(a, 'b')
    2165          c = SubElement(a, 'c')
    2166          d = SubElement(a, 'd')
    2167
    2168          s = [d, c, b]
    2169          a[:] = s
    2170          self.assertEquals(
    2171              [d, c, b],
    2172              list(a))
    2173
    2174 -    def test_setslice_all_replace_reversed_ns1(self):
    2175          Element = self.etree.Element
    2176          SubElement = self.etree.SubElement
    2177
    2178          a = Element('{ns}a')
    2179          b = SubElement(a, '{ns}b', {'{ns1}a1': 'test'})
    2180          c = SubElement(a, '{ns}c', {'{ns2}a2': 'test'})
    2181          d = SubElement(a, '{ns}d', {'{ns3}a3': 'test'})
    2182
    2183          s = [d, c, b]
    2184          a[:] = s
    2185          self.assertEquals(
    2186              [d, c, b],
    2187              list(a))
    2188          self.assertEquals(
    2189              ['{ns}d', '{ns}c', '{ns}b'],
    2190              [ child.tag for child in a ])
    2191
    2192          self.assertEquals(
    2193              [['{ns3}a3'], ['{ns2}a2'], ['{ns1}a1']],
    2194              [ child.attrib.keys() for child in a ])
    2195
    2196 -    def test_setslice_all_replace_reversed_ns2(self):
    2197          Element = self.etree.Element
    2198          SubElement = self.etree.SubElement
    2199
    2200          a = Element('{ns}a')
    2201          b = SubElement(a, '{ns1}b', {'{ns}a1': 'test'})
    2202          c = SubElement(a, '{ns2}c', {'{ns}a2': 'test'})
    2203          d = SubElement(a, '{ns3}d', {'{ns}a3': 'test'})
    2204
    2205          s = [d, c, b]
    2206          a[:] = s
    2207          self.assertEquals(
    2208              [d, c, b],
    2209              list(a))
    2210          self.assertEquals(
    2211              ['{ns3}d', '{ns2}c', '{ns1}b'],
    2212              [ child.tag for child in a ])
    2213
    2214          self.assertEquals(
    2215              [['{ns}a3'], ['{ns}a2'], ['{ns}a1']],
    2216              [ child.attrib.keys() for child in a ])
    2217
    2218 -    def test_setslice_end(self):
    2219          Element = self.etree.Element
    2220          SubElement = self.etree.SubElement
    2221
    2222          a = Element('a')
    2223          b = SubElement(a, 'b')
    2224          c = SubElement(a, 'c')
    2225
    2226          e = Element('e')
    2227          f = Element('f')
    2228          g = Element('g')
    2229          h = Element('h')
    2230
    2231          s = [e, f]
    2232          a[99:] = s
    2233          self.assertEquals(
    2234              [a, b, e, f],
    2235              list(a))
    2236
    2237          s = [g, h]
    2238          a[:0] = s
    2239          self.assertEquals(
    2240              [g, h, a, b, e, f],
    2241              list(a))
    2242
    2243 -    def test_setslice_single(self):
    2244          Element = self.etree.Element
    2245          SubElement = self.etree.SubElement
    2246
    2247          a = Element('a')
    2248          b = SubElement(a, 'b')
    2249          c = SubElement(a, 'c')
    2250
    2251          e = Element('e')
    2252          f = Element('f')
    2253
    2254          s = [e]
    2255          a[0:1] = s
    2256          self.assertEquals(
    2257              [e, c],
    2258              list(a))
    2259
    2260          s = [f]
    2261          a[1:2] = s
    2262          self.assertEquals(
    2263              [e, f],
    2264              list(a))
    2265
    2266 -    def test_setslice_tail(self):
    2267          ElementTree = self.etree.ElementTree
    2268          Element = self.etree.Element
    2269          f = BytesIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>')
    2270          doc = ElementTree(file=f)
    2271          a = doc.getroot()
    2272          x = Element('x')
    2273          y = Element('y')
    2274          z = Element('z')
    2275          x.tail = 'X2'
    2276          y.tail = 'Y2'
    2277          z.tail = 'Z2'
    2278          a[1:3] = [x, y, z]
    2279          self.assertXML(
    2280              _bytes('<a><b></b>B2<x></x>X2<y></y>Y2<z></z>Z2<e></e>E2</a>'),
    2281              a)
    2282
    2283 -    def test_setslice_negative(self):
    2284          Element = self.etree.Element
    2285          SubElement = self.etree.SubElement
    2286
    2287          a = Element('a')
    2288          b = SubElement(a, 'b')
    2289          c = SubElement(a, 'c')
    2290          d = SubElement(a, 'd')
    2291
    2292          x = Element('x')
    2293          y = Element('y')
    2294
    2295          a[1:-1] = [x, y]
    2296          self.assertEquals(
    2297              [b, x, y, d],
    2298              list(a))
    2299
    2300 -    def test_setslice_negative2(self):
    2301          Element = self.etree.Element
    2302          SubElement = self.etree.SubElement
    2303
    2304          a = Element('a')
    2305          b = SubElement(a, 'b')
    2306          c = SubElement(a, 'c')
    2307          d = SubElement(a, 'd')
    2308
    2309          x = Element('x')
    2310          y = Element('y')
    2311
    2312          a[1:-2] = [x, y]
    2313          self.assertEquals(
    2314              [b, x, y, c, d],
    2315              list(a))
    2316
    2317 -    def test_setslice_end(self):
    2318          Element = self.etree.Element
    2319          SubElement = self.etree.SubElement
    2320
    2321          a = Element('a')
    2322          b = SubElement(a, 'b')
    2323          c = SubElement(a, 'c')
    2324          d = SubElement(a, 'd')
    2325
    2326          e = Element('e')
    2327          f = Element('f')
    2328          g = Element('g')
    2329
    2330          s = [e, f, g]
    2331          a[3:] = s
    2332          self.assertEquals(
    2333              [b, c, d, e, f, g],
    2334              list(a))
    2335
    2336 -    def test_setslice_empty(self):
    2337          Element = self.etree.Element
    2338
    2339          a = Element('a')
    2340
    2341          b = Element('b')
    2342          c = Element('c')
    2343
    2344          a[:] = [b, c]
    2345          self.assertEquals(
    2346              [b, c],
    2347              list(a))
    2348
    2349 -    def test_tail_elementtree_root(self):
    2350          Element = self.etree.Element
    2351          ElementTree = self.etree.ElementTree
    2352
    2353          a = Element('a')
    2354          a.tail = 'A2'
    2355          t = ElementTree(element=a)
    2356          self.assertEquals('A2',
    2357                            a.tail)
    2358
    2359 -    def test_elementtree_getiterator(self):
    2360          Element = self.etree.Element
    2361          SubElement = self.etree.SubElement
    2362          ElementTree = self.etree.ElementTree
    2363
    2364          a = Element('a')
    2365          b = SubElement(a, 'b')
    2366          c = SubElement(a, 'c')
    2367          d = SubElement(b, 'd')
    2368          e = SubElement(c, 'e')
    2369          t = ElementTree(element=a)
    2370
    2371          self.assertEquals(
    2372              [a, b, d, c, e],
    2373              list(t.getiterator()))
    2374
    2375 -    def test_elementtree_getiterator_filter(self):
    2376          Element = self.etree.Element
    2377          SubElement = self.etree.SubElement
    2378          ElementTree = self.etree.ElementTree
    2379          a = Element('a')
    2380          b = SubElement(a, 'b')
    2381          c = SubElement(a, 'c')
    2382          d = SubElement(b, 'd')
    2383          e = SubElement(c, 'e')
    2384          t = ElementTree(element=a)
    2385
    2386          self.assertEquals(
    2387              [a],
    2388              list(t.getiterator('a')))
    2389          a2 = SubElement(e, 'a')
    2390          self.assertEquals(
    2391              [a, a2],
    2392              list(t.getiterator('a')))
    2393
    2394 -    def test_ns_access(self):
    2395          ElementTree = self.etree.ElementTree
    2396          ns = 'http://xml.infrae.com/1'
    2397          f = BytesIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns)
    2398          t = ElementTree(file=f)
    2399          a = t.getroot()
    2400          self.assertEquals('{%s}a' % ns,
    2401                            a.tag)
    2402          self.assertEquals('{%s}b' % ns,
    2403                            a[0].tag)
    2404
    2405 -    def test_ns_access2(self):
    2406          ElementTree = self.etree.ElementTree
    2407          ns = 'http://xml.infrae.com/1'
    2408          ns2 = 'http://xml.infrae.com/2'
    2409          f = BytesIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2))
    2410          t = ElementTree(file=f)
    2411          a = t.getroot()
    2412          self.assertEquals('{%s}a' % ns,
    2413                            a.tag)
    2414          self.assertEquals('{%s}b' % ns,
    2415                            a[0].tag)
    2416          self.assertEquals('{%s}b' % ns2,
    2417                            a[1].tag)
    2418
    2419 -    def test_ns_setting(self):
    2420          Element = self.etree.Element
    2421          SubElement = self.etree.SubElement
    2422          ns = 'http://xml.infrae.com/1'
    2423          ns2 = 'http://xml.infrae.com/2'
    2424          a = Element('{%s}a' % ns)
    2425          b = SubElement(a, '{%s}b' % ns2)
    2426          c = SubElement(a, '{%s}c' % ns)
    2427          self.assertEquals('{%s}a' % ns,
    2428                            a.tag)
    2429          self.assertEquals('{%s}b' % ns2,
    2430                            b.tag)
    2431          self.assertEquals('{%s}c' % ns,
    2432                            c.tag)
    2433          self.assertEquals('{%s}a' % ns,
    2434                            a.tag)
    2435          self.assertEquals('{%s}b' % ns2,
    2436                            b.tag)
    2437          self.assertEquals('{%s}c' % ns,
    2438                            c.tag)
    2439
    2440 -    def test_ns_tag_parse(self):
    2441          Element = self.etree.Element
    2442          SubElement = self.etree.SubElement
    2443          ElementTree = self.etree.ElementTree
    2444
    2445          ns = 'http://xml.infrae.com/1'
    2446          ns2 = 'http://xml.infrae.com/2'
    2447          f = BytesIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b><b></b></a>' % (ns, ns2))
    2448          t = ElementTree(file=f)
    2449
    2450          a = t.getroot()
    2451          self.assertEquals('{%s}a' % ns,
    2452                            a.tag)
    2453          self.assertEquals('{%s}b' % ns2,
    2454                            a[0].tag)
    2455          self.assertEquals('{%s}b' % ns,
    2456                            a[1].tag)
    2457
    2458 -    def test_ns_attr(self):
    2459          Element = self.etree.Element
    2460          ns = 'http://xml.infrae.com/1'
    2461          ns2 = 'http://xml.infrae.com/2'
    2462          a = Element('a')
    2463          a.set('{%s}foo' % ns, 'Foo')
    2464          a.set('{%s}bar' % ns2, 'Bar')
    2465          self.assertEquals(
    2466              'Foo',
    2467              a.get('{%s}foo' % ns))
    2468          self.assertEquals(
    2469              'Bar',
    2470              a.get('{%s}bar' % ns2))
    2471          try:
    2472              self.assertXML(
    2473                  _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2)),
    2474                  a)
    2475          except AssertionError:
    2476              self.assertXML(
    2477                  _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns)),
    2478                  a)
    2479
    2480 -    def test_ns_move(self):
    2481          Element = self.etree.Element
    2482          one = self.etree.fromstring(
    2483              _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>'))
    2484          baz = one[0][0]
    2485
    2486          two = Element('root')
    2487          two.append(baz)
    2488          # removing the originating document could cause a crash/error before
    2489          # as namespace is not moved along with it
    2490          del one, baz
    2491          self.assertEquals('{http://a.b.c}baz', two[0].tag)
    2492
    2493 -    def test_ns_decl_tostring(self):
    2494          tostring = self.etree.tostring
    2495          root = self.etree.XML(
    2496              _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>'))
    2497          baz = root[0][0]
    2498
    2499          nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"),
    2500                              tostring(baz))
    2501          self.assertEquals([_bytes("http://a.b.c")], nsdecl)
    2502
    2503 -    def test_ns_decl_tostring_default(self):
    2504          tostring = self.etree.tostring
    2505          root = self.etree.XML(
    2506              _bytes('<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>'))
    2507          baz = root[0][0]
    2508
    2509          nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"),
    2510                              tostring(baz))
    2511          self.assertEquals([_bytes("http://a.b.c")], nsdecl)
    2512
    2513 -    def test_ns_decl_tostring_root(self):
    2514          tostring = self.etree.tostring
    2515          root = self.etree.XML(
    2516              _bytes('<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>'))
    2517          baz = root[0][0]
    2518
    2519          nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"),
    2520                              tostring(baz))
    2521
    2522          self.assertEquals([_bytes("http://a.b.c")], nsdecl)
    2523
    2524 -    def test_ns_decl_tostring_element(self):
    2525          Element = self.etree.Element
    2526          SubElement = self.etree.SubElement
    2527
    2528          root = Element("foo")
    2529          bar = SubElement(root, "{http://a.b.c}bar")
    2530          baz = SubElement(bar, "{http://a.b.c}baz")
    2531
    2532          nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"),
    2533                              self.etree.tostring(baz))
    2534
    2535          self.assertEquals([_bytes("http://a.b.c")], nsdecl)
    2536
    2537 -    def test_attribute_xmlns_move(self):
    2538          Element = self.etree.Element
    2539
    2540          root = Element('element')
    2541
    2542          subelement = Element('subelement',
    2543                               {"{http://www.w3.org/XML/1998/namespace}id": "foo"})
    2544          self.assertEquals(1, len(subelement.attrib))
    2545          self.assertEquals(
    2546              "foo",
    2547              subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
    2548
    2549          root.append(subelement)
    2550          self.assertEquals(1, len(subelement.attrib))
    2551          self.assertEquals(
    2552              list({"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items()),
    2553              list(subelement.attrib.items()))
    2554          self.assertEquals(
    2555              "foo",
    2556              subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
    2557
    2558 -    def test_namespaces_after_serialize(self):
    2559          parse = self.etree.parse
    2560          tostring = self.etree.tostring
    2561
    2562          ns_href = "http://a.b.c"
    2563          one = parse(
    2564              BytesIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href))
    2565          baz = one.getroot()[0][0]
    2566
    2567          parsed = parse(BytesIO( tostring(baz) )).getroot()
    2568          self.assertEquals('{%s}baz' % ns_href, parsed.tag)
    2569
    2570 -    def test_tostring(self):
    2571          tostring = self.etree.tostring
    2572          Element = self.etree.Element
    2573          SubElement = self.etree.SubElement
    2574
    2575          a = Element('a')
    2576          b = SubElement(a, 'b')
    2577          c = SubElement(a, 'c')
    2578
    2579          self.assertEquals(_bytes('<a><b></b><c></c></a>'),
    2580                            canonicalize(tostring(a)))
    2581
    2582 -    def test_tostring_element(self):
    2583          tostring = self.etree.tostring
    2584          Element = self.etree.Element
    2585          SubElement = self.etree.SubElement
    2586
    2587          a = Element('a')
    2588          b = SubElement(a, 'b')
    2589          c = SubElement(a, 'c')
    2590          d = SubElement(c, 'd')
    2591          self.assertEquals(_bytes('<b></b>'),
    2592                            canonicalize(tostring(b)))
    2593          self.assertEquals(_bytes('<c><d></d></c>'),
    2594                            canonicalize(tostring(c)))
    2595
    2596 -    def test_tostring_element_tail(self):
    2597          tostring = self.etree.tostring
    2598          Element = self.etree.Element
    2599          SubElement = self.etree.SubElement
    2600
    2601          a = Element('a')
    2602          b = SubElement(a, 'b')
    2603          c = SubElement(a, 'c')
    2604          d = SubElement(c, 'd')
    2605          b.tail = 'Foo'
    2606
    2607          self.assert_(tostring(b) == _bytes('<b/>Foo') or
    2608                       tostring(b) == _bytes('<b />Foo'))
    2609
    2610 -    def test_tostring_method_html(self):
    2611          tostring = self.etree.tostring
    2612          Element = self.etree.Element
    2613          SubElement = self.etree.SubElement
    2614
    2615          html = Element('html')
    2616          body = SubElement(html, 'body')
    2617          p = SubElement(body, 'p')
    2618          p.text = "html"
    2619          SubElement(p, 'br').tail = "test"
    2620
    2621          self.assertEquals(_bytes('<html><body><p>html<br>test</p></body></html>'),
    2622                            tostring(html, method="html"))
    2623
    2624 -    def test_tostring_method_text(self):
    2625          tostring = self.etree.tostring
    2626          Element = self.etree.Element
    2627          SubElement = self.etree.SubElement
    2628
    2629          a = Element('a')
    2630          a.text = "A"
    2631          a.tail = "tail"
    2632          b = SubElement(a, 'b')
    2633          b.text = "B"
    2634          b.tail = "TAIL"
    2635          c = SubElement(a, 'c')
    2636          c.text = "C"
    2637
    2638          self.assertEquals(_bytes('ABTAILCtail'),
    2639                            tostring(a, method="text"))
    2640
    2641 -    def test_iterparse(self):
    2642          iterparse = self.etree.iterparse
    2643          f = BytesIO('<a><b></b><c/></a>')
    2644
    2645          iterator = iterparse(f)
    2646          self.assertEquals(None,
    2647                            iterator.root)
    2648          events = list(iterator)
    2649          root = iterator.root
    2650          self.assertEquals(
    2651              [('end', root[0]), ('end', root[1]), ('end', root)],
    2652              events)
    2653
    2654 -    def test_iterparse_file(self):
    2655          iterparse = self.etree.iterparse
    2656          iterator = iterparse(fileInTestDir("test.xml"))
    2657          self.assertEquals(None,
    2658                            iterator.root)
    2659          events = list(iterator)
    2660          root = iterator.root
    2661          self.assertEquals(
    2662              [('end', root[0]), ('end', root)],
    2663              events)
    2664
    2665 -    def test_iterparse_start(self):
    2666          iterparse = self.etree.iterparse
    2667          f = BytesIO('<a><b></b><c/></a>')
    2668
    2669          iterator = iterparse(f, events=('start',))
    2670          events = list(iterator)
    2671          root = iterator.root
    2672          self.assertEquals(
    2673              [('start', root), ('start', root[0]), ('start', root[1])],
    2674              events)
    2675
    2676 -    def test_iterparse_start_end(self):
    2677          iterparse = self.etree.iterparse
    2678          f = BytesIO('<a><b></b><c/></a>')
    2679
    2680          iterator = iterparse(f, events=('start','end'))
    2681          events = list(iterator)
    2682          root = iterator.root
    2683          self.assertEquals(
    2684              [('start', root), ('start', root[0]), ('end', root[0]),
    2685               ('start', root[1]), ('end', root[1]), ('end', root)],
    2686              events)
    2687
    2688 -    def test_iterparse_clear(self):
    2689          iterparse = self.etree.iterparse
    2690          f = BytesIO('<a><b></b><c/></a>')
    2691
    2692          iterator = iterparse(f)
    2693          for event, elem in iterator:
    2694              elem.clear()
    2695
    2696          root = iterator.root
    2697          self.assertEquals(0,
    2698                            len(root))
    2699
    2700 -    def test_iterparse_large(self):
    2701          iterparse = self.etree.iterparse
    2702          CHILD_COUNT = 12345
    2703          f = BytesIO('<a>%s</a>' % ('<b>test</b>'*CHILD_COUNT))
    2704
    2705          i = 0
    2706          for key in iterparse(f):
    2707              event, element = key
    2708              i += 1
    2709          self.assertEquals(i, CHILD_COUNT + 1)
    2710
    2711 -    def test_iterparse_attrib_ns(self):
    2712          iterparse = self.etree.iterparse
    2713          f = BytesIO('<a xmlns="http://ns1/"><b><c xmlns="http://ns2/"/></b></a>')
    2714
    2715          attr_name = '{http://testns/}bla'
    2716          events = []
    2717          iterator = iterparse(f, events=('start','end','start-ns','end-ns'))
    2718          for event, elem in iterator:
    2719              events.append(event)
    2720              if event == 'start':
    2721                  if elem.tag != '{http://ns1/}a':
    2722                      elem.set(attr_name, 'value')
    2723
    2724          self.assertEquals(
    2725              ['start-ns', 'start', 'start', 'start-ns', 'start',
    2726               'end', 'end-ns', 'end', 'end', 'end-ns'],
    2727              events)
    2728
    2729          root = iterator.root
    2730          self.assertEquals(
    2731              None,
    2732              root.get(attr_name))
    2733          self.assertEquals(
    2734              'value',
    2735              root[0].get(attr_name))
    2736
    2737 -    def test_iterparse_getiterator(self):
    2738          iterparse = self.etree.iterparse
    2739          f = BytesIO('<a><b><d/></b><c/></a>')
    2740
    2741          counts = []
    2742          for event, elem in iterparse(f):
    2743              counts.append(len(list(elem.getiterator())))
    2744          self.assertEquals(
    2745              [1,2,1,4],
    2746              counts)
    2747
    2748 -    def test_iterparse_move_elements(self):
    2749          iterparse = self.etree.iterparse
    2750          f = BytesIO('<a><b><d/></b><c/></a>')
    2751
    2752          for event, node in etree.iterparse(f): pass
    2753
    2754          root = etree.Element('new_root', {})
    2755          root[:] = node[:]
    2756
    2757          self.assertEquals(
    2758              ['b', 'c'],
    2759              [ el.tag for el in root ])
    2760
    2761 -    def test_iterparse_cdata(self):
    2762          tostring = self.etree.tostring
    2763          f = BytesIO('<root><![CDATA[test]]></root>')
    2764          context = self.etree.iterparse(f)
    2765          content = [ el.text for event,el in context ]
    2766
    2767          self.assertEquals(['test'], content)
    2768          self.assertEquals(_bytes('<root>test</root>'),
    2769                            tostring(context.root))
    2770
    2771 -    def test_parse_file(self):
    2772          parse = self.etree.parse
    2773          # from file
    2774          tree = parse(fileInTestDir('test.xml'))
    2775          self.assertXML(
    2776              _bytes('<a><b></b></a>'),
    2777              tree.getroot())
    2778
    2779 -    def test_parse_file_nonexistent(self):
    2780          parse = self.etree.parse
    2781          self.assertRaises(IOError, parse, fileInTestDir('notthere.xml'))
    2782
    2783 -    def test_parse_error_none(self):
    2784          parse = self.etree.parse
    2785          self.assertRaises(TypeError, parse, None)
    2786
    2787 -    def test_parse_error(self):
    2788          # ET < 1.3 raises ExpatError
    2789          parse = self.etree.parse
    2790          f = BytesIO('<a><b></c></b></a>')
    2791          self.assertRaises(SyntaxError, parse, f)
    2792          f.close()
    2793
    2794 -    def test_parse_error_from_file(self):
    2795          parse = self.etree.parse
    2796          # from file
    2797          f = open(fileInTestDir('test_broken.xml'), 'rb')
    2798          self.assertRaises(SyntaxError, parse, f)
    2799          f.close()
    2800
    2801 -    def test_parse_file_object(self):
    2802          parse = self.etree.parse
    2803          # from file object
    2804          f = open(fileInTestDir('test.xml'), 'rb')
    2805          tree = parse(f)
    2806          f.close()
    2807          self.assertXML(
    2808              _bytes('<a><b></b></a>'),
    2809              tree.getroot())
    2810
    2811 -    def test_parse_stringio(self):
    2812          parse = self.etree.parse
    2813          f = BytesIO('<a><b></b></a>')
    2814          tree = parse(f)
    2815          f.close()
    2816          self.assertXML(
    2817              _bytes('<a><b></b></a>'),
    2818              tree.getroot()
    2819             )
    2820
    2821 -    def test_parse_cdata(self):
    2822          tostring = self.etree.tostring
    2823          root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>'))
    2824
    2825          self.assertEquals('test', root.text)
    2826          self.assertEquals(_bytes('<root>test</root>'),
    2827                            tostring(root))
    2828
    2829 -    def test_parse_with_encoding(self):
    2830          # this can fail in libxml2 <= 2.6.22
    2831          parse = self.etree.parse
    2832          tree = parse(BytesIO('<?xml version="1.0" encoding="ascii"?><html/>'))
    2833          self.assertXML(_bytes('<html></html>'),
    2834                         tree.getroot())
    2835
    2836 -    def test_encoding(self):
    2837          Element = self.etree.Element
    2838
    2839          a = Element('a')
    2840          a.text = _str('Søk på nettet')
    2841          self.assertXML(
    2842              _str('<a>Søk på nettet</a>').encode('UTF-8'),
    2843              a, 'utf-8')
    2844
    2845 -    def test_encoding_exact(self):
    2846          ElementTree = self.etree.ElementTree
    2847          Element = self.etree.Element
    2848
    2849          a = Element('a')
    2850          a.text = _str('Søk på nettet')
    2851
    2852          f = BytesIO()
    2853          tree = ElementTree(element=a)
    2854          tree.write(f, encoding='utf-8')
    2855          self.assertEquals(_str('<a>Søk på nettet</a>').encode('UTF-8'),
    2856                            f.getvalue().replace(_bytes('\n'),_bytes('')))
    2857
    2858 -    def test_parse_file_encoding(self):
    2859          parse = self.etree.parse
    2860          # from file
    2861          tree = parse(fileInTestDir('test-string.xml'))
    2862          self.assertXML(
    2863              _str('<a>Søk på nettet</a>').encode('UTF-8'),
    2864              tree.getroot(), 'UTF-8')
    2865
    2866 -    def test_parse_file_object_encoding(self):
    2867          parse = self.etree.parse
    2868          # from file object
    2869          f = open(fileInTestDir('test-string.xml'), 'rb')
    2870          tree = parse(f)
    2871          f.close()
    2872          self.assertXML(
    2873              _str('<a>Søk på nettet</a>').encode('UTF-8'),
    2874              tree.getroot(), 'UTF-8')
    2875
    2876 -    def test_encoding_8bit_latin1(self):
    2877          ElementTree = self.etree.ElementTree
    2878          Element = self.etree.Element
    2879
    2880          a = Element('a')
    2881          a.text = _str('Søk på nettet')
    2882
    2883          f = BytesIO()
    2884          tree = ElementTree(element=a)
    2885          tree.write(f, encoding='iso-8859-1')
    2886          result = f.getvalue()
    2887          declaration = _bytes("<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>")
    2888          self.assertEncodingDeclaration(result, _bytes('iso-8859-1'))
    2889          result = result.split(_bytes('?>'), 1)[-1].replace(_bytes('\n'),_bytes(''))
    2890          self.assertEquals(_str('<a>Søk på nettet</a>').encode('iso-8859-1'),
    2891                            result)
    2892
    2893 -    def test_parse_encoding_8bit_explicit(self):
    2894          XMLParser = self.etree.XMLParser
    2895
    2896          text = _str('Søk på nettet')
    2897          xml_latin1 = (_str('<a>%s</a>') % text).encode('iso-8859-1')
    2898
    2899          self.assertRaises(self.etree.ParseError,
    2900                            self.etree.parse,
    2901                            BytesIO(xml_latin1))
    2902
    2903          tree = self.etree.parse(BytesIO(xml_latin1),
    2904                                  XMLParser(encoding="iso-8859-1"))
    2905          a = tree.getroot()
    2906          self.assertEquals(a.text, text)
    2907
    2908 -    def test_parse_encoding_8bit_override(self):
    2909          XMLParser = self.etree.XMLParser
    2910
    2911          text = _str('Søk på nettet')
    2912          wrong_declaration = _str("<?xml version='1.0' encoding='UTF-8'?>")
    2913          xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text)
    2914                        ).encode('iso-8859-1')
    2915
    2916          self.assertRaises(self.etree.ParseError,
    2917                            self.etree.parse,
    2918                            BytesIO(xml_latin1))
    2919
    2920          tree = self.etree.parse(BytesIO(xml_latin1),
    2921                                  XMLParser(encoding="iso-8859-1"))
    2922          a = tree.getroot()
    2923          self.assertEquals(a.text, text)
    2924
    2925 -    def _test_wrong_unicode_encoding(self):
    2926          # raise error on wrong encoding declaration in unicode strings
    2927          XML = self.etree.XML
    2928          test_utf = (_str('<?xml version="1.0" encoding="iso-8859-1"?>') +
    2929                      _str('<a>Søk på nettet</a>'))
    2930          self.assertRaises(SyntaxError, XML, test_utf)
    2931
    2932 -    def test_encoding_write_default_encoding(self):
    2933          ElementTree = self.etree.ElementTree
    2934          Element = self.etree.Element
    2935
    2936          a = Element('a')
    2937          a.text = _str('Søk på nettet')
    2938
    2939          f = BytesIO()
    2940          tree = ElementTree(element=a)
    2941          tree.write(f)
    2942          data = f.getvalue().replace(_bytes('\n'),_bytes(''))
    2943          self.assertEquals(
    2944              _str('<a>Søk på nettet</a>').encode('ASCII', 'xmlcharrefreplace'),
    2945              data)
    2946
    2947 -    def test_encoding_tostring(self):
    2948          Element = self.etree.Element
    2949          tostring = self.etree.tostring
    2950
    2951          a = Element('a')
    2952          a.text = _str('Søk på nettet')
    2953          self.assertEquals(_str('<a>Søk på nettet</a>').encode('UTF-8'),
    2954                           tostring(a, encoding='utf-8'))
    2955
    2956 -    def test_encoding_tostring_unknown(self):
    2957          Element = self.etree.Element
    2958          tostring = self.etree.tostring
    2959
    2960          a = Element('a')
    2961          a.text = _str('Søk på nettet')
    2962          self.assertRaises(LookupError, tostring, a,
    2963                            encoding='Invalid Encoding')
    2964
    2965 -    def test_encoding_tostring_sub(self):
    2966          Element = self.etree.Element
    2967          SubElement = self.etree.SubElement
    2968          tostring = self.etree.tostring
    2969
    2970          a = Element('a')
    2971          b = SubElement(a, 'b')
    2972          b.text = _str('Søk på nettet')
    2973          self.assertEquals(_str('<b>Søk på nettet</b>').encode('UTF-8'),
    2974                           tostring(b, encoding='utf-8'))
    2975
    2976 -    def test_encoding_tostring_sub_tail(self):
    2977          Element = self.etree.Element
    2978          SubElement = self.etree.SubElement
    2979          tostring = self.etree.tostring
    2980
    2981          a = Element('a')
    2982          b = SubElement(a, 'b')
    2983          b.text = _str('Søk på nettet')
    2984          b.tail = _str('Søk')
    2985          self.assertEquals(_str('<b>Søk på nettet</b>Søk').encode('UTF-8'),
    2986                           tostring(b, encoding='utf-8'))
    2987
    2988 -    def test_encoding_tostring_default_encoding(self):
    2989          Element = self.etree.Element
    2990          SubElement = self.etree.SubElement
    2991          tostring = self.etree.tostring
    2992
    2993          a = Element('a')
    2994          a.text = _str('Søk på nettet')
    2995
    2996          expected = _bytes('<a>S&#248;k p&#229; nettet</a>')
    2997          self.assertEquals(
    2998              expected,
    2999              tostring(a))
    3000
    3001 -    def test_encoding_sub_tostring_default_encoding(self):
    3002          Element = self.etree.Element
    3003          SubElement = self.etree.SubElement
    3004          tostring = self.etree.tostring
    3005
    3006          a = Element('a')
    3007          b = SubElement(a, 'b')
    3008          b.text = _str('Søk på nettet')
    3009
    3010          expected = _bytes('<b>S&#248;k p&#229; nettet</b>')
    3011          self.assertEquals(
    3012              expected,
    3013              tostring(b))
    3014
    3015 -    def test_encoding_8bit_xml(self):
    3016          utext = _str('Søk på nettet')
    3017          uxml = _str('<p>%s</p>') % utext
    3018          prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>')
    3019          isoxml = prologue + uxml.encode('iso-8859-1')
    3020          tree = self.etree.XML(isoxml)
    3021          self.assertEquals(utext, tree.text)
    3022
    3023 -    def test_encoding_utf8_bom(self):
    3024          utext = _str('Søk på nettet')
    3025          uxml = (_str('<?xml version="1.0" encoding="UTF-8"?>') +
    3026                  _str('<p>%s</p>') % utext)
    3027          bom = _bytes('\\xEF\\xBB\\xBF').decode("unicode_escape").encode("latin1")
    3028          xml = bom + uxml.encode("utf-8")
    3029          tree = etree.XML(xml)
    3030          self.assertEquals(utext, tree.text)
    3031
    3032 -    def test_encoding_8bit_parse_stringio(self):
    3033          utext = _str('Søk på nettet')
    3034          uxml = _str('<p>%s</p>') % utext
    3035          prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>')
    3036          isoxml = prologue + uxml.encode('iso-8859-1')
    3037          el = self.etree.parse(BytesIO(isoxml)).getroot()
    3038          self.assertEquals(utext, el.text)
    3039
    3040 -    def test_deepcopy_elementtree(self):
    3041          Element = self.etree.Element
    3042          ElementTree = self.etree.ElementTree
    3043
    3044          a = Element('a')
    3045          a.text = "Foo"
    3046          atree = ElementTree(a)
    3047
    3048          btree = copy.deepcopy(atree)
    3049          self.assertEqual("Foo", atree.getroot().text)
    3050          self.assertEqual("Foo", btree.getroot().text)
    3051          self.assertFalse(btree is atree)
    3052          self.assertFalse(btree.getroot() is atree.getroot())
    3053
    3054 -    def test_deepcopy(self):
    3055          Element = self.etree.Element
    3056
    3057          a = Element('a')
    3058          a.text = 'Foo'
    3059
    3060          b = copy.deepcopy(a)
    3061          self.assertEquals('Foo', b.text)
    3062
    3063          b.text = 'Bar'
    3064          self.assertEquals('Bar', b.text)
    3065          self.assertEquals('Foo', a.text)
    3066
    3067          del a
    3068          self.assertEquals('Bar', b.text)
    3069
    3070 -    def test_deepcopy_tail(self):
    3071          Element = self.etree.Element
    3072
    3073          a = Element('a')
    3074          a.tail = 'Foo'
    3075
    3076          b = copy.deepcopy(a)
    3077          self.assertEquals('Foo', b.tail)
    3078
    3079          b.tail = 'Bar'
    3080          self.assertEquals('Bar', b.tail)
    3081          self.assertEquals('Foo', a.tail)
    3082
    3083          del a
    3084          self.assertEquals('Bar', b.tail)
    3085
    3086 -    def test_deepcopy_subelement(self):
    3087          Element = self.etree.Element
    3088          SubElement = self.etree.SubElement
    3089
    3090          root = Element('root')
    3091          a = SubElement(root, 'a')
    3092          a.text = 'FooText'
    3093          a.tail = 'FooTail'
    3094
    3095          b = copy.deepcopy(a)
    3096          self.assertEquals('FooText', b.text)
    3097          self.assertEquals('FooTail', b.tail)
    3098
    3099          b.text = 'BarText'
    3100          b.tail = 'BarTail'
    3101          self.assertEquals('BarTail', b.tail)
    3102          self.assertEquals('FooTail', a.tail)
    3103          self.assertEquals('BarText', b.text)
    3104          self.assertEquals('FooText', a.text)
    3105
    3106          del a
    3107          self.assertEquals('BarTail', b.tail)
    3108          self.assertEquals('BarText', b.text)
    3109
    3110 -    def test_deepcopy_namespaces(self):
    3111          root = self.etree.XML(_bytes('''<doc xmlns="dns" xmlns:t="tns">
    3112          <parent><node t:foo="bar" /></parent>
    3113          </doc>'''))
    3114          self.assertEquals(
    3115              root[0][0].get('{tns}foo'),
    3116              copy.deepcopy(root[0])[0].get('{tns}foo') )
    3117          self.assertEquals(
    3118              root[0][0].get('{tns}foo'),
    3119              copy.deepcopy(root[0][0]).get('{tns}foo') )
    3120
    3121 -    def test_deepcopy_append(self):
    3122          # previously caused a crash
    3123          Element = self.etree.Element
    3124          tostring = self.etree.tostring
    3125
    3126          a = Element('a')
    3127          b = copy.deepcopy(a)
    3128          a.append( Element('C') )
    3129          b.append( Element('X') )
    3130
    3131          self.assertEquals(_bytes('<a><C/></a>'),
    3132                            tostring(a).replace(_bytes(' '), _bytes('')))
    3133          self.assertEquals(_bytes('<a><X/></a>'),
    3134                            tostring(b).replace(_bytes(' '), _bytes('')))
    3135
    3136 -    def test_deepcopy_comment(self):
    3137          # previously caused a crash
    3138          # not supported by ET < 1.3!
    3139          Comment = self.etree.Comment
    3140
    3141          a = Comment("ONE")
    3142          b = copy.deepcopy(a)
    3143          b.text = "ANOTHER"
    3144
    3145          self.assertEquals('ONE',     a.text)
    3146          self.assertEquals('ANOTHER', b.text)
    3147
    3148 -    def test_shallowcopy(self):
    3149          Element = self.etree.Element
    3150
    3151          a = Element('a')
    3152          a.text = 'Foo'
    3153
    3154          b = copy.copy(a)
    3155          self.assertEquals('Foo', b.text)
    3156
    3157          b.text = 'Bar'
    3158          self.assertEquals('Bar', b.text)
    3159          self.assertEquals('Foo', a.text)
    3160          # XXX ElementTree will share nodes, but lxml.etree won't..
    3161
    3162 -    def test_shallowcopy_elementtree(self):
    3163          Element = self.etree.Element
    3164          ElementTree = self.etree.ElementTree
    3165
    3166          a = Element('a')
    3167          a.text = 'Foo'
    3168          atree = ElementTree(a)
    3169
    3170          btree = copy.copy(atree)
    3171          self.assertFalse(btree is atree)
    3172          self.assert_(btree.getroot() is atree.getroot())
    3173          self.assertEquals('Foo', atree.getroot().text)
    3174
    3175 -    def _test_element_boolean(self):
    3176          # deprecated as of ET 1.3/lxml 2.0
    3177          etree = self.etree
    3178          e = etree.Element('foo')
    3179          self.assertEquals(False, bool(e))
    3180          etree.SubElement(e, 'bar')
    3181          self.assertEquals(True, bool(e))
    3182          e = etree.Element('foo')
    3183          e.text = 'hey'
    3184          self.assertEquals(False, bool(e))
    3185          e = etree.Element('foo')
    3186          e.tail = 'bar'
    3187          self.assertEquals(False, bool(e))
    3188          e = etree.Element('foo')
    3189          e.set('bar', 'Bar')
    3190          self.assertEquals(False, bool(e))
    3191
    3192 -    def test_multiple_elementrees(self):
    3193          etree = self.etree
    3194
    3195          a = etree.Element('a')
    3196          b = etree.SubElement(a, 'b')
    3197
    3198          t = etree.ElementTree(a)
    3199          self.assertEquals(self._rootstring(t), _bytes('<a><b/></a>'))
    3200
    3201          t1 = etree.ElementTree(a)
    3202          self.assertEquals(self._rootstring(t1), _bytes('<a><b/></a>'))
    3203          self.assertEquals(self._rootstring(t),  _bytes('<a><b/></a>'))
    3204
    3205          t2 = etree.ElementTree(b)
    3206          self.assertEquals(self._rootstring(t2), _bytes('<b/>'))
    3207          self.assertEquals(self._rootstring(t1), _bytes('<a><b/></a>'))
    3208          self.assertEquals(self._rootstring(t),  _bytes('<a><b/></a>'))
    3209
    3210 -    def test_qname(self):
    3211          etree = self.etree
    3212          qname = etree.QName('myns', 'a')
    3213          a1 = etree.Element(qname)
    3214          a2 = etree.SubElement(a1, qname)
    3215          self.assertEquals(a1.tag, "{myns}a")
    3216          self.assertEquals(a2.tag, "{myns}a")
    3217
    3218 -    def test_qname_cmp(self):
    3219          etree = self.etree
    3220          qname1 = etree.QName('myns', 'a')
    3221          qname2 = etree.QName('myns', 'a')
    3222          self.assertEquals(qname1, "{myns}a")
    3223          self.assertEquals("{myns}a", qname2)
    3224          self.assertEquals(qname1, qname1)
    3225          self.assertEquals(qname1, qname2)
    3226
    3227 -    def test_qname_attribute_getset(self):
    3228          etree = self.etree
    3229          qname = etree.QName('myns', 'a')
    3230
    3231          a = etree.Element(qname)
    3232          a.set(qname, "value")
    3233
    3234          self.assertEquals(a.get(qname), "value")
    3235          self.assertEquals(a.get("{myns}a"), "value")
    3236
    3237 -    def test_qname_attrib(self):
    3238          etree = self.etree
    3239          qname = etree.QName('myns', 'a')
    3240
    3241          a = etree.Element(qname)
    3242          a.attrib[qname] = "value"
    3243
    3244          self.assertEquals(a.attrib[qname], "value")
    3245          self.assertEquals(a.attrib.get(qname), "value")
    3246
    3247          self.assertEquals(a.attrib["{myns}a"], "value")
    3248          self.assertEquals(a.attrib.get("{myns}a"), "value")
    3249
    3250 -    def test_qname_attribute_resolve(self):
    3251          etree = self.etree
    3252          qname = etree.QName('http://myns', 'a')
    3253          a = etree.Element(qname)
    3254          a.set(qname, qname)
    3255
    3256          self.assertXML(
    3257              _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'),
    3258              a)
    3259
    3260 -    def test_qname_attribute_resolve_new(self):
    3261          etree = self.etree
    3262          qname = etree.QName('http://myns', 'a')
    3263          a = etree.Element('a')
    3264          a.set('a', qname)
    3265
    3266          self.assertXML(
    3267              _bytes('<a xmlns:ns0="http://myns" a="ns0:a"></a>'),
    3268              a)
    3269
    3270 -    def test_qname_attrib_resolve(self):
    3271          etree = self.etree
    3272          qname = etree.QName('http://myns', 'a')
    3273          a = etree.Element(qname)
    3274          a.attrib[qname] = qname
    3275
    3276          self.assertXML(
    3277              _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'),
    3278              a)
    3279
    3280 -    def test_parser_version(self):
    3281          etree = self.etree
    3282          parser = etree.XMLParser()
    3283          if hasattr(parser, "version"):
    3284              # ElementTree 1.3+, cET
    3285              self.assert_(re.match("[^ ]+ [0-9.]+", parser.version))
    3286
    3287      # feed parser interface
    3288
    3289 -    def test_feed_parser(self):
    3290          parser = self.etree.XMLParser()
    3291
    3292          parser.feed('<?xml version=')
    3293          parser.feed('"1.0"?><ro')
    3294          parser.feed('ot><')
    3295          parser.feed('a test="works"/')
    3296          parser.feed('></root')
    3297          parser.feed('>')
    3298
    3299          root = parser.close()
    3300
    3301          self.assertEquals(root.tag, "root")
    3302          self.assertEquals(root[0].tag, "a")
    3303          self.assertEquals(root[0].get("test"), "works")
    3304
    3305 -    def test_feed_parser_error_close_empty(self):
    3306          ParseError = self.etree.ParseError
    3307          parser = self.etree.XMLParser()
    3308          self.assertRaises(ParseError, parser.close)
    3309
    3310 -    def test_feed_parser_error_close_incomplete(self):
    3311          ParseError = self.etree.ParseError
    3312          parser = self.etree.XMLParser()
    3313
    3314          parser.feed('<?xml version=')
    3315          parser.feed('"1.0"?><ro')
    3316
    3317          self.assertRaises(ParseError, parser.close)
    3318
    3319 -    def test_feed_parser_error_broken(self):
    3320          ParseError = self.etree.ParseError
    3321          parser = self.etree.XMLParser()
    3322
    3323          parser.feed('<?xml version=')
    3324          parser.feed('"1.0"?><ro')
    3325          try:
    3326              parser.feed('<><><><><><><')
    3327          except ParseError:
    3328              # can raise, but not required before close()
    3329              pass
    3330
    3331          self.assertRaises(ParseError, parser.close)
    3332
    3333 -    def test_feed_parser_error_position(self):
    3334          ParseError = self.etree.ParseError
    3335          parser = self.etree.XMLParser()
    3336          try:
    3337              parser.close()
    3338          except ParseError:
    3339              e = sys.exc_info()[1]
    3340              self.assertNotEquals(None, e.code)
    3341              self.assertNotEquals(0, e.code)
    3342              self.assert_(isinstance(e.position, tuple))
    3343              self.assert_(e.position >= (0, 0))
    3344
    3345      # parser target interface
    3346
    3347 -    def test_parser_target_tag(self):
    3348          assertEquals = self.assertEquals
    3349          assertFalse  = self.assertFalse
    3350
    3351          events = []
    3352          class Target(object):
    3353              def start(self, tag, attrib):
    3354                  events.append("start")
    3355                  assertFalse(attrib)
    3356                  assertEquals("TAG", tag)
    3357              def end(self, tag):
    3358                  events.append("end")
    3359                  assertEquals("TAG", tag)
    3360              def close(self):
    3361                  return "DONE"
    3362
    3363          parser = self.etree.XMLParser(target=Target())
    3364
    3365          parser.feed("<TAG/>")
    3366          done = parser.close()
    3367
    3368          self.assertEquals("DONE", done)
    3369          self.assertEquals(["start", "end"], events)
    3370
    3371 -    def test_elementtree_parser_target(self):
    3372          assertEquals = self.assertEquals
    3373          assertFalse  = self.assertFalse
    3374          Element = self.etree.Element
    3375
    3376          events = []
    3377          class Target(object):
    3378              def start(self, tag, attrib):
    3379                  events.append("start")
    3380                  assertFalse(attrib)
    3381                  assertEquals("TAG", tag)
    3382              def end(self, tag):
    3383                  events.append("end")
    3384                  assertEquals("TAG", tag)
    3385              def close(self):
    3386                  return Element("DONE")
    3387
    3388          parser = self.etree.XMLParser(target=Target())
    3389          tree = self.etree.ElementTree()
    3390          tree.parse(BytesIO("<TAG/>"), parser=parser)
    3391
    3392          self.assertEquals("DONE", tree.getroot().tag)
    3393          self.assertEquals(["start", "end"], events)
    3394
    3395 -    def test_parser_target_attrib(self):
    3396          assertEquals = self.assertEquals
    3397
    3398          events = []
    3399          class Target(object):
    3400              def start(self, tag, attrib):
    3401                  events.append("start-" + tag)
    3402                  for name, value in attrib.items():
    3403                      assertEquals(tag + name, value)
    3404              def end(self, tag):
    3405                  events.append("end-" + tag)
    3406              def close(self):
    3407                  return "DONE"
    3408
    3409          parser = self.etree.XMLParser(target=Target())
    3410
    3411          parser.feed('<root a="roota" b="rootb"><sub c="subc"/></root>')
    3412          done = parser.close()
    3413
    3414          self.assertEquals("DONE", done)
    3415          self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"],
    3416                            events)
    3417
    3418 -    def test_parser_target_data(self):
    3419          events = []
    3420          class Target(object):
    3421              def start(self, tag, attrib):
    3422                  events.append("start-" + tag)
    3423              def end(self, tag):
    3424                  events.append("end-" + tag)
    3425              def data(self, data):
    3426                  events.append("data-" + data)
    3427              def close(self):
    3428                  return "DONE"
    3429
    3430          parser = self.etree.XMLParser(target=Target())
    3431
    3432          parser.feed('<root>A<sub/>B</root>')
    3433          done = parser.close()
    3434
    3435          self.assertEquals("DONE", done)
    3436          self.assertEquals(["start-root", "data-A", "start-sub",
    3437                             "end-sub", "data-B", "end-root"],
    3438                            events)
    3439
    3440 -    def test_parser_target_entity(self):
    3441          events = []
    3442          class Target(object):
    3443              def __init__(self):
    3444                  self._data = []
    3445              def _flush_data(self):
    3446                  if self._data:
    3447                      events.append("data-" + ''.join(self._data))
    3448                      del self._data[:]
    3449              def start(self, tag, attrib):
    3450                  self._flush_data()
    3451                  events.append("start-" + tag)
    3452              def end(self, tag):
    3453                  self._flush_data()
    3454                  events.append("end-" + tag)
    3455              def data(self, data):
    3456                  self._data.append(data)
    3457              def close(self):
    3458                  self._flush_data()
    3459                  return "DONE"
    3460
    3461          parser = self.etree.XMLParser(target=Target())
    3462
    3463          dtd = '''
    3464              <!DOCTYPE root [
    3465              <!ELEMENT root (sub*)>
    3466              <!ELEMENT sub (#PCDATA)>
    3467              <!ENTITY ent "an entity">
    3468          ]>
    3469          '''
    3470          parser.feed(dtd+'<root><sub/><sub>this is &ent;</sub><sub/></root>')
    3471          done = parser.close()
    3472
    3473          self.assertEquals("DONE", done)
    3474          self.assertEquals(["start-root", "start-sub", "end-sub", "start-sub",
    3475                             "data-this is an entity",
    3476                             "end-sub", "start-sub", "end-sub", "end-root"],
    3477                            events)
    3478
    3479 -    def test_parser_target_entity_unknown(self):
    3480          events = []
    3481          class Target(object):
    3482              def __init__(self):
    3483                  self._data = []
    3484              def _flush_data(self):
    3485                  if self._data:
    3486                      events.append("data-" + ''.join(self._data))
    3487                      del self._data[:]
    3488              def start(self, tag, attrib):
    3489                  self._flush_data()
    3490                  events.append("start-" + tag)
    3491              def end(self, tag):
    3492                  self._flush_data()
    3493                  events.append("end-" + tag)
    3494              def data(self, data):
    3495                  self._data.append(data)
    3496              def close(self):
    3497                  self._flush_data()
    3498                  return "DONE"
    3499
    3500          parser = self.etree.XMLParser(target=Target())
    3501
    3502          def feed():
    3503              parser.feed('<root><sub/><sub>some &ent;</sub><sub/></root>')
    3504              parser.close()
    3505
    3506          self.assertRaises(self.etree.ParseError, feed)
    3507
    3508 -    def test_parser_target_feed_exception(self):
    3509          events = []
    3510          class Target(object):
    3511              def start(self, tag, attrib):
    3512                  events.append("start-" + tag)
    3513              def end(self, tag):
    3514                  events.append("end-" + tag)
    3515                  if tag == 'a':
    3516                      raise ValueError("dead and gone")
    3517              def data(self, data):
    3518                  events.append("data-" + data)
    3519              def close(self):
    3520                  events.append("close")
    3521                  return "DONE"
    3522
    3523          parser = self.etree.XMLParser(target=Target())
    3524
    3525          try:
    3526              parser.feed(_bytes('<root>A<a>ca</a>B</root>'))
    3527              done = parser.close()
    3528              self.fail("error expected, but parsing succeeded")
    3529          except ValueError:
    3530              done = 'value error received as expected'
    3531
    3532          self.assertEquals(["start-root", "data-A", "start-a",
    3533                             "data-ca", "end-a"],
    3534                            events)
    3535
    3536 -    def test_parser_target_fromstring_exception(self):
    3537          events = []
    3538          class Target(object):
    3539              def start(self, tag, attrib):
    3540                  events.append("start-" + tag)
    3541              def end(self, tag):
    3542                  events.append("end-" + tag)
    3543                  if tag == 'a':
    3544                      raise ValueError("dead and gone")
    3545              def data(self, data):
    3546                  events.append("data-" + data)
    3547              def close(self):
    3548                  events.append("close")
    3549                  return "DONE"
    3550
    3551          parser = self.etree.XMLParser(target=Target())
    3552
    3553          try:
    3554              done = self.etree.fromstring(_bytes('<root>A<a>ca</a>B</root>'),
    3555                                           parser=parser)
    3556              self.fail("error expected, but parsing succeeded")
    3557          except ValueError:
    3558              done = 'value error received as expected'
    3559
    3560          self.assertEquals(["start-root", "data-A", "start-a",
    3561                             "data-ca", "end-a"],
    3562                            events)
    3563
    3564 -    def test_treebuilder(self):
    3565          builder = self.etree.TreeBuilder()
    3566          el = builder.start("root", {'a':'A', 'b':'B'})
    3567          self.assertEquals("root", el.tag)
    3568          self.assertEquals({'a':'A', 'b':'B'}, el.attrib)
    3569          builder.data("ROOTTEXT")
    3570          el = builder.start("child", {'x':'X', 'y':'Y'})
    3571          self.assertEquals("child", el.tag)
    3572          self.assertEquals({'x':'X', 'y':'Y'}, el.attrib)
    3573          builder.data("CHILDTEXT")
    3574          el = builder.end("child")
    3575          self.assertEquals("child", el.tag)
    3576          self.assertEquals({'x':'X', 'y':'Y'}, el.attrib)
    3577          self.assertEquals("CHILDTEXT", el.text)
    3578          self.assertEquals(None, el.tail)
    3579          builder.data("CHILDTAIL")
    3580          root = builder.end("root")
    3581
    3582          self.assertEquals("root", root.tag)
    3583          self.assertEquals("ROOTTEXT", root.text)
    3584          self.assertEquals("CHILDTEXT", root[0].text)
    3585          self.assertEquals("CHILDTAIL", root[0].tail)
    3586
    3587 -    def test_treebuilder_target(self):
    3588          parser = self.etree.XMLParser(target=self.etree.TreeBuilder())
    3589          parser.feed('<root>ROOTTEXT<child>CHILDTEXT</child>CHILDTAIL</root>')
    3590          root = parser.close()
    3591
    3592          self.assertEquals("root", root.tag)
    3593          self.assertEquals("ROOTTEXT", root.text)
    3594          self.assertEquals("CHILDTEXT", root[0].text)
    3595          self.assertEquals("CHILDTAIL", root[0].tail)
    3596
    3597      # helper methods
    3598
    3599 -    def _writeElement(self, element, encoding='us-ascii'):
    3600          """Write out element for comparison.
    3601          """
    3602          data = self.etree.tostring(element, encoding=encoding)
    3603          if encoding != 'us-ascii':
    3604              data = data.decode(encoding)
    3605          return canonicalize(data)
    3606
    3607 -    def _writeElementFile(self, element, encoding='us-ascii'):
    3608          """Write out element for comparison, using real file.
    3609          """
    3610          ElementTree = self.etree.ElementTree
    3611          handle, filename = tempfile.mkstemp()
    3612          try:
    3613              f = open(filename, 'wb')
    3614              tree = ElementTree(element=element)
    3615              tree.write(f, encoding=encoding)
    3616              f.close()
    3617              f = open(filename, 'rb')
    3618              data = f.read()
    3619              f.close()
    3620          finally:
    3621              os.close(handle)
    3622              os.remove(filename)
    3623          if encoding != 'us-ascii':
    3624              data = data.decode(encoding)
    3625          return canonicalize(data)
    3626
    3627 -    def assertXML(self, expected, element, encoding='us-ascii'):
    3628          """Writes element out and checks whether it is expected.
    3629
    3630          Does this two ways; once using BytesIO, once using a real file.
    3631          """
    3632          self.assertEquals(expected, self._writeElement(element, encoding))
    3633          self.assertEquals(expected, self._writeElementFile(element, encoding))
    3634
    3635 -    def assertEncodingDeclaration(self, result, encoding):
    3636          "Checks if the result XML byte string specifies the encoding."
    3637          enc_re = r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']"
    3638          if isinstance(result, str):
    3639              has_encoding = re.compile(enc_re).match
    3640          else:
    3641              has_encoding = re.compile(_bytes(enc_re)).match
    3642          self.assert_(has_encoding(result))
    3643          result_encoding = has_encoding(result).group(1)
    3644          self.assertEquals(result_encoding.upper(), encoding.upper())
    3645
    3646 -    def _rootstring(self, tree):
    3647          return self.etree.tostring(tree.getroot()).replace(
    3648              _bytes(' '), _bytes('')).replace(_bytes('\n'), _bytes(''))
    3649
    3650 -    def _check_element_tree(self, tree):
    3651          self._check_element(tree.getroot())
    3652
    3653 -    def _check_element(self, element):
    3654          self.assert_(hasattr(element, 'tag'))
    3655          self.assert_(hasattr(element, 'attrib'))
    3656          self.assert_(hasattr(element, 'text'))
    3657          self.assert_(hasattr(element, 'tail'))
    3658          self._check_string(element.tag)
    3659          self._check_mapping(element.attrib)
    3660          if element.text != None:
    3661              self._check_string(element.text)
    3662          if element.tail != None:
    3663              self._check_string(element.tail)
    3664
    3665 -    def _check_string(self, string):
    3666          len(string)
    3667          for char in string:
    3668              self.assertEquals(1, len(char))
    3669          new_string = string + ""
    3670          new_string = string + " "
    3671          string[:0]
    3672
    3673 -    def _check_mapping(self, mapping):
    3674          len(mapping)
    3675          keys = mapping.keys()
    3676          values = mapping.values()
    3677          items = mapping.items()
    3678          for key in keys:
    3679              item = mapping[key]
    3680          mapping["key"] = "value"
    3681          self.assertEquals("value", mapping["key"])
    3682
    3683
    3684  if etree:
    3685 -    class ETreeTestCase(ETreeTestCaseBase):
    3686          etree = etree
    3687
    3688  if ElementTree:
    3689 -    class ElementTreeTestCase(ETreeTestCaseBase):
    3690          etree = ElementTree
    3691
    3692  if cElementTree:
    3693 -    class CElementTreeTestCase(ETreeTestCaseBase):
    3694          etree = cElementTree
    3695
    3696 -def test_suite():
    3697      suite = unittest.TestSuite()
    3698      if etree:
    3699          suite.addTests([unittest.makeSuite(ETreeTestCase)])
    3700      if ElementTree:
    3701          suite.addTests([unittest.makeSuite(ElementTreeTestCase)])
    3702      if cElementTree:
    3703          suite.addTests([unittest.makeSuite(CElementTreeTestCase)])
    3704      return suite
    3705
    3706  if __name__ == '__main__':
    3707      print('to test use test.py %s' % __file__)
    3708