← Back to branch summary

~ubuntu-branches/ubuntu/karmic/python-docutils/karmic

« back to all changes in this revision

Viewing changes to test/test_nodes.py

  • Committer: Bazaar Package Importer
  • Author(s): martin f. krafft
  • Date: 2006-07-10 11:45:05 UTC
  • mfrom: (2.1.4 edgy)
  • Revision ID: james.westby@ubuntu.com-20060710114505-otkhqcslevewxmz5
Tags: 0.4-3
http://bugs.debian.org/377580
Added build dependency on python-central (closes: #377580).

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/test_nodes.py
2
2
 
3
3
# Author: David Goodger
4
4
# Contact: goodger@users.sourceforge.net
5
 
# Revision: $Revision: 1.11 $
6
 
# Date: $Date: 2003/04/28 02:51:01 $
 
5
# Revision: $Revision: 4132 $
 
6
# Date: $Date: 2005-12-03 03:13:12 +0100 (Sat, 03 Dec 2005) $
7
7
# Copyright: This module has been placed in the public domain.
8
8
 
9
9
"""
12
12
 
13
13
import unittest
14
14
from types import ClassType
 
15
import DocutilsTestSupport              # must be imported before docutils
15
16
from DocutilsTestSupport import nodes, utils
16
17
 
17
18
debug = 0
75
76
                          '<Element attr="1">text\nmore</Element>')
76
77
        dom.unlink()
77
78
        self.assertEquals(element.pformat(),
78
 
"""\
79
 
<Element attr="1">
80
 
    text
81
 
    more
 
79
                          '<Element attr="1">\n    text\n    more\n')
 
80
 
 
81
    def test_clear(self):
 
82
        element = nodes.Element()
 
83
        element += nodes.Element()
 
84
        self.assert_(len(element))
 
85
        element.clear()
 
86
        self.assert_(not len(element))
 
87
 
 
88
    def test_normal_attributes(self):
 
89
        element = nodes.Element()
 
90
        self.assert_(not element.has_key('foo'))
 
91
        self.assertRaises(KeyError, element.__getitem__, 'foo')
 
92
        element['foo'] = 'sometext'
 
93
        self.assertEquals(element['foo'], 'sometext')
 
94
        del element['foo']
 
95
        self.assertRaises(KeyError, element.__getitem__, 'foo')
 
96
 
 
97
    def test_default_attributes(self):
 
98
        element = nodes.Element()
 
99
        self.assertEquals(element['ids'], [])
 
100
        self.assertEquals(element.non_default_attributes(), {})
 
101
        self.assert_(not element.is_not_default('ids'))
 
102
        self.assert_(element['ids'] is not nodes.Element()['ids'])
 
103
        element['ids'].append('someid')
 
104
        self.assertEquals(element['ids'], ['someid'])
 
105
        self.assertEquals(element.non_default_attributes(),
 
106
                          {'ids': ['someid']})
 
107
        self.assert_(element.is_not_default('ids'))
 
108
 
 
109
    def test_update_basic_atts(self):
 
110
        element1 = nodes.Element(ids=['foo', 'bar'], test=['test1'])
 
111
        element2 = nodes.Element(ids=['baz', 'qux'], test=['test2'])
 
112
        element1.update_basic_atts(element2)
 
113
        # 'ids' are appended because 'ids' is a basic attribute.
 
114
        self.assertEquals(element1['ids'], ['foo', 'bar', 'baz', 'qux'])
 
115
        # 'test' is not overwritten because it is not a basic attribute.
 
116
        self.assertEquals(element1['test'], ['test1'])
 
117
 
 
118
    def test_replace_self(self):
 
119
        parent = nodes.Element(ids=['parent'])
 
120
        child1 = nodes.Element(ids=['child1'])
 
121
        grandchild = nodes.Element(ids=['grandchild'])
 
122
        child1 += grandchild
 
123
        child2 = nodes.Element(ids=['child2'])
 
124
        twins = [nodes.Element(ids=['twin%s' % i]) for i in (1, 2)]
 
125
        child2 += twins
 
126
        child3 = nodes.Element(ids=['child3'])
 
127
        child4 = nodes.Element(ids=['child4'])
 
128
        parent += [child1, child2, child3, child4]
 
129
        self.assertEquals(parent.pformat(), """\
 
130
<Element ids="parent">
 
131
    <Element ids="child1">
 
132
        <Element ids="grandchild">
 
133
    <Element ids="child2">
 
134
        <Element ids="twin1">
 
135
        <Element ids="twin2">
 
136
    <Element ids="child3">
 
137
    <Element ids="child4">
82
138
""")
 
139
        # Replace child1 with the grandchild.
 
140
        child1.replace_self(child1[0])
 
141
        self.assertEquals(parent[0], grandchild)
 
142
        # Assert that 'ids' have been updated.
 
143
        self.assertEquals(grandchild['ids'], ['grandchild', 'child1'])
 
144
        # Replace child2 with its children.
 
145
        child2.replace_self(child2[:])
 
146
        self.assertEquals(parent[1:3], twins)
 
147
        # Assert that 'ids' have been propagated to first child.
 
148
        self.assertEquals(twins[0]['ids'], ['twin1', 'child2'])
 
149
        self.assertEquals(twins[1]['ids'], ['twin2'])
 
150
        # Replace child3 with new child.
 
151
        newchild = nodes.Element(ids=['newchild'])
 
152
        child3.replace_self(newchild)
 
153
        self.assertEquals(parent[3], newchild)
 
154
        self.assertEquals(newchild['ids'], ['newchild', 'child3'])
 
155
        # Crazy but possible case: Substitute child4 for itself.
 
156
        child4.replace_self(child4)
 
157
        # Make sure the 'child4' ID hasn't been duplicated.
 
158
        self.assertEquals(child4['ids'], ['child4'])
 
159
        self.assertEquals(len(parent), 5)
83
160
 
84
161
 
85
162
class MiscTests(unittest.TestCase):
88
165
        node_class_names = []
89
166
        for x in dir(nodes):
90
167
            c = getattr(nodes, x)
91
 
            if type(c) is ClassType and issubclass(c, nodes.Node) \
 
168
            if isinstance(c, ClassType) and issubclass(c, nodes.Node) \
92
169
                   and len(c.__bases__) > 1:
93
170
                node_class_names.append(x)
94
171
        node_class_names.sort()
105
182
            normed = nodes.make_id(input)
106
183
            self.assertEquals(normed, output)
107
184
 
 
185
    def test_traverse(self):
 
186
        e = nodes.Element()
 
187
        e += nodes.Element()
 
188
        e[0] += nodes.Element()
 
189
        e[0] += nodes.TextElement()
 
190
        e[0][1] += nodes.Text('some text')
 
191
        e += nodes.Element()
 
192
        e += nodes.Element()
 
193
        self.assertEquals(list(e.traverse()),
 
194
                          [e, e[0], e[0][0], e[0][1], e[0][1][0], e[1], e[2]])
 
195
        self.assertEquals(list(e.traverse(include_self=0)),
 
196
                          [e[0], e[0][0], e[0][1], e[0][1][0], e[1], e[2]])
 
197
        self.assertEquals(list(e.traverse(descend=0)),
 
198
                          [e])
 
199
        self.assertEquals(list(e[0].traverse(descend=0, ascend=1)),
 
200
                          [e[0], e[1], e[2]])
 
201
        self.assertEquals(list(e[0][0].traverse(descend=0, ascend=1)),
 
202
                          [e[0][0], e[0][1], e[1], e[2]])
 
203
        self.assertEquals(list(e[0][0].traverse(descend=0, siblings=1)),
 
204
                          [e[0][0], e[0][1]])
 
205
        self.testlist = e[0:2]
 
206
        self.assertEquals(list(e.traverse(condition=self.not_in_testlist)),
 
207
                          [e, e[0][0], e[0][1], e[0][1][0], e[2]])
 
208
        # Return siblings despite siblings=0 because ascend is true.
 
209
        self.assertEquals(list(e[1].traverse(ascend=1, siblings=0)),
 
210
                          [e[1], e[2]])
 
211
        self.assertEquals(list(e[0].traverse()),
 
212
                          [e[0], e[0][0], e[0][1], e[0][1][0]])
 
213
        self.testlist = [e[0][0], e[0][1]]
 
214
        self.assertEquals(list(e[0].traverse(condition=self.not_in_testlist)),
 
215
                               [e[0], e[0][1][0]])
 
216
        self.testlist.append(e[0][1][0])
 
217
        self.assertEquals(list(e[0].traverse(condition=self.not_in_testlist)),
 
218
                               [e[0]])
 
219
        self.assertEquals(list(e.traverse(nodes.TextElement)), [e[0][1]])
 
220
 
 
221
    def test_next_node(self):
 
222
        e = nodes.Element()
 
223
        e += nodes.Element()
 
224
        e[0] += nodes.Element()
 
225
        e[0] += nodes.TextElement()
 
226
        e[0][1] += nodes.Text('some text')
 
227
        e += nodes.Element()
 
228
        e += nodes.Element()
 
229
        self.testlist = [e[0], e[0][1], e[1]]
 
230
        compare = [(e, e[0][0]),
 
231
                   (e[0], e[0][0]),
 
232
                   (e[0][0], e[0][1][0]),
 
233
                   (e[0][1], e[0][1][0]),
 
234
                   (e[0][1][0], e[2]),
 
235
                   (e[1], e[2]),
 
236
                   (e[2], None)]
 
237
        for node, next_node in compare:
 
238
            self.assertEquals(node.next_node(self.not_in_testlist, ascend=1),
 
239
                              next_node)
 
240
        self.assertEquals(e[0][0].next_node(ascend=1), e[0][1])
 
241
        self.assertEquals(e[2].next_node(), None)
 
242
 
 
243
    def not_in_testlist(self, x):
 
244
        return x not in self.testlist
 
245
 
 
246
    def test_copy(self):
 
247
        grandchild = nodes.Text('rawsource')
 
248
        child = nodes.emphasis('rawsource', grandchild, att='child')
 
249
        e = nodes.Element('rawsource', child, att='e')
 
250
        # Shallow copy:
 
251
        e_copy = e.copy()
 
252
        self.assert_(e is not e_copy)
 
253
        # Internal attributes (like `rawsource`) are not copied.
 
254
        self.assertEquals(e.rawsource, 'rawsource')
 
255
        self.assertEquals(e_copy.rawsource, '')
 
256
        self.assertEquals(e_copy['att'], 'e')
 
257
        # Children are not copied.
 
258
        self.assertEquals(len(e_copy), 0)
 
259
        # Deep copy:
 
260
        e_deepcopy = e.deepcopy()
 
261
        self.assertEquals(e_deepcopy.rawsource, '')
 
262
        self.assertEquals(e_deepcopy['att'], 'e')
 
263
        # Children are copied recursively.
 
264
        self.assertEquals(e_deepcopy[0][0], grandchild)
 
265
        self.assert_(e_deepcopy[0][0] is not grandchild)
 
266
        self.assertEquals(e_deepcopy[0]['att'], 'child')
 
267
 
108
268
 
109
269
class TreeCopyVisitorTests(unittest.TestCase):
110
270
 
123
283
    def compare_trees(self, one, two):
124
284
        self.assertEquals(one.__class__, two.__class__)
125
285
        self.assertNotEquals(id(one), id(two))
126
 
        children1 = one.get_children()
127
 
        children2 = two.get_children()
128
 
        self.assertEquals(len(children1), len(children2))
129
 
        for i in range(len(children1)):
130
 
            self.compare_trees(children1[i], children2[i])
 
286
        self.assertEquals(len(one.children), len(two.children))
 
287
        for i in range(len(one.children)):
 
288
            self.compare_trees(one.children[i], two.children[i])
131
289
 
132
290
    def test_copy_whole(self):
133
291
        visitor = nodes.TreeCopyVisitor(self.document)
148
306
            normed = nodes.fully_normalize_name(input)
149
307
            self.assertEquals(normed, output)
150
308
 
 
309
    def test_set_id_default(self):
 
310
        # Default prefixes.
 
311
        document = utils.new_document('test')
 
312
        # From name.
 
313
        element = nodes.Element(names=['test'])
 
314
        document.set_id(element)
 
315
        self.assertEquals(element['ids'], ['test'])
 
316
        # Auto-generated.
 
317
        element = nodes.Element()
 
318
        document.set_id(element)
 
319
        self.assertEquals(element['ids'], ['id1'])
 
320
 
 
321
    def test_set_id_custom(self):
 
322
        # Custom prefixes.
 
323
        document = utils.new_document('test')
 
324
        # Change settings.
 
325
        document.settings.id_prefix = 'prefix'
 
326
        document.settings.auto_id_prefix = 'auto'
 
327
        # From name.
 
328
        element = nodes.Element(names=['test'])
 
329
        document.set_id(element)
 
330
        self.assertEquals(element['ids'], ['prefixtest'])
 
331
        # Auto-generated.
 
332
        element = nodes.Element()
 
333
        document.set_id(element)
 
334
        self.assertEquals(element['ids'], ['prefixauto1'])
 
335
        
151
336
 
152
337
if __name__ == '__main__':
153
338
    unittest.main()