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$

import unittest

import support
support.initthuban()

import copy

from Thuban.Model.color import Color, Transparent, Black
from Thuban.Model.classification import \
    Classification, ClassGroup, \
    ClassGroupDefault, ClassGroupSingleton, ClassGroupRange,\
    ClassGroupProperties
from Thuban.Model.messages import CLASS_CHANGED

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, support.SubscriberMixin):

    """Test cases for Classification"""

    def setUp(self):
        self.clazz = Classification()
        self.clazz.Subscribe(CLASS_CHANGED, self.subscribe_with_params,
                             CLASS_CHANGED)
        self.clear_messages()

    def tearDown(self):
        self.clear_messages()
        self.clazz.Destroy()
        del self.clazz

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

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

        # No messages should have been sent so far
        self.check_messages([])

    def test_set_default_properties(self):
        """Test Classification.SetDefaultLineColor and SetDefaultFill"""
        # No messages so far
        self.check_messages([])

        # Change the default line color
        self.clazz.SetDefaultLineColor(red)
        self.assertEqual(self.clazz.GetDefaultLineColor(), red)
        self.assertEqual(self.clazz.GetDefaultFill(), Transparent)
        self.assertEqual(self.clazz.GetDefaultLineWidth(), 1)

        self.check_messages([(CLASS_CHANGED,)])
        self.clear_messages()

        self.clazz.SetDefaultFill(green)
        self.assertEqual(self.clazz.GetDefaultFill(), green)
        self.assertEqual(self.clazz.GetDefaultLineColor(), red)
        self.assertEqual(self.clazz.GetDefaultLineWidth(), 1)
        self.check_messages([(CLASS_CHANGED,)])

        self.check_messages([(CLASS_CHANGED,)])
        self.clear_messages()

        self.clazz.SetDefaultLineWidth(10)
        self.assertEqual(self.clazz.GetDefaultFill(), green)
        self.assertEqual(self.clazz.GetDefaultLineColor(), red)
        self.assertEqual(self.clazz.GetDefaultLineWidth(), 10)
        self.check_messages([(CLASS_CHANGED,)])

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

        s = ClassGroupSingleton(5)
        self.clazz.AppendGroup(s)
        self.check_messages([(CLASS_CHANGED,)])
        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())"""
        self.assertEquals(self.clazz.FindGroup(0),
                          self.clazz.GetDefaultGroup())

        r = ClassGroupRange((-10, 10))
        self.clazz.AppendGroup(r)
        self.check_messages([(CLASS_CHANGED,)])
        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"""
        # 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.check_messages([(CLASS_CHANGED,), (CLASS_CHANGED,),
                             (CLASS_CHANGED,), (CLASS_CHANGED,)])

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