← 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_nsclasses.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_nsclasses.py
58
58
        tree = self.parse(_bytes('<bluff xmlns="ns10"><ns11:maeh xmlns:ns11="ns11"/></bluff>'))
59
59
 
60
60
        el = tree.getroot()
61
 
        self.assert_(isinstance(el, etree.ElementBase))
62
 
        self.assert_(hasattr(el, 'bluff'))
 
61
        self.assertTrue(isinstance(el, etree.ElementBase))
 
62
        self.assertTrue(hasattr(el, 'bluff'))
63
63
        self.assertFalse(hasattr(el[0], 'maeh'))
64
64
        self.assertFalse(hasattr(el[0], 'bluff'))
65
 
        self.assertEquals(el.bluff(), 'bluff')
 
65
        self.assertEqual(el.bluff(), 'bluff')
66
66
        del el
67
67
 
68
68
        self.Namespace('ns11').update(maeh_dict)
69
69
        el = tree.getroot()
70
 
        self.assert_(hasattr(el, 'bluff'))
71
 
        self.assert_(hasattr(el[0], 'maeh'))
72
 
        self.assertEquals(el.bluff(), 'bluff')
73
 
        self.assertEquals(el[0].maeh(), 'maeh')
 
70
        self.assertTrue(hasattr(el, 'bluff'))
 
71
        self.assertTrue(hasattr(el[0], 'maeh'))
 
72
        self.assertEqual(el.bluff(), 'bluff')
 
73
        self.assertEqual(el[0].maeh(), 'maeh')
74
74
        del el
75
75
 
76
76
        self.Namespace('ns10').clear()
80
80
        self.assertFalse(hasattr(el, 'bluff'))
81
81
        self.assertFalse(hasattr(el, 'maeh'))
82
82
        self.assertFalse(hasattr(el[0], 'bluff'))
83
 
        self.assert_(hasattr(el[0], 'maeh'))
 
83
        self.assertTrue(hasattr(el[0], 'maeh'))
84
84
 
85
85
        self.Namespace('ns11').clear()
86
86
 
102
102
        el = tree.getroot()
103
103
        self.assertFalse(isinstance(el, etree.ElementBase))
104
104
        for child in el[:-1]:
105
 
            self.assert_(isinstance(child, etree.ElementBase), child.tag)
 
105
            self.assertTrue(isinstance(child, etree.ElementBase), child.tag)
106
106
        self.assertFalse(isinstance(el[-1], etree.ElementBase))
107
107
 
108
 
        self.assert_(hasattr(el[0], 'bluff'))
109
 
        self.assert_(hasattr(el[1], 'bluff'))
110
 
        self.assert_(hasattr(el[2], 'maeh'))
111
 
        self.assert_(hasattr(el[3], 'maeh'))
 
108
        self.assertTrue(hasattr(el[0], 'bluff'))
 
109
        self.assertTrue(hasattr(el[1], 'bluff'))
 
110
        self.assertTrue(hasattr(el[2], 'maeh'))
 
111
        self.assertTrue(hasattr(el[3], 'maeh'))
112
112
        self.assertFalse(hasattr(el[4], 'maeh'))
113
113
        del el
114
114
 
122
122
        self.Namespace('ns21').update(maeh_dict)
123
123
 
124
124
        el = etree.Element("{ns20}bluff")
125
 
        self.assert_(hasattr(el, 'bluff'))
 
125
        self.assertTrue(hasattr(el, 'bluff'))
126
126
 
127
127
        child = etree.SubElement(el, "{ns21}maeh")
128
 
        self.assert_(hasattr(child, 'maeh'))
 
128
        self.assertTrue(hasattr(child, 'maeh'))
129
129
        child = etree.SubElement(el, "{ns20}bluff")
130
 
        self.assert_(hasattr(child, 'bluff'))
 
130
        self.assertTrue(hasattr(child, 'bluff'))
131
131
        child = etree.SubElement(el, "{ns21}bluff")
132
132
        self.assertFalse(hasattr(child, 'bluff'))
133
133
        self.assertFalse(hasattr(child, 'maeh'))
134
134
 
135
 
        self.assert_(hasattr(el[0], 'maeh'))
136
 
        self.assert_(hasattr(el[1], 'bluff'))
 
135
        self.assertTrue(hasattr(el[0], 'maeh'))
 
136
        self.assertTrue(hasattr(el[1], 'bluff'))
137
137
        self.assertFalse(hasattr(el[2], 'bluff'))
138
138
        self.assertFalse(hasattr(el[2], 'maeh'))
139
139
 
140
 
        self.assertEquals(el.bluff(), 'bluff')
141
 
        self.assertEquals(el[0].maeh(), 'maeh')
142
 
        self.assertEquals(el[1].bluff(), 'bluff')
 
140
        self.assertEqual(el.bluff(), 'bluff')
 
141
        self.assertEqual(el[0].maeh(), 'maeh')
 
142
        self.assertEqual(el[1].bluff(), 'bluff')
143
143
 
144
144
        self.Namespace('ns20').clear()
145
145
        self.Namespace('ns21').clear()
153
153
 
154
154
        el = etree.Element("{ns30}bluff")
155
155
        etree.SubElement(el, "maeh")
156
 
        self.assert_(hasattr(el, 'bluff'))
157
 
        self.assert_(hasattr(el[0], 'maeh'))
158
 
        self.assertEquals(el.bluff(), 'bluff')
159
 
        self.assertEquals(el[0].maeh(), 'maeh')
 
156
        self.assertTrue(hasattr(el, 'bluff'))
 
157
        self.assertTrue(hasattr(el[0], 'maeh'))
 
158
        self.assertEqual(el.bluff(), 'bluff')
 
159
        self.assertEqual(el[0].maeh(), 'maeh')
160
160
 
161
161
        self.Namespace(None).clear()
162
162
        self.Namespace('ns30').clear()
176
176
            maeh("TeXT", bluff, honk(), "TAiL"),
177
177
            "Tail")
178
178
 
179
 
        self.assertEquals('default_class', el.tag)
180
 
        self.assertEquals('testtext', el.text)
181
 
        self.assertEquals(None, el.tail)
182
 
        self.assertEquals(2, len(el))
183
 
        self.assertEquals(7, len(list(el.iter())))
 
179
        self.assertEqual('default_class', el.tag)
 
180
        self.assertEqual('testtext', el.text)
 
181
        self.assertEqual(None, el.tail)
 
182
        self.assertEqual(2, len(el))
 
183
        self.assertEqual(7, len(list(el.iter())))
184
184
 
185
 
        self.assertEquals('bluff_class', el[0].tag)
186
 
        self.assertEquals('TaIL', el[0][0].tail)
187
 
        self.assertEquals('TaIL', ''.join(el[0].itertext()))
188
 
        self.assertEquals('{http://a.b/c}HONK',
 
185
        self.assertEqual('bluff_class', el[0].tag)
 
186
        self.assertEqual('TaIL', el[0][0].tail)
 
187
        self.assertEqual('TaIL', ''.join(el[0].itertext()))
 
188
        self.assertEqual('{http://a.b/c}HONK',
189
189
                          el[0][0].tag)
190
 
        self.assertEquals('maeh_class',
 
190
        self.assertEqual('maeh_class',
191
191
                          el[0][1].tag)
192
192
 
193
 
        self.assertEquals('maeh_class', el[1].tag)
194
 
        self.assertEquals('TeXT', el[1].text)
195
 
        self.assertEquals('bluff_class', el[1][0].tag)
196
 
        self.assertEquals('{http://a.b/c}HONK', el[1][1].tag)
197
 
        self.assertEquals('TAiL', el[1][1].tail)
 
193
        self.assertEqual('maeh_class', el[1].tag)
 
194
        self.assertEqual('TeXT', el[1].text)
 
195
        self.assertEqual('bluff_class', el[1][0].tag)
 
196
        self.assertEqual('{http://a.b/c}HONK', el[1][1].tag)
 
197
        self.assertEqual('TAiL', el[1][1].tail)
198
198
 
199
 
        self.assertEquals('TeXTTAiL',
 
199
        self.assertEqual('TeXTTAiL',
200
200
                          ''.join(el[1].itertext()))
201
 
        self.assertEquals('Tail', el[1].tail)
202
 
        self.assertEquals('TAiL', el[1][1].tail)
203
 
        self.assertEquals('bluff_class', el[1][0].tag)
204
 
        self.assertEquals('{http://a.b/c}HONK', el[1][1].tag)
 
201
        self.assertEqual('Tail', el[1].tail)
 
202
        self.assertEqual('TAiL', el[1][1].tail)
 
203
        self.assertEqual('bluff_class', el[1][0].tag)
 
204
        self.assertEqual('{http://a.b/c}HONK', el[1][1].tag)
205
205
        
206
206
 
207
207
def test_suite():