| 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 & Co") |
| 305 |
|
| 306 |
def test_escape_all(self): |
| 307 |
self.assertEqual(escape("<Donald Duck & Co>"), |
| 308 |
"<Donald Duck & Co>") |
| 309 |
|
| 310 |
def test_escape_extra(self): |
| 311 |
self.assertEqual(escape("Hei pÃ¥ deg", {"Ã¥" : "å"}), |
| 312 |
"Hei på deg") |
| 313 |
|
| 314 |
# ===== unescape |
| 315 |
def test_unescape_basic(self): |
| 316 |
self.assertEqual(unescape("Donald Duck & Co"), "Donald Duck & Co") |
| 317 |
|
| 318 |
def test_unescape_all(self): |
| 319 |
self.assertEqual(unescape("<Donald Duck & Co>"), |
| 320 |
"<Donald Duck & Co>") |
| 321 |
|
| 322 |
def test_unescape_extra(self): |
| 323 |
self.assertEqual(unescape("Hei pÃ¥ deg", {"Ã¥" : "å"}), |
| 324 |
"Hei på deg") |
| 325 |
|
| 326 |
def test_unescape_amp_extra(self): |
| 327 |
self.assertEqual(unescape("&foo;", {"&foo;": "splat"}), "&foo;") |
| 328 |
|
| 329 |
# ===== quoteattr |
| 330 |
def test_quoteattr_basic(self): |
| 331 |
self.assertEqual(quoteattr("Donald Duck & Co"), |
| 332 |
'"Donald Duck & 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 "double" 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><huhei&</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=\"'"\"></e>" |
| 525 |
"<e a=\" 	\"></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="€">€</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 {} " ">\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() |