/[thuban]/branches/WIP-pyshapelib-bramz/test/test_classification.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/test/test_classification.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 369 by jonathan, Mon Jan 27 11:53:51 2003 UTC revision 1910 by bh, Fri Oct 31 18:16:46 2003 UTC
# Line 1  Line 1 
1  # Copyright (c) 2002 by Intevation GmbH  # Copyright (c) 2002, 2003 by Intevation GmbH
2  # Authors:  # Authors:
3  # Jonathan Coles <[email protected]>  # Jonathan Coles <[email protected]>
4  #  #
# Line 18  import unittest Line 18  import unittest
18  import support  import support
19  support.initthuban()  support.initthuban()
20    
21  from Thuban.Model.classification import Classification  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  class TestClassification(unittest.TestCase):          self.assertEquals(list, [0, 1, 1, 2, 1, 0])
459    
     def test_classification(self):  
         """Test Classification"""  
   
         #  
         # init with no params  
         #  
         c = Classification()  
         self.assertEquals(c.field, None)  
         self.assertEquals(c.NullData, None)  
   
         #  
         # setField  
         #  
         c = Classification()  
         c.setField("Test")  
         self.assertEquals(c.field, "Test")  
         c.setField(None)  
         self.assertEquals(c.field, None)  
   
         #  
         # init with field  
         #  
         c = Classification("Test")  
         self.assertEquals(c.field, "Test")  
         self.assertEquals(c.NullData, None)  
   
         #  
         # addRange  
         #  
         c0 = Classification("c0")  
         self.assertRaises(ValueError, c0.addRange, 0, 0, None)  
         self.assertRaises(ValueError, c0.addRange, 10, 0, None)  
         c0.addRange(-10, 0, "1")  
         c0.addRange(0, 10, "2")  
   
         #  
         # addPoint  
         #  
         c1 = Classification("c1")  
         c1.addPoint(0, "1")  
         c1.addPoint("0", "2")  
         self.assertRaises(TypeError, c1.addPoint, {'monty':'python'}, "3")  
   
         #  
         # getProperties  
         #  
   
         self.assertEqual(c0.getProperties(-10), "1")  
         self.assertEqual(c0.getProperties(-11), None)  
         self.assertEqual(c0.getProperties(0), "2") # min <= x < max  
         self.assertEqual(c0.getProperties(10), None)  
         self.assertEqual(c0.getProperties(11), None)  
   
         self.assertEqual(c1.getProperties(0), "1")  
         self.assertEqual(c1.getProperties("0"), "2")  
         self.assertEqual(c1.getProperties(-1), None)  
         self.assertEqual(c1.getProperties(1), None)  
         self.assertRaises(TypeError, c1.getProperties, {'monty':'python'})  
   
         #  
         # toggle field  
         #  
   
         c0.setField(None)  
         self.assertEqual(c0.getProperties(10), None)  
         self.assertEqual(c0.getProperties(11), None)  
   
         c1.setField(None)  
         self.assertEqual(c1.getProperties(0), None)  
         self.assertEqual(c1.getProperties("0"), None)  
   
         c0.setField("c0")  
         self.assertEqual(c0.getProperties(10), None)  
         self.assertEqual(c0.getProperties(11), None)  
   
         c1.setField("c1")  
         self.assertEqual(c1.getProperties(0), "1")  
         self.assertEqual(c1.getProperties("0"), "2")  
460    
461  if __name__ == "__main__":  if __name__ == "__main__":
462      unittest.main()      support.run_tests()
Legend:
Removed from v.369  
changed lines
  Added in v.1910
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26