45
45
def test_element(self):
46
46
for i in range(10):
47
47
e = self.etree.Element('foo')
48
self.assertEquals(e.tag, 'foo')
49
self.assertEquals(e.text, None)
50
self.assertEquals(e.tail, None)
48
self.assertEqual(e.tag, 'foo')
49
self.assertEqual(e.text, None)
50
self.assertEqual(e.tail, None)
52
52
def test_simple(self):
53
53
Element = self.etree.Element
56
56
root.append(Element('one'))
57
57
root.append(Element('two'))
58
58
root.append(Element('three'))
59
self.assertEquals(3, len(root))
60
self.assertEquals('one', root[0].tag)
61
self.assertEquals('two', root[1].tag)
62
self.assertEquals('three', root[2].tag)
59
self.assertEqual(3, len(root))
60
self.assertEqual('one', root[0].tag)
61
self.assertEqual('two', root[1].tag)
62
self.assertEqual('three', root[2].tag)
63
63
self.assertRaises(IndexError, operator.getitem, root, 3)
65
65
# test weird dictionary interaction leading to segfault previously
66
66
def test_weird_dict_interaction(self):
67
67
root = self.etree.Element('root')
68
self.assertEquals(root.tag, "root")
68
self.assertEqual(root.tag, "root")
69
69
add = self.etree.ElementTree(file=BytesIO('<foo>Foo</foo>'))
70
self.assertEquals(add.getroot().tag, "foo")
71
self.assertEquals(add.getroot().text, "Foo")
70
self.assertEqual(add.getroot().tag, "foo")
71
self.assertEqual(add.getroot().text, "Foo")
72
72
root.append(self.etree.Element('baz'))
73
self.assertEquals(root.tag, "root")
74
self.assertEquals(root[0].tag, "baz")
73
self.assertEqual(root.tag, "root")
74
self.assertEqual(root[0].tag, "baz")
76
76
def test_subelement(self):
77
77
Element = self.etree.Element
81
81
SubElement(root, 'one')
82
82
SubElement(root, 'two')
83
83
SubElement(root, 'three')
84
self.assertEquals(3, len(root))
85
self.assertEquals('one', root[0].tag)
86
self.assertEquals('two', root[1].tag)
87
self.assertEquals('three', root[2].tag)
84
self.assertEqual(3, len(root))
85
self.assertEqual('one', root[0].tag)
86
self.assertEqual('two', root[1].tag)
87
self.assertEqual('three', root[2].tag)
89
89
def test_element_contains(self):
90
90
Element = self.etree.Element
110
110
f = BytesIO('<doc>Test<one>One</one></doc>')
111
111
doc = ElementTree(file=f)
112
112
root = doc.getroot()
113
self.assertEquals(1, len(root))
114
self.assertEquals('one', root[0].tag)
113
self.assertEqual(1, len(root))
114
self.assertEqual('one', root[0].tag)
115
115
self.assertRaises(IndexError, operator.getitem, root, 1)
117
117
def test_element_indexing_with_text2(self):
120
120
f = BytesIO('<doc><one>One</one><two>Two</two>hm<three>Three</three></doc>')
121
121
doc = ElementTree(file=f)
122
122
root = doc.getroot()
123
self.assertEquals(3, len(root))
124
self.assertEquals('one', root[0].tag)
125
self.assertEquals('two', root[1].tag)
126
self.assertEquals('three', root[2].tag)
123
self.assertEqual(3, len(root))
124
self.assertEqual('one', root[0].tag)
125
self.assertEqual('two', root[1].tag)
126
self.assertEqual('three', root[2].tag)
128
128
def test_element_indexing_only_text(self):
129
129
ElementTree = self.etree.ElementTree
140
140
b = SubElement(a, 'b')
141
141
c = SubElement(a, 'c')
142
142
d = SubElement(a, 'd')
143
self.assertEquals(d, a[-1])
144
self.assertEquals(c, a[-2])
145
self.assertEquals(b, a[-3])
143
self.assertEqual(d, a[-1])
144
self.assertEqual(c, a[-2])
145
self.assertEqual(b, a[-3])
146
146
self.assertRaises(IndexError, operator.getitem, a, -4)
147
147
a[-1] = e = Element('e')
148
self.assertEquals(e, a[-1])
148
self.assertEqual(e, a[-1])
150
self.assertEquals(2, len(a))
150
self.assertEqual(2, len(a))
152
152
def test_elementtree(self):
153
153
ElementTree = self.etree.ElementTree
155
155
f = BytesIO('<doc><one>One</one><two>Two</two></doc>')
156
156
doc = ElementTree(file=f)
157
157
root = doc.getroot()
158
self.assertEquals(2, len(root))
159
self.assertEquals('one', root[0].tag)
160
self.assertEquals('two', root[1].tag)
158
self.assertEqual(2, len(root))
159
self.assertEqual('one', root[0].tag)
160
self.assertEqual('two', root[1].tag)
162
162
def test_text(self):
163
163
ElementTree = self.etree.ElementTree
226
226
f = BytesIO('<doc>This is <i>mixed</i> content.</doc>')
227
227
doc = ElementTree(file=f)
228
228
root = doc.getroot()
229
self.assertEquals(1, len(root))
230
self.assertEquals('This is ', root.text)
231
self.assertEquals(None, root.tail)
232
self.assertEquals('mixed', root[0].text)
233
self.assertEquals(' content.', root[0].tail)
229
self.assertEqual(1, len(root))
230
self.assertEqual('This is ', root.text)
231
self.assertEqual(None, root.tail)
232
self.assertEqual('mixed', root[0].text)
233
self.assertEqual(' content.', root[0].tail)
235
235
def test_tail_str_subclass(self):
236
236
Element = self.etree.Element
249
249
XML = self.etree.XML
251
251
root = XML(_bytes('<doc>This is <i>mixed</i> content.</doc>'))
252
self.assertEquals(1, len(root))
253
self.assertEquals('This is ', root.text)
254
self.assertEquals(None, root.tail)
255
self.assertEquals('mixed', root[0].text)
256
self.assertEquals(' content.', root[0].tail)
252
self.assertEqual(1, len(root))
253
self.assertEqual('This is ', root.text)
254
self.assertEqual(None, root.tail)
255
self.assertEqual('mixed', root[0].text)
256
self.assertEqual(' content.', root[0].tail)
260
self.assertEquals(1, len(root))
261
self.assertEquals('This is ', root.text)
262
self.assertEquals(None, root.tail)
263
self.assertEquals('mixed', root[0].text)
264
self.assertEquals(None, root[0].tail)
260
self.assertEqual(1, len(root))
261
self.assertEqual('This is ', root.text)
262
self.assertEqual(None, root.tail)
263
self.assertEqual('mixed', root[0].text)
264
self.assertEqual(None, root[0].tail)
266
266
root[0].tail = "TAIL"
268
self.assertEquals(1, len(root))
269
self.assertEquals('This is ', root.text)
270
self.assertEquals(None, root.tail)
271
self.assertEquals('mixed', root[0].text)
272
self.assertEquals('TAIL', root[0].tail)
268
self.assertEqual(1, len(root))
269
self.assertEqual('This is ', root.text)
270
self.assertEqual(None, root.tail)
271
self.assertEqual('mixed', root[0].text)
272
self.assertEqual('TAIL', root[0].tail)
274
274
def test_ElementTree(self):
275
275
Element = self.etree.Element
287
287
f = BytesIO('<doc one="One" two="Two"/>')
288
288
doc = ElementTree(file=f)
289
289
root = doc.getroot()
290
self.assertEquals('One', root.attrib['one'])
291
self.assertEquals('Two', root.attrib['two'])
290
self.assertEqual('One', root.attrib['one'])
291
self.assertEqual('Two', root.attrib['two'])
292
292
self.assertRaises(KeyError, operator.getitem, root.attrib, 'three')
294
294
def test_attributes2(self):
297
297
f = BytesIO('<doc one="One" two="Two"/>')
298
298
doc = ElementTree(file=f)
299
299
root = doc.getroot()
300
self.assertEquals('One', root.attrib.get('one'))
301
self.assertEquals('Two', root.attrib.get('two'))
302
self.assertEquals(None, root.attrib.get('three'))
303
self.assertEquals('foo', root.attrib.get('three', 'foo'))
300
self.assertEqual('One', root.attrib.get('one'))
301
self.assertEqual('Two', root.attrib.get('two'))
302
self.assertEqual(None, root.attrib.get('three'))
303
self.assertEqual('foo', root.attrib.get('three', 'foo'))
305
305
def test_attributes3(self):
306
306
ElementTree = self.etree.ElementTree
308
308
f = BytesIO('<doc one="One" two="Two"/>')
309
309
doc = ElementTree(file=f)
310
310
root = doc.getroot()
311
self.assertEquals('One', root.get('one'))
312
self.assertEquals('Two', root.get('two'))
313
self.assertEquals(None, root.get('three'))
314
self.assertEquals('foo', root.get('three', 'foo'))
311
self.assertEqual('One', root.get('one'))
312
self.assertEqual('Two', root.get('two'))
313
self.assertEqual(None, root.get('three'))
314
self.assertEqual('foo', root.get('three', 'foo'))
316
316
def test_attrib_clear(self):
317
317
XML = self.etree.XML
319
319
root = XML(_bytes('<doc one="One" two="Two"/>'))
320
self.assertEquals('One', root.get('one'))
321
self.assertEquals('Two', root.get('two'))
320
self.assertEqual('One', root.get('one'))
321
self.assertEqual('Two', root.get('two'))
322
322
root.attrib.clear()
323
self.assertEquals(None, root.get('one'))
324
self.assertEquals(None, root.get('two'))
323
self.assertEqual(None, root.get('one'))
324
self.assertEqual(None, root.get('two'))
326
326
def test_attrib_set_clear(self):
327
327
Element = self.etree.Element
329
329
root = Element("root", one="One")
330
330
root.set("two", "Two")
331
self.assertEquals('One', root.get('one'))
332
self.assertEquals('Two', root.get('two'))
331
self.assertEqual('One', root.get('one'))
332
self.assertEqual('Two', root.get('two'))
333
333
root.attrib.clear()
334
self.assertEquals(None, root.get('one'))
335
self.assertEquals(None, root.get('two'))
334
self.assertEqual(None, root.get('one'))
335
self.assertEqual(None, root.get('two'))
337
337
def test_attrib_ns_clear(self):
338
338
Element = self.etree.Element
345
345
child = SubElement(parent, 'child')
346
346
child.set(attribNS, 'b')
348
self.assertEquals('a', parent.get(attribNS))
349
self.assertEquals('b', child.get(attribNS))
348
self.assertEqual('a', parent.get(attribNS))
349
self.assertEqual('b', child.get(attribNS))
352
self.assertEquals(None, parent.get(attribNS))
353
self.assertEquals('b', child.get(attribNS))
352
self.assertEqual(None, parent.get(attribNS))
353
self.assertEqual('b', child.get(attribNS))
355
355
def test_attrib_pop(self):
356
356
ElementTree = self.etree.ElementTree
358
358
f = BytesIO('<doc one="One" two="Two"/>')
359
359
doc = ElementTree(file=f)
360
360
root = doc.getroot()
361
self.assertEquals('One', root.attrib['one'])
362
self.assertEquals('Two', root.attrib['two'])
364
self.assertEquals('One', root.attrib.pop('one'))
366
self.assertEquals(None, root.attrib.get('one'))
367
self.assertEquals('Two', root.attrib['two'])
361
self.assertEqual('One', root.attrib['one'])
362
self.assertEqual('Two', root.attrib['two'])
364
self.assertEqual('One', root.attrib.pop('one'))
366
self.assertEqual(None, root.attrib.get('one'))
367
self.assertEqual('Two', root.attrib['two'])
369
369
def test_attrib_pop_unknown(self):
370
370
root = self.etree.XML(_bytes('<doc one="One" two="Two"/>'))
371
371
self.assertRaises(KeyError, root.attrib.pop, 'NONE')
373
self.assertEquals('One', root.attrib['one'])
374
self.assertEquals('Two', root.attrib['two'])
373
self.assertEqual('One', root.attrib['one'])
374
self.assertEqual('Two', root.attrib['two'])
376
376
def test_attrib_pop_default(self):
377
377
root = self.etree.XML(_bytes('<doc one="One" two="Two"/>'))
378
self.assertEquals('Three', root.attrib.pop('three', 'Three'))
378
self.assertEqual('Three', root.attrib.pop('three', 'Three'))
380
380
def test_attrib_pop_empty_default(self):
381
381
root = self.etree.XML(_bytes('<doc/>'))
382
self.assertEquals('Three', root.attrib.pop('three', 'Three'))
382
self.assertEqual('Three', root.attrib.pop('three', 'Three'))
384
384
def test_attrib_pop_invalid_args(self):
385
385
root = self.etree.XML(_bytes('<doc one="One" two="Two"/>'))
542
542
root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
544
self.assertEquals(expected, str(root.attrib))
544
self.assertEqual(expected, str(root.attrib))
545
545
except AssertionError:
546
self.assertEquals(alternative, str(root.attrib))
546
self.assertEqual(alternative, str(root.attrib))
548
548
def test_attribute_contains(self):
549
549
XML = self.etree.XML
551
551
root = XML(_bytes('<foo bar="Bar" xmlns:ns="http://ns.codespeak.net/test" ns:baz="Baz" />'))
553
553
True, 'bar' in root.attrib)
555
555
False, 'baz' in root.attrib)
557
557
False, 'hah' in root.attrib)
560
560
'{http://ns.codespeak.net/test}baz' in root.attrib)
593
593
a.attrib['{http://a/}foo'] = 'Foo'
594
594
a.attrib['{http://a/}bar'] = 'Bar'
595
self.assertEquals(None, a.get('foo'))
596
self.assertEquals('Foo', a.get('{http://a/}foo'))
597
self.assertEquals('Foo', a.attrib['{http://a/}foo'])
595
self.assertEqual(None, a.get('foo'))
596
self.assertEqual('Foo', a.get('{http://a/}foo'))
597
self.assertEqual('Foo', a.attrib['{http://a/}foo'])
599
599
self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo')
600
self.assertEquals('Foo', a.attrib['{http://a/}foo'])
600
self.assertEqual('Foo', a.attrib['{http://a/}foo'])
602
602
del a.attrib['{http://a/}foo']
603
603
self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
608
608
a = XML(_bytes('<a xmlns:nsa="http://a/" nsa:foo="FooNS" foo="Foo" />'))
610
self.assertEquals('Foo', a.attrib['foo'])
611
self.assertEquals('FooNS', a.attrib['{http://a/}foo'])
610
self.assertEqual('Foo', a.attrib['foo'])
611
self.assertEqual('FooNS', a.attrib['{http://a/}foo'])
613
613
del a.attrib['foo']
614
self.assertEquals('FooNS', a.attrib['{http://a/}foo'])
614
self.assertEqual('FooNS', a.attrib['{http://a/}foo'])
615
615
self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
616
616
self.assertRaises(KeyError, operator.delitem, a.attrib, 'foo')
622
622
a = XML(_bytes('<a xmlns:nsa="http://a/" foo="Foo" nsa:foo="FooNS" />'))
624
self.assertEquals('Foo', a.attrib['foo'])
625
self.assertEquals('FooNS', a.attrib['{http://a/}foo'])
624
self.assertEqual('Foo', a.attrib['foo'])
625
self.assertEqual('FooNS', a.attrib['{http://a/}foo'])
627
627
del a.attrib['foo']
628
self.assertEquals('FooNS', a.attrib['{http://a/}foo'])
628
self.assertEqual('FooNS', a.attrib['{http://a/}foo'])
629
629
self.assertRaises(KeyError, operator.getitem, a.attrib, 'foo')
631
631
del a.attrib['{http://a/}foo']
655
655
root, dic = XMLID(xml_text)
656
656
root2 = XML(xml_text)
657
self.assertEquals(self._writeElement(root),
657
self.assertEqual(self._writeElement(root),
658
658
self._writeElement(root2))
660
660
"chapter1" : root[0],
661
661
"note1" : root[1],
662
662
"warn1" : root[4]
664
self.assertEquals(dic, expected)
664
self.assertEqual(dic, expected)
666
666
def test_fromstring(self):
667
667
fromstring = self.etree.fromstring
669
669
root = fromstring('<doc>This is a text.</doc>')
670
self.assertEquals(0, len(root))
671
self.assertEquals('This is a text.', root.text)
670
self.assertEqual(0, len(root))
671
self.assertEqual('This is a text.', root.text)
673
673
required_versions_ET['test_fromstringlist'] = (1,3)
674
674
def test_fromstringlist(self):
677
677
root = fromstringlist(["<do", "c>T", "hi", "s is",
678
678
" a text.<", "/doc", ">"])
679
self.assertEquals(0, len(root))
680
self.assertEquals('This is a text.', root.text)
679
self.assertEqual(0, len(root))
680
self.assertEqual('This is a text.', root.text)
682
682
required_versions_ET['test_fromstringlist_characters'] = (1,3)
683
683
def test_fromstringlist_characters(self):
684
684
fromstringlist = self.etree.fromstringlist
686
686
root = fromstringlist(list('<doc>This is a text.</doc>'))
687
self.assertEquals(0, len(root))
688
self.assertEquals('This is a text.', root.text)
687
self.assertEqual(0, len(root))
688
self.assertEqual('This is a text.', root.text)
690
690
required_versions_ET['test_fromstringlist_single'] = (1,3)
691
691
def test_fromstringlist_single(self):
692
692
fromstringlist = self.etree.fromstringlist
694
694
root = fromstringlist(['<doc>This is a text.</doc>'])
695
self.assertEquals(0, len(root))
696
self.assertEquals('This is a text.', root.text)
695
self.assertEqual(0, len(root))
696
self.assertEqual('This is a text.', root.text)
698
698
def test_iselement(self):
699
699
iselement = self.etree.iselement
704
704
ProcessingInstruction = self.etree.ProcessingInstruction
706
706
el = Element('hoi')
707
self.assert_(iselement(el))
707
self.assertTrue(iselement(el))
709
709
el2 = XML(_bytes('<foo/>'))
710
self.assert_(iselement(el2))
710
self.assertTrue(iselement(el2))
712
712
tree = ElementTree(element=Element('dag'))
713
self.assert_(not iselement(tree))
714
self.assert_(iselement(tree.getroot()))
713
self.assertTrue(not iselement(tree))
714
self.assertTrue(iselement(tree.getroot()))
716
716
c = Comment('test')
717
self.assert_(iselement(c))
717
self.assertTrue(iselement(c))
719
719
p = ProcessingInstruction("test", "some text")
720
self.assert_(iselement(p))
720
self.assertTrue(iselement(p))
722
722
def test_iteration(self):
723
723
XML = self.etree.XML
812
812
root = XML(_bytes("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>"))
814
814
text = list(root[2].itertext())
815
self.assertEquals(["CTEXT"],
815
self.assertEqual(["CTEXT"],
818
818
def test_findall(self):
819
819
XML = self.etree.XML
820
820
root = XML(_bytes('<a><b><c/></b><b/><c><b/></c></a>'))
821
self.assertEquals(len(list(root.findall("c"))), 1)
822
self.assertEquals(len(list(root.findall(".//c"))), 2)
823
self.assertEquals(len(list(root.findall(".//b"))), 3)
824
self.assertEquals(len(list(root.findall(".//b"))[0]), 1)
825
self.assertEquals(len(list(root.findall(".//b"))[1]), 0)
826
self.assertEquals(len(list(root.findall(".//b"))[2]), 0)
821
self.assertEqual(len(list(root.findall("c"))), 1)
822
self.assertEqual(len(list(root.findall(".//c"))), 2)
823
self.assertEqual(len(list(root.findall(".//b"))), 3)
824
self.assertEqual(len(list(root.findall(".//b"))[0]), 1)
825
self.assertEqual(len(list(root.findall(".//b"))[1]), 0)
826
self.assertEqual(len(list(root.findall(".//b"))[2]), 0)
828
828
def test_findall_ns(self):
829
829
XML = self.etree.XML
830
830
root = XML(_bytes('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>'))
831
self.assertEquals(len(list(root.findall(".//{X}b"))), 2)
832
self.assertEquals(len(list(root.findall(".//b"))), 3)
833
self.assertEquals(len(list(root.findall("b"))), 2)
831
self.assertEqual(len(list(root.findall(".//{X}b"))), 2)
832
self.assertEqual(len(list(root.findall(".//b"))), 3)
833
self.assertEqual(len(list(root.findall("b"))), 2)
835
835
def test_element_with_attributes_keywords(self):
836
836
Element = self.etree.Element
838
838
el = Element('tag', foo='Foo', bar='Bar')
839
self.assertEquals('Foo', el.attrib['foo'])
840
self.assertEquals('Bar', el.attrib['bar'])
839
self.assertEqual('Foo', el.attrib['foo'])
840
self.assertEqual('Bar', el.attrib['bar'])
842
842
def test_element_with_attributes(self):
843
843
Element = self.etree.Element
845
845
el = Element('tag', {'foo':'Foo', 'bar':'Bar'})
846
self.assertEquals('Foo', el.attrib['foo'])
847
self.assertEquals('Bar', el.attrib['bar'])
846
self.assertEqual('Foo', el.attrib['foo'])
847
self.assertEqual('Bar', el.attrib['bar'])
849
849
def test_element_with_attributes_ns(self):
850
850
Element = self.etree.Element
852
852
el = Element('tag', {'{ns1}foo':'Foo', '{ns2}bar':'Bar'})
853
self.assertEquals('Foo', el.attrib['{ns1}foo'])
854
self.assertEquals('Bar', el.attrib['{ns2}bar'])
853
self.assertEqual('Foo', el.attrib['{ns1}foo'])
854
self.assertEqual('Bar', el.attrib['{ns2}bar'])
856
856
def test_subelement_with_attributes(self):
857
857
Element = self.etree.Element
860
860
el = Element('tag')
861
861
SubElement(el, 'foo', {'foo':'Foo'}, baz="Baz")
862
self.assertEquals("Baz", el[0].attrib['baz'])
863
self.assertEquals('Foo', el[0].attrib['foo'])
862
self.assertEqual("Baz", el[0].attrib['baz'])
863
self.assertEqual('Foo', el[0].attrib['foo'])
865
865
def test_subelement_with_attributes_ns(self):
866
866
Element = self.etree.Element
1099
1099
root.extend(elements)
1102
1102
["a0", "a1", "a2", "test0", "test1", "test2"],
1103
1103
[ el.tag for el in root ])
1105
1105
["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"],
1106
1106
[ el.text for el in root ])
1108
1108
["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"],
1109
1109
[ el.tail for el in root ])
1152
1152
a = Element('a')
1153
1153
a.append(Comment(' foo '))
1154
self.assertEquals(a[0].text, ' foo ')
1154
self.assertEqual(a[0].text, ' foo ')
1156
1156
_bytes('<a><!-- foo --></a>'),
1159
1159
def test_comment_nonsense(self):
1160
1160
Comment = self.etree.Comment
1161
1161
c = Comment('foo')
1162
self.assertEquals({}, c.attrib)
1163
self.assertEquals([], list(c.keys()))
1164
self.assertEquals([], list(c.items()))
1165
self.assertEquals(None, c.get('hoi'))
1166
self.assertEquals(0, len(c))
1162
self.assertEqual({}, c.attrib)
1163
self.assertEqual([], list(c.keys()))
1164
self.assertEqual([], list(c.items()))
1165
self.assertEqual(None, c.get('hoi'))
1166
self.assertEqual(0, len(c))
1167
1167
# should not iterate
1189
1189
a = Element('a')
1190
1190
a.append(ProcessingInstruction('foo', 'some more text'))
1191
self.assertEquals(a[0].tag, ProcessingInstruction)
1191
self.assertEqual(a[0].tag, ProcessingInstruction)
1192
1192
self.assertXML(_bytes("<a><?foo some more text?></a>"),
1195
1195
def test_pi_nonsense(self):
1196
1196
ProcessingInstruction = self.etree.ProcessingInstruction
1197
1197
pi = ProcessingInstruction('foo')
1198
self.assertEquals({}, pi.attrib)
1199
self.assertEquals([], list(pi.keys()))
1200
self.assertEquals([], list(pi.items()))
1201
self.assertEquals(None, pi.get('hoi'))
1202
self.assertEquals(0, len(pi))
1198
self.assertEqual({}, pi.attrib)
1199
self.assertEqual([], list(pi.keys()))
1200
self.assertEqual([], list(pi.items()))
1201
self.assertEqual(None, pi.get('hoi'))
1202
self.assertEqual(0, len(pi))
1203
1203
# should not iterate
1298
1298
b1 = SubElement(a, '{a}b')
1299
1299
b2 = SubElement(a, '{b}b')
1301
self.assertEquals('{a}b', b1.tag)
1301
self.assertEqual('{a}b', b1.tag)
1305
1305
# can't use C14N here!
1306
self.assertEquals('c', b1.tag)
1307
self.assertEquals(_bytes('<c'), tostring(b1)[:2])
1308
self.assert_(_bytes('<c') in tostring(a))
1306
self.assertEqual('c', b1.tag)
1307
self.assertEqual(_bytes('<c'), tostring(b1)[:2])
1308
self.assertTrue(_bytes('<c') in tostring(a))
1310
1310
def test_tag_reset_root_ns(self):
1311
1311
Element = self.etree.Element
1456
1456
result = self.etree.tostring(root)
1457
1457
foo = self.etree.fromstring(result)
1459
self.assertEquals('puh', foo[0].tag)
1460
self.assertEquals('{http://huhu}bump1', foo[0][0].tag)
1461
self.assertEquals('{http://huhu}bump2', foo[0][1].tag)
1459
self.assertEqual('puh', foo[0].tag)
1460
self.assertEqual('{http://huhu}bump1', foo[0][0].tag)
1461
self.assertEqual('{http://huhu}bump2', foo[0][1].tag)
1463
1463
def test_delitem_tail(self):
1464
1464
ElementTree = self.etree.ElementTree
1479
1479
a.set('hoi', 'dag')
1481
self.assertEquals(None, a.text)
1482
self.assertEquals(None, a.tail)
1483
self.assertEquals(None, a.get('hoi'))
1484
self.assertEquals('a', a.tag)
1481
self.assertEqual(None, a.text)
1482
self.assertEqual(None, a.tail)
1483
self.assertEqual(None, a.get('hoi'))
1484
self.assertEqual('a', a.tag)
1486
1486
def test_clear_sub(self):
1487
1487
Element = self.etree.Element
1494
1494
b = SubElement(a, 'b')
1495
1495
c = SubElement(b, 'c')
1497
self.assertEquals(None, a.text)
1498
self.assertEquals(None, a.tail)
1499
self.assertEquals(None, a.get('hoi'))
1500
self.assertEquals('a', a.tag)
1501
self.assertEquals(0, len(a))
1497
self.assertEqual(None, a.text)
1498
self.assertEqual(None, a.tail)
1499
self.assertEqual(None, a.get('hoi'))
1500
self.assertEqual('a', a.tag)
1501
self.assertEqual(0, len(a))
1502
1502
self.assertXML(_bytes('<a></a>'),
1504
1504
self.assertXML(_bytes('<b><c></c></b>'),
2432
2432
f = BytesIO('<x:a xmlns:x="%s" xmlns:y="%s"><x:b></x:b><y:b></y:b></x:a>' % (ns, ns2))
2433
2433
t = ElementTree(file=f)
2434
2434
a = t.getroot()
2435
self.assertEquals('{%s}a' % ns,
2435
self.assertEqual('{%s}a' % ns,
2437
self.assertEquals('{%s}b' % ns,
2437
self.assertEqual('{%s}b' % ns,
2439
self.assertEquals('{%s}b' % ns2,
2439
self.assertEqual('{%s}b' % ns2,
2442
2442
def test_ns_setting(self):
2447
2447
a = Element('{%s}a' % ns)
2448
2448
b = SubElement(a, '{%s}b' % ns2)
2449
2449
c = SubElement(a, '{%s}c' % ns)
2450
self.assertEquals('{%s}a' % ns,
2450
self.assertEqual('{%s}a' % ns,
2452
self.assertEquals('{%s}b' % ns2,
2452
self.assertEqual('{%s}b' % ns2,
2454
self.assertEquals('{%s}c' % ns,
2454
self.assertEqual('{%s}c' % ns,
2456
self.assertEquals('{%s}a' % ns,
2456
self.assertEqual('{%s}a' % ns,
2458
self.assertEquals('{%s}b' % ns2,
2458
self.assertEqual('{%s}b' % ns2,
2460
self.assertEquals('{%s}c' % ns,
2460
self.assertEqual('{%s}c' % ns,
2463
2463
def test_ns_tag_parse(self):
2565
2565
subelement = Element('subelement',
2566
2566
{"{http://www.w3.org/XML/1998/namespace}id": "foo"})
2567
self.assertEquals(1, len(subelement.attrib))
2567
self.assertEqual(1, len(subelement.attrib))
2570
2570
subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2572
2572
root.append(subelement)
2573
self.assertEquals(1, len(subelement.attrib))
2573
self.assertEqual(1, len(subelement.attrib))
2575
2575
list({"{http://www.w3.org/XML/1998/namespace}id" : "foo"}.items()),
2576
2576
list(subelement.attrib.items()))
2579
2579
subelement.get("{http://www.w3.org/XML/1998/namespace}id"))
2598
2598
xml = _bytes('<root xmlns="%s" xmlns:x="%s"><el x:a="test" /></root>' % (
2599
2599
ns_href,ns_href))
2600
2600
root = fromstring(xml)
2601
self.assertEquals('test', root[0].get('{%s}a' % ns_href))
2601
self.assertEqual('test', root[0].get('{%s}a' % ns_href))
2603
2603
xml2 = tostring(root)
2604
2604
self.assertTrue(_bytes(':a=') in xml2, xml2)
2606
2606
root2 = fromstring(xml2)
2607
self.assertEquals('test', root2[0].get('{%s}a' % ns_href))
2607
self.assertEqual('test', root2[0].get('{%s}a' % ns_href))
2609
2609
def test_attribute_namespace_roundtrip_replaced(self):
2610
2610
fromstring = self.etree.fromstring
2632
2632
namespace = 'http://seriously.unknown/namespace/URI'
2634
2634
el = Element('{%s}test' % namespace)
2635
self.assertEquals(_bytes('<ns0:test xmlns:ns0="%s"></ns0:test>' % namespace),
2635
self.assertEqual(_bytes('<ns0:test xmlns:ns0="%s"></ns0:test>' % namespace),
2636
2636
self._writeElement(el))
2638
2638
self.etree.register_namespace(prefix, namespace)
2639
2639
el = Element('{%s}test' % namespace)
2640
self.assertEquals(_bytes('<%s:test xmlns:%s="%s"></%s:test>' % (
2640
self.assertEqual(_bytes('<%s:test xmlns:%s="%s"></%s:test>' % (
2641
2641
prefix, prefix, namespace, prefix)),
2642
2642
self._writeElement(el))
2721
2721
f = BytesIO('<a><b></b><c/></a>')
2723
2723
iterator = iterparse(f)
2724
self.assertEquals(None,
2724
self.assertEqual(None,
2726
2726
events = list(iterator)
2727
2727
root = iterator.root
2729
2729
[('end', root[0]), ('end', root[1]), ('end', root)],
2732
2732
def test_iterparse_file(self):
2733
2733
iterparse = self.etree.iterparse
2734
2734
iterator = iterparse(fileInTestDir("test.xml"))
2735
self.assertEquals(None,
2735
self.assertEqual(None,
2737
2737
events = list(iterator)
2738
2738
root = iterator.root
2740
2740
[('end', root[0]), ('end', root)],
3142
3142
b = copy.deepcopy(a)
3143
self.assertEquals('Foo', b.text)
3143
self.assertEqual('Foo', b.text)
3146
self.assertEquals('Bar', b.text)
3147
self.assertEquals('Foo', a.text)
3146
self.assertEqual('Bar', b.text)
3147
self.assertEqual('Foo', a.text)
3150
self.assertEquals('Bar', b.text)
3150
self.assertEqual('Bar', b.text)
3152
3152
def test_deepcopy_tail(self):
3153
3153
Element = self.etree.Element
3158
3158
b = copy.deepcopy(a)
3159
self.assertEquals('Foo', b.tail)
3159
self.assertEqual('Foo', b.tail)
3162
self.assertEquals('Bar', b.tail)
3163
self.assertEquals('Foo', a.tail)
3162
self.assertEqual('Bar', b.tail)
3163
self.assertEqual('Foo', a.tail)
3166
self.assertEquals('Bar', b.tail)
3166
self.assertEqual('Bar', b.tail)
3168
3168
def test_deepcopy_subelement(self):
3169
3169
Element = self.etree.Element
3175
3175
a.tail = 'FooTail'
3177
3177
b = copy.deepcopy(a)
3178
self.assertEquals('FooText', b.text)
3179
self.assertEquals('FooTail', b.tail)
3178
self.assertEqual('FooText', b.text)
3179
self.assertEqual('FooTail', b.tail)
3181
3181
b.text = 'BarText'
3182
3182
b.tail = 'BarTail'
3183
self.assertEquals('BarTail', b.tail)
3184
self.assertEquals('FooTail', a.tail)
3185
self.assertEquals('BarText', b.text)
3186
self.assertEquals('FooText', a.text)
3183
self.assertEqual('BarTail', b.tail)
3184
self.assertEqual('FooTail', a.tail)
3185
self.assertEqual('BarText', b.text)
3186
self.assertEqual('FooText', a.text)
3189
self.assertEquals('BarTail', b.tail)
3190
self.assertEquals('BarText', b.text)
3189
self.assertEqual('BarTail', b.tail)
3190
self.assertEqual('BarText', b.text)
3192
3192
def test_deepcopy_namespaces(self):
3193
3193
root = self.etree.XML(_bytes('''<doc xmlns="dns" xmlns:t="tns">
3194
3194
<parent><node t:foo="bar" /></parent>
3197
3197
root[0][0].get('{tns}foo'),
3198
3198
copy.deepcopy(root[0])[0].get('{tns}foo') )
3200
3200
root[0][0].get('{tns}foo'),
3201
3201
copy.deepcopy(root[0][0]).get('{tns}foo') )
3236
3236
b = copy.copy(a)
3237
self.assertEquals('Foo', b.text)
3237
self.assertEqual('Foo', b.text)
3240
self.assertEquals('Bar', b.text)
3241
self.assertEquals('Foo', a.text)
3240
self.assertEqual('Bar', b.text)
3241
self.assertEqual('Foo', a.text)
3242
3242
# XXX ElementTree will share nodes, but lxml.etree won't..
3244
3244
def test_shallowcopy_elementtree(self):
3252
3252
btree = copy.copy(atree)
3253
3253
self.assertFalse(btree is atree)
3254
self.assert_(btree.getroot() is atree.getroot())
3255
self.assertEquals('Foo', atree.getroot().text)
3254
self.assertTrue(btree.getroot() is atree.getroot())
3255
self.assertEqual('Foo', atree.getroot().text)
3257
3257
def _test_element_boolean(self):
3258
3258
# deprecated as of ET 1.3/lxml 2.0
3259
3259
etree = self.etree
3260
3260
e = etree.Element('foo')
3261
self.assertEquals(False, bool(e))
3261
self.assertEqual(False, bool(e))
3262
3262
etree.SubElement(e, 'bar')
3263
self.assertEquals(True, bool(e))
3263
self.assertEqual(True, bool(e))
3264
3264
e = etree.Element('foo')
3266
self.assertEquals(False, bool(e))
3266
self.assertEqual(False, bool(e))
3267
3267
e = etree.Element('foo')
3269
self.assertEquals(False, bool(e))
3269
self.assertEqual(False, bool(e))
3270
3270
e = etree.Element('foo')
3271
3271
e.set('bar', 'Bar')
3272
self.assertEquals(False, bool(e))
3272
self.assertEqual(False, bool(e))
3274
3274
def test_multiple_elementrees(self):
3275
3275
etree = self.etree
3278
3278
b = etree.SubElement(a, 'b')
3280
3280
t = etree.ElementTree(a)
3281
self.assertEquals(self._rootstring(t), _bytes('<a><b/></a>'))
3281
self.assertEqual(self._rootstring(t), _bytes('<a><b/></a>'))
3283
3283
t1 = etree.ElementTree(a)
3284
self.assertEquals(self._rootstring(t1), _bytes('<a><b/></a>'))
3285
self.assertEquals(self._rootstring(t), _bytes('<a><b/></a>'))
3284
self.assertEqual(self._rootstring(t1), _bytes('<a><b/></a>'))
3285
self.assertEqual(self._rootstring(t), _bytes('<a><b/></a>'))
3287
3287
t2 = etree.ElementTree(b)
3288
self.assertEquals(self._rootstring(t2), _bytes('<b/>'))
3289
self.assertEquals(self._rootstring(t1), _bytes('<a><b/></a>'))
3290
self.assertEquals(self._rootstring(t), _bytes('<a><b/></a>'))
3288
self.assertEqual(self._rootstring(t2), _bytes('<b/>'))
3289
self.assertEqual(self._rootstring(t1), _bytes('<a><b/></a>'))
3290
self.assertEqual(self._rootstring(t), _bytes('<a><b/></a>'))
3292
3292
def test_qname(self):
3293
3293
etree = self.etree
3294
3294
qname = etree.QName('myns', 'a')
3295
3295
a1 = etree.Element(qname)
3296
3296
a2 = etree.SubElement(a1, qname)
3297
self.assertEquals(a1.tag, "{myns}a")
3298
self.assertEquals(a2.tag, "{myns}a")
3297
self.assertEqual(a1.tag, "{myns}a")
3298
self.assertEqual(a2.tag, "{myns}a")
3300
3300
def test_qname_cmp(self):
3301
3301
etree = self.etree
3302
3302
qname1 = etree.QName('myns', 'a')
3303
3303
qname2 = etree.QName('myns', 'a')
3304
self.assertEquals(qname1, "{myns}a")
3305
self.assertEquals("{myns}a", qname2)
3306
self.assertEquals(qname1, qname1)
3307
self.assertEquals(qname1, qname2)
3304
self.assertEqual(qname1, "{myns}a")
3305
self.assertEqual("{myns}a", qname2)
3306
self.assertEqual(qname1, qname1)
3307
self.assertEqual(qname1, qname2)
3309
3309
def test_qname_attribute_getset(self):
3310
3310
etree = self.etree
3323
3323
a = etree.Element(qname)
3324
3324
a.attrib[qname] = "value"
3326
self.assertEquals(a.attrib[qname], "value")
3327
self.assertEquals(a.attrib.get(qname), "value")
3326
self.assertEqual(a.attrib[qname], "value")
3327
self.assertEqual(a.attrib.get(qname), "value")
3329
self.assertEquals(a.attrib["{myns}a"], "value")
3330
self.assertEquals(a.attrib.get("{myns}a"), "value")
3329
self.assertEqual(a.attrib["{myns}a"], "value")
3330
self.assertEqual(a.attrib.get("{myns}a"), "value")
3332
3332
def test_qname_attribute_resolve(self):
3333
3333
etree = self.etree
3381
3381
root = parser.close()
3383
self.assertEquals(root.tag, "root")
3384
self.assertEquals(root[0].tag, "a")
3385
self.assertEquals(root[0].get("test"), "works")
3383
self.assertEqual(root.tag, "root")
3384
self.assertEqual(root[0].tag, "a")
3385
self.assertEqual(root[0].get("test"), "works")
3387
3387
def test_feed_parser_unicode(self):
3388
3388
parser = self.etree.XMLParser()
3396
3396
root = parser.close()
3398
self.assertEquals(root.tag, "root")
3399
self.assertEquals(root[0].tag, "a")
3400
self.assertEquals(root[0].get("test"), "works")
3398
self.assertEqual(root.tag, "root")
3399
self.assertEqual(root[0].tag, "a")
3400
self.assertEqual(root[0].get("test"), "works")
3402
3402
required_versions_ET['test_feed_parser_error_close_empty'] = (1,3)
3403
3403
def test_feed_parser_error_close_empty(self):
3439
3439
except ParseError:
3440
3440
e = sys.exc_info()[1]
3441
self.assertNotEquals(None, e.code)
3442
self.assertNotEquals(0, e.code)
3443
self.assert_(isinstance(e.position, tuple))
3444
self.assert_(e.position >= (0, 0))
3441
self.assertNotEqual(None, e.code)
3442
self.assertNotEqual(0, e.code)
3443
self.assertTrue(isinstance(e.position, tuple))
3444
self.assertTrue(e.position >= (0, 0))
3446
3446
# parser target interface
3476
3476
parser.feed("<TAG/>")
3477
3477
done = parser.close()
3479
self.assertEquals("DONE", done)
3480
self.assertEquals(["start", "end"], events)
3479
self.assertEqual("DONE", done)
3480
self.assertEqual(["start", "end"], events)
3482
3482
def test_elementtree_parser_target(self):
3483
assertEquals = self.assertEquals
3483
assertEqual = self.assertEqual
3484
3484
assertFalse = self.assertFalse
3485
3485
Element = self.etree.Element
3500
3500
tree = self.etree.ElementTree()
3501
3501
tree.parse(BytesIO("<TAG/>"), parser=parser)
3503
self.assertEquals("DONE", tree.getroot().tag)
3504
self.assertEquals(["start", "end"], events)
3503
self.assertEqual("DONE", tree.getroot().tag)
3504
self.assertEqual(["start", "end"], events)
3506
3506
def test_parser_target_attrib(self):
3507
assertEquals = self.assertEquals
3507
assertEqual = self.assertEqual
3510
3510
class Target(object):
3511
3511
def start(self, tag, attrib):
3512
3512
events.append("start-" + tag)
3513
3513
for name, value in attrib.items():
3514
assertEquals(tag + name, value)
3514
assertEqual(tag + name, value)
3515
3515
def end(self, tag):
3516
3516
events.append("end-" + tag)
3517
3517
def close(self):
3522
3522
parser.feed('<root a="roota" b="rootb"><sub c="subc"/></root>')
3523
3523
done = parser.close()
3525
self.assertEquals("DONE", done)
3526
self.assertEquals(["start-root", "start-sub", "end-sub", "end-root"],
3525
self.assertEqual("DONE", done)
3526
self.assertEqual(["start-root", "start-sub", "end-sub", "end-root"],
3529
3529
def test_parser_target_data(self):
3543
3543
parser.feed('<root>A<sub/>B</root>')
3544
3544
done = parser.close()
3546
self.assertEquals("DONE", done)
3547
self.assertEquals(["start-root", "data-A", "start-sub",
3546
self.assertEqual("DONE", done)
3547
self.assertEqual(["start-root", "data-A", "start-sub",
3548
3548
"end-sub", "data-B", "end-root"],
3581
3581
parser.feed(dtd+'<root><sub/><sub>this is &ent;</sub><sub/></root>')
3582
3582
done = parser.close()
3584
self.assertEquals("DONE", done)
3585
self.assertEquals(["start-root", "start-sub", "end-sub", "start-sub",
3584
self.assertEqual("DONE", done)
3585
self.assertEqual(["start-root", "start-sub", "end-sub", "start-sub",
3586
3586
"data-this is an entity",
3587
3587
"end-sub", "start-sub", "end-sub", "end-root"],
3620
3620
def test_treebuilder(self):
3621
3621
builder = self.etree.TreeBuilder()
3622
3622
el = builder.start("root", {'a':'A', 'b':'B'})
3623
self.assertEquals("root", el.tag)
3624
self.assertEquals({'a':'A', 'b':'B'}, el.attrib)
3623
self.assertEqual("root", el.tag)
3624
self.assertEqual({'a':'A', 'b':'B'}, el.attrib)
3625
3625
builder.data("ROOTTEXT")
3626
3626
el = builder.start("child", {'x':'X', 'y':'Y'})
3627
self.assertEquals("child", el.tag)
3628
self.assertEquals({'x':'X', 'y':'Y'}, el.attrib)
3627
self.assertEqual("child", el.tag)
3628
self.assertEqual({'x':'X', 'y':'Y'}, el.attrib)
3629
3629
builder.data("CHILDTEXT")
3630
3630
el = builder.end("child")
3631
self.assertEquals("child", el.tag)
3632
self.assertEquals({'x':'X', 'y':'Y'}, el.attrib)
3633
self.assertEquals("CHILDTEXT", el.text)
3634
self.assertEquals(None, el.tail)
3631
self.assertEqual("child", el.tag)
3632
self.assertEqual({'x':'X', 'y':'Y'}, el.attrib)
3633
self.assertEqual("CHILDTEXT", el.text)
3634
self.assertEqual(None, el.tail)
3635
3635
builder.data("CHILDTAIL")
3636
3636
root = builder.end("root")
3638
self.assertEquals("root", root.tag)
3639
self.assertEquals("ROOTTEXT", root.text)
3640
self.assertEquals("CHILDTEXT", root[0].text)
3641
self.assertEquals("CHILDTAIL", root[0].tail)
3638
self.assertEqual("root", root.tag)
3639
self.assertEqual("ROOTTEXT", root.text)
3640
self.assertEqual("CHILDTEXT", root[0].text)
3641
self.assertEqual("CHILDTAIL", root[0].tail)
3643
3643
def test_treebuilder_target(self):
3644
3644
parser = self.etree.XMLParser(target=self.etree.TreeBuilder())
3645
3645
parser.feed('<root>ROOTTEXT<child>CHILDTEXT</child>CHILDTAIL</root>')
3646
3646
root = parser.close()
3648
self.assertEquals("root", root.tag)
3649
self.assertEquals("ROOTTEXT", root.text)
3650
self.assertEquals("CHILDTEXT", root[0].text)
3651
self.assertEquals("CHILDTAIL", root[0].tail)
3648
self.assertEqual("root", root.tag)
3649
self.assertEqual("ROOTTEXT", root.text)
3650
self.assertEqual("CHILDTEXT", root[0].text)
3651
self.assertEqual("CHILDTAIL", root[0].tail)
3653
3653
# helper methods
3684
3684
if isinstance(expected, unicode):
3685
3685
expected = expected.encode(encoding)
3686
self.assertEquals(expected, self._writeElement(element, encoding))
3687
self.assertEquals(expected, self._writeElementFile(element, encoding))
3686
self.assertEqual(expected, self._writeElement(element, encoding))
3687
self.assertEqual(expected, self._writeElementFile(element, encoding))
3689
3689
def assertEncodingDeclaration(self, result, encoding):
3690
3690
"Checks if the result XML byte string specifies the encoding."
3693
3693
has_encoding = re.compile(enc_re).match
3695
3695
has_encoding = re.compile(_bytes(enc_re)).match
3696
self.assert_(has_encoding(result))
3696
self.assertTrue(has_encoding(result))
3697
3697
result_encoding = has_encoding(result).group(1)
3698
self.assertEquals(result_encoding.upper(), encoding.upper())
3698
self.assertEqual(result_encoding.upper(), encoding.upper())
3700
3700
def _rootstring(self, tree):
3701
3701
return self.etree.tostring(tree.getroot()).replace(
3705
3705
self._check_element(tree.getroot())
3707
3707
def _check_element(self, element):
3708
self.assert_(hasattr(element, 'tag'))
3709
self.assert_(hasattr(element, 'attrib'))
3710
self.assert_(hasattr(element, 'text'))
3711
self.assert_(hasattr(element, 'tail'))
3708
self.assertTrue(hasattr(element, 'tag'))
3709
self.assertTrue(hasattr(element, 'attrib'))
3710
self.assertTrue(hasattr(element, 'text'))
3711
self.assertTrue(hasattr(element, 'tail'))
3712
3712
self._check_string(element.tag)
3713
3713
self._check_mapping(element.attrib)
3714
3714
if element.text != None:
added
removed
src/lxml/tests/test_elementtree.py
