Lines Matching refs:self
19 def setUp(self):
20 self.parser = expat.ParserCreate(namespace_separator='!')
22 def test_buffer_text(self):
23 self.assertIs(self.parser.buffer_text, False)
25 self.parser.buffer_text = x
26 self.assertIs(self.parser.buffer_text, bool(x))
28 def test_namespace_prefixes(self):
29 self.assertIs(self.parser.namespace_prefixes, False)
31 self.parser.namespace_prefixes = x
32 self.assertIs(self.parser.namespace_prefixes, bool(x))
34 def test_ordered_attributes(self):
35 self.assertIs(self.parser.ordered_attributes, False)
37 self.parser.ordered_attributes = x
38 self.assertIs(self.parser.ordered_attributes, bool(x))
40 def test_specified_attributes(self):
41 self.assertIs(self.parser.specified_attributes, False)
43 self.parser.specified_attributes = x
44 self.assertIs(self.parser.specified_attributes, bool(x))
46 def test_invalid_attributes(self):
47 with self.assertRaises(AttributeError):
48 self.parser.returns_unicode = 1
49 with self.assertRaises(AttributeError):
50 self.parser.returns_unicode
53 self.assertRaises(TypeError, setattr, self.parser, range(0xF), 0)
54 self.assertRaises(TypeError, self.parser.__setattr__, range(0xF), 0)
55 self.assertRaises(TypeError, getattr, self.parser, range(0xF))
87 def __init__(self):
88 self.out = []
90 def StartElementHandler(self, name, attrs):
91 self.out.append('Start element: ' + repr(name) + ' ' +
94 def EndElementHandler(self, name):
95 self.out.append('End element: ' + repr(name))
97 def CharacterDataHandler(self, data):
100 self.out.append('Character data: ' + repr(data))
102 def ProcessingInstructionHandler(self, target, data):
103 self.out.append('PI: ' + repr(target) + ' ' + repr(data))
105 def StartNamespaceDeclHandler(self, prefix, uri):
106 self.out.append('NS decl: ' + repr(prefix) + ' ' + repr(uri))
108 def EndNamespaceDeclHandler(self, prefix):
109 self.out.append('End of NS decl: ' + repr(prefix))
111 def StartCdataSectionHandler(self):
112 self.out.append('Start of CDATA section')
114 def EndCdataSectionHandler(self):
115 self.out.append('End of CDATA section')
117 def CommentHandler(self, text):
118 self.out.append('Comment: ' + repr(text))
120 def NotationDeclHandler(self, *args):
122 self.out.append('Notation declared: %s' %(args,))
124 def UnparsedEntityDeclHandler(self, *args):
126 self.out.append('Unparsed entity decl: %s' %(args,))
128 def NotStandaloneHandler(self):
129 self.out.append('Not standalone')
132 def ExternalEntityRefHandler(self, *args):
134 self.out.append('External entity ref: %s' %(args[1:],))
137 def StartDoctypeDeclHandler(self, *args):
138 self.out.append(('Start doctype', args))
141 def EndDoctypeDeclHandler(self):
142 self.out.append("End doctype")
145 def EntityDeclHandler(self, *args):
146 self.out.append(('Entity declaration', args))
149 def XmlDeclHandler(self, *args):
150 self.out.append(('XML declaration', args))
153 def ElementDeclHandler(self, *args):
154 self.out.append(('Element declaration', args))
157 def AttlistDeclHandler(self, *args):
158 self.out.append(('Attribute list declaration', args))
161 def SkippedEntityHandler(self, *args):
162 self.out.append(("Skipped entity", args))
165 def DefaultHandler(self, userData):
168 def DefaultHandlerExpand(self, userData):
183 def _hookup_callbacks(self, parser, handler):
186 self.handler_names on the given parser.
188 for name in self.handler_names:
191 def _verify_parse_output(self, operations):
227 self.assertEqual(operation, expected_operation)
229 def test_parse_bytes(self):
230 out = self.Outputter()
232 self._hookup_callbacks(parser, out)
237 self._verify_parse_output(operations)
239 self.assertRaises(AttributeError, getattr, parser, '\uD800')
241 def test_parse_str(self):
242 out = self.Outputter()
244 self._hookup_callbacks(parser, out)
249 self._verify_parse_output(operations)
251 def test_parse_file(self):
253 out = self.Outputter()
255 self._hookup_callbacks(parser, out)
261 self._verify_parse_output(operations)
263 def test_parse_again(self):
270 with self.assertRaises(expat.error) as cm:
272 self.assertEqual(expat.ErrorString(cm.exception.code),
276 def test_legal(self):
283 def test_illegal(self):
286 self.fail()
288 self.assertEqual(str(e),
293 self.fail()
295 self.assertEqual(str(e),
298 def test_zero_length(self):
311 def test(self):
321 self.assertEqual(len(L), 6)
324 self.assertTrue(tag is entry)
326 def test_issue9402(self):
329 def __init__(self, parser):
330 self.parser = parser
331 self.parser_result = None
333 def ExternalEntityRefHandler(self, context, base, sysId, pubId):
334 external_parser = self.parser.ExternalEntityParserCreate("")
335 self.parser_result = external_parser.Parse(b"", True)
343 self.assertEqual(out.parser_result, 1)
347 def setUp(self):
348 self.stuff = []
349 self.parser = expat.ParserCreate()
350 self.parser.buffer_text = 1
351 self.parser.CharacterDataHandler = self.CharacterDataHandler
353 def check(self, expected, label):
354 self.assertEqual(self.stuff, expected,
356 % (label, self.stuff, map(str, expected)))
358 def CharacterDataHandler(self, text):
359 self.stuff.append(text)
361 def StartElementHandler(self, name, attrs):
362 self.stuff.append("<%s>" % name)
365 self.parser.buffer_text = 1
367 self.parser.buffer_text = 0
369 def EndElementHandler(self, name):
370 self.stuff.append("</%s>" % name)
372 def CommentHandler(self, data):
373 self.stuff.append("<!--%s-->" % data)
375 def setHandlers(self, handlers=[]):
377 setattr(self.parser, name, getattr(self, name))
379 def test_default_to_disabled(self):
381 self.assertFalse(parser.buffer_text)
383 def test_buffering_enabled(self):
385 self.assertTrue(self.parser.buffer_text)
386 self.parser.Parse(b"<a>1<b/>2<c/>3</a>", True)
387 self.assertEqual(self.stuff, ['123'],
390 def test1(self):
393 self.setHandlers(["StartElementHandler"])
394 self.parser.Parse(b"<a>1<b buffer-text='no'/>2\n3<c buffer-text='yes'/>4\n5</a>", True)
395 self.assertEqual(self.stuff,
399 def test2(self):
400 self.parser.Parse(b"<a>1<b/><2><c/> \n 3</a>", True)
401 self.assertEqual(self.stuff, ["1<2> \n 3"],
404 def test3(self):
405 self.setHandlers(["StartElementHandler"])
406 self.parser.Parse(b"<a>1<b/>2<c/>3</a>", True)
407 self.assertEqual(self.stuff, ["<a>", "1", "<b>", "2", "<c>", "3"],
410 def test4(self):
411 self.setHandlers(["StartElementHandler", "EndElementHandler"])
412 self.parser.CharacterDataHandler = None
413 self.parser.Parse(b"<a>1<b/>2<c/>3</a>", True)
414 self.assertEqual(self.stuff,
417 def test5(self):
418 self.setHandlers(["StartElementHandler", "EndElementHandler"])
419 self.parser.Parse(b"<a>1<b></b>2<c/>3</a>", True)
420 self.assertEqual(self.stuff,
423 def test6(self):
424 self.setHandlers(["CommentHandler", "EndElementHandler",
426 self.parser.Parse(b"<a>1<b/>2<c></c>345</a> ", True)
427 self.assertEqual(self.stuff,
431 def test7(self):
432 self.setHandlers(["CommentHandler", "EndElementHandler",
434 self.parser.Parse(b"<a>1<b/>2<c></c>3<!--abc-->4<!--def-->5</a> ", True)
435 self.assertEqual(self.stuff,
443 def StartElementHandler(self, name, attrs):
446 def check_traceback_entry(self, entry, filename, funcname):
447 self.assertEqual(os.path.basename(entry[0]), filename)
448 self.assertEqual(entry[2], funcname)
450 def test_exception(self):
452 parser.StartElementHandler = self.StartElementHandler
455 self.fail()
457 self.assertEqual(e.args[0], 'a',
462 self.assertEqual(len(entries), 3)
463 self.check_traceback_entry(entries[0],
465 self.check_traceback_entry(entries[1],
467 self.check_traceback_entry(entries[2],
474 self.assertIn('call_with_frame("StartElement"', entries[1][3])
479 def StartElementHandler(self, name, attrs):
480 self.check_pos('s')
482 def EndElementHandler(self, name):
483 self.check_pos('e')
485 def check_pos(self, event):
487 self.parser.CurrentByteIndex,
488 self.parser.CurrentLineNumber,
489 self.parser.CurrentColumnNumber)
490 self.assertTrue(self.upto < len(self.expected_list),
492 expected = self.expected_list[self.upto]
493 self.assertEqual(pos, expected,
495 self.upto += 1
497 def test(self):
498 self.parser = expat.ParserCreate()
499 self.parser.StartElementHandler = self.StartElementHandler
500 self.parser.EndElementHandler = self.EndElementHandler
501 self.upto = 0
502 self.expected_list = [('s', 0, 1, 0), ('s', 5, 2, 1), ('s', 11, 3, 2),
506 self.parser.Parse(xml, True)
510 def test_parse_only_xml_data(self):
526 self.assertRaises(Exception, parser.Parse, xml.encode('iso8859'))
533 def test_1025_bytes(self):
534 self.assertEqual(self.small_buffer_test(1025), 2)
536 def test_1000_bytes(self):
537 self.assertEqual(self.small_buffer_test(1000), 1)
539 def test_wrong_size(self):
542 with self.assertRaises(ValueError):
544 with self.assertRaises(ValueError):
546 with self.assertRaises((ValueError, OverflowError)):
548 with self.assertRaises(TypeError):
551 def test_unchanged_size(self):
555 parser.CharacterDataHandler = self.counting_handler
561 self.n = 0
563 self.assertEqual(self.n, 1)
567 self.assertEqual(self.n, 1)
571 self.assertEqual(self.n, 2)
574 def test_disabling_buffer(self):
579 parser.CharacterDataHandler = self.counting_handler
582 self.assertEqual(parser.buffer_size, 1024)
585 self.n = 0
587 self.assertEqual(parser.buffer_size, 1024)
588 self.assertEqual(self.n, 1)
592 self.assertFalse(parser.buffer_text)
593 self.assertEqual(parser.buffer_size, 1024)
596 self.assertEqual(self.n, 11)
599 self.assertTrue(parser.buffer_text)
600 self.assertEqual(parser.buffer_size, 1024)
602 self.assertEqual(self.n, 12)
604 def counting_handler(self, text):
605 self.n += 1
607 def small_buffer_test(self, buffer_len):
610 parser.CharacterDataHandler = self.counting_handler
614 self.n = 0
616 return self.n
618 def test_change_size_1(self):
622 parser.CharacterDataHandler = self.counting_handler
625 self.assertEqual(parser.buffer_size, 1024)
627 self.n = 0
630 self.assertEqual(parser.buffer_size, 2048)
632 self.assertEqual(self.n, 2)
634 def test_change_size_2(self):
638 parser.CharacterDataHandler = self.counting_handler
641 self.assertEqual(parser.buffer_size, 2048)
643 self.n=0
646 self.assertEqual(parser.buffer_size, 1024)
648 self.assertEqual(self.n, 4)
651 def test1(self):
656 self.fail()
658 self.assertEqual(str(e), 'unclosed token: line 2, column 0')
660 def test2(self):
665 with self.assertRaisesRegex(expat.ExpatError, err_pattern):
669 def test_codes(self):
671 self.assertEqual(errors.XML_ERROR_SYNTAX,
674 def test_expaterror(self):
679 self.fail()
681 self.assertEqual(e.code,
689 def test_use_foreign_dtd(self):
705 self.assertEqual(handler_call_args, [(None, None)])
715 self.assertEqual(handler_call_args, [(None, None)])
717 def test_ignore_use_foreign_dtd(self):
734 self.assertEqual(handler_call_args, [("bar", "baz")])