WIP-pyshapelib-bramz/test/test_classification.py

# Copyright (c) 2002, 2003 by Intevation GmbH
# Authors:
# Jonathan Coles <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""
Test the Classification class
"""

__version__ = "$Revision$"
# $Source$
# $Id$

from __future__ import nested_scopes

import unittest

import support
support.initthuban()

import os
import copy

from Thuban.Model.color import Color, Transparent, Black
from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_STRING, FIELDTYPE_DOUBLE
from Thuban.Model.classification import \
    Classification, ClassGroup, \
    ClassGroupDefault, ClassGroupSingleton, ClassGroupRange,\
    ClassGroupProperties

from Thuban.Model.session import Session
from Thuban.Model.layer import Layer
from Thuban.Model.range import Range


# A few colors for use by the test cases
red = Color(1, 0, 0)
green = Color(0, 1, 0)
blue = Color(0, 0, 1)


class TestClassGroupProperties(unittest.TestCase):

    def test(self):
        """Test ClassGroupProperties"""

        props = ClassGroupProperties()
        self.assertEqual(props.GetLineColor(), Black)
        self.assertEqual(props.GetLineWidth(), 1)
        self.assertEqual(props.GetFill(), Transparent)

        props.SetLineColor(red)
        self.assertEqual(props.GetLineColor(), red)

        props.SetLineColor(blue)
        self.assertEqual(props.GetLineColor(), blue)

        props.SetLineWidth(10)
        self.assertEqual(props.GetLineWidth(), 10)

        self.assertRaises(ValueError, props.SetLineWidth, -10)
        self.assertEqual(props.GetLineWidth(), 10)

        newProps1 = ClassGroupProperties()
        newProps2 = ClassGroupProperties()
        self.assertNotEqual(newProps1, props)
        self.assertEqual(newProps1, newProps2)


class TestClassGroup(unittest.TestCase):

    def test(self):
        """Test ClassGroup"""

        # test constructor with no label
        group = ClassGroup()
        self.assertEqual(group.GetLabel(), "")

        # test constructor with label
        group = ClassGroup("hallo")
        self.assertEqual(group.GetLabel(), "hallo")

        # test SetLabel()/GetLabel()
        group = ClassGroup("welt")
        group.SetLabel("hallo")
        self.assertEqual(group.GetLabel(), "hallo")

        group.SetLabel("")
        self.assertEqual(group.GetLabel(), "")

        # test Matches
        # Matches() is a virtual function...can't test it here
        #
        #self.assertEqual(group.Matches(None), False)
        #self.assertEqual(group.Matches(1), False)
        #self.assertEqual(group.Matches("hallo"), False)
        #self.assertEqual(group.Matches([]), False)

        # test GetProperties...also a virtual function
        #self.assertEqual(group.GetProperties(), None)


class TestClassGroupDefault(unittest.TestCase):

    def test(self):
        """Test ClassGroupDefault"""

        defProps = ClassGroupProperties()

        newProps = ClassGroupProperties()
        newProps.SetLineColor(Color(.25, .5, .75))
        newProps.SetLineWidth(5)
        newProps.SetFill(Color(.12, .24, .36))

        # test constructor

        group = ClassGroupDefault(newProps)
        self.assertEqual(group.GetProperties(), newProps)

        group = ClassGroupDefault(newProps, "hallo")
        self.assertEqual(group.GetProperties(), newProps)
        self.assertEqual(group.GetLabel(), "hallo")

        # test empty constructor
        group = ClassGroupDefault()
        props = group.GetProperties()

        self.assertEqual(group.GetLabel(), "")
        self.assertEqual(defProps, props)

        # test Matches()
        self.assertEqual(group.Matches(None), True)
        self.assertEqual(group.Matches(1), True)
        self.assertEqual(group.Matches("hallo"), True)
        self.assertEqual(group.Matches([]), True)

        # test SetProperties()/GetProperties()
        group.SetProperties(newProps)
        self.assertEqual(group.GetProperties(), newProps)

        # test copy
        groupCopy = copy.copy(group)
        self.assertEqual(group, groupCopy)


class TestClassGroupRange(unittest.TestCase):

    def test(self):
        """Test ClassGroupRange"""

        defProps = ClassGroupProperties()
        newProps = ClassGroupProperties()
        newProps.SetLineColor(Color(.25, .5, .75))
        newProps.SetLineWidth(5)
        newProps.SetFill(Color(.12, .24, .36))

        # test empty constructor
        group = ClassGroupRange()

        self.assertEqual(group.GetMin(), 0)
        self.assertEqual(group.GetMax(), 1)
        self.assertEqual(group.GetProperties(), defProps)
        self.assertEqual(group.GetLabel(), "")

        # test SetMax()
        self.assertRaises(ValueError, group.SetMax, 0)
        self.assertRaises(ValueError, group.SetMax, -1)
        self.assertEquals(group.GetMax(), 1)
        group.SetMax(2)
        self.assertEquals(group.GetMax(), 2)

        # test SetMin()
        self.assertRaises(ValueError, group.SetMin, 2)
        self.assertRaises(ValueError, group.SetMin, 3)
        self.assertEquals(group.GetMin(), 0)
        group.SetMin(-5)
        self.assertEquals(group.GetMin(), -5)

        # test SetProperties()/GetProperties()
        group.SetProperties(newProps)
        self.assertEqual(group.GetProperties(), newProps)

        # test SetRange()
        self.assertRaises(ValueError, group.SetRange, (1, 0))
        group.SetRange(Range("]-oo;6]"))
        self.assertEqual(group.GetRange(), "]-oo;6]")
        group.SetRange((-5, 5))
        self.assertEqual(group.GetRange(), "[-5;5[")

        # test Matches()
        self.assertEqual(group.Matches(-6), False)
        self.assertEqual(group.Matches(-5), True)
        self.assertEqual(group.Matches(0), True)
        self.assertEqual(group.Matches(4), True)
        self.assertEqual(group.Matches(5), False)

        # test copy
        groupCopy = copy.copy(group)
        self.assertEqual(group, groupCopy)


class TestClassGroupSingleton(unittest.TestCase):

    def test(self):
        """Test ClassGroupSingleton"""

        defProps = ClassGroupProperties()
        newProps = ClassGroupProperties()
        newProps.SetLineColor(Color(.25, .5, .75))
        newProps.SetLineWidth(5)
        newProps.SetFill(Color(.12, .24, .36))

        # test empty constructor
        group = ClassGroupSingleton()

        self.assertEqual(group.GetValue(), 0)
        self.assertEqual(group.GetProperties(), defProps)
        self.assertEqual(group.GetLabel(), "")

        # test SetProperties()/GetProperties()
        group.SetProperties(newProps)
        self.assertEqual(group.GetProperties(), newProps)

        # test SetValue()
        group.SetValue(5)
        self.assertEqual(group.GetValue(), 5)

        # test Matches()
        self.assertEqual(group.Matches(0), False)
        self.assertEqual(group.Matches(5), True)

        group.SetValue("5")
        self.assertNotEqual(group.GetValue(), 5)

        # test Matches()
        self.assertEqual(group.Matches(5), False)
        self.assertEqual(group.Matches("5"), True)

        group.SetValue("hallo")
        self.assertEqual(group.GetValue(), "hallo")

        # test Matches()
        self.assertEqual(group.Matches("HALLO"), False)
        self.assertEqual(group.Matches("hallo"), True)

        # test copy
        groupCopy = copy.copy(group)
        self.assertEqual(group, groupCopy)


class TestClassification(unittest.TestCase):

    """Test cases for Classification"""

    def test_defaults(self):
        """Test Classification default settings"""
        c = Classification()
        self.assertEqual(c.FindGroup(-1), c.GetDefaultGroup())
        self.assertEqual(c.GetDefaultLineColor(), Black)
        self.assertEqual(c.GetDefaultFill(), Transparent)

        # The default group is not counted, hence 0 groups
        self.assertEqual(c.GetNumGroups(), 0)

    def test_set_default_properties(self):
        """Test Classification.SetDefaultLineColor and SetDefaultFill"""
        c = Classification()

        c.SetDefaultLineColor(red)
        self.assertEqual(c.GetDefaultLineColor(), red)
        self.assertEqual(c.GetDefaultFill(), Transparent)

        c.SetDefaultFill(green)
        self.assertEqual(c.GetDefaultFill(), green)
        self.assertEqual(c.GetDefaultLineColor(), red)

    def test_add_singleton(self):
        """Test Classification.AppendGroup(ClassGroupSingleton())"""
        c = Classification()
        self.assertEquals(c.FindGroup(5), c.GetDefaultGroup())

        s = ClassGroupSingleton(5)
        c.AppendGroup(s)
        self.assertEquals(c.FindGroup(5), s)
        self.assertEquals(c.FindGroup(0), c.GetDefaultGroup())

    def test_add_range(self):
        """Test Classification.AppendGroup(ClassGroupRange())"""
        c = Classification()
        self.assertEquals(c.FindGroup(0), c.GetDefaultGroup())

        r = ClassGroupRange((-10, 10))
        c.AppendGroup(r)
        self.assertEquals(c.FindGroup(-11), c.GetDefaultGroup())
        self.assertEquals(c.FindGroup(-10), r)
        self.assertEquals(c.FindGroup(9), r)
        self.assertEquals(c.FindGroup(5), r)
        self.assertEquals(c.FindGroup(10), c.GetDefaultGroup())

    def test_multiple_groups(self):
        """Test Classification with multiple groups"""
        c = Classification()
        s1 = ClassGroupSingleton(1)
        s1a = ClassGroupSingleton(1)
        s2 = ClassGroupSingleton(2)
        r = ClassGroupRange((-10, 10))

        c.AppendGroup(s1)
        c.AppendGroup(s2)
        c.AppendGroup(s1a)
        c.AppendGroup(r)

        self.assertEquals(c.FindGroup(-11), c.GetDefaultGroup())
        self.assertEquals(c.FindGroup(-10), r)
        self.assertEquals(c.FindGroup(1), s1)
        self.assertEquals(c.FindGroup(2), s2)
        self.assertEquals(c.FindGroup(3), r)
        self.assertEquals(c.FindGroup(9), r)
        self.assertEquals(c.FindGroup(10), c.GetDefaultGroup())

    def test_deepcopy(self):
        """Test deepcopy(Classification())"""
        c = Classification()
        c.AppendGroup(ClassGroupSingleton(5))
        c.AppendGroup(ClassGroupRange((-10, 10)))

        clazz = copy.deepcopy(c)

        self.assertEquals(clazz.GetNumGroups(), c.GetNumGroups())

        for i in range(clazz.GetNumGroups()):
            self.assertEquals(clazz.GetGroup(i), c.GetGroup(i))


    def test_iterator(self):
        """Test Classification iteration"""
        groups = [ClassGroupSingleton(5), ClassGroupSingleton(5),
                  ClassGroupRange((-3, 3)), ClassGroupSingleton(-5),
                  ClassGroupDefault()]

        clazz = Classification()

        for g in groups:
            clazz.AppendGroup(g)

        def convert(clazz):
            if isinstance(clazz, ClassGroupDefault):   return 0
            if isinstance(clazz, ClassGroupSingleton): return 1
            if isinstance(clazz, ClassGroupRange):     return 2

        list = []
        for g in clazz:
            list.append(convert(g))

        self.assertEquals(list, [0, 1, 1, 2, 1, 0])


if __name__ == "__main__":
    support.run_tests()
1	bh	598	# Copyright (c) 2002, 2003 by Intevation GmbH
2	jonathan	369	# Authors:
3			# Jonathan Coles <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with Thuban for details.
7
8			"""
9			Test the Classification class
10			"""
11
12			__version__ = "$Revision$"
13			# $Source$
14			# $Id$
15
16	jonathan	482	from __future__ import nested_scopes
17
18	jonathan	369	import unittest
19
20			import support
21			support.initthuban()
22
23	bh	723	import os
24	bh	1903	import copy
25
26	jonathan	1346	from Thuban.Model.color import Color, Transparent, Black
27	jonathan	884	from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_STRING, FIELDTYPE_DOUBLE
28			from Thuban.Model.classification import \
29			Classification, ClassGroup, \
30			ClassGroupDefault, ClassGroupSingleton, ClassGroupRange,\
31			ClassGroupProperties
32
33	bh	723	from Thuban.Model.session import Session
34	jonathan	395	from Thuban.Model.layer import Layer
35	jonathan	1356	from Thuban.Model.range import Range
36	jonathan	369
37
38	jonathan	482
39	bh	1903	# A few colors for use by the test cases
40			red = Color(1, 0, 0)
41			green = Color(0, 1, 0)
42			blue = Color(0, 0, 1)
43
44
45	bh	1898	class TestClassGroupProperties(unittest.TestCase):
46	jonathan	369
47	bh	1898	def test(self):
48	jonathan	482	"""Test ClassGroupProperties"""
49
50			props = ClassGroupProperties()
51	jonathan	1346	self.assertEqual(props.GetLineColor(), Black)
52	jonathan	482	self.assertEqual(props.GetLineWidth(), 1)
53	jonathan	1346	self.assertEqual(props.GetFill(), Transparent)
54	jonathan	482
55			props.SetLineColor(red)
56			self.assertEqual(props.GetLineColor(), red)
57
58			props.SetLineColor(blue)
59			self.assertEqual(props.GetLineColor(), blue)
60
61			props.SetLineWidth(10)
62			self.assertEqual(props.GetLineWidth(), 10)
63
64			self.assertRaises(ValueError, props.SetLineWidth, -10)
65			self.assertEqual(props.GetLineWidth(), 10)
66
67			newProps1 = ClassGroupProperties()
68			newProps2 = ClassGroupProperties()
69			self.assertNotEqual(newProps1, props)
70			self.assertEqual(newProps1, newProps2)
71
72	bh	1898
73			class TestClassGroup(unittest.TestCase):
74
75			def test(self):
76	jonathan	482	"""Test ClassGroup"""
77
78			# test constructor with no label
79			group = ClassGroup()
80			self.assertEqual(group.GetLabel(), "")
81
82			# test constructor with label
83			group = ClassGroup("hallo")
84			self.assertEqual(group.GetLabel(), "hallo")
85
86			# test SetLabel()/GetLabel()
87			group = ClassGroup("welt")
88			group.SetLabel("hallo")
89			self.assertEqual(group.GetLabel(), "hallo")
90
91			group.SetLabel("")
92			self.assertEqual(group.GetLabel(), "")
93
94			# test Matches
95	jonathan	610	# Matches() is a virtual function...can't test it here
96			#
97			#self.assertEqual(group.Matches(None), False)
98			#self.assertEqual(group.Matches(1), False)
99			#self.assertEqual(group.Matches("hallo"), False)
100			#self.assertEqual(group.Matches([]), False)
101	jonathan	482
102	jonathan	610	# test GetProperties...also a virtual function
103			#self.assertEqual(group.GetProperties(), None)
104	jonathan	482
105	bh	1898
106			class TestClassGroupDefault(unittest.TestCase):
107
108			def test(self):
109	jonathan	482	"""Test ClassGroupDefault"""
110
111			defProps = ClassGroupProperties()
112
113			newProps = ClassGroupProperties()
114			newProps.SetLineColor(Color(.25, .5, .75))
115			newProps.SetLineWidth(5)
116			newProps.SetFill(Color(.12, .24, .36))
117
118			# test constructor
119
120			group = ClassGroupDefault(newProps)
121			self.assertEqual(group.GetProperties(), newProps)
122
123			group = ClassGroupDefault(newProps, "hallo")
124			self.assertEqual(group.GetProperties(), newProps)
125			self.assertEqual(group.GetLabel(), "hallo")
126
127			# test empty constructor
128			group = ClassGroupDefault()
129			props = group.GetProperties()
130
131			self.assertEqual(group.GetLabel(), "")
132			self.assertEqual(defProps, props)
133
134			# test Matches()
135			self.assertEqual(group.Matches(None), True)
136			self.assertEqual(group.Matches(1), True)
137			self.assertEqual(group.Matches("hallo"), True)
138			self.assertEqual(group.Matches([]), True)
139
140			# test SetProperties()/GetProperties()
141			group.SetProperties(newProps)
142			self.assertEqual(group.GetProperties(), newProps)
143
144			# test copy
145			groupCopy = copy.copy(group)
146			self.assertEqual(group, groupCopy)
147
148	bh	1898
149			class TestClassGroupRange(unittest.TestCase):
150
151			def test(self):
152	jonathan	482	"""Test ClassGroupRange"""
153
154			defProps = ClassGroupProperties()
155			newProps = ClassGroupProperties()
156			newProps.SetLineColor(Color(.25, .5, .75))
157			newProps.SetLineWidth(5)
158			newProps.SetFill(Color(.12, .24, .36))
159
160			# test empty constructor
161			group = ClassGroupRange()
162
163			self.assertEqual(group.GetMin(), 0)
164			self.assertEqual(group.GetMax(), 1)
165			self.assertEqual(group.GetProperties(), defProps)
166			self.assertEqual(group.GetLabel(), "")
167	bh	1898
168	jonathan	482	# test SetMax()
169			self.assertRaises(ValueError, group.SetMax, 0)
170			self.assertRaises(ValueError, group.SetMax, -1)
171			self.assertEquals(group.GetMax(), 1)
172			group.SetMax(2)
173			self.assertEquals(group.GetMax(), 2)
174
175			# test SetMin()
176			self.assertRaises(ValueError, group.SetMin, 2)
177			self.assertRaises(ValueError, group.SetMin, 3)
178			self.assertEquals(group.GetMin(), 0)
179			group.SetMin(-5)
180			self.assertEquals(group.GetMin(), -5)
181
182			# test SetProperties()/GetProperties()
183			group.SetProperties(newProps)
184			self.assertEqual(group.GetProperties(), newProps)
185
186			# test SetRange()
187	jonathan	1356	self.assertRaises(ValueError, group.SetRange, (1, 0))
188			group.SetRange(Range("]-oo;6]"))
189			self.assertEqual(group.GetRange(), "]-oo;6]")
190			group.SetRange((-5, 5))
191	jonathan	884	self.assertEqual(group.GetRange(), "[-5;5[")
192	jonathan	482
193			# test Matches()
194			self.assertEqual(group.Matches(-6), False)
195			self.assertEqual(group.Matches(-5), True)
196			self.assertEqual(group.Matches(0), True)
197			self.assertEqual(group.Matches(4), True)
198			self.assertEqual(group.Matches(5), False)
199
200			# test copy
201			groupCopy = copy.copy(group)
202			self.assertEqual(group, groupCopy)
203
204	bh	1898
205			class TestClassGroupSingleton(unittest.TestCase):
206
207			def test(self):
208	jonathan	482	"""Test ClassGroupSingleton"""
209
210			defProps = ClassGroupProperties()
211			newProps = ClassGroupProperties()
212			newProps.SetLineColor(Color(.25, .5, .75))
213			newProps.SetLineWidth(5)
214			newProps.SetFill(Color(.12, .24, .36))
215
216			# test empty constructor
217			group = ClassGroupSingleton()
218
219			self.assertEqual(group.GetValue(), 0)
220			self.assertEqual(group.GetProperties(), defProps)
221			self.assertEqual(group.GetLabel(), "")
222
223			# test SetProperties()/GetProperties()
224			group.SetProperties(newProps)
225			self.assertEqual(group.GetProperties(), newProps)
226
227			# test SetValue()
228			group.SetValue(5)
229			self.assertEqual(group.GetValue(), 5)
230
231			# test Matches()
232			self.assertEqual(group.Matches(0), False)
233			self.assertEqual(group.Matches(5), True)
234
235			group.SetValue("5")
236			self.assertNotEqual(group.GetValue(), 5)
237
238			# test Matches()
239			self.assertEqual(group.Matches(5), False)
240			self.assertEqual(group.Matches("5"), True)
241
242			group.SetValue("hallo")
243			self.assertEqual(group.GetValue(), "hallo")
244
245			# test Matches()
246			self.assertEqual(group.Matches("HALLO"), False)
247			self.assertEqual(group.Matches("hallo"), True)
248
249			# test copy
250			groupCopy = copy.copy(group)
251			self.assertEqual(group, groupCopy)
252
253	bh	1898
254			class TestClassification(unittest.TestCase):
255
256	bh	1903	"""Test cases for Classification"""
257	jonathan	369
258	bh	1903	def test_defaults(self):
259			"""Test Classification default settings"""
260			c = Classification()
261			self.assertEqual(c.FindGroup(-1), c.GetDefaultGroup())
262			self.assertEqual(c.GetDefaultLineColor(), Black)
263			self.assertEqual(c.GetDefaultFill(), Transparent)
264	jonathan	482
265	bh	1903	# The default group is not counted, hence 0 groups
266			self.assertEqual(c.GetNumGroups(), 0)
267	jonathan	395
268	bh	1903	def test_set_default_properties(self):
269			"""Test Classification.SetDefaultLineColor and SetDefaultFill"""
270	jonathan	482	c = Classification()
271	jonathan	369
272	jonathan	482	c.SetDefaultLineColor(red)
273			self.assertEqual(c.GetDefaultLineColor(), red)
274	jonathan	1346	self.assertEqual(c.GetDefaultFill(), Transparent)
275	jonathan	369
276	jonathan	482	c.SetDefaultFill(green)
277			self.assertEqual(c.GetDefaultFill(), green)
278			self.assertEqual(c.GetDefaultLineColor(), red)
279	jonathan	369
280	bh	1903	def test_add_singleton(self):
281			"""Test Classification.AppendGroup(ClassGroupSingleton())"""
282			c = Classification()
283	jonathan	618	self.assertEquals(c.FindGroup(5), c.GetDefaultGroup())
284	jonathan	369
285	jonathan	482	s = ClassGroupSingleton(5)
286	jonathan	618	c.AppendGroup(s)
287			self.assertEquals(c.FindGroup(5), s)
288			self.assertEquals(c.FindGroup(0), c.GetDefaultGroup())
289	jonathan	369
290	bh	1903	def test_add_range(self):
291			"""Test Classification.AppendGroup(ClassGroupRange())"""
292			c = Classification()
293			self.assertEquals(c.FindGroup(0), c.GetDefaultGroup())
294
295	jonathan	1356	r = ClassGroupRange((-10, 10))
296	jonathan	618	c.AppendGroup(r)
297			self.assertEquals(c.FindGroup(-11), c.GetDefaultGroup())
298			self.assertEquals(c.FindGroup(-10), r)
299			self.assertEquals(c.FindGroup(9), r)
300	bh	1903	self.assertEquals(c.FindGroup(5), r)
301	jonathan	618	self.assertEquals(c.FindGroup(10), c.GetDefaultGroup())
302	jonathan	369
303	bh	1903	def test_multiple_groups(self):
304			"""Test Classification with multiple groups"""
305			c = Classification()
306			s1 = ClassGroupSingleton(1)
307			s1a = ClassGroupSingleton(1)
308			s2 = ClassGroupSingleton(2)
309			r = ClassGroupRange((-10, 10))
310
311			c.AppendGroup(s1)
312			c.AppendGroup(s2)
313			c.AppendGroup(s1a)
314			c.AppendGroup(r)
315
316			self.assertEquals(c.FindGroup(-11), c.GetDefaultGroup())
317			self.assertEquals(c.FindGroup(-10), r)
318			self.assertEquals(c.FindGroup(1), s1)
319			self.assertEquals(c.FindGroup(2), s2)
320			self.assertEquals(c.FindGroup(3), r)
321			self.assertEquals(c.FindGroup(9), r)
322			self.assertEquals(c.FindGroup(10), c.GetDefaultGroup())
323
324			def test_deepcopy(self):
325			"""Test deepcopy(Classification())"""
326			c = Classification()
327			c.AppendGroup(ClassGroupSingleton(5))
328			c.AppendGroup(ClassGroupRange((-10, 10)))
329
330	jonathan	656	clazz = copy.deepcopy(c)
331
332			self.assertEquals(clazz.GetNumGroups(), c.GetNumGroups())
333
334			for i in range(clazz.GetNumGroups()):
335			self.assertEquals(clazz.GetGroup(i), c.GetGroup(i))
336
337	bh	598
338	bh	1903	def test_iterator(self):
339			"""Test Classification iteration"""
340			groups = [ClassGroupSingleton(5), ClassGroupSingleton(5),
341			ClassGroupRange((-3, 3)), ClassGroupSingleton(-5),
342			ClassGroupDefault()]
343	bh	1898
344	bh	1903	clazz = Classification()
345
346			for g in groups:
347			clazz.AppendGroup(g)
348
349			def convert(clazz):
350			if isinstance(clazz, ClassGroupDefault): return 0
351			if isinstance(clazz, ClassGroupSingleton): return 1
352			if isinstance(clazz, ClassGroupRange): return 2
353
354			list = []
355			for g in clazz:
356			list.append(convert(g))
357
358			self.assertEquals(list, [0, 1, 1, 2, 1, 0])
359
360
361	jonathan	369	if __name__ == "__main__":
362	bh	598	support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision