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 setUp(self):
        self.clazz = Classification()

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

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

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

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

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

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

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

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

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

    def test_multiple_groups(self):
        """Test Classification with multiple groups"""
        c = Classification()

        # two singletons matching 1 to test whether they're tested in
        # the right order. Use a non default fill on the second to make
        # it compare unequal to the first.
        s1 = ClassGroupSingleton(1)
        s1a = ClassGroupSingleton(1)
        s1a.GetProperties().SetFill(blue)
        # Sanity check: are they considered different?
        self.assertNotEqual(s1, s1a)

        s2 = ClassGroupSingleton(2)
        r = ClassGroupRange((-10, 10))

        self.clazz.AppendGroup(s1)
        self.clazz.AppendGroup(s2)
        self.clazz.AppendGroup(s1a)
        self.clazz.AppendGroup(r)

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

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

        clazz = copy.deepcopy(self.clazz)

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

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


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

        for g in groups:
            self.clazz.AppendGroup(g)

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

        list = []
        for g in self.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	1905	def setUp(self):
259			self.clazz = Classification()
260
261	bh	1903	def test_defaults(self):
262			"""Test Classification default settings"""
263			c = Classification()
264	bh	1905	self.assertEqual(self.clazz.FindGroup(-1),
265			self.clazz.GetDefaultGroup())
266			self.assertEqual(self.clazz.GetDefaultLineColor(), Black)
267			self.assertEqual(self.clazz.GetDefaultFill(), Transparent)
268	jonathan	482
269	bh	1903	# The default group is not counted, hence 0 groups
270	bh	1905	self.assertEqual(self.clazz.GetNumGroups(), 0)
271	jonathan	395
272	bh	1903	def test_set_default_properties(self):
273			"""Test Classification.SetDefaultLineColor and SetDefaultFill"""
274	jonathan	482	c = Classification()
275	jonathan	369
276	bh	1905	self.clazz.SetDefaultLineColor(red)
277			self.assertEqual(self.clazz.GetDefaultLineColor(), red)
278			self.assertEqual(self.clazz.GetDefaultFill(), Transparent)
279	jonathan	369
280	bh	1905	self.clazz.SetDefaultFill(green)
281			self.assertEqual(self.clazz.GetDefaultFill(), green)
282			self.assertEqual(self.clazz.GetDefaultLineColor(), red)
283	jonathan	369
284	bh	1903	def test_add_singleton(self):
285			"""Test Classification.AppendGroup(ClassGroupSingleton())"""
286			c = Classification()
287	bh	1905	self.assertEquals(self.clazz.FindGroup(5),
288			self.clazz.GetDefaultGroup())
289	jonathan	369
290	jonathan	482	s = ClassGroupSingleton(5)
291	bh	1905	self.clazz.AppendGroup(s)
292			self.assertEquals(self.clazz.FindGroup(5), s)
293			self.assertEquals(self.clazz.FindGroup(0),
294			self.clazz.GetDefaultGroup())
295	jonathan	369
296	bh	1903	def test_add_range(self):
297			"""Test Classification.AppendGroup(ClassGroupRange())"""
298			c = Classification()
299	bh	1905	self.assertEquals(self.clazz.FindGroup(0),
300			self.clazz.GetDefaultGroup())
301	bh	1903
302	jonathan	1356	r = ClassGroupRange((-10, 10))
303	bh	1905	self.clazz.AppendGroup(r)
304			self.assertEquals(self.clazz.FindGroup(-11),
305			self.clazz.GetDefaultGroup())
306			self.assertEquals(self.clazz.FindGroup(-10), r)
307			self.assertEquals(self.clazz.FindGroup(9), r)
308			self.assertEquals(self.clazz.FindGroup(5), r)
309			self.assertEquals(self.clazz.FindGroup(10),
310			self.clazz.GetDefaultGroup())
311	jonathan	369
312	bh	1903	def test_multiple_groups(self):
313			"""Test Classification with multiple groups"""
314			c = Classification()
315	bh	1905
316			# two singletons matching 1 to test whether they're tested in
317			# the right order. Use a non default fill on the second to make
318			# it compare unequal to the first.
319	bh	1903	s1 = ClassGroupSingleton(1)
320			s1a = ClassGroupSingleton(1)
321	bh	1905	s1a.GetProperties().SetFill(blue)
322			# Sanity check: are they considered different?
323			self.assertNotEqual(s1, s1a)
324
325	bh	1903	s2 = ClassGroupSingleton(2)
326			r = ClassGroupRange((-10, 10))
327
328	bh	1905	self.clazz.AppendGroup(s1)
329			self.clazz.AppendGroup(s2)
330			self.clazz.AppendGroup(s1a)
331			self.clazz.AppendGroup(r)
332	bh	1903
333	bh	1905	self.assertEquals(self.clazz.FindGroup(-11),
334			self.clazz.GetDefaultGroup())
335			self.assertEquals(self.clazz.FindGroup(-10), r)
336			self.assertEquals(self.clazz.FindGroup(1), s1)
337			self.assertEquals(self.clazz.FindGroup(2), s2)
338			self.assertEquals(self.clazz.FindGroup(3), r)
339			self.assertEquals(self.clazz.FindGroup(9), r)
340			self.assertEquals(self.clazz.FindGroup(10),
341			self.clazz.GetDefaultGroup())
342	bh	1903
343			def test_deepcopy(self):
344			"""Test deepcopy(Classification())"""
345	bh	1905	self.clazz.AppendGroup(ClassGroupSingleton(5))
346			self.clazz.AppendGroup(ClassGroupRange((-10, 10)))
347	bh	1903
348	bh	1905	clazz = copy.deepcopy(self.clazz)
349	jonathan	656
350	bh	1905	self.assertEquals(clazz.GetNumGroups(), self.clazz.GetNumGroups())
351	jonathan	656
352			for i in range(clazz.GetNumGroups()):
353	bh	1905	self.assertEquals(clazz.GetGroup(i), self.clazz.GetGroup(i))
354	jonathan	656
355	bh	598
356	bh	1903	def test_iterator(self):
357			"""Test Classification iteration"""
358			groups = [ClassGroupSingleton(5), ClassGroupSingleton(5),
359			ClassGroupRange((-3, 3)), ClassGroupSingleton(-5),
360			ClassGroupDefault()]
361	bh	1898
362	bh	1903	for g in groups:
363	bh	1905	self.clazz.AppendGroup(g)
364	bh	1903
365	bh	1905	def convert(group):
366			if isinstance(group, ClassGroupDefault): return 0
367			if isinstance(group, ClassGroupSingleton): return 1
368			if isinstance(group, ClassGroupRange): return 2
369	bh	1903
370			list = []
371	bh	1905	for g in self.clazz:
372	bh	1903	list.append(convert(g))
373
374			self.assertEquals(list, [0, 1, 1, 2, 1, 0])
375
376
377	jonathan	369	if __name__ == "__main__":
378	bh	598	support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision