← Back to branch summary

~ubuntu-branches/ubuntu/saucy/lxml/saucy-updates

« back to all changes in this revision

Viewing changes to src/lxml/tests/test_etree.py

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-01-27 22:14:53 UTC
  • mto: (2.1.34 experimental) (1.4.1)
  • mto: This revision was merged to the branch mainline in revision 17.
  • Revision ID: package-import@ubuntu.com-20130127221453-2k7oc1crqc28802y
Tags: upstream-3.1~beta1
Import upstream version 3.1~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lxml/tests/test_etree.py
46
46
    etree = etree
47
47
 
48
48
    def test_version(self):
49
 
        self.assert_(isinstance(etree.__version__, _unicode))
50
 
        self.assert_(isinstance(etree.LXML_VERSION, tuple))
 
49
        self.assertTrue(isinstance(etree.__version__, _unicode))
 
50
        self.assertTrue(isinstance(etree.LXML_VERSION, tuple))
51
51
        self.assertEqual(len(etree.LXML_VERSION), 4)
52
 
        self.assert_(isinstance(etree.LXML_VERSION[0], int))
53
 
        self.assert_(isinstance(etree.LXML_VERSION[1], int))
54
 
        self.assert_(isinstance(etree.LXML_VERSION[2], int))
55
 
        self.assert_(isinstance(etree.LXML_VERSION[3], int))
56
 
        self.assert_(etree.__version__.startswith(
 
52
        self.assertTrue(isinstance(etree.LXML_VERSION[0], int))
 
53
        self.assertTrue(isinstance(etree.LXML_VERSION[1], int))
 
54
        self.assertTrue(isinstance(etree.LXML_VERSION[2], int))
 
55
        self.assertTrue(isinstance(etree.LXML_VERSION[3], int))
 
56
        self.assertTrue(etree.__version__.startswith(
57
57
            str(etree.LXML_VERSION[0])))
58
58
 
59
59
    def test_c_api(self):
60
60
        if hasattr(self.etree, '__pyx_capi__'):
61
61
            # newer Pyrex compatible C-API
62
 
            self.assert_(isinstance(self.etree.__pyx_capi__, dict))
63
 
            self.assert_(len(self.etree.__pyx_capi__) > 0)
 
62
            self.assertTrue(isinstance(self.etree.__pyx_capi__, dict))
 
63
            self.assertTrue(len(self.etree.__pyx_capi__) > 0)
64
64
        else:
65
65
            # older C-API mechanism
66
 
            self.assert_(hasattr(self.etree, '_import_c_api'))
 
66
            self.assertTrue(hasattr(self.etree, '_import_c_api'))
67
67
 
68
68
    def test_element_names(self):
69
69
        Element = self.etree.Element
70
70
        el = Element('name')
71
 
        self.assertEquals(el.tag, 'name')
 
71
        self.assertEqual(el.tag, 'name')
72
72
        el = Element('{}name')
73
 
        self.assertEquals(el.tag, 'name')
 
73
        self.assertEqual(el.tag, 'name')
74
74
 
75
75
    def test_element_name_empty(self):
76
76
        Element = self.etree.Element
153
153
        el = Element('name')
154
154
        self.assertRaises(ValueError, SubElement, el, 'name', {'a b c' : 'abc'})
155
155
        self.assertRaises(ValueError, SubElement, el, 'name', {'a' : 'a\0\n'})
156
 
        self.assertEquals(0, len(el))
 
156
        self.assertEqual(0, len(el))
157
157
 
158
158
    def test_qname_empty(self):
159
159
        QName = self.etree.QName
176
176
        QName = self.etree.QName
177
177
        namespace, localname = 'http://myns', 'a'
178
178
        qname = QName(namespace, localname)
179
 
        self.assertEquals(namespace, qname.namespace)
180
 
        self.assertEquals(localname, qname.localname)
 
179
        self.assertEqual(namespace, qname.namespace)
 
180
        self.assertEqual(localname, qname.localname)
181
181
 
182
182
    def test_qname_element(self):
183
183
        # ET doesn't have namespace/localname properties on QNames
186
186
        a = self.etree.Element(qname1, nsmap={'p' : 'http://myns'})
187
187
 
188
188
        qname2 = QName(a)
189
 
        self.assertEquals(a.tag, qname1.text)
190
 
        self.assertEquals(qname1.text, qname2.text)
191
 
        self.assertEquals(qname1, qname2)
 
189
        self.assertEqual(a.tag, qname1.text)
 
190
        self.assertEqual(qname1.text, qname2.text)
 
191
        self.assertEqual(qname1, qname2)
192
192
 
193
193
    def test_qname_text_resolve(self):
194
194
        # ET doesn't resove QNames as text values
197
197
        a = etree.Element(qname, nsmap={'p' : 'http://myns'})
198
198
        a.text = qname
199
199
 
200
 
        self.assertEquals("p:a", a.text)
 
200
        self.assertEqual("p:a", a.text)
201
201
 
202
202
    def test_nsmap_prefix_invalid(self):
203
203
        etree = self.etree
213
213
        XML = self.etree.XML
214
214
 
215
215
        root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
216
 
        self.assertEquals(
 
216
        self.assertEqual(
217
217
            True, root.attrib.has_key('bar'))
218
 
        self.assertEquals(
 
218
        self.assertEqual(
219
219
            False, root.attrib.has_key('baz'))
220
 
        self.assertEquals(
 
220
        self.assertEqual(
221
221
            False, root.attrib.has_key('hah'))
222
 
        self.assertEquals(
 
222
        self.assertEqual(
223
223
            True,
224
224
            root.attrib.has_key('{http://ns.codespeak.net/test}baz'))
225
225
 
227
227
        Element = self.etree.Element
228
228
        root = Element("root")
229
229
        root.set("attr", "TEST")
230
 
        self.assertEquals("TEST", root.get("attr"))
 
230
        self.assertEqual("TEST", root.get("attr"))
231
231
 
232
232
    def test_attribute_set_invalid(self):
233
233
        # ElementTree accepts arbitrary attribute values
243
243
 
244
244
        root = XML(xml)
245
245
        self.etree.strip_attributes(root, 'a')
246
 
        self.assertEquals(_bytes('<test b="10" c="20"><x b="2"></x></test>'),
 
246
        self.assertEqual(_bytes('<test b="10" c="20"><x b="2"></x></test>'),
247
247
                          self._writeElement(root))
248
248
 
249
249
        root = XML(xml)
250
250
        self.etree.strip_attributes(root, 'b', 'c')
251
 
        self.assertEquals(_bytes('<test a="5"><x a="4"></x></test>'),
 
251
        self.assertEqual(_bytes('<test a="5"><x a="4"></x></test>'),
252
252
                          self._writeElement(root))
253
253
 
254
254
    def test_strip_attributes_ns(self):
257
257
 
258
258
        root = XML(xml)
259
259
        self.etree.strip_attributes(root, 'a')
260
 
        self.assertEquals(
 
260
        self.assertEqual(
261
261
            _bytes('<test xmlns:n="http://test/ns" b="10" c="20" n:a="5"><x n:b="2"></x></test>'),
262
262
            self._writeElement(root))
263
263
 
264
264
        root = XML(xml)
265
265
        self.etree.strip_attributes(root, '{http://test/ns}a', 'c')
266
 
        self.assertEquals(
 
266
        self.assertEqual(
267
267
            _bytes('<test xmlns:n="http://test/ns" a="6" b="10"><x a="4" n:b="2"></x></test>'),
268
268
            self._writeElement(root))
269
269
 
270
270
        root = XML(xml)
271
271
        self.etree.strip_attributes(root, '{http://test/ns}*')
272
 
        self.assertEquals(
 
272
        self.assertEqual(
273
273
            _bytes('<test xmlns:n="http://test/ns" a="6" b="10" c="20"><x a="4"></x></test>'),
274
274
            self._writeElement(root))
275
275
 
279
279
 
280
280
        root = XML(xml)
281
281
        self.etree.strip_elements(root, 'a')
282
 
        self.assertEquals(_bytes('<test><x></x></test>'),
 
282
        self.assertEqual(_bytes('<test><x></x></test>'),
283
283
                          self._writeElement(root))
284
284
 
285
285
        root = XML(xml)
286
286
        self.etree.strip_elements(root, 'b', 'c', 'X', 'Y', 'Z')
287
 
        self.assertEquals(_bytes('<test><a></a><x><a></a></x></test>'),
 
287
        self.assertEqual(_bytes('<test><a></a><x><a></a></x></test>'),
288
288
                          self._writeElement(root))
289
289
 
290
290
        root = XML(xml)
291
291
        self.etree.strip_elements(root, 'c')
292
 
        self.assertEquals(_bytes('<test><a><b></b></a><x><a><b></b></a></x></test>'),
 
292
        self.assertEqual(_bytes('<test><a><b></b></a><x><a><b></b></a></x></test>'),
293
293
                          self._writeElement(root))
294
294
 
295
295
    def test_strip_elements_ns(self):
298
298
 
299
299
        root = XML(xml)
300
300
        self.etree.strip_elements(root, 'a')
301
 
        self.assertEquals(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>C</b>BT</n:a>AT<x>X</x>XT</test>'),
 
301
        self.assertEqual(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>C</b>BT</n:a>AT<x>X</x>XT</test>'),
302
302
                          self._writeElement(root))
303
303
 
304
304
        root = XML(xml)
305
305
        self.etree.strip_elements(root, '{urn:a}b', 'c')
306
 
        self.assertEquals(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>C</b>BT</n:a>AT<x>X<a>A<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
 
306
        self.assertEqual(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>C</b>BT</n:a>AT<x>X<a>A<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
307
307
                          self._writeElement(root))
308
308
 
309
309
        root = XML(xml)
310
310
        self.etree.strip_elements(root, '{urn:a}*', 'c')
311
 
        self.assertEquals(_bytes('<test>TEST<x>X<a>A<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
 
311
        self.assertEqual(_bytes('<test>TEST<x>X<a>A<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
312
312
                          self._writeElement(root))
313
313
 
314
314
        root = XML(xml)
315
315
        self.etree.strip_elements(root, '{urn:a}*', 'c', with_tail=False)
316
 
        self.assertEquals(_bytes('<test>TESTAT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
 
316
        self.assertEqual(_bytes('<test>TESTAT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
317
317
                          self._writeElement(root))
318
318
 
319
319
    def test_strip_tags(self):
322
322
 
323
323
        root = XML(xml)
324
324
        self.etree.strip_tags(root, 'a')
325
 
        self.assertEquals(_bytes('<test>TESTA<b>B<c></c>CT</b>BTAT<x>XA<b></b>BT<c></c>CTAT</x>XT</test>'),
 
325
        self.assertEqual(_bytes('<test>TESTA<b>B<c></c>CT</b>BTAT<x>XA<b></b>BT<c></c>CTAT</x>XT</test>'),
326
326
                          self._writeElement(root))
327
327
 
328
328
        root = XML(xml)
329
329
        self.etree.strip_tags(root, 'b', 'c', 'X', 'Y', 'Z')
330
 
        self.assertEquals(_bytes('<test>TEST<a>ABCTBT</a>AT<x>X<a>ABTCT</a>AT</x>XT</test>'),
 
330
        self.assertEqual(_bytes('<test>TEST<a>ABCTBT</a>AT<x>X<a>ABTCT</a>AT</x>XT</test>'),
331
331
                          self._writeElement(root))
332
332
 
333
333
        root = XML(xml)
334
334
        self.etree.strip_tags(root, 'c')
335
 
        self.assertEquals(_bytes('<test>TEST<a>A<b>BCT</b>BT</a>AT<x>X<a>A<b></b>BTCT</a>AT</x>XT</test>'),
 
335
        self.assertEqual(_bytes('<test>TEST<a>A<b>BCT</b>BT</a>AT<x>X<a>A<b></b>BTCT</a>AT</x>XT</test>'),
336
336
                          self._writeElement(root))
337
337
 
338
338
    def test_strip_tags_pi_comment(self):
343
343
 
344
344
        root = XML(xml)
345
345
        self.etree.strip_tags(root, PI)
346
 
        self.assertEquals(_bytes('<!--comment1-->\n<?PI1?>\n<test>TEST<!--comment2-->XT</test>\n<!--comment3-->\n<?PI1?>'),
 
346
        self.assertEqual(_bytes('<!--comment1-->\n<?PI1?>\n<test>TEST<!--comment2-->XT</test>\n<!--comment3-->\n<?PI1?>'),
347
347
                          self._writeElement(root))
348
348
 
349
349
        root = XML(xml)
350
350
        self.etree.strip_tags(root, Comment)
351
 
        self.assertEquals(_bytes('<!--comment1-->\n<?PI1?>\n<test>TESTXT<?PI2?></test>\n<!--comment3-->\n<?PI1?>'),
 
351
        self.assertEqual(_bytes('<!--comment1-->\n<?PI1?>\n<test>TESTXT<?PI2?></test>\n<!--comment3-->\n<?PI1?>'),
352
352
                          self._writeElement(root))
353
353
 
354
354
        root = XML(xml)
355
355
        self.etree.strip_tags(root, PI, Comment)
356
 
        self.assertEquals(_bytes('<!--comment1-->\n<?PI1?>\n<test>TESTXT</test>\n<!--comment3-->\n<?PI1?>'),
 
356
        self.assertEqual(_bytes('<!--comment1-->\n<?PI1?>\n<test>TESTXT</test>\n<!--comment3-->\n<?PI1?>'),
357
357
                          self._writeElement(root))
358
358
 
359
359
        root = XML(xml)
360
360
        self.etree.strip_tags(root, Comment, PI)
361
 
        self.assertEquals(_bytes('<!--comment1-->\n<?PI1?>\n<test>TESTXT</test>\n<!--comment3-->\n<?PI1?>'),
 
361
        self.assertEqual(_bytes('<!--comment1-->\n<?PI1?>\n<test>TESTXT</test>\n<!--comment3-->\n<?PI1?>'),
362
362
                          self._writeElement(root))
363
363
 
364
364
    def test_strip_tags_pi_comment_all(self):
370
370
 
371
371
        root = XML(xml)
372
372
        self.etree.strip_tags(ElementTree(root), PI)
373
 
        self.assertEquals(_bytes('<!--comment1-->\n<test>TEST<!--comment2-->XT</test>\n<!--comment3-->'),
 
373
        self.assertEqual(_bytes('<!--comment1-->\n<test>TEST<!--comment2-->XT</test>\n<!--comment3-->'),
374
374
                          self._writeElement(root))
375
375
 
376
376
        root = XML(xml)
377
377
        self.etree.strip_tags(ElementTree(root), Comment)
378
 
        self.assertEquals(_bytes('<?PI1?>\n<test>TESTXT<?PI2?></test>\n<?PI1?>'),
 
378
        self.assertEqual(_bytes('<?PI1?>\n<test>TESTXT<?PI2?></test>\n<?PI1?>'),
379
379
                          self._writeElement(root))
380
380
 
381
381
        root = XML(xml)
382
382
        self.etree.strip_tags(ElementTree(root), PI, Comment)
383
 
        self.assertEquals(_bytes('<test>TESTXT</test>'),
 
383
        self.assertEqual(_bytes('<test>TESTXT</test>'),
384
384
                          self._writeElement(root))
385
385
 
386
386
        root = XML(xml)
387
387
        self.etree.strip_tags(ElementTree(root), Comment, PI)
388
 
        self.assertEquals(_bytes('<test>TESTXT</test>'),
 
388
        self.assertEqual(_bytes('<test>TESTXT</test>'),
389
389
                          self._writeElement(root))
390
390
 
391
391
    def test_strip_tags_doc_style(self):
405
405
 
406
406
        root = XML(xml)
407
407
        self.etree.strip_tags(root, 'a')
408
 
        self.assertEquals(re.sub(_bytes('</?a[^>]*>'), _bytes(''), xml).replace(_bytes('<br/>'), _bytes('<br></br>')),
 
408
        self.assertEqual(re.sub(_bytes('</?a[^>]*>'), _bytes(''), xml).replace(_bytes('<br/>'), _bytes('<br></br>')),
409
409
                          self._writeElement(root))
410
410
 
411
411
        root = XML(xml)
412
412
        self.etree.strip_tags(root, 'a', 'br')
413
 
        self.assertEquals(re.sub(_bytes('</?a[^>]*>'), _bytes(''),
 
413
        self.assertEqual(re.sub(_bytes('</?a[^>]*>'), _bytes(''),
414
414
                                 re.sub(_bytes('<br[^>]*>'), _bytes(''), xml)),
415
415
                          self._writeElement(root))
416
416
 
420
420
 
421
421
        root = XML(xml)
422
422
        self.etree.strip_tags(root, 'a')
423
 
        self.assertEquals(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>CT</b>BT</n:a>AT<x>XA<b xmlns="urn:a"></b>BT<c xmlns="urn:x"></c>CTAT</x>XT</test>'),
 
423
        self.assertEqual(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>CT</b>BT</n:a>AT<x>XA<b xmlns="urn:a"></b>BT<c xmlns="urn:x"></c>CTAT</x>XT</test>'),
424
424
                          self._writeElement(root))
425
425
 
426
426
        root = XML(xml)
427
427
        self.etree.strip_tags(root, '{urn:a}b', 'c')
428
 
        self.assertEquals(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>CT</b>BT</n:a>AT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
 
428
        self.assertEqual(_bytes('<test>TEST<n:a xmlns:n="urn:a">A<b>B<c xmlns="urn:c"></c>CT</b>BT</n:a>AT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
429
429
                          self._writeElement(root))
430
430
 
431
431
        root = XML(xml)
432
432
        self.etree.strip_tags(root, '{urn:a}*', 'c')
433
 
        self.assertEquals(_bytes('<test>TESTA<b>B<c xmlns="urn:c"></c>CT</b>BTAT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
 
433
        self.assertEqual(_bytes('<test>TESTA<b>B<c xmlns="urn:c"></c>CT</b>BTAT<x>X<a>ABT<c xmlns="urn:x"></c>CT</a>AT</x>XT</test>'),
434
434
                          self._writeElement(root))
435
435
 
436
436
    def test_strip_tags_and_remove(self):
437
437
        # previously crashed
438
438
        HTML = self.etree.HTML
439
439
        root = HTML(_bytes('<div><h1>title</h1> <b>foo</b> <p>boo</p></div>'))[0][0]
440
 
        self.assertEquals(_bytes('<div><h1>title</h1> <b>foo</b> <p>boo</p></div>'),
 
440
        self.assertEqual(_bytes('<div><h1>title</h1> <b>foo</b> <p>boo</p></div>'),
441
441
                          self.etree.tostring(root))
442
442
        self.etree.strip_tags(root, 'b')
443
 
        self.assertEquals(_bytes('<div><h1>title</h1> foo <p>boo</p></div>'),
 
443
        self.assertEqual(_bytes('<div><h1>title</h1> foo <p>boo</p></div>'),
444
444
                          self.etree.tostring(root))
445
445
        root.remove(root[0])
446
 
        self.assertEquals(_bytes('<div><p>boo</p></div>'),
 
446
        self.assertEqual(_bytes('<div><p>boo</p></div>'),
447
447
                          self.etree.tostring(root))
448
448
 
449
449
    def test_pi(self):
454
454
 
455
455
        a = Element('a')
456
456
        a.append(ProcessingInstruction('foo', 'some more text'))
457
 
        self.assertEquals(a[0].target, 'foo')
458
 
        self.assertEquals(a[0].text, 'some more text')
 
457
        self.assertEqual(a[0].target, 'foo')
 
458
        self.assertEqual(a[0].text, 'some more text')
459
459
 
460
460
    def test_pi_parse(self):
461
461
        XML = self.etree.XML
462
462
        root = XML(_bytes("<test><?mypi my test ?></test>"))
463
 
        self.assertEquals(root[0].target, "mypi")
464
 
        self.assertEquals(root[0].text, "my test ")
 
463
        self.assertEqual(root[0].target, "mypi")
 
464
        self.assertEqual(root[0].text, "my test ")
465
465
 
466
466
    def test_pi_pseudo_attributes_get(self):
467
467
        XML = self.etree.XML
468
468
        root = XML(_bytes("<test><?mypi my='1' test=\" abc \" quotes=\"' '\" only names ?></test>"))
469
 
        self.assertEquals(root[0].target, "mypi")
470
 
        self.assertEquals(root[0].get('my'), "1")
471
 
        self.assertEquals(root[0].get('test'), " abc ")
472
 
        self.assertEquals(root[0].get('quotes'), "' '")
473
 
        self.assertEquals(root[0].get('only'), None)
474
 
        self.assertEquals(root[0].get('names'), None)
475
 
        self.assertEquals(root[0].get('nope'), None)
 
469
        self.assertEqual(root[0].target, "mypi")
 
470
        self.assertEqual(root[0].get('my'), "1")
 
471
        self.assertEqual(root[0].get('test'), " abc ")
 
472
        self.assertEqual(root[0].get('quotes'), "' '")
 
473
        self.assertEqual(root[0].get('only'), None)
 
474
        self.assertEqual(root[0].get('names'), None)
 
475
        self.assertEqual(root[0].get('nope'), None)
476
476
 
477
477
    def test_pi_pseudo_attributes_attrib(self):
478
478
        XML = self.etree.XML
479
479
        root = XML(_bytes("<test><?mypi my='1' test=\" abc \" quotes=\"' '\" only names ?></test>"))
480
 
        self.assertEquals(root[0].target, "mypi")
481
 
        self.assertEquals(root[0].attrib['my'], "1")
482
 
        self.assertEquals(root[0].attrib['test'], " abc ")
483
 
        self.assertEquals(root[0].attrib['quotes'], "' '")
 
480
        self.assertEqual(root[0].target, "mypi")
 
481
        self.assertEqual(root[0].attrib['my'], "1")
 
482
        self.assertEqual(root[0].attrib['test'], " abc ")
 
483
        self.assertEqual(root[0].attrib['quotes'], "' '")
484
484
        self.assertRaises(KeyError, root[0].attrib.__getitem__, 'only')
485
485
        self.assertRaises(KeyError, root[0].attrib.__getitem__, 'names')
486
486
        self.assertRaises(KeyError, root[0].attrib.__getitem__, 'nope')
493
493
        b = copy.deepcopy(a)
494
494
        b.text = "ANOTHER"
495
495
 
496
 
        self.assertEquals('ONE',     a.text)
497
 
        self.assertEquals('ANOTHER', b.text)
 
496
        self.assertEqual('ONE',     a.text)
 
497
        self.assertEqual('ANOTHER', b.text)
498
498
 
499
499
    def test_deepcopy_elementtree_pi(self):
500
500
        XML = self.etree.XML
501
501
        tostring = self.etree.tostring
502
502
        root = XML(_bytes("<?mypi my test ?><test/><!--comment -->"))
503
503
        tree1 = self.etree.ElementTree(root)
504
 
        self.assertEquals(_bytes("<?mypi my test ?><test/><!--comment -->"),
 
504
        self.assertEqual(_bytes("<?mypi my test ?><test/><!--comment -->"),
505
505
                          tostring(tree1))
506
506
 
507
507
        tree2 = copy.deepcopy(tree1)
508
 
        self.assertEquals(_bytes("<?mypi my test ?><test/><!--comment -->"),
 
508
        self.assertEqual(_bytes("<?mypi my test ?><test/><!--comment -->"),
509
509
                          tostring(tree2))
510
510
 
511
511
        root2 = copy.deepcopy(tree1.getroot())
512
 
        self.assertEquals(_bytes("<test/>"),
 
512
        self.assertEqual(_bytes("<test/>"),
513
513
                          tostring(root2))
514
514
 
515
515
    def test_deepcopy_elementtree_dtd(self):
518
518
        xml = _bytes('<!DOCTYPE test [\n<!ENTITY entity "tasty">\n]>\n<test/>')
519
519
        root = XML(xml)
520
520
        tree1 = self.etree.ElementTree(root)
521
 
        self.assertEquals(xml, tostring(tree1))
 
521
        self.assertEqual(xml, tostring(tree1))
522
522
 
523
523
        tree2 = copy.deepcopy(tree1)
524
 
        self.assertEquals(xml, tostring(tree2))
 
524
        self.assertEqual(xml, tostring(tree2))
525
525
 
526
526
        root2 = copy.deepcopy(tree1.getroot())
527
 
        self.assertEquals(_bytes("<test/>"),
 
527
        self.assertEqual(_bytes("<test/>"),
528
528
                          tostring(root2))
529
529
 
530
530
    def test_attribute_set(self):
534
534
 
535
535
        root = Element("root")
536
536
        root.set("attr", "TEST")
537
 
        self.assertEquals("TEST", root.get("attr"))
 
537
        self.assertEqual("TEST", root.get("attr"))
538
538
        self.assertRaises(TypeError, root.set, "newattr", 5)
539
539
 
540
540
    def test_parse_remove_comments(self):
545
545
        xml = _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
546
546
        parser = XMLParser(remove_comments=True)
547
547
        root = fromstring(xml, parser)
548
 
        self.assertEquals(
 
548
        self.assertEqual(
549
549
            _bytes('<a><b><c/></b></a>'),
550
550
            tostring(root))
551
551
 
558
558
 
559
559
        f = BytesIO(xml)
560
560
        tree = parse(f)
561
 
        self.assertEquals(
 
561
        self.assertEqual(
562
562
            xml,
563
563
            tostring(tree))
564
564
 
565
565
        parser = XMLParser(remove_pis=True)
566
566
        tree = parse(f, parser)
567
 
        self.assertEquals(
 
567
        self.assertEqual(
568
568
            _bytes('<a><b><c/></b></a>'),
569
569
            tostring(tree))
570
570
 
581
581
        f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
582
582
        events = list(iterparse(f))
583
583
        root = events[-1][1]
584
 
        self.assertEquals(3, len(events))
585
 
        self.assertEquals(
 
584
        self.assertEqual(3, len(events))
 
585
        self.assertEqual(
586
586
            _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>'),
587
587
            tostring(root))
588
588
 
600
600
        f = BytesIO('<a><!--A--><b><!-- B --><c/></b><!--C--></a>')
601
601
        events = list(iterparse(f, events=('end', 'comment')))
602
602
        root = events[-1][1]
603
 
        self.assertEquals(6, len(events))
604
 
        self.assertEquals(['A', ' B ', 'c', 'b', 'C', 'a'],
 
603
        self.assertEqual(6, len(events))
 
604
        self.assertEqual(['A', ' B ', 'c', 'b', 'C', 'a'],
605
605
                          [ name(*item) for item in events ])
606
 
        self.assertEquals(
 
606
        self.assertEqual(
607
607
            _bytes('<a><!--A--><b><!-- B --><c/></b><!--C--></a>'),
608
608
            tostring(root))
609
609
 
622
622
        f = BytesIO('<?pia a?><a><?pib b?><b><?pic c?><c/></b><?pid d?></a><?pie e?>')
623
623
        events = list(iterparse(f, events=('end', 'pi')))
624
624
        root = events[-2][1]
625
 
        self.assertEquals(8, len(events))
626
 
        self.assertEquals([('pia','a'), ('pib','b'), ('pic','c'), 'c', 'b',
 
625
        self.assertEqual(8, len(events))
 
626
        self.assertEqual([('pia','a'), ('pib','b'), ('pic','c'), 'c', 'b',
627
627
                           ('pid','d'), 'a', ('pie','e')],
628
628
                          [ name(*item) for item in events ])
629
 
        self.assertEquals(
 
629
        self.assertEqual(
630
630
            _bytes('<?pia a?><a><?pib b?><b><?pic c?><c/></b><?pid d?></a><?pie e?>'),
631
631
            tostring(ElementTree(root)))
632
632
 
638
638
        events = list(iterparse(f, remove_comments=True,
639
639
                                events=('end', 'comment')))
640
640
        root = events[-1][1]
641
 
        self.assertEquals(3, len(events))
642
 
        self.assertEquals(['c', 'b', 'a'],
 
641
        self.assertEqual(3, len(events))
 
642
        self.assertEqual(['c', 'b', 'a'],
643
643
                          [ el.tag for (event, el) in events ])
644
 
        self.assertEquals(
 
644
        self.assertEqual(
645
645
            _bytes('<a><b><c/></b></a>'),
646
646
            tostring(root))
647
647
 
660
660
        iterator = iterparse(f, remove_blank_text=True)
661
661
        text = [ (element.text, element.tail)
662
662
                 for event, element in iterator ]
663
 
        self.assertEquals(
 
663
        self.assertEqual(
664
664
            [(" b test ", None), (" \n ", None), (None, None)],
665
665
            text)
666
666
 
671
671
        iterator = iterparse(f, tag="b", events=('start', 'end'))
672
672
        events = list(iterator)
673
673
        root = iterator.root
674
 
        self.assertEquals(
 
674
        self.assertEqual(
675
675
            [('start', root[0]), ('end', root[0])],
676
676
            events)
677
677
 
681
681
 
682
682
        iterator = iterparse(f, tag="*", events=('start', 'end'))
683
683
        events = list(iterator)
684
 
        self.assertEquals(
 
684
        self.assertEqual(
685
685
            8,
686
686
            len(events))
687
687
 
692
692
        iterator = iterparse(f, tag="{urn:test:1}b", events=('start', 'end'))
693
693
        events = list(iterator)
694
694
        root = iterator.root
695
 
        self.assertEquals(
 
695
        self.assertEqual(
696
696
            [('start', root[0]), ('end', root[0])],
697
697
            events)
698
698
 
702
702
        iterator = iterparse(f, tag="{}b", events=('start', 'end'))
703
703
        events = list(iterator)
704
704
        root = iterator.root
705
 
        self.assertEquals(
 
705
        self.assertEqual(
706
706
            [('start', root[0]), ('end', root[0])],
707
707
            events)
708
708
 
710
710
        iterator = iterparse(f, tag="{}b", events=('start', 'end'))
711
711
        events = list(iterator)
712
712
        root = iterator.root
713
 
        self.assertEquals([], events)
 
713
        self.assertEqual([], events)
714
714
 
715
715
    def test_iterparse_tag_ns_all(self):
716
716
        iterparse = self.etree.iterparse
717
717
        f = BytesIO('<a xmlns="urn:test:1"><b><d/></b><c/></a>')
718
718
        iterator = iterparse(f, tag="{urn:test:1}*", events=('start', 'end'))
719
719
        events = list(iterator)
720
 
        self.assertEquals(8, len(events))
 
720
        self.assertEqual(8, len(events))
721
721
 
722
722
    def test_iterparse_tag_ns_empty_all(self):
723
723
        iterparse = self.etree.iterparse
724
724
        f = BytesIO('<a xmlns="urn:test:1"><b><d/></b><c/></a>')
725
725
        iterator = iterparse(f, tag="{}*", events=('start', 'end'))
726
726
        events = list(iterator)
727
 
        self.assertEquals([], events)
 
727
        self.assertEqual([], events)
728
728
 
729
729
        f = BytesIO('<a><b><d/></b><c/></a>')
730
730
        iterator = iterparse(f, tag="{}*", events=('start', 'end'))
731
731
        events = list(iterator)
732
 
        self.assertEquals(8, len(events))
 
732
        self.assertEqual(8, len(events))
733
733
 
734
734
    def test_iterparse_encoding_error(self):
735
735
        text = _str('Søk på nettet')
748
748
 
749
749
        iterator = self.etree.iterparse(BytesIO(xml_latin1),
750
750
                                        encoding="iso-8859-1")
751
 
        self.assertEquals(1, len(list(iterator)))
 
751
        self.assertEqual(1, len(list(iterator)))
752
752
 
753
753
        a = iterator.root
754
 
        self.assertEquals(a.text, text)
 
754
        self.assertEqual(a.text, text)
755
755
 
756
756
    def test_iterparse_keep_cdata(self):
757
757
        tostring = self.etree.tostring
759
759
        context = self.etree.iterparse(f, strip_cdata=False)
760
760
        content = [ el.text for event,el in context ]
761
761
 
762
 
        self.assertEquals(['test'], content)
763
 
        self.assertEquals(_bytes('<root><![CDATA[test]]></root>'),
 
762
        self.assertEqual(['test'], content)
 
763
        self.assertEqual(_bytes('<root><![CDATA[test]]></root>'),
764
764
                          tostring(context.root))
765
765
 
766
766
    def test_parser_encoding_unknown(self):
784
784
 
785
785
        root = parser.close()
786
786
 
787
 
        self.assertEquals(root.tag, "root")
788
 
        self.assertEquals(len(root), 1)
789
 
        self.assertEquals(root[0].tag, "a")
790
 
        self.assertEquals(root[0].get("test"), "works")
791
 
        self.assertEquals(len(root[0]), 1)
792
 
        self.assertEquals(root[0][0].tag, "othertag")
 
787
        self.assertEqual(root.tag, "root")
 
788
        self.assertEqual(len(root), 1)
 
789
        self.assertEqual(root[0].tag, "a")
 
790
        self.assertEqual(root[0].get("test"), "works")
 
791
        self.assertEqual(len(root[0]), 1)
 
792
        self.assertEqual(root[0][0].tag, "othertag")
793
793
        # FIXME: would be nice to get some errors logged ...
794
 
        #self.assert_(len(parser.error_log) > 0, "error log is empty")
 
794
        #self.assertTrue(len(parser.error_log) > 0, "error log is empty")
795
795
 
796
796
    def test_elementtree_parser_target_type_error(self):
797
 
        assertEquals = self.assertEquals
 
797
        assertEqual = self.assertEqual
798
798
        assertFalse  = self.assertFalse
799
799
 
800
800
        events = []
802
802
            def start(self, tag, attrib):
803
803
                events.append("start")
804
804
                assertFalse(attrib)
805
 
                assertEquals("TAG", tag)
 
805
                assertEqual("TAG", tag)
806
806
            def end(self, tag):
807
807
                events.append("end")
808
 
                assertEquals("TAG", tag)
 
808
                assertEqual("TAG", tag)
809
809
            def close(self):
810
810
                return "DONE" # no Element!
811
811
 
814
814
 
815
815
        self.assertRaises(TypeError,
816
816
                          tree.parse, BytesIO("<TAG/>"), parser=parser)
817
 
        self.assertEquals(["start", "end"], events)
 
817
        self.assertEqual(["start", "end"], events)
818
818
 
819
819
    def test_parser_target_feed_exception(self):
820
820
        # ET doesn't call .close() on errors
841
841
        except ValueError:
842
842
            done = 'value error received as expected'
843
843
 
844
 
        self.assertEquals(["start-root", "data-A", "start-a",
 
844
        self.assertEqual(["start-root", "data-A", "start-a",
845
845
                           "data-ca", "end-a", "close"],
846
846
                          events)
847
847
 
870
870
        except ValueError:
871
871
            done = 'value error received as expected'
872
872
 
873
 
        self.assertEquals(["start-root", "data-A", "start-a",
 
873
        self.assertEqual(["start-root", "data-A", "start-a",
874
874
                           "data-ca", "end-a", "close"],
875
875
                          events)
876
876
 
893
893
        parser.feed(_bytes('<!--a--><root>A<!--b--><sub/><!--c-->B</root><!--d-->'))
894
894
        done = parser.close()
895
895
 
896
 
        self.assertEquals("DONE", done)
897
 
        self.assertEquals(["comment-a", "start-root", "data-A", "comment-b",
 
896
        self.assertEqual("DONE", done)
 
897
        self.assertEqual(["comment-a", "start-root", "data-A", "comment-b",
898
898
                           "start-sub", "end-sub", "comment-c", "data-B",
899
899
                           "end-root", "comment-d"],
900
900
                          events)
918
918
        parser.feed(_bytes('<?test a?><root>A<?test b?>B</root><?test c?>'))
919
919
        done = parser.close()
920
920
 
921
 
        self.assertEquals("DONE", done)
922
 
        self.assertEquals(["pi-test-a", "start-root", "data-A", "pi-test-b",
 
921
        self.assertEqual("DONE", done)
 
922
        self.assertEqual(["pi-test-a", "start-root", "data-A", "pi-test-b",
923
923
                           "data-B", "end-root", "pi-test-c"],
924
924
                          events)
925
925
 
941
941
        parser.feed(_bytes('<root>A<a><![CDATA[ca]]></a>B</root>'))
942
942
        done = parser.close()
943
943
 
944
 
        self.assertEquals("DONE", done)
945
 
        self.assertEquals(["start-root", "data-A", "start-a",
 
944
        self.assertEqual("DONE", done)
 
945
        self.assertEqual(["start-root", "data-A", "start-a",
946
946
                           "data-ca", "end-a", "data-B", "end-root"],
947
947
                          events)
948
948
 
965
965
        parser.feed(_bytes('<root>A<a>ca</a>B</not-root>'))
966
966
        done = parser.close()
967
967
 
968
 
        self.assertEquals("DONE", done)
969
 
        self.assertEquals(["start-root", "data-A", "start-a",
 
968
        self.assertEqual("DONE", done)
 
969
        self.assertEqual(["start-root", "data-A", "start-a",
970
970
                           "data-ca", "end-a", "data-B",
971
971
                           "end-root", "close"],
972
972
                          events)
977
977
 
978
978
        iterator = iterwalk(root, tag="b", events=('start', 'end'))
979
979
        events = list(iterator)
980
 
        self.assertEquals(
 
980
        self.assertEqual(
981
981
            [('start', root[0]), ('end', root[0])],
982
982
            events)
983
983
 
987
987
 
988
988
        iterator = iterwalk(root, tag="*", events=('start', 'end'))
989
989
        events = list(iterator)
990
 
        self.assertEquals(
 
990
        self.assertEqual(
991
991
            8,
992
992
            len(events))
993
993
 
996
996
        root = self.etree.XML(_bytes('<a><b></b><c/></a>'))
997
997
 
998
998
        events = list(iterwalk(root))
999
 
        self.assertEquals(
 
999
        self.assertEqual(
1000
1000
            [('end', root[0]), ('end', root[1]), ('end', root)],
1001
1001
            events)
1002
1002
 
1006
1006
 
1007
1007
        iterator = iterwalk(root, events=('start',))
1008
1008
        events = list(iterator)
1009
 
        self.assertEquals(
 
1009
        self.assertEqual(
1010
1010
            [('start', root), ('start', root[0]), ('start', root[1])],
1011
1011
            events)
1012
1012
 
1016
1016
 
1017
1017
        iterator = iterwalk(root, events=('start','end'))
1018
1018
        events = list(iterator)
1019
 
        self.assertEquals(
 
1019
        self.assertEqual(
1020
1020
            [('start', root), ('start', root[0]), ('end', root[0]),
1021
1021
             ('start', root[1]), ('end', root[1]), ('end', root)],
1022
1022
            events)
1029
1029
        for event, elem in iterator:
1030
1030
            elem.clear()
1031
1031
 
1032
 
        self.assertEquals(0,
 
1032
        self.assertEqual(0,
1033
1033
                          len(root))
1034
1034
 
1035
1035
    def test_iterwalk_attrib_ns(self):
1045
1045
                if elem.tag != '{ns1}a':
1046
1046
                    elem.set(attr_name, 'value')
1047
1047
 
1048
 
        self.assertEquals(
 
1048
        self.assertEqual(
1049
1049
            ['start-ns', 'start', 'start', 'start-ns', 'start',
1050
1050
             'end', 'end-ns', 'end', 'end', 'end-ns'],
1051
1051
            events)
1052
1052
 
1053
 
        self.assertEquals(
 
1053
        self.assertEqual(
1054
1054
            None,
1055
1055
            root.get(attr_name))
1056
 
        self.assertEquals(
 
1056
        self.assertEqual(
1057
1057
            'value',
1058
1058
            root[0].get(attr_name))
1059
1059
 
1064
1064
        counts = []
1065
1065
        for event, elem in iterwalk(root):
1066
1066
            counts.append(len(list(elem.getiterator())))
1067
 
        self.assertEquals(
 
1067
        self.assertEqual(
1068
1068
            [1,2,1,4],
1069
1069
            counts)
1070
1070
 
1086
1086
        xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
1087
1087
        tree = parse(StringIO(xml), parser)
1088
1088
        root = tree.getroot()
1089
 
        self.assertEquals(root.text, test_url)
 
1089
        self.assertEqual(root.text, test_url)
1090
1090
 
1091
1091
    def test_resolve_bytes_dtd(self):
1092
1092
        parse = self.etree.parse
1107
1107
        xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
1108
1108
        tree = parse(StringIO(xml), parser)
1109
1109
        root = tree.getroot()
1110
 
        self.assertEquals(root.text, test_url)
 
1110
        self.assertEqual(root.text, test_url)
1111
1111
 
1112
1112
    def test_resolve_filelike_dtd(self):
1113
1113
        parse = self.etree.parse
1128
1128
        xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
1129
1129
        tree = parse(StringIO(xml), parser)
1130
1130
        root = tree.getroot()
1131
 
        self.assertEquals(root.text, test_url)
 
1131
        self.assertEqual(root.text, test_url)
1132
1132
 
1133
1133
    def test_resolve_filename_dtd(self):
1134
1134
        parse = self.etree.parse
1147
1147
        xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url
1148
1148
        tree = parse(StringIO(xml), parser)
1149
1149
        root = tree.getroot()
1150
 
        self.assertEquals(
 
1150
        self.assertEqual(
1151
1151
            root.attrib,    {'default': 'valueA'})
1152
 
        self.assertEquals(
 
1152
        self.assertEqual(
1153
1153
            root[0].attrib, {'default': 'valueB'})
1154
1154
 
1155
1155
    def test_resolve_filename_dtd_relative(self):
1170
1170
        tree = parse(StringIO(xml), parser,
1171
1171
                     base_url=fileInTestDir('__test.xml'))
1172
1172
        root = tree.getroot()
1173
 
        self.assertEquals(
 
1173
        self.assertEqual(
1174
1174
            root.attrib,    {'default': 'valueA'})
1175
 
        self.assertEquals(
 
1175
        self.assertEqual(
1176
1176
            root[0].attrib, {'default': 'valueB'})
1177
1177
 
1178
1178
    def test_resolve_file_dtd(self):
1192
1192
        xml = _str('<!DOCTYPE a SYSTEM "%s"><a><b/></a>') % test_url
1193
1193
        tree = parse(StringIO(xml), parser)
1194
1194
        root = tree.getroot()
1195
 
        self.assertEquals(
 
1195
        self.assertEqual(
1196
1196
            root.attrib,    {'default': 'valueA'})
1197
 
        self.assertEquals(
 
1197
        self.assertEqual(
1198
1198
            root[0].attrib, {'default': 'valueB'})
1199
1199
 
1200
1200
    def test_resolve_empty(self):
1216
1216
 
1217
1217
        xml = _str('<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>') % test_url
1218
1218
        self.assertRaises(etree.XMLSyntaxError, parse, StringIO(xml), parser)
1219
 
        self.assert_(check.resolved)
 
1219
        self.assertTrue(check.resolved)
1220
1220
 
1221
1221
    def test_resolve_error(self):
1222
1222
        parse = self.etree.parse
1244
1244
            xml = _bytes('<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>')
1245
1245
            tree = parse(BytesIO(xml), parser)
1246
1246
            root = tree.getroot()
1247
 
            self.assertEquals(root[0].tag, Entity)
1248
 
            self.assertEquals(root[0].text, "&myentity;")
1249
 
            self.assertEquals(root[0].tail, None)
1250
 
            self.assertEquals(root[0].name, "myentity")
 
1247
            self.assertEqual(root[0].tag, Entity)
 
1248
            self.assertEqual(root[0].text, "&myentity;")
 
1249
            self.assertEqual(root[0].tail, None)
 
1250
            self.assertEqual(root[0].name, "myentity")
1251
1251
 
1252
 
            self.assertEquals(_bytes('<doc>&myentity;</doc>'),
 
1252
            self.assertEqual(_bytes('<doc>&myentity;</doc>'),
1253
1253
                              tostring(root))
1254
1254
 
1255
1255
        def test_entity_restructure(self):
1262
1262
 
1263
1263
            parser = self.etree.XMLParser(resolve_entities=False)
1264
1264
            root = etree.fromstring(xml, parser)
1265
 
            self.assertEquals([ el.tag for el in root ],
 
1265
            self.assertEqual([ el.tag for el in root ],
1266
1266
                              ['child1', 'child2', 'child3'])
1267
1267
 
1268
1268
            root[0] = root[-1]
1269
 
            self.assertEquals([ el.tag for el in root ],
 
1269
            self.assertEqual([ el.tag for el in root ],
1270
1270
                              ['child3', 'child2'])
1271
 
            self.assertEquals(root[0][0].text, '&nbsp;')
1272
 
            self.assertEquals(root[0][0].name, 'nbsp')
 
1271
            self.assertEqual(root[0][0].text, '&nbsp;')
 
1272
            self.assertEqual(root[0][0].name, 'nbsp')
1273
1273
 
1274
1274
    def test_entity_append(self):
1275
1275
        Entity = self.etree.Entity
1279
1279
        root = Element("root")
1280
1280
        root.append( Entity("test") )
1281
1281
 
1282
 
        self.assertEquals(root[0].tag, Entity)
1283
 
        self.assertEquals(root[0].text, "&test;")
1284
 
        self.assertEquals(root[0].tail, None)
1285
 
        self.assertEquals(root[0].name, "test")
 
1282
        self.assertEqual(root[0].tag, Entity)
 
1283
        self.assertEqual(root[0].text, "&test;")
 
1284
        self.assertEqual(root[0].tail, None)
 
1285
        self.assertEqual(root[0].name, "test")
1286
1286
 
1287
 
        self.assertEquals(_bytes('<root>&test;</root>'),
 
1287
        self.assertEqual(_bytes('<root>&test;</root>'),
1288
1288
                          tostring(root))
1289
1289
 
1290
1290
    def test_entity_values(self):
1291
1291
        Entity = self.etree.Entity
1292
 
        self.assertEquals(Entity("test").text, '&test;')
1293
 
        self.assertEquals(Entity("#17683").text, '&#17683;')
1294
 
        self.assertEquals(Entity("#x1768").text, '&#x1768;')
1295
 
        self.assertEquals(Entity("#x98AF").text, '&#x98AF;')
 
1292
        self.assertEqual(Entity("test").text, '&test;')
 
1293
        self.assertEqual(Entity("#17683").text, '&#17683;')
 
1294
        self.assertEqual(Entity("#x1768").text, '&#x1768;')
 
1295
        self.assertEqual(Entity("#x98AF").text, '&#x98AF;')
1296
1296
 
1297
1297
    def test_entity_error(self):
1298
1298
        Entity = self.etree.Entity
1310
1310
        root = Element("root")
1311
1311
        root.text = CDATA('test')
1312
1312
 
1313
 
        self.assertEquals('test',
 
1313
        self.assertEqual('test',
1314
1314
                          root.text)
1315
 
        self.assertEquals(_bytes('<root><![CDATA[test]]></root>'),
 
1315
        self.assertEqual(_bytes('<root><![CDATA[test]]></root>'),
1316
1316
                          tostring(root))
1317
1317
 
1318
1318
    def test_cdata_type(self):
1321
1321
        root = Element("root")
1322
1322
 
1323
1323
        root.text = CDATA("test")
1324
 
        self.assertEquals('test', root.text)
 
1324
        self.assertEqual('test', root.text)
1325
1325
 
1326
1326
        root.text = CDATA(_str("test"))
1327
 
        self.assertEquals('test', root.text)
 
1327
        self.assertEqual('test', root.text)
1328
1328
 
1329
1329
        self.assertRaises(TypeError, CDATA, 1)
1330
1330
 
1347
1347
        parser = self.etree.XMLParser(strip_cdata=False)
1348
1348
        root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>'), parser)
1349
1349
 
1350
 
        self.assertEquals('test', root.text)
1351
 
        self.assertEquals(_bytes('<root><![CDATA[test]]></root>'),
 
1350
        self.assertEqual('test', root.text)
 
1351
        self.assertEqual(_bytes('<root><![CDATA[test]]></root>'),
1352
1352
                          tostring(root))
1353
1353
 
1354
1354
    def test_cdata_xpath(self):
1355
1355
        tostring = self.etree.tostring
1356
1356
        parser = self.etree.XMLParser(strip_cdata=False)
1357
1357
        root = self.etree.XML(_bytes('<root><![CDATA[test]]></root>'), parser)
1358
 
        self.assertEquals(_bytes('<root><![CDATA[test]]></root>'),
 
1358
        self.assertEqual(_bytes('<root><![CDATA[test]]></root>'),
1359
1359
                          tostring(root))
1360
1360
 
1361
 
        self.assertEquals(['test'], root.xpath('//text()'))
 
1361
        self.assertEqual(['test'], root.xpath('//text()'))
1362
1362
 
1363
1363
    # TypeError in etree, AssertionError in ElementTree;
1364
1364
    def test_setitem_assert(self):
1378
1378
        self.assertRaises(TypeError, root.append, None)
1379
1379
        self.assertRaises(TypeError, root.extend, [None])
1380
1380
        self.assertRaises(TypeError, root.extend, [Element('one'), None])
1381
 
        self.assertEquals('one', root[0].tag)
 
1381
        self.assertEqual('one', root[0].tag)
1382
1382
 
1383
1383
    def test_addnext(self):
1384
1384
        Element = self.etree.Element
1387
1387
        SubElement(root, 'a')
1388
1388
        SubElement(root, 'b')
1389
1389
 
1390
 
        self.assertEquals(['a', 'b'],
 
1390
        self.assertEqual(['a', 'b'],
1391
1391
                          [c.tag for c in root])
1392
1392
        root[1].addnext(root[0])
1393
 
        self.assertEquals(['b', 'a'],
 
1393
        self.assertEqual(['b', 'a'],
1394
1394
                          [c.tag for c in root])
1395
1395
 
1396
1396
    def test_addprevious(self):
1400
1400
        SubElement(root, 'a')
1401
1401
        SubElement(root, 'b')
1402
1402
 
1403
 
        self.assertEquals(['a', 'b'],
 
1403
        self.assertEqual(['a', 'b'],
1404
1404
                          [c.tag for c in root])
1405
1405
        root[0].addprevious(root[1])
1406
 
        self.assertEquals(['b', 'a'],
 
1406
        self.assertEqual(['b', 'a'],
1407
1407
                          [c.tag for c in root])
1408
1408
 
1409
1409
    def test_addnext_root(self):
1427
1427
        pi = PI('TARGET', 'TEXT')
1428
1428
        pi.tail = "TAIL"
1429
1429
 
1430
 
        self.assertEquals(_bytes('<root><a></a></root>'),
 
1430
        self.assertEqual(_bytes('<root><a></a></root>'),
1431
1431
                          self._writeElement(root))
1432
1432
        root[0].addprevious(pi)
1433
 
        self.assertEquals(_bytes('<root><?TARGET TEXT?>TAIL<a></a></root>'),
 
1433
        self.assertEqual(_bytes('<root><?TARGET TEXT?>TAIL<a></a></root>'),
1434
1434
                          self._writeElement(root))
1435
1435
 
1436
1436
    def test_addprevious_root_pi(self):
1440
1440
        pi = PI('TARGET', 'TEXT')
1441
1441
        pi.tail = "TAIL"
1442
1442
 
1443
 
        self.assertEquals(_bytes('<root></root>'),
 
1443
        self.assertEqual(_bytes('<root></root>'),
1444
1444
                          self._writeElement(root))
1445
1445
        root.addprevious(pi)
1446
 
        self.assertEquals(_bytes('<?TARGET TEXT?>\n<root></root>'),
 
1446
        self.assertEqual(_bytes('<?TARGET TEXT?>\n<root></root>'),
1447
1447
                          self._writeElement(root))
1448
1448
 
1449
1449
    def test_addnext_pi(self):
1455
1455
        pi = PI('TARGET', 'TEXT')
1456
1456
        pi.tail = "TAIL"
1457
1457
 
1458
 
        self.assertEquals(_bytes('<root><a></a></root>'),
 
1458
        self.assertEqual(_bytes('<root><a></a></root>'),
1459
1459
                          self._writeElement(root))
1460
1460
        root[0].addnext(pi)
1461
 
        self.assertEquals(_bytes('<root><a></a><?TARGET TEXT?>TAIL</root>'),
 
1461
        self.assertEqual(_bytes('<root><a></a><?TARGET TEXT?>TAIL</root>'),
1462
1462
                          self._writeElement(root))
1463
1463
 
1464
1464
    def test_addnext_root_pi(self):
1468
1468
        pi = PI('TARGET', 'TEXT')
1469
1469
        pi.tail = "TAIL"
1470
1470
 
1471
 
        self.assertEquals(_bytes('<root></root>'),
 
1471
        self.assertEqual(_bytes('<root></root>'),
1472
1472
                          self._writeElement(root))
1473
1473
        root.addnext(pi)
1474
 
        self.assertEquals(_bytes('<root></root>\n<?TARGET TEXT?>'),
 
1474
        self.assertEqual(_bytes('<root></root>\n<?TARGET TEXT?>'),
1475
1475
                          self._writeElement(root))
1476
1476
 
1477
1477
    def test_addnext_comment(self):
1483
1483
        comment = Comment('TEXT ')
1484
1484
        comment.tail = "TAIL"
1485
1485
 
1486
 
        self.assertEquals(_bytes('<root><a></a></root>'),
 
1486
        self.assertEqual(_bytes('<root><a></a></root>'),
1487
1487
                          self._writeElement(root))
1488
1488
        root[0].addnext(comment)
1489
 
        self.assertEquals(_bytes('<root><a></a><!--TEXT -->TAIL</root>'),
 
1489
        self.assertEqual(_bytes('<root><a></a><!--TEXT -->TAIL</root>'),
1490
1490
                          self._writeElement(root))
1491
1491
 
1492
1492
    def test_addnext_root_comment(self):
1496
1496
        comment = Comment('TEXT ')
1497
1497
        comment.tail = "TAIL"
1498
1498
 
1499
 
        self.assertEquals(_bytes('<root></root>'),
 
1499
        self.assertEqual(_bytes('<root></root>'),
1500
1500
                          self._writeElement(root))
1501
1501
        root.addnext(comment)
1502
 
        self.assertEquals(_bytes('<root></root>\n<!--TEXT -->'),
 
1502
        self.assertEqual(_bytes('<root></root>\n<!--TEXT -->'),
1503
1503
                          self._writeElement(root))
1504
1504
 
1505
1505
    def test_addprevious_comment(self):
1511
1511
        comment = Comment('TEXT ')
1512
1512
        comment.tail = "TAIL"
1513
1513
 
1514
 
        self.assertEquals(_bytes('<root><a></a></root>'),
 
1514
        self.assertEqual(_bytes('<root><a></a></root>'),
1515
1515
                          self._writeElement(root))
1516
1516
        root[0].addprevious(comment)
1517
 
        self.assertEquals(_bytes('<root><!--TEXT -->TAIL<a></a></root>'),
 
1517
        self.assertEqual(_bytes('<root><!--TEXT -->TAIL<a></a></root>'),
1518
1518
                          self._writeElement(root))
1519
1519
 
1520
1520
    def test_addprevious_root_comment(self):
1524
1524
        comment = Comment('TEXT ')
1525
1525
        comment.tail = "TAIL"
1526
1526
 
1527
 
        self.assertEquals(_bytes('<root></root>'),
 
1527
        self.assertEqual(_bytes('<root></root>'),
1528
1528
                          self._writeElement(root))
1529
1529
        root.addprevious(comment)
1530
 
        self.assertEquals(_bytes('<!--TEXT -->\n<root></root>'),
 
1530
        self.assertEqual(_bytes('<!--TEXT -->\n<root></root>'),
1531
1531
                          self._writeElement(root))
1532
1532
 
1533
1533
    # ET's Elements have items() and key(), but not values()
1537
1537
        root = XML(_bytes('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>'))
1538
1538
        values = root.values()
1539
1539
        values.sort()
1540
 
        self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)
 
1540
        self.assertEqual(['Alpha', 'Beta', 'Gamma'], values)
1541
1541
 
1542
1542
    # gives error in ElementTree
1543
1543
    def test_comment_empty(self):
1546
1546
 
1547
1547
        a = Element('a')
1548
1548
        a.append(Comment())
1549
 
        self.assertEquals(
 
1549
        self.assertEqual(
1550
1550
            _bytes('<a><!----></a>'),
1551
1551
            self._writeElement(a))
1552
1552
 
1559
1559
        f = BytesIO(xml)
1560
1560
        doc = ElementTree(file=f)
1561
1561
        a = doc.getroot()
1562
 
        self.assertEquals(
 
1562
        self.assertEqual(
1563
1563
            '',
1564
1564
            a[1].text)
1565
 
        self.assertEquals(
 
1565
        self.assertEqual(
1566
1566
            xml,
1567
1567
            tostring(a))
1568
1568
 
1573
1573
        f = BytesIO('<a><b></b><!-- hoi --><c></c></a>')
1574
1574
        doc = ElementTree(file=f)
1575
1575
        a = doc.getroot()
1576
 
        self.assertEquals(
 
1576
        self.assertEqual(
1577
1577
            ' hoi ',
1578
1578
            a[1].text)
1579
1579
 
1599
1599
        f = BytesIO('<a xmlns:foo="http://www.infrae.com/ns/1"><foo:b/></a>')
1600
1600
        doc = ElementTree(file=f)
1601
1601
        a = doc.getroot()
1602
 
        self.assertEquals(
 
1602
        self.assertEqual(
1603
1603
            None,
1604
1604
            a.prefix)
1605
 
        self.assertEquals(
 
1605
        self.assertEqual(
1606
1606
            'foo',
1607
1607
            a[0].prefix)
1608
1608
 
1612
1612
        f = BytesIO('<a xmlns="http://www.infrae.com/ns/1"><b/></a>')
1613
1613
        doc = ElementTree(file=f)
1614
1614
        a = doc.getroot()
1615
 
        self.assertEquals(
 
1615
        self.assertEqual(
1616
1616
            None,
1617
1617
            a.prefix)
1618
 
        self.assertEquals(
 
1618
        self.assertEqual(
1619
1619
            None,
1620
1620
            a[0].prefix)
1621
1621
 
1627
1627
        b = SubElement(a, 'b')
1628
1628
        c = SubElement(a, 'c')
1629
1629
        d = SubElement(b, 'd')
1630
 
        self.assertEquals(
 
1630
        self.assertEqual(
1631
1631
            None,
1632
1632
            a.getparent())
1633
 
        self.assertEquals(
 
1633
        self.assertEqual(
1634
1634
            a,
1635
1635
            b.getparent())
1636
 
        self.assertEquals(
 
1636
        self.assertEqual(
1637
1637
            b.getparent(),
1638
1638
            c.getparent())
1639
 
        self.assertEquals(
 
1639
        self.assertEqual(
1640
1640
            b,
1641
1641
            d.getparent())
1642
1642
 
1647
1647
        result = []
1648
1648
        for el in root.iterchildren():
1649
1649
            result.append(el.tag)
1650
 
        self.assertEquals(['one', 'two', 'three'], result)
 
1650
        self.assertEqual(['one', 'two', 'three'], result)
1651
1651
 
1652
1652
    def test_iterchildren_reversed(self):
1653
1653
        XML = self.etree.XML
1656
1656
        result = []
1657
1657
        for el in root.iterchildren(reversed=True):
1658
1658
            result.append(el.tag)
1659
 
        self.assertEquals(['three', 'two', 'one'], result)
 
1659
        self.assertEqual(['three', 'two', 'one'], result)
1660
1660
 
1661
1661
    def test_iterchildren_tag(self):
1662
1662
        XML = self.etree.XML
1665
1665
        result = []
1666
1666
        for el in root.iterchildren(tag='two'):
1667
1667
            result.append(el.text)
1668
 
        self.assertEquals(['Two', 'Bla'], result)
 
1668
        self.assertEqual(['Two', 'Bla'], result)
1669
1669
 
1670
1670
    def test_iterchildren_tag_reversed(self):
1671
1671
        XML = self.etree.XML
1674
1674
        result = []
1675
1675
        for el in root.iterchildren(reversed=True, tag='two'):
1676
1676
            result.append(el.text)
1677
 
        self.assertEquals(['Bla', 'Two'], result)
 
1677
        self.assertEqual(['Bla', 'Two'], result)
1678
1678
 
1679
1679
    def test_iterchildren_tag_multiple(self):
1680
1680
        XML = self.etree.XML
1683
1683
        result = []
1684
1684
        for el in root.iterchildren(tag=['two', 'three']):
1685
1685
            result.append(el.text)
1686
 
        self.assertEquals(['Two', 'Bla', None], result)
 
1686
        self.assertEqual(['Two', 'Bla', None], result)
1687
1687
 
1688
1688
    def test_iterchildren_tag_multiple_reversed(self):
1689
1689
        XML = self.etree.XML
1692
1692
        result = []
1693
1693
        for el in root.iterchildren(reversed=True, tag=['two', 'three']):
1694
1694
            result.append(el.text)
1695
 
        self.assertEquals([None, 'Bla', 'Two'], result)
 
1695
        self.assertEqual([None, 'Bla', 'Two'], result)
1696
1696
 
1697
1697
    def test_iterancestors(self):
1698
1698
        Element    = self.etree.Element
1702
1702
        b = SubElement(a, 'b')
1703
1703
        c = SubElement(a, 'c')
1704
1704
        d = SubElement(b, 'd')
1705
 
        self.assertEquals(
 
1705
        self.assertEqual(
1706
1706
            [],
1707
1707
            list(a.iterancestors()))
1708
 
        self.assertEquals(
 
1708
        self.assertEqual(
1709
1709
            [a],
1710
1710
            list(b.iterancestors()))
1711
 
        self.assertEquals(
 
1711
        self.assertEqual(
1712
1712
            [a],
1713
1713
            list(c.iterancestors()))
1714
 
        self.assertEquals(
 
1714
        self.assertEqual(
1715
1715
            [b, a],
1716
1716
            list(d.iterancestors()))
1717
1717
 
1723
1723
        b = SubElement(a, 'b')
1724
1724
        c = SubElement(a, 'c')
1725
1725
        d = SubElement(b, 'd')
1726
 
        self.assertEquals(
 
1726
        self.assertEqual(
1727
1727
            [a],
1728
1728
            list(d.iterancestors(tag='a')))
1729
 
        self.assertEquals(
 
1729
        self.assertEqual(
1730
1730
            [b, a],
1731
1731
               list(d.iterancestors(tag='*')))
1732
1732
 
1738
1738
        b = SubElement(a, 'b')
1739
1739
        c = SubElement(a, 'c')
1740
1740
        d = SubElement(b, 'd')
1741
 
        self.assertEquals(
 
1741
        self.assertEqual(
1742
1742
            [b, a],
1743
1743
               list(d.iterancestors(tag=('a', 'b'))))
1744
 
        self.assertEquals(
 
1744
        self.assertEqual(
1745
1745
            [],
1746
1746
               list(d.iterancestors(tag=('w', 'x', 'y', 'z'))))
1747
 
        self.assertEquals(
 
1747
        self.assertEqual(
1748
1748
            [],
1749
1749
              list(d.iterancestors(tag=('d', 'x'))))
1750
 
        self.assertEquals(
 
1750
        self.assertEqual(
1751
1751
            [b, a],
1752
1752
              list(d.iterancestors(tag=('b', '*'))))
1753
 
        self.assertEquals(
 
1753
        self.assertEqual(
1754
1754
            [b],
1755
1755
              list(d.iterancestors(tag=('b', 'c'))))
1756
1756
 
1764
1764
        d = SubElement(b, 'd')
1765
1765
        e = SubElement(c, 'e')
1766
1766
 
1767
 
        self.assertEquals(
 
1767
        self.assertEqual(
1768
1768
            [b, d, c, e],
1769
1769
            list(a.iterdescendants()))
1770
 
        self.assertEquals(
 
1770
        self.assertEqual(
1771
1771
            [],
1772
1772
            list(d.iterdescendants()))
1773
1773
 
1781
1781
        d = SubElement(b, 'd')
1782
1782
        e = SubElement(c, 'e')
1783
1783
 
1784
 
        self.assertEquals(
 
1784
        self.assertEqual(
1785
1785
            [],
1786
1786
            list(a.iterdescendants('a')))
1787
1787
        a2 = SubElement(e, 'a')
1788
 
        self.assertEquals(
 
1788
        self.assertEqual(
1789
1789
            [a2],
1790
1790
            list(a.iterdescendants('a')))
1791
 
        self.assertEquals(
 
1791
        self.assertEqual(
1792
1792
            [a2],
1793
1793
            list(c.iterdescendants('a')))
1794
1794
 
1802
1802
        d = SubElement(b, 'd')
1803
1803
        e = SubElement(c, 'e')
1804
1804
 
1805
 
        self.assertEquals(
 
1805
        self.assertEqual(
1806
1806
            [b, e],
1807
1807
            list(a.iterdescendants(tag=('a', 'b', 'e'))))
1808
1808
        a2 = SubElement(e, 'a')
1809
 
        self.assertEquals(
 
1809
        self.assertEqual(
1810
1810
            [b, a2],
1811
1811
            list(a.iterdescendants(tag=('a', 'b'))))
1812
 
        self.assertEquals(
 
1812
        self.assertEqual(
1813
1813
            [],
1814
1814
            list(c.iterdescendants(tag=('x', 'y', 'z'))))
1815
 
        self.assertEquals(
 
1815
        self.assertEqual(
1816
1816
            [b, d, c, e, a2],
1817
1817
              list(a.iterdescendants(tag=('x', 'y', 'z', '*'))))
1818
1818
 
1824
1824
        b = SubElement(a, 'b')
1825
1825
        c = SubElement(a, 'c')
1826
1826
        d = SubElement(b, 'd')
1827
 
        self.assertEquals(
 
1827
        self.assertEqual(
1828
1828
            a,
1829
1829
            a.getroottree().getroot())
1830
 
        self.assertEquals(
 
1830
        self.assertEqual(
1831
1831
            a,
1832
1832
            b.getroottree().getroot())
1833
 
        self.assertEquals(
 
1833
        self.assertEqual(
1834
1834
            a,
1835
1835
            d.getroottree().getroot())
1836
1836
 
1841
1841
        a = Element('a')
1842
1842
        b = SubElement(a, 'b')
1843
1843
        c = SubElement(a, 'c')
1844
 
        self.assertEquals(
 
1844
        self.assertEqual(
1845
1845
            None,
1846
1846
            a.getnext())
1847
 
        self.assertEquals(
 
1847
        self.assertEqual(
1848
1848
            c,
1849
1849
            b.getnext())
1850
 
        self.assertEquals(
 
1850
        self.assertEqual(
1851
1851
            None,
1852
1852
            c.getnext())
1853
1853
 
1859
1859
        b = SubElement(a, 'b')
1860
1860
        c = SubElement(a, 'c')
1861
1861
        d = SubElement(b, 'd')
1862
 
        self.assertEquals(
 
1862
        self.assertEqual(
1863
1863
            None,
1864
1864
            a.getprevious())
1865
 
        self.assertEquals(
 
1865
        self.assertEqual(
1866
1866
            b,
1867
1867
            c.getprevious())
1868
 
        self.assertEquals(
 
1868
        self.assertEqual(
1869
1869
            None,
1870
1870
            b.getprevious())
1871
1871
 
1877
1877
        b = SubElement(a, 'b')
1878
1878
        c = SubElement(a, 'c')
1879
1879
        d = SubElement(b, 'd')
1880
 
        self.assertEquals(
 
1880
        self.assertEqual(
1881
1881
            [],
1882
1882
            list(a.itersiblings()))
1883
 
        self.assertEquals(
 
1883
        self.assertEqual(
1884
1884
            [c],
1885
1885
            list(b.itersiblings()))
1886
 
        self.assertEquals(
 
1886
        self.assertEqual(
1887
1887
            [],
1888
1888
            list(c.itersiblings()))
1889
 
        self.assertEquals(
 
1889
        self.assertEqual(
1890
1890
            [b],
1891
1891
            list(c.itersiblings(preceding=True)))
1892
 
        self.assertEquals(
 
1892
        self.assertEqual(
1893
1893
            [],
1894
1894
            list(b.itersiblings(preceding=True)))
1895
1895
 
1901
1901
        b = SubElement(a, 'b')
1902
1902
        c = SubElement(a, 'c')
1903
1903
        d = SubElement(b, 'd')
1904
 
        self.assertEquals(
 
1904
        self.assertEqual(
1905
1905
            [],
1906
1906
            list(a.itersiblings(tag='XXX')))
1907
 
        self.assertEquals(
 
1907
        self.assertEqual(
1908
1908
            [c],
1909
1909
            list(b.itersiblings(tag='c')))
1910
 
        self.assertEquals(
 
1910
        self.assertEqual(
1911
1911
            [c],
1912
1912
            list(b.itersiblings(tag='*')))
1913
 
        self.assertEquals(
 
1913
        self.assertEqual(
1914
1914
            [b],
1915
1915
            list(c.itersiblings(preceding=True, tag='b')))
1916
 
        self.assertEquals(
 
1916
        self.assertEqual(
1917
1917
            [],
1918
1918
            list(c.itersiblings(preceding=True, tag='c')))
1919
1919
 
1926
1926
        c = SubElement(a, 'c')
1927
1927
        d = SubElement(b, 'd')
1928
1928
        e = SubElement(a, 'e')
1929
 
        self.assertEquals(
 
1929
        self.assertEqual(
1930
1930
            [],
1931
1931
            list(a.itersiblings(tag=('XXX', 'YYY'))))
1932
 
        self.assertEquals(
 
1932
        self.assertEqual(
1933
1933
            [c, e],
1934
1934
            list(b.itersiblings(tag=('c', 'd', 'e'))))
1935
 
        self.assertEquals(
 
1935
        self.assertEqual(
1936
1936
            [b],
1937
1937
            list(c.itersiblings(preceding=True, tag=('b', 'b', 'c', 'd'))))
1938
 
        self.assertEquals(
 
1938
        self.assertEqual(
1939
1939
            [c, b],
1940
1940
            list(e.itersiblings(preceding=True, tag=('c', '*'))))
1941
1941
 
1962
1962
        tree, dic = parseid(BytesIO(xml_text))
1963
1963
        root = tree.getroot()
1964
1964
        root2 = XML(xml_text)
1965
 
        self.assertEquals(self._writeElement(root),
 
1965
        self.assertEqual(self._writeElement(root),
1966
1966
                          self._writeElement(root2))
1967
1967
        expected = {
1968
1968
            "chapter1" : root[0],
1969
1969
            "xmlid"    : root[3],
1970
1970
            "warn1"    : root[4]
1971
1971
            }
1972
 
        self.assert_("chapter1" in dic)
1973
 
        self.assert_("warn1" in dic)
1974
 
        self.assert_("xmlid" in dic)
 
1972
        self.assertTrue("chapter1" in dic)
 
1973
        self.assertTrue("warn1" in dic)
 
1974
        self.assertTrue("xmlid" in dic)
1975
1975
        self._checkIDDict(dic, expected)
1976
1976
 
1977
1977
    def test_XMLDTDID(self):
1996
1996
 
1997
1997
        root, dic = XMLDTDID(xml_text)
1998
1998
        root2 = XML(xml_text)
1999
 
        self.assertEquals(self._writeElement(root),
 
1999
        self.assertEqual(self._writeElement(root),
2000
2000
                          self._writeElement(root2))
2001
2001
        expected = {
2002
2002
            "chapter1" : root[0],
2003
2003
            "xmlid"    : root[3],
2004
2004
            "warn1"    : root[4]
2005
2005
            }
2006
 
        self.assert_("chapter1" in dic)
2007
 
        self.assert_("warn1" in dic)
2008
 
        self.assert_("xmlid" in dic)
 
2006
        self.assertTrue("chapter1" in dic)
 
2007
        self.assertTrue("warn1" in dic)
 
2008
        self.assertTrue("xmlid" in dic)
2009
2009
        self._checkIDDict(dic, expected)
2010
2010
 
2011
2011
    def test_XMLDTDID_empty(self):
2022
2022
 
2023
2023
        root, dic = XMLDTDID(xml_text)
2024
2024
        root2 = XML(xml_text)
2025
 
        self.assertEquals(self._writeElement(root),
 
2025
        self.assertEqual(self._writeElement(root),
2026
2026
                          self._writeElement(root2))
2027
2027
        expected = {}
2028
2028
        self._checkIDDict(dic, expected)
2029
2029
 
2030
2030
    def _checkIDDict(self, dic, expected):
2031
 
        self.assertEquals(len(dic),
 
2031
        self.assertEqual(len(dic),
2032
2032
                          len(expected))
2033
 
        self.assertEquals(sorted(dic.items()),
 
2033
        self.assertEqual(sorted(dic.items()),
2034
2034
                          sorted(expected.items()))
2035
2035
        if sys.version_info < (3,):
2036
 
            self.assertEquals(sorted(dic.iteritems()),
 
2036
            self.assertEqual(sorted(dic.iteritems()),
2037
2037
                              sorted(expected.iteritems()))
2038
 
        self.assertEquals(sorted(dic.keys()),
 
2038
        self.assertEqual(sorted(dic.keys()),
2039
2039
                          sorted(expected.keys()))
2040
2040
        if sys.version_info < (3,):
2041
 
            self.assertEquals(sorted(dic.iterkeys()),
 
2041
            self.assertEqual(sorted(dic.iterkeys()),
2042
2042
                              sorted(expected.iterkeys()))
2043
2043
        if sys.version_info < (3,):
2044
 
            self.assertEquals(sorted(dic.values()),
 
2044
            self.assertEqual(sorted(dic.values()),
2045
2045
                              sorted(expected.values()))
2046
 
            self.assertEquals(sorted(dic.itervalues()),
 
2046
            self.assertEqual(sorted(dic.itervalues()),
2047
2047
                              sorted(expected.itervalues()))
2048
2048
 
2049
2049
    def test_namespaces(self):
2051
2051
 
2052
2052
        r = {'foo': 'http://ns.infrae.com/foo'}
2053
2053
        e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
2054
 
        self.assertEquals(
 
2054
        self.assertEqual(
2055
2055
            'foo',
2056
2056
            e.prefix)
2057
 
        self.assertEquals(
 
2057
        self.assertEqual(
2058
2058
            _bytes('<foo:bar xmlns:foo="http://ns.infrae.com/foo"></foo:bar>'),
2059
2059
            self._writeElement(e))
2060
2060
        
2063
2063
 
2064
2064
        r = {None: 'http://ns.infrae.com/foo'}
2065
2065
        e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
2066
 
        self.assertEquals(
 
2066
        self.assertEqual(
2067
2067
            None,
2068
2068
            e.prefix)
2069
 
        self.assertEquals(
 
2069
        self.assertEqual(
2070
2070
            '{http://ns.infrae.com/foo}bar',
2071
2071
            e.tag)
2072
 
        self.assertEquals(
 
2072
        self.assertEqual(
2073
2073
            _bytes('<bar xmlns="http://ns.infrae.com/foo"></bar>'),
2074
2074
            self._writeElement(e))
2075
2075
 
2080
2080
             'hoi': 'http://ns.infrae.com/hoi'}
2081
2081
        e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
2082
2082
        e.set('{http://ns.infrae.com/hoi}test', 'value')
2083
 
        self.assertEquals(
 
2083
        self.assertEqual(
2084
2084
            _bytes('<bar xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi" hoi:test="value"></bar>'),
2085
2085
            self._writeElement(e))
2086
2086
 
2091
2091
        e = etree.Element('{http://ns.infrae.com/foo}z', nsmap=r)
2092
2092
        tree = etree.ElementTree(element=e)
2093
2093
        etree.SubElement(e, '{http://ns.infrae.com/hoi}x')
2094
 
        self.assertEquals(
 
2094
        self.assertEqual(
2095
2095
            _bytes('<z xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi"><hoi:x></hoi:x></z>'),
2096
2096
            self._writeElement(e))
2097
2097
 
2104
2104
 
2105
2105
        e1.append(e2)
2106
2106
 
2107
 
        self.assertEquals(
 
2107
        self.assertEqual(
2108
2108
            None,
2109
2109
            e1.prefix)
2110
 
        self.assertEquals(
 
2110
        self.assertEqual(
2111
2111
            None,
2112
2112
            e1[0].prefix)
2113
 
        self.assertEquals(
 
2113
        self.assertEqual(
2114
2114
            '{http://ns.infrae.com/foo}bar',
2115
2115
            e1.tag)
2116
 
        self.assertEquals(
 
2116
        self.assertEqual(
2117
2117
            '{http://ns.infrae.com/foo}bar',
2118
2118
            e1[0].tag)
2119
2119
 
2126
2126
 
2127
2127
        e1.append(e2)
2128
2128
 
2129
 
        self.assertEquals(
 
2129
        self.assertEqual(
2130
2130
            None,
2131
2131
            e1.prefix)
2132
 
        self.assertNotEquals(
 
2132
        self.assertNotEqual(
2133
2133
            None,
2134
2134
            e2.prefix)
2135
 
        self.assertEquals(
 
2135
        self.assertEqual(
2136
2136
            '{http://ns.infrae.com/BAR}bar',
2137
2137
            e1.tag)
2138
 
        self.assertEquals(
 
2138
        self.assertEqual(
2139
2139
            '{http://ns.infrae.com/foo}bar',
2140
2140
            e2.tag)
2141
2141
 
2150
2150
        two.append(baz)
2151
2151
        del one # make sure the source document is deallocated
2152
2152
 
2153
 
        self.assertEquals('{%s}baz' % ns_href, baz.tag)
2154
 
        self.assertEquals(
 
2153
        self.assertEqual('{%s}baz' % ns_href, baz.tag)
 
2154
        self.assertEqual(
2155
2155
            _bytes('<root xmlns:ns="%s"><ns:baz/></root>' % ns_href),
2156
2156
            self.etree.tostring(two))
2157
2157
 
2158
2158
    def test_namespace_cleanup(self):
2159
2159
        xml = _bytes('<foo xmlns="F" xmlns:x="x"><bar xmlns:ns="NS" xmlns:b="b" xmlns="B"><ns:baz/></bar></foo>')
2160
2160
        root = self.etree.fromstring(xml)
2161
 
        self.assertEquals(xml,
 
2161
        self.assertEqual(xml,
2162
2162
                          self.etree.tostring(root))
2163
2163
        self.etree.cleanup_namespaces(root)
2164
 
        self.assertEquals(
 
2164
        self.assertEqual(
2165
2165
            _bytes('<foo xmlns="F"><bar xmlns:ns="NS" xmlns="B"><ns:baz/></bar></foo>'),
2166
2166
            self.etree.tostring(root))
2167
2167
 
2171
2171
        r = {None: 'http://ns.infrae.com/foo',
2172
2172
             'hoi': 'http://ns.infrae.com/hoi'}
2173
2173
        e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
2174
 
        self.assertEquals(
 
2174
        self.assertEqual(
2175
2175
            r,
2176
2176
            e.nsmap)
2177
2177
 
2188
2188
 
2189
2189
        r = re.copy()
2190
2190
        r.update(rs)
2191
 
        self.assertEquals(re, e.nsmap)
2192
 
        self.assertEquals(r,  s.nsmap)
 
2191
        self.assertEqual(re, e.nsmap)
 
2192
        self.assertEqual(r,  s.nsmap)
2193
2193
 
2194
2194
    def test_html_prefix_nsmap(self):
2195
2195
        etree = self.etree
2196
2196
        el = etree.HTML('<hha:page-description>aa</hha:page-description>').find('.//page-description')
2197
 
        self.assertEquals({'hha': None}, el.nsmap)
 
2197
        self.assertEqual({'hha': None}, el.nsmap)
2198
2198
 
2199
2199
    def test_getiterator_filter_multiple(self):
2200
2200
        Element = self.etree.Element
2207
2207
        e = SubElement(c, 'e')
2208
2208
        f = SubElement(c, 'f')
2209
2209
 
2210
 
        self.assertEquals(
 
2210
        self.assertEqual(
2211
2211
            [a, b],
2212
2212
               list(a.getiterator('a', 'b')))
2213
 
        self.assertEquals(
 
2213
        self.assertEqual(
2214
2214
            [],
2215
2215
              list(a.getiterator('x', 'y')))
2216
 
        self.assertEquals(
 
2216
        self.assertEqual(
2217
2217
            [a, f],
2218
2218
              list(a.getiterator('f', 'a')))
2219
 
        self.assertEquals(
 
2219
        self.assertEqual(
2220
2220
            [c, e, f],
2221
2221
               list(c.getiterator('c', '*', 'a')))
2222
 
        self.assertEquals(
 
2222
        self.assertEqual(
2223
2223
            [],
2224
2224
                  list(a.getiterator( (), () )))
2225
2225
 
2234
2234
        e = SubElement(c, 'e')
2235
2235
        f = SubElement(c, 'f')
2236
2236
 
2237
 
        self.assertEquals(
 
2237
        self.assertEqual(
2238
2238
            [a, b],
2239
2239
                  list(a.getiterator( ('a', 'b') )))
2240
 
        self.assertEquals(
 
2240
        self.assertEqual(
2241
2241
            [],
2242
2242
              list(a.getiterator( ('x', 'y') )))
2243
 
        self.assertEquals(
 
2243
        self.assertEqual(
2244
2244
            [a, f],
2245
2245
                  list(a.getiterator( ('f', 'a') )))
2246
 
        self.assertEquals(
 
2246
        self.assertEqual(
2247
2247
            [c, e, f],
2248
2248
                     list(c.getiterator( ('c', '*', 'a') )))
2249
 
        self.assertEquals(
 
2249
        self.assertEqual(
2250
2250
            [],
2251
2251
              list(a.getiterator( () )))
2252
2252
 
2262
2262
        f = SubElement(c, '{b}f')
2263
2263
        g = SubElement(c, 'g')
2264
2264
 
2265
 
        self.assertEquals(
 
2265
        self.assertEqual(
2266
2266
            [a],
2267
2267
            list(a.getiterator('{a}a')))
2268
 
        self.assertEquals(
 
2268
        self.assertEqual(
2269
2269
            [],
2270
2270
            list(a.getiterator('{b}a')))
2271
 
        self.assertEquals(
 
2271
        self.assertEqual(
2272
2272
            [],
2273
2273
            list(a.getiterator('a')))
2274
 
        self.assertEquals(
 
2274
        self.assertEqual(
2275
2275
            [a,b,d,c,e,f,g],
2276
2276
            list(a.getiterator('*')))
2277
 
        self.assertEquals(
 
2277
        self.assertEqual(
2278
2278
            [f],
2279
2279
            list(c.getiterator('{b}*')))
2280
 
        self.assertEquals(
 
2280
        self.assertEqual(
2281
2281
            [d, f],
2282
2282
            list(a.getiterator('{b}*')))
2283
 
        self.assertEquals(
 
2283
        self.assertEqual(
2284
2284
            [g],
2285
2285
            list(a.getiterator('g')))
2286
 
        self.assertEquals(
 
2286
        self.assertEqual(
2287
2287
            [g],
2288
2288
            list(a.getiterator('{}g')))
2289
 
        self.assertEquals(
 
2289
        self.assertEqual(
2290
2290
            [g],
2291
2291
            list(a.getiterator('{}*')))
2292
2292
 
2302
2302
        f = SubElement(e, '{nsB}e')
2303
2303
        g = SubElement(e, 'e')
2304
2304
 
2305
 
        self.assertEquals(
 
2305
        self.assertEqual(
2306
2306
            [b, c, d],
2307
2307
            list(a.getiterator('{*}b')))
2308
 
        self.assertEquals(
 
2308
        self.assertEqual(
2309
2309
            [e, f, g],
2310
2310
            list(a.getiterator('{*}e')))
2311
 
        self.assertEquals(
 
2311
        self.assertEqual(
2312
2312
            [a, b, c, d, e, f, g],
2313
2313
            list(a.getiterator('{*}*')))
2314
2314
 
2322
2322
        entity_b = Entity("TEST-b")
2323
2323
        b.append(entity_b)
2324
2324
 
2325
 
        self.assertEquals(
 
2325
        self.assertEqual(
2326
2326
            [entity_b],
2327
2327
            list(a.getiterator(Entity)))
2328
2328
 
2329
2329
        entity_a = Entity("TEST-a")
2330
2330
        a.append(entity_a)
2331
2331
 
2332
 
        self.assertEquals(
 
2332
        self.assertEqual(
2333
2333
            [entity_b, entity_a],
2334
2334
            list(a.getiterator(Entity)))
2335
2335
 
2336
 
        self.assertEquals(
 
2336
        self.assertEqual(
2337
2337
            [entity_b],
2338
2338
            list(b.getiterator(Entity)))
2339
2339
 
2349
2349
        a.append(PI("pi", "content"))
2350
2350
        c = SubElement(a, 'c')
2351
2351
 
2352
 
        self.assertEquals(
 
2352
        self.assertEqual(
2353
2353
            [a, b, c],
2354
2354
            list(a.getiterator(Element)))
2355
2355
 
2366
2366
        a.append(PI("pi", "content"))
2367
2367
        c = SubElement(a, 'c')
2368
2368
 
2369
 
        self.assertEquals(
 
2369
        self.assertEqual(
2370
2370
            [a, b, c],
2371
2371
            list(a.getiterator('*')))
2372
2372
 
2375
2375
        ElementTree = self.etree.ElementTree
2376
2376
        QName = self.etree.QName
2377
2377
        tree = ElementTree(XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>')))
2378
 
        self.assertEquals(tree.find(QName("c")), tree.getroot()[2])
 
2378
        self.assertEqual(tree.find(QName("c")), tree.getroot()[2])
2379
2379
 
2380
2380
    def test_elementtree_findall_qname(self):
2381
2381
        XML = self.etree.XML
2382
2382
        ElementTree = self.etree.ElementTree
2383
2383
        QName = self.etree.QName
2384
2384
        tree = ElementTree(XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>')))
2385
 
        self.assertEquals(len(list(tree.findall(QName("c")))), 1)
 
2385
        self.assertEqual(len(list(tree.findall(QName("c")))), 1)
2386
2386
 
2387
2387
    def test_elementtree_findall_ns_qname(self):
2388
2388
        XML = self.etree.XML
2390
2390
        QName = self.etree.QName
2391
2391
        tree = ElementTree(XML(
2392
2392
                _bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')))
2393
 
        self.assertEquals(len(list(tree.findall(QName("b")))), 2)
2394
 
        self.assertEquals(len(list(tree.findall(QName("X", "b")))), 1)
 
2393
        self.assertEqual(len(list(tree.findall(QName("b")))), 2)
 
2394
        self.assertEqual(len(list(tree.findall(QName("X", "b")))), 1)
2395
2395
 
2396
2396
    def test_findall_ns(self):
2397
2397
        XML = self.etree.XML
2398
2398
        root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>'))
2399
 
        self.assertEquals(len(root.findall(".//{X}b")), 2)
2400
 
        self.assertEquals(len(root.findall(".//{X}*")), 2)
2401
 
        self.assertEquals(len(root.findall(".//b")), 3)
 
2399
        self.assertEqual(len(root.findall(".//{X}b")), 2)
 
2400
        self.assertEqual(len(root.findall(".//{X}*")), 2)
 
2401
        self.assertEqual(len(root.findall(".//b")), 3)
2402
2402
 
2403
2403
    def test_findall_syntax_error(self):
2404
2404
        XML = self.etree.XML
2413
2413
        for i in range(10):
2414
2414
            etree.SubElement(e, 'a%s' % i)
2415
2415
        for i in range(10):
2416
 
            self.assertEquals(
 
2416
            self.assertEqual(
2417
2417
                i,
2418
2418
                e.index(e[i]))
2419
 
        self.assertEquals(
 
2419
        self.assertEqual(
2420
2420
            3, e.index(e[3], 3))
2421
2421
        self.assertRaises(
2422
2422
            ValueError, e.index, e[3], 4)
2426
2426
            ValueError, e.index, e[8], 0, -3)
2427
2427
        self.assertRaises(
2428
2428
            ValueError, e.index, e[8], -5, -3)
2429
 
        self.assertEquals(
 
2429
        self.assertEqual(
2430
2430
            8, e.index(e[8], 0, -1))
2431
 
        self.assertEquals(
 
2431
        self.assertEqual(
2432
2432
            8, e.index(e[8], -12, -1))
2433
 
        self.assertEquals(
 
2433
        self.assertEqual(
2434
2434
            0, e.index(e[0], -12, -1))
2435
2435
 
2436
2436
    def test_replace(self):
2446
2446
        child2 = e[2]
2447
2447
 
2448
2448
        e.replace(e[0], e[1])
2449
 
        self.assertEquals(
 
2449
        self.assertEqual(
2450
2450
            9, len(e))
2451
 
        self.assertEquals(
 
2451
        self.assertEqual(
2452
2452
            child1, e[0])
2453
 
        self.assertEquals(
 
2453
        self.assertEqual(
2454
2454
            child1.text, "text1")
2455
 
        self.assertEquals(
 
2455
        self.assertEqual(
2456
2456
            child1.tail, "tail1")
2457
 
        self.assertEquals(
 
2457
        self.assertEqual(
2458
2458
            child0.tail, "tail0")
2459
 
        self.assertEquals(
 
2459
        self.assertEqual(
2460
2460
            child2, e[1])
2461
2461
 
2462
2462
        e.replace(e[-1], e[0])
2463
 
        self.assertEquals(
 
2463
        self.assertEqual(
2464
2464
            child1, e[-1])
2465
 
        self.assertEquals(
 
2465
        self.assertEqual(
2466
2466
            child1.text, "text1")
2467
 
        self.assertEquals(
 
2467
        self.assertEqual(
2468
2468
            child1.tail, "tail1")
2469
 
        self.assertEquals(
 
2469
        self.assertEqual(
2470
2470
            child2, e[0])
2471
2471
 
2472
2472
    def test_replace_new(self):
2480
2480
        new_element.tail = "TESTTAIL"
2481
2481
        child1 = e[1]
2482
2482
        e.replace(e[0], new_element)
2483
 
        self.assertEquals(
 
2483
        self.assertEqual(
2484
2484
            new_element, e[0])
2485
 
        self.assertEquals(
 
2485
        self.assertEqual(
2486
2486
            "TESTTEXT",
2487
2487
            e[0].text)
2488
 
        self.assertEquals(
 
2488
        self.assertEqual(
2489
2489
            "TESTTAIL",
2490
2490
            e[0].tail)
2491
 
        self.assertEquals(
 
2491
        self.assertEqual(
2492
2492
            child1, e[1])
2493
2493
 
2494
2494
    def test_setslice_all_empty_reversed(self):
2503
2503
 
2504
2504
        s = [e, f, g]
2505
2505
        a[::-1] = s
2506
 
        self.assertEquals(
 
2506
        self.assertEqual(
2507
2507
            [g, f, e],
2508
2508
            list(a))
2509
2509
 
2521
2521
        y = Element('y')
2522
2522
 
2523
2523
        a[1::2] = [x, y]
2524
 
        self.assertEquals(
 
2524
        self.assertEqual(
2525
2525
            [b, x, d, y],
2526
2526
            list(a))
2527
2527
 
2539
2539
        y = Element('y')
2540
2540
 
2541
2541
        a[1::-1] = [x, y]
2542
 
        self.assertEquals(
 
2542
        self.assertEqual(
2543
2543
            [y, x, d, e],
2544
2544
            list(a))
2545
2545
 
2557
2557
        y = Element('y')
2558
2558
 
2559
2559
        a[::-2] = [x, y]
2560
 
        self.assertEquals(
 
2560
        self.assertEqual(
2561
2561
            [b, y, d, x],
2562
2562
            list(a))
2563
2563
 
2584
2584
            ValueError,
2585
2585
            operator.setitem, a, slice(1,None,2), [x, y, z])
2586
2586
 
2587
 
        self.assertEquals(
 
2587
        self.assertEqual(
2588
2588
            [b, c, d, e],
2589
2589
            list(a))
2590
2590
 
2597
2597
        </root>
2598
2598
        '''))
2599
2599
 
2600
 
        self.assertEquals(
 
2600
        self.assertEqual(
2601
2601
            [2, 2, 4],
2602
2602
            [ el.sourceline for el in root.getiterator() ])
2603
2603
 
2605
2605
        parse = self.etree.parse
2606
2606
        tree = parse(fileInTestDir('include/test_xinclude.xml'))
2607
2607
 
2608
 
        self.assertEquals(
 
2608
        self.assertEqual(
2609
2609
            [1, 2, 3],
2610
2610
            [ el.sourceline for el in tree.getiterator() ])
2611
2611
 
2614
2614
        lines = [ el.sourceline for (event, el) in 
2615
2615
                  iterparse(fileInTestDir('include/test_xinclude.xml')) ]
2616
2616
 
2617
 
        self.assertEquals(
 
2617
        self.assertEqual(
2618
2618
            [2, 3, 1],
2619
2619
            lines)
2620
2620
 
2624
2624
                  iterparse(fileInTestDir('include/test_xinclude.xml'),
2625
2625
                            events=("start",)) ]
2626
2626
 
2627
 
        self.assertEquals(
 
2627
        self.assertEqual(
2628
2628
            [1, 2, 3],
2629
2629
            lines)
2630
2630
 
2632
2632
        Element = self.etree.Element
2633
2633
        SubElement = self.etree.SubElement
2634
2634
        el = Element("test")
2635
 
        self.assertEquals(None, el.sourceline)
 
2635
        self.assertEqual(None, el.sourceline)
2636
2636
 
2637
2637
        child = SubElement(el, "test")
2638
 
        self.assertEquals(None, el.sourceline)
2639
 
        self.assertEquals(None, child.sourceline)
 
2638
        self.assertEqual(None, el.sourceline)
 
2639
        self.assertEqual(None, child.sourceline)
2640
2640
 
2641
2641
    def test_XML_base_url_docinfo(self):
2642
2642
        etree = self.etree
2643
2643
        root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2644
2644
        docinfo = root.getroottree().docinfo
2645
 
        self.assertEquals(docinfo.URL, "http://no/such/url")
 
2645
        self.assertEqual(docinfo.URL, "http://no/such/url")
2646
2646
 
2647
2647
    def test_XML_set_base_url_docinfo(self):
2648
2648
        etree = self.etree
2649
2649
        root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2650
2650
        docinfo = root.getroottree().docinfo
2651
 
        self.assertEquals(docinfo.URL, "http://no/such/url")
 
2651
        self.assertEqual(docinfo.URL, "http://no/such/url")
2652
2652
        docinfo.URL = "https://secret/url"
2653
 
        self.assertEquals(docinfo.URL, "https://secret/url")
 
2653
        self.assertEqual(docinfo.URL, "https://secret/url")
2654
2654
 
2655
2655
    def test_parse_stringio_base_url(self):
2656
2656
        etree = self.etree
2657
2657
        tree = etree.parse(BytesIO("<root/>"), base_url="http://no/such/url")
2658
2658
        docinfo = tree.docinfo
2659
 
        self.assertEquals(docinfo.URL, "http://no/such/url")
 
2659
        self.assertEqual(docinfo.URL, "http://no/such/url")
2660
2660
 
2661
2661
    def test_parse_base_url_docinfo(self):
2662
2662
        etree = self.etree
2663
2663
        tree = etree.parse(fileInTestDir('include/test_xinclude.xml'),
2664
2664
                           base_url="http://no/such/url")
2665
2665
        docinfo = tree.docinfo
2666
 
        self.assertEquals(docinfo.URL, "http://no/such/url")
 
2666
        self.assertEqual(docinfo.URL, "http://no/such/url")
2667
2667
 
2668
2668
    def test_HTML_base_url_docinfo(self):
2669
2669
        etree = self.etree
2670
2670
        root = etree.HTML(_bytes("<html/>"), base_url="http://no/such/url")
2671
2671
        docinfo = root.getroottree().docinfo
2672
 
        self.assertEquals(docinfo.URL, "http://no/such/url")
 
2672
        self.assertEqual(docinfo.URL, "http://no/such/url")
2673
2673
 
2674
2674
    def test_docinfo_public(self):
2675
2675
        etree = self.etree
2682
2682
 
2683
2683
        tree = etree.parse(BytesIO(xml))
2684
2684
        docinfo = tree.docinfo
2685
 
        self.assertEquals(docinfo.encoding,    "ascii")
2686
 
        self.assertEquals(docinfo.xml_version, "1.0")
2687
 
        self.assertEquals(docinfo.public_id,   pub_id)
2688
 
        self.assertEquals(docinfo.system_url,  sys_id)
2689
 
        self.assertEquals(docinfo.root_name,   'html')
2690
 
        self.assertEquals(docinfo.doctype, doctype_string)
 
2685
        self.assertEqual(docinfo.encoding,    "ascii")
 
2686
        self.assertEqual(docinfo.xml_version, "1.0")
 
2687
        self.assertEqual(docinfo.public_id,   pub_id)
 
2688
        self.assertEqual(docinfo.system_url,  sys_id)
 
2689
        self.assertEqual(docinfo.root_name,   'html')
 
2690
        self.assertEqual(docinfo.doctype, doctype_string)
2691
2691
 
2692
2692
    def test_docinfo_system(self):
2693
2693
        etree = self.etree
2698
2698
 
2699
2699
        tree = etree.parse(BytesIO(xml))
2700
2700
        docinfo = tree.docinfo
2701
 
        self.assertEquals(docinfo.encoding,    "UTF-8")
2702
 
        self.assertEquals(docinfo.xml_version, "1.0")
2703
 
        self.assertEquals(docinfo.public_id,   None)
2704
 
        self.assertEquals(docinfo.system_url,  sys_id)
2705
 
        self.assertEquals(docinfo.root_name,   'html')
2706
 
        self.assertEquals(docinfo.doctype, doctype_string)
 
2701
        self.assertEqual(docinfo.encoding,    "UTF-8")
 
2702
        self.assertEqual(docinfo.xml_version, "1.0")
 
2703
        self.assertEqual(docinfo.public_id,   None)
 
2704
        self.assertEqual(docinfo.system_url,  sys_id)
 
2705
        self.assertEqual(docinfo.root_name,   'html')
 
2706
        self.assertEqual(docinfo.doctype, doctype_string)
2707
2707
 
2708
2708
    def test_docinfo_empty(self):
2709
2709
        etree = self.etree
2710
2710
        xml = _bytes('<html><body></body></html>')
2711
2711
        tree = etree.parse(BytesIO(xml))
2712
2712
        docinfo = tree.docinfo
2713
 
        self.assertEquals(docinfo.encoding,    "UTF-8")
2714
 
        self.assertEquals(docinfo.xml_version, "1.0")
2715
 
        self.assertEquals(docinfo.public_id,   None)
2716
 
        self.assertEquals(docinfo.system_url,  None)
2717
 
        self.assertEquals(docinfo.root_name,   'html')
2718
 
        self.assertEquals(docinfo.doctype, '')
 
2713
        self.assertEqual(docinfo.encoding,    "UTF-8")
 
2714
        self.assertEqual(docinfo.xml_version, "1.0")
 
2715
        self.assertEqual(docinfo.public_id,   None)
 
2716
        self.assertEqual(docinfo.system_url,  None)
 
2717
        self.assertEqual(docinfo.root_name,   'html')
 
2718
        self.assertEqual(docinfo.doctype, '')
2719
2719
 
2720
2720
    def test_docinfo_name_only(self):
2721
2721
        etree = self.etree
2722
2722
        xml = _bytes('<!DOCTYPE root><root></root>')
2723
2723
        tree = etree.parse(BytesIO(xml))
2724
2724
        docinfo = tree.docinfo
2725
 
        self.assertEquals(docinfo.encoding,    "UTF-8")
2726
 
        self.assertEquals(docinfo.xml_version, "1.0")
2727
 
        self.assertEquals(docinfo.public_id,   None)
2728
 
        self.assertEquals(docinfo.system_url,  None)
2729
 
        self.assertEquals(docinfo.root_name,   'root')
2730
 
        self.assertEquals(docinfo.doctype, '<!DOCTYPE root>')
 
2725
        self.assertEqual(docinfo.encoding,    "UTF-8")
 
2726
        self.assertEqual(docinfo.xml_version, "1.0")
 
2727
        self.assertEqual(docinfo.public_id,   None)
 
2728
        self.assertEqual(docinfo.system_url,  None)
 
2729
        self.assertEqual(docinfo.root_name,   'root')
 
2730
        self.assertEqual(docinfo.doctype, '<!DOCTYPE root>')
2731
2731
 
2732
2732
    def test_doctype_name_only_roundtrip(self):
2733
2733
        etree = self.etree
2734
2734
        xml = _bytes('<!DOCTYPE root>\n<root/>')
2735
2735
        tree = etree.parse(BytesIO(xml))
2736
 
        self.assertEquals(xml, etree.tostring(tree))
 
2736
        self.assertEqual(xml, etree.tostring(tree))
2737
2737
 
2738
2738
    def test_doctype_output_override(self):
2739
2739
        etree = self.etree
2743
2743
 
2744
2744
        xml = _bytes('<!DOCTYPE root>\n<root/>')
2745
2745
        tree = etree.parse(BytesIO(xml))
2746
 
        self.assertEquals(xml.replace(_bytes('<!DOCTYPE root>'), doctype_string),
 
2746
        self.assertEqual(xml.replace(_bytes('<!DOCTYPE root>'), doctype_string),
2747
2747
                          etree.tostring(tree, doctype=doctype_string))
2748
2748
 
2749
2749
    def test_xml_base(self):
2750
2750
        etree = self.etree
2751
2751
        root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2752
 
        self.assertEquals(root.base, "http://no/such/url")
2753
 
        self.assertEquals(
 
2752
        self.assertEqual(root.base, "http://no/such/url")
 
2753
        self.assertEqual(
2754
2754
            root.get('{http://www.w3.org/XML/1998/namespace}base'), None)
2755
2755
        root.base = "https://secret/url"
2756
 
        self.assertEquals(root.base, "https://secret/url")
2757
 
        self.assertEquals(
 
2756
        self.assertEqual(root.base, "https://secret/url")
 
2757
        self.assertEqual(
2758
2758
            root.get('{http://www.w3.org/XML/1998/namespace}base'),
2759
2759
            "https://secret/url")
2760
2760
 
2761
2761
    def test_xml_base_attribute(self):
2762
2762
        etree = self.etree
2763
2763
        root = etree.XML(_bytes("<root/>"), base_url="http://no/such/url")
2764
 
        self.assertEquals(root.base, "http://no/such/url")
2765
 
        self.assertEquals(
 
2764
        self.assertEqual(root.base, "http://no/such/url")
 
2765
        self.assertEqual(
2766
2766
            root.get('{http://www.w3.org/XML/1998/namespace}base'), None)
2767
2767
        root.set('{http://www.w3.org/XML/1998/namespace}base',
2768
2768
                 "https://secret/url")
2769
 
        self.assertEquals(root.base, "https://secret/url")
2770
 
        self.assertEquals(
 
2769
        self.assertEqual(root.base, "https://secret/url")
 
2770
        self.assertEqual(
2771
2771
            root.get('{http://www.w3.org/XML/1998/namespace}base'),
2772
2772
            "https://secret/url")
2773
2773
 
2775
2775
        etree = self.etree
2776
2776
        root = etree.HTML(_bytes("<html><body></body></html>"),
2777
2777
                          base_url="http://no/such/url")
2778
 
        self.assertEquals(root.base, "http://no/such/url")
 
2778
        self.assertEqual(root.base, "http://no/such/url")
2779
2779
 
2780
2780
    def test_html_base_tag(self):
2781
2781
        etree = self.etree
2782
2782
        root = etree.HTML(_bytes('<html><head><base href="http://no/such/url"></head></html>'))
2783
 
        self.assertEquals(root.base, "http://no/such/url")
 
2783
        self.assertEqual(root.base, "http://no/such/url")
2784
2784
 
2785
2785
    def test_parse_fileobject_unicode(self):
2786
2786
        # parse from a file object that returns unicode strings
2787
2787
        f = LargeFileLikeUnicode()
2788
2788
        tree = self.etree.parse(f)
2789
2789
        root = tree.getroot()
2790
 
        self.assert_(root.tag.endswith('root'))
 
2790
        self.assertTrue(root.tag.endswith('root'))
2791
2791
 
2792
2792
    def test_dtd_io(self):
2793
2793
        # check that DTDs that go in also go back out
2886
2886
        c = SubElement(a, 'c')
2887
2887
 
2888
2888
        result = tostring(a, encoding='UTF-16')
2889
 
        self.assertEquals(_bytes('<a><b></b><c></c></a>'),
 
2889
        self.assertEqual(_bytes('<a><b></b><c></c></a>'),
2890
2890
                          canonicalize(result))
2891
2891
 
2892
2892
    def test_tostring_none(self):
2904
2904
        c = SubElement(a, 'c')
2905
2905
 
2906
2906
        result = tostring(a)
2907
 
        self.assertEquals(result, _bytes("<a><b/><c/></a>"))
 
2907
        self.assertEqual(result, _bytes("<a><b/><c/></a>"))
2908
2908
 
2909
2909
        result = tostring(a, pretty_print=False)
2910
 
        self.assertEquals(result, _bytes("<a><b/><c/></a>"))
 
2910
        self.assertEqual(result, _bytes("<a><b/><c/></a>"))
2911
2911
 
2912
2912
        result = tostring(a, pretty_print=True)
2913
 
        self.assertEquals(result, _bytes("<a>\n  <b/>\n  <c/>\n</a>\n"))
 
2913
        self.assertEqual(result, _bytes("<a>\n  <b/>\n  <c/>\n</a>\n"))
2914
2914
 
2915
2915
    def test_tostring_with_tail(self):
2916
2916
        tostring = self.etree.tostring
2924
2924
        c = SubElement(a, 'c')
2925
2925
 
2926
2926
        result = tostring(a)
2927
 
        self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>aTAIL"))
 
2927
        self.assertEqual(result, _bytes("<a><b/>bTAIL<c/></a>aTAIL"))
2928
2928
 
2929
2929
        result = tostring(a, with_tail=False)
2930
 
        self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>"))
 
2930
        self.assertEqual(result, _bytes("<a><b/>bTAIL<c/></a>"))
2931
2931
 
2932
2932
        result = tostring(a, with_tail=True)
2933
 
        self.assertEquals(result, _bytes("<a><b/>bTAIL<c/></a>aTAIL"))
 
2933
        self.assertEqual(result, _bytes("<a><b/>bTAIL<c/></a>aTAIL"))
2934
2934
 
2935
2935
    def test_standalone(self):
2936
2936
        tostring = self.etree.tostring
2939
2939
        Element = self.etree.Element
2940
2940
 
2941
2941
        tree = Element("root").getroottree()
2942
 
        self.assertEquals(None, tree.docinfo.standalone)
 
2942
        self.assertEqual(None, tree.docinfo.standalone)
2943
2943
 
2944
2944
        tree = XML(_bytes("<root/>")).getroottree()
2945
 
        self.assertEquals(None, tree.docinfo.standalone)
 
2945
        self.assertEqual(None, tree.docinfo.standalone)
2946
2946
 
2947
2947
        tree = XML(_bytes(
2948
2948
            "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>"
2949
2949
            )).getroottree()
2950
 
        self.assertEquals(True, tree.docinfo.standalone)
 
2950
        self.assertEqual(True, tree.docinfo.standalone)
2951
2951
 
2952
2952
        tree = XML(_bytes(
2953
2953
            "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>"
2954
2954
            )).getroottree()
2955
 
        self.assertEquals(False, tree.docinfo.standalone)
 
2955
        self.assertEqual(False, tree.docinfo.standalone)
2956
2956
 
2957
2957
    def test_tostring_standalone(self):
2958
2958
        tostring = self.etree.tostring
2962
2962
        root = XML(_bytes("<root/>"))
2963
2963
 
2964
2964
        tree = ElementTree(root)
2965
 
        self.assertEquals(None, tree.docinfo.standalone)
 
2965
        self.assertEqual(None, tree.docinfo.standalone)
2966
2966
 
2967
2967
        result = tostring(root, xml_declaration=True, encoding="ASCII")
2968
 
        self.assertEquals(result, _bytes(
 
2968
        self.assertEqual(result, _bytes(
2969
2969
            "<?xml version='1.0' encoding='ASCII'?>\n<root/>"))
2970
2970
 
2971
2971
        result = tostring(root, xml_declaration=True, encoding="ASCII",
2972
2972
                          standalone=True)
2973
 
        self.assertEquals(result, _bytes(
 
2973
        self.assertEqual(result, _bytes(
2974
2974
            "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>"))
2975
2975
 
2976
2976
        tree = ElementTree(XML(result))
2977
 
        self.assertEquals(True, tree.docinfo.standalone)
 
2977
        self.assertEqual(True, tree.docinfo.standalone)
2978
2978
 
2979
2979
        result = tostring(root, xml_declaration=True, encoding="ASCII",
2980
2980
                          standalone=False)
2981
 
        self.assertEquals(result, _bytes(
 
2981
        self.assertEqual(result, _bytes(
2982
2982
            "<?xml version='1.0' encoding='ASCII' standalone='no'?>\n<root/>"))
2983
2983
 
2984
2984
        tree = ElementTree(XML(result))
2985
 
        self.assertEquals(False, tree.docinfo.standalone)
 
2985
        self.assertEqual(False, tree.docinfo.standalone)
2986
2986
 
2987
2987
    def test_tostring_standalone_in_out(self):
2988
2988
        tostring = self.etree.tostring
2993
2993
            "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>\n<root/>"))
2994
2994
 
2995
2995
        tree = ElementTree(root)
2996
 
        self.assertEquals(True, tree.docinfo.standalone)
 
2996
        self.assertEqual(True, tree.docinfo.standalone)
2997
2997
 
2998
2998
        result = tostring(root, xml_declaration=True, encoding="ASCII")
2999
 
        self.assertEquals(result, _bytes(
 
2999
        self.assertEqual(result, _bytes(
3000
3000
            "<?xml version='1.0' encoding='ASCII'?>\n<root/>"))
3001
3001
 
3002
3002
        result = tostring(root, xml_declaration=True, encoding="ASCII",
3003
3003
                          standalone=True)
3004
 
        self.assertEquals(result, _bytes(
 
3004
        self.assertEqual(result, _bytes(
3005
3005
            "<?xml version='1.0' encoding='ASCII' standalone='yes'?>\n<root/>"))
3006
3006
 
3007
3007
    def test_tostring_method_text_encoding(self):
3020
3020
 
3021
3021
        result = tostring(a, method="text", encoding="UTF-16")
3022
3022
 
3023
 
        self.assertEquals(_str('ABSøk på nettetCtail').encode("UTF-16"),
 
3023
        self.assertEqual(_str('ABSøk på nettetCtail').encode("UTF-16"),
3024
3024
                          result)
3025
3025
 
3026
3026
    def test_tostring_method_text_unicode(self):
3040
3040
        self.assertRaises(UnicodeEncodeError,
3041
3041
                          tostring, a, method="text")
3042
3042
        
3043
 
        self.assertEquals(
 
3043
        self.assertEqual(
3044
3044
            _str('Søk på nettetABSøk på nettetBCtail').encode('utf-8'),
3045
3045
            tostring(a, encoding="UTF-8", method="text"))
3046
3046
 
3053
3053
        b = SubElement(a, 'b')
3054
3054
        c = SubElement(a, 'c')
3055
3055
        
3056
 
        self.assert_(isinstance(tounicode(a), _unicode))
3057
 
        self.assertEquals(_bytes('<a><b></b><c></c></a>'),
 
3056
        self.assertTrue(isinstance(tounicode(a), _unicode))
 
3057
        self.assertEqual(_bytes('<a><b></b><c></c></a>'),
3058
3058
                          canonicalize(tounicode(a)))
3059
3059
 
3060
3060
    def test_tounicode_element(self):
3066
3066
        b = SubElement(a, 'b')
3067
3067
        c = SubElement(a, 'c')
3068
3068
        d = SubElement(c, 'd')
3069
 
        self.assert_(isinstance(tounicode(b), _unicode))
3070
 
        self.assert_(isinstance(tounicode(c), _unicode))
3071
 
        self.assertEquals(_bytes('<b></b>'),
 
3069
        self.assertTrue(isinstance(tounicode(b), _unicode))
 
3070
        self.assertTrue(isinstance(tounicode(c), _unicode))
 
3071
        self.assertEqual(_bytes('<b></b>'),
3072
3072
                          canonicalize(tounicode(b)))
3073
 
        self.assertEquals(_bytes('<c><d></d></c>'),
 
3073
        self.assertEqual(_bytes('<c><d></d></c>'),
3074
3074
                          canonicalize(tounicode(c)))
3075
3075
 
3076
3076
    def test_tounicode_none(self):
3088
3088
        d = SubElement(c, 'd')
3089
3089
        b.tail = 'Foo'
3090
3090
 
3091
 
        self.assert_(isinstance(tounicode(b), _unicode))
3092
 
        self.assert_(tounicode(b) == '<b/>Foo' or
 
3091
        self.assertTrue(isinstance(tounicode(b), _unicode))
 
3092
        self.assertTrue(tounicode(b) == '<b/>Foo' or
3093
3093
                     tounicode(b) == '<b />Foo')
3094
3094
 
3095
3095
    def test_tounicode_pretty(self):
3102
3102
        c = SubElement(a, 'c')
3103
3103
 
3104
3104
        result = tounicode(a)
3105
 
        self.assertEquals(result, "<a><b/><c/></a>")
 
3105
        self.assertEqual(result, "<a><b/><c/></a>")
3106
3106
 
3107
3107
        result = tounicode(a, pretty_print=False)
3108
 
        self.assertEquals(result, "<a><b/><c/></a>")
 
3108
        self.assertEqual(result, "<a><b/><c/></a>")
3109
3109
 
3110
3110
        result = tounicode(a, pretty_print=True)
3111
 
        self.assertEquals(result, "<a>\n  <b/>\n  <c/>\n</a>\n")
 
3111
        self.assertEqual(result, "<a>\n  <b/>\n  <c/>\n</a>\n")
3112
3112
 
3113
3113
    def test_tostring_unicode(self):
3114
3114
        tostring = self.etree.tostring
3119
3119
        b = SubElement(a, 'b')
3120
3120
        c = SubElement(a, 'c')
3121
3121
        
3122
 
        self.assert_(isinstance(tostring(a, encoding=_unicode), _unicode))
3123
 
        self.assertEquals(_bytes('<a><b></b><c></c></a>'),
 
3122
        self.assertTrue(isinstance(tostring(a, encoding=_unicode), _unicode))
 
3123
        self.assertEqual(_bytes('<a><b></b><c></c></a>'),
3124
3124
                          canonicalize(tostring(a, encoding=_unicode)))
3125
3125
 
3126
3126
    def test_tostring_unicode_element(self):
3132
3132
        b = SubElement(a, 'b')
3133
3133
        c = SubElement(a, 'c')
3134
3134
        d = SubElement(c, 'd')
3135
 
        self.assert_(isinstance(tostring(b, encoding=_unicode), _unicode))
3136
 
        self.assert_(isinstance(tostring(c, encoding=_unicode), _unicode))
3137
 
        self.assertEquals(_bytes('<b></b>'),
 
3135
        self.assertTrue(isinstance(tostring(b, encoding=_unicode), _unicode))
 
3136
        self.assertTrue(isinstance(tostring(c, encoding=_unicode), _unicode))
 
3137
        self.assertEqual(_bytes('<b></b>'),
3138
3138
                          canonicalize(tostring(b, encoding=_unicode)))
3139
 
        self.assertEquals(_bytes('<c><d></d></c>'),
 
3139
        self.assertEqual(_bytes('<c><d></d></c>'),
3140
3140
                          canonicalize(tostring(c, encoding=_unicode)))
3141
3141
 
3142
3142
    def test_tostring_unicode_none(self):
3155
3155
        d = SubElement(c, 'd')
3156
3156
        b.tail = 'Foo'
3157
3157
 
3158
 
        self.assert_(isinstance(tostring(b, encoding=_unicode), _unicode))
3159
 
        self.assert_(tostring(b, encoding=_unicode) == '<b/>Foo' or
 
3158
        self.assertTrue(isinstance(tostring(b, encoding=_unicode), _unicode))
 
3159
        self.assertTrue(tostring(b, encoding=_unicode) == '<b/>Foo' or
3160
3160
                     tostring(b, encoding=_unicode) == '<b />Foo')
3161
3161
 
3162
3162
    def test_tostring_unicode_pretty(self):
3169
3169
        c = SubElement(a, 'c')
3170
3170
 
3171
3171
        result = tostring(a, encoding=_unicode)
3172
 
        self.assertEquals(result, "<a><b/><c/></a>")
 
3172
        self.assertEqual(result, "<a><b/><c/></a>")
3173
3173
 
3174
3174
        result = tostring(a, encoding=_unicode, pretty_print=False)
3175
 
        self.assertEquals(result, "<a><b/><c/></a>")
 
3175
        self.assertEqual(result, "<a><b/><c/></a>")
3176
3176
 
3177
3177
        result = tostring(a, encoding=_unicode, pretty_print=True)
3178
 
        self.assertEquals(result, "<a>\n  <b/>\n  <c/>\n</a>\n")
 
3178
        self.assertEqual(result, "<a>\n  <b/>\n  <c/>\n</a>\n")
3179
3179
 
3180
3180
    def test_pypy_proxy_collect(self):
3181
3181
        root = etree.Element('parent')
3182
3182
        etree.SubElement(root, 'child')
3183
3183
 
3184
 
        self.assertEquals(len(root), 1)
3185
 
        self.assertEquals(root[0].tag, 'child')
 
3184
        self.assertEqual(len(root), 1)
 
3185
        self.assertEqual(root[0].tag, 'child')
3186
3186
 
3187
3187
        # in PyPy, GC used to kill the Python proxy instance without cleanup
3188
3188
        gc.collect()
3189
 
        self.assertEquals(len(root), 1)
3190
 
        self.assertEquals(root[0].tag, 'child')
 
3189
        self.assertEqual(len(root), 1)
 
3190
        self.assertEqual(root[0].tag, 'child')
3191
3191
 
3192
3192
    # helper methods
3193
3193
 
3217
3217
        old_tail = root[0].tail
3218
3218
 
3219
3219
        self.include( etree.ElementTree(root) )
3220
 
        self.assertEquals(old_text + content + old_tail,
 
3220
        self.assertEqual(old_text + content + old_tail,
3221
3221
                          root.text)
3222
3222
 
3223
3223
    def test_xinclude(self):
3224
3224
        tree = etree.parse(fileInTestDir('include/test_xinclude.xml'))
3225
 
        self.assertNotEquals(
 
3225
        self.assertNotEqual(
3226
3226
            'a',
3227
3227
            tree.getroot()[1].tag)
3228
3228
        # process xincludes
3229
3229
        self.include( tree )
3230
3230
        # check whether we find it replaced with included data
3231
 
        self.assertEquals(
 
3231
        self.assertEqual(
3232
3232
            'a',
3233
3233
            tree.getroot()[1].tag)
3234
3234
 
3259
3259
 
3260
3260
        called = list(res_instance.called.items())
3261
3261
        called.sort()
3262
 
        self.assertEquals(
 
3262
        self.assertEqual(
3263
3263
            [("dtd", True), ("include", True), ("input", True)],
3264
3264
            called)
3265
3265
 
3280
3280
        f = BytesIO()
3281
3281
        tree.write_c14n(f)
3282
3282
        s = f.getvalue()
3283
 
        self.assertEquals(_bytes('<a><b></b></a>'),
 
3283
        self.assertEqual(_bytes('<a><b></b></a>'),
3284
3284
                          s)
3285
3285
 
3286
3286
    def test_c14n_gzip(self):
3292
3292
            s = gzfile.read()
3293
3293
        finally:
3294
3294
            gzfile.close()
3295
 
        self.assertEquals(_bytes('<a>'+'<b></b>'*200+'</a>'),
 
3295
        self.assertEqual(_bytes('<a>'+'<b></b>'*200+'</a>'),
3296
3296
                          s)
3297
3297
 
3298
3298
    def test_c14n_file(self):
3304
3304
        finally:
3305
3305
            os.close(handle)
3306
3306
            os.remove(filename)
3307
 
        self.assertEquals(_bytes('<a><b></b></a>'),
 
3307
        self.assertEqual(_bytes('<a><b></b></a>'),
3308
3308
                          data)
3309
3309
 
3310
3310
    def test_c14n_file_gzip(self):
3320
3320
        finally:
3321
3321
            os.close(handle)
3322
3322
            os.remove(filename)
3323
 
        self.assertEquals(_bytes('<a>'+'<b></b>'*200+'</a>'),
 
3323
        self.assertEqual(_bytes('<a>'+'<b></b>'*200+'</a>'),
3324
3324
                          data)
3325
3325
 
3326
3326
    def test_c14n_with_comments(self):
3328
3328
        f = BytesIO()
3329
3329
        tree.write_c14n(f)
3330
3330
        s = f.getvalue()
3331
 
        self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
 
3331
        self.assertEqual(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
3332
3332
                          s)
3333
3333
        f = BytesIO()
3334
3334
        tree.write_c14n(f, with_comments=True)
3335
3335
        s = f.getvalue()
3336
 
        self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
 
3336
        self.assertEqual(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
3337
3337
                          s)
3338
3338
        f = BytesIO()
3339
3339
        tree.write_c14n(f, with_comments=False)
3340
3340
        s = f.getvalue()
3341
 
        self.assertEquals(_bytes('<a><b></b></a>'),
 
3341
        self.assertEqual(_bytes('<a><b></b></a>'),
3342
3342
                          s)
3343
3343
 
3344
3344
    def test_c14n_tostring_with_comments(self):
3345
3345
        tree = self.parse(_bytes('<!--hi--><a><!--ho--><b/></a><!--hu-->'))
3346
3346
        s = etree.tostring(tree, method='c14n')
3347
 
        self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
 
3347
        self.assertEqual(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
3348
3348
                          s)
3349
3349
        s = etree.tostring(tree, method='c14n', with_comments=True)
3350
 
        self.assertEquals(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
 
3350
        self.assertEqual(_bytes('<!--hi-->\n<a><!--ho--><b></b></a>\n<!--hu-->'),
3351
3351
                          s)
3352
3352
        s = etree.tostring(tree, method='c14n', with_comments=False)
3353
 
        self.assertEquals(_bytes('<a><b></b></a>'),
 
3353
        self.assertEqual(_bytes('<a><b></b></a>'),
3354
3354
                          s)
3355
3355
 
3356
3356
    def test_c14n_element_tostring_with_comments(self):
3357
3357
        tree = self.parse(_bytes('<!--hi--><a><!--ho--><b/></a><!--hu-->'))
3358
3358
        s = etree.tostring(tree.getroot(), method='c14n')
3359
 
        self.assertEquals(_bytes('<a><!--ho--><b></b></a>'),
 
3359
        self.assertEqual(_bytes('<a><!--ho--><b></b></a>'),
3360
3360
                          s)
3361
3361
        s = etree.tostring(tree.getroot(), method='c14n', with_comments=True)
3362
 
        self.assertEquals(_bytes('<a><!--ho--><b></b></a>'),
 
3362
        self.assertEqual(_bytes('<a><!--ho--><b></b></a>'),
3363
3363
                          s)
3364
3364
        s = etree.tostring(tree.getroot(), method='c14n', with_comments=False)
3365
 
        self.assertEquals(_bytes('<a><b></b></a>'),
 
3365
        self.assertEqual(_bytes('<a><b></b></a>'),
3366
3366
                          s)
3367
3367
 
3368
3368
    def test_c14n_exclusive(self):
3371
3371
        f = BytesIO()
3372
3372
        tree.write_c14n(f)
3373
3373
        s = f.getvalue()
3374
 
        self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
 
3374
        self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
3375
3375
                          s)
3376
3376
        f = BytesIO()
3377
3377
        tree.write_c14n(f, exclusive=False)
3378
3378
        s = f.getvalue()
3379
 
        self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
 
3379
        self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
3380
3380
                          s)
3381
3381
        f = BytesIO()
3382
3382
        tree.write_c14n(f, exclusive=True)
3383
3383
        s = f.getvalue()
3384
 
        self.assertEquals(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'),
 
3384
        self.assertEqual(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'),
3385
3385
                          s)
3386
3386
 
3387
3387
        f = BytesIO()
3388
3388
        tree.write_c14n(f, exclusive=True, inclusive_ns_prefixes=['z'])
3389
3389
        s = f.getvalue()
3390
 
        self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:z="http://cde"><z:b></z:b></a>'),
 
3390
        self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:z="http://cde"><z:b></z:b></a>'),
3391
3391
                          s)
3392
3392
 
3393
3393
    def test_c14n_tostring_exclusive(self):
3394
3394
        tree = self.parse(_bytes(
3395
3395
                '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>'))
3396
3396
        s = etree.tostring(tree, method='c14n')
3397
 
        self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
 
3397
        self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
3398
3398
                          s)
3399
3399
        s = etree.tostring(tree, method='c14n', exclusive=False)
3400
 
        self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
 
3400
        self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
3401
3401
                          s)
3402
3402
        s = etree.tostring(tree, method='c14n', exclusive=True)
3403
 
        self.assertEquals(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'),
 
3403
        self.assertEqual(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'),
3404
3404
                          s)
3405
3405
 
3406
3406
        s = etree.tostring(tree, method='c14n', exclusive=True, inclusive_ns_prefixes=['y'])
3407
 
        self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd"><z:b xmlns:z="http://cde"></z:b></a>'),
 
3407
        self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd"><z:b xmlns:z="http://cde"></z:b></a>'),
3408
3408
                          s)
3409
3409
 
3410
3410
    def test_c14n_element_tostring_exclusive(self):
3411
3411
        tree = self.parse(_bytes(
3412
3412
                '<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>'))
3413
3413
        s = etree.tostring(tree.getroot(), method='c14n')
3414
 
        self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
 
3414
        self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
3415
3415
                          s)
3416
3416
        s = etree.tostring(tree.getroot(), method='c14n', exclusive=False)
3417
 
        self.assertEquals(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
 
3417
        self.assertEqual(_bytes('<a xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
3418
3418
                          s)
3419
3419
        s = etree.tostring(tree.getroot(), method='c14n', exclusive=True)
3420
 
        self.assertEquals(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'),
 
3420
        self.assertEqual(_bytes('<a xmlns="http://abc"><z:b xmlns:z="http://cde"></z:b></a>'),
3421
3421
                          s)
3422
3422
 
3423
3423
        s = etree.tostring(tree.getroot()[0], method='c14n', exclusive=False)
3424
 
        self.assertEquals(_bytes('<z:b xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"></z:b>'),
 
3424
        self.assertEqual(_bytes('<z:b xmlns="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"></z:b>'),
3425
3425
                          s)
3426
3426
        s = etree.tostring(tree.getroot()[0], method='c14n', exclusive=True)
3427
 
        self.assertEquals(_bytes('<z:b xmlns:z="http://cde"></z:b>'),
 
3427
        self.assertEqual(_bytes('<z:b xmlns:z="http://cde"></z:b>'),
3428
3428
                          s)
3429
3429
 
3430
3430
        s = etree.tostring(tree.getroot()[0], method='c14n', exclusive=True, inclusive_ns_prefixes=['y'])
3431
 
        self.assertEquals(_bytes('<z:b xmlns:y="http://bcd" xmlns:z="http://cde"></z:b>'),
 
3431
        self.assertEqual(_bytes('<z:b xmlns:y="http://bcd" xmlns:z="http://cde"></z:b>'),
3432
3432
                          s)
3433
3433
 
3434
3434
    def test_c14n_tostring_inclusive_ns_prefixes(self):
3437
3437
                '<a xmlns:x="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b/></a>'))
3438
3438
 
3439
3439
        s = etree.tostring(tree, method='c14n', exclusive=True, inclusive_ns_prefixes=['x', 'y', 'z'])
3440
 
        self.assertEquals(_bytes('<a xmlns:x="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
 
3440
        self.assertEqual(_bytes('<a xmlns:x="http://abc" xmlns:y="http://bcd" xmlns:z="http://cde"><z:b></z:b></a>'),
3441
3441
                          s)
3442
3442
 
3443
3443
 
3447
3447
        f = BytesIO()
3448
3448
        tree.write(f)
3449
3449
        s = f.getvalue()
3450
 
        self.assertEquals(_bytes('<a><b/></a>'),
 
3450
        self.assertEqual(_bytes('<a><b/></a>'),
3451
3451
                          s)
3452
3452
 
3453
3453
    def test_write_gzip(self):
3459
3459
            s = gzfile.read()
3460
3460
        finally:
3461
3461
            gzfile.close()
3462
 
        self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
 
3462
        self.assertEqual(_bytes('<a>'+'<b/>'*200+'</a>'),
3463
3463
                          s)
3464
3464
 
3465
3465
    def test_write_gzip_level(self):
3470
3470
 
3471
3471
        f = BytesIO()
3472
3472
        tree.write(f)
3473
 
        self.assertEquals(f.getvalue(), s0)
 
3473
        self.assertEqual(f.getvalue(), s0)
3474
3474
 
3475
3475
        f = BytesIO()
3476
3476
        tree.write(f, compression=1)
3477
3477
        s = f.getvalue()
3478
 
        self.assert_(len(s) <= len(s0))
 
3478
        self.assertTrue(len(s) <= len(s0))
3479
3479
        gzfile = gzip.GzipFile(fileobj=BytesIO(s))
3480
3480
        try:
3481
3481
            s1 = gzfile.read()
3485
3485
        f = BytesIO()
3486
3486
        tree.write(f, compression=9)
3487
3487
        s = f.getvalue()
3488
 
        self.assert_(len(s) <= len(s0))
 
3488
        self.assertTrue(len(s) <= len(s0))
3489
3489
        gzfile = gzip.GzipFile(fileobj=BytesIO(s))
3490
3490
        try:
3491
3491
            s9 = gzfile.read()
3492
3492
        finally:
3493
3493
            gzfile.close()
3494
3494
 
3495
 
        self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
 
3495
        self.assertEqual(_bytes('<a>'+'<b/>'*200+'</a>'),
3496
3496
                          s0)
3497
 
        self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
 
3497
        self.assertEqual(_bytes('<a>'+'<b/>'*200+'</a>'),
3498
3498
                          s1)
3499
 
        self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
 
3499
        self.assertEqual(_bytes('<a>'+'<b/>'*200+'</a>'),
3500
3500
                          s9)
3501
3501
 
3502
3502
    def test_write_file(self):
3508
3508
        finally:
3509
3509
            os.close(handle)
3510
3510
            os.remove(filename)
3511
 
        self.assertEquals(_bytes('<a><b/></a>'),
 
3511
        self.assertEqual(_bytes('<a><b/></a>'),
3512
3512
                          data)
3513
3513
 
3514
3514
    def test_write_file_gzip(self):
3524
3524
        finally:
3525
3525
            os.close(handle)
3526
3526
            os.remove(filename)
3527
 
        self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
 
3527
        self.assertEqual(_bytes('<a>'+'<b/>'*200+'</a>'),
3528
3528
                          data)
3529
3529
 
3530
3530
    def test_write_file_gzip_parse(self):
3536
3536
        finally:
3537
3537
            os.close(handle)
3538
3538
            os.remove(filename)
3539
 
        self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
 
3539
        self.assertEqual(_bytes('<a>'+'<b/>'*200+'</a>'),
3540
3540
                          data)
3541
3541
 
3542
3542
    def test_write_file_gzipfile_parse(self):
3549
3549
        finally:
3550
3550
            os.close(handle)
3551
3551
            os.remove(filename)
3552
 
        self.assertEquals(_bytes('<a>'+'<b/>'*200+'</a>'),
 
3552
        self.assertEqual(_bytes('<a>'+'<b/>'*200+'</a>'),
3553
3553
                          data)
3554
3554
 
3555
3555
class ETreeErrorLogTest(HelperTestCase):
3566
3566
            e = sys.exc_info()[1]
3567
3567
            logs = e.error_log
3568
3568
        f.close()
3569
 
        self.assert_([ log for log in logs
 
3569
        self.assertTrue([ log for log in logs
3570
3570
                       if 'mismatch' in log.message ])
3571
 
        self.assert_([ log for log in logs
 
3571
        self.assertTrue([ log for log in logs
3572
3572
                       if 'PARSER'   in log.domain_name])
3573
 
        self.assert_([ log for log in logs
 
3573
        self.assertTrue([ log for log in logs
3574
3574
                       if 'ERR_TAG_NAME_MISMATCH' in log.type_name ])
3575
 
        self.assert_([ log for log in logs
 
3575
        self.assertTrue([ log for log in logs
3576
3576
                       if 1 == log.line ])
3577
 
        self.assert_([ log for log in logs
 
3577
        self.assertTrue([ log for log in logs
3578
3578
                       if 15 == log.column ])
3579
3579
 
3580
3580
    def _test_python_error_logging(self):
3596
3596
            pass
3597
3597
        f.close()
3598
3598
 
3599
 
        self.assert_([ message for message in messages
 
3599
        self.assertTrue([ message for message in messages
3600
3600
                       if 'mismatch' in message ])
3601
 
        self.assert_([ message for message in messages
 
3601
        self.assertTrue([ message for message in messages
3602
3602
                       if ':PARSER:'   in message])
3603
 
        self.assert_([ message for message in messages
 
3603
        self.assertTrue([ message for message in messages
3604
3604
                       if ':ERR_TAG_NAME_MISMATCH:' in message ])
3605
 
        self.assert_([ message for message in messages
 
3605
        self.assertTrue([ message for message in messages
3606
3606
                       if ':1:15:' in message ])
3607
3607
 
3608
3608
def test_suite():