Lines Matching refs:self
25 def default_builder(self): argument
28 def soup(self, markup, **kwargs): argument
30 builder = kwargs.pop('builder', self.default_builder)
33 def document_for(self, markup): argument
38 return self.default_builder.test_fragment_to_document(markup)
40 def assertSoupEquals(self, to_parse, compare_parsed_to=None): argument
41 builder = self.default_builder
46 self.assertEqual(obj.decode(), self.document_for(compare_parsed_to))
48 def assertConnectedness(self, element): argument
55 self.assertEqual(e, earlier.next_element)
56 self.assertEqual(earlier, e.previous_element)
69 def test_pickle_and_unpickle_identity(self): argument
72 tree = self.soup("<a><b>foo</a>")
75 self.assertEqual(loaded.__class__, BeautifulSoup)
76 self.assertEqual(loaded.decode(), tree.decode())
78 def assertDoctypeHandled(self, doctype_fragment): argument
80 doctype_str, soup = self._document_with_doctype(doctype_fragment)
84 self.assertEqual(doctype.__class__, Doctype)
85 self.assertEqual(doctype, doctype_fragment)
86 self.assertEqual(str(soup)[:len(doctype_str)], doctype_str)
90 self.assertEqual(soup.p.contents[0], 'foo')
92 def _document_with_doctype(self, doctype_fragment): argument
96 soup = self.soup(markup)
99 def test_normal_doctypes(self): argument
101 self.assertDoctypeHandled("html")
102 self.assertDoctypeHandled(
105 def test_empty_doctype(self): argument
106 soup = self.soup("<!DOCTYPE>")
108 self.assertEqual("", doctype.strip())
110 def test_public_doctype_with_url(self): argument
112 self.assertDoctypeHandled(doctype)
114 def test_system_doctype(self): argument
115 self.assertDoctypeHandled('foo SYSTEM "http://www.example.com/"')
117 def test_namespaced_system_doctype(self): argument
119 self.assertDoctypeHandled('xsl:stylesheet SYSTEM "htmlent.dtd"')
121 def test_namespaced_public_doctype(self): argument
123 self.assertDoctypeHandled('xsl:stylesheet PUBLIC "htmlent.dtd"')
125 def test_real_xhtml_document(self): argument
133 soup = self.soup(markup)
134 self.assertEqual(
138 def test_processing_instruction(self): argument
140 soup = self.soup(markup)
141 self.assertEqual(markup, soup.encode("utf8"))
143 def test_deepcopy(self): argument
149 copy.deepcopy(self.default_builder)
151 def test_p_tag_is_never_empty_element(self): argument
157 soup = self.soup("<p/>")
158 self.assertFalse(soup.p.is_empty_element)
159 self.assertEqual(str(soup.p), "<p></p>")
161 def test_unclosed_tags_get_closed(self): argument
166 self.assertSoupEquals("<p>", "<p></p>")
167 self.assertSoupEquals("<b>", "<b></b>")
169 self.assertSoupEquals("<br>", "<br/>")
171 def test_br_is_always_empty_element_tag(self): argument
177 soup = self.soup("<br></br>")
178 self.assertTrue(soup.br.is_empty_element)
179 self.assertEqual(str(soup.br), "<br/>")
181 def test_nested_formatting_elements(self): argument
182 self.assertSoupEquals("<em><em></em></em>")
184 def test_double_head(self): argument
198 soup = self.soup(html)
199 self.assertEqual("text/javascript", soup.find('script')['type'])
201 def test_comment(self): argument
204 self.assertSoupEquals(markup)
206 soup = self.soup(markup)
208 self.assertEqual(comment.__class__, Comment)
212 self.assertEqual(comment, foo.next_element)
214 self.assertEqual(comment, baz.previous_element)
216 def test_preserved_whitespace_in_pre_and_textarea(self): argument
218 self.assertSoupEquals("<pre> </pre>")
219 self.assertSoupEquals("<textarea> woo </textarea>")
221 def test_nested_inline_elements(self): argument
224 self.assertSoupEquals(b_tag)
227 self.assertSoupEquals(nested_b_tag)
230 self.assertSoupEquals(nested_b_tag)
232 def test_nested_block_level_elements(self): argument
234 soup = self.soup('<blockquote><p><b>Foo</b></p></blockquote>')
236 self.assertEqual(blockquote.p.b.string, 'Foo')
237 self.assertEqual(blockquote.b.string, 'Foo')
239 def test_correctly_nested_tables(self): argument
248 self.assertSoupEquals(
254 self.assertSoupEquals(
259 def test_deeply_nested_multivalued_attribute(self): argument
264 soup = self.soup(markup)
265 self.assertEqual(["css"], soup.div.div['class'])
267 def test_multivalued_attribute_on_html(self): argument
272 soup = self.soup(markup)
273 self.assertEqual(["a", "b"], soup.html['class'])
275 def test_angle_brackets_in_attribute_values_are_escaped(self): argument
276 self.assertSoupEquals('<a b="<a>"></a>', '<a b="<a>"></a>')
278 def test_entities_in_attributes_converted_to_unicode(self): argument
280 self.assertSoupEquals('<p id="piñata"></p>', expect)
281 self.assertSoupEquals('<p id="piñata"></p>', expect)
282 self.assertSoupEquals('<p id="piñata"></p>', expect)
283 self.assertSoupEquals('<p id="piñata"></p>', expect)
285 def test_entities_in_text_converted_to_unicode(self): argument
287 self.assertSoupEquals("<p>piñata</p>", expect)
288 self.assertSoupEquals("<p>piñata</p>", expect)
289 self.assertSoupEquals("<p>piñata</p>", expect)
290 self.assertSoupEquals("<p>piñata</p>", expect)
292 def test_quot_entity_converted_to_quotation_mark(self): argument
293 self.assertSoupEquals("<p>I said "good day!"</p>",
296 def test_out_of_range_entity(self): argument
298 self.assertSoupEquals("�", expect)
299 self.assertSoupEquals("�", expect)
300 self.assertSoupEquals("�", expect)
302 def test_multipart_strings(self): argument
304 soup = self.soup("<html><h2>\nfoo</h2><p></p></html>")
305 self.assertEqual("p", soup.h2.string.next_element.name)
306 self.assertEqual("p", soup.p.name)
307 self.assertConnectedness(soup)
309 def test_head_tag_between_head_and_body(self): argument
316 soup = self.soup(content)
317 self.assertNotEqual(None, soup.html.body)
318 self.assertConnectedness(soup)
320 def test_multiple_copies_of_a_tag(self): argument
334 soup = self.soup(content)
335 self.assertConnectedness(soup.article)
337 def test_basic_namespaces(self): argument
343 soup = self.soup(markup)
344 self.assertEqual(markup, soup.encode())
346 self.assertEqual('http://www.w3.org/1999/xhtml', soup.html['xmlns'])
347 self.assertEqual(
349 self.assertEqual(
352 def test_multivalued_attribute_value_becomes_list(self): argument
354 soup = self.soup(markup)
355 self.assertEqual(['foo', 'bar'], soup.a['class'])
364 def test_can_parse_unicode_document(self): argument
369 soup = self.soup(markup)
370 self.assertEqual('Sacr\xe9 bleu!', soup.body.string)
372 def test_soupstrainer(self): argument
375 soup = self.soup("A <b>bold</b> <meta/> <i>statement</i>",
377 self.assertEqual(soup.decode(), "<b>bold</b>")
379 def test_single_quote_attribute_values_become_double_quotes(self): argument
380 self.assertSoupEquals("<foo attr='bar'></foo>",
383 def test_attribute_values_with_nested_quotes_are_left_alone(self): argument
385 self.assertSoupEquals(text)
387 def test_attribute_values_with_double_nested_quotes_get_quoted(self): argument
389 soup = self.soup(text)
391 self.assertSoupEquals(
395 def test_ampersand_in_attribute_value_gets_escaped(self): argument
396 self.assertSoupEquals('<this is="really messed up & stuff"></this>',
399 self.assertSoupEquals(
403 def test_escaped_ampersand_in_attribute_value_is_left_alone(self): argument
404 self.assertSoupEquals('<a href="http://example.org?a=1&b=2;3"></a>')
406 def test_entities_in_strings_converted_during_parsing(self): argument
411 self.assertSoupEquals(text, expected)
413 def test_smart_quotes_converted_on_the_way_in(self): argument
417 soup = self.soup(quote)
418 self.assertEqual(
422 def test_non_breaking_spaces_converted_on_the_way_in(self): argument
423 soup = self.soup("<a> </a>")
424 self.assertEqual(soup.a.string, "\N{NO-BREAK SPACE}" * 2)
426 def test_entities_converted_on_the_way_out(self): argument
429 soup = self.soup(text)
430 self.assertEqual(soup.p.encode("utf-8"), expected)
432 def test_real_iso_latin_document(self): argument
444 soup = self.soup(iso_latin_html)
457 self.assertEqual(result, expected)
459 def test_real_shift_jis_document(self): argument
469 soup = self.soup(unicode_html)
473 self.assertEqual(soup.encode("utf-8"), unicode_html.encode("utf-8"))
474 self.assertEqual(soup.encode("euc_jp"), unicode_html.encode("euc_jp"))
476 def test_real_hebrew_document(self): argument
480 soup = self.soup(
482 self.assertEqual(soup.original_encoding, 'iso8859-8')
483 self.assertEqual(
487 def test_meta_tag_reflects_current_encoding(self): argument
498 soup = self.soup(shift_jis_html)
503 self.assertEqual('text/html; charset=x-sjis', content)
506 self.assertTrue(isinstance(content, ContentMetaAttributeValue))
510 self.assertEqual('text/html; charset=utf8', content.encode("utf8"))
515 def test_html5_style_meta_tag_reflects_current_encoding(self): argument
525 soup = self.soup(shift_jis_html)
530 self.assertEqual('x-sjis', charset)
533 self.assertTrue(isinstance(charset, CharsetMetaAttributeValue))
537 self.assertEqual('utf8', charset.encode("utf8"))
539 def test_tag_with_no_attributes_can_have_attributes_added(self): argument
540 data = self.soup("<a>text</a>")
542 self.assertEqual('<a foo="bar">text</a>', data.a.decode())
546 def test_pickle_and_unpickle_identity(self): argument
549 tree = self.soup("<a><b>foo</a>")
552 self.assertEqual(loaded.__class__, BeautifulSoup)
553 self.assertEqual(loaded.decode(), tree.decode())
555 def test_docstring_generated(self): argument
556 soup = self.soup("<root/>")
557 self.assertEqual(
560 def test_xml_declaration(self): argument
562 soup = self.soup(markup)
563 self.assertEqual(markup, soup.encode("utf8"))
565 def test_real_xhtml_document(self): argument
573 soup = self.soup(markup)
574 self.assertEqual(
577 def test_formatter_processes_script_tag_for_xml_documents(self): argument
587 self.assertTrue(b"< < hey > >" in encoded)
589 def test_can_parse_unicode_document(self): argument
591 soup = self.soup(markup)
592 self.assertEqual('Sacr\xe9 bleu!', soup.root.string)
594 def test_popping_namespaced_tag(self): argument
596 soup = self.soup(markup)
597 self.assertEqual(
600 def test_docstring_includes_correct_encoding(self): argument
601 soup = self.soup("<root/>")
602 self.assertEqual(
606 def test_large_xml_document(self): argument
611 soup = self.soup(markup)
612 self.assertEqual(soup.encode("utf-8"), markup)
615 def test_tags_are_empty_element_if_and_only_if_they_are_empty(self): argument
616 self.assertSoupEquals("<p>", "<p/>")
617 self.assertSoupEquals("<p>foo</p>")
619 def test_namespaces_are_preserved(self): argument
621 soup = self.soup(markup)
623 self.assertEqual("http://example.com/", root['xmlns:a'])
624 self.assertEqual("http://example.net/", root['xmlns:b'])
626 def test_closing_namespaced_tag(self): argument
628 soup = self.soup(markup)
629 self.assertEqual(str(soup.p), markup)
631 def test_namespaced_attributes(self): argument
633 soup = self.soup(markup)
634 self.assertEqual(str(soup.foo), markup)
636 def test_namespaced_attributes_xml_namespace(self): argument
638 soup = self.soup(markup)
639 self.assertEqual(str(soup.foo), markup)
644 def test_real_xhtml_document(self): argument
649 def test_html_tags_have_namespace(self): argument
651 soup = self.soup(markup)
652 self.assertEqual("http://www.w3.org/1999/xhtml", soup.a.namespace)
654 def test_svg_tags_have_namespace(self): argument
656 soup = self.soup(markup)
658 self.assertEqual(namespace, soup.svg.namespace)
659 self.assertEqual(namespace, soup.circle.namespace)
662 def test_mathml_tags_have_namespace(self): argument
664 soup = self.soup(markup)
666 self.assertEqual(namespace, soup.math.namespace)
667 self.assertEqual(namespace, soup.msqrt.namespace)
669 def test_xml_declaration_becomes_comment(self): argument
671 soup = self.soup(markup)
672 self.assertTrue(isinstance(soup.contents[0], Comment))
673 self.assertEqual(soup.contents[0], '?xml version="1.0" encoding="utf-8"?')
674 self.assertEqual("html", soup.contents[0].next_element.name)