Debian Codegraph @

Lib/test/test_sax.py

raw
1 # regression test for SAX 2.0
2
3 from xml.sax import make_parser, ContentHandler, \
4 SAXException, SAXReaderNotAvailable, SAXParseException
5 import unittest
6 from unittest import mock
7 try:
8 make_parser()
9 except SAXReaderNotAvailable:
10 # don't try to test this module if we cannot create a parser
11 raise unittest.SkipTest("no XML parsers available")
12 from xml.sax.saxutils import XMLGenerator, escape, unescape, quoteattr, \
13 XMLFilterBase, prepare_input_source
14 from xml.sax.expatreader import create_parser
15 from xml.sax.handler import (feature_namespaces, feature_external_ges,
16 LexicalHandler)
17 from xml.sax.xmlreader import InputSource, AttributesImpl, AttributesNSImpl
18 from xml import sax
19 from io import BytesIO, StringIO
20 import codecs
21 import os.path
22 import pyexpat
23 import shutil
24 import sys
25 from urllib.error import URLError
26 import urllib.request
27 from test.support import os_helper
28 from test.support import findfile, check__all__
29 from test.support.os_helper import FakePath, TESTFN
30
31
32 TEST_XMLFILE = findfile("test.xml", subdir="xmltestdata")
33 TEST_XMLFILE_OUT = findfile("test.xml.out", subdir="xmltestdata")
34 try:
35 TEST_XMLFILE.encode("utf-8")
36 TEST_XMLFILE_OUT.encode("utf-8")
37 except UnicodeEncodeError:
38 raise unittest.SkipTest("filename is not encodable to utf8")
39
40 supports_nonascii_filenames = True
41 if not os.path.supports_unicode_filenames:
42 try:
43 os_helper.TESTFN_UNICODE.encode(sys.getfilesystemencoding())
44 except (UnicodeError, TypeError):
45 # Either the file system encoding is None, or the file name
46 # cannot be encoded in the file system encoding.
47 supports_nonascii_filenames = False
48 requires_nonascii_filenames = unittest.skipUnless(
49 supports_nonascii_filenames,
50 'Requires non-ascii filenames support')
51
52 ns_uri = "http://www.python.org/xml-ns/saxtest/"
53
54 class XmlTestBase(unittest.TestCase):
55 def verify_empty_attrs(self, attrs):
56 self.assertRaises(KeyError, attrs.getValue, "attr")
57 self.assertRaises(KeyError, attrs.getValueByQName, "attr")
58 self.assertRaises(KeyError, attrs.getNameByQName, "attr")
59 self.assertRaises(KeyError, attrs.getQNameByName, "attr")
60 self.assertRaises(KeyError, attrs.__getitem__, "attr")
61 self.assertEqual(attrs.getLength(), 0)
62 self.assertEqual(attrs.getNames(), [])
63 self.assertEqual(attrs.getQNames(), [])
64 self.assertEqual(len(attrs), 0)
65 self.assertNotIn("attr", attrs)
66 self.assertEqual(list(attrs.keys()), [])
67 self.assertEqual(attrs.get("attrs"), None)
68 self.assertEqual(attrs.get("attrs", 25), 25)
69 self.assertEqual(list(attrs.items()), [])
70 self.assertEqual(list(attrs.values()), [])
71
72 def verify_empty_nsattrs(self, attrs):
73 self.assertRaises(KeyError, attrs.getValue, (ns_uri, "attr"))
74 self.assertRaises(KeyError, attrs.getValueByQName, "ns:attr")
75 self.assertRaises(KeyError, attrs.getNameByQName, "ns:attr")
76 self.assertRaises(KeyError, attrs.getQNameByName, (ns_uri, "attr"))
77 self.assertRaises(KeyError, attrs.__getitem__, (ns_uri, "attr"))
78 self.assertEqual(attrs.getLength(), 0)
79 self.assertEqual(attrs.getNames(), [])
80 self.assertEqual(attrs.getQNames(), [])
81 self.assertEqual(len(attrs), 0)
82 self.assertNotIn((ns_uri, "attr"), attrs)
83 self.assertEqual(list(attrs.keys()), [])
84 self.assertEqual(attrs.get((ns_uri, "attr")), None)
85 self.assertEqual(attrs.get((ns_uri, "attr"), 25), 25)
86 self.assertEqual(list(attrs.items()), [])
87 self.assertEqual(list(attrs.values()), [])
88
89 def verify_attrs_wattr(self, attrs):
90 self.assertEqual(attrs.getLength(), 1)
91 self.assertEqual(attrs.getNames(), ["attr"])
92 self.assertEqual(attrs.getQNames(), ["attr"])
93 self.assertEqual(len(attrs), 1)
94 self.assertIn("attr", attrs)
95 self.assertEqual(list(attrs.keys()), ["attr"])
96 self.assertEqual(attrs.get("attr"), "val")
97 self.assertEqual(attrs.get("attr", 25), "val")
98 self.assertEqual(list(attrs.items()), [("attr", "val")])
99 self.assertEqual(list(attrs.values()), ["val"])
100 self.assertEqual(attrs.getValue("attr"), "val")
101 self.assertEqual(attrs.getValueByQName("attr"), "val")
102 self.assertEqual(attrs.getNameByQName("attr"), "attr")
103 self.assertEqual(attrs["attr"], "val")
104 self.assertEqual(attrs.getQNameByName("attr"), "attr")
105
106
107 def xml_str(doc, encoding=None):
108 if encoding is None:
109 return doc
110 return '<?xml version="1.0" encoding="%s"?>\n%s' % (encoding, doc)
111
112 def xml_bytes(doc, encoding, decl_encoding=...):
113 if decl_encoding is ...:
114 decl_encoding = encoding
115 return xml_str(doc, decl_encoding).encode(encoding, 'xmlcharrefreplace')
116
117 def make_xml_file(doc, encoding, decl_encoding=...):
118 if decl_encoding is ...:
119 decl_encoding = encoding
120 with open(TESTFN, 'w', encoding=encoding, errors='xmlcharrefreplace') as f:
121 f.write(xml_str(doc, decl_encoding))
122
123
124 class ParseTest(unittest.TestCase):
125 data = '<money value="$\xa3\u20ac\U0001017b">$\xa3\u20ac\U0001017b</money>'
126
127 def tearDown(self):
128 os_helper.unlink(TESTFN)
129
130 def check_parse(self, f):
131 from xml.sax import parse
132 result = StringIO()
133 parse(f, XMLGenerator(result, 'utf-8'))
134 self.assertEqual(result.getvalue(), xml_str(self.data, 'utf-8'))
135
136 def test_parse_text(self):
137 encodings = ('us-ascii', 'iso-8859-1', 'utf-8',
138 'utf-16', 'utf-16le', 'utf-16be')
139 for encoding in encodings:
140 self.check_parse(StringIO(xml_str(self.data, encoding)))
141 make_xml_file(self.data, encoding)
142 with open(TESTFN, 'r', encoding=encoding) as f:
143 self.check_parse(f)
144 self.check_parse(StringIO(self.data))
145 make_xml_file(self.data, encoding, None)
146 with open(TESTFN, 'r', encoding=encoding) as f:
147 self.check_parse(f)
148
149 def test_parse_bytes(self):
150 # UTF-8 is default encoding, US-ASCII is compatible with UTF-8,
151 # UTF-16 is autodetected
152 encodings = ('us-ascii', 'utf-8', 'utf-16', 'utf-16le', 'utf-16be')
153 for encoding in encodings:
154 self.check_parse(BytesIO(xml_bytes(self.data, encoding)))
155 make_xml_file(self.data, encoding)
156 self.check_parse(TESTFN)
157 with open(TESTFN, 'rb') as f:
158 self.check_parse(f)
159 self.check_parse(BytesIO(xml_bytes(self.data, encoding, None)))
160 make_xml_file(self.data, encoding, None)
161 self.check_parse(TESTFN)
162 with open(TESTFN, 'rb') as f:
163 self.check_parse(f)
164 # accept UTF-8 with BOM
165 self.check_parse(BytesIO(xml_bytes(self.data, 'utf-8-sig', 'utf-8')))
166 make_xml_file(self.data, 'utf-8-sig', 'utf-8')
167 self.check_parse(TESTFN)
168 with open(TESTFN, 'rb') as f:
169 self.check_parse(f)
170 self.check_parse(BytesIO(xml_bytes(self.data, 'utf-8-sig', None)))
171 make_xml_file(self.data, 'utf-8-sig', None)
172 self.check_parse(TESTFN)
173 with open(TESTFN, 'rb') as f:
174 self.check_parse(f)
175 # accept data with declared encoding
176 self.check_parse(BytesIO(xml_bytes(self.data, 'iso-8859-1')))
177 make_xml_file(self.data, 'iso-8859-1')
178 self.check_parse(TESTFN)
179 with open(TESTFN, 'rb') as f:
180 self.check_parse(f)
181 # fail on non-UTF-8 incompatible data without declared encoding
182 with self.assertRaises(SAXException):
183 self.check_parse(BytesIO(xml_bytes(self.data, 'iso-8859-1', None)))
184 make_xml_file(self.data, 'iso-8859-1', None)
185 with self.assertRaises(SAXException):
186 self.check_parse(TESTFN)
187 with open(TESTFN, 'rb') as f:
188 with self.assertRaises(SAXException):
189 self.check_parse(f)
190
191 def test_parse_path_object(self):
192 make_xml_file(self.data, 'utf-8', None)
193 self.check_parse(FakePath(TESTFN))
194
195 def test_parse_InputSource(self):
196 # accept data without declared but with explicitly specified encoding
197 make_xml_file(self.data, 'iso-8859-1', None)
198 with open(TESTFN, 'rb') as f:
199 input = InputSource()
200 input.setByteStream(f)
201 input.setEncoding('iso-8859-1')
202 self.check_parse(input)
203
204 def test_parse_close_source(self):
205 builtin_open = open
206 fileobj = None
207
208 def mock_open(*args):
209 nonlocal fileobj
210 fileobj = builtin_open(*args)
211 return fileobj
212
213 with mock.patch('xml.sax.saxutils.open', side_effect=mock_open):
214 make_xml_file(self.data, 'iso-8859-1', None)
215 with self.assertRaises(SAXException):
216 self.check_parse(TESTFN)
217 self.assertTrue(fileobj.closed)
218
219 def check_parseString(self, s):
220 from xml.sax import parseString
221 result = StringIO()
222 parseString(s, XMLGenerator(result, 'utf-8'))
223 self.assertEqual(result.getvalue(), xml_str(self.data, 'utf-8'))
224
225 def test_parseString_text(self):
226 encodings = ('us-ascii', 'iso-8859-1', 'utf-8',
227 'utf-16', 'utf-16le', 'utf-16be')
228 for encoding in encodings:
229 self.check_parseString(xml_str(self.data, encoding))
230 self.check_parseString(self.data)
231
232 def test_parseString_bytes(self):
233 # UTF-8 is default encoding, US-ASCII is compatible with UTF-8,
234 # UTF-16 is autodetected
235 encodings = ('us-ascii', 'utf-8', 'utf-16', 'utf-16le', 'utf-16be')
236 for encoding in encodings:
237 self.check_parseString(xml_bytes(self.data, encoding))
238 self.check_parseString(xml_bytes(self.data, encoding, None))
239 # accept UTF-8 with BOM
240 self.check_parseString(xml_bytes(self.data, 'utf-8-sig', 'utf-8'))
241 self.check_parseString(xml_bytes(self.data, 'utf-8-sig', None))
242 # accept data with declared encoding
243 self.check_parseString(xml_bytes(self.data, 'iso-8859-1'))
244 # fail on non-UTF-8 incompatible data without declared encoding
245 with self.assertRaises(SAXException):
246 self.check_parseString(xml_bytes(self.data, 'iso-8859-1', None))
247
248 class MakeParserTest(unittest.TestCase):
249 def test_make_parser2(self):
250 # Creating parsers several times in a row should succeed.
251 # Testing this because there have been failures of this kind
252 # before.
253 from xml.sax import make_parser
254 p = make_parser()
255 from xml.sax import make_parser
256 p = make_parser()
257 from xml.sax import make_parser
258 p = make_parser()
259 from xml.sax import make_parser
260 p = make_parser()
261 from xml.sax import make_parser
262 p = make_parser()
263 from xml.sax import make_parser
264 p = make_parser()
265
266 def test_make_parser3(self):
267 # Testing that make_parser can handle different types of
268 # iterables.
269 make_parser(['module'])
270 make_parser(('module', ))
271 make_parser({'module'})
272 make_parser(frozenset({'module'}))
273 make_parser({'module': None})
274 make_parser(iter(['module']))
275
276 def test_make_parser4(self):
277 # Testing that make_parser can handle empty iterables.
278 make_parser([])
279 make_parser(tuple())
280 make_parser(set())
281 make_parser(frozenset())
282 make_parser({})
283 make_parser(iter([]))
284
285 def test_make_parser5(self):
286 # Testing that make_parser can handle iterables with more than
287 # one item.
288 make_parser(['module1', 'module2'])
289 make_parser(('module1', 'module2'))
290 make_parser({'module1', 'module2'})
291 make_parser(frozenset({'module1', 'module2'}))
292 make_parser({'module1': None, 'module2': None})
293 make_parser(iter(['module1', 'module2']))
294
295 # ===========================================================================
296 #
297 # saxutils tests
298 #
299 # ===========================================================================
300
301 class SaxutilsTest(unittest.TestCase):
302 # ===== escape
303 def test_escape_basic(self):
304 self.assertEqual(escape("Donald Duck & Co"), "Donald Duck &amp; Co")
305
306 def test_escape_all(self):
307 self.assertEqual(escape("<Donald Duck & Co>"),
308 "&lt;Donald Duck &amp; Co&gt;")
309
310 def test_escape_extra(self):
311 self.assertEqual(escape("Hei på deg", {"å" : "&aring;"}),
312 "Hei p&aring; deg")
313
314 # ===== unescape
315 def test_unescape_basic(self):
316 self.assertEqual(unescape("Donald Duck &amp; Co"), "Donald Duck & Co")
317
318 def test_unescape_all(self):
319 self.assertEqual(unescape("&lt;Donald Duck &amp; Co&gt;"),
320 "<Donald Duck & Co>")
321
322 def test_unescape_extra(self):
323 self.assertEqual(unescape("Hei på deg", {"å" : "&aring;"}),
324 "Hei p&aring; deg")
325
326 def test_unescape_amp_extra(self):
327 self.assertEqual(unescape("&amp;foo;", {"&foo;": "splat"}), "&foo;")
328
329 # ===== quoteattr
330 def test_quoteattr_basic(self):
331 self.assertEqual(quoteattr("Donald Duck & Co"),
332 '"Donald Duck &amp; Co"')
333
334 def test_single_quoteattr(self):
335 self.assertEqual(quoteattr('Includes "double" quotes'),
336 '\'Includes "double" quotes\'')
337
338 def test_double_quoteattr(self):
339 self.assertEqual(quoteattr("Includes 'single' quotes"),
340 "\"Includes 'single' quotes\"")
341
342 def test_single_double_quoteattr(self):
343 self.assertEqual(quoteattr("Includes 'single' and \"double\" quotes"),
344 "\"Includes 'single' and &quot;double&quot; quotes\"")
345
346 # ===== make_parser
347 def test_make_parser(self):
348 # Creating a parser should succeed - it should fall back
349 # to the expatreader
350 p = make_parser(['xml.parsers.no_such_parser'])
351
352
353 class PrepareInputSourceTest(unittest.TestCase):
354
355 def setUp(self):
356 self.file = os_helper.TESTFN
357 with open(self.file, "w") as tmp:
358 tmp.write("This was read from a file.")
359
360 def tearDown(self):
361 os_helper.unlink(self.file)
362
363 def make_byte_stream(self):
364 return BytesIO(b"This is a byte stream.")
365
366 def make_character_stream(self):
367 return StringIO("This is a character stream.")
368
369 def checkContent(self, stream, content):
370 self.assertIsNotNone(stream)
371 self.assertEqual(stream.read(), content)
372 stream.close()
373
374
375 def test_character_stream(self):
376 # If the source is an InputSource with a character stream, use it.
377 src = InputSource(self.file)
378 src.setCharacterStream(self.make_character_stream())
379 prep = prepare_input_source(src)
380 self.assertIsNone(prep.getByteStream())
381 self.checkContent(prep.getCharacterStream(),
382 "This is a character stream.")
383
384 def test_byte_stream(self):
385 # If the source is an InputSource that does not have a character
386 # stream but does have a byte stream, use the byte stream.
387 src = InputSource(self.file)
388 src.setByteStream(self.make_byte_stream())
389 prep = prepare_input_source(src)
390 self.assertIsNone(prep.getCharacterStream())
391 self.checkContent(prep.getByteStream(),
392 b"This is a byte stream.")
393
394 def test_system_id(self):
395 # If the source is an InputSource that has neither a character
396 # stream nor a byte stream, open the system ID.
397 src = InputSource(self.file)
398 prep = prepare_input_source(src)
399 self.assertIsNone(prep.getCharacterStream())
400 self.checkContent(prep.getByteStream(),
401 b"This was read from a file.")
402
403 def test_string(self):
404 # If the source is a string, use it as a system ID and open it.
405 prep = prepare_input_source(self.file)
406 self.assertIsNone(prep.getCharacterStream())
407 self.checkContent(prep.getByteStream(),
408 b"This was read from a file.")
409
410 def test_path_objects(self):
411 # If the source is a Path object, use it as a system ID and open it.
412 prep = prepare_input_source(FakePath(self.file))
413 self.assertIsNone(prep.getCharacterStream())
414 self.checkContent(prep.getByteStream(),
415 b"This was read from a file.")
416
417 def test_binary_file(self):
418 # If the source is a binary file-like object, use it as a byte
419 # stream.
420 prep = prepare_input_source(self.make_byte_stream())
421 self.assertIsNone(prep.getCharacterStream())
422 self.checkContent(prep.getByteStream(),
423 b"This is a byte stream.")
424
425 def test_text_file(self):
426 # If the source is a text file-like object, use it as a character
427 # stream.
428 prep = prepare_input_source(self.make_character_stream())
429 self.assertIsNone(prep.getByteStream())
430 self.checkContent(prep.getCharacterStream(),
431 "This is a character stream.")
432
433
434 # ===== XMLGenerator
435
436 class XmlgenTest:
437 def test_xmlgen_basic(self):
438 result = self.ioclass()
439 gen = XMLGenerator(result)
440 gen.startDocument()
441 gen.startElement("doc", {})
442 gen.endElement("doc")
443 gen.endDocument()
444
445 self.assertEqual(result.getvalue(), self.xml("<doc></doc>"))
446
447 def test_xmlgen_basic_empty(self):
448 result = self.ioclass()
449 gen = XMLGenerator(result, short_empty_elements=True)
450 gen.startDocument()
451 gen.startElement("doc", {})
452 gen.endElement("doc")
453 gen.endDocument()
454
455 self.assertEqual(result.getvalue(), self.xml("<doc/>"))
456
457 def test_xmlgen_content(self):
458 result = self.ioclass()
459 gen = XMLGenerator(result)
460
461 gen.startDocument()
462 gen.startElement("doc", {})
463 gen.characters("huhei")
464 gen.endElement("doc")
465 gen.endDocument()
466
467 self.assertEqual(result.getvalue(), self.xml("<doc>huhei</doc>"))
468
469 def test_xmlgen_content_empty(self):
470 result = self.ioclass()
471 gen = XMLGenerator(result, short_empty_elements=True)
472
473 gen.startDocument()
474 gen.startElement("doc", {})
475 gen.characters("huhei")
476 gen.endElement("doc")
477 gen.endDocument()
478
479 self.assertEqual(result.getvalue(), self.xml("<doc>huhei</doc>"))
480
481 def test_xmlgen_pi(self):
482 result = self.ioclass()
483 gen = XMLGenerator(result)
484
485 gen.startDocument()
486 gen.processingInstruction("test", "data")
487 gen.startElement("doc", {})
488 gen.endElement("doc")
489 gen.endDocument()
490
491 self.assertEqual(result.getvalue(),
492 self.xml("<?test data?><doc></doc>"))
493
494 def test_xmlgen_content_escape(self):
495 result = self.ioclass()
496 gen = XMLGenerator(result)
497
498 gen.startDocument()
499 gen.startElement("doc", {})
500 gen.characters("<huhei&")
501 gen.endElement("doc")
502 gen.endDocument()
503
504 self.assertEqual(result.getvalue(),
505 self.xml("<doc>&lt;huhei&amp;</doc>"))
506
507 def test_xmlgen_attr_escape(self):
508 result = self.ioclass()
509 gen = XMLGenerator(result)
510
511 gen.startDocument()
512 gen.startElement("doc", {"a": '"'})
513 gen.startElement("e", {"a": "'"})
514 gen.endElement("e")
515 gen.startElement("e", {"a": "'\""})
516 gen.endElement("e")
517 gen.startElement("e", {"a": "\n\r\t"})
518 gen.endElement("e")
519 gen.endElement("doc")
520 gen.endDocument()
521
522 self.assertEqual(result.getvalue(), self.xml(
523 "<doc a='\"'><e a=\"'\"></e>"
524 "<e a=\"'&quot;\"></e>"
525 "<e a=\"&#10;&#13;&#9;\"></e></doc>"))
526
527 def test_xmlgen_encoding(self):
528 encodings = ('iso-8859-15', 'utf-8', 'utf-8-sig',
529 'utf-16', 'utf-16be', 'utf-16le',
530 'utf-32', 'utf-32be', 'utf-32le')
531 for encoding in encodings:
532 result = self.ioclass()
533 gen = XMLGenerator(result, encoding=encoding)
534
535 gen.startDocument()
536 gen.startElement("doc", {"a": '\u20ac'})
537 gen.characters("\u20ac")
538 gen.endElement("doc")
539 gen.endDocument()
540
541 self.assertEqual(result.getvalue(),
542 self.xml('<doc a="\u20ac">\u20ac</doc>', encoding=encoding))
543
544 def test_xmlgen_unencodable(self):
545 result = self.ioclass()
546 gen = XMLGenerator(result, encoding='ascii')
547
548 gen.startDocument()
549 gen.startElement("doc", {"a": '\u20ac'})
550 gen.characters("\u20ac")
551 gen.endElement("doc")
552 gen.endDocument()
553
554 self.assertEqual(result.getvalue(),
555 self.xml('<doc a="&#8364;">&#8364;</doc>', encoding='ascii'))
556
557 def test_xmlgen_ignorable(self):
558 result = self.ioclass()
559 gen = XMLGenerator(result)
560
561 gen.startDocument()
562 gen.startElement("doc", {})
563 gen.ignorableWhitespace(" ")
564 gen.endElement("doc")
565 gen.endDocument()
566
567 self.assertEqual(result.getvalue(), self.xml("<doc> </doc>"))
568
569 def test_xmlgen_ignorable_empty(self):
570 result = self.ioclass()
571 gen = XMLGenerator(result, short_empty_elements=True)
572
573 gen.startDocument()
574 gen.startElement("doc", {})
575 gen.ignorableWhitespace(" ")
576 gen.endElement("doc")
577 gen.endDocument()
578
579 self.assertEqual(result.getvalue(), self.xml("<doc> </doc>"))
580
581 def test_xmlgen_encoding_bytes(self):
582 encodings = ('iso-8859-15', 'utf-8', 'utf-8-sig',
583 'utf-16', 'utf-16be', 'utf-16le',
584 'utf-32', 'utf-32be', 'utf-32le')
585 for encoding in encodings:
586 result = self.ioclass()
587 gen = XMLGenerator(result, encoding=encoding)
588
589 gen.startDocument()
590 gen.startElement("doc", {"a": '\u20ac'})
591 gen.characters("\u20ac".encode(encoding))
592 gen.ignorableWhitespace(" ".encode(encoding))
593 gen.endElement("doc")
594 gen.endDocument()
595
596 self.assertEqual(result.getvalue(),
597 self.xml('<doc a="\u20ac">\u20ac </doc>', encoding=encoding))
598
599 def test_xmlgen_ns(self):
600 result = self.ioclass()
601 gen = XMLGenerator(result)
602
603 gen.startDocument()
604 gen.startPrefixMapping("ns1", ns_uri)
605 gen.startElementNS((ns_uri, "doc"), "ns1:doc", {})
606 # add an unqualified name
607 gen.startElementNS((None, "udoc"), None, {})
608 gen.endElementNS((None, "udoc"), None)
609 gen.endElementNS((ns_uri, "doc"), "ns1:doc")
610 gen.endPrefixMapping("ns1")
611 gen.endDocument()
612
613 self.assertEqual(result.getvalue(), self.xml(
614 '<ns1:doc xmlns:ns1="%s"><udoc></udoc></ns1:doc>' %
615 ns_uri))
616
617 def test_xmlgen_ns_empty(self):
618 result = self.ioclass()
619 gen = XMLGenerator(result, short_empty_elements=True)
620
621 gen.startDocument()
622 gen.startPrefixMapping("ns1", ns_uri)
623 gen.startElementNS((ns_uri, "doc"), "ns1:doc", {})
624 # add an unqualified name
625 gen.startElementNS((None, "udoc"), None, {})
626 gen.endElementNS((None, "udoc"), None)
627 gen.endElementNS((ns_uri, "doc"), "ns1:doc")
628 gen.endPrefixMapping("ns1")
629 gen.endDocument()
630
631 self.assertEqual(result.getvalue(), self.xml(
632 '<ns1:doc xmlns:ns1="%s"><udoc/></ns1:doc>' %
633 ns_uri))
634
635 def test_1463026_1(self):
636 result = self.ioclass()
637 gen = XMLGenerator(result)
638
639 gen.startDocument()
640 gen.startElementNS((None, 'a'), 'a', {(None, 'b'):'c'})
641 gen.endElementNS((None, 'a'), 'a')
642 gen.endDocument()
643
644 self.assertEqual(result.getvalue(), self.xml('<a b="c"></a>'))
645
646 def test_1463026_1_empty(self):
647 result = self.ioclass()
648 gen = XMLGenerator(result, short_empty_elements=True)
649
650 gen.startDocument()
651 gen.startElementNS((None, 'a'), 'a', {(None, 'b'):'c'})
652 gen.endElementNS((None, 'a'), 'a')
653 gen.endDocument()
654
655 self.assertEqual(result.getvalue(), self.xml('<a b="c"/>'))
656
657 def test_1463026_2(self):
658 result = self.ioclass()
659 gen = XMLGenerator(result)
660
661 gen.startDocument()
662 gen.startPrefixMapping(None, 'qux')
663 gen.startElementNS(('qux', 'a'), 'a', {})
664 gen.endElementNS(('qux', 'a'), 'a')
665 gen.endPrefixMapping(None)
666 gen.endDocument()
667
668 self.assertEqual(result.getvalue(), self.xml('<a xmlns="qux"></a>'))
669
670 def test_1463026_2_empty(self):
671 result = self.ioclass()
672 gen = XMLGenerator(result, short_empty_elements=True)
673
674 gen.startDocument()
675 gen.startPrefixMapping(None, 'qux')
676 gen.startElementNS(('qux', 'a'), 'a', {})
677 gen.endElementNS(('qux', 'a'), 'a')
678 gen.endPrefixMapping(None)
679 gen.endDocument()
680
681 self.assertEqual(result.getvalue(), self.xml('<a xmlns="qux"/>'))
682
683 def test_1463026_3(self):
684 result = self.ioclass()
685 gen = XMLGenerator(result)
686
687 gen.startDocument()
688 gen.startPrefixMapping('my', 'qux')
689 gen.startElementNS(('qux', 'a'), 'a', {(None, 'b'):'c'})
690 gen.endElementNS(('qux', 'a'), 'a')
691 gen.endPrefixMapping('my')
692 gen.endDocument()
693
694 self.assertEqual(result.getvalue(),
695 self.xml('<my:a xmlns:my="qux" b="c"></my:a>'))
696
697 def test_1463026_3_empty(self):
698 result = self.ioclass()
699 gen = XMLGenerator(result, short_empty_elements=True)
700
701 gen.startDocument()
702 gen.startPrefixMapping('my', 'qux')
703 gen.startElementNS(('qux', 'a'), 'a', {(None, 'b'):'c'})
704 gen.endElementNS(('qux', 'a'), 'a')
705 gen.endPrefixMapping('my')
706 gen.endDocument()
707
708 self.assertEqual(result.getvalue(),
709 self.xml('<my:a xmlns:my="qux" b="c"/>'))
710
711 def test_5027_1(self):
712 # The xml prefix (as in xml:lang below) is reserved and bound by
713 # definition to http://www.w3.org/XML/1998/namespace. XMLGenerator had
714 # a bug whereby a KeyError is raised because this namespace is missing
715 # from a dictionary.
716 #
717 # This test demonstrates the bug by parsing a document.
718 test_xml = StringIO(
719 '<?xml version="1.0"?>'
720 '<a:g1 xmlns:a="http://example.com/ns">'
721 '<a:g2 xml:lang="en">Hello</a:g2>'
722 '</a:g1>')
723
724 parser = make_parser()
725 parser.setFeature(feature_namespaces, True)
726 result = self.ioclass()
727 gen = XMLGenerator(result)
728 parser.setContentHandler(gen)
729 parser.parse(test_xml)
730
731 self.assertEqual(result.getvalue(),
732 self.xml(
733 '<a:g1 xmlns:a="http://example.com/ns">'
734 '<a:g2 xml:lang="en">Hello</a:g2>'
735 '</a:g1>'))
736
737 def test_5027_2(self):
738 # The xml prefix (as in xml:lang below) is reserved and bound by
739 # definition to http://www.w3.org/XML/1998/namespace. XMLGenerator had
740 # a bug whereby a KeyError is raised because this namespace is missing
741 # from a dictionary.
742 #
743 # This test demonstrates the bug by direct manipulation of the
744 # XMLGenerator.
745 result = self.ioclass()
746 gen = XMLGenerator(result)
747
748 gen.startDocument()
749 gen.startPrefixMapping('a', 'http://example.com/ns')
750 gen.startElementNS(('http://example.com/ns', 'g1'), 'g1', {})
751 lang_attr = {('http://www.w3.org/XML/1998/namespace', 'lang'): 'en'}
752 gen.startElementNS(('http://example.com/ns', 'g2'), 'g2', lang_attr)
753 gen.characters('Hello')
754 gen.endElementNS(('http://example.com/ns', 'g2'), 'g2')
755 gen.endElementNS(('http://example.com/ns', 'g1'), 'g1')
756 gen.endPrefixMapping('a')
757 gen.endDocument()
758
759 self.assertEqual(result.getvalue(),
760 self.xml(
761 '<a:g1 xmlns:a="http://example.com/ns">'
762 '<a:g2 xml:lang="en">Hello</a:g2>'
763 '</a:g1>'))
764
765 def test_no_close_file(self):
766 result = self.ioclass()
767 def func(out):
768 gen = XMLGenerator(out)
769 gen.startDocument()
770 gen.startElement("doc", {})
771 func(result)
772 self.assertFalse(result.closed)
773
774 def test_xmlgen_fragment(self):
775 result = self.ioclass()
776 gen = XMLGenerator(result)
777
778 # Don't call gen.startDocument()
779 gen.startElement("foo", {"a": "1.0"})
780 gen.characters("Hello")
781 gen.endElement("foo")
782 gen.startElement("bar", {"b": "2.0"})
783 gen.endElement("bar")
784 # Don't call gen.endDocument()
785
786 self.assertEqual(result.getvalue(),
787 self.xml('<foo a="1.0">Hello</foo><bar b="2.0"></bar>')[len(self.xml('')):])
788
789 class StringXmlgenTest(XmlgenTest, unittest.TestCase):
790 ioclass = StringIO
791
792 def xml(self, doc, encoding='iso-8859-1'):
793 return '<?xml version="1.0" encoding="%s"?>\n%s' % (encoding, doc)
794
795 test_xmlgen_unencodable = None
796
797 class BytesXmlgenTest(XmlgenTest, unittest.TestCase):
798 ioclass = BytesIO
799
800 def xml(self, doc, encoding='iso-8859-1'):
801 return ('<?xml version="1.0" encoding="%s"?>\n%s' %
802 (encoding, doc)).encode(encoding, 'xmlcharrefreplace')
803
804 class WriterXmlgenTest(BytesXmlgenTest):
805 class ioclass(list):
806 write = list.append
807 closed = False
808
809 def seekable(self):
810 return True
811
812 def tell(self):
813 # return 0 at start and not 0 after start
814 return len(self)
815
816 def getvalue(self):
817 return b''.join(self)
818
819 class StreamWriterXmlgenTest(XmlgenTest, unittest.TestCase):
820 def ioclass(self):
821 raw = BytesIO()
822 writer = codecs.getwriter('ascii')(raw, 'xmlcharrefreplace')
823 writer.getvalue = raw.getvalue
824 return writer
825
826 def xml(self, doc, encoding='iso-8859-1'):
827 return ('<?xml version="1.0" encoding="%s"?>\n%s' %
828 (encoding, doc)).encode('ascii', 'xmlcharrefreplace')
829
830 class StreamReaderWriterXmlgenTest(XmlgenTest, unittest.TestCase):
831 fname = os_helper.TESTFN + '-codecs'
832
833 def ioclass(self):
834 with self.assertWarns(DeprecationWarning):
835 writer = codecs.open(self.fname, 'w', encoding='ascii',
836 errors='xmlcharrefreplace', buffering=0)
837 def cleanup():
838 writer.close()
839 os_helper.unlink(self.fname)
840 self.addCleanup(cleanup)
841 def getvalue():
842 # Windows will not let use reopen without first closing
843 writer.close()
844 with open(writer.name, 'rb') as f:
845 return f.read()
846 writer.getvalue = getvalue
847 return writer
848
849 def xml(self, doc, encoding='iso-8859-1'):
850 return ('<?xml version="1.0" encoding="%s"?>\n%s' %
851 (encoding, doc)).encode('ascii', 'xmlcharrefreplace')
852
853 start = b'<?xml version="1.0" encoding="iso-8859-1"?>\n'
854
855
856 class XMLFilterBaseTest(unittest.TestCase):
857 def test_filter_basic(self):
858 result = BytesIO()
859 gen = XMLGenerator(result)
860 filter = XMLFilterBase()
861 filter.setContentHandler(gen)
862
863 filter.startDocument()
864 filter.startElement("doc", {})
865 filter.characters("content")
866 filter.ignorableWhitespace(" ")
867 filter.endElement("doc")
868 filter.endDocument()
869
870 self.assertEqual(result.getvalue(), start + b"<doc>content </doc>")
871
872 # ===========================================================================
873 #
874 # expatreader tests
875 #
876 # ===========================================================================
877
878 with open(TEST_XMLFILE_OUT, 'rb') as f:
879 xml_test_out = f.read()
880
881 class ExpatReaderTest(XmlTestBase):
882
883 # ===== XMLReader support
884
885 def test_expat_binary_file(self):
886 parser = create_parser()
887 result = BytesIO()
888 xmlgen = XMLGenerator(result)
889
890 parser.setContentHandler(xmlgen)
891 with open(TEST_XMLFILE, 'rb') as f:
892 parser.parse(f)
893
894 self.assertEqual(result.getvalue(), xml_test_out)
895
896 def test_expat_text_file(self):
897 parser = create_parser()
898 result = BytesIO()
899 xmlgen = XMLGenerator(result)
900
901 parser.setContentHandler(xmlgen)
902 with open(TEST_XMLFILE, 'rt', encoding='iso-8859-1') as f:
903 parser.parse(f)
904
905 self.assertEqual(result.getvalue(), xml_test_out)
906
907 @requires_nonascii_filenames
908 def test_expat_binary_file_nonascii(self):
909 fname = os_helper.TESTFN_UNICODE
910 shutil.copyfile(TEST_XMLFILE, fname)
911 self.addCleanup(os_helper.unlink, fname)
912
913 parser = create_parser()
914 result = BytesIO()
915 xmlgen = XMLGenerator(result)
916
917 parser.setContentHandler(xmlgen)
918 parser.parse(open(fname, 'rb'))
919
920 self.assertEqual(result.getvalue(), xml_test_out)
921
922 def test_expat_binary_file_bytes_name(self):
923 fname = os.fsencode(TEST_XMLFILE)
924 parser = create_parser()
925 result = BytesIO()
926 xmlgen = XMLGenerator(result)
927
928 parser.setContentHandler(xmlgen)
929 with open(fname, 'rb') as f:
930 parser.parse(f)
931
932 self.assertEqual(result.getvalue(), xml_test_out)
933
934 def test_expat_binary_file_int_name(self):
935 parser = create_parser()
936 result = BytesIO()
937 xmlgen = XMLGenerator(result)
938
939 parser.setContentHandler(xmlgen)
940 with open(TEST_XMLFILE, 'rb') as f:
941 with open(f.fileno(), 'rb', closefd=False) as f2:
942 parser.parse(f2)
943
944 self.assertEqual(result.getvalue(), xml_test_out)
945
946 # ===== DTDHandler support
947
948 class TestDTDHandler:
949
950 def __init__(self):
951 self._notations = []
952 self._entities = []
953
954 def notationDecl(self, name, publicId, systemId):
955 self._notations.append((name, publicId, systemId))
956
957 def unparsedEntityDecl(self, name, publicId, systemId, ndata):
958 self._entities.append((name, publicId, systemId, ndata))
959
960
961 class TestEntityRecorder:
962 def __init__(self):
963 self.entities = []
964
965 def resolveEntity(self, publicId, systemId):
966 self.entities.append((publicId, systemId))
967 source = InputSource()
968 source.setPublicId(publicId)
969 source.setSystemId(systemId)
970 return source
971
972 def test_expat_dtdhandler(self):
973 parser = create_parser()
974 handler = self.TestDTDHandler()
975 parser.setDTDHandler(handler)
976
977 parser.feed('<!DOCTYPE doc [\n')
978 parser.feed(' <!ENTITY img SYSTEM "expat.gif" NDATA GIF>\n')
979 parser.feed(' <!NOTATION GIF PUBLIC "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN">\n')
980 parser.feed(']>\n')
981 parser.feed('<doc></doc>')
982 parser.close()
983
984 self.assertEqual(handler._notations,
985 [("GIF", "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN", None)])
986 self.assertEqual(handler._entities, [("img", None, "expat.gif", "GIF")])
987
988 def test_expat_external_dtd_enabled(self):
989 # clear _opener global variable
990 self.addCleanup(urllib.request.urlcleanup)
991
992 parser = create_parser()
993 parser.setFeature(feature_external_ges, True)
994 resolver = self.TestEntityRecorder()
995 parser.setEntityResolver(resolver)
996
997 with self.assertRaises(URLError):
998 parser.feed(
999 '<!DOCTYPE external SYSTEM "unsupported://non-existing">\n'
1000 )
1001 self.assertEqual(
1002 resolver.entities, [(None, 'unsupported://non-existing')]
1003 )
1004
1005 def test_expat_external_dtd_default(self):
1006 parser = create_parser()
1007 resolver = self.TestEntityRecorder()
1008 parser.setEntityResolver(resolver)
1009
1010 parser.feed(
1011 '<!DOCTYPE external SYSTEM "unsupported://non-existing">\n'
1012 )
1013 parser.feed('<doc />')
1014 parser.close()
1015 self.assertEqual(resolver.entities, [])
1016
1017 # ===== EntityResolver support
1018
1019 class TestEntityResolver:
1020
1021 def resolveEntity(self, publicId, systemId):
1022 inpsrc = InputSource()
1023 inpsrc.setByteStream(BytesIO(b"<entity/>"))
1024 return inpsrc
1025
1026 def test_expat_entityresolver_enabled(self):
1027 parser = create_parser()
1028 parser.setFeature(feature_external_ges, True)
1029 parser.setEntityResolver(self.TestEntityResolver())
1030 result = BytesIO()
1031 parser.setContentHandler(XMLGenerator(result))
1032
1033 parser.feed('<!DOCTYPE doc [\n')
1034 parser.feed(' <!ENTITY test SYSTEM "whatever">\n')
1035 parser.feed(']>\n')
1036 parser.feed('<doc>&test;</doc>')
1037 parser.close()
1038
1039 self.assertEqual(result.getvalue(), start +
1040 b"<doc><entity></entity></doc>")
1041
1042 def test_expat_entityresolver_default(self):
1043 parser = create_parser()
1044 self.assertEqual(parser.getFeature(feature_external_ges), False)
1045 parser.setEntityResolver(self.TestEntityResolver())
1046 result = BytesIO()
1047 parser.setContentHandler(XMLGenerator(result))
1048
1049 parser.feed('<!DOCTYPE doc [\n')
1050 parser.feed(' <!ENTITY test SYSTEM "whatever">\n')
1051 parser.feed(']>\n')
1052 parser.feed('<doc>&test;</doc>')
1053 parser.close()
1054
1055 self.assertEqual(result.getvalue(), start +
1056 b"<doc></doc>")
1057
1058 # ===== Attributes support
1059
1060 class AttrGatherer(ContentHandler):
1061
1062 def startElement(self, name, attrs):
1063 self._attrs = attrs
1064
1065 def startElementNS(self, name, qname, attrs):
1066 self._attrs = attrs
1067
1068 def test_expat_attrs_empty(self):
1069 parser = create_parser()
1070 gather = self.AttrGatherer()
1071 parser.setContentHandler(gather)
1072
1073 parser.feed("<doc/>")
1074 parser.close()
1075
1076 self.verify_empty_attrs(gather._attrs)
1077
1078 def test_expat_attrs_wattr(self):
1079 parser = create_parser()
1080 gather = self.AttrGatherer()
1081 parser.setContentHandler(gather)
1082
1083 parser.feed("<doc attr='val'/>")
1084 parser.close()
1085
1086 self.verify_attrs_wattr(gather._attrs)
1087
1088 def test_expat_nsattrs_empty(self):
1089 parser = create_parser(1)
1090 gather = self.AttrGatherer()
1091 parser.setContentHandler(gather)
1092
1093 parser.feed("<doc/>")
1094 parser.close()
1095
1096 self.verify_empty_nsattrs(gather._attrs)
1097
1098 def test_expat_nsattrs_wattr(self):
1099 parser = create_parser(1)
1100 gather = self.AttrGatherer()
1101 parser.setContentHandler(gather)
1102
1103 parser.feed("<doc xmlns:ns='%s' ns:attr='val'/>" % ns_uri)
1104 parser.close()
1105
1106 attrs = gather._attrs
1107
1108 self.assertEqual(attrs.getLength(), 1)
1109 self.assertEqual(attrs.getNames(), [(ns_uri, "attr")])
1110 self.assertTrue((attrs.getQNames() == [] or
1111 attrs.getQNames() == ["ns:attr"]))
1112 self.assertEqual(len(attrs), 1)
1113 self.assertIn((ns_uri, "attr"), attrs)
1114 self.assertEqual(attrs.get((ns_uri, "attr")), "val")
1115 self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val")
1116 self.assertEqual(list(attrs.items()), [((ns_uri, "attr"), "val")])
1117 self.assertEqual(list(attrs.values()), ["val"])
1118 self.assertEqual(attrs.getValue((ns_uri, "attr")), "val")
1119 self.assertEqual(attrs[(ns_uri, "attr")], "val")
1120
1121 # ===== InputSource support
1122
1123 def test_expat_inpsource_filename(self):
1124 parser = create_parser()
1125 result = BytesIO()
1126 xmlgen = XMLGenerator(result)
1127
1128 parser.setContentHandler(xmlgen)
1129 parser.parse(TEST_XMLFILE)
1130
1131 self.assertEqual(result.getvalue(), xml_test_out)
1132
1133 def test_expat_inpsource_sysid(self):
1134 parser = create_parser()
1135 result = BytesIO()
1136 xmlgen = XMLGenerator(result)
1137
1138 parser.setContentHandler(xmlgen)
1139 parser.parse(InputSource(TEST_XMLFILE))
1140
1141 self.assertEqual(result.getvalue(), xml_test_out)
1142
1143 @requires_nonascii_filenames
1144 def test_expat_inpsource_sysid_nonascii(self):
1145 fname = os_helper.TESTFN_UNICODE
1146 shutil.copyfile(TEST_XMLFILE, fname)
1147 self.addCleanup(os_helper.unlink, fname)
1148
1149 parser = create_parser()
1150 result = BytesIO()
1151 xmlgen = XMLGenerator(result)
1152
1153 parser.setContentHandler(xmlgen)
1154 parser.parse(InputSource(fname))
1155
1156 self.assertEqual(result.getvalue(), xml_test_out)
1157
1158 def test_expat_inpsource_byte_stream(self):
1159 parser = create_parser()
1160 result = BytesIO()
1161 xmlgen = XMLGenerator(result)
1162
1163 parser.setContentHandler(xmlgen)
1164 inpsrc = InputSource()
1165 with open(TEST_XMLFILE, 'rb') as f:
1166 inpsrc.setByteStream(f)
1167 parser.parse(inpsrc)
1168
1169 self.assertEqual(result.getvalue(), xml_test_out)
1170
1171 def test_expat_inpsource_character_stream(self):
1172 parser = create_parser()
1173 result = BytesIO()
1174 xmlgen = XMLGenerator(result)
1175
1176 parser.setContentHandler(xmlgen)
1177 inpsrc = InputSource()
1178 with open(TEST_XMLFILE, 'rt', encoding='iso-8859-1') as f:
1179 inpsrc.setCharacterStream(f)
1180 parser.parse(inpsrc)
1181
1182 self.assertEqual(result.getvalue(), xml_test_out)
1183
1184 # ===== IncrementalParser support
1185
1186 def test_expat_incremental(self):
1187 result = BytesIO()
1188 xmlgen = XMLGenerator(result)
1189 parser = create_parser()
1190 parser.setContentHandler(xmlgen)
1191
1192 parser.feed("<doc>")
1193 parser.feed("</doc>")
1194 parser.close()
1195
1196 self.assertEqual(result.getvalue(), start + b"<doc></doc>")
1197
1198 def test_expat_incremental_reset(self):
1199 result = BytesIO()
1200 xmlgen = XMLGenerator(result)
1201 parser = create_parser()
1202 parser.setContentHandler(xmlgen)
1203
1204 parser.feed("<doc>")
1205 parser.feed("text")
1206
1207 result = BytesIO()
1208 xmlgen = XMLGenerator(result)
1209 parser.setContentHandler(xmlgen)
1210 parser.reset()
1211
1212 parser.feed("<doc>")
1213 parser.feed("text")
1214 parser.feed("</doc>")
1215 parser.close()
1216
1217 self.assertEqual(result.getvalue(), start + b"<doc>text</doc>")
1218
1219 @unittest.skipIf(pyexpat.version_info < (2, 6, 0),
1220 f'Expat {pyexpat.version_info} does not '
1221 'support reparse deferral')
1222 def test_flush_reparse_deferral_enabled(self):
1223 result = BytesIO()
1224 xmlgen = XMLGenerator(result)
1225 parser = create_parser()
1226 parser.setContentHandler(xmlgen)
1227
1228 for chunk in ("<doc", ">"):
1229 parser.feed(chunk)
1230
1231 self.assertEqual(result.getvalue(), start) # i.e. no elements started
1232 self.assertTrue(parser._parser.GetReparseDeferralEnabled())
1233
1234 parser.flush()
1235
1236 self.assertTrue(parser._parser.GetReparseDeferralEnabled())
1237 self.assertEqual(result.getvalue(), start + b"<doc>")
1238
1239 parser.feed("</doc>")
1240 parser.close()
1241
1242 self.assertEqual(result.getvalue(), start + b"<doc></doc>")
1243
1244 def test_flush_reparse_deferral_disabled(self):
1245 result = BytesIO()
1246 xmlgen = XMLGenerator(result)
1247 parser = create_parser()
1248 parser.setContentHandler(xmlgen)
1249
1250 for chunk in ("<doc", ">"):
1251 parser.feed(chunk)
1252
1253 if pyexpat.version_info >= (2, 6, 0):
1254 parser._parser.SetReparseDeferralEnabled(False)
1255 self.assertEqual(result.getvalue(), start) # i.e. no elements started
1256
1257 self.assertFalse(parser._parser.GetReparseDeferralEnabled())
1258
1259 parser.flush()
1260
1261 self.assertFalse(parser._parser.GetReparseDeferralEnabled())
1262 self.assertEqual(result.getvalue(), start + b"<doc>")
1263
1264 parser.feed("</doc>")
1265 parser.close()
1266
1267 self.assertEqual(result.getvalue(), start + b"<doc></doc>")
1268
1269 # ===== Locator support
1270
1271 def test_expat_locator_noinfo(self):
1272 result = BytesIO()
1273 xmlgen = XMLGenerator(result)
1274 parser = create_parser()
1275 parser.setContentHandler(xmlgen)
1276
1277 parser.feed("<doc>")
1278 parser.feed("</doc>")
1279 parser.close()
1280
1281 self.assertEqual(parser.getSystemId(), None)
1282 self.assertEqual(parser.getPublicId(), None)
1283 self.assertEqual(parser.getLineNumber(), 1)
1284
1285 def test_expat_locator_withinfo(self):
1286 result = BytesIO()
1287 xmlgen = XMLGenerator(result)
1288 parser = create_parser()
1289 parser.setContentHandler(xmlgen)
1290 parser.parse(TEST_XMLFILE)
1291
1292 self.assertEqual(parser.getSystemId(), TEST_XMLFILE)
1293 self.assertEqual(parser.getPublicId(), None)
1294
1295 @requires_nonascii_filenames
1296 def test_expat_locator_withinfo_nonascii(self):
1297 fname = os_helper.TESTFN_UNICODE
1298 shutil.copyfile(TEST_XMLFILE, fname)
1299 self.addCleanup(os_helper.unlink, fname)
1300
1301 result = BytesIO()
1302 xmlgen = XMLGenerator(result)
1303 parser = create_parser()
1304 parser.setContentHandler(xmlgen)
1305 parser.parse(fname)
1306
1307 self.assertEqual(parser.getSystemId(), fname)
1308 self.assertEqual(parser.getPublicId(), None)
1309
1310
1311 # ===========================================================================
1312 #
1313 # error reporting
1314 #
1315 # ===========================================================================
1316
1317 class ErrorReportingTest(unittest.TestCase):
1318 def test_expat_inpsource_location(self):
1319 parser = create_parser()
1320 parser.setContentHandler(ContentHandler()) # do nothing
1321 source = InputSource()
1322 source.setByteStream(BytesIO(b"<foo bar foobar>")) #ill-formed
1323 name = "a file name"
1324 source.setSystemId(name)
1325 try:
1326 parser.parse(source)
1327 self.fail()
1328 except SAXException as e:
1329 self.assertEqual(e.getSystemId(), name)
1330
1331 def test_expat_incomplete(self):
1332 parser = create_parser()
1333 parser.setContentHandler(ContentHandler()) # do nothing
1334 self.assertRaises(SAXParseException, parser.parse, StringIO("<foo>"))
1335 self.assertEqual(parser.getColumnNumber(), 5)
1336 self.assertEqual(parser.getLineNumber(), 1)
1337
1338 def test_sax_parse_exception_str(self):
1339 # pass various values from a locator to the SAXParseException to
1340 # make sure that the __str__() doesn't fall apart when None is
1341 # passed instead of an integer line and column number
1342 #
1343 # use "normal" values for the locator:
1344 str(SAXParseException("message", None,
1345 self.DummyLocator(1, 1)))
1346 # use None for the line number:
1347 str(SAXParseException("message", None,
1348 self.DummyLocator(None, 1)))
1349 # use None for the column number:
1350 str(SAXParseException("message", None,
1351 self.DummyLocator(1, None)))
1352 # use None for both:
1353 str(SAXParseException("message", None,
1354 self.DummyLocator(None, None)))
1355
1356 class DummyLocator:
1357 def __init__(self, lineno, colno):
1358 self._lineno = lineno
1359 self._colno = colno
1360
1361 def getPublicId(self):
1362 return "pubid"
1363
1364 def getSystemId(self):
1365 return "sysid"
1366
1367 def getLineNumber(self):
1368 return self._lineno
1369
1370 def getColumnNumber(self):
1371 return self._colno
1372
1373 # ===========================================================================
1374 #
1375 # xmlreader tests
1376 #
1377 # ===========================================================================
1378
1379 class XmlReaderTest(XmlTestBase):
1380
1381 # ===== AttributesImpl
1382 def test_attrs_empty(self):
1383 self.verify_empty_attrs(AttributesImpl({}))
1384
1385 def test_attrs_wattr(self):
1386 self.verify_attrs_wattr(AttributesImpl({"attr" : "val"}))
1387
1388 def test_nsattrs_empty(self):
1389 self.verify_empty_nsattrs(AttributesNSImpl({}, {}))
1390
1391 def test_nsattrs_wattr(self):
1392 attrs = AttributesNSImpl({(ns_uri, "attr") : "val"},
1393 {(ns_uri, "attr") : "ns:attr"})
1394
1395 self.assertEqual(attrs.getLength(), 1)
1396 self.assertEqual(attrs.getNames(), [(ns_uri, "attr")])
1397 self.assertEqual(attrs.getQNames(), ["ns:attr"])
1398 self.assertEqual(len(attrs), 1)
1399 self.assertIn((ns_uri, "attr"), attrs)
1400 self.assertEqual(list(attrs.keys()), [(ns_uri, "attr")])
1401 self.assertEqual(attrs.get((ns_uri, "attr")), "val")
1402 self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val")
1403 self.assertEqual(list(attrs.items()), [((ns_uri, "attr"), "val")])
1404 self.assertEqual(list(attrs.values()), ["val"])
1405 self.assertEqual(attrs.getValue((ns_uri, "attr")), "val")
1406 self.assertEqual(attrs.getValueByQName("ns:attr"), "val")
1407 self.assertEqual(attrs.getNameByQName("ns:attr"), (ns_uri, "attr"))
1408 self.assertEqual(attrs[(ns_uri, "attr")], "val")
1409 self.assertEqual(attrs.getQNameByName((ns_uri, "attr")), "ns:attr")
1410
1411
1412 class LexicalHandlerTest(unittest.TestCase):
1413 def setUp(self):
1414 self.parser = None
1415
1416 self.specified_version = '1.0'
1417 self.specified_encoding = 'UTF-8'
1418 self.specified_doctype = 'wish'
1419 self.specified_entity_names = ('nbsp', 'source', 'target')
1420 self.specified_comment = ('Comment in a DTD',
1421 'Really! You think so?')
1422 self.test_data = StringIO()
1423 self.test_data.write('<?xml version="{}" encoding="{}"?>\n'.
1424 format(self.specified_version,
1425 self.specified_encoding))
1426 self.test_data.write('<!DOCTYPE {} [\n'.
1427 format(self.specified_doctype))
1428 self.test_data.write('<!-- {} -->\n'.
1429 format(self.specified_comment[0]))
1430 self.test_data.write('<!ELEMENT {} (to,from,heading,body,footer)>\n'.
1431 format(self.specified_doctype))
1432 self.test_data.write('<!ELEMENT to (#PCDATA)>\n')
1433 self.test_data.write('<!ELEMENT from (#PCDATA)>\n')
1434 self.test_data.write('<!ELEMENT heading (#PCDATA)>\n')
1435 self.test_data.write('<!ELEMENT body (#PCDATA)>\n')
1436 self.test_data.write('<!ELEMENT footer (#PCDATA)>\n')
1437 self.test_data.write('<!ENTITY {} "&#xA0;">\n'.
1438 format(self.specified_entity_names[0]))
1439 self.test_data.write('<!ENTITY {} "Written by: Alexander.">\n'.
1440 format(self.specified_entity_names[1]))
1441 self.test_data.write('<!ENTITY {} "Hope it gets to: Aristotle.">\n'.
1442 format(self.specified_entity_names[2]))
1443 self.test_data.write(']>\n')
1444 self.test_data.write('<{}>'.format(self.specified_doctype))
1445 self.test_data.write('<to>Aristotle</to>\n')
1446 self.test_data.write('<from>Alexander</from>\n')
1447 self.test_data.write('<heading>Supplication</heading>\n')
1448 self.test_data.write('<body>Teach me patience!</body>\n')
1449 self.test_data.write('<footer>&{};&{};&{};</footer>\n'.
1450 format(self.specified_entity_names[1],
1451 self.specified_entity_names[0],
1452 self.specified_entity_names[2]))
1453 self.test_data.write('<!-- {} -->\n'.format(self.specified_comment[1]))
1454 self.test_data.write('</{}>\n'.format(self.specified_doctype))
1455 self.test_data.seek(0)
1456
1457 # Data received from handlers - to be validated
1458 self.version = None
1459 self.encoding = None
1460 self.standalone = None
1461 self.doctype = None
1462 self.publicID = None
1463 self.systemID = None
1464 self.end_of_dtd = False
1465 self.comments = []
1466
1467 def test_handlers(self):
1468 class TestLexicalHandler(LexicalHandler):
1469 def __init__(self, test_harness, *args, **kwargs):
1470 super().__init__(*args, **kwargs)
1471 self.test_harness = test_harness
1472
1473 def startDTD(self, doctype, publicID, systemID):
1474 self.test_harness.doctype = doctype
1475 self.test_harness.publicID = publicID
1476 self.test_harness.systemID = systemID
1477
1478 def endDTD(self):
1479 self.test_harness.end_of_dtd = True
1480
1481 def comment(self, text):
1482 self.test_harness.comments.append(text)
1483
1484 self.parser = create_parser()
1485 self.parser.setContentHandler(ContentHandler())
1486 self.parser.setProperty(
1487 'http://xml.org/sax/properties/lexical-handler',
1488 TestLexicalHandler(self))
1489 source = InputSource()
1490 source.setCharacterStream(self.test_data)
1491 self.parser.parse(source)
1492 self.assertEqual(self.doctype, self.specified_doctype)
1493 self.assertIsNone(self.publicID)
1494 self.assertIsNone(self.systemID)
1495 self.assertTrue(self.end_of_dtd)
1496 self.assertEqual(len(self.comments),
1497 len(self.specified_comment))
1498 self.assertEqual(f' {self.specified_comment[0]} ', self.comments[0])
1499
1500
1501 class CDATAHandlerTest(unittest.TestCase):
1502 def setUp(self):
1503 self.parser = None
1504 self.specified_chars = []
1505 self.specified_chars.append(('Parseable character data', False))
1506 self.specified_chars.append(('<> &% - assorted other XML junk.', True))
1507 self.char_index = 0 # Used to index specified results within handlers
1508 self.test_data = StringIO()
1509 self.test_data.write('<root_doc>\n')
1510 self.test_data.write('<some_pcdata>\n')
1511 self.test_data.write(f'{self.specified_chars[0][0]}\n')
1512 self.test_data.write('</some_pcdata>\n')
1513 self.test_data.write('<some_cdata>\n')
1514 self.test_data.write(f'<![CDATA[{self.specified_chars[1][0]}]]>\n')
1515 self.test_data.write('</some_cdata>\n')
1516 self.test_data.write('</root_doc>\n')
1517 self.test_data.seek(0)
1518
1519 # Data received from handlers - to be validated
1520 self.chardata = []
1521 self.in_cdata = False
1522
1523 def test_handlers(self):
1524 class TestLexicalHandler(LexicalHandler):
1525 def __init__(self, test_harness, *args, **kwargs):
1526 super().__init__(*args, **kwargs)
1527 self.test_harness = test_harness
1528
1529 def startCDATA(self):
1530 self.test_harness.in_cdata = True
1531
1532 def endCDATA(self):
1533 self.test_harness.in_cdata = False
1534
1535 class TestCharHandler(ContentHandler):
1536 def __init__(self, test_harness, *args, **kwargs):
1537 super().__init__(*args, **kwargs)
1538 self.test_harness = test_harness
1539
1540 def characters(self, content):
1541 if content != '\n':
1542 h = self.test_harness
1543 t = h.specified_chars[h.char_index]
1544 h.assertEqual(t[0], content)
1545 h.assertEqual(t[1], h.in_cdata)
1546 h.char_index += 1
1547
1548 self.parser = create_parser()
1549 self.parser.setContentHandler(TestCharHandler(self))
1550 self.parser.setProperty(
1551 'http://xml.org/sax/properties/lexical-handler',
1552 TestLexicalHandler(self))
1553 source = InputSource()
1554 source.setCharacterStream(self.test_data)
1555 self.parser.parse(source)
1556
1557 self.assertFalse(self.in_cdata)
1558 self.assertEqual(self.char_index, 2)
1559
1560
1561 class TestModuleAll(unittest.TestCase):
1562 def test_all(self):
1563 extra = (
1564 'ContentHandler',
1565 'ErrorHandler',
1566 'InputSource',
1567 'SAXException',
1568 'SAXNotRecognizedException',
1569 'SAXNotSupportedException',
1570 'SAXParseException',
1571 'SAXReaderNotAvailable',
1572 )
1573 check__all__(self, sax, extra=extra)
1574
1575
1576 if __name__ == "__main__":
1577 unittest.main()