| Home | Trees | Indices | Help | 
 | 
|---|
|  | 
   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, 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 BytesIO, etree 
  19  from common_imports import ElementTree, cElementTree, ET_VERSION, CET_VERSION 
  20  from common_imports import filter_by_version, fileInTestDir, canonicalize, HelperTestCase 
  21  from common_imports import _str, _bytes, unicode, next 
  22   
  23  if cElementTree is not None and (CET_VERSION <= (1,0,7) or sys.version_info[0] >= 3): 
  24      cElementTree = None 
  25   
  26  if ElementTree is not None: 
  27      print("Comparing with ElementTree %s" % getattr(ElementTree, "VERSION", "?")) 
  28   
  29  if cElementTree is not None: 
  30      print("Comparing with cElementTree %s" % getattr(cElementTree, "VERSION", "?")) 
  33      etree = None 
  34      required_versions_ET = {} 
  35      required_versions_cET = {} 
  36   
  38          try: 
  39              XMLParser = self.etree.XMLParser 
  40          except AttributeError: 
  41              assert 'ElementTree' in self.etree.__name__ 
  42              XMLParser = self.etree.TreeBuilder 
  43          return XMLParser(**kwargs) 
  44   
  46          for i in range(10): 
  47              e = self.etree.Element('foo') 
  48              self.assertEqual(e.tag, 'foo') 
  49              self.assertEqual(e.text, None) 
  50              self.assertEqual(e.tail, None) 
  51   
  53          Element = self.etree.Element 
  54           
  55          root = Element('root') 
  56          root.append(Element('one')) 
  57          root.append(Element('two')) 
  58          root.append(Element('three')) 
  59          self.assertEqual(3, len(root)) 
  60          self.assertEqual('one', root[0].tag) 
  61          self.assertEqual('two', root[1].tag) 
  62          self.assertEqual('three', root[2].tag) 
  63          self.assertRaises(IndexError, operator.getitem, root, 3) 
  64   
  65      # test weird dictionary interaction leading to segfault previously 
  67          root = self.etree.Element('root') 
  68          self.assertEqual(root.tag, "root") 
  69          add = self.etree.ElementTree(file=BytesIO('<foo>Foo</foo>')) 
  70          self.assertEqual(add.getroot().tag, "foo") 
  71          self.assertEqual(add.getroot().text, "Foo") 
  72          root.append(self.etree.Element('baz')) 
  73          self.assertEqual(root.tag, "root") 
  74          self.assertEqual(root[0].tag, "baz") 
  75   
  77          Element = self.etree.Element 
  78          SubElement = self.etree.SubElement 
  79           
  80          root = Element('root') 
  81          SubElement(root, 'one') 
  82          SubElement(root, 'two') 
  83          SubElement(root, 'three') 
  84          self.assertEqual(3, len(root)) 
  85          self.assertEqual('one', root[0].tag) 
  86          self.assertEqual('two', root[1].tag) 
  87          self.assertEqual('three', root[2].tag) 
  88           
  90          Element = self.etree.Element 
  91          SubElement = self.etree.SubElement 
  92   
  93          root1 = Element('root') 
  94          SubElement(root1, 'one') 
  95          self.assertTrue(root1[0] in root1) 
  96   
  97          root2 = Element('root') 
  98          SubElement(root2, 'two') 
  99          SubElement(root2, 'three') 
 100          self.assertTrue(root2[0] in root2) 
 101          self.assertTrue(root2[1] in root2) 
 102   
 103          self.assertFalse(root1[0] in root2) 
 104          self.assertFalse(root2[0] in root1) 
 105          self.assertFalse(None in root2) 
 106   
 108          ElementTree = self.etree.ElementTree 
 109           
 110          f = BytesIO('<doc>Test<one>One</one></doc>') 
 111          doc = ElementTree(file=f) 
 112          root = doc.getroot() 
 113          self.assertEqual(1, len(root)) 
 114          self.assertEqual('one', root[0].tag) 
 115          self.assertRaises(IndexError, operator.getitem, root, 1) 
 116           
 118          ElementTree = self.etree.ElementTree 
 119           
 120          f = BytesIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>') 
 121          doc = ElementTree(file=f) 
 122          root = doc.getroot() 
 123          self.assertEqual(3, len(root)) 
 124          self.assertEqual('one', root[0].tag) 
 125          self.assertEqual('two', root[1].tag) 
 126          self.assertEqual('three', root[2].tag) 
 127   
 129          ElementTree = self.etree.ElementTree 
 130           
 131          f = BytesIO('<doc>Test</doc>') 
 132          doc = ElementTree(file=f) 
 133          root = doc.getroot() 
 134          self.assertEqual(0, len(root)) 
 135   
 137          Element = self.etree.Element 
 138          SubElement = self.etree.SubElement 
 139          a = Element('a') 
 140          b = SubElement(a, 'b') 
 141          c = SubElement(a, 'c') 
 142          d = SubElement(a, 'd') 
 143          self.assertEqual(d, a[-1]) 
 144          self.assertEqual(c, a[-2]) 
 145          self.assertEqual(b, a[-3]) 
 146          self.assertRaises(IndexError, operator.getitem, a, -4) 
 147          a[-1] = e = Element('e') 
 148          self.assertEqual(e, a[-1]) 
 149          del a[-1] 
 150          self.assertEqual(2, len(a)) 
 151           
 153          ElementTree = self.etree.ElementTree 
 154           
 155          f = BytesIO('<doc><one>One</one><two>Two</two></doc>') 
 156          doc = ElementTree(file=f) 
 157          root = doc.getroot() 
 158          self.assertEqual(2, len(root)) 
 159          self.assertEqual('one', root[0].tag) 
 160          self.assertEqual('two', root[1].tag) 
 161   
 163          ElementTree = self.etree.ElementTree 
 164           
 165          f = BytesIO('<doc>This is a text</doc>') 
 166          doc = ElementTree(file=f) 
 167          root = doc.getroot() 
 168          self.assertEqual('This is a text', root.text) 
 169   
 171          ElementTree = self.etree.ElementTree 
 172           
 173          f = BytesIO('<doc></doc>') 
 174          doc = ElementTree(file=f) 
 175          root = doc.getroot() 
 176          self.assertEqual(None, root.text) 
 177   
 179          ElementTree = self.etree.ElementTree 
 180           
 181          f = BytesIO('<doc><one>One</one></doc>') 
 182          doc = ElementTree(file=f) 
 183          root = doc.getroot() 
 184          self.assertEqual(None, root.text) 
 185          self.assertEqual('One', root[0].text) 
 186   
 188          ElementTree = self.etree.ElementTree 
 189   
 190          f = BytesIO('<doc>This is > than a text</doc>') 
 191          doc = ElementTree(file=f) 
 192          root = doc.getroot() 
 193          self.assertEqual('This is > than a text', root.text) 
 194   
 196          Element = self.etree.Element 
 197   
 198          a = Element("a") 
 199          a.text = "<>&" 
 200          self.assertXML(_bytes('<a><>&</a>'), 
 201                         a) 
 202   
 204          tostring = self.etree.tostring 
 205          Element  = self.etree.Element 
 206   
 207          a = Element("a") 
 208          a.text = "<>&" 
 209          self.assertEqual(_bytes('<a><>&</a>'), 
 210                           tostring(a)) 
 211   
 217   
 218          a = Element("a") 
 219          a.text = strTest("text") 
 220          self.assertXML(_bytes('<a>text</a>'), 
 221                         a) 
 222   
 224          ElementTree = self.etree.ElementTree 
 225           
 226          f = BytesIO('<doc>This is <i>mixed</i> content.</doc>') 
 227          doc = ElementTree(file=f) 
 228          root = doc.getroot() 
 229          self.assertEqual(1, len(root)) 
 230          self.assertEqual('This is ', root.text) 
 231          self.assertEqual(None, root.tail) 
 232          self.assertEqual('mixed', root[0].text) 
 233          self.assertEqual(' content.', root[0].tail) 
 234   
 236          Element = self.etree.Element 
 237          SubElement = self.etree.SubElement 
 238   
 239          class strTest(str): 
 240              pass 
 241   
 242          a = Element("a") 
 243          SubElement(a, "t").tail = strTest("tail") 
 244          self.assertXML(_bytes('<a><t></t>tail</a>'), 
 245                         a) 
 246   
 248          # this is discouraged for ET compat, should not be tested... 
 249          XML = self.etree.XML 
 250           
 251          root = XML(_bytes('<doc>This is <i>mixed</i> content.</doc>')) 
 252          self.assertEqual(1, len(root)) 
 253          self.assertEqual('This is ', root.text) 
 254          self.assertEqual(None, root.tail) 
 255          self.assertEqual('mixed', root[0].text) 
 256          self.assertEqual(' content.', root[0].tail) 
 257   
 258          del root[0].tail 
 259   
 260          self.assertEqual(1, len(root)) 
 261          self.assertEqual('This is ', root.text) 
 262          self.assertEqual(None, root.tail) 
 263          self.assertEqual('mixed', root[0].text) 
 264          self.assertEqual(None, root[0].tail) 
 265   
 266          root[0].tail = "TAIL" 
 267   
 268          self.assertEqual(1, len(root)) 
 269          self.assertEqual('This is ', root.text) 
 270          self.assertEqual(None, root.tail) 
 271          self.assertEqual('mixed', root[0].text) 
 272          self.assertEqual('TAIL', root[0].tail) 
 273   
 275          Element = self.etree.Element 
 276          ElementTree = self.etree.ElementTree 
 277           
 278          el = Element('hoi') 
 279          doc = ElementTree(el) 
 280          root = doc.getroot() 
 281          self.assertEqual(None, root.text) 
 282          self.assertEqual('hoi', root.tag) 
 283   
 285          ElementTree = self.etree.ElementTree 
 286           
 287          f = BytesIO('<doc one="One" two="Two"/>') 
 288          doc = ElementTree(file=f) 
 289          root = doc.getroot() 
 290          self.assertEqual('One', root.attrib['one']) 
 291          self.assertEqual('Two', root.attrib['two']) 
 292          self.assertRaises(KeyError, operator.getitem, root.attrib, 'three') 
 293   
 295          ElementTree = self.etree.ElementTree 
 296           
 297          f = BytesIO('<doc one="One" two="Two"/>') 
 298          doc = ElementTree(file=f) 
 299          root = doc.getroot() 
 300          self.assertEqual('One', root.attrib.get('one')) 
 301          self.assertEqual('Two', root.attrib.get('two')) 
 302          self.assertEqual(None, root.attrib.get('three')) 
 303          self.assertEqual('foo', root.attrib.get('three', 'foo')) 
 304   
 306          ElementTree = self.etree.ElementTree 
 307   
 308          f = BytesIO('<doc one="One" two="Two"/>') 
 309          doc = ElementTree(file=f) 
 310          root = doc.getroot() 
 311          attrib = dict(root.attrib) 
 312          self.assertEqual('One', attrib['one']) 
 313          self.assertEqual('Two', attrib['two']) 
 314          self.assertRaises(KeyError, operator.getitem, attrib, 'three') 
 315   
 317          ElementTree = self.etree.ElementTree 
 318   
 319          f = BytesIO('<doc one="One" two="Two"/>') 
 320          doc = ElementTree(file=f) 
 321          root = doc.getroot() 
 322          attrib = copy.copy(root.attrib) 
 323          self.assertEqual('One', attrib['one']) 
 324          self.assertEqual('Two', attrib['two']) 
 325          self.assertRaises(KeyError, operator.getitem, attrib, 'three') 
 326   
 328          ElementTree = self.etree.ElementTree 
 329   
 330          f = BytesIO('<doc one="One" two="Two"/>') 
 331          doc = ElementTree(file=f) 
 332          root = doc.getroot() 
 333          attrib = copy.deepcopy(root.attrib) 
 334          self.assertEqual('One', attrib['one']) 
 335          self.assertEqual('Two', attrib['two']) 
 336          self.assertRaises(KeyError, operator.getitem, attrib, 'three') 
 337   
 339          ElementTree = self.etree.ElementTree 
 340           
 341          f = BytesIO('<doc one="One" two="Two"/>') 
 342          doc = ElementTree(file=f) 
 343          root = doc.getroot() 
 344          self.assertEqual('One', root.get('one')) 
 345          self.assertEqual('Two', root.get('two')) 
 346          self.assertEqual(None, root.get('three')) 
 347          self.assertEqual('foo', root.get('three', 'foo')) 
 348   
 350          XML = self.etree.XML 
 351           
 352          root = XML(_bytes('<doc one="One" two="Two"/>')) 
 353          self.assertEqual('One', root.get('one')) 
 354          self.assertEqual('Two', root.get('two')) 
 355          root.attrib.clear() 
 356          self.assertEqual(None, root.get('one')) 
 357          self.assertEqual(None, root.get('two')) 
 358   
 360          Element = self.etree.Element 
 361           
 362          root = Element("root", one="One") 
 363          root.set("two", "Two") 
 364          self.assertEqual('One', root.get('one')) 
 365          self.assertEqual('Two', root.get('two')) 
 366          root.attrib.clear() 
 367          self.assertEqual(None, root.get('one')) 
 368          self.assertEqual(None, root.get('two')) 
 369   
 371          Element = self.etree.Element 
 372          SubElement = self.etree.SubElement 
 373   
 374          attribNS = '{http://foo/bar}x' 
 375   
 376          parent = Element('parent') 
 377          parent.set(attribNS, 'a') 
 378          child = SubElement(parent, 'child') 
 379          child.set(attribNS, 'b') 
 380   
 381          self.assertEqual('a', parent.get(attribNS)) 
 382          self.assertEqual('b', child.get(attribNS)) 
 383   
 384          parent.clear() 
 385          self.assertEqual(None, parent.get(attribNS)) 
 386          self.assertEqual('b', child.get(attribNS)) 
 387   
 389          ElementTree = self.etree.ElementTree 
 390           
 391          f = BytesIO('<doc one="One" two="Two"/>') 
 392          doc = ElementTree(file=f) 
 393          root = doc.getroot() 
 394          self.assertEqual('One', root.attrib['one']) 
 395          self.assertEqual('Two', root.attrib['two']) 
 396   
 397          self.assertEqual('One', root.attrib.pop('one')) 
 398   
 399          self.assertEqual(None, root.attrib.get('one')) 
 400          self.assertEqual('Two', root.attrib['two']) 
 401   
 403          root = self.etree.XML(_bytes('<doc one="One" two="Two"/>')) 
 404          self.assertRaises(KeyError, root.attrib.pop, 'NONE') 
 405   
 406          self.assertEqual('One', root.attrib['one']) 
 407          self.assertEqual('Two', root.attrib['two']) 
 408   
 410          root = self.etree.XML(_bytes('<doc one="One" two="Two"/>')) 
 411          self.assertEqual('Three', root.attrib.pop('three', 'Three')) 
 412   
 414          root = self.etree.XML(_bytes('<doc/>')) 
 415          self.assertEqual('Three', root.attrib.pop('three', 'Three')) 
 416   
 418          root = self.etree.XML(_bytes('<doc one="One" two="Two"/>')) 
 419          self.assertRaises(TypeError, root.attrib.pop, 'One', None, None) 
 420   
 422          XML = self.etree.XML 
 423           
 424          root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 
 425          items = list(root.attrib.items()) 
 426          items.sort() 
 427          self.assertEqual( 
 428              [('alpha', 'Alpha'), ('beta', 'Beta')], 
 429              items) 
 430   
 431          root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}) 
 432   
 433          items = list(root.attrib.items()) 
 434          items.sort() 
 435          self.assertEqual( 
 436              [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 
 437              items) 
 438   
 440          XML = self.etree.XML 
 441           
 442          root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 
 443          items = list(root.attrib.items()) 
 444          items.sort() 
 445          self.assertEqual( 
 446              [('alpha', 'Alpha'), ('beta', 'Beta')], 
 447              items) 
 448   
 449          root.attrib.update({'alpha' : 'test', 'gamma' : 'Gamma'}.items()) 
 450   
 451          items = list(root.attrib.items()) 
 452          items.sort() 
 453          self.assertEqual( 
 454              [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 
 455              items) 
 456   
 458          XML = self.etree.XML 
 459           
 460          root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 
 461          items = list(root.attrib.items()) 
 462          items.sort() 
 463          self.assertEqual( 
 464              [('alpha', 'Alpha'), ('beta', 'Beta')], 
 465              items) 
 466   
 467          root.attrib.update(iter({'alpha' : 'test', 'gamma' : 'Gamma'}.items())) 
 468   
 469          items = list(root.attrib.items()) 
 470          items.sort() 
 471          self.assertEqual( 
 472              [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 
 473              items) 
 474   
 476          XML = self.etree.XML 
 477   
 478          root = XML(_bytes('<doc alpha="Alpha" beta="Beta"/>')) 
 479          items = list(root.attrib.items()) 
 480          items.sort() 
 481          self.assertEqual( 
 482              [('alpha', 'Alpha'), ('beta', 'Beta')], 
 483                                                    items) 
 484   
 485          other = XML(_bytes('<doc alpha="test" gamma="Gamma"/>')) 
 486          root.attrib.update(other.attrib) 
 487   
 488          items = list(root.attrib.items()) 
 489          items.sort() 
 490          self.assertEqual( 
 491              [('alpha', 'test'), ('beta', 'Beta'), ('gamma', 'Gamma')], 
 492                                                                       items) 
 493   
 495          XML = self.etree.XML 
 496           
 497          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 
 498          keys = list(root.attrib.keys()) 
 499          keys.sort() 
 500          self.assertEqual(['alpha', 'beta', 'gamma'], keys) 
 501   
 503          XML = self.etree.XML 
 504           
 505          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 
 506          keys = list(root.keys()) 
 507          keys.sort() 
 508          self.assertEqual(['alpha', 'beta', 'gamma'], keys) 
 509   
 511          XML = self.etree.XML 
 512           
 513          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 
 514          items = list(root.items()) 
 515          items.sort() 
 516          self.assertEqual( 
 517              [('alpha','Alpha'), ('beta','Beta'), ('gamma','Gamma')], 
 518              items) 
 519   
 521          XML = self.etree.XML 
 522   
 523          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 
 524          keys = list(root.keys()) 
 525          keys.sort() 
 526          self.assertEqual(['bar', '{http://ns.codespeak.net/test}baz'], 
 527                            keys) 
 528           
 530          XML = self.etree.XML 
 531           
 532          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 
 533          values = list(root.attrib.values()) 
 534          values.sort() 
 535          self.assertEqual(['Alpha', 'Beta', 'Gamma'], values) 
 536   
 538          XML = self.etree.XML 
 539           
 540          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 
 541          values = list(root.attrib.values()) 
 542          values.sort() 
 543          self.assertEqual( 
 544              ['Bar', 'Baz'], values) 
 545           
 547          XML = self.etree.XML 
 548           
 549          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')) 
 550          items = list(root.attrib.items()) 
 551          items.sort() 
 552          self.assertEqual([ 
 553              ('alpha', 'Alpha'), 
 554              ('beta', 'Beta'), 
 555              ('gamma', 'Gamma'), 
 556              ],  
 557              items) 
 558   
 560          XML = self.etree.XML 
 561           
 562          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 
 563          items = list(root.attrib.items()) 
 564          items.sort() 
 565          self.assertEqual( 
 566              [('bar', 'Bar'), ('{http://ns.codespeak.net/test}baz', 'Baz')], 
 567              items) 
 568   
 570          XML = self.etree.XML 
 571   
 572          expected = "{'{http://ns.codespeak.net/test}baz': 'Baz', 'bar': 'Bar'}" 
 573          alternative = "{'bar': 'Bar', '{http://ns.codespeak.net/test}baz': 'Baz'}" 
 574           
 575          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 
 576          try: 
 577              self.assertEqual(expected, str(root.attrib)) 
 578          except AssertionError: 
 579              self.assertEqual(alternative, str(root.attrib)) 
 580   
 582          XML = self.etree.XML 
 583   
 584          root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />')) 
 585          self.assertEqual( 
 586              True, 'bar' in root.attrib) 
 587          self.assertEqual( 
 588              False, 'baz' in root.attrib) 
 589          self.assertEqual( 
 590              False, 'hah' in root.attrib) 
 591          self.assertEqual( 
 592              True, 
 593              '{http://ns.codespeak.net/test}baz' in root.attrib) 
 594   
 596          Element = self.etree.Element 
 597   
 598          root = Element("root") 
 599          root.set("attr", "TEST") 
 600          self.assertEqual("TEST", root.get("attr")) 
 601   
 603          Element = self.etree.Element 
 604   
 605          root = Element("root") 
 606          root.set("attr", "TEST") 
 607          self.assertEqual("TEST", root.attrib["attr"]) 
 608   
 609          root2 = Element("root2", root.attrib) 
 610          self.assertEqual("TEST", root2.attrib["attr"]) 
 611   
 613          XML = self.etree.XML 
 614           
 615          root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma" />')) 
 616          result = [] 
 617          for key in root.attrib: 
 618              result.append(key) 
 619          result.sort() 
 620          self.assertEqual(['alpha', 'beta', 'gamma'], result) 
 621   
 623          Element = self.etree.Element 
 624   
 625          a = Element('a') 
 626          a.attrib['foo'] = 'Foo' 
 627          a.attrib['bar'] = 'Bar' 
 628          self.assertEqual('Foo', a.attrib['foo']) 
 629          del a.attrib['foo'] 
 630          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 
 631   
 633          Element = self.etree.Element 
 634   
 635          a = Element('a') 
 636          a.attrib['{http://a/}foo'] = 'Foo' 
 637          a.attrib['{http://a/}bar'] = 'Bar' 
 638          self.assertEqual(None, a.get('foo')) 
 639          self.assertEqual('Foo', a.get('{http://a/}foo')) 
 640          self.assertEqual('Foo', a.attrib['{http://a/}foo']) 
 641   
 642          self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo') 
 643          self.assertEqual('Foo', a.attrib['{http://a/}foo']) 
 644   
 645          del a.attrib['{http://a/}foo'] 
 646          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 
 647   
 649          XML = self.etree.XML 
 650   
 651          a = XML(_bytes('<a xmlns:nsa="http://a/" nsa:foo="FooNS" foo="Foo" />')) 
 652   
 653          self.assertEqual('Foo', a.attrib['foo']) 
 654          self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 
 655   
 656          del a.attrib['foo'] 
 657          self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 
 658          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 
 659          self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo') 
 660   
 661          del a.attrib['{http://a/}foo'] 
 662          self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo') 
 663          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 
 664   
 665          a = XML(_bytes('<a xmlns:nsa="http://a/" foo="Foo" nsa:foo="FooNS" />')) 
 666   
 667          self.assertEqual('Foo', a.attrib['foo']) 
 668          self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 
 669   
 670          del a.attrib['foo'] 
 671          self.assertEqual('FooNS', a.attrib['{http://a/}foo']) 
 672          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 
 673   
 674          del a.attrib['{http://a/}foo'] 
 675          self.assertRaises(KeyError, operator.getitem, a.attrib, '{http://a/}foo') 
 676          self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo') 
 677   
 679          XML = self.etree.XML 
 680           
 681          root = XML(_bytes('<doc>This is a text.</doc>')) 
 682          self.assertEqual(0, len(root)) 
 683          self.assertEqual('This is a text.', root.text) 
 684   
 686          XMLID = self.etree.XMLID 
 687          XML   = self.etree.XML 
 688          xml_text = _bytes(''' 
 689          <document> 
 690            <h1 id="chapter1">...</h1> 
 691            <p id="note1" class="note">...</p> 
 692            <p>Regular paragraph.</p> 
 693            <p xml:id="xmlid">XML:ID paragraph.</p> 
 694            <p id="warn1" class="warning">...</p> 
 695          </document> 
 696          ''') 
 697   
 698          root, dic = XMLID(xml_text) 
 699          root2 = XML(xml_text) 
 700          self.assertEqual(self._writeElement(root), 
 701                            self._writeElement(root2)) 
 702          expected = { 
 703              "chapter1" : root[0], 
 704              "note1"    : root[1], 
 705              "warn1"    : root[4] 
 706              } 
 707          self.assertEqual(dic, expected) 
 708   
 710          fromstring = self.etree.fromstring 
 711   
 712          root = fromstring('<doc>This is a text.</doc>') 
 713          self.assertEqual(0, len(root)) 
 714          self.assertEqual('This is a text.', root.text) 
 715   
 716      required_versions_ET['test_fromstringlist'] = (1,3) 
 718          fromstringlist = self.etree.fromstringlist 
 719   
 720          root = fromstringlist(["<do", "c>T", "hi", "s is", 
 721                                 " a text.<", "/doc", ">"]) 
 722          self.assertEqual(0, len(root)) 
 723          self.assertEqual('This is a text.', root.text) 
 724   
 725      required_versions_ET['test_fromstringlist_characters'] = (1,3) 
 727          fromstringlist = self.etree.fromstringlist 
 728   
 729          root = fromstringlist(list('<doc>This is a text.</doc>')) 
 730          self.assertEqual(0, len(root)) 
 731          self.assertEqual('This is a text.', root.text) 
 732   
 733      required_versions_ET['test_fromstringlist_single'] = (1,3) 
 735          fromstringlist = self.etree.fromstringlist 
 736   
 737          root = fromstringlist(['<doc>This is a text.</doc>']) 
 738          self.assertEqual(0, len(root)) 
 739          self.assertEqual('This is a text.', root.text) 
 740   
 742          iselement = self.etree.iselement 
 743          Element = self.etree.Element 
 744          ElementTree = self.etree.ElementTree 
 745          XML = self.etree.XML 
 746          Comment = self.etree.Comment 
 747          ProcessingInstruction = self.etree.ProcessingInstruction 
 748           
 749          el = Element('hoi') 
 750          self.assertTrue(iselement(el)) 
 751   
 752          el2 = XML(_bytes('<foo/>')) 
 753          self.assertTrue(iselement(el2)) 
 754   
 755          tree = ElementTree(element=Element('dag')) 
 756          self.assertTrue(not iselement(tree)) 
 757          self.assertTrue(iselement(tree.getroot())) 
 758   
 759          c = Comment('test') 
 760          self.assertTrue(iselement(c)) 
 761   
 762          p = ProcessingInstruction("test", "some text") 
 763          self.assertTrue(iselement(p)) 
 764           
 766          XML = self.etree.XML 
 767           
 768          root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 
 769          result = [] 
 770          for el in root: 
 771              result.append(el.tag) 
 772          self.assertEqual(['one', 'two', 'three'], result) 
 773   
 775          XML = self.etree.XML 
 776           
 777          root = XML(_bytes('<doc></doc>')) 
 778          result = [] 
 779          for el in root: 
 780              result.append(el.tag) 
 781          self.assertEqual([], result) 
 782   
 784          XML = self.etree.XML 
 785           
 786          root = XML(_bytes('<doc>Text</doc>')) 
 787          result = [] 
 788          for el in root: 
 789              result.append(el.tag) 
 790          self.assertEqual([], result) 
 791   
 793          # this would cause a crash in the past 
 794          fromstring = self.etree.fromstring 
 795          root = fromstring('<html><p></p>x</html>') 
 796          for elem in root: 
 797              elem.tail = '' 
 798   
 800          # this would cause a crash in the past 
 801          fromstring = self.etree.fromstring 
 802          root = fromstring('<html><p></p>x</html>') 
 803          for elem in root: 
 804              elem.tail = None 
 805   
 807          XML = self.etree.XML 
 808          root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 
 809          result = [] 
 810          for el in reversed(root): 
 811              result.append(el.tag) 
 812          self.assertEqual(['three', 'two', 'one'], result) 
 813   
 815          XML = self.etree.XML 
 816   
 817          root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 
 818          result = [] 
 819          add = True 
 820          for el in root: 
 821              result.append(el.tag) 
 822              if add: 
 823                  self.etree.SubElement(root, 'four') 
 824                  add = False 
 825          self.assertEqual(['one', 'two', 'three', 'four'], result) 
 826   
 828          XML = self.etree.XML 
 829   
 830          root = XML(_bytes('<doc><one/><two>Two</two>Hm<three/></doc>')) 
 831          result = [] 
 832          for el in root: 
 833              result.append(el.tag) 
 834              del root[-1] 
 835          self.assertEqual(['one', 'two'], result) 
 836   
 838          XML = self.etree.XML 
 839   
 840          root = XML(_bytes('<doc><one/><two/></doc>')) 
 841          result = [] 
 842          for el0 in root: 
 843              result.append(el0.tag) 
 844              for el1 in root: 
 845                  result.append(el1.tag) 
 846          self.assertEqual(['one','one', 'two', 'two', 'one', 'two'], result) 
 847   
 848      required_versions_ET['test_itertext'] = (1,3) 
 850          # ET 1.3+ 
 851          XML = self.etree.XML 
 852          root = XML(_bytes("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>")) 
 853   
 854          text = list(root.itertext()) 
 855          self.assertEqual(["RTEXT", "ATAIL", "CTEXT", "CTAIL"], 
 856                            text) 
 857   
 858      required_versions_ET['test_itertext_child'] = (1,3) 
 860          # ET 1.3+ 
 861          XML = self.etree.XML 
 862          root = XML(_bytes("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>")) 
 863   
 864          text = list(root[2].itertext()) 
 865          self.assertEqual(["CTEXT"], 
 866                            text) 
 867   
 869          XML = self.etree.XML 
 870          root = XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>')) 
 871          self.assertEqual(len(list(root.findall("c"))), 1) 
 872          self.assertEqual(len(list(root.findall(".//c"))), 2) 
 873          self.assertEqual(len(list(root.findall(".//b"))), 3) 
 874          self.assertEqual(len(list(root.findall(".//b"))[0]), 1) 
 875          self.assertEqual(len(list(root.findall(".//b"))[1]), 0) 
 876          self.assertEqual(len(list(root.findall(".//b"))[2]), 0) 
 877   
 879          XML = self.etree.XML 
 880          root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')) 
 881          self.assertEqual(len(list(root.findall(".//{X}b"))), 2) 
 882          self.assertEqual(len(list(root.findall(".//b"))), 3) 
 883          self.assertEqual(len(list(root.findall("b"))), 2) 
 884   
 886          Element = self.etree.Element 
 887           
 888          el = Element('tag', foo='Foo', bar='Bar') 
 889          self.assertEqual('Foo', el.attrib['foo']) 
 890          self.assertEqual('Bar', el.attrib['bar']) 
 891   
 893          Element = self.etree.Element 
 894           
 895          el = Element('tag', {'foo': 'Foo', 'bar': 'Bar'}) 
 896          self.assertEqual('Foo', el.attrib['foo']) 
 897          self.assertEqual('Bar', el.attrib['bar']) 
 898   
 900          Element = self.etree.Element 
 901   
 902          el = Element('tag', {'foo': 'Foo', 'bar': 'Bar'}, baz='Baz') 
 903          self.assertEqual('Foo', el.attrib['foo']) 
 904          self.assertEqual('Bar', el.attrib['bar']) 
 905          self.assertEqual('Baz', el.attrib['baz']) 
 906   
 908          Element = self.etree.Element 
 909   
 910          el = Element('tag', {'foo': 'Foo', 'bar': 'Bar'}, bar='Baz') 
 911          self.assertEqual('Foo', el.attrib['foo']) 
 912          self.assertEqual('Baz', el.attrib['bar']) 
 913   
 915          Element = self.etree.Element 
 916   
 917          el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 
 918          self.assertEqual('Foo', el.attrib['{ns1}foo']) 
 919          self.assertEqual('Bar', el.attrib['{ns2}bar']) 
 920   
 922          Element =  self.etree.Element 
 923          SubElement = self.etree.SubElement 
 924           
 925          el = Element('tag') 
 926          SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz") 
 927          self.assertEqual("Baz", el[0].attrib['baz']) 
 928          self.assertEqual('Foo', el[0].attrib['foo']) 
 929   
 931          Element = self.etree.Element 
 932          SubElement = self.etree.SubElement 
 933   
 934          el = Element('tag') 
 935          SubElement(el, 'foo', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'}) 
 936          self.assertEqual('Foo', el[0].attrib['{ns1}foo']) 
 937          self.assertEqual('Bar', el[0].attrib['{ns2}bar']) 
 938           
 940          ElementTree = self.etree.ElementTree 
 941          XML = self.etree.XML 
 942   
 943          for i in range(10): 
 944              f = BytesIO()  
 945              root = XML(_bytes('<doc%s>This is a test.</doc%s>' % (i, i))) 
 946              tree = ElementTree(element=root) 
 947              tree.write(f) 
 948              data = f.getvalue() 
 949              self.assertEqual( 
 950                  _bytes('<doc%s>This is a test.</doc%s>' % (i, i)), 
 951                  canonicalize(data)) 
 952   
 953      required_versions_ET['test_write_method_html'] = (1,3) 
 955          ElementTree = self.etree.ElementTree 
 956          Element = self.etree.Element 
 957          SubElement = self.etree.SubElement 
 958           
 959          html = Element('html') 
 960          body = SubElement(html, 'body') 
 961          p = SubElement(body, 'p') 
 962          p.text = "html" 
 963          SubElement(p, 'br').tail = "test" 
 964   
 965          tree = ElementTree(element=html) 
 966          f = BytesIO()  
 967          tree.write(f, method="html") 
 968          data = f.getvalue().replace(_bytes('\n'),_bytes('')) 
 969   
 970          self.assertEqual(_bytes('<html><body><p>html<br>test</p></body></html>'), 
 971                            data) 
 972   
 973      required_versions_ET['test_write_method_text'] = (1,3) 
 975          ElementTree = self.etree.ElementTree 
 976          Element = self.etree.Element 
 977          SubElement = self.etree.SubElement 
 978           
 979          a = Element('a') 
 980          a.text = "A" 
 981          a.tail = "tail" 
 982          b = SubElement(a, 'b') 
 983          b.text = "B" 
 984          b.tail = "TAIL" 
 985          c = SubElement(a, 'c') 
 986          c.text = "C" 
 987           
 988          tree = ElementTree(element=a) 
 989          f = BytesIO()  
 990          tree.write(f, method="text") 
 991          data = f.getvalue() 
 992   
 993          self.assertEqual(_bytes('ABTAILCtail'), 
 994                            data) 
 995           
 997          ElementTree = self.etree.ElementTree 
 998          XML = self.etree.XML 
 999   
1000          tree = ElementTree( XML(_bytes('<doc>This is a test.</doc>')) ) 
1001          self.assertRaises(IOError, tree.write, 
1002                            "definitely////\\-\\nonexisting\\-\\////FILE") 
1003   
1004      # this could trigger a crash, apparently because the document 
1005      # reference was prematurely garbage collected 
1007          Element = self.etree.Element 
1008           
1009          element = Element('tag') 
1010          for i in range(10): 
1011              element.attrib['key'] = 'value' 
1012              value = element.attrib['key'] 
1013              self.assertEqual(value, 'value') 
1014               
1015      # from doctest; for some reason this caused crashes too 
1017          Element = self.etree.Element 
1018          ElementTree = self.etree.ElementTree 
1019           
1020          f = BytesIO() 
1021          for i in range(10): 
1022              element = Element('tag%s' % i) 
1023              self._check_element(element) 
1024              tree = ElementTree(element) 
1025              tree.write(f) 
1026              self._check_element_tree(tree) 
1027   
1029          Element = self.etree.Element 
1030          SubElement = self.etree.SubElement 
1031           
1032          el = Element('foo') 
1033          el2 = SubElement(el, 'bar') 
1034          el3 = SubElement(el2, 'baz') 
1035   
1036          al = Element('foo2') 
1037          al2 = SubElement(al, 'bar2') 
1038          al3 = SubElement(al2, 'baz2') 
1039   
1040          # now move al2 into el 
1041          el.append(al2) 
1042   
1043          # now change al3 directly 
1044          al3.text = 'baz2-modified' 
1045   
1046          # it should have changed through this route too 
1047          self.assertEqual( 
1048              'baz2-modified', 
1049              el[1][0].text) 
1050   
1052          Element = self.etree.Element 
1053          SubElement = self.etree.SubElement 
1054           
1055          a = Element('a') 
1056          b = SubElement(a, 'b') 
1057          a.text = 'hoi' 
1058          self.assertEqual( 
1059              'hoi', 
1060              a.text) 
1061          self.assertEqual( 
1062              'b', 
1063              a[0].tag) 
1064   
1066          Element = self.etree.Element 
1067          SubElement = self.etree.SubElement 
1068           
1069          a = Element('a') 
1070          a.text = 'hoi' 
1071          b = SubElement(a ,'b') 
1072          self.assertEqual( 
1073              'hoi', 
1074              a.text) 
1075          self.assertEqual( 
1076              'b', 
1077              a[0].tag) 
1078   
1080          Element = self.etree.Element 
1081   
1082          a = Element('a') 
1083   
1084          a.text = 'foo' 
1085          a.text = None 
1086   
1087          self.assertEqual( 
1088              None, 
1089              a.text) 
1090          self.assertXML(_bytes('<a></a>'), a) 
1091           
1093          Element = self.etree.Element 
1094   
1095          a = Element('a') 
1096          self.assertEqual(None, a.text) 
1097   
1098          a.text = '' 
1099          self.assertEqual('', a.text) 
1100          self.assertXML(_bytes('<a></a>'), a) 
1101           
1103          Element = self.etree.Element 
1104          SubElement = self.etree.SubElement 
1105           
1106          a = Element('a') 
1107          a.tail = 'dag' 
1108          self.assertEqual('dag', 
1109                            a.tail) 
1110          b = SubElement(a, 'b') 
1111          b.tail = 'hoi' 
1112          self.assertEqual('hoi', 
1113                            b.tail) 
1114          self.assertEqual('dag', 
1115                            a.tail) 
1116   
1118          Element = self.etree.Element 
1119           
1120          a = Element('a') 
1121          b = Element('b') 
1122          b.tail = 'b_tail' 
1123          a.append(b) 
1124          self.assertEqual('b_tail', 
1125                            b.tail) 
1126   
1128          Element = self.etree.Element 
1129          SubElement = self.etree.SubElement 
1130           
1131          a = Element('a') 
1132          b = SubElement(a, 'b') 
1133          b.tail = 'foo' 
1134          b.tail = 'bar' 
1135          self.assertEqual('bar', 
1136                            b.tail) 
1137          self.assertXML(_bytes('<a><b></b>bar</a>'), a) 
1138           
1140          Element = self.etree.Element 
1141          a = Element('a') 
1142          a.tail = 'foo' 
1143          a.tail = None 
1144          self.assertEqual( 
1145              None, 
1146              a.tail) 
1147          self.assertXML(_bytes('<a></a>'), a) 
1148   
1149      required_versions_ET['test_extend'] = (1,3) 
1151          root = self.etree.Element('foo') 
1152          for i in range(3): 
1153              element = self.etree.SubElement(root, 'a%s' % i) 
1154              element.text = "text%d" % i 
1155              element.tail = "tail%d" % i 
1156   
1157          elements = [] 
1158          for i in range(3): 
1159              new_element = self.etree.Element("test%s" % i) 
1160              new_element.text = "TEXT%s" % i 
1161              new_element.tail = "TAIL%s" % i 
1162              elements.append(new_element) 
1163   
1164          root.extend(elements) 
1165   
1166          self.assertEqual( 
1167              ["a0", "a1", "a2", "test0", "test1", "test2"], 
1168              [ el.tag for el in root ]) 
1169          self.assertEqual( 
1170              ["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"], 
1171              [ el.text for el in root ]) 
1172          self.assertEqual( 
1173              ["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"], 
1174              [ el.tail for el in root ]) 
1175   
1177          Element = self.etree.Element 
1178          SubElement = self.etree.SubElement 
1179          Comment = self.etree.Comment 
1180   
1181          a = Element('a') 
1182          a.append(Comment('foo')) 
1183          self.assertEqual(a[0].tag, Comment) 
1184          self.assertEqual(a[0].text, 'foo') 
1185   
1186      # ElementTree < 1.3 adds whitespace around comments 
1187      required_versions_ET['test_comment_text'] = (1,3) 
1189          Element = self.etree.Element 
1190          SubElement = self.etree.SubElement 
1191          Comment = self.etree.Comment 
1192          tostring = self.etree.tostring 
1193   
1194          a = Element('a') 
1195          a.append(Comment('foo')) 
1196          self.assertEqual(a[0].text, 'foo') 
1197   
1198          self.assertEqual( 
1199              _bytes('<a><!--foo--></a>'), 
1200              tostring(a)) 
1201   
1202          a[0].text = "TEST" 
1203          self.assertEqual(a[0].text, 'TEST') 
1204   
1205          self.assertEqual( 
1206              _bytes('<a><!--TEST--></a>'), 
1207              tostring(a)) 
1208   
1209      # ElementTree < 1.3 adds whitespace around comments 
1210      required_versions_ET['test_comment_whitespace'] = (1,3) 
1212          Element = self.etree.Element 
1213          SubElement = self.etree.SubElement 
1214          Comment = self.etree.Comment 
1215          tostring = self.etree.tostring 
1216   
1217          a = Element('a') 
1218          a.append(Comment(' foo  ')) 
1219          self.assertEqual(a[0].text, ' foo  ') 
1220          self.assertEqual( 
1221              _bytes('<a><!-- foo  --></a>'), 
1222              tostring(a)) 
1223           
1225          Comment = self.etree.Comment 
1226          c = Comment('foo') 
1227          self.assertEqual({}, c.attrib) 
1228          self.assertEqual([], list(c.keys())) 
1229          self.assertEqual([], list(c.items())) 
1230          self.assertEqual(None, c.get('hoi')) 
1231          self.assertEqual(0, len(c)) 
1232          # should not iterate 
1233          for i in c: 
1234              pass 
1235   
1237          # lxml.etree separates target and text 
1238          Element = self.etree.Element 
1239          SubElement = self.etree.SubElement 
1240          ProcessingInstruction = self.etree.ProcessingInstruction 
1241   
1242          a = Element('a') 
1243          a.append(ProcessingInstruction('foo', 'some more text')) 
1244          self.assertEqual(a[0].tag, ProcessingInstruction) 
1245          self.assertXML(_bytes("<a><?foo some more text?></a>"), 
1246                         a) 
1247   
1249          # lxml.etree separates target and text 
1250          Element = self.etree.Element 
1251          SubElement = self.etree.SubElement 
1252          ProcessingInstruction = self.etree.PI 
1253   
1254          a = Element('a') 
1255          a.append(ProcessingInstruction('foo', 'some more text')) 
1256          self.assertEqual(a[0].tag, ProcessingInstruction) 
1257          self.assertXML(_bytes("<a><?foo some more text?></a>"), 
1258                         a) 
1259   
1261          ProcessingInstruction = self.etree.ProcessingInstruction 
1262          pi = ProcessingInstruction('foo') 
1263          self.assertEqual({}, pi.attrib) 
1264          self.assertEqual([], list(pi.keys())) 
1265          self.assertEqual([], list(pi.items())) 
1266          self.assertEqual(None, pi.get('hoi')) 
1267          self.assertEqual(0, len(pi)) 
1268          # should not iterate 
1269          for i in pi: 
1270              pass 
1271   
1273          Element = self.etree.Element 
1274          SubElement = self.etree.SubElement 
1275   
1276          a = Element('a') 
1277          b = SubElement(a, 'b') 
1278          c = Element('c') 
1279          a[0] = c 
1280          self.assertEqual( 
1281              c, 
1282              a[0]) 
1283          self.assertXML(_bytes('<a><c></c></a>'), 
1284                         a) 
1285          self.assertXML(_bytes('<b></b>'), 
1286                         b) 
1287           
1289          Element = self.etree.Element 
1290          SubElement = self.etree.SubElement 
1291   
1292          a = Element('a') 
1293          for i in range(5): 
1294              b = SubElement(a, 'b%s' % i) 
1295              c = SubElement(b, 'c') 
1296          for i in range(5): 
1297              d = Element('d') 
1298              e = SubElement(d, 'e') 
1299              a[i] = d 
1300          self.assertXML( 
1301              _bytes('<a><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d><d><e></e></d></a>'), 
1302              a) 
1303          self.assertXML(_bytes('<c></c>'), 
1304                         c) 
1305   
1307          Element = self.etree.Element 
1308          SubElement = self.etree.SubElement 
1309   
1310          a = Element('a') 
1311          SubElement(a, 'b') 
1312          d = Element('d') 
1313          a[0] = d 
1314          self.assertXML(_bytes('<a><d></d></a>'), a) 
1315   
1317          Element = self.etree.Element 
1318          SubElement = self.etree.SubElement 
1319   
1320          a = Element('a') 
1321          b = SubElement(a, 'b') 
1322   
1323          self.assertRaises(IndexError, operator.setitem, a, 1, Element('c')) 
1324   
1326          Element = self.etree.Element 
1327          SubElement = self.etree.SubElement 
1328   
1329          a = Element('a') 
1330          b = SubElement(a, 'b') 
1331          b.tail = 'B2' 
1332          c = Element('c') 
1333          c.tail = 'C2' 
1334   
1335          a[0] = c 
1336          self.assertXML( 
1337              _bytes('<a><c></c>C2</a>'), 
1338              a) 
1339   
1341          Element = self.etree.Element 
1342          SubElement = self.etree.SubElement 
1343   
1344          a = Element('a') 
1345          b = SubElement(a, 'b') 
1346   
1347          a.tag = 'c' 
1348   
1349          self.assertEqual( 
1350              'c', 
1351              a.tag) 
1352   
1353          self.assertXML( 
1354              _bytes('<c><b></b></c>'), 
1355              a) 
1356   
1358          Element = self.etree.Element 
1359          SubElement = self.etree.SubElement 
1360          tostring = self.etree.tostring 
1361   
1362          a = Element('{a}a') 
1363          b1 = SubElement(a, '{a}b') 
1364          b2 = SubElement(a, '{b}b') 
1365   
1366          self.assertEqual('{a}b',  b1.tag) 
1367   
1368          b1.tag = 'c' 
1369   
1370          # can't use C14N here! 
1371          self.assertEqual('c', b1.tag) 
1372          self.assertEqual(_bytes('<c'), tostring(b1)[:2]) 
1373          self.assertTrue(_bytes('<c') in tostring(a)) 
1374   
1376          Element = self.etree.Element 
1377          SubElement = self.etree.SubElement 
1378          tostring = self.etree.tostring 
1379   
1380          a = Element('{a}a') 
1381          b1 = SubElement(a, '{a}b') 
1382          b2 = SubElement(a, '{b}b') 
1383   
1384          a.tag = 'c' 
1385   
1386          self.assertEqual( 
1387              'c', 
1388              a.tag) 
1389   
1390          # can't use C14N here! 
1391          self.assertEqual('c',  a.tag) 
1392          self.assertEqual(_bytes('<c'), tostring(a)[:2]) 
1393   
1399   
1400          a = Element("a") 
1401          a.tag = strTest("TAG") 
1402          self.assertXML(_bytes('<TAG></TAG>'), 
1403                         a) 
1404   
1406          Element = self.etree.Element 
1407          SubElement = self.etree.SubElement 
1408   
1409          a = Element('a') 
1410          b = SubElement(a, 'b') 
1411          c = SubElement(a, 'c') 
1412          d = SubElement(a, 'd') 
1413   
1414          del a[1] 
1415          self.assertXML( 
1416              _bytes('<a><b></b><d></d></a>'), 
1417              a) 
1418   
1419          del a[0] 
1420          self.assertXML( 
1421              _bytes('<a><d></d></a>'), 
1422              a) 
1423   
1424          del a[0] 
1425          self.assertXML( 
1426              _bytes('<a></a>'), 
1427              a) 
1428          # move deleted element into other tree afterwards 
1429          other = Element('other') 
1430          other.append(c) 
1431          self.assertXML( 
1432              _bytes('<other><c></c></other>'), 
1433              other) 
1434       
1436          Element = self.etree.Element 
1437          SubElement = self.etree.SubElement 
1438   
1439          a = Element('a') 
1440          b = SubElement(a, 'b') 
1441          bs = SubElement(b, 'bs') 
1442          c = SubElement(a, 'c') 
1443          cs = SubElement(c, 'cs') 
1444   
1445          el = a[0] 
1446          self.assertXML( 
1447              _bytes('<a><b><bs></bs></b><c><cs></cs></c></a>'), 
1448              a) 
1449          self.assertXML(_bytes('<b><bs></bs></b>'), b) 
1450          self.assertXML(_bytes('<c><cs></cs></c>'), c) 
1451   
1452          del a[0] 
1453          self.assertXML( 
1454              _bytes('<a><c><cs></cs></c></a>'), 
1455              a) 
1456          self.assertXML(_bytes('<b><bs></bs></b>'), b) 
1457          self.assertXML(_bytes('<c><cs></cs></c>'), c) 
1458   
1459          a.insert(0, el) 
1460          self.assertXML( 
1461              _bytes('<a><b><bs></bs></b><c><cs></cs></c></a>'), 
1462              a) 
1463          self.assertXML(_bytes('<b><bs></bs></b>'), b) 
1464          self.assertXML(_bytes('<c><cs></cs></c>'), c) 
1465   
1467          Element = self.etree.Element 
1468          SubElement = self.etree.SubElement 
1469   
1470          a = Element('a') 
1471          b = SubElement(a, 'b') 
1472          bs = SubElement(b, 'bs') 
1473          c = SubElement(a, 'c') 
1474          cs = SubElement(c, 'cs') 
1475   
1476          el = a[0] 
1477          del a[0] 
1478          a[0] = el 
1479          self.assertXML( 
1480              _bytes('<a><b><bs></bs></b></a>'), 
1481              a) 
1482          self.assertXML(_bytes('<b><bs></bs></b>'), b) 
1483          self.assertXML(_bytes('<c><cs></cs></c>'), c) 
1484   
1486          Element = self.etree.Element 
1487          SubElement = self.etree.SubElement 
1488   
1489          a = Element('a') 
1490          b = SubElement(a, 'b') 
1491          bs = SubElement(b, 'bs') 
1492          c = SubElement(a, 'c') 
1493          cs = SubElement(c, 'cs') 
1494   
1495          el = a[0] 
1496          del a[0] 
1497          a[0:0] = [el] 
1498          self.assertXML( 
1499              _bytes('<a><b><bs></bs></b><c><cs></cs></c></a>'), 
1500              a) 
1501          self.assertXML(_bytes('<b><bs></bs></b>'), b) 
1502          self.assertXML(_bytes('<c><cs></cs></c>'), c) 
1503   
1505          XML = self.etree.XML 
1506          a = XML(_bytes('<a><b></b>B2<c></c>C2</a>')) 
1507          b, c = a 
1508   
1509          a[:] = [] 
1510   
1511          self.assertEqual("B2", b.tail) 
1512          self.assertEqual("C2", c.tail) 
1513   
1515          XML = self.etree.XML 
1516          root = XML(_bytes( 
1517              '<foo><bar xmlns:baz="http://huhu"><puh><baz:bump1 /><baz:bump2 /></puh></bar></foo>')) 
1518          root[:] = root.findall('.//puh') # delete bar from hierarchy 
1519   
1520          # previously, this lost a namespace declaration on bump2 
1521          result = self.etree.tostring(root) 
1522          foo = self.etree.fromstring(result) 
1523   
1524          self.assertEqual('puh', foo[0].tag) 
1525          self.assertEqual('{http://huhu}bump1', foo[0][0].tag) 
1526          self.assertEqual('{http://huhu}bump2', foo[0][1].tag) 
1527   
1529          ElementTree = self.etree.ElementTree 
1530          f = BytesIO('<a><b></b>B2<c></c>C2</a>') 
1531          doc = ElementTree(file=f) 
1532          a = doc.getroot() 
1533          del a[0] 
1534          self.assertXML( 
1535              _bytes('<a><c></c>C2</a>'), 
1536              a) 
1537           
1539          Element = self.etree.Element 
1540        
1541          a = Element('a') 
1542          a.text = 'foo' 
1543          a.tail = 'bar' 
1544          a.set('hoi', 'dag') 
1545          a.clear() 
1546          self.assertEqual(None, a.text) 
1547          self.assertEqual(None, a.tail) 
1548          self.assertEqual(None, a.get('hoi')) 
1549          self.assertEqual('a', a.tag) 
1550   
1552          Element = self.etree.Element 
1553          SubElement = self.etree.SubElement 
1554   
1555          a = Element('a') 
1556          a.text = 'foo' 
1557          a.tail = 'bar' 
1558          a.set('hoi', 'dag') 
1559          b = SubElement(a, 'b') 
1560          c = SubElement(b, 'c') 
1561          a.clear() 
1562          self.assertEqual(None, a.text) 
1563          self.assertEqual(None, a.tail) 
1564          self.assertEqual(None, a.get('hoi')) 
1565          self.assertEqual('a', a.tag) 
1566          self.assertEqual(0, len(a)) 
1567          self.assertXML(_bytes('<a></a>'), 
1568                         a) 
1569          self.assertXML(_bytes('<b><c></c></b>'), 
1570                         b) 
1571       
1573          ElementTree = self.etree.ElementTree 
1574          f = BytesIO('<a><b></b>B2<c></c>C2</a>') 
1575          doc = ElementTree(file=f) 
1576          a = doc.getroot() 
1577          a.clear() 
1578          self.assertXML( 
1579              _bytes('<a></a>'), 
1580              a) 
1581   
1583          Element = self.etree.Element 
1584          SubElement = self.etree.SubElement 
1585   
1586          a = Element('a') 
1587          b = SubElement(a, 'b') 
1588          c = SubElement(a, 'c') 
1589          d = Element('d') 
1590          a.insert(0, d) 
1591   
1592          self.assertEqual( 
1593              d, 
1594              a[0]) 
1595   
1596          self.assertXML( 
1597              _bytes('<a><d></d><b></b><c></c></a>'), 
1598              a) 
1599   
1600          e = Element('e') 
1601          a.insert(2, e) 
1602          self.assertEqual( 
1603              e, 
1604              a[2]) 
1605          self.assertXML( 
1606              _bytes('<a><d></d><b></b><e></e><c></c></a>'), 
1607              a) 
1608   
1610          # See GH#268 / LP#1773749. 
1611          Element = self.etree.Element 
1612          SubElement = self.etree.SubElement 
1613   
1614          # Use unique names to make sure they are new in the tag name dict. 
1615          import uuid 
1616          names = dict((k, 'tag-' + str(uuid.uuid4())) for k in 'abcde') 
1617   
1618          a = Element(names['a']) 
1619          b = SubElement(a, names['b']) 
1620          c = SubElement(a, names['c']) 
1621          d = Element(names['d']) 
1622          a.insert(0, d) 
1623   
1624          self.assertEqual( 
1625              d, 
1626              a[0]) 
1627   
1628          self.assertXML( 
1629              _bytes('<%(a)s><%(d)s></%(d)s><%(b)s></%(b)s><%(c)s></%(c)s></%(a)s>' % names), 
1630              a) 
1631   
1632          e = Element(names['e']) 
1633          a.insert(2, e) 
1634          self.assertEqual( 
1635              e, 
1636              a[2]) 
1637          self.assertXML( 
1638              _bytes('<%(a)s><%(d)s></%(d)s><%(b)s></%(b)s><%(e)s></%(e)s><%(c)s></%(c)s></%(a)s>' % names), 
1639              a) 
1640   
1642          Element = self.etree.Element 
1643          SubElement = self.etree.SubElement 
1644   
1645          a = Element('a') 
1646          b = SubElement(a, 'b') 
1647          c = Element('c') 
1648   
1649          a.insert(2, c) 
1650          self.assertEqual( 
1651              c, 
1652              a[1]) 
1653          self.assertXML( 
1654              _bytes('<a><b></b><c></c></a>'), 
1655              a) 
1656   
1658          Element = self.etree.Element 
1659          SubElement = self.etree.SubElement 
1660   
1661          a = Element('a') 
1662          b = SubElement(a, 'b') 
1663          c = SubElement(a, 'c') 
1664   
1665          d = Element('d') 
1666          a.insert(-1, d) 
1667          self.assertEqual( 
1668              d, 
1669              a[-2]) 
1670          self.assertXML( 
1671              _bytes('<a><b></b><d></d><c></c></a>'), 
1672              a) 
1673   
1675          Element = self.etree.Element 
1676          SubElement = self.etree.SubElement 
1677   
1678          a = Element('a') 
1679          b = SubElement(a, 'b') 
1680   
1681          c = Element('c') 
1682          c.tail = 'C2' 
1683   
1684          a.insert(0, c) 
1685          self.assertXML( 
1686              _bytes('<a><c></c>C2<b></b></a>'), 
1687              a) 
1688           
1690          Element = self.etree.Element 
1691          SubElement = self.etree.SubElement 
1692   
1693          a = Element('a') 
1694          b = SubElement(a, 'b') 
1695          c = SubElement(a, 'c') 
1696   
1697          a.remove(b) 
1698          self.assertEqual( 
1699              c, 
1700              a[0]) 
1701          self.assertXML( 
1702              _bytes('<a><c></c></a>'), 
1703              a) 
1704           
1706          Element = self.etree.Element 
1707          SubElement = self.etree.SubElement 
1708   
1709          a = Element('{http://test}a') 
1710          b = SubElement(a, '{http://test}b') 
1711          c = SubElement(a, '{http://test}c') 
1712   
1713          a.remove(b) 
1714          self.assertXML( 
1715              _bytes('<ns0:a xmlns:ns0="http://test"><ns0:c></ns0:c></ns0:a>'), 
1716              a) 
1717          self.assertXML( 
1718              _bytes('<ns0:b xmlns:ns0="http://test"></ns0:b>'), 
1719              b) 
1720   
1722          Element = self.etree.Element 
1723          SubElement = self.etree.SubElement 
1724   
1725          a = Element('a') 
1726          b = SubElement(a, 'b') 
1727          c = SubElement(a, 'c') 
1728          d = Element('d') 
1729          self.assertRaises( 
1730              ValueError, a.remove, d) 
1731   
1733          Element = self.etree.Element 
1734          SubElement = self.etree.SubElement 
1735   
1736          a = Element('a') 
1737          b = SubElement(a, 'b') 
1738          b.tail = 'b2' 
1739          a.remove(b) 
1740          self.assertXML( 
1741              _bytes('<a></a>'), 
1742              a) 
1743          self.assertEqual('b2', b.tail) 
1744   
1746          # There is no guarantee that this "works", but it should 
1747          # remove at least one child and not crash. 
1748          Element = self.etree.Element 
1749          SubElement = self.etree.SubElement 
1750   
1751          a = Element('a') 
1752          SubElement(a, 'b') 
1753          SubElement(a, 'c') 
1754          SubElement(a, 'd') 
1755          for el in a: 
1756              a.remove(el) 
1757          self.assertLess(len(a), 3) 
1758   
1760          Element = self.etree.Element 
1761          SubElement = self.etree.SubElement 
1762   
1763          a = Element('a') 
1764          b = SubElement(a, 'b') 
1765          c = SubElement(a, 'c') 
1766          d = SubElement(b, 'd') 
1767          e = SubElement(c, 'e') 
1768          self.assertXML( 
1769              _bytes('<a><b><d></d></b><c><e></e></c></a>'), 
1770              a) 
1771          self.assertEqual( 
1772              [b, c], 
1773              a.getchildren()) 
1774          self.assertEqual( 
1775              [d], 
1776              b.getchildren()) 
1777          self.assertEqual( 
1778              [], 
1779              d.getchildren()) 
1780   
1782          Element = self.etree.Element 
1783   
1784          a = Element('a') 
1785          b = a.makeelement('c', {'hoi':'dag'}) 
1786          self.assertXML( 
1787              _bytes('<c hoi="dag"></c>'), 
1788              b) 
1789   
1790      required_versions_ET['test_iter'] = (1,3) 
1792          Element = self.etree.Element 
1793          SubElement = self.etree.SubElement 
1794   
1795          a = Element('a') 
1796          b = SubElement(a, 'b') 
1797          c = SubElement(a, 'c') 
1798          d = SubElement(b, 'd') 
1799          e = SubElement(c, 'e') 
1800   
1801          self.assertEqual( 
1802              [a, b, d, c, e], 
1803              list(a.iter())) 
1804          self.assertEqual( 
1805              [d], 
1806              list(d.iter())) 
1807   
1809          Element = self.etree.Element 
1810          SubElement = self.etree.SubElement 
1811   
1812          a = Element('a') 
1813          a.text = 'a' 
1814          a.tail = 'a1' * 100 
1815          b = SubElement(a, 'b') 
1816          b.text = 'b' 
1817          b.tail = 'b1' * 100 
1818          c = SubElement(a, 'c') 
1819          c.text = 'c' 
1820          c.tail = 'c1' * 100 
1821          d = SubElement(b, 'd') 
1822          d.text = 'd' 
1823          d.tail = 'd1' * 100 
1824          e = SubElement(c, 'e') 
1825          e.text = 'e' 
1826          e.tail = 'e1' * 100 
1827   
1828          for el in a.iter(): 
1829              el.tail = None 
1830          el = None 
1831   
1832          self.assertEqual( 
1833              [None] * 5, 
1834              [el.tail for el in a.iter()]) 
1835   
1837          Element = self.etree.Element 
1838          SubElement = self.etree.SubElement 
1839   
1840          a = Element('a') 
1841          b = SubElement(a, 'b') 
1842          c = SubElement(a, 'c') 
1843          d = SubElement(b, 'd') 
1844          e = SubElement(c, 'e') 
1845   
1846          self.assertEqual( 
1847              [a, b, d, c, e], 
1848              list(a.getiterator())) 
1849          self.assertEqual( 
1850              [d], 
1851              list(d.getiterator())) 
1852   
1854          Element = self.etree.Element 
1855          SubElement = self.etree.SubElement 
1856   
1857          a = Element('a') 
1858          b = SubElement(a, 'b') 
1859          c = SubElement(a, 'c') 
1860          d = SubElement(b, 'd') 
1861          e = SubElement(c, 'e') 
1862   
1863          self.assertEqual( 
1864              [], 
1865              list(a.getiterator('none'))) 
1866          self.assertEqual( 
1867              [], 
1868              list(e.getiterator('none'))) 
1869          self.assertEqual( 
1870              [e], 
1871              list(e.getiterator())) 
1872   
1874          Element = self.etree.Element 
1875          SubElement = self.etree.SubElement 
1876   
1877          a = Element('a') 
1878          b = SubElement(a, 'b') 
1879          c = SubElement(a, 'c') 
1880          d = SubElement(b, 'd') 
1881          e = SubElement(c, 'e') 
1882   
1883          self.assertEqual( 
1884              [a], 
1885              list(a.getiterator('a'))) 
1886          a2 = SubElement(e, 'a') 
1887          self.assertEqual( 
1888              [a, a2], 
1889              list(a.getiterator('a'))) 
1890          self.assertEqual( 
1891              [a2], 
1892              list(c.getiterator('a'))) 
1893   
1895          Element = self.etree.Element 
1896          SubElement = self.etree.SubElement 
1897   
1898          a = Element('a') 
1899          b = SubElement(a, 'b') 
1900          c = SubElement(a, 'c') 
1901          d = SubElement(b, 'd') 
1902          e = SubElement(c, 'e') 
1903   
1904          self.assertEqual( 
1905              [a, b, d, c, e], 
1906              list(a.getiterator('*'))) 
1907   
1909          Element = self.etree.Element 
1910          Comment = self.etree.Comment 
1911          SubElement = self.etree.SubElement 
1912   
1913          a = Element('a') 
1914          b = SubElement(a, 'b') 
1915          comment_b = Comment("TEST-b") 
1916          b.append(comment_b) 
1917   
1918          self.assertEqual( 
1919              [comment_b], 
1920              list(a.getiterator(Comment))) 
1921   
1922          comment_a = Comment("TEST-a") 
1923          a.append(comment_a) 
1924   
1925          self.assertEqual( 
1926              [comment_b, comment_a], 
1927              list(a.getiterator(Comment))) 
1928   
1929          self.assertEqual( 
1930              [comment_b], 
1931              list(b.getiterator(Comment))) 
1932   
1934          Element = self.etree.Element 
1935          PI = self.etree.ProcessingInstruction 
1936          SubElement = self.etree.SubElement 
1937   
1938          a = Element('a') 
1939          b = SubElement(a, 'b') 
1940          pi_b = PI("TEST-b") 
1941          b.append(pi_b) 
1942   
1943          self.assertEqual( 
1944              [pi_b], 
1945              list(a.getiterator(PI))) 
1946   
1947          pi_a = PI("TEST-a") 
1948          a.append(pi_a) 
1949   
1950          self.assertEqual( 
1951              [pi_b, pi_a], 
1952              list(a.getiterator(PI))) 
1953   
1954          self.assertEqual( 
1955              [pi_b], 
1956              list(b.getiterator(PI))) 
1957   
1959          Element = self.etree.Element 
1960          SubElement = self.etree.SubElement 
1961   
1962          a = Element('a') 
1963          a.text = 'a' 
1964          b = SubElement(a, 'b') 
1965          b.text = 'b' 
1966          b.tail = 'b1' 
1967          c = SubElement(a, 'c') 
1968          c.text = 'c' 
1969          c.tail = 'c1' 
1970          d = SubElement(b, 'd') 
1971          d.text = 'd' 
1972          d.tail = 'd1' 
1973          e = SubElement(c, 'e') 
1974          e.text = 'e' 
1975          e.tail = 'e1' 
1976   
1977          self.assertEqual( 
1978              [a, b, d, c, e], 
1979              list(a.getiterator())) 
1980          #self.assertEqual( 
1981          #    [d], 
1982          #    list(d.getiterator())) 
1983   
1985          Element = self.etree.Element 
1986          SubElement = self.etree.SubElement 
1987   
1988          a = Element('a') 
1989          a.text = 'a' 
1990          b = SubElement(a, 'b') 
1991          b.text = 'b' 
1992          b.tail = 'b1' 
1993          c = SubElement(a, 'c') 
1994          c.text = 'c' 
1995          c.tail = 'c1' 
1996          d = SubElement(b, 'd') 
1997          d.text = 'd' 
1998          d.tail = 'd1' 
1999          e = SubElement(c, 'e') 
2000          e.text = 'e' 
2001          e.tail = 'e1' 
2002   
2003          self.assertEqual( 
2004              [a], 
2005              list(a.getiterator('a'))) 
2006          a2 = SubElement(e, 'a') 
2007          self.assertEqual( 
2008              [a, a2], 
2009              list(a.getiterator('a')))    
2010          self.assertEqual( 
2011              [a2], 
2012              list(e.getiterator('a'))) 
2013   
2015          Element = self.etree.Element 
2016          SubElement = self.etree.SubElement 
2017   
2018          a = Element('a') 
2019          b = SubElement(a, 'b') 
2020          c = SubElement(a, 'c') 
2021          d = SubElement(a, 'd') 
2022   
2023          self.assertEqual( 
2024              [b, c], 
2025              a[0:2]) 
2026          self.assertEqual( 
2027              [b, c, d], 
2028              a[:]) 
2029          self.assertEqual( 
2030              [b, c, d], 
2031              a[:10]) 
2032          self.assertEqual( 
2033              [b], 
2034              a[0:1]) 
2035          self.assertEqual( 
2036              [], 
2037              a[10:12]) 
2038   
2040          Element = self.etree.Element 
2041          SubElement = self.etree.SubElement 
2042   
2043          a = Element('a') 
2044          b = SubElement(a, 'b') 
2045          c = SubElement(a, 'c') 
2046          d = SubElement(a, 'd') 
2047   
2048          self.assertEqual( 
2049              [d], 
2050              a[-1:]) 
2051          self.assertEqual( 
2052              [c, d], 
2053              a[-2:]) 
2054          self.assertEqual( 
2055              [c], 
2056              a[-2:-1]) 
2057          self.assertEqual( 
2058              [b, c], 
2059              a[-3:-1]) 
2060          self.assertEqual( 
2061              [b, c], 
2062              a[-3:2]) 
2063   
2065          Element = self.etree.Element 
2066          SubElement = self.etree.SubElement 
2067   
2068          a = Element('a') 
2069          b = SubElement(a, 'b') 
2070          c = SubElement(a, 'c') 
2071          d = SubElement(a, 'd') 
2072          e = SubElement(a, 'e') 
2073   
2074          self.assertEqual( 
2075              [e,d,c,b], 
2076              a[::-1]) 
2077          self.assertEqual( 
2078              [b,d], 
2079              a[::2]) 
2080          self.assertEqual( 
2081              [e,c], 
2082              a[::-2]) 
2083          self.assertEqual( 
2084              [d,c], 
2085              a[-2:0:-1]) 
2086          self.assertEqual( 
2087              [e], 
2088              a[:1:-2]) 
2089   
2091          ElementTree = self.etree.ElementTree 
2092           
2093          f = BytesIO('<a><b>B</b>B1<c>C</c>C1</a>') 
2094          doc = ElementTree(file=f) 
2095          a = doc.getroot() 
2096          b = a[0] 
2097          c = a[1] 
2098          self.assertEqual( 
2099              [b, c], 
2100              a[:]) 
2101          self.assertEqual( 
2102              [b], 
2103              a[0:1]) 
2104          self.assertEqual( 
2105              [c], 
2106              a[1:]) 
2107   
2109          Element = self.etree.Element 
2110          Comment = self.etree.Comment 
2111          SubElement = self.etree.SubElement 
2112   
2113          a = Element('a') 
2114          b = SubElement(a, 'b') 
2115          foo = Comment('foo') 
2116          a.append(foo) 
2117          c = SubElement(a, 'c') 
2118          self.assertEqual( 
2119              [b, foo, c], 
2120              a[:]) 
2121          self.assertEqual( 
2122              foo, 
2123              a[1]) 
2124          a[1] = new = Element('new') 
2125          self.assertEqual( 
2126              new, 
2127              a[1]) 
2128          self.assertXML( 
2129              _bytes('<a><b></b><new></new><c></c></a>'), 
2130              a) 
2131           
2133          Element = self.etree.Element 
2134          SubElement = self.etree.SubElement 
2135   
2136          a = Element('a') 
2137          b = SubElement(a, 'b') 
2138          c = SubElement(a, 'c') 
2139          d = SubElement(a, 'd') 
2140          e = SubElement(a, 'e') 
2141   
2142          del a[1:3] 
2143          self.assertEqual( 
2144              [b, e], 
2145              list(a)) 
2146   
2148          Element = self.etree.Element 
2149          SubElement = self.etree.SubElement 
2150   
2151          a = Element('a') 
2152          b = SubElement(a, 'b') 
2153          c = SubElement(a, 'c') 
2154          d = SubElement(a, 'd') 
2155          e = SubElement(a, 'e') 
2156   
2157          del a[1:-1] 
2158          self.assertEqual( 
2159              [b, e], 
2160              list(a)) 
2161   
2163          Element = self.etree.Element 
2164          SubElement = self.etree.SubElement 
2165   
2166          a = Element('a') 
2167          b = SubElement(a, 'b') 
2168          c = SubElement(a, 'c') 
2169          d = SubElement(a, 'd') 
2170          e = SubElement(a, 'e') 
2171   
2172          del a[-3:-1] 
2173          self.assertEqual( 
2174              [b, e], 
2175              list(a)) 
2176   
2178          Element = self.etree.Element 
2179          SubElement = self.etree.SubElement 
2180   
2181          a = Element('a') 
2182          b = SubElement(a, 'b') 
2183          c = SubElement(a, 'c') 
2184          d = SubElement(a, 'd') 
2185          e = SubElement(a, 'e') 
2186   
2187          del a[1::2] 
2188          self.assertEqual( 
2189              [b, d], 
2190              list(a)) 
2191   
2193          Element = self.etree.Element 
2194          SubElement = self.etree.SubElement 
2195   
2196          a = Element('a') 
2197          b = SubElement(a, 'b') 
2198          c = SubElement(a, 'c') 
2199          d = SubElement(a, 'd') 
2200          e = SubElement(a, 'e') 
2201   
2202          del a[::-1] 
2203          self.assertEqual( 
2204              [], 
2205              list(a)) 
2206   
2208          Element = self.etree.Element 
2209          SubElement = self.etree.SubElement 
2210   
2211          a = Element('a') 
2212          b = SubElement(a, 'b') 
2213          c = SubElement(a, 'c') 
2214          d = SubElement(a, 'd') 
2215          e = SubElement(a, 'e') 
2216   
2217          del a[::-2] 
2218          self.assertEqual( 
2219              [b, d], 
2220              list(a)) 
2221   
2223          ElementTree = self.etree.ElementTree 
2224          f = BytesIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>') 
2225          doc = ElementTree(file=f) 
2226          a = doc.getroot() 
2227          del a[1:3] 
2228          self.assertXML( 
2229              _bytes('<a><b></b>B2<e></e>E2</a>'), 
2230              a) 
2231   
2233          XML = self.etree.XML 
2234          a = XML(_bytes('<a><b></b>B2<c></c>C2</a>')) 
2235          b, c = a 
2236   
2237          del a[:] 
2238   
2239          self.assertEqual("B2", b.tail) 
2240          self.assertEqual("C2", c.tail) 
2241   
2243          # this could trigger a crash 
2244          Element = self.etree.Element 
2245          SubElement = self.etree.SubElement 
2246          a = Element('a') 
2247          b = SubElement(a, 'b') 
2248          c = SubElement(b, 'c') 
2249          del b # no more reference to b 
2250          del a[:] 
2251          self.assertEqual('c', c.tag) 
2252           
2254          Element = self.etree.Element 
2255          SubElement = self.etree.SubElement 
2256   
2257          a = Element('a') 
2258          b = SubElement(a, 'b') 
2259          c = SubElement(a, 'c') 
2260          d = SubElement(a, 'd') 
2261   
2262          e = Element('e') 
2263          f = Element('f') 
2264          g = Element('g') 
2265   
2266          s = [e, f, g] 
2267          a[1:2] = s 
2268          self.assertEqual( 
2269              [b, e, f, g, d], 
2270              list(a)) 
2271   
2273          Element = self.etree.Element 
2274          SubElement = self.etree.SubElement 
2275   
2276          a = Element('a') 
2277          b = SubElement(a, 'b') 
2278          c = SubElement(a, 'c') 
2279   
2280          e = Element('e') 
2281          f = Element('f') 
2282          g = Element('g') 
2283   
2284          s = [e, f, g] 
2285          a[:] = s 
2286          self.assertEqual( 
2287              [e, f, g], 
2288              list(a)) 
2289   
2291          Element = self.etree.Element 
2292          SubElement = self.etree.SubElement 
2293   
2294          a = Element('a') 
2295   
2296          e = Element('e') 
2297          f = Element('f') 
2298          g = Element('g') 
2299   
2300          s = [e, f, g] 
2301          a[:] = s 
2302          self.assertEqual( 
2303              [e, f, g], 
2304              list(a)) 
2305   
2307          Element = self.etree.Element 
2308          SubElement = self.etree.SubElement 
2309   
2310          a = Element('a') 
2311          b = SubElement(a, 'b') 
2312          c = SubElement(a, 'c') 
2313          d = SubElement(a, 'd') 
2314   
2315          s = [b, c, d] 
2316          a[:] = s 
2317          self.assertEqual( 
2318              [b, c, d], 
2319              list(a)) 
2320           
2322          Element = self.etree.Element 
2323          SubElement = self.etree.SubElement 
2324   
2325          a = Element('a') 
2326          b = SubElement(a, 'b') 
2327          c = SubElement(a, 'c') 
2328          d = SubElement(a, 'd') 
2329   
2330          s = [d, c, b] 
2331          a[:] = s 
2332          self.assertEqual( 
2333              [d, c, b], 
2334              list(a)) 
2335   
2337          Element = self.etree.Element 
2338          SubElement = self.etree.SubElement 
2339   
2340          a = Element('{ns}a') 
2341          b = SubElement(a, '{ns}b', {'{ns1}a1': 'test'}) 
2342          c = SubElement(a, '{ns}c', {'{ns2}a2': 'test'}) 
2343          d = SubElement(a, '{ns}d', {'{ns3}a3': 'test'}) 
2344   
2345          s = [d, c, b] 
2346          a[:] = s 
2347          self.assertEqual( 
2348              [d, c, b], 
2349              list(a)) 
2350          self.assertEqual( 
2351              ['{ns}d', '{ns}c', '{ns}b'], 
2352              [ child.tag for child in a ]) 
2353   
2354          self.assertEqual( 
2355              [['{ns3}a3'], ['{ns2}a2'], ['{ns1}a1']], 
2356              [ list(child.attrib.keys()) for child in a ]) 
2357   
2359          Element = self.etree.Element 
2360          SubElement = self.etree.SubElement 
2361   
2362          a = Element('{ns}a') 
2363          b = SubElement(a, '{ns1}b', {'{ns}a1': 'test'}) 
2364          c = SubElement(a, '{ns2}c', {'{ns}a2': 'test'}) 
2365          d = SubElement(a, '{ns3}d', {'{ns}a3': 'test'}) 
2366   
2367          s = [d, c, b] 
2368          a[:] = s 
2369          self.assertEqual( 
2370              [d, c, b], 
2371              list(a)) 
2372          self.assertEqual( 
2373              ['{ns3}d', '{ns2}c', '{ns1}b'], 
2374              [ child.tag for child in a ]) 
2375   
2376          self.assertEqual( 
2377              [['{ns}a3'], ['{ns}a2'], ['{ns}a1']], 
2378              [ list(child.attrib.keys()) for child in a ]) 
2379   
2381          Element = self.etree.Element 
2382          SubElement = self.etree.SubElement 
2383   
2384          a = Element('a') 
2385          b = SubElement(a, 'b') 
2386          c = SubElement(a, 'c') 
2387   
2388          e = Element('e') 
2389          f = Element('f') 
2390          g = Element('g') 
2391          h = Element('h') 
2392   
2393          s = [e, f] 
2394          a[99:] = s 
2395          self.assertEqual( 
2396              [b, c, e, f], 
2397              list(a)) 
2398   
2399          s = [g, h] 
2400          a[:0] = s 
2401          self.assertEqual( 
2402              [g, h, b, c, e, f], 
2403              list(a)) 
2404   
2406          Element = self.etree.Element 
2407          SubElement = self.etree.SubElement 
2408   
2409          a = Element('a') 
2410          b = SubElement(a, 'b') 
2411          c = SubElement(a, 'c') 
2412          d = SubElement(a, 'd') 
2413   
2414          e = Element('e') 
2415          f = Element('f') 
2416          g = Element('g') 
2417   
2418          s = [e, f, g] 
2419          a[3:] = s 
2420          self.assertEqual( 
2421              [b, c, d, e, f, g], 
2422              list(a)) 
2423   
2425          Element = self.etree.Element 
2426          SubElement = self.etree.SubElement 
2427   
2428          a = Element('a') 
2429          b = SubElement(a, 'b') 
2430          c = SubElement(a, 'c') 
2431   
2432          e = Element('e') 
2433          f = Element('f') 
2434   
2435          s = [e] 
2436          a[0:1] = s 
2437          self.assertEqual( 
2438              [e, c], 
2439              list(a)) 
2440   
2441          s = [f] 
2442          a[1:2] = s 
2443          self.assertEqual( 
2444              [e, f], 
2445              list(a)) 
2446   
2448          ElementTree = self.etree.ElementTree 
2449          Element = self.etree.Element 
2450          f = BytesIO('<a><b></b>B2<c></c>C2<d></d>D2<e></e>E2</a>') 
2451          doc = ElementTree(file=f) 
2452          a = doc.getroot() 
2453          x = Element('x') 
2454          y = Element('y') 
2455          z = Element('z') 
2456          x.tail = 'X2' 
2457          y.tail = 'Y2' 
2458          z.tail = 'Z2' 
2459          a[1:3] = [x, y, z] 
2460          self.assertXML( 
2461              _bytes('<a><b></b>B2<x></x>X2<y></y>Y2<z></z>Z2<e></e>E2</a>'), 
2462              a) 
2463   
2465          Element = self.etree.Element 
2466          SubElement = self.etree.SubElement 
2467   
2468          a = Element('a') 
2469          b = SubElement(a, 'b') 
2470          c = SubElement(a, 'c') 
2471          d = SubElement(a, 'd') 
2472   
2473          x = Element('x') 
2474          y = Element('y') 
2475   
2476          a[1:-1] = [x, y] 
2477          self.assertEqual( 
2478              [b, x, y, d], 
2479              list(a)) 
2480   
2482          Element = self.etree.Element 
2483          SubElement = self.etree.SubElement 
2484   
2485          a = Element('a') 
2486          b = SubElement(a, 'b') 
2487          c = SubElement(a, 'c') 
2488          d = SubElement(a, 'd') 
2489   
2490          x = Element('x') 
2491          y = Element('y') 
2492   
2493          a[1:-2] = [x, y] 
2494          self.assertEqual( 
2495              [b, x, y, c, d], 
2496              list(a)) 
2497   
2499          Element = self.etree.Element 
2500   
2501          a = Element('a') 
2502   
2503          b = Element('b') 
2504          c = Element('c') 
2505   
2506          a[:] = [b, c] 
2507          self.assertEqual( 
2508              [b, c], 
2509              list(a)) 
2510   
2512          Element = self.etree.Element 
2513          ElementTree = self.etree.ElementTree 
2514   
2515          a = Element('a') 
2516          a.tail = 'A2' 
2517          t = ElementTree(element=a) 
2518          self.assertEqual('A2', 
2519                            a.tail) 
2520   
2522          Element = self.etree.Element 
2523          SubElement = self.etree.SubElement 
2524          ElementTree = self.etree.ElementTree 
2525           
2526          a = Element('a') 
2527          b = SubElement(a, 'b') 
2528          c = SubElement(a, 'c') 
2529          d = SubElement(b, 'd') 
2530          e = SubElement(c, 'e') 
2531          t = ElementTree(element=a) 
2532           
2533          self.assertEqual( 
2534              [a, b, d, c, e], 
2535              list(t.getiterator())) 
2536   
2538          Element = self.etree.Element 
2539          SubElement = self.etree.SubElement 
2540          ElementTree = self.etree.ElementTree 
2541          a = Element('a') 
2542          b = SubElement(a, 'b') 
2543          c = SubElement(a, 'c') 
2544          d = SubElement(b, 'd') 
2545          e = SubElement(c, 'e') 
2546          t = ElementTree(element=a) 
2547           
2548          self.assertEqual( 
2549              [a], 
2550              list(t.getiterator('a'))) 
2551          a2 = SubElement(e, 'a') 
2552          self.assertEqual( 
2553              [a, a2], 
2554              list(t.getiterator('a'))) 
2555   
2557          ElementTree = self.etree.ElementTree 
2558          ns = 'http://xml.infrae.com/1' 
2559          f = BytesIO('<x:a xmlns:x="%s"><x:b></x:b></x:a>' % ns) 
2560          t = ElementTree(file=f) 
2561          a = t.getroot() 
2562          self.assertEqual('{%s}a' % ns, 
2563                            a.tag) 
2564          self.assertEqual('{%s}b' % ns, 
2565                            a[0].tag) 
2566   
2568          ElementTree = self.etree.ElementTree 
2569          ns = 'http://xml.infrae.com/1' 
2570          ns2 = 'http://xml.infrae.com/2' 
2571          f = BytesIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2)) 
2572          t = ElementTree(file=f) 
2573          a = t.getroot() 
2574          self.assertEqual('{%s}a' % ns, 
2575                            a.tag) 
2576          self.assertEqual('{%s}b' % ns, 
2577                            a[0].tag) 
2578          self.assertEqual('{%s}b' % ns2, 
2579                            a[1].tag) 
2580   
2582          Element = self.etree.Element 
2583          SubElement = self.etree.SubElement 
2584          ns = 'http://xml.infrae.com/1' 
2585          ns2 = 'http://xml.infrae.com/2' 
2586          a = Element('{%s}a' % ns) 
2587          b = SubElement(a, '{%s}b' % ns2) 
2588          c = SubElement(a, '{%s}c' % ns) 
2589          self.assertEqual('{%s}a' % ns, 
2590                            a.tag) 
2591          self.assertEqual('{%s}b' % ns2, 
2592                            b.tag) 
2593          self.assertEqual('{%s}c' % ns, 
2594                            c.tag) 
2595          self.assertEqual('{%s}a' % ns, 
2596                            a.tag) 
2597          self.assertEqual('{%s}b' % ns2, 
2598                            b.tag) 
2599          self.assertEqual('{%s}c' % ns, 
2600                            c.tag) 
2601   
2603          Element = self.etree.Element 
2604          SubElement = self.etree.SubElement 
2605          ElementTree = self.etree.ElementTree 
2606   
2607          ns = 'http://xml.infrae.com/1' 
2608          ns2 = 'http://xml.infrae.com/2' 
2609          f = BytesIO('<a xmlns="%s" xmlns:x="%s"><x:b></x:b><b></b></a>' % (ns, ns2)) 
2610          t = ElementTree(file=f) 
2611   
2612          a = t.getroot() 
2613          self.assertEqual('{%s}a' % ns, 
2614                            a.tag) 
2615          self.assertEqual('{%s}b' % ns2, 
2616                            a[0].tag) 
2617          self.assertEqual('{%s}b' % ns, 
2618                            a[1].tag) 
2619   
2621          Element = self.etree.Element 
2622          ns = 'http://xml.infrae.com/1' 
2623          ns2 = 'http://xml.infrae.com/2' 
2624          a = Element('a') 
2625          a.set('{%s}foo' % ns, 'Foo') 
2626          a.set('{%s}bar' % ns2, 'Bar') 
2627          self.assertEqual( 
2628              'Foo', 
2629              a.get('{%s}foo' % ns)) 
2630          self.assertEqual( 
2631              'Bar', 
2632              a.get('{%s}bar' % ns2)) 
2633          try: 
2634              self.assertXML( 
2635                  _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns0:foo="Foo" ns1:bar="Bar"></a>' % (ns, ns2)), 
2636                  a) 
2637          except AssertionError: 
2638              self.assertXML( 
2639                  _bytes('<a xmlns:ns0="%s" xmlns:ns1="%s" ns1:foo="Foo" ns0:bar="Bar"></a>' % (ns2, ns)), 
2640                  a) 
2641   
2643          Element = self.etree.Element 
2644          one = self.etree.fromstring( 
2645              _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 
2646          baz = one[0][0] 
2647   
2648          two = Element('root') 
2649          two.append(baz) 
2650          # removing the originating document could cause a crash/error before 
2651          # as namespace is not moved along with it 
2652          del one, baz 
2653          self.assertEqual('{http://a.b.c}baz', two[0].tag) 
2654   
2656          tostring = self.etree.tostring 
2657          root = self.etree.XML( 
2658              _bytes('<foo><bar xmlns:ns="http://a.b.c"><ns:baz/></bar></foo>')) 
2659          baz = root[0][0] 
2660   
2661          nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 
2662                              tostring(baz)) 
2663          self.assertEqual([_bytes("http://a.b.c")], nsdecl) 
2664   
2666          tostring = self.etree.tostring 
2667          root = self.etree.XML( 
2668              _bytes('<foo><bar xmlns="http://a.b.c"><baz/></bar></foo>')) 
2669          baz = root[0][0] 
2670   
2671          nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 
2672                              tostring(baz)) 
2673          self.assertEqual([_bytes("http://a.b.c")], nsdecl) 
2674           
2676          tostring = self.etree.tostring 
2677          root = self.etree.XML( 
2678              _bytes('<foo xmlns:ns="http://a.b.c"><bar><ns:baz/></bar></foo>')) 
2679          baz = root[0][0] 
2680   
2681          nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 
2682                              tostring(baz)) 
2683   
2684          self.assertEqual([_bytes("http://a.b.c")], nsdecl) 
2685           
2687          Element = self.etree.Element 
2688          SubElement = self.etree.SubElement 
2689   
2690          root = Element("foo") 
2691          bar = SubElement(root, "{http://a.b.c}bar") 
2692          baz = SubElement(bar, "{http://a.b.c}baz") 
2693   
2694          nsdecl = re.findall(_bytes("xmlns(?::[a-z0-9]+)?=[\"']([^\"']+)[\"']"), 
2695                              self.etree.tostring(baz)) 
2696   
2697          self.assertEqual([_bytes("http://a.b.c")], nsdecl) 
2698   
2700          Element = self.etree.Element 
2701   
2702          root = Element('element') 
2703   
2704          subelement = Element('subelement', 
2705                               {"{http://www.w3.org/XML/1998/namespace}id": "foo"}) 
2706          self.assertEqual(1, len(subelement.attrib)) 
2707          self.assertEqual( 
2708              "foo", 
2709              subelement.get("{http://www.w3.org/XML/1998/namespace}id")) 
2710   
2711          root.append(subelement) 
2712          self.assertEqual(1, len(subelement.attrib)) 
2713          self.assertEqual( 
2714              list({"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items()), 
2715              list(subelement.attrib.items())) 
2716          self.assertEqual( 
2717              "foo", 
2718              subelement.get("{http://www.w3.org/XML/1998/namespace}id")) 
2719   
2721          parse = self.etree.parse 
2722          tostring = self.etree.tostring 
2723   
2724          ns_href = "http://a.b.c" 
2725          one = parse( 
2726              BytesIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)) 
2727          baz = one.getroot()[0][0] 
2728   
2729          parsed = parse(BytesIO( tostring(baz) )).getroot() 
2730          self.assertEqual('{%s}baz' % ns_href, parsed.tag) 
2731   
2733          fromstring = self.etree.fromstring 
2734          tostring = self.etree.tostring 
2735   
2736          ns_href = "http://a.b.c" 
2737          xml = _bytes('<root xmlns="%s" xmlns:x="%s"><el x:a="test" /></root>' % ( 
2738                  ns_href,ns_href)) 
2739          root = fromstring(xml) 
2740          self.assertEqual('test', root[0].get('{%s}a' % ns_href)) 
2741   
2742          xml2 = tostring(root) 
2743          self.assertTrue(_bytes(':a=') in xml2, xml2) 
2744   
2745          root2 = fromstring(xml2) 
2746          self.assertEqual('test', root2[0].get('{%s}a' % ns_href)) 
2747   
2749          fromstring = self.etree.fromstring 
2750          tostring = self.etree.tostring 
2751   
2752          ns_href = "http://a.b.c" 
2753          xml = _bytes('<root xmlns="%s" xmlns:x="%s"><el x:a="test" /></root>' % ( 
2754                  ns_href,ns_href)) 
2755          root = fromstring(xml) 
2756          self.assertEqual('test', root[0].get('{%s}a' % ns_href)) 
2757   
2758          root[0].set('{%s}a' % ns_href, 'TEST') 
2759   
2760          xml2 = tostring(root) 
2761          self.assertTrue(_bytes(':a=') in xml2, xml2) 
2762   
2763          root2 = fromstring(xml2) 
2764          self.assertEqual('TEST', root2[0].get('{%s}a' % ns_href)) 
2765   
2766      required_versions_ET['test_register_namespace'] = (1,3) 
2768          # ET 1.3+ 
2769          Element = self.etree.Element 
2770          prefix = 'TESTPREFIX' 
2771          namespace = 'http://seriously.unknown/namespace/URI' 
2772   
2773          el = Element('{%s}test' % namespace) 
2774          self.assertEqual(_bytes('<ns0:test xmlns:ns0="%s"></ns0:test>' % namespace), 
2775              self._writeElement(el)) 
2776   
2777          self.etree.register_namespace(prefix, namespace) 
2778          el = Element('{%s}test' % namespace) 
2779          self.assertEqual(_bytes('<%s:test xmlns:%s="%s"></%s:test>' % ( 
2780              prefix, prefix, namespace, prefix)), 
2781              self._writeElement(el)) 
2782   
2783          self.assertRaises(ValueError, self.etree.register_namespace, 'ns25', namespace) 
2784   
2786          tostring = self.etree.tostring 
2787          Element = self.etree.Element 
2788          SubElement = self.etree.SubElement 
2789           
2790          a = Element('a') 
2791          b = SubElement(a, 'b') 
2792          c = SubElement(a, 'c') 
2793           
2794          self.assertEqual(_bytes('<a><b></b><c></c></a>'), 
2795                            canonicalize(tostring(a))) 
2796   
2798          tostring = self.etree.tostring 
2799          Element = self.etree.Element 
2800          SubElement = self.etree.SubElement 
2801           
2802          a = Element('a') 
2803          b = SubElement(a, 'b') 
2804          c = SubElement(a, 'c') 
2805          d = SubElement(c, 'd') 
2806          self.assertEqual(_bytes('<b></b>'), 
2807                            canonicalize(tostring(b))) 
2808          self.assertEqual(_bytes('<c><d></d></c>'), 
2809                            canonicalize(tostring(c))) 
2810           
2812          tostring = self.etree.tostring 
2813          Element = self.etree.Element 
2814          SubElement = self.etree.SubElement 
2815           
2816          a = Element('a') 
2817          b = SubElement(a, 'b') 
2818          c = SubElement(a, 'c') 
2819          d = SubElement(c, 'd') 
2820          b.tail = 'Foo' 
2821   
2822          self.assertTrue(tostring(b) == _bytes('<b/>Foo') or 
2823                       tostring(b) == _bytes('<b />Foo')) 
2824   
2825      required_versions_ET['test_tostring_method_html'] = (1,3) 
2827          tostring = self.etree.tostring 
2828          Element = self.etree.Element 
2829          SubElement = self.etree.SubElement 
2830           
2831          html = Element('html') 
2832          body = SubElement(html, 'body') 
2833          p = SubElement(body, 'p') 
2834          p.text = "html" 
2835          SubElement(p, 'br').tail = "test" 
2836   
2837          self.assertEqual(_bytes('<html><body><p>html<br>test</p></body></html>'), 
2838                            tostring(html, method="html")) 
2839   
2840      required_versions_ET['test_tostring_method_text'] = (1,3) 
2842          tostring = self.etree.tostring 
2843          Element = self.etree.Element 
2844          SubElement = self.etree.SubElement 
2845           
2846          a = Element('a') 
2847          a.text = "A" 
2848          a.tail = "tail" 
2849          b = SubElement(a, 'b') 
2850          b.text = "B" 
2851          b.tail = "TAIL" 
2852          c = SubElement(a, 'c') 
2853          c.text = "C" 
2854           
2855          self.assertEqual(_bytes('ABTAILCtail'), 
2856                            tostring(a, method="text")) 
2857   
2859          iterparse = self.etree.iterparse 
2860          f = BytesIO('<a><b></b><c/></a>') 
2861   
2862          iterator = iterparse(f) 
2863          self.assertEqual(None, 
2864                            iterator.root) 
2865          events = list(iterator) 
2866          root = iterator.root 
2867          self.assertEqual( 
2868              [('end', root[0]), ('end', root[1]), ('end', root)], 
2869              events) 
2870   
2872          iterparse = self.etree.iterparse 
2873          f = BytesIO('<a><b></b><c/></a>') 
2874   
2875          iterator = iterparse(f) 
2876          self.assertEqual(None, 
2877                            iterator.root) 
2878          event, element = next(iter(iterator)) 
2879          self.assertEqual('end', event) 
2880          self.assertEqual('b', element.tag) 
2881   
2883          iterparse = self.etree.iterparse 
2884          iterator = iterparse(fileInTestDir("test.xml")) 
2885          self.assertEqual(None, 
2886                            iterator.root) 
2887          events = list(iterator) 
2888          root = iterator.root 
2889          self.assertEqual( 
2890              [('end', root[0]), ('end', root)], 
2891              events) 
2892   
2894          iterparse = self.etree.iterparse 
2895          f = BytesIO('<a><b></b><c/></a>') 
2896   
2897          iterator = iterparse(f, events=('start',)) 
2898          events = list(iterator) 
2899          root = iterator.root 
2900          self.assertEqual( 
2901              [('start', root), ('start', root[0]), ('start', root[1])], 
2902              events) 
2903   
2905          iterparse = self.etree.iterparse 
2906          f = BytesIO('<a><b></b><c/></a>') 
2907   
2908          iterator = iterparse(f, events=('start','end')) 
2909          events = list(iterator) 
2910          root = iterator.root 
2911          self.assertEqual( 
2912              [('start', root), ('start', root[0]), ('end', root[0]), 
2913               ('start', root[1]), ('end', root[1]), ('end', root)], 
2914              events) 
2915   
2917          iterparse = self.etree.iterparse 
2918          f = BytesIO('<a><b></b><c/></a>') 
2919   
2920          iterator = iterparse(f) 
2921          for event, elem in iterator: 
2922              elem.clear() 
2923   
2924          root = iterator.root 
2925          self.assertEqual(0, 
2926                            len(root)) 
2927   
2929          iterparse = self.etree.iterparse 
2930          CHILD_COUNT = 12345 
2931          f = BytesIO('<a>%s</a>' % ('<b>test</b>'*CHILD_COUNT)) 
2932   
2933          i = 0 
2934          for key in iterparse(f): 
2935              event, element = key 
2936              i += 1 
2937          self.assertEqual(i, CHILD_COUNT + 1) 
2938   
2940          iterparse = self.etree.iterparse 
2941          f = BytesIO('<a xmlns="http://ns1/"><b><c xmlns="http://ns2/"/></b></a>') 
2942   
2943          attr_name = '{http://testns/}bla' 
2944          events = [] 
2945          iterator = iterparse(f, events=('start','end','start-ns','end-ns')) 
2946          for event, elem in iterator: 
2947              events.append(event) 
2948              if event == 'start': 
2949                  if elem.tag != '{http://ns1/}a': 
2950                      elem.set(attr_name, 'value') 
2951   
2952          self.assertEqual( 
2953              ['start-ns', 'start', 'start', 'start-ns', 'start', 
2954               'end', 'end-ns', 'end', 'end', 'end-ns'], 
2955              events) 
2956   
2957          root = iterator.root 
2958          self.assertEqual( 
2959              None, 
2960              root.get(attr_name)) 
2961          self.assertEqual( 
2962              'value', 
2963              root[0].get(attr_name)) 
2964   
2966          iterparse = self.etree.iterparse 
2967          f = BytesIO('<a><b><d/></b><c/></a>') 
2968   
2969          counts = [] 
2970          for event, elem in iterparse(f): 
2971              counts.append(len(list(elem.getiterator()))) 
2972          self.assertEqual( 
2973              [1,2,1,4], 
2974              counts) 
2975   
2977          iterparse = self.etree.iterparse 
2978          f = BytesIO('<a><b><d/></b><c/></a>') 
2979   
2980          for event, node in etree.iterparse(f): pass 
2981   
2982          root = etree.Element('new_root', {}) 
2983          root[:] = node[:] 
2984   
2985          self.assertEqual( 
2986              ['b', 'c'], 
2987              [ el.tag for el in root ]) 
2988   
2990          tostring = self.etree.tostring 
2991          f = BytesIO('<root><![CDATA[test]]></root>') 
2992          context = self.etree.iterparse(f) 
2993          content = [ el.text for event,el in context ] 
2994   
2995          self.assertEqual(['test'], content) 
2996          self.assertEqual(_bytes('<root>test</root>'), 
2997                            tostring(context.root)) 
2998   
3000          parse = self.etree.parse 
3001          # from file 
3002          tree = parse(fileInTestDir('test.xml')) 
3003          self.assertXML( 
3004              _bytes('<a><b></b></a>'), 
3005              tree.getroot()) 
3006   
3010   
3014   
3015      required_versions_ET['test_parse_error'] = (1,3) 
3017          # ET < 1.3 raises ExpatError 
3018          parse = self.etree.parse 
3019          f = BytesIO('<a><b></c></b></a>') 
3020          self.assertRaises(SyntaxError, parse, f) 
3021          f.close() 
3022   
3023      required_versions_ET['test_parse_error_from_file'] = (1,3) 
3025          parse = self.etree.parse 
3026          # from file 
3027          f = open(fileInTestDir('test_broken.xml'), 'rb') 
3028          self.assertRaises(SyntaxError, parse, f) 
3029          f.close() 
3030   
3032          parse = self.etree.parse 
3033          # from file object 
3034          f = open(fileInTestDir('test.xml'), 'rb') 
3035          tree = parse(f) 
3036          f.close() 
3037          self.assertXML( 
3038              _bytes('<a><b></b></a>'), 
3039              tree.getroot()) 
3040   
3042          parse = self.etree.parse 
3043          f = BytesIO('<a><b></b></a>') 
3044          tree = parse(f) 
3045          f.close() 
3046          self.assertXML( 
3047              _bytes('<a><b></b></a>'), 
3048              tree.getroot() 
3049             ) 
3050   
3052          tostring = self.etree.tostring 
3053          root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>')) 
3054   
3055          self.assertEqual('test', root.text) 
3056          self.assertEqual(_bytes('<root>test</root>'), 
3057                            tostring(root)) 
3058   
3060          # this can fail in libxml2 <= 2.6.22 
3061          parse = self.etree.parse 
3062          tree = parse(BytesIO('<?xml version="1.0" encoding="ascii"?><html/>')) 
3063          self.assertXML(_bytes('<html></html>'), 
3064                         tree.getroot()) 
3065   
3067          Element = self.etree.Element 
3068   
3069          a = Element('a') 
3070          a.text = _str('Søk på nettet') 
3071          self.assertXML( 
3072              _str('<a>Søk på nettet</a>').encode('UTF-8'), 
3073              a, 'utf-8') 
3074   
3076          ElementTree = self.etree.ElementTree 
3077          Element = self.etree.Element 
3078   
3079          a = Element('a') 
3080          a.text = _str('Søk på nettet') 
3081           
3082          f = BytesIO() 
3083          tree = ElementTree(element=a) 
3084          tree.write(f, encoding='utf-8') 
3085          self.assertEqual(_str('<a>Søk på nettet</a>').encode('UTF-8'), 
3086                            f.getvalue().replace(_bytes('\n'),_bytes(''))) 
3087   
3089          parse = self.etree.parse 
3090          # from file 
3091          tree = parse(fileInTestDir('test-string.xml')) 
3092          self.assertXML( 
3093              _str('<a>Søk på nettet</a>').encode('UTF-8'), 
3094              tree.getroot(), 'UTF-8') 
3095   
3097          parse = self.etree.parse 
3098          # from file object 
3099          f = open(fileInTestDir('test-string.xml'), 'rb') 
3100          tree = parse(f) 
3101          f.close() 
3102          self.assertXML( 
3103              _str('<a>Søk på nettet</a>').encode('UTF-8'), 
3104              tree.getroot(), 'UTF-8') 
3105   
3107          ElementTree = self.etree.ElementTree 
3108          Element = self.etree.Element 
3109   
3110          a = Element('a') 
3111          a.text = _str('Søk på nettet') 
3112   
3113          f = BytesIO() 
3114          tree = ElementTree(element=a) 
3115          tree.write(f, encoding='iso-8859-1') 
3116          result = f.getvalue() 
3117          declaration = _bytes("<?xml version=\'1.0\' encoding=\'iso-8859-1\'?>") 
3118          self.assertEncodingDeclaration(result, _bytes('iso-8859-1')) 
3119          result = result.split(_bytes('?>'), 1)[-1].replace(_bytes('\n'),_bytes('')) 
3120          self.assertEqual(_str('<a>Søk på nettet</a>').encode('iso-8859-1'), 
3121                            result) 
3122   
3123      required_versions_ET['test_parse_encoding_8bit_explicit'] = (1,3) 
3125          XMLParser = self.XMLParser 
3126   
3127          text = _str('Søk på nettet') 
3128          xml_latin1 = (_str('<a>%s</a>') % text).encode('iso-8859-1') 
3129   
3130          self.assertRaises(self.etree.ParseError, 
3131                            self.etree.parse, 
3132                            BytesIO(xml_latin1)) 
3133   
3134          tree = self.etree.parse(BytesIO(xml_latin1), 
3135                                  XMLParser(encoding="iso-8859-1")) 
3136          a = tree.getroot() 
3137          self.assertEqual(a.text, text) 
3138   
3139      required_versions_ET['test_parse_encoding_8bit_override'] = (1,3) 
3141          XMLParser = self.XMLParser 
3142   
3143          text = _str('Søk på nettet') 
3144          wrong_declaration = _str("<?xml version='1.0' encoding='UTF-8'?>") 
3145          xml_latin1 = (_str('%s<a>%s</a>') % (wrong_declaration, text) 
3146                        ).encode('iso-8859-1') 
3147   
3148          self.assertRaises(self.etree.ParseError, 
3149                            self.etree.parse, 
3150                            BytesIO(xml_latin1)) 
3151   
3152          tree = self.etree.parse(BytesIO(xml_latin1), 
3153                                  XMLParser(encoding="iso-8859-1")) 
3154          a = tree.getroot() 
3155          self.assertEqual(a.text, text) 
3156   
3158          # raise error on wrong encoding declaration in unicode strings 
3159          XML = self.etree.XML 
3160          test_utf = (_str('<?xml version="1.0" encoding="iso-8859-1"?>') + 
3161                      _str('<a>Søk på nettet</a>')) 
3162          self.assertRaises(SyntaxError, XML, test_utf) 
3163   
3165          ElementTree = self.etree.ElementTree 
3166          Element = self.etree.Element 
3167   
3168          a = Element('a') 
3169          a.text = _str('Søk på nettet') 
3170           
3171          f = BytesIO() 
3172          tree = ElementTree(element=a) 
3173          tree.write(f) 
3174          data = f.getvalue().replace(_bytes('\n'),_bytes('')) 
3175          self.assertEqual( 
3176              _str('<a>Søk på nettet</a>').encode('ASCII', 'xmlcharrefreplace'), 
3177              data) 
3178   
3180          Element = self.etree.Element 
3181          tostring = self.etree.tostring 
3182   
3183          a = Element('a') 
3184          a.text = _str('Søk på nettet') 
3185          self.assertEqual(_str('<a>Søk på nettet</a>').encode('UTF-8'), 
3186                           tostring(a, encoding='utf-8')) 
3187   
3189          Element = self.etree.Element 
3190          tostring = self.etree.tostring 
3191           
3192          a = Element('a') 
3193          a.text = _str('Søk på nettet') 
3194          self.assertRaises(LookupError, tostring, a, 
3195                            encoding='Invalid Encoding') 
3196   
3198          Element = self.etree.Element 
3199          SubElement = self.etree.SubElement 
3200          tostring = self.etree.tostring 
3201   
3202          a = Element('a') 
3203          b = SubElement(a, 'b') 
3204          b.text = _str('Søk på nettet') 
3205          self.assertEqual(_str('<b>Søk på nettet</b>').encode('UTF-8'), 
3206                           tostring(b, encoding='utf-8')) 
3207   
3209          Element = self.etree.Element 
3210          SubElement = self.etree.SubElement 
3211          tostring = self.etree.tostring 
3212   
3213          a = Element('a') 
3214          b = SubElement(a, 'b') 
3215          b.text = _str('Søk på nettet') 
3216          b.tail = _str('Søk') 
3217          self.assertEqual(_str('<b>Søk på nettet</b>Søk').encode('UTF-8'), 
3218                           tostring(b, encoding='utf-8')) 
3219           
3221          Element = self.etree.Element 
3222          SubElement = self.etree.SubElement 
3223          tostring = self.etree.tostring 
3224   
3225          a = Element('a') 
3226          a.text = _str('Søk på nettet') 
3227   
3228          expected = _bytes('<a>Søk på nettet</a>') 
3229          self.assertEqual( 
3230              expected, 
3231              tostring(a)) 
3232   
3234          Element = self.etree.Element 
3235          SubElement = self.etree.SubElement 
3236          tostring = self.etree.tostring 
3237   
3238          a = Element('a') 
3239          b = SubElement(a, 'b') 
3240          b.text = _str('Søk på nettet') 
3241   
3242          expected = _bytes('<b>Søk på nettet</b>') 
3243          self.assertEqual( 
3244              expected, 
3245              tostring(b)) 
3246   
3248          utext = _str('Søk på nettet') 
3249          uxml = _str('<p>%s</p>') % utext 
3250          prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>') 
3251          isoxml = prologue + uxml.encode('iso-8859-1') 
3252          tree = self.etree.XML(isoxml) 
3253          self.assertEqual(utext, tree.text) 
3254   
3256          utext = _str('Søk på nettet') 
3257          uxml = (_str('<?xml version="1.0" encoding="UTF-8"?>') + 
3258                  _str('<p>%s</p>') % utext) 
3259          bom = _bytes('\\xEF\\xBB\\xBF').decode("unicode_escape").encode("latin1") 
3260          xml = bom + uxml.encode("utf-8") 
3261          tree = etree.XML(xml) 
3262          self.assertEqual(utext, tree.text) 
3263   
3265          utext = _str('Søk på nettet') 
3266          uxml = _str('<p>%s</p>') % utext 
3267          prologue = _bytes('<?xml version="1.0" encoding="iso-8859-1" ?>') 
3268          isoxml = prologue + uxml.encode('iso-8859-1') 
3269          el = self.etree.parse(BytesIO(isoxml)).getroot() 
3270          self.assertEqual(utext, el.text) 
3271   
3273          Element = self.etree.Element 
3274          ElementTree = self.etree.ElementTree 
3275   
3276          a = Element('a') 
3277          a.text = "Foo" 
3278          atree = ElementTree(a) 
3279   
3280          btree = copy.deepcopy(atree) 
3281          self.assertEqual("Foo", atree.getroot().text) 
3282          self.assertEqual("Foo", btree.getroot().text) 
3283          self.assertFalse(btree is atree) 
3284          self.assertFalse(btree.getroot() is atree.getroot()) 
3285   
3287          Element = self.etree.Element 
3288           
3289          a = Element('a') 
3290          a.text = 'Foo' 
3291   
3292          b = copy.deepcopy(a) 
3293          self.assertEqual('Foo', b.text) 
3294           
3295          b.text = 'Bar' 
3296          self.assertEqual('Bar', b.text) 
3297          self.assertEqual('Foo', a.text) 
3298   
3299          del a 
3300          self.assertEqual('Bar', b.text) 
3301   
3303          Element = self.etree.Element 
3304           
3305          a = Element('a') 
3306          a.tail = 'Foo' 
3307   
3308          b = copy.deepcopy(a) 
3309          self.assertEqual('Foo', b.tail) 
3310           
3311          b.tail = 'Bar' 
3312          self.assertEqual('Bar', b.tail) 
3313          self.assertEqual('Foo', a.tail) 
3314   
3315          del a 
3316          self.assertEqual('Bar', b.tail) 
3317   
3319          Element = self.etree.Element 
3320          SubElement = self.etree.SubElement 
3321   
3322          root = Element('root') 
3323          a = SubElement(root, 'a') 
3324          a.text = 'FooText' 
3325          a.tail = 'FooTail' 
3326   
3327          b = copy.deepcopy(a) 
3328          self.assertEqual('FooText', b.text) 
3329          self.assertEqual('FooTail', b.tail) 
3330           
3331          b.text = 'BarText' 
3332          b.tail = 'BarTail' 
3333          self.assertEqual('BarTail', b.tail) 
3334          self.assertEqual('FooTail', a.tail) 
3335          self.assertEqual('BarText', b.text) 
3336          self.assertEqual('FooText', a.text) 
3337   
3338          del a 
3339          self.assertEqual('BarTail', b.tail) 
3340          self.assertEqual('BarText', b.text) 
3341   
3343          root = self.etree.XML(_bytes('''<doc xmlns="dns" xmlns:t="tns"> 
3344          <parent><node t:foo="bar" /></parent> 
3345          </doc>''')) 
3346          self.assertEqual( 
3347              root[0][0].get('{tns}foo'), 
3348              copy.deepcopy(root[0])[0].get('{tns}foo') ) 
3349          self.assertEqual( 
3350              root[0][0].get('{tns}foo'), 
3351              copy.deepcopy(root[0][0]).get('{tns}foo') ) 
3352           
3354          # previously caused a crash 
3355          Element = self.etree.Element 
3356          tostring = self.etree.tostring 
3357           
3358          a = Element('a') 
3359          b = copy.deepcopy(a) 
3360          a.append( Element('C') ) 
3361          b.append( Element('X') ) 
3362   
3363          self.assertEqual(_bytes('<a><C/></a>'), 
3364                            tostring(a).replace(_bytes(' '), _bytes(''))) 
3365          self.assertEqual(_bytes('<a><X/></a>'), 
3366                            tostring(b).replace(_bytes(' '), _bytes(''))) 
3367   
3369          # previously caused a crash 
3370          # not supported by ET < 1.3! 
3371          Comment = self.etree.Comment 
3372           
3373          a = Comment("ONE") 
3374          b = copy.deepcopy(a) 
3375          b.text = "ANOTHER" 
3376   
3377          self.assertEqual('ONE',     a.text) 
3378          self.assertEqual('ANOTHER', b.text) 
3379   
3381          Element = self.etree.Element 
3382           
3383          a = Element('a') 
3384          a.text = 'Foo' 
3385   
3386          b = copy.copy(a) 
3387          self.assertEqual('Foo', b.text) 
3388           
3389          b.text = 'Bar' 
3390          self.assertEqual('Bar', b.text) 
3391          self.assertEqual('Foo', a.text) 
3392          # XXX ElementTree will share nodes, but lxml.etree won't.. 
3393   
3395          Element = self.etree.Element 
3396          ElementTree = self.etree.ElementTree 
3397           
3398          a = Element('a') 
3399          a.text = 'Foo' 
3400          atree = ElementTree(a) 
3401   
3402          btree = copy.copy(atree) 
3403          self.assertFalse(btree is atree) 
3404          self.assertTrue(btree.getroot() is atree.getroot()) 
3405          self.assertEqual('Foo', atree.getroot().text) 
3406   
3408          # deprecated as of ET 1.3/lxml 2.0 
3409          etree = self.etree 
3410          e = etree.Element('foo') 
3411          self.assertEqual(False, bool(e)) 
3412          etree.SubElement(e, 'bar') 
3413          self.assertEqual(True, bool(e)) 
3414          e = etree.Element('foo') 
3415          e.text = 'hey' 
3416          self.assertEqual(False, bool(e)) 
3417          e = etree.Element('foo') 
3418          e.tail = 'bar' 
3419          self.assertEqual(False, bool(e)) 
3420          e = etree.Element('foo') 
3421          e.set('bar', 'Bar') 
3422          self.assertEqual(False, bool(e)) 
3423   
3425          etree = self.etree 
3426   
3427          a = etree.Element('a') 
3428          b = etree.SubElement(a, 'b') 
3429   
3430          t = etree.ElementTree(a) 
3431          self.assertEqual(self._rootstring(t), _bytes('<a><b/></a>')) 
3432   
3433          t1 = etree.ElementTree(a) 
3434          self.assertEqual(self._rootstring(t1), _bytes('<a><b/></a>')) 
3435          self.assertEqual(self._rootstring(t),  _bytes('<a><b/></a>')) 
3436   
3437          t2 = etree.ElementTree(b) 
3438          self.assertEqual(self._rootstring(t2), _bytes('<b/>')) 
3439          self.assertEqual(self._rootstring(t1), _bytes('<a><b/></a>')) 
3440          self.assertEqual(self._rootstring(t),  _bytes('<a><b/></a>')) 
3441   
3443          etree = self.etree 
3444          qname = etree.QName('myns', 'a') 
3445          a1 = etree.Element(qname) 
3446          a2 = etree.SubElement(a1, qname) 
3447          self.assertEqual(a1.tag, "{myns}a") 
3448          self.assertEqual(a2.tag, "{myns}a") 
3449   
3451          etree = self.etree 
3452          qname1 = etree.QName('myns', 'a') 
3453          qname2 = etree.QName('myns', 'a') 
3454          self.assertEqual(qname1, "{myns}a") 
3455          self.assertEqual("{myns}a", qname2) 
3456          self.assertEqual(qname1, qname1) 
3457          self.assertEqual(qname1, qname2) 
3458   
3460          etree = self.etree 
3461          qname = etree.QName('myns', 'a') 
3462   
3463          a = etree.Element(qname) 
3464          a.set(qname, "value") 
3465   
3466          self.assertEqual(a.get(qname), "value") 
3467          self.assertEqual(a.get("{myns}a"), "value") 
3468   
3470          etree = self.etree 
3471          qname = etree.QName('myns', 'a') 
3472   
3473          a = etree.Element(qname) 
3474          a.attrib[qname] = "value" 
3475   
3476          self.assertEqual(a.attrib[qname], "value") 
3477          self.assertEqual(a.attrib.get(qname), "value") 
3478   
3479          self.assertEqual(a.attrib["{myns}a"], "value") 
3480          self.assertEqual(a.attrib.get("{myns}a"), "value") 
3481   
3483          etree = self.etree 
3484          qname = etree.QName('http://myns', 'a') 
3485          a = etree.Element(qname) 
3486          a.set(qname, qname) 
3487   
3488          self.assertXML( 
3489              _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'), 
3490              a) 
3491   
3493          etree = self.etree 
3494          qname = etree.QName('http://myns', 'a') 
3495          a = etree.Element('a') 
3496          a.set('a', qname) 
3497   
3498          self.assertXML( 
3499              _bytes('<a xmlns:ns0="http://myns" a="ns0:a"></a>'), 
3500              a) 
3501   
3503          etree = self.etree 
3504          qname = etree.QName('http://myns', 'a') 
3505          a = etree.Element(qname) 
3506          a.attrib[qname] = qname 
3507   
3508          self.assertXML( 
3509              _bytes('<ns0:a xmlns:ns0="http://myns" ns0:a="ns0:a"></ns0:a>'), 
3510              a) 
3511   
3513          etree = self.etree 
3514          parser = etree.XMLParser() 
3515          if hasattr(parser, "version"): 
3516              # ElementTree 1.3+, cET 
3517              self.assertTrue(re.match("[^ ]+ [0-9.]+", parser.version)) 
3518   
3519      # feed parser interface 
3520   
3522          parser = self.XMLParser() 
3523   
3524          parser.feed(_bytes('<?xml version=')) 
3525          parser.feed(_bytes('"1.0"?><ro')) 
3526          parser.feed(_bytes('ot><')) 
3527          parser.feed(_bytes('a test="works"/')) 
3528          parser.feed(_bytes('></root')) 
3529          parser.feed(_bytes('>')) 
3530   
3531          root = parser.close() 
3532   
3533          self.assertEqual(root.tag, "root") 
3534          self.assertEqual(root[0].tag, "a") 
3535          self.assertEqual(root[0].get("test"), "works") 
3536   
3538          parser = self.XMLParser() 
3539   
3540          parser.feed(_str('<ro')) 
3541          parser.feed(_str('ot><')) 
3542          parser.feed(_str('a test="works"/')) 
3543          parser.feed(_str('></root')) 
3544          parser.feed(_str('>')) 
3545   
3546          root = parser.close() 
3547   
3548          self.assertEqual(root.tag, "root") 
3549          self.assertEqual(root[0].tag, "a") 
3550          self.assertEqual(root[0].get("test"), "works") 
3551   
3552      required_versions_ET['test_feed_parser_error_close_empty'] = (1,3) 
3554          ParseError = self.etree.ParseError 
3555          parser = self.XMLParser() 
3556          self.assertRaises(ParseError, parser.close) 
3557   
3558      required_versions_ET['test_feed_parser_error_close_incomplete'] = (1,3) 
3560          ParseError = self.etree.ParseError 
3561          parser = self.XMLParser() 
3562   
3563          parser.feed('<?xml version=') 
3564          parser.feed('"1.0"?><ro') 
3565   
3566          self.assertRaises(ParseError, parser.close) 
3567   
3568      required_versions_ET['test_feed_parser_error_broken'] = (1,3) 
3570          ParseError = self.etree.ParseError 
3571          parser = self.XMLParser() 
3572   
3573          parser.feed('<?xml version=') 
3574          parser.feed('"1.0"?><ro') 
3575          try: 
3576              parser.feed('<><><><><><><') 
3577          except ParseError: 
3578              # can raise, but not required before close() 
3579              pass 
3580   
3581          self.assertRaises(ParseError, parser.close) 
3582   
3583      required_versions_ET['test_feed_parser_error_position'] = (1,3) 
3585          ParseError = self.etree.ParseError 
3586          parser = self.XMLParser() 
3587          try: 
3588              parser.close() 
3589          except ParseError: 
3590              e = sys.exc_info()[1] 
3591              self.assertNotEqual(None, e.code) 
3592              self.assertNotEqual(0, e.code) 
3593              self.assertTrue(isinstance(e.position, tuple)) 
3594              self.assertTrue(e.position >= (0, 0)) 
3595   
3596      # parser target interface 
3597   
3598      required_versions_ET['test_parser_target_property'] = (1,3) 
3602   
3603          target = Target() 
3604          parser = self.XMLParser(target=target) 
3605   
3606          self.assertEqual(target, parser.target) 
3607   
3609          assertEqual = self.assertEqual 
3610          assertFalse  = self.assertFalse 
3611   
3612          events = [] 
3613          class Target(object): 
3614              def start(self, tag, attrib): 
3615                  events.append("start") 
3616                  assertFalse(attrib) 
3617                  assertEqual("TAG", tag) 
3618              def end(self, tag): 
3619                  events.append("end") 
3620                  assertEqual("TAG", tag) 
3621              def close(self): 
3622                  return "DONE" 
3623   
3624          parser = self.XMLParser(target=Target()) 
3625   
3626          parser.feed("<TAG/>") 
3627          done = parser.close() 
3628   
3629          self.assertEqual("DONE", done) 
3630          self.assertEqual(["start", "end"], events) 
3631   
3633          assertEqual = self.assertEqual 
3634   
3635          events = [] 
3636          class Target(object): 
3637              def start(self, tag, attrib): 
3638                  events.append("start") 
3639                  assertEqual("TAG", tag) 
3640                  raise ValueError("TEST") 
3641              def end(self, tag): 
3642                  events.append("end") 
3643                  assertEqual("TAG", tag) 
3644              def close(self): 
3645                  return "DONE" 
3646   
3647          parser = self.XMLParser(target=Target()) 
3648   
3649          try: 
3650              parser.feed("<TAG/>") 
3651          except ValueError: 
3652              self.assertTrue('TEST' in str(sys.exc_info()[1])) 
3653          else: 
3654              self.assertTrue(False) 
3655          if 'lxml' in self.etree.__name__: 
3656              self.assertEqual(["start"], events) 
3657          else: 
3658              # cElementTree calls end() as well 
3659              self.assertTrue("start" in events) 
3660   
3662          assertEqual = self.assertEqual 
3663   
3664          events = [] 
3665          class Target(object): 
3666              def start(self, tag, attrib): 
3667                  events.append("start") 
3668                  assertEqual("TAG", tag) 
3669              def end(self, tag): 
3670                  events.append("end") 
3671                  assertEqual("TAG", tag) 
3672                  raise ValueError("TEST") 
3673              def close(self): 
3674                  return "DONE" 
3675   
3676          parser = self.XMLParser(target=Target()) 
3677   
3678          try: 
3679              parser.feed("<TAG/>") 
3680          except ValueError: 
3681              self.assertTrue('TEST' in str(sys.exc_info()[1])) 
3682          else: 
3683              self.assertTrue(False) 
3684          self.assertEqual(["start", "end"], events) 
3685   
3687          assertEqual = self.assertEqual 
3688   
3689          events = [] 
3690          class Target(object): 
3691              def start(self, tag, attrib): 
3692                  events.append("start") 
3693                  assertEqual("TAG", tag) 
3694              def end(self, tag): 
3695                  events.append("end") 
3696                  assertEqual("TAG", tag) 
3697              def close(self): 
3698                  raise ValueError("TEST") 
3699   
3700          parser = self.XMLParser(target=Target()) 
3701   
3702          try: 
3703              parser.feed("<TAG/>") 
3704              parser.close() 
3705          except ValueError: 
3706              self.assertTrue('TEST' in str(sys.exc_info()[1])) 
3707          else: 
3708              self.assertTrue(False) 
3709          self.assertEqual(["start", "end"], events) 
3710   
3712          assertEqual = self.assertEqual 
3713   
3714          events = [] 
3715          class Target(object): 
3716              def start(self, tag, attrib): 
3717                  events.append("start") 
3718                  assertEqual("TAG", tag) 
3719                  raise IndexError("TEST-IE") 
3720              def end(self, tag): 
3721                  events.append("end") 
3722                  assertEqual("TAG", tag) 
3723              def close(self): 
3724                  raise ValueError("TEST-VE") 
3725   
3726          parser = self.XMLParser(target=Target()) 
3727   
3728          try: 
3729              parser.feed("<TAG/>") 
3730              parser.close() 
3731          except IndexError: 
3732              if 'lxml' in self.etree.__name__: 
3733                  # we try not to swallow the initial exception in Py2 
3734                  self.assertTrue(sys.version_info[0] < 3) 
3735              self.assertTrue('TEST-IE' in str(sys.exc_info()[1])) 
3736          except ValueError: 
3737              if 'lxml' in self.etree.__name__: 
3738                  self.assertTrue(sys.version_info[0] >= 3) 
3739              self.assertTrue('TEST-VE' in str(sys.exc_info()[1])) 
3740          else: 
3741              self.assertTrue(False) 
3742   
3743          if 'lxml' in self.etree.__name__: 
3744              self.assertEqual(["start"], events) 
3745          else: 
3746              # cElementTree calls end() as well 
3747              self.assertTrue("start" in events) 
3748   
3750          assertEqual = self.assertEqual 
3751          assertFalse  = self.assertFalse 
3752          Element = self.etree.Element 
3753   
3754          events = [] 
3755          class Target(object): 
3756              def start(self, tag, attrib): 
3757                  events.append("start") 
3758                  assertFalse(attrib) 
3759                  assertEqual("TAG", tag) 
3760              def end(self, tag): 
3761                  events.append("end") 
3762                  assertEqual("TAG", tag) 
3763              def close(self): 
3764                  return Element("DONE") 
3765   
3766          parser = self.XMLParser(target=Target()) 
3767          tree = self.etree.ElementTree() 
3768          tree.parse(BytesIO("<TAG/>"), parser=parser) 
3769   
3770          self.assertEqual("DONE", tree.getroot().tag) 
3771          self.assertEqual(["start", "end"], events) 
3772   
3774          assertEqual = self.assertEqual 
3775   
3776          events = [] 
3777          class Target(object): 
3778              def start(self, tag, attrib): 
3779                  events.append("start-" + tag) 
3780                  for name, value in attrib.items(): 
3781                      assertEqual(tag + name, value) 
3782              def end(self, tag): 
3783                  events.append("end-" + tag) 
3784              def close(self): 
3785                  return "DONE" 
3786   
3787          parser = self.XMLParser(target=Target()) 
3788   
3789          parser.feed('<root a="roota" b="rootb"><sub c="subc"/></root>') 
3790          done = parser.close() 
3791   
3792          self.assertEqual("DONE", done) 
3793          self.assertEqual(["start-root", "start-sub", "end-sub", "end-root"], 
3794                            events) 
3795   
3797          events = [] 
3798          class Target(object): 
3799              def start(self, tag, attrib): 
3800                  events.append("start-" + tag) 
3801              def end(self, tag): 
3802                  events.append("end-" + tag) 
3803              def data(self, data): 
3804                  events.append("data-" + data) 
3805              def close(self): 
3806                  return "DONE" 
3807   
3808          parser = self.XMLParser(target=Target()) 
3809   
3810          parser.feed('<root>A<sub/>B</root>') 
3811          done = parser.close() 
3812   
3813          self.assertEqual("DONE", done) 
3814          self.assertEqual(["start-root", "data-A", "start-sub", 
3815                             "end-sub", "data-B", "end-root"], 
3816                            events) 
3817   
3823              def _flush_data(self): 
3824                  if self._data: 
3825                      events.append("data-" + ''.join(self._data)) 
3826                      del self._data[:] 
3827              def start(self, tag, attrib): 
3828                  self._flush_data() 
3829                  events.append("start-" + tag) 
3830              def end(self, tag): 
3831                  self._flush_data() 
3832                  events.append("end-" + tag) 
3833              def data(self, data): 
3834                  self._data.append(data) 
3835              def close(self): 
3836                  self._flush_data() 
3837                  return "DONE" 
3838   
3839          parser = self.XMLParser(target=Target()) 
3840   
3841          dtd = ''' 
3842              <!DOCTYPE root [ 
3843              <!ELEMENT root (sub*)> 
3844              <!ELEMENT sub (#PCDATA)> 
3845              <!ENTITY ent "an entity"> 
3846          ]> 
3847          ''' 
3848          parser.feed(dtd+'<root><sub/><sub>this is &ent;</sub><sub/></root>') 
3849          done = parser.close() 
3850   
3851          self.assertEqual("DONE", done) 
3852          self.assertEqual(["start-root", "start-sub", "end-sub", "start-sub", 
3853                             "data-this is an entity", 
3854                             "end-sub", "start-sub", "end-sub", "end-root"], 
3855                            events) 
3856   
3857      required_versions_ET['test_parser_target_entity_unknown'] = (1,3) 
3863              def _flush_data(self): 
3864                  if self._data: 
3865                      events.append("data-" + ''.join(self._data)) 
3866                      del self._data[:] 
3867              def start(self, tag, attrib): 
3868                  self._flush_data() 
3869                  events.append("start-" + tag) 
3870              def end(self, tag): 
3871                  self._flush_data() 
3872                  events.append("end-" + tag) 
3873              def data(self, data): 
3874                  self._data.append(data) 
3875              def close(self): 
3876                  self._flush_data() 
3877                  return "DONE" 
3878   
3879          parser = self.XMLParser(target=Target()) 
3880   
3881          def feed(): 
3882              parser.feed('<root><sub/><sub>some &ent;</sub><sub/></root>') 
3883              parser.close() 
3884   
3885          self.assertRaises(self.etree.ParseError, feed) 
3886   
3888          builder = self.etree.TreeBuilder() 
3889          el = builder.start("root", {'a':'A', 'b':'B'}) 
3890          self.assertEqual("root", el.tag) 
3891          self.assertEqual({'a':'A', 'b':'B'}, el.attrib) 
3892          builder.data("ROOTTEXT") 
3893          el = builder.start("child", {'x':'X', 'y':'Y'}) 
3894          self.assertEqual("child", el.tag) 
3895          self.assertEqual({'x':'X', 'y':'Y'}, el.attrib) 
3896          builder.data("CHILDTEXT") 
3897          el = builder.end("child") 
3898          self.assertEqual("child", el.tag) 
3899          self.assertEqual({'x':'X', 'y':'Y'}, el.attrib) 
3900          self.assertEqual("CHILDTEXT", el.text) 
3901          self.assertEqual(None, el.tail) 
3902          builder.data("CHILDTAIL") 
3903          root = builder.end("root") 
3904   
3905          self.assertEqual("root", root.tag) 
3906          self.assertEqual("ROOTTEXT", root.text) 
3907          self.assertEqual("CHILDTEXT", root[0].text) 
3908          self.assertEqual("CHILDTAIL", root[0].tail) 
3909   
3911          parser = self.XMLParser(target=self.etree.TreeBuilder()) 
3912          parser.feed('<root>ROOTTEXT<child>CHILDTEXT</child>CHILDTAIL</root>') 
3913          root = parser.close() 
3914   
3915          self.assertEqual("root", root.tag) 
3916          self.assertEqual("ROOTTEXT", root.text) 
3917          self.assertEqual("CHILDTEXT", root[0].text) 
3918          self.assertEqual("CHILDTAIL", root[0].tail) 
3919   
3920      # helper methods 
3921   
3923          """Write out element for comparison. 
3924          """ 
3925          data = self.etree.tostring(element, encoding=encoding) 
3926          return canonicalize(data) 
3927   
3929          """Write out element for comparison, using real file. 
3930          """ 
3931          ElementTree = self.etree.ElementTree 
3932          handle, filename = tempfile.mkstemp() 
3933          try: 
3934              f = open(filename, 'wb') 
3935              tree = ElementTree(element=element) 
3936              tree.write(f, encoding=encoding) 
3937              f.close() 
3938              f = open(filename, 'rb') 
3939              data = f.read() 
3940              f.close() 
3941          finally: 
3942              os.close(handle) 
3943              os.remove(filename) 
3944          return canonicalize(data) 
3945   
3947          """Writes element out and checks whether it is expected. 
3948   
3949          Does this two ways; once using BytesIO, once using a real file. 
3950          """ 
3951          if isinstance(expected, unicode): 
3952              expected = expected.encode(encoding) 
3953          self.assertEqual(expected, self._writeElement(element, encoding)) 
3954          self.assertEqual(expected, self._writeElementFile(element, encoding)) 
3955   
3957          "Checks if the result XML byte string specifies the encoding." 
3958          enc_re = r"<\?xml[^>]+ encoding=[\"']([^\"']+)[\"']" 
3959          if isinstance(result, str): 
3960              has_encoding = re.compile(enc_re).match 
3961          else: 
3962              has_encoding = re.compile(_bytes(enc_re)).match 
3963          self.assertTrue(has_encoding(result)) 
3964          result_encoding = has_encoding(result).group(1) 
3965          self.assertEqual(result_encoding.upper(), encoding.upper()) 
3966           
3968          return self.etree.tostring(tree.getroot()).replace( 
3969              _bytes(' '), _bytes('')).replace(_bytes('\n'), _bytes('')) 
3970   
3973           
3975          self.assertTrue(hasattr(element, 'tag')) 
3976          self.assertTrue(hasattr(element, 'attrib')) 
3977          self.assertTrue(hasattr(element, 'text')) 
3978          self.assertTrue(hasattr(element, 'tail')) 
3979          self._check_string(element.tag) 
3980          self._check_mapping(element.attrib) 
3981          if element.text is not None: 
3982              self._check_string(element.text) 
3983          if element.tail is not None: 
3984              self._check_string(element.tail) 
3985           
3987          len(string) 
3988          for char in string: 
3989              self.assertEqual(1, len(char)) 
3990          new_string = string + "" 
3991          new_string = string + " " 
3992          string[:0] 
3993   
3995          len(mapping) 
3996          keys = mapping.keys() 
3997          values = mapping.values() 
3998          items = mapping.items() 
3999          for key in keys: 
4000              item = mapping[key] 
4001          mapping["key"] = "value" 
4002          self.assertEqual("value", mapping["key"]) 
4003   
4006      etree = None 
4007   
4009          if chunk_size is None: 
4010              parser.feed(data) 
4011          else: 
4012              for i in range(0, len(data), chunk_size): 
4013                  parser.feed(data[i:i+chunk_size]) 
4014   
4016          if 'ElementTree' in self.etree.__name__: 
4017              # ElementTree's API is a bit unwieldy in Py3.4 
4018              root = parser._close_and_return_root() 
4019          else: 
4020              root = parser.close() 
4021          return root 
4022   
4027   
4029          for chunk_size in (None, 1, 5): 
4030              #with self.subTest(chunk_size=chunk_size): 
4031                  parser = self.etree.XMLPullParser() 
4032                  self.assert_event_tags(parser, []) 
4033                  self._feed(parser, "<!-- comment -->\n", chunk_size) 
4034                  self.assert_event_tags(parser, []) 
4035                  self._feed(parser, 
4036                             "<root>\n  <element key='value'>text</element", 
4037                             chunk_size) 
4038                  self.assert_event_tags(parser, []) 
4039                  self._feed(parser, ">\n", chunk_size) 
4040                  self.assert_event_tags(parser, [('end', 'element')]) 
4041                  self._feed(parser, "<element>text</element>tail\n", chunk_size) 
4042                  self._feed(parser, "<empty-element/>\n", chunk_size) 
4043                  self.assert_event_tags(parser, [ 
4044                      ('end', 'element'), 
4045                      ('end', 'empty-element'), 
4046                      ]) 
4047                  self._feed(parser, "</root>\n", chunk_size) 
4048                  self.assert_event_tags(parser, [('end', 'root')]) 
4049                  root = self._close_and_return_root(parser) 
4050                  self.assertEqual(root.tag, 'root') 
4051   
4053          parser = self.etree.XMLPullParser() 
4054          it = parser.read_events() 
4055          self._feed(parser, "<root>\n  <element key='value'>text</element>\n") 
4056          action, elem = next(it) 
4057          self.assertEqual((action, elem.tag), ('end', 'element')) 
4058          self._feed(parser, "</root>\n") 
4059          action, elem = next(it) 
4060          self.assertEqual((action, elem.tag), ('end', 'root')) 
4061          try: 
4062              next(it) 
4063          except StopIteration: 
4064              self.assertTrue(True) 
4065          else: 
4066              self.assertTrue(False) 
4067   
4069          parser = self.etree.XMLPullParser() 
4070          self.assert_event_tags(parser, []) 
4071          self._feed(parser, "<!-- comment -->\n") 
4072          self.assert_event_tags(parser, []) 
4073          self._feed(parser, "<root xmlns='namespace'>\n") 
4074          self.assert_event_tags(parser, []) 
4075          self._feed(parser, "<element key='value'>text</element") 
4076          self.assert_event_tags(parser, []) 
4077          self._feed(parser, ">\n") 
4078          self.assert_event_tags(parser, [('end', '{namespace}element')]) 
4079          self._feed(parser, "<element>text</element>tail\n") 
4080          self._feed(parser, "<empty-element/>\n") 
4081          self.assert_event_tags(parser, [ 
4082              ('end', '{namespace}element'), 
4083              ('end', '{namespace}empty-element'), 
4084              ]) 
4085          self._feed(parser, "</root>\n") 
4086          self.assert_event_tags(parser, [('end', '{namespace}root')]) 
4087          root = self._close_and_return_root(parser) 
4088          self.assertEqual(root.tag, '{namespace}root') 
4089   
4091          parser = self.etree.XMLPullParser(events=('start-ns', 'end-ns')) 
4092          self._feed(parser, "<!-- comment -->\n") 
4093          self._feed(parser, "<root xmlns='namespace'>\n") 
4094          self.assertEqual( 
4095              list(parser.read_events()), 
4096              [('start-ns', ('', 'namespace'))]) 
4097          self._feed(parser, "<element key='value'>text</element") 
4098          self._feed(parser, ">\n") 
4099          self._feed(parser, "<element>text</element>tail\n") 
4100          self._feed(parser, "<empty-element/>\n") 
4101          self._feed(parser, "</root>\n") 
4102          self.assertEqual(list(parser.read_events()), [('end-ns', None)]) 
4103          parser.close() 
4104   
4106          parser = self.etree.XMLPullParser(events=()) 
4107          self._feed(parser, "<root/>\n") 
4108          self.assert_event_tags(parser, []) 
4109   
4110          parser = self.etree.XMLPullParser(events=('start', 'end')) 
4111          self._feed(parser, "<!-- comment -->\n") 
4112          self.assert_event_tags(parser, []) 
4113          self._feed(parser, "<root>\n") 
4114          self.assert_event_tags(parser, [('start', 'root')]) 
4115          self._feed(parser, "<element key='value'>text</element") 
4116          self.assert_event_tags(parser, [('start', 'element')]) 
4117          self._feed(parser, ">\n") 
4118          self.assert_event_tags(parser, [('end', 'element')]) 
4119          self._feed(parser, 
4120                     "<element xmlns='foo'>text<empty-element/></element>tail\n") 
4121          self.assert_event_tags(parser, [ 
4122              ('start', '{foo}element'), 
4123              ('start', '{foo}empty-element'), 
4124              ('end', '{foo}empty-element'), 
4125              ('end', '{foo}element'), 
4126              ]) 
4127          self._feed(parser, "</root>") 
4128          root = self._close_and_return_root(parser) 
4129          self.assert_event_tags(parser, [('end', 'root')]) 
4130          self.assertEqual(root.tag, 'root') 
4131   
4132          parser = self.etree.XMLPullParser(events=('start',)) 
4133          self._feed(parser, "<!-- comment -->\n") 
4134          self.assert_event_tags(parser, []) 
4135          self._feed(parser, "<root>\n") 
4136          self.assert_event_tags(parser, [('start', 'root')]) 
4137          self._feed(parser, "<element key='value'>text</element") 
4138          self.assert_event_tags(parser, [('start', 'element')]) 
4139          self._feed(parser, ">\n") 
4140          self.assert_event_tags(parser, []) 
4141          self._feed(parser, 
4142                     "<element xmlns='foo'>text<empty-element/></element>tail\n") 
4143          self.assert_event_tags(parser, [ 
4144              ('start', '{foo}element'), 
4145              ('start', '{foo}empty-element'), 
4146              ]) 
4147          self._feed(parser, "</root>") 
4148          root = self._close_and_return_root(parser) 
4149          self.assertEqual(root.tag, 'root') 
4150   
4152          # Test that events can be some sequence that's not just a tuple or list 
4153          eventset = {'end', 'start'} 
4154          parser = self.etree.XMLPullParser(events=eventset) 
4155          self._feed(parser, "<foo>bar</foo>") 
4156          self.assert_event_tags(parser, [('start', 'foo'), ('end', 'foo')]) 
4157   
4158          class DummyIter: 
4159              def __init__(self): 
4160                  self.events = iter(['start', 'end', 'start-ns']) 
4161              def __iter__(self): 
4162                  return self 
4163              def __next__(self): 
4164                  return next(self.events) 
4165              next = __next__ 
4166   
4167          parser = self.etree.XMLPullParser(events=DummyIter()) 
4168          self._feed(parser, "<foo>bar</foo>") 
4169          self.assert_event_tags(parser, [('start', 'foo'), ('end', 'foo')]) 
4170   
4172          try: 
4173              self.etree.XMLPullParser(events=('start', 'end', 'bogus')) 
4174          except ValueError: 
4175              self.assertTrue(True) 
4176          else: 
4177              self.assertTrue(False) 
4178   
4179   
4180  if etree: 
4183   
4186   
4187   
4188  if ElementTree: 
4200   
4201      filter_by_version( 
4202          ElementTreeTestCase, 
4203          ElementTreeTestCase.required_versions_ET, ET_VERSION) 
4204   
4205      if hasattr(ElementTree, 'XMLPullParser'): 
4208      else: 
4209          ElementTreePullTestCase = None 
4210   
4211   
4212  if cElementTree: 
4215   
4216      filter_by_version( 
4217          CElementTreeTestCase, 
4218          CElementTreeTestCase.required_versions_cET, CET_VERSION) 
4222      suite = unittest.TestSuite() 
4223      if etree: 
4224          suite.addTests([unittest.makeSuite(ETreeTestCase)]) 
4225          suite.addTests([unittest.makeSuite(ETreePullTestCase)]) 
4226      if ElementTree: 
4227          suite.addTests([unittest.makeSuite(ElementTreeTestCase)]) 
4228          if ElementTreePullTestCase: 
4229              suite.addTests([unittest.makeSuite(ElementTreePullTestCase)]) 
4230      if cElementTree: 
4231          suite.addTests([unittest.makeSuite(CElementTreeTestCase)]) 
4232      return suite 
4233   
4234  if __name__ == '__main__': 
4235      print('to test use test.py %s' % __file__) 
4236   
| Home | Trees | Indices | Help | 
 | 
|---|
| Generated by Epydoc 3.0.1 on Tue Mar 26 13:39:43 2019 | http://epydoc.sourceforge.net |