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_set_default_group(self):
        """Test Classification.SetDefaultGroup()"""
        prop = ClassGroupProperties()
        prop.SetLineColor(blue)
        prop.SetLineWidth(5)
        prop.SetFill(red)

        self.clazz.SetDefaultGroup(ClassGroupDefault(prop))
        self.assertEqual(self.clazz.GetDefaultFill(), red)
        self.assertEqual(self.clazz.GetDefaultLineColor(), blue)
        self.assertEqual(self.clazz.GetDefaultLineWidth(), 5)
        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_insert_group(self):
        """Test Classification.InsertGroup()"""
        s1 = ClassGroupSingleton(1)
        s2 = ClassGroupSingleton(2)
        r = ClassGroupRange((0, 10))

        self.clazz.AppendGroup(s1)
        self.clazz.AppendGroup(r)
        self.assertEquals(self.clazz.FindGroup(2), r)
        self.clear_messages()

        self.clazz.InsertGroup(1, s2)
        self.assertEquals(self.clazz.FindGroup(2), s2)
        self.check_messages([(CLASS_CHANGED,)])

    def test_remove_group(self):
        """Test Classification.RemoveGroup()"""
        s1 = ClassGroupSingleton(1)
        s2 = ClassGroupSingleton(2)
        r = ClassGroupRange((0, 10))

        self.clazz.AppendGroup(s1)
        self.clazz.AppendGroup(s2)
        self.clazz.AppendGroup(r)
        self.assertEquals(self.clazz.FindGroup(2), s2)
        self.clear_messages()

        self.clazz.RemoveGroup(1)
        self.assertEquals(self.clazz.FindGroup(2), r)
        self.check_messages([(CLASS_CHANGED,)])

    def test_replace_group(self):
        """Test Classification.ReplaceGroup()"""
        s1 = ClassGroupSingleton(1)
        s2 = ClassGroupSingleton(2)
        r = ClassGroupRange((0, 10))

        self.clazz.AppendGroup(s2)
        self.clazz.AppendGroup(r)
        self.assertEquals(self.clazz.FindGroup(2), s2)
        self.assertEquals(self.clazz.FindGroup(1), r)
        self.clear_messages()

        self.clazz.ReplaceGroup(0, s1)
        self.assertEquals(self.clazz.FindGroup(2), r)
        self.assertEquals(self.clazz.FindGroup(1), s1)
        self.check_messages([(CLASS_CHANGED,)])

    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	1910	def test_set_default_group(self):
308			"""Test Classification.SetDefaultGroup()"""
309			prop = ClassGroupProperties()
310			prop.SetLineColor(blue)
311			prop.SetLineWidth(5)
312			prop.SetFill(red)
313
314			self.clazz.SetDefaultGroup(ClassGroupDefault(prop))
315			self.assertEqual(self.clazz.GetDefaultFill(), red)
316			self.assertEqual(self.clazz.GetDefaultLineColor(), blue)
317			self.assertEqual(self.clazz.GetDefaultLineWidth(), 5)
318			self.check_messages([(CLASS_CHANGED,)])
319
320	bh	1903	def test_add_singleton(self):
321			"""Test Classification.AppendGroup(ClassGroupSingleton())"""
322	bh	1905	self.assertEquals(self.clazz.FindGroup(5),
323			self.clazz.GetDefaultGroup())
324	jonathan	369
325	jonathan	482	s = ClassGroupSingleton(5)
326	bh	1905	self.clazz.AppendGroup(s)
327	bh	1907	self.check_messages([(CLASS_CHANGED,)])
328	bh	1905	self.assertEquals(self.clazz.FindGroup(5), s)
329			self.assertEquals(self.clazz.FindGroup(0),
330			self.clazz.GetDefaultGroup())
331	jonathan	369
332	bh	1903	def test_add_range(self):
333			"""Test Classification.AppendGroup(ClassGroupRange())"""
334	bh	1905	self.assertEquals(self.clazz.FindGroup(0),
335			self.clazz.GetDefaultGroup())
336	bh	1903
337	jonathan	1356	r = ClassGroupRange((-10, 10))
338	bh	1905	self.clazz.AppendGroup(r)
339	bh	1907	self.check_messages([(CLASS_CHANGED,)])
340	bh	1905	self.assertEquals(self.clazz.FindGroup(-11),
341			self.clazz.GetDefaultGroup())
342			self.assertEquals(self.clazz.FindGroup(-10), r)
343			self.assertEquals(self.clazz.FindGroup(9), r)
344			self.assertEquals(self.clazz.FindGroup(5), r)
345			self.assertEquals(self.clazz.FindGroup(10),
346			self.clazz.GetDefaultGroup())
347	jonathan	369
348	bh	1903	def test_multiple_groups(self):
349			"""Test Classification with multiple groups"""
350	bh	1905	# two singletons matching 1 to test whether they're tested in
351			# the right order. Use a non default fill on the second to make
352			# it compare unequal to the first.
353	bh	1903	s1 = ClassGroupSingleton(1)
354			s1a = ClassGroupSingleton(1)
355	bh	1905	s1a.GetProperties().SetFill(blue)
356			# Sanity check: are they considered different?
357			self.assertNotEqual(s1, s1a)
358
359	bh	1903	s2 = ClassGroupSingleton(2)
360			r = ClassGroupRange((-10, 10))
361
362	bh	1905	self.clazz.AppendGroup(s1)
363			self.clazz.AppendGroup(s2)
364			self.clazz.AppendGroup(s1a)
365			self.clazz.AppendGroup(r)
366	bh	1907	self.check_messages([(CLASS_CHANGED,), (CLASS_CHANGED,),
367			(CLASS_CHANGED,), (CLASS_CHANGED,)])
368	bh	1903
369	bh	1905	self.assertEquals(self.clazz.FindGroup(-11),
370			self.clazz.GetDefaultGroup())
371			self.assertEquals(self.clazz.FindGroup(-10), r)
372			self.assertEquals(self.clazz.FindGroup(1), s1)
373			self.assertEquals(self.clazz.FindGroup(2), s2)
374			self.assertEquals(self.clazz.FindGroup(3), r)
375			self.assertEquals(self.clazz.FindGroup(9), r)
376			self.assertEquals(self.clazz.FindGroup(10),
377			self.clazz.GetDefaultGroup())
378	bh	1903
379	bh	1910	def test_insert_group(self):
380			"""Test Classification.InsertGroup()"""
381			s1 = ClassGroupSingleton(1)
382			s2 = ClassGroupSingleton(2)
383			r = ClassGroupRange((0, 10))
384
385			self.clazz.AppendGroup(s1)
386			self.clazz.AppendGroup(r)
387			self.assertEquals(self.clazz.FindGroup(2), r)
388			self.clear_messages()
389
390			self.clazz.InsertGroup(1, s2)
391			self.assertEquals(self.clazz.FindGroup(2), s2)
392			self.check_messages([(CLASS_CHANGED,)])
393
394			def test_remove_group(self):
395			"""Test Classification.RemoveGroup()"""
396			s1 = ClassGroupSingleton(1)
397			s2 = ClassGroupSingleton(2)
398			r = ClassGroupRange((0, 10))
399
400			self.clazz.AppendGroup(s1)
401			self.clazz.AppendGroup(s2)
402			self.clazz.AppendGroup(r)
403			self.assertEquals(self.clazz.FindGroup(2), s2)
404			self.clear_messages()
405
406			self.clazz.RemoveGroup(1)
407			self.assertEquals(self.clazz.FindGroup(2), r)
408			self.check_messages([(CLASS_CHANGED,)])
409
410			def test_replace_group(self):
411			"""Test Classification.ReplaceGroup()"""
412			s1 = ClassGroupSingleton(1)
413			s2 = ClassGroupSingleton(2)
414			r = ClassGroupRange((0, 10))
415
416			self.clazz.AppendGroup(s2)
417			self.clazz.AppendGroup(r)
418			self.assertEquals(self.clazz.FindGroup(2), s2)
419			self.assertEquals(self.clazz.FindGroup(1), r)
420			self.clear_messages()
421
422			self.clazz.ReplaceGroup(0, s1)
423			self.assertEquals(self.clazz.FindGroup(2), r)
424			self.assertEquals(self.clazz.FindGroup(1), s1)
425			self.check_messages([(CLASS_CHANGED,)])
426
427	bh	1903	def test_deepcopy(self):
428			"""Test deepcopy(Classification())"""
429	bh	1905	self.clazz.AppendGroup(ClassGroupSingleton(5))
430			self.clazz.AppendGroup(ClassGroupRange((-10, 10)))
431	bh	1903
432	bh	1905	clazz = copy.deepcopy(self.clazz)
433	jonathan	656
434	bh	1905	self.assertEquals(clazz.GetNumGroups(), self.clazz.GetNumGroups())
435	jonathan	656
436			for i in range(clazz.GetNumGroups()):
437	bh	1905	self.assertEquals(clazz.GetGroup(i), self.clazz.GetGroup(i))
438	jonathan	656
439	bh	598
440	bh	1903	def test_iterator(self):
441			"""Test Classification iteration"""
442			groups = [ClassGroupSingleton(5), ClassGroupSingleton(5),
443			ClassGroupRange((-3, 3)), ClassGroupSingleton(-5),
444			ClassGroupDefault()]
445	bh	1898
446	bh	1903	for g in groups:
447	bh	1905	self.clazz.AppendGroup(g)
448	bh	1903
449	bh	1905	def convert(group):
450			if isinstance(group, ClassGroupDefault): return 0
451			if isinstance(group, ClassGroupSingleton): return 1
452			if isinstance(group, ClassGroupRange): return 2
453	bh	1903
454			list = []
455	bh	1905	for g in self.clazz:
456	bh	1903	list.append(convert(g))
457
458			self.assertEquals(list, [0, 1, 1, 2, 1, 0])
459
460
461	jonathan	369	if __name__ == "__main__":
462	bh	598	support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision