← Back to branch summary

~ubuntu-branches/ubuntu/saucy/lxml/saucy-updates

« back to all changes in this revision

Viewing changes to src/lxml/tests/test_htmlparser.py

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-01-27 22:14:53 UTC
  • mto: (2.1.34 experimental) (1.4.1)
  • mto: This revision was merged to the branch mainline in revision 17.
  • Revision ID: package-import@ubuntu.com-20130127221453-2k7oc1crqc28802y
Tags: upstream-3.1~beta1
Import upstream version 3.1~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lxml/tests/test_htmlparser.py
77
77
        Element = parser.makeelement
78
78
 
79
79
        pname = Element('p:name')
80
 
        self.assertEquals(pname.tag, 'p:name')
 
80
        self.assertEqual(pname.tag, 'p:name')
81
81
 
82
82
        pname = Element('{test}p:name')
83
 
        self.assertEquals(pname.tag, '{test}p:name')
 
83
        self.assertEqual(pname.tag, '{test}p:name')
84
84
 
85
85
        pname = Element('name')
86
86
        pname.tag = 'p:name'
87
 
        self.assertEquals(pname.tag, 'p:name')
 
87
        self.assertEqual(pname.tag, 'p:name')
88
88
 
89
89
    def test_html_element_name_quote(self):
90
90
        parser = self.etree.HTMLParser()
98
98
        el = Element('name')
99
99
        self.assertRaises(ValueError, setattr, el, 'tag', "pname'")
100
100
        self.assertRaises(ValueError, setattr, el, 'tag', '"pname')
101
 
        self.assertEquals(el.tag, "name")
 
101
        self.assertEqual(el.tag, "name")
102
102
 
103
103
    def test_html_element_name_space(self):
104
104
        parser = self.etree.HTMLParser()
110
110
 
111
111
        el = Element('name')
112
112
        self.assertRaises(ValueError, setattr, el, 'tag', ' name ')
113
 
        self.assertEquals(el.tag, "name")
 
113
        self.assertEqual(el.tag, "name")
114
114
 
115
115
    def test_html_subelement_name_empty(self):
116
116
        parser = self.etree.HTMLParser()
129
129
 
130
130
        el = Element('name')
131
131
        pname = SubElement(el, 'p:name')
132
 
        self.assertEquals(pname.tag, 'p:name')
 
132
        self.assertEqual(pname.tag, 'p:name')
133
133
 
134
134
        pname = SubElement(el, '{test}p:name')
135
 
        self.assertEquals(pname.tag, '{test}p:name')
 
135
        self.assertEqual(pname.tag, '{test}p:name')
136
136
 
137
137
    def test_html_subelement_name_quote(self):
138
138
        parser = self.etree.HTMLParser()
170
170
            BytesIO(html_latin1),
171
171
            self.etree.HTMLParser(encoding="iso-8859-1"))
172
172
        p = tree.find("//p")
173
 
        self.assertEquals(p.text, text)
 
173
        self.assertEqual(p.text, text)
174
174
 
175
175
    def test_parse_encoding_8bit_override(self):
176
176
        text = _str('Søk på nettet')
191
191
            BytesIO(html_latin1),
192
192
            self.etree.HTMLParser(encoding="iso-8859-1"))
193
193
        p = tree.find("//p")
194
 
        self.assertEquals(p.text, text)
 
194
        self.assertEqual(p.text, text)
195
195
 
196
196
    def test_module_HTML_broken(self):
197
197
        element = self.etree.HTML(self.broken_html_str)
202
202
        # by default, libxml2 generates CDATA nodes for <script> content
203
203
        html = _bytes('<html><head><style>foo</style></head></html>')
204
204
        element = self.etree.HTML(html)
205
 
        self.assertEquals(element[0][0].text, "foo")
 
205
        self.assertEqual(element[0][0].text, "foo")
206
206
 
207
207
    def test_module_HTML_access(self):
208
208
        element = self.etree.HTML(self.html_str)
264
264
            '<html><head><title>TITLE</title><body><p>P</p></body></html>')
265
265
 
266
266
        iterator = iterparse(f, html=True)
267
 
        self.assertEquals(None, iterator.root)
 
267
        self.assertEqual(None, iterator.root)
268
268
 
269
269
        events = list(iterator)
270
270
        root = iterator.root
271
 
        self.assert_(root is not None)
272
 
        self.assertEquals(
 
271
        self.assertTrue(root is not None)
 
272
        self.assertEqual(
273
273
            [('end', root[0][0]), ('end', root[0]), ('end', root[1][0]),
274
274
             ('end', root[1]), ('end', root)],
275
275
            events)
279
279
        iterator = iterparse(fileInTestDir("shakespeare.html"),
280
280
                             html=True)
281
281
 
282
 
        self.assertEquals(None, iterator.root)
 
282
        self.assertEqual(None, iterator.root)
283
283
        events = list(iterator)
284
284
        root = iterator.root
285
 
        self.assert_(root is not None)
286
 
        self.assertEquals(249, len(events))
287
 
        self.assertEquals(
 
285
        self.assertTrue(root is not None)
 
286
        self.assertEqual(249, len(events))
 
287
        self.assertEqual(
288
288
            [],
289
289
            [ event for (event, element) in events if event != 'end' ])
290
290
 
294
294
            '<html><head><title>TITLE</title><body><p>P</p></body></html>')
295
295
 
296
296
        iterator = iterparse(f, html=True, events=('start',))
297
 
        self.assertEquals(None, iterator.root)
 
297
        self.assertEqual(None, iterator.root)
298
298
 
299
299
        events = list(iterator)
300
300
        root = iterator.root
301
 
        self.assert_(root is not None)
302
 
        self.assertEquals(
 
301
        self.assertTrue(root is not None)
 
302
        self.assertEqual(
303
303
            [('start', root), ('start', root[0]), ('start', root[0][0]),
304
304
                ('start', root[1]), ('start', root[1][0])],
305
305
            events)
321
321
        parser.feed("<html><body></body></html>")
322
322
        done = parser.close()
323
323
 
324
 
        self.assertEquals("DONE", done)
325
 
        self.assertEquals([
 
324
        self.assertEqual("DONE", done)
 
325
        self.assertEqual([
326
326
            ("start", "html"), ("start", "body"),
327
327
            ("end", "body"), ("end", "html")], events)
328
328
 
344
344
        parser.feed("<!DOCTYPE><html><body></body></html>")
345
345
        done = parser.close()
346
346
 
347
 
        self.assertEquals("DONE", done)
348
 
        self.assertEquals([
 
347
        self.assertEqual("DONE", done)
 
348
        self.assertEqual([
349
349
            ("doctype", (None, None, None)),
350
350
            ("start", "html"), ("start", "body"),
351
351
            ("end", "body"), ("end", "html")], events)
368
368
        parser.feed("<!DOCTYPE html><html><body></body></html>")
369
369
        done = parser.close()
370
370
 
371
 
        self.assertEquals("DONE", done)
372
 
        self.assertEquals([
 
371
        self.assertEqual("DONE", done)
 
372
        self.assertEqual([
373
373
            ("doctype", ("html", None, None)),
374
374
            ("start", "html"), ("start", "body"),
375
375
            ("end", "body"), ("end", "html")], events)
393
393
                    '<html><body></body></html>')
394
394
        done = parser.close()
395
395
 
396
 
        self.assertEquals("DONE", done)
397
 
        self.assertEquals([
 
396
        self.assertEqual("DONE", done)
 
397
        self.assertEqual([
398
398
            ("doctype", ("html", "-//W3C//DTD HTML 4.01//EN", "sys.dtd")),
399
399
            ("start", "html"), ("start", "body"),
400
400
            ("end", "body"), ("end", "html")], events)