← 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_pyclasslookup.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_pyclasslookup.py
64
64
            return el_class
65
65
        self._setClassLookup(lookup)
66
66
        root = self.XML(xml_str)
67
 
        self.assertEquals(2, el_class.i)
 
67
        self.assertEqual(2, el_class.i)
68
68
 
69
69
    def test_lookup_keep_ref_assertion(self):
70
70
        el_class = self._buildElementClass()
75
75
            return el_class
76
76
        self._setClassLookup(lookup)
77
77
        root = self.XML(xml_str)
78
 
        self.assertNotEquals(None, el_class.EL)
 
78
        self.assertNotEqual(None, el_class.EL)
79
79
        self.assertRaises(AssertionError, el_class.EL.getchildren)
80
80
 
81
81
    def test_lookup_tag(self):
87
87
            return el_class
88
88
        self._setClassLookup(lookup)
89
89
        root = self.XML(xml_str)
90
 
        self.assertNotEquals(None, root.TAG)
91
 
        self.assertEquals(root.tag, root.TAG)
 
90
        self.assertNotEqual(None, root.TAG)
 
91
        self.assertEqual(root.tag, root.TAG)
92
92
 
93
93
    def test_lookup_text(self):
94
94
        el_class = self._buildElementClass()
99
99
            return el_class
100
100
        self._setClassLookup(lookup)
101
101
        root = self.XML(xml_str)
102
 
        self.assertNotEquals(None, root.TEXT)
103
 
        self.assertEquals(root.text, root.TEXT)
 
102
        self.assertNotEqual(None, root.TEXT)
 
103
        self.assertEqual(root.text, root.TEXT)
104
104
 
105
105
    def test_lookup_tail(self):
106
106
        el_class = self._buildElementClass()
111
111
            return el_class
112
112
        self._setClassLookup(lookup)
113
113
        root = self.XML(xml_str)
114
 
        self.assertEquals(root.tail, root.TAIL)
 
114
        self.assertEqual(root.tail, root.TAIL)
115
115
 
116
116
    def test_lookup_attrib(self):
117
117
        el_class = self._buildElementClass()
126
126
        items1.sort()
127
127
        items2 = list(root.ATTRIB.items())
128
128
        items2.sort()
129
 
        self.assertEquals(items1, items2)
 
129
        self.assertEqual(items1, items2)
130
130
 
131
131
    def test_lookup_prefix(self):
132
132
        el_class = self._buildElementClass()
137
137
            return el_class
138
138
        self._setClassLookup(lookup)
139
139
        root = self.XML(xml_str)
140
 
        self.assertEquals(root.prefix, root.PREFIX)
 
140
        self.assertEqual(root.prefix, root.PREFIX)
141
141
 
142
142
    def test_lookup_sourceline(self):
143
143
        el_class = self._buildElementClass()
148
148
            return el_class
149
149
        self._setClassLookup(lookup)
150
150
        root = self.XML(xml_str)
151
 
        self.assertEquals(root.sourceline, root.LINE)
 
151
        self.assertEqual(root.sourceline, root.LINE)
152
152
 
153
153
    def test_lookup_getitem(self):
154
154
        el_class = self._buildElementClass()
159
159
        self._setClassLookup(lookup)
160
160
        root = self.XML(xml_str)
161
161
        child_tag = root.CHILD_TAG
162
 
        self.assertNotEquals(None, child_tag)
163
 
        self.assertEquals(root[0].tag, child_tag)
 
162
        self.assertNotEqual(None, child_tag)
 
163
        self.assertEqual(root[0].tag, child_tag)
164
164
 
165
165
    def test_lookup_getitem_neg(self):
166
166
        el_class = self._buildElementClass()
172
172
        self._setClassLookup(lookup)
173
173
        root = self.XML(xml_str)
174
174
        child_tag = root.CHILD_TAG
175
 
        self.assertNotEquals(None, child_tag)
176
 
        self.assertEquals(root[-1].tag, child_tag)
 
175
        self.assertNotEqual(None, child_tag)
 
176
        self.assertEqual(root[-1].tag, child_tag)
177
177
 
178
178
    def test_lookup_getslice(self):
179
179
        el_class = self._buildElementClass()
185
185
        self._setClassLookup(lookup)
186
186
        root = self.XML(xml_str)
187
187
        child_tags = root.CHILD_TAGS
188
 
        self.assertNotEquals(None, child_tags)
189
 
        self.assertEquals([ c.tag for c in root[1:-1] ],
 
188
        self.assertNotEqual(None, child_tags)
 
189
        self.assertEqual([ c.tag for c in root[1:-1] ],
190
190
                          child_tags)
191
191
 
192
192
    def test_lookup_len(self):
198
198
            return el_class
199
199
        self._setClassLookup(lookup)
200
200
        root = self.XML(xml_str)
201
 
        self.assertEquals(1, el_class.LEN)
 
201
        self.assertEqual(1, el_class.LEN)
202
202
 
203
203
    def test_lookup_bool(self):
204
204
        el_class = self._buildElementClass()
209
209
            return el_class
210
210
        self._setClassLookup(lookup)
211
211
        root = self.XML(xml_str)
212
 
        self.assert_(el_class.TRUE)
 
212
        self.assertTrue(el_class.TRUE)
213
213
 
214
214
    def test_lookup_get(self):
215
215
        el_class = self._buildElementClass()
220
220
            return el_class
221
221
        self._setClassLookup(lookup)
222
222
        root = self.XML(xml_str)
223
 
        self.assertNotEquals(None, el_class.VAL)
224
 
        self.assertEquals(root[0].get('a1'), el_class.VAL)
 
223
        self.assertNotEqual(None, el_class.VAL)
 
224
        self.assertEqual(root[0].get('a1'), el_class.VAL)
225
225
 
226
226
    def test_lookup_get_default(self):
227
227
        el_class = self._buildElementClass()
233
233
            return el_class
234
234
        self._setClassLookup(lookup)
235
235
        root = self.XML(xml_str)
236
 
        self.assertEquals(default, el_class.VAL)
 
236
        self.assertEqual(default, el_class.VAL)
237
237
 
238
238
    def test_lookup_getchildren(self):
239
239
        el_class = self._buildElementClass()
245
245
        self._setClassLookup(lookup)
246
246
        root = self.XML(xml_str)
247
247
        child_tags = root.CHILD_TAGS
248
 
        self.assertNotEquals(None, child_tags)
249
 
        self.assertEquals([ c.tag for c in root.getchildren() ],
 
248
        self.assertNotEqual(None, child_tags)
 
249
        self.assertEqual([ c.tag for c in root.getchildren() ],
250
250
                          child_tags)
251
251
 
252
252
    def test_lookup_iter_children(self):
259
259
        self._setClassLookup(lookup)
260
260
        root = self.XML(xml_str)
261
261
        child_tags = root.CHILD_TAGS
262
 
        self.assertNotEquals(None, child_tags)
263
 
        self.assertEquals([ c.tag for c in root.getchildren() ],
 
262
        self.assertNotEqual(None, child_tags)
 
263
        self.assertEqual([ c.tag for c in root.getchildren() ],
264
264
                          child_tags)
265
265
 
266
266
    def test_lookup_iterchildren(self):
273
273
        self._setClassLookup(lookup)
274
274
        root = self.XML(xml_str)
275
275
        child_tags = root.CHILD_TAGS
276
 
        self.assertNotEquals(None, child_tags)
277
 
        self.assertEquals([ c.tag for c in root.getchildren() ],
 
276
        self.assertNotEqual(None, child_tags)
 
277
        self.assertEqual([ c.tag for c in root.getchildren() ],
278
278
                          child_tags)
279
279
 
280
280
    def test_lookup_iterchildren_tag(self):
289
289
 
290
290
        root = self.XML(xml_str)
291
291
        child_tags = root.CHILD_TAGS
292
 
        self.assertNotEquals(None, child_tags)
293
 
        self.assertEquals([], child_tags)
 
292
        self.assertNotEqual(None, child_tags)
 
293
        self.assertEqual([], child_tags)
294
294
 
295
295
        c1 = root[0]
296
296
        child_tags = root.CHILD_TAGS
297
 
        self.assertNotEquals(None, child_tags)
298
 
        self.assertNotEquals([], child_tags)
299
 
        self.assertEquals(
 
297
        self.assertNotEqual(None, child_tags)
 
298
        self.assertNotEqual([], child_tags)
 
299
        self.assertEqual(
300
300
            [ c.tag for c in root[0].iterchildren(tag='{objectified}c2') ],
301
301
            child_tags)
302
302
 
309
309
            return el_class
310
310
        self._setClassLookup(lookup)
311
311
        root = self.XML(xml_str)
312
 
        self.assertEquals(root.tag, root.PARENT)
 
312
        self.assertEqual(root.tag, root.PARENT)
313
313
 
314
314
    def test_lookup_getnext(self):
315
315
        el_class = self._buildElementClass()
320
320
            return el_class
321
321
        self._setClassLookup(lookup)
322
322
        root = self.XML(xml_str)
323
 
        self.assertNotEquals(None, el_class.NEXT)
324
 
        self.assertEquals(root[0][1].getnext().tag, el_class.NEXT)
 
323
        self.assertNotEqual(None, el_class.NEXT)
 
324
        self.assertEqual(root[0][1].getnext().tag, el_class.NEXT)
325
325
 
326
326
    def test_lookup_getprevious(self):
327
327
        el_class = self._buildElementClass()
332
332
            return el_class
333
333
        self._setClassLookup(lookup)
334
334
        root = self.XML(xml_str)
335
 
        self.assertNotEquals(None, el_class.PREV)
336
 
        self.assertEquals(root[0][1].getprevious().tag, el_class.PREV)
 
335
        self.assertNotEqual(None, el_class.PREV)
 
336
        self.assertEqual(root[0][1].getprevious().tag, el_class.PREV)
337
337
 
338
338
 
339
339
def test_suite():