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