1
2
3 """
4 Tests specific to the extended etree API
5
6 Tests that apply to the general ElementTree API should go into
7 test_elementtree
8 """
9
10
11 import unittest, copy, sys, operator
12
13 from common_imports import etree, StringIO, HelperTestCase, fileInTestDir
14 from common_imports import SillyFileLike, canonicalize, doctest
15
16 print
17 print "TESTED VERSION:", etree.__version__
18 print " Python: ", sys.version_info
19 print " lxml.etree: ", etree.LXML_VERSION
20 print " libxml used: ", etree.LIBXML_VERSION
21 print " libxml compiled: ", etree.LIBXML_COMPILED_VERSION
22 print " libxslt used: ", etree.LIBXSLT_VERSION
23 print " libxslt compiled: ", etree.LIBXSLT_COMPILED_VERSION
24 print
25
26 try:
27 sorted
28 except NameError:
29
31 seq = list(seq)
32 seq.sort()
33 return seq
34
36 """Tests only for etree, not ElementTree"""
37 etree = etree
38
49
58
65
67 Element = self.etree.Element
68 el = Element('name')
69 self.assertRaises(ValueError, Element, '{}')
70 self.assertRaises(ValueError, setattr, el, 'tag', '{}')
71
72 self.assertRaises(ValueError, Element, '{test}')
73 self.assertRaises(ValueError, setattr, el, 'tag', '{test}')
74
82
84 Element = self.etree.Element
85 self.assertRaises(ValueError, Element, "p'name")
86 self.assertRaises(ValueError, Element, 'p"name')
87
88 self.assertRaises(ValueError, Element, "{test}p'name")
89 self.assertRaises(ValueError, Element, '{test}p"name')
90
91 el = Element('name')
92 self.assertRaises(ValueError, setattr, el, 'tag', "p'name")
93 self.assertRaises(ValueError, setattr, el, 'tag', 'p"name')
94
96 Element = self.etree.Element
97 self.assertRaises(ValueError, Element, ' name ')
98 self.assertRaises(ValueError, Element, 'na me')
99 self.assertRaises(ValueError, Element, '{test} name')
100
101 el = Element('name')
102 self.assertRaises(ValueError, setattr, el, 'tag', ' name ')
103
111
119
121 Element = self.etree.Element
122 SubElement = self.etree.SubElement
123
124 el = Element('name')
125 self.assertRaises(ValueError, SubElement, el, "p'name")
126 self.assertRaises(ValueError, SubElement, el, "{test}p'name")
127
128 self.assertRaises(ValueError, SubElement, el, 'p"name')
129 self.assertRaises(ValueError, SubElement, el, '{test}p"name')
130
139
141 QName = self.etree.QName
142 self.assertRaises(ValueError, QName, '')
143 self.assertRaises(ValueError, QName, 'test', '')
144
146 QName = self.etree.QName
147 self.assertRaises(ValueError, QName, 'p:name')
148 self.assertRaises(ValueError, QName, 'test', 'p:name')
149
151 QName = self.etree.QName
152 self.assertRaises(ValueError, QName, ' name ')
153 self.assertRaises(ValueError, QName, 'na me')
154 self.assertRaises(ValueError, QName, 'test', ' name')
155
157
158 etree = self.etree
159 qname = etree.QName('http://myns', 'a')
160 a = etree.Element(qname, nsmap={'p' : 'http://myns'})
161 a.text = qname
162
163 self.assertEquals("p:a", a.text)
164
170
178
192
194 root = self.etree.XML('<doc one="One" two="Two"/>')
195 self.assertRaises(KeyError, root.attrib.pop, 'NONE')
196
197 self.assertEquals('One', root.attrib['one'])
198 self.assertEquals('Two', root.attrib['two'])
199
201 root = self.etree.XML('<doc one="One" two="Two"/>')
202 self.assertEquals('Three', root.attrib.pop('three', 'Three'))
203
207
209 root = self.etree.XML('<doc one="One" two="Two"/>')
210 self.assertRaises(TypeError, root.attrib.pop, 'One', None, None)
211
213
214 Element = self.etree.Element
215 SubElement = self.etree.SubElement
216 ProcessingInstruction = self.etree.ProcessingInstruction
217
218 a = Element('a')
219 a.append(ProcessingInstruction('foo', 'some more text'))
220 self.assertEquals(a[0].target, 'foo')
221 self.assertEquals(a[0].text, 'some more text')
222
224 XML = self.etree.XML
225 root = XML("<test><?mypi my test ?></test>")
226 self.assertEquals(root[0].target, "mypi")
227 self.assertEquals(root[0].text, "my test ")
228
230
231 ProcessingInstruction = self.etree.ProcessingInstruction
232
233 a = ProcessingInstruction("PI", "ONE")
234 b = copy.deepcopy(a)
235 b.text = "ANOTHER"
236
237 self.assertEquals('ONE', a.text)
238 self.assertEquals('ANOTHER', b.text)
239
251
261
263
264 parse = self.etree.parse
265
266 f = StringIO('<a><b></c></b></a>')
267 self.assertRaises(SyntaxError, parse, f)
268 f.close()
269
281
300
305
307 parse = self.etree.parse
308
309 f = StringIO('<a><b></c></b></a>')
310 self.etree.clearErrorLog()
311 try:
312 parse(f)
313 logs = None
314 except SyntaxError, e:
315 logs = e.error_log
316 f.close()
317 self.assert_([ log for log in logs
318 if 'mismatch' in log.message ])
319 self.assert_([ log for log in logs
320 if 'PARSER' in log.domain_name])
321 self.assert_([ log for log in logs
322 if 'TAG_NAME_MISMATCH' in log.type_name ])
323 self.assert_([ log for log in logs
324 if 1 == log.line ])
325 self.assert_([ log for log in logs
326 if 15 == log.column ])
327
334
347
358
364
366 iterparse = self.etree.iterparse
367 f = StringIO("""
368 <a> \n \n <b> b test </b> \n
369
370 \n\t <c> \n </c> </a> \n """)
371 iterator = iterparse(f, remove_blank_text=True)
372 text = [ (element.text, element.tail)
373 for event, element in iterator ]
374 self.assertEquals(
375 [(" b test ", None), (" \n ", None), (None, None)],
376 text)
377
379 iterparse = self.etree.iterparse
380 f = StringIO('<a><b><d/></b><c/></a>')
381
382 iterator = iterparse(f, tag="b", events=('start', 'end'))
383 events = list(iterator)
384 root = iterator.root
385 self.assertEquals(
386 [('start', root[0]), ('end', root[0])],
387 events)
388
390 iterparse = self.etree.iterparse
391 f = StringIO('<a><b><d/></b><c/></a>')
392
393 iterator = iterparse(f, tag="*", events=('start', 'end'))
394 events = list(iterator)
395 self.assertEquals(
396 8,
397 len(events))
398
400 text = u'Søk på nettet'
401 wrong_declaration = "<?xml version='1.0' encoding='UTF-8'?>"
402 xml_latin1 = (u'%s<a>%s</a>' % (wrong_declaration, text)
403 ).encode('iso-8859-1')
404
405 self.assertRaises(self.etree.ParseError,
406 list, self.etree.iterparse(StringIO(xml_latin1)))
407
408 iterator = self.etree.iterparse(StringIO(xml_latin1),
409 encoding="iso-8859-1")
410 self.assertEquals(1, len(list(iterator)))
411
412 a = iterator.root
413 self.assertEquals(a.text, text)
414
418
420 assertEquals = self.assertEquals
421 assertFalse = self.assertFalse
422
423 events = []
424 class Target(object):
425 def start(self, tag, attrib):
426 events.append("start")
427 assertFalse(attrib)
428 assertEquals("TAG", tag)
429 def end(self, tag):
430 events.append("end")
431 assertEquals("TAG", tag)
432 def close(self):
433 return "DONE"
434
435 parser = self.etree.XMLParser(target=Target())
436 tree = self.etree.ElementTree()
437
438 self.assertRaises(TypeError,
439 tree.parse, StringIO("<TAG/>"), parser=parser)
440 self.assertEquals(["start", "end"], events)
441
451
461
470
480
482 iterwalk = self.etree.iterwalk
483 root = self.etree.XML('<a><b></b><c/></a>')
484
485 iterator = iterwalk(root, events=('start','end'))
486 events = list(iterator)
487 self.assertEquals(
488 [('start', root), ('start', root[0]), ('end', root[0]),
489 ('start', root[1]), ('end', root[1]), ('end', root)],
490 events)
491
502
504 iterwalk = self.etree.iterwalk
505 root = self.etree.XML('<a xmlns="ns1"><b><c xmlns="ns2"/></b></a>')
506
507 attr_name = '{testns}bla'
508 events = []
509 iterator = iterwalk(root, events=('start','end','start-ns','end-ns'))
510 for event, elem in iterator:
511 events.append(event)
512 if event == 'start':
513 if elem.tag != '{ns1}a':
514 elem.set(attr_name, 'value')
515
516 self.assertEquals(
517 ['start-ns', 'start', 'start', 'start-ns', 'start',
518 'end', 'end-ns', 'end', 'end', 'end-ns'],
519 events)
520
521 self.assertEquals(
522 None,
523 root.get(attr_name))
524 self.assertEquals(
525 'value',
526 root[0].get(attr_name))
527
529 iterwalk = self.etree.iterwalk
530 root = self.etree.XML('<a><b><d/></b><c/></a>')
531
532 counts = []
533 for event, elem in iterwalk(root):
534 counts.append(len(list(elem.getiterator())))
535 self.assertEquals(
536 [1,2,1,4],
537 counts)
538
540 parse = self.etree.parse
541 parser = self.etree.XMLParser(dtd_validation=True)
542 assertEqual = self.assertEqual
543 test_url = u"__nosuch.dtd"
544
545 class MyResolver(self.etree.Resolver):
546 def resolve(self, url, id, context):
547 assertEqual(url, test_url)
548 return self.resolve_string(
549 u'''<!ENTITY myentity "%s">
550 <!ELEMENT doc ANY>''' % url, context)
551
552 parser.resolvers.add(MyResolver())
553
554 xml = u'<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>' % test_url
555 tree = parse(StringIO(xml), parser)
556 root = tree.getroot()
557 self.assertEquals(root.text, test_url)
558
560 parse = self.etree.parse
561 parser = self.etree.XMLParser(attribute_defaults=True)
562 assertEqual = self.assertEqual
563 test_url = u"__nosuch.dtd"
564
565 class MyResolver(self.etree.Resolver):
566 def resolve(self, url, id, context):
567 assertEqual(url, test_url)
568 return self.resolve_filename(
569 fileInTestDir('test.dtd'), context)
570
571 parser.resolvers.add(MyResolver())
572
573 xml = u'<!DOCTYPE a SYSTEM "%s"><a><b/></a>' % test_url
574 tree = parse(StringIO(xml), parser)
575 root = tree.getroot()
576 self.assertEquals(
577 root.attrib, {'default': 'valueA'})
578 self.assertEquals(
579 root[0].attrib, {'default': 'valueB'})
580
582 parse = self.etree.parse
583 parser = self.etree.XMLParser(load_dtd=True)
584 assertEqual = self.assertEqual
585 test_url = u"__nosuch.dtd"
586
587 class check(object):
588 resolved = False
589
590 class MyResolver(self.etree.Resolver):
591 def resolve(self, url, id, context):
592 assertEqual(url, test_url)
593 check.resolved = True
594 return self.resolve_empty(context)
595
596 parser.resolvers.add(MyResolver())
597
598 xml = u'<!DOCTYPE doc SYSTEM "%s"><doc>&myentity;</doc>' % test_url
599 self.assertRaises(etree.XMLSyntaxError, parse, StringIO(xml), parser)
600 self.assert_(check.resolved)
601
609
610 class MyResolver(self.etree.Resolver):
611 def resolve(self, url, id, context):
612 raise _LocalException
613
614 parser.resolvers.add(MyResolver())
615
616 xml = u'<!DOCTYPE doc SYSTEM "test"><doc>&myentity;</doc>'
617 self.assertRaises(_LocalException, parse, StringIO(xml), parser)
618
619 if etree.LIBXML_VERSION > (2,6,20):
636
652
659
661 Entity = self.etree.Entity
662 self.assertRaises(ValueError, Entity, 'a b c')
663 self.assertRaises(ValueError, Entity, 'a,b')
664 self.assertRaises(AssertionError, Entity, 'a\0b')
665 self.assertRaises(ValueError, Entity, '#abc')
666 self.assertRaises(ValueError, Entity, '#xxyz')
667
668
678
683
696
709
715
721
736
738 Element = self.etree.Element
739 PI = self.etree.PI
740 root = Element('root')
741 pi = PI('TARGET', 'TEXT')
742 pi.tail = "TAIL"
743
744 self.assertEquals('<root></root>',
745 self._writeElement(root))
746 root.addprevious(pi)
747 self.assertEquals('<?TARGET TEXT?>\n<root></root>',
748 self._writeElement(root))
749
764
777
792
805
820
833
834
836 XML = self.etree.XML
837
838 root = XML('<doc alpha="Alpha" beta="Beta" gamma="Gamma"/>')
839 values = root.values()
840 values.sort()
841 self.assertEquals(['Alpha', 'Beta', 'Gamma'], values)
842
843
853
854
869
870
880
881
897
898
909
910
921
922
927
928
930 self.assertRaises(TypeError, etree.dump, None)
931
933 ElementTree = self.etree.ElementTree
934
935 f = StringIO('<a xmlns:foo="http://www.infrae.com/ns/1"><foo:b/></a>')
936 doc = ElementTree(file=f)
937 a = doc.getroot()
938 self.assertEquals(
939 None,
940 a.prefix)
941 self.assertEquals(
942 'foo',
943 a[0].prefix)
944
946 ElementTree = self.etree.ElementTree
947
948 f = StringIO('<a xmlns="http://www.infrae.com/ns/1"><b/></a>')
949 doc = ElementTree(file=f)
950 a = doc.getroot()
951 self.assertEquals(
952 None,
953 a.prefix)
954 self.assertEquals(
955 None,
956 a[0].prefix)
957
978
980 XML = self.etree.XML
981
982 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
983 result = []
984 for el in root.iterchildren():
985 result.append(el.tag)
986 self.assertEquals(['one', 'two', 'three'], result)
987
989 XML = self.etree.XML
990
991 root = XML('<doc><one/><two>Two</two>Hm<three/></doc>')
992 result = []
993 for el in root.iterchildren(reversed=True):
994 result.append(el.tag)
995 self.assertEquals(['three', 'two', 'one'], result)
996
998 XML = self.etree.XML
999
1000 root = XML('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')
1001 result = []
1002 for el in root.iterchildren(tag='two'):
1003 result.append(el.text)
1004 self.assertEquals(['Two', 'Bla'], result)
1005
1007 XML = self.etree.XML
1008
1009 root = XML('<doc><one/><two>Two</two>Hm<two>Bla</two></doc>')
1010 result = []
1011 for el in root.iterchildren(reversed=True, tag='two'):
1012 result.append(el.text)
1013 self.assertEquals(['Bla', 'Two'], result)
1014
1016 Element = self.etree.Element
1017 SubElement = self.etree.SubElement
1018
1019 a = Element('a')
1020 b = SubElement(a, 'b')
1021 c = SubElement(a, 'c')
1022 d = SubElement(b, 'd')
1023 self.assertEquals(
1024 [],
1025 list(a.iterancestors()))
1026 self.assertEquals(
1027 [a],
1028 list(b.iterancestors()))
1029 self.assertEquals(
1030 a,
1031 c.iterancestors().next())
1032 self.assertEquals(
1033 [b, a],
1034 list(d.iterancestors()))
1035
1047
1064
1085
1103
1120
1138
1140 Element = self.etree.Element
1141 SubElement = self.etree.SubElement
1142
1143 a = Element('a')
1144 b = SubElement(a, 'b')
1145 c = SubElement(a, 'c')
1146 d = SubElement(b, 'd')
1147 self.assertEquals(
1148 [],
1149 list(a.itersiblings()))
1150 self.assertEquals(
1151 [c],
1152 list(b.itersiblings()))
1153 self.assertEquals(
1154 c,
1155 b.itersiblings().next())
1156 self.assertEquals(
1157 [],
1158 list(c.itersiblings()))
1159 self.assertEquals(
1160 [b],
1161 list(c.itersiblings(preceding=True)))
1162 self.assertEquals(
1163 [],
1164 list(b.itersiblings(preceding=True)))
1165
1167 Element = self.etree.Element
1168 SubElement = self.etree.SubElement
1169
1170 a = Element('a')
1171 b = SubElement(a, 'b')
1172 c = SubElement(a, 'c')
1173 d = SubElement(b, 'd')
1174 self.assertEquals(
1175 [],
1176 list(a.itersiblings(tag='XXX')))
1177 self.assertEquals(
1178 [c],
1179 list(b.itersiblings(tag='c')))
1180 self.assertEquals(
1181 [b],
1182 list(c.itersiblings(preceding=True, tag='b')))
1183 self.assertEquals(
1184 [],
1185 list(c.itersiblings(preceding=True, tag='c')))
1186
1188 parseid = self.etree.parseid
1189 XML = self.etree.XML
1190 xml_text = '''
1191 <!DOCTYPE document [
1192 <!ELEMENT document (h1,p)*>
1193 <!ELEMENT h1 (#PCDATA)>
1194 <!ATTLIST h1 myid ID #REQUIRED>
1195 <!ELEMENT p (#PCDATA)>
1196 <!ATTLIST p someid ID #REQUIRED>
1197 ]>
1198 <document>
1199 <h1 myid="chapter1">...</h1>
1200 <p id="note1" class="note">...</p>
1201 <p>Regular paragraph.</p>
1202 <p xml:id="xmlid">XML:ID paragraph.</p>
1203 <p someid="warn1" class="warning">...</p>
1204 </document>
1205 '''
1206
1207 tree, dic = parseid(StringIO(xml_text))
1208 root = tree.getroot()
1209 root2 = XML(xml_text)
1210 self.assertEquals(self._writeElement(root),
1211 self._writeElement(root2))
1212 expected = {
1213 "chapter1" : root[0],
1214 "xmlid" : root[3],
1215 "warn1" : root[4]
1216 }
1217 self.assert_("chapter1" in dic)
1218 self.assert_("warn1" in dic)
1219 self.assert_("xmlid" in dic)
1220 self._checkIDDict(dic, expected)
1221
1223 XMLDTDID = self.etree.XMLDTDID
1224 XML = self.etree.XML
1225 xml_text = '''
1226 <!DOCTYPE document [
1227 <!ELEMENT document (h1,p)*>
1228 <!ELEMENT h1 (#PCDATA)>
1229 <!ATTLIST h1 myid ID #REQUIRED>
1230 <!ELEMENT p (#PCDATA)>
1231 <!ATTLIST p someid ID #REQUIRED>
1232 ]>
1233 <document>
1234 <h1 myid="chapter1">...</h1>
1235 <p id="note1" class="note">...</p>
1236 <p>Regular paragraph.</p>
1237 <p xml:id="xmlid">XML:ID paragraph.</p>
1238 <p someid="warn1" class="warning">...</p>
1239 </document>
1240 '''
1241
1242 root, dic = XMLDTDID(xml_text)
1243 root2 = XML(xml_text)
1244 self.assertEquals(self._writeElement(root),
1245 self._writeElement(root2))
1246 expected = {
1247 "chapter1" : root[0],
1248 "xmlid" : root[3],
1249 "warn1" : root[4]
1250 }
1251 self.assert_("chapter1" in dic)
1252 self.assert_("warn1" in dic)
1253 self.assert_("xmlid" in dic)
1254 self._checkIDDict(dic, expected)
1255
1257 XMLDTDID = self.etree.XMLDTDID
1258 XML = self.etree.XML
1259 xml_text = '''
1260 <document>
1261 <h1 myid="chapter1">...</h1>
1262 <p id="note1" class="note">...</p>
1263 <p>Regular paragraph.</p>
1264 <p someid="warn1" class="warning">...</p>
1265 </document>
1266 '''
1267
1268 root, dic = XMLDTDID(xml_text)
1269 root2 = XML(xml_text)
1270 self.assertEquals(self._writeElement(root),
1271 self._writeElement(root2))
1272 expected = {}
1273 self._checkIDDict(dic, expected)
1274
1276 self.assertEquals(dic, expected)
1277 self.assertEquals(len(dic),
1278 len(expected))
1279 self.assertEquals(sorted(dic.items()),
1280 sorted(expected.items()))
1281 self.assertEquals(sorted(dic.iteritems()),
1282 sorted(expected.iteritems()))
1283 self.assertEquals(sorted(dic.keys()),
1284 sorted(expected.keys()))
1285 self.assertEquals(sorted(dic.iterkeys()),
1286 sorted(expected.iterkeys()))
1287 self.assertEquals(sorted(dic.values()),
1288 sorted(expected.values()))
1289 self.assertEquals(sorted(dic.itervalues()),
1290 sorted(expected.itervalues()))
1291
1293 etree = self.etree
1294
1295 r = {'foo': 'http://ns.infrae.com/foo'}
1296 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1297 self.assertEquals(
1298 'foo',
1299 e.prefix)
1300 self.assertEquals(
1301 '<foo:bar xmlns:foo="http://ns.infrae.com/foo"></foo:bar>',
1302 self._writeElement(e))
1303
1305 etree = self.etree
1306
1307 r = {None: 'http://ns.infrae.com/foo'}
1308 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1309 self.assertEquals(
1310 None,
1311 e.prefix)
1312 self.assertEquals(
1313 '{http://ns.infrae.com/foo}bar',
1314 e.tag)
1315 self.assertEquals(
1316 '<bar xmlns="http://ns.infrae.com/foo"></bar>',
1317 self._writeElement(e))
1318
1320 etree = self.etree
1321
1322 r = {None: 'http://ns.infrae.com/foo',
1323 'hoi': 'http://ns.infrae.com/hoi'}
1324 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1325 e.set('{http://ns.infrae.com/hoi}test', 'value')
1326 self.assertEquals(
1327 '<bar xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi" hoi:test="value"></bar>',
1328 self._writeElement(e))
1329
1331 etree = self.etree
1332 r = {None: 'http://ns.infrae.com/foo',
1333 'hoi': 'http://ns.infrae.com/hoi'}
1334 e = etree.Element('{http://ns.infrae.com/foo}z', nsmap=r)
1335 tree = etree.ElementTree(element=e)
1336 etree.SubElement(e, '{http://ns.infrae.com/hoi}x')
1337 self.assertEquals(
1338 '<z xmlns="http://ns.infrae.com/foo" xmlns:hoi="http://ns.infrae.com/hoi"><hoi:x></hoi:x></z>',
1339 self._writeElement(e))
1340
1342 etree = self.etree
1343
1344 r = {None: 'http://ns.infrae.com/foo'}
1345 e1 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1346 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1347
1348 e1.append(e2)
1349
1350 self.assertEquals(
1351 None,
1352 e1.prefix)
1353 self.assertEquals(
1354 None,
1355 e1[0].prefix)
1356 self.assertEquals(
1357 '{http://ns.infrae.com/foo}bar',
1358 e1.tag)
1359 self.assertEquals(
1360 '{http://ns.infrae.com/foo}bar',
1361 e1[0].tag)
1362
1364 etree = self.etree
1365
1366 r = {None: 'http://ns.infrae.com/BAR'}
1367 e1 = etree.Element('{http://ns.infrae.com/BAR}bar', nsmap=r)
1368 e2 = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1369
1370 e1.append(e2)
1371
1372 self.assertEquals(
1373 None,
1374 e1.prefix)
1375 self.assertNotEquals(
1376 None,
1377 e2.prefix)
1378 self.assertEquals(
1379 '{http://ns.infrae.com/BAR}bar',
1380 e1.tag)
1381 self.assertEquals(
1382 '{http://ns.infrae.com/foo}bar',
1383 e2.tag)
1384
1386 ns_href = "http://a.b.c"
1387 one = self.etree.fromstring(
1388 '<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href)
1389 baz = one[0][0]
1390
1391 two = self.etree.fromstring(
1392 '<root xmlns:ns="%s"/>' % ns_href)
1393 two.append(baz)
1394 del one
1395
1396 self.assertEquals('{%s}baz' % ns_href, baz.tag)
1397 self.assertEquals(
1398 '<root xmlns:ns="%s"><ns:baz/></root>' % ns_href,
1399 self.etree.tostring(two))
1400
1402 parse = self.etree.parse
1403 tostring = self.etree.tostring
1404
1405 ns_href = "http://a.b.c"
1406 one = parse(
1407 StringIO('<foo><bar xmlns:ns="%s"><ns:baz/></bar></foo>' % ns_href))
1408 baz = one.getroot()[0][0]
1409
1410 parsed = parse(StringIO( tostring(baz) )).getroot()
1411 self.assertEquals('{%s}baz' % ns_href, parsed.tag)
1412
1414 etree = self.etree
1415
1416 r = {None: 'http://ns.infrae.com/foo',
1417 'hoi': 'http://ns.infrae.com/hoi'}
1418 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=r)
1419 self.assertEquals(
1420 r,
1421 e.nsmap)
1422
1424 etree = self.etree
1425
1426 re = {None: 'http://ns.infrae.com/foo',
1427 'hoi': 'http://ns.infrae.com/hoi'}
1428 e = etree.Element('{http://ns.infrae.com/foo}bar', nsmap=re)
1429
1430 rs = {None: 'http://ns.infrae.com/honk',
1431 'top': 'http://ns.infrae.com/top'}
1432 s = etree.SubElement(e, '{http://ns.infrae.com/honk}bar', nsmap=rs)
1433
1434 r = re.copy()
1435 r.update(rs)
1436 self.assertEquals(
1437 re,
1438 e.nsmap)
1439 self.assertEquals(
1440 r,
1441 s.nsmap)
1442
1444 Element = self.etree.Element
1445 SubElement = self.etree.SubElement
1446
1447 a = Element('{a}a')
1448 b = SubElement(a, '{a}b')
1449 c = SubElement(a, '{a}c')
1450 d = SubElement(b, '{b}d')
1451 e = SubElement(c, '{a}e')
1452 f = SubElement(c, '{b}f')
1453
1454 self.assertEquals(
1455 [a],
1456 list(a.getiterator('{a}a')))
1457 self.assertEquals(
1458 [],
1459 list(a.getiterator('{b}a')))
1460 self.assertEquals(
1461 [],
1462 list(a.getiterator('a')))
1463 self.assertEquals(
1464 [f],
1465 list(c.getiterator('{b}*')))
1466 self.assertEquals(
1467 [d, f],
1468 list(a.getiterator('{b}*')))
1469
1494
1510
1527
1528 - def test_itertext(self):
1529
1530 XML = self.etree.XML
1531 root = XML("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>")
1532
1533 text = list(root.itertext())
1534 self.assertEquals(["RTEXT", "ATAIL", "CTEXT", "CTAIL"],
1535 text)
1536
1538
1539 XML = self.etree.XML
1540 root = XML("<root>RTEXT<a></a>ATAIL<b/><c>CTEXT</c>CTAIL</root>")
1541
1542 text = list(root[2].itertext())
1543 self.assertEquals(["CTEXT"],
1544 text)
1545
1552
1559
1568
1570 XML = self.etree.XML
1571 root = XML('<a xmlns:x="X" xmlns:y="Y"><x:b><c/></x:b><b/><c><x:b/><b/></c><b/></a>')
1572 self.assertEquals(len(root.findall(".//{X}b")), 2)
1573 self.assertEquals(len(root.findall(".//{X}*")), 2)
1574 self.assertEquals(len(root.findall(".//b")), 3)
1575
1577 etree = self.etree
1578 e = etree.Element('foo')
1579 for i in range(10):
1580 etree.SubElement(e, 'a%s' % i)
1581 for i in range(10):
1582 self.assertEquals(
1583 i,
1584 e.index(e[i]))
1585 self.assertEquals(
1586 3, e.index(e[3], 3))
1587 self.assertRaises(
1588 ValueError, e.index, e[3], 4)
1589 self.assertRaises(
1590 ValueError, e.index, e[3], 0, 2)
1591 self.assertRaises(
1592 ValueError, e.index, e[8], 0, -3)
1593 self.assertRaises(
1594 ValueError, e.index, e[8], -5, -3)
1595 self.assertEquals(
1596 8, e.index(e[8], 0, -1))
1597 self.assertEquals(
1598 8, e.index(e[8], -12, -1))
1599 self.assertEquals(
1600 0, e.index(e[0], -12, -1))
1601
1603 etree = self.etree
1604 e = etree.Element('foo')
1605 for i in range(10):
1606 el = etree.SubElement(e, 'a%s' % i)
1607 el.text = "text%d" % i
1608 el.tail = "tail%d" % i
1609
1610 child0 = e[0]
1611 child1 = e[1]
1612 child2 = e[2]
1613
1614 e.replace(e[0], e[1])
1615 self.assertEquals(
1616 9, len(e))
1617 self.assertEquals(
1618 child1, e[0])
1619 self.assertEquals(
1620 child1.text, "text1")
1621 self.assertEquals(
1622 child1.tail, "tail1")
1623 self.assertEquals(
1624 child0.tail, "tail0")
1625 self.assertEquals(
1626 child2, e[1])
1627
1628 e.replace(e[-1], e[0])
1629 self.assertEquals(
1630 child1, e[-1])
1631 self.assertEquals(
1632 child1.text, "text1")
1633 self.assertEquals(
1634 child1.tail, "tail1")
1635 self.assertEquals(
1636 child2, e[0])
1637
1639 etree = self.etree
1640 e = etree.Element('foo')
1641 for i in range(10):
1642 etree.SubElement(e, 'a%s' % i)
1643
1644 new_element = etree.Element("test")
1645 new_element.text = "TESTTEXT"
1646 new_element.tail = "TESTTAIL"
1647 child1 = e[1]
1648 e.replace(e[0], new_element)
1649 self.assertEquals(
1650 new_element, e[0])
1651 self.assertEquals(
1652 "TESTTEXT",
1653 e[0].text)
1654 self.assertEquals(
1655 "TESTTAIL",
1656 e[0].tail)
1657 self.assertEquals(
1658 child1, e[1])
1659
1675
1693
1711
1729
1731 Element = self.etree.Element
1732 SubElement = self.etree.SubElement
1733 try:
1734 slice
1735 except NameError:
1736 print "slice() not found"
1737 return
1738
1739 a = Element('a')
1740 b = SubElement(a, 'b')
1741 c = SubElement(a, 'c')
1742 d = SubElement(a, 'd')
1743 e = SubElement(a, 'e')
1744
1745 x = Element('x')
1746 y = Element('y')
1747 z = Element('z')
1748
1749 self.assertRaises(
1750 ValueError,
1751 operator.setitem, a, slice(1,None,2), [x, y, z])
1752
1753 self.assertEquals(
1754 [b, c, d, e],
1755 list(a))
1756
1758 etree = self.etree
1759 root = etree.Element('foo')
1760 for i in range(3):
1761 element = etree.SubElement(root, 'a%s' % i)
1762 element.text = "text%d" % i
1763 element.tail = "tail%d" % i
1764
1765 elements = []
1766 for i in range(3):
1767 new_element = etree.Element("test%s" % i)
1768 new_element.text = "TEXT%s" % i
1769 new_element.tail = "TAIL%s" % i
1770 elements.append(new_element)
1771
1772 root.extend(elements)
1773
1774 self.assertEquals(
1775 ["a0", "a1", "a2", "test0", "test1", "test2"],
1776 [ el.tag for el in root ])
1777 self.assertEquals(
1778 ["text0", "text1", "text2", "TEXT0", "TEXT1", "TEXT2"],
1779 [ el.text for el in root ])
1780 self.assertEquals(
1781 ["tail0", "tail1", "tail2", "TAIL0", "TAIL1", "TAIL2"],
1782 [ el.tail for el in root ])
1783
1785 XML = self.etree.XML
1786 root = XML('''<?xml version="1.0"?>
1787 <root><test>
1788
1789 <bla/></test>
1790 </root>
1791 ''')
1792
1793 self.assertEquals(
1794 [2, 2, 4],
1795 [ el.sourceline for el in root.getiterator() ])
1796
1798 parse = self.etree.parse
1799 tree = parse(fileInTestDir('include/test_xinclude.xml'))
1800
1801 self.assertEquals(
1802 [1, 2, 3],
1803 [ el.sourceline for el in tree.getiterator() ])
1804
1813
1815 iterparse = self.etree.iterparse
1816 lines = [ el.sourceline for (event, el) in
1817 iterparse(fileInTestDir('include/test_xinclude.xml'),
1818 events=("start",)) ]
1819
1820 self.assertEquals(
1821 [1, 2, 3],
1822 lines)
1823
1833
1835 etree = self.etree
1836 root = etree.XML("<root/>", base_url="http://no/such/url")
1837 docinfo = root.getroottree().docinfo
1838 self.assertEquals(docinfo.URL, "http://no/such/url")
1839
1841 etree = self.etree
1842 tree = etree.parse(StringIO("<root/>"), base_url="http://no/such/url")
1843 docinfo = tree.docinfo
1844 self.assertEquals(docinfo.URL, "http://no/such/url")
1845
1847 etree = self.etree
1848 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'),
1849 base_url="http://no/such/url")
1850 docinfo = tree.docinfo
1851 self.assertEquals(docinfo.URL, "http://no/such/url")
1852
1854 etree = self.etree
1855 root = etree.HTML("<html/>", base_url="http://no/such/url")
1856 docinfo = root.getroottree().docinfo
1857 self.assertEquals(docinfo.URL, "http://no/such/url")
1858
1860 etree = self.etree
1861 xml_header = '<?xml version="1.0" encoding="ascii"?>'
1862 pub_id = "-//W3C//DTD XHTML 1.0 Transitional//EN"
1863 sys_id = "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"
1864 doctype_string = '<!DOCTYPE html PUBLIC "%s" "%s">' % (pub_id, sys_id)
1865
1866 xml = xml_header + doctype_string + '<html><body></body></html>'
1867
1868 tree = etree.parse(StringIO(xml))
1869 docinfo = tree.docinfo
1870 self.assertEquals(docinfo.encoding, "ascii")
1871 self.assertEquals(docinfo.xml_version, "1.0")
1872 self.assertEquals(docinfo.public_id, pub_id)
1873 self.assertEquals(docinfo.system_url, sys_id)
1874 self.assertEquals(docinfo.root_name, 'html')
1875 self.assertEquals(docinfo.doctype, doctype_string)
1876
1878 etree = self.etree
1879 xml_header = '<?xml version="1.0" encoding="UTF-8"?>'
1880 sys_id = "some.dtd"
1881 doctype_string = '<!DOCTYPE html SYSTEM "%s">' % sys_id
1882 xml = xml_header + doctype_string + '<html><body></body></html>'
1883
1884 tree = etree.parse(StringIO(xml))
1885 docinfo = tree.docinfo
1886 self.assertEquals(docinfo.encoding, "UTF-8")
1887 self.assertEquals(docinfo.xml_version, "1.0")
1888 self.assertEquals(docinfo.public_id, None)
1889 self.assertEquals(docinfo.system_url, sys_id)
1890 self.assertEquals(docinfo.root_name, 'html')
1891 self.assertEquals(docinfo.doctype, doctype_string)
1892
1894 etree = self.etree
1895 xml = '<html><body></body></html>'
1896 tree = etree.parse(StringIO(xml))
1897 docinfo = tree.docinfo
1898 self.assertEquals(docinfo.encoding, "UTF-8")
1899 self.assertEquals(docinfo.xml_version, "1.0")
1900 self.assertEquals(docinfo.public_id, None)
1901 self.assertEquals(docinfo.system_url, None)
1902 self.assertEquals(docinfo.root_name, 'html')
1903 self.assertEquals(docinfo.doctype, '')
1904
1906
1907 xml = '''\
1908 <!DOCTYPE test SYSTEM "test.dtd" [
1909 <!ENTITY entity "tasty">
1910 <!ELEMENT test (a)>
1911 <!ELEMENT a (#PCDATA)>
1912 ]>
1913 <test><a>test-test</a></test>\
1914 '''
1915 tree = self.etree.parse(StringIO(xml))
1916 self.assertEqual(self.etree.tostring(tree).replace(" ", ""),
1917 xml.replace(" ", ""))
1918
1920 Element = self.etree.Element
1921
1922 a = Element('a')
1923 self.assertRaises(AssertionError, setattr, a, "text", 'ha\0ho')
1924 self.assertRaises(AssertionError, setattr, a, "tail", 'ha\0ho')
1925
1926 self.assertRaises(AssertionError, Element, 'ha\0ho')
1927
1929 Element = self.etree.Element
1930
1931 a = Element('a')
1932 self.assertRaises(AssertionError, setattr, a, "text", u'ha\0ho')
1933 self.assertRaises(AssertionError, setattr, a, "tail", u'ha\0ho')
1934
1935 self.assertRaises(AssertionError, Element, u'ha\0ho')
1936
1938 Element = self.etree.Element
1939
1940 a = Element('a')
1941 self.assertRaises(AssertionError, setattr, a, "text", 'ha\x07ho')
1942 self.assertRaises(AssertionError, setattr, a, "text", 'ha\x02ho')
1943
1944 self.assertRaises(AssertionError, setattr, a, "tail", 'ha\x07ho')
1945 self.assertRaises(AssertionError, setattr, a, "tail", 'ha\x02ho')
1946
1947 self.assertRaises(AssertionError, Element, 'ha\x07ho')
1948 self.assertRaises(AssertionError, Element, 'ha\x02ho')
1949
1951 Element = self.etree.Element
1952
1953 a = Element('a')
1954 self.assertRaises(AssertionError, setattr, a, "text", u'ha\x07ho')
1955 self.assertRaises(AssertionError, setattr, a, "text", u'ha\x02ho')
1956
1957 self.assertRaises(AssertionError, setattr, a, "tail", u'ha\x07ho')
1958 self.assertRaises(AssertionError, setattr, a, "tail", u'ha\x02ho')
1959
1960 self.assertRaises(AssertionError, Element, u'ha\x07ho')
1961 self.assertRaises(AssertionError, Element, u'ha\x02ho')
1962
1976
1981
1999
2019
2021 tostring = self.etree.tostring
2022 Element = self.etree.Element
2023 SubElement = self.etree.SubElement
2024
2025 a = Element('a')
2026 a.text = "A"
2027 a.tail = "tail"
2028 b = SubElement(a, 'b')
2029 b.text = "B"
2030 b.tail = u"Søk på nettet"
2031 c = SubElement(a, 'c')
2032 c.text = "C"
2033
2034 result = tostring(a, method="text", encoding="UTF-16")
2035
2036 self.assertEquals(u'ABSøk på nettetCtail'.encode("UTF-16"),
2037 result)
2038
2051
2067
2071
2086
2104
2117
2119 tostring = self.etree.tostring
2120 Element = self.etree.Element
2121 SubElement = self.etree.SubElement
2122
2123 a = Element('a')
2124 b = SubElement(a, 'b')
2125 c = SubElement(a, 'c')
2126 d = SubElement(c, 'd')
2127 self.assert_(isinstance(tostring(b, encoding=unicode), unicode))
2128 self.assert_(isinstance(tostring(c, encoding=unicode), unicode))
2129 self.assertEquals('<b></b>',
2130 canonicalize(tostring(b, encoding=unicode)))
2131 self.assertEquals('<c><d></d></c>',
2132 canonicalize(tostring(c, encoding=unicode)))
2133
2138
2153
2155 tostring = self.etree.tostring
2156 Element = self.etree.Element
2157 SubElement = self.etree.SubElement
2158
2159 a = Element('a')
2160 b = SubElement(a, 'b')
2161 c = SubElement(a, 'c')
2162
2163 result = tostring(a, encoding=unicode)
2164 self.assertEquals(result, "<a><b/><c/></a>")
2165
2166 result = tostring(a, encoding=unicode, pretty_print=False)
2167 self.assertEquals(result, "<a><b/><c/></a>")
2168
2169 result = tostring(a, encoding=unicode, pretty_print=True)
2170 self.assertEquals(result, "<a>\n <b/>\n <c/>\n</a>\n")
2171
2172
2173
2183
2184
2187 filename = fileInTestDir('test_broken.xml')
2188 root = etree.XML('''\
2189 <doc xmlns:xi="http://www.w3.org/2001/XInclude">
2190 <xi:include href="%s" parse="text"/>
2191 </doc>
2192 ''' % filename)
2193 old_text = root.text
2194 content = open(filename).read()
2195 old_tail = root[0].tail
2196
2197 self.include( etree.ElementTree(root) )
2198 self.assertEquals(old_text + content + old_tail,
2199 root.text)
2200
2202 tree = etree.parse(fileInTestDir('include/test_xinclude.xml'))
2203 self.assertNotEquals(
2204 'a',
2205 tree.getroot()[1].tag)
2206
2207 self.include( tree )
2208
2209 self.assertEquals(
2210 'a',
2211 tree.getroot()[1].tag)
2212
2216
2217
2222
2223
2226 tree = self.parse('<a><b/></a>')
2227 f = StringIO()
2228 tree.write_c14n(f)
2229 s = f.getvalue()
2230 self.assertEquals('<a><b></b></a>',
2231 s)
2232
2234 suite = unittest.TestSuite()
2235 suite.addTests([unittest.makeSuite(ETreeOnlyTestCase)])
2236 suite.addTests([unittest.makeSuite(ETreeXIncludeTestCase)])
2237 suite.addTests([unittest.makeSuite(ElementIncludeTestCase)])
2238 suite.addTests([unittest.makeSuite(ETreeC14NTestCase)])
2239 suite.addTests(
2240 [doctest.DocFileSuite('../../../doc/tutorial.txt')])
2241 suite.addTests(
2242 [doctest.DocFileSuite('../../../doc/api.txt')])
2243 suite.addTests(
2244 [doctest.DocFileSuite('../../../doc/parsing.txt')])
2245 suite.addTests(
2246 [doctest.DocFileSuite('../../../doc/resolvers.txt')])
2247 return suite
2248
2249 if __name__ == '__main__':
2250 print 'to test use test.py %s' % __file__
2251