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	# Copyright (c) 2002, 2003 by Intevation GmbH
2	# 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	import copy
22
23	from Thuban.Model.color import Color, Transparent, Black
24	from Thuban.Model.classification import \
25	Classification, ClassGroup, \
26	ClassGroupDefault, ClassGroupSingleton, ClassGroupRange,\
27	ClassGroupProperties
28	from Thuban.Model.messages import CLASS_CHANGED
29
30	from Thuban.Model.range import Range
31
32
33
34	# 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	class TestClassGroupProperties(unittest.TestCase):
41
42	def test(self):
43	"""Test ClassGroupProperties"""
44
45	props = ClassGroupProperties()
46	self.assertEqual(props.GetLineColor(), Black)
47	self.assertEqual(props.GetLineWidth(), 1)
48	self.assertEqual(props.GetFill(), Transparent)
49
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
68	class TestClassGroup(unittest.TestCase):
69
70	def test(self):
71	"""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	# 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
97	# test GetProperties...also a virtual function
98	#self.assertEqual(group.GetProperties(), None)
99
100
101	class TestClassGroupDefault(unittest.TestCase):
102
103	def test(self):
104	"""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
144	class TestClassGroupRange(unittest.TestCase):
145
146	def test(self):
147	"""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
163	# 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	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	self.assertEqual(group.GetRange(), "[-5;5[")
187
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
200	class TestClassGroupSingleton(unittest.TestCase):
201
202	def test(self):
203	"""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
249	class TestClassification(unittest.TestCase, support.SubscriberMixin):
250
251	"""Test cases for Classification"""
252
253	def setUp(self):
254	self.clazz = Classification()
255	self.clazz.Subscribe(CLASS_CHANGED, self.subscribe_with_params,
256	CLASS_CHANGED)
257	self.clear_messages()
258
259	def tearDown(self):
260	self.clear_messages()
261	self.clazz.Destroy()
262	del self.clazz
263
264	def test_defaults(self):
265	"""Test Classification default settings"""
266	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	self.assertEqual(self.clazz.GetDefaultLineWidth(), 1)
271
272	# The default group is not counted, hence 0 groups
273	self.assertEqual(self.clazz.GetNumGroups(), 0)
274
275	# No messages should have been sent so far
276	self.check_messages([])
277
278	def test_set_default_properties(self):
279	"""Test Classification.SetDefaultLineColor and SetDefaultFill"""
280	# No messages so far
281	self.check_messages([])
282
283	# Change the default line color
284	self.clazz.SetDefaultLineColor(red)
285	self.assertEqual(self.clazz.GetDefaultLineColor(), red)
286	self.assertEqual(self.clazz.GetDefaultFill(), Transparent)
287	self.assertEqual(self.clazz.GetDefaultLineWidth(), 1)
288
289	self.check_messages([(CLASS_CHANGED,)])
290	self.clear_messages()
291
292	self.clazz.SetDefaultFill(green)
293	self.assertEqual(self.clazz.GetDefaultFill(), green)
294	self.assertEqual(self.clazz.GetDefaultLineColor(), red)
295	self.assertEqual(self.clazz.GetDefaultLineWidth(), 1)
296	self.check_messages([(CLASS_CHANGED,)])
297
298	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	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	def test_add_singleton(self):
321	"""Test Classification.AppendGroup(ClassGroupSingleton())"""
322	self.assertEquals(self.clazz.FindGroup(5),
323	self.clazz.GetDefaultGroup())
324
325	s = ClassGroupSingleton(5)
326	self.clazz.AppendGroup(s)
327	self.check_messages([(CLASS_CHANGED,)])
328	self.assertEquals(self.clazz.FindGroup(5), s)
329	self.assertEquals(self.clazz.FindGroup(0),
330	self.clazz.GetDefaultGroup())
331
332	def test_add_range(self):
333	"""Test Classification.AppendGroup(ClassGroupRange())"""
334	self.assertEquals(self.clazz.FindGroup(0),
335	self.clazz.GetDefaultGroup())
336
337	r = ClassGroupRange((-10, 10))
338	self.clazz.AppendGroup(r)
339	self.check_messages([(CLASS_CHANGED,)])
340	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
348	def test_multiple_groups(self):
349	"""Test Classification with multiple groups"""
350	# 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	s1 = ClassGroupSingleton(1)
354	s1a = ClassGroupSingleton(1)
355	s1a.GetProperties().SetFill(blue)
356	# Sanity check: are they considered different?
357	self.assertNotEqual(s1, s1a)
358
359	s2 = ClassGroupSingleton(2)
360	r = ClassGroupRange((-10, 10))
361
362	self.clazz.AppendGroup(s1)
363	self.clazz.AppendGroup(s2)
364	self.clazz.AppendGroup(s1a)
365	self.clazz.AppendGroup(r)
366	self.check_messages([(CLASS_CHANGED,), (CLASS_CHANGED,),
367	(CLASS_CHANGED,), (CLASS_CHANGED,)])
368
369	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
379	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	def test_deepcopy(self):
428	"""Test deepcopy(Classification())"""
429	self.clazz.AppendGroup(ClassGroupSingleton(5))
430	self.clazz.AppendGroup(ClassGroupRange((-10, 10)))
431
432	clazz = copy.deepcopy(self.clazz)
433
434	self.assertEquals(clazz.GetNumGroups(), self.clazz.GetNumGroups())
435
436	for i in range(clazz.GetNumGroups()):
437	self.assertEquals(clazz.GetGroup(i), self.clazz.GetGroup(i))
438
439
440	def test_iterator(self):
441	"""Test Classification iteration"""
442	groups = [ClassGroupSingleton(5), ClassGroupSingleton(5),
443	ClassGroupRange((-3, 3)), ClassGroupSingleton(-5),
444	ClassGroupDefault()]
445
446	for g in groups:
447	self.clazz.AppendGroup(g)
448
449	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
454	list = []
455	for g in self.clazz:
456	list.append(convert(g))
457
458	self.assertEquals(list, [0, 1, 1, 2, 1, 0])
459
460
461	if __name__ == "__main__":
462	support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision