Lines Matching refs:self
54 def verify_empty_attrs(self, attrs):
55 self.assertRaises(KeyError, attrs.getValue, "attr")
56 self.assertRaises(KeyError, attrs.getValueByQName, "attr")
57 self.assertRaises(KeyError, attrs.getNameByQName, "attr")
58 self.assertRaises(KeyError, attrs.getQNameByName, "attr")
59 self.assertRaises(KeyError, attrs.__getitem__, "attr")
60 self.assertEqual(attrs.getLength(), 0)
61 self.assertEqual(attrs.getNames(), [])
62 self.assertEqual(attrs.getQNames(), [])
63 self.assertEqual(len(attrs), 0)
64 self.assertNotIn("attr", attrs)
65 self.assertEqual(list(attrs.keys()), [])
66 self.assertEqual(attrs.get("attrs"), None)
67 self.assertEqual(attrs.get("attrs", 25), 25)
68 self.assertEqual(list(attrs.items()), [])
69 self.assertEqual(list(attrs.values()), [])
71 def verify_empty_nsattrs(self, attrs):
72 self.assertRaises(KeyError, attrs.getValue, (ns_uri, "attr"))
73 self.assertRaises(KeyError, attrs.getValueByQName, "ns:attr")
74 self.assertRaises(KeyError, attrs.getNameByQName, "ns:attr")
75 self.assertRaises(KeyError, attrs.getQNameByName, (ns_uri, "attr"))
76 self.assertRaises(KeyError, attrs.__getitem__, (ns_uri, "attr"))
77 self.assertEqual(attrs.getLength(), 0)
78 self.assertEqual(attrs.getNames(), [])
79 self.assertEqual(attrs.getQNames(), [])
80 self.assertEqual(len(attrs), 0)
81 self.assertNotIn((ns_uri, "attr"), attrs)
82 self.assertEqual(list(attrs.keys()), [])
83 self.assertEqual(attrs.get((ns_uri, "attr")), None)
84 self.assertEqual(attrs.get((ns_uri, "attr"), 25), 25)
85 self.assertEqual(list(attrs.items()), [])
86 self.assertEqual(list(attrs.values()), [])
88 def verify_attrs_wattr(self, attrs):
89 self.assertEqual(attrs.getLength(), 1)
90 self.assertEqual(attrs.getNames(), ["attr"])
91 self.assertEqual(attrs.getQNames(), ["attr"])
92 self.assertEqual(len(attrs), 1)
93 self.assertIn("attr", attrs)
94 self.assertEqual(list(attrs.keys()), ["attr"])
95 self.assertEqual(attrs.get("attr"), "val")
96 self.assertEqual(attrs.get("attr", 25), "val")
97 self.assertEqual(list(attrs.items()), [("attr", "val")])
98 self.assertEqual(list(attrs.values()), ["val"])
99 self.assertEqual(attrs.getValue("attr"), "val")
100 self.assertEqual(attrs.getValueByQName("attr"), "val")
101 self.assertEqual(attrs.getNameByQName("attr"), "attr")
102 self.assertEqual(attrs["attr"], "val")
103 self.assertEqual(attrs.getQNameByName("attr"), "attr")
126 def tearDown(self):
129 def check_parse(self, f):
133 self.assertEqual(result.getvalue(), xml_str(self.data, 'utf-8'))
135 def test_parse_text(self):
139 self.check_parse(StringIO(xml_str(self.data, encoding)))
140 make_xml_file(self.data, encoding)
142 self.check_parse(f)
143 self.check_parse(StringIO(self.data))
144 make_xml_file(self.data, encoding, None)
146 self.check_parse(f)
148 def test_parse_bytes(self):
153 self.check_parse(BytesIO(xml_bytes(self.data, encoding)))
154 make_xml_file(self.data, encoding)
155 self.check_parse(TESTFN)
157 self.check_parse(f)
158 self.check_parse(BytesIO(xml_bytes(self.data, encoding, None)))
159 make_xml_file(self.data, encoding, None)
160 self.check_parse(TESTFN)
162 self.check_parse(f)
164 self.check_parse(BytesIO(xml_bytes(self.data, 'utf-8-sig', 'utf-8')))
165 make_xml_file(self.data, 'utf-8-sig', 'utf-8')
166 self.check_parse(TESTFN)
168 self.check_parse(f)
169 self.check_parse(BytesIO(xml_bytes(self.data, 'utf-8-sig', None)))
170 make_xml_file(self.data, 'utf-8-sig', None)
171 self.check_parse(TESTFN)
173 self.check_parse(f)
175 self.check_parse(BytesIO(xml_bytes(self.data, 'iso-8859-1')))
176 make_xml_file(self.data, 'iso-8859-1')
177 self.check_parse(TESTFN)
179 self.check_parse(f)
181 with self.assertRaises(SAXException):
182 self.check_parse(BytesIO(xml_bytes(self.data, 'iso-8859-1', None)))
183 make_xml_file(self.data, 'iso-8859-1', None)
184 with self.assertRaises(SAXException):
185 self.check_parse(TESTFN)
187 with self.assertRaises(SAXException):
188 self.check_parse(f)
190 def test_parse_path_object(self):
191 make_xml_file(self.data, 'utf-8', None)
192 self.check_parse(FakePath(TESTFN))
194 def test_parse_InputSource(self):
196 make_xml_file(self.data, 'iso-8859-1', None)
201 self.check_parse(input)
203 def test_parse_close_source(self):
213 make_xml_file(self.data, 'iso-8859-1', None)
214 with self.assertRaises(SAXException):
215 self.check_parse(TESTFN)
216 self.assertTrue(fileobj.closed)
218 def check_parseString(self, s):
222 self.assertEqual(result.getvalue(), xml_str(self.data, 'utf-8'))
224 def test_parseString_text(self):
228 self.check_parseString(xml_str(self.data, encoding))
229 self.check_parseString(self.data)
231 def test_parseString_bytes(self):
236 self.check_parseString(xml_bytes(self.data, encoding))
237 self.check_parseString(xml_bytes(self.data, encoding, None))
239 self.check_parseString(xml_bytes(self.data, 'utf-8-sig', 'utf-8'))
240 self.check_parseString(xml_bytes(self.data, 'utf-8-sig', None))
242 self.check_parseString(xml_bytes(self.data, 'iso-8859-1'))
244 with self.assertRaises(SAXException):
245 self.check_parseString(xml_bytes(self.data, 'iso-8859-1', None))
248 def test_make_parser2(self):
265 def test_make_parser3(self):
275 def test_make_parser4(self):
284 def test_make_parser5(self):
302 def test_escape_basic(self):
303 self.assertEqual(escape("Donald Duck & Co"), "Donald Duck & Co")
305 def test_escape_all(self):
306 self.assertEqual(escape("<Donald Duck & Co>"),
309 def test_escape_extra(self):
310 self.assertEqual(escape("Hei på deg", {"å" : "å"}),
314 def test_unescape_basic(self):
315 self.assertEqual(unescape("Donald Duck & Co"), "Donald Duck & Co")
317 def test_unescape_all(self):
318 self.assertEqual(unescape("<Donald Duck & Co>"),
321 def test_unescape_extra(self):
322 self.assertEqual(unescape("Hei på deg", {"å" : "å"}),
325 def test_unescape_amp_extra(self):
326 self.assertEqual(unescape("&foo;", {"&foo;": "splat"}), "&foo;")
329 def test_quoteattr_basic(self):
330 self.assertEqual(quoteattr("Donald Duck & Co"),
333 def test_single_quoteattr(self):
334 self.assertEqual(quoteattr('Includes "double" quotes'),
337 def test_double_quoteattr(self):
338 self.assertEqual(quoteattr("Includes 'single' quotes"),
341 def test_single_double_quoteattr(self):
342 self.assertEqual(quoteattr("Includes 'single' and \"double\" quotes"),
346 def test_make_parser(self):
354 def setUp(self):
355 self.file = os_helper.TESTFN
356 with open(self.file, "w") as tmp:
359 def tearDown(self):
360 os_helper.unlink(self.file)
362 def make_byte_stream(self):
365 def make_character_stream(self):
368 def checkContent(self, stream, content):
369 self.assertIsNotNone(stream)
370 self.assertEqual(stream.read(), content)
374 def test_character_stream(self):
376 src = InputSource(self.file)
377 src.setCharacterStream(self.make_character_stream())
379 self.assertIsNone(prep.getByteStream())
380 self.checkContent(prep.getCharacterStream(),
383 def test_byte_stream(self):
386 src = InputSource(self.file)
387 src.setByteStream(self.make_byte_stream())
389 self.assertIsNone(prep.getCharacterStream())
390 self.checkContent(prep.getByteStream(),
393 def test_system_id(self):
396 src = InputSource(self.file)
398 self.assertIsNone(prep.getCharacterStream())
399 self.checkContent(prep.getByteStream(),
402 def test_string(self):
404 prep = prepare_input_source(self.file)
405 self.assertIsNone(prep.getCharacterStream())
406 self.checkContent(prep.getByteStream(),
409 def test_path_objects(self):
411 prep = prepare_input_source(FakePath(self.file))
412 self.assertIsNone(prep.getCharacterStream())
413 self.checkContent(prep.getByteStream(),
416 def test_binary_file(self):
419 prep = prepare_input_source(self.make_byte_stream())
420 self.assertIsNone(prep.getCharacterStream())
421 self.checkContent(prep.getByteStream(),
424 def test_text_file(self):
427 prep = prepare_input_source(self.make_character_stream())
428 self.assertIsNone(prep.getByteStream())
429 self.checkContent(prep.getCharacterStream(),
436 def test_xmlgen_basic(self):
437 result = self.ioclass()
444 self.assertEqual(result.getvalue(), self.xml("<doc></doc>"))
446 def test_xmlgen_basic_empty(self):
447 result = self.ioclass()
454 self.assertEqual(result.getvalue(), self.xml("<doc/>"))
456 def test_xmlgen_content(self):
457 result = self.ioclass()
466 self.assertEqual(result.getvalue(), self.xml("<doc>huhei</doc>"))
468 def test_xmlgen_content_empty(self):
469 result = self.ioclass()
478 self.assertEqual(result.getvalue(), self.xml("<doc>huhei</doc>"))
480 def test_xmlgen_pi(self):
481 result = self.ioclass()
490 self.assertEqual(result.getvalue(),
491 self.xml("<?test data?><doc></doc>"))
493 def test_xmlgen_content_escape(self):
494 result = self.ioclass()
503 self.assertEqual(result.getvalue(),
504 self.xml("<doc><huhei&</doc>"))
506 def test_xmlgen_attr_escape(self):
507 result = self.ioclass()
521 self.assertEqual(result.getvalue(), self.xml(
526 def test_xmlgen_encoding(self):
531 result = self.ioclass()
540 self.assertEqual(result.getvalue(),
541 self.xml('<doc a="\u20ac">\u20ac</doc>', encoding=encoding))
543 def test_xmlgen_unencodable(self):
544 result = self.ioclass()
553 self.assertEqual(result.getvalue(),
554 self.xml('<doc a="€">€</doc>', encoding='ascii'))
556 def test_xmlgen_ignorable(self):
557 result = self.ioclass()
566 self.assertEqual(result.getvalue(), self.xml("<doc> </doc>"))
568 def test_xmlgen_ignorable_empty(self):
569 result = self.ioclass()
578 self.assertEqual(result.getvalue(), self.xml("<doc> </doc>"))
580 def test_xmlgen_encoding_bytes(self):
585 result = self.ioclass()
595 self.assertEqual(result.getvalue(),
596 self.xml('<doc a="\u20ac">\u20ac </doc>', encoding=encoding))
598 def test_xmlgen_ns(self):
599 result = self.ioclass()
612 self.assertEqual(result.getvalue(), self.xml(
616 def test_xmlgen_ns_empty(self):
617 result = self.ioclass()
630 self.assertEqual(result.getvalue(), self.xml(
634 def test_1463026_1(self):
635 result = self.ioclass()
643 self.assertEqual(result.getvalue(), self.xml('<a b="c"></a>'))
645 def test_1463026_1_empty(self):
646 result = self.ioclass()
654 self.assertEqual(result.getvalue(), self.xml('<a b="c"/>'))
656 def test_1463026_2(self):
657 result = self.ioclass()
667 self.assertEqual(result.getvalue(), self.xml('<a xmlns="qux"></a>'))
669 def test_1463026_2_empty(self):
670 result = self.ioclass()
680 self.assertEqual(result.getvalue(), self.xml('<a xmlns="qux"/>'))
682 def test_1463026_3(self):
683 result = self.ioclass()
693 self.assertEqual(result.getvalue(),
694 self.xml('<my:a xmlns:my="qux" b="c"></my:a>'))
696 def test_1463026_3_empty(self):
697 result = self.ioclass()
707 self.assertEqual(result.getvalue(),
708 self.xml('<my:a xmlns:my="qux" b="c"/>'))
710 def test_5027_1(self):
725 result = self.ioclass()
730 self.assertEqual(result.getvalue(),
731 self.xml(
736 def test_5027_2(self):
744 result = self.ioclass()
758 self.assertEqual(result.getvalue(),
759 self.xml(
764 def test_no_close_file(self):
765 result = self.ioclass()
771 self.assertFalse(result.closed)
773 def test_xmlgen_fragment(self):
774 result = self.ioclass()
785 self.assertEqual(result.getvalue(),
786 self.xml('<foo a="1.0">Hello</foo><bar b="2.0"></bar>')[len(self.xml('')):])
791 def xml(self, doc, encoding='iso-8859-1'):
799 def xml(self, doc, encoding='iso-8859-1'):
808 def seekable(self):
811 def tell(self):
813 return len(self)
815 def getvalue(self):
816 return b''.join(self)
819 def ioclass(self):
825 def xml(self, doc, encoding='iso-8859-1'):
832 def ioclass(self):
833 writer = codecs.open(self.fname, 'w', encoding='ascii',
837 os_helper.unlink(self.fname)
838 self.addCleanup(cleanup)
847 def xml(self, doc, encoding='iso-8859-1'):
855 def test_filter_basic(self):
868 self.assertEqual(result.getvalue(), start + b"<doc>content </doc>")
883 def test_expat_binary_file(self):
892 self.assertEqual(result.getvalue(), xml_test_out)
894 def test_expat_text_file(self):
903 self.assertEqual(result.getvalue(), xml_test_out)
906 def test_expat_binary_file_nonascii(self):
909 self.addCleanup(os_helper.unlink, fname)
918 self.assertEqual(result.getvalue(), xml_test_out)
920 def test_expat_binary_file_bytes_name(self):
930 self.assertEqual(result.getvalue(), xml_test_out)
932 def test_expat_binary_file_int_name(self):
942 self.assertEqual(result.getvalue(), xml_test_out)
948 def __init__(self):
949 self._notations = []
950 self._entities = []
952 def notationDecl(self, name, publicId, systemId):
953 self._notations.append((name, publicId, systemId))
955 def unparsedEntityDecl(self, name, publicId, systemId, ndata):
956 self._entities.append((name, publicId, systemId, ndata))
960 def __init__(self):
961 self.entities = []
963 def resolveEntity(self, publicId, systemId):
964 self.entities.append((publicId, systemId))
970 def test_expat_dtdhandler(self):
972 handler = self.TestDTDHandler()
982 self.assertEqual(handler._notations,
984 self.assertEqual(handler._entities, [("img", None, "expat.gif", "GIF")])
986 def test_expat_external_dtd_enabled(self):
988 self.addCleanup(urllib.request.urlcleanup)
992 resolver = self.TestEntityRecorder()
995 with self.assertRaises(URLError):
999 self.assertEqual(
1003 def test_expat_external_dtd_default(self):
1005 resolver = self.TestEntityRecorder()
1013 self.assertEqual(resolver.entities, [])
1019 def resolveEntity(self, publicId, systemId):
1024 def test_expat_entityresolver_enabled(self):
1027 parser.setEntityResolver(self.TestEntityResolver())
1037 self.assertEqual(result.getvalue(), start +
1040 def test_expat_entityresolver_default(self):
1042 self.assertEqual(parser.getFeature(feature_external_ges), False)
1043 parser.setEntityResolver(self.TestEntityResolver())
1053 self.assertEqual(result.getvalue(), start +
1060 def startElement(self, name, attrs):
1061 self._attrs = attrs
1063 def startElementNS(self, name, qname, attrs):
1064 self._attrs = attrs
1066 def test_expat_attrs_empty(self):
1068 gather = self.AttrGatherer()
1074 self.verify_empty_attrs(gather._attrs)
1076 def test_expat_attrs_wattr(self):
1078 gather = self.AttrGatherer()
1084 self.verify_attrs_wattr(gather._attrs)
1086 def test_expat_nsattrs_empty(self):
1088 gather = self.AttrGatherer()
1094 self.verify_empty_nsattrs(gather._attrs)
1096 def test_expat_nsattrs_wattr(self):
1098 gather = self.AttrGatherer()
1106 self.assertEqual(attrs.getLength(), 1)
1107 self.assertEqual(attrs.getNames(), [(ns_uri, "attr")])
1108 self.assertTrue((attrs.getQNames() == [] or
1110 self.assertEqual(len(attrs), 1)
1111 self.assertIn((ns_uri, "attr"), attrs)
1112 self.assertEqual(attrs.get((ns_uri, "attr")), "val")
1113 self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val")
1114 self.assertEqual(list(attrs.items()), [((ns_uri, "attr"), "val")])
1115 self.assertEqual(list(attrs.values()), ["val"])
1116 self.assertEqual(attrs.getValue((ns_uri, "attr")), "val")
1117 self.assertEqual(attrs[(ns_uri, "attr")], "val")
1121 def test_expat_inpsource_filename(self):
1129 self.assertEqual(result.getvalue(), xml_test_out)
1131 def test_expat_inpsource_sysid(self):
1139 self.assertEqual(result.getvalue(), xml_test_out)
1142 def test_expat_inpsource_sysid_nonascii(self):
1145 self.addCleanup(os_helper.unlink, fname)
1154 self.assertEqual(result.getvalue(), xml_test_out)
1156 def test_expat_inpsource_byte_stream(self):
1167 self.assertEqual(result.getvalue(), xml_test_out)
1169 def test_expat_inpsource_character_stream(self):
1180 self.assertEqual(result.getvalue(), xml_test_out)
1184 def test_expat_incremental(self):
1194 self.assertEqual(result.getvalue(), start + b"<doc></doc>")
1196 def test_expat_incremental_reset(self):
1215 self.assertEqual(result.getvalue(), start + b"<doc>text</doc>")
1219 def test_expat_locator_noinfo(self):
1229 self.assertEqual(parser.getSystemId(), None)
1230 self.assertEqual(parser.getPublicId(), None)
1231 self.assertEqual(parser.getLineNumber(), 1)
1233 def test_expat_locator_withinfo(self):
1240 self.assertEqual(parser.getSystemId(), TEST_XMLFILE)
1241 self.assertEqual(parser.getPublicId(), None)
1244 def test_expat_locator_withinfo_nonascii(self):
1247 self.addCleanup(os_helper.unlink, fname)
1255 self.assertEqual(parser.getSystemId(), fname)
1256 self.assertEqual(parser.getPublicId(), None)
1266 def test_expat_inpsource_location(self):
1275 self.fail()
1277 self.assertEqual(e.getSystemId(), name)
1279 def test_expat_incomplete(self):
1282 self.assertRaises(SAXParseException, parser.parse, StringIO("<foo>"))
1283 self.assertEqual(parser.getColumnNumber(), 5)
1284 self.assertEqual(parser.getLineNumber(), 1)
1286 def test_sax_parse_exception_str(self):
1293 self.DummyLocator(1, 1)))
1296 self.DummyLocator(None, 1)))
1299 self.DummyLocator(1, None)))
1302 self.DummyLocator(None, None)))
1305 def __init__(self, lineno, colno):
1306 self._lineno = lineno
1307 self._colno = colno
1309 def getPublicId(self):
1312 def getSystemId(self):
1315 def getLineNumber(self):
1316 return self._lineno
1318 def getColumnNumber(self):
1319 return self._colno
1330 def test_attrs_empty(self):
1331 self.verify_empty_attrs(AttributesImpl({}))
1333 def test_attrs_wattr(self):
1334 self.verify_attrs_wattr(AttributesImpl({"attr" : "val"}))
1336 def test_nsattrs_empty(self):
1337 self.verify_empty_nsattrs(AttributesNSImpl({}, {}))
1339 def test_nsattrs_wattr(self):
1343 self.assertEqual(attrs.getLength(), 1)
1344 self.assertEqual(attrs.getNames(), [(ns_uri, "attr")])
1345 self.assertEqual(attrs.getQNames(), ["ns:attr"])
1346 self.assertEqual(len(attrs), 1)
1347 self.assertIn((ns_uri, "attr"), attrs)
1348 self.assertEqual(list(attrs.keys()), [(ns_uri, "attr")])
1349 self.assertEqual(attrs.get((ns_uri, "attr")), "val")
1350 self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val")
1351 self.assertEqual(list(attrs.items()), [((ns_uri, "attr"), "val")])
1352 self.assertEqual(list(attrs.values()), ["val"])
1353 self.assertEqual(attrs.getValue((ns_uri, "attr")), "val")
1354 self.assertEqual(attrs.getValueByQName("ns:attr"), "val")
1355 self.assertEqual(attrs.getNameByQName("ns:attr"), (ns_uri, "attr"))
1356 self.assertEqual(attrs[(ns_uri, "attr")], "val")
1357 self.assertEqual(attrs.getQNameByName((ns_uri, "attr")), "ns:attr")
1361 def setUp(self):
1362 self.parser = None
1364 self.specified_version = '1.0'
1365 self.specified_encoding = 'UTF-8'
1366 self.specified_doctype = 'wish'
1367 self.specified_entity_names = ('nbsp', 'source', 'target')
1368 self.specified_comment = ('Comment in a DTD',
1370 self.test_data = StringIO()
1371 self.test_data.write('<?xml version="{}" encoding="{}"?>\n'.
1372 format(self.specified_version,
1373 self.specified_encoding))
1374 self.test_data.write('<!DOCTYPE {} [\n'.
1375 format(self.specified_doctype))
1376 self.test_data.write('<!-- {} -->\n'.
1377 format(self.specified_comment[0]))
1378 self.test_data.write('<!ELEMENT {} (to,from,heading,body,footer)>\n'.
1379 format(self.specified_doctype))
1380 self.test_data.write('<!ELEMENT to (#PCDATA)>\n')
1381 self.test_data.write('<!ELEMENT from (#PCDATA)>\n')
1382 self.test_data.write('<!ELEMENT heading (#PCDATA)>\n')
1383 self.test_data.write('<!ELEMENT body (#PCDATA)>\n')
1384 self.test_data.write('<!ELEMENT footer (#PCDATA)>\n')
1385 self.test_data.write('<!ENTITY {} " ">\n'.
1386 format(self.specified_entity_names[0]))
1387 self.test_data.write('<!ENTITY {} "Written by: Alexander.">\n'.
1388 format(self.specified_entity_names[1]))
1389 self.test_data.write('<!ENTITY {} "Hope it gets to: Aristotle.">\n'.
1390 format(self.specified_entity_names[2]))
1391 self.test_data.write(']>\n')
1392 self.test_data.write('<{}>'.format(self.specified_doctype))
1393 self.test_data.write('<to>Aristotle</to>\n')
1394 self.test_data.write('<from>Alexander</from>\n')
1395 self.test_data.write('<heading>Supplication</heading>\n')
1396 self.test_data.write('<body>Teach me patience!</body>\n')
1397 self.test_data.write('<footer>&{};&{};&{};</footer>\n'.
1398 format(self.specified_entity_names[1],
1399 self.specified_entity_names[0],
1400 self.specified_entity_names[2]))
1401 self.test_data.write('<!-- {} -->\n'.format(self.specified_comment[1]))
1402 self.test_data.write('</{}>\n'.format(self.specified_doctype))
1403 self.test_data.seek(0)
1406 self.version = None
1407 self.encoding = None
1408 self.standalone = None
1409 self.doctype = None
1410 self.publicID = None
1411 self.systemID = None
1412 self.end_of_dtd = False
1413 self.comments = []
1415 def test_handlers(self):
1417 def __init__(self, test_harness, *args, **kwargs):
1419 self.test_harness = test_harness
1421 def startDTD(self, doctype, publicID, systemID):
1422 self.test_harness.doctype = doctype
1423 self.test_harness.publicID = publicID
1424 self.test_harness.systemID = systemID
1426 def endDTD(self):
1427 self.test_harness.end_of_dtd = True
1429 def comment(self, text):
1430 self.test_harness.comments.append(text)
1432 self.parser = create_parser()
1433 self.parser.setContentHandler(ContentHandler())
1434 self.parser.setProperty(
1436 TestLexicalHandler(self))
1438 source.setCharacterStream(self.test_data)
1439 self.parser.parse(source)
1440 self.assertEqual(self.doctype, self.specified_doctype)
1441 self.assertIsNone(self.publicID)
1442 self.assertIsNone(self.systemID)
1443 self.assertTrue(self.end_of_dtd)
1444 self.assertEqual(len(self.comments),
1445 len(self.specified_comment))
1446 self.assertEqual(f' {self.specified_comment[0]} ', self.comments[0])
1450 def setUp(self):
1451 self.parser = None
1452 self.specified_chars = []
1453 self.specified_chars.append(('Parseable character data', False))
1454 self.specified_chars.append(('<> &% - assorted other XML junk.', True))
1455 self.char_index = 0 # Used to index specified results within handlers
1456 self.test_data = StringIO()
1457 self.test_data.write('<root_doc>\n')
1458 self.test_data.write('<some_pcdata>\n')
1459 self.test_data.write(f'{self.specified_chars[0][0]}\n')
1460 self.test_data.write('</some_pcdata>\n')
1461 self.test_data.write('<some_cdata>\n')
1462 self.test_data.write(f'<![CDATA[{self.specified_chars[1][0]}]]>\n')
1463 self.test_data.write('</some_cdata>\n')
1464 self.test_data.write('</root_doc>\n')
1465 self.test_data.seek(0)
1468 self.chardata = []
1469 self.in_cdata = False
1471 def test_handlers(self):
1473 def __init__(self, test_harness, *args, **kwargs):
1475 self.test_harness = test_harness
1477 def startCDATA(self):
1478 self.test_harness.in_cdata = True
1480 def endCDATA(self):
1481 self.test_harness.in_cdata = False
1484 def __init__(self, test_harness, *args, **kwargs):
1486 self.test_harness = test_harness
1488 def characters(self, content):
1490 h = self.test_harness
1496 self.parser = create_parser()
1497 self.parser.setContentHandler(TestCharHandler(self))
1498 self.parser.setProperty(
1500 TestLexicalHandler(self))
1502 source.setCharacterStream(self.test_data)
1503 self.parser.parse(source)
1505 self.assertFalse(self.in_cdata)
1506 self.assertEqual(self.char_index, 2)