/[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 446 by jonathan, Thu Feb 27 16:05:10 2003 UTC revision 2688 by frank, Fri Jun 30 12:27:20 2006 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
 from Thuban.Model.layer import Layer  
22    
23    from Thuban.Model.color import Color, Transparent, Black
24    from Thuban.Model.classification import \
25        Classification, ClassGroup, \
26        ClassGroupDefault, ClassGroupSingleton, ClassGroupRange,\
27        ClassGroupPattern, ClassGroupProperties
28    from Thuban.Model.messages import CLASS_CHANGED
29    
30  class TestClassification(unittest.TestCase):  from Thuban.Model.range import Range
31    
     def test_classification(self):  
         """Test Classification"""  
32    
         layer = Layer("asdf", "../Data/iceland/political.shp")  
33    
34          #  # A few colors for use by the test cases
35          # init with no params  red = Color(1, 0, 0)
36          #  green = Color(0, 1, 0)
37          c = Classification(layer)  blue = Color(0, 0, 1)
         self.assertEqual(c.GetField(), None)  
         self.assertNotEqual(c.GetDefaultGroup(), None)  
38    
         #  
         # SetField  
         #  
         c = Classification(layer)  
         c.SetField("Test")  
         self.assertEqual(c.field, "Test")  
         c.SetField(None)  
         self.assertEqual(c.field, None)  
39    
40          #  class TestClassGroupProperties(unittest.TestCase):
         # init with field  
         #  
         c = Classification(layer, "Test")  
         self.assertEqual(c.field, "Test")  
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          # GetProperties          #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 TestClassGroupPattern(unittest.TestCase):
250    
251        def test(self):
252            """Test ClassGroupPattern"""
253    
254            defProps = ClassGroupProperties()
255            newProps = ClassGroupProperties()
256            newProps.SetLineColor(Color(.25, .5, .75))
257            newProps.SetLineWidth(5)
258            newProps.SetFill(Color(.12, .24, .36))
259    
260            # test empty constructor
261            group = ClassGroupPattern()
262    
263            self.assertEqual(group.GetPattern(), "")
264            self.assertEqual(group.GetProperties(), defProps)
265            self.assertEqual(group.GetLabel(), "")
266    
267            # test SetProperties()/GetProperties()
268            group.SetProperties(newProps)
269            self.assertEqual(group.GetProperties(), newProps)
270    
271            # test SetPattern()
272            group.SetPattern("A")
273            self.assertEqual(group.GetPattern(), "A")
274    
275            # test Matches()
276            self.assertEqual(group.Matches("CBA"), False)
277            self.assertEqual(group.Matches("ABC"), True)
278    
279            group.SetPattern("a")
280            self.assertNotEqual(group.GetPattern(), "A")
281    
282            # test Matches()
283            self.assertEqual(group.Matches("Abc"), False)
284            self.assertEqual(group.Matches("aBC"), True)
285    
286            group.SetPattern("hallo")
287            self.assertEqual(group.GetPattern(), "hallo")
288    
289            # test Matches()
290            self.assertEqual(group.Matches("HALLO"), False)
291            self.assertEqual(group.Matches("hallo"), True)
292    
293            # test copy
294            groupCopy = copy.copy(group)
295            self.assertEqual(group, groupCopy)
296    
297    
298    class TestClassification(unittest.TestCase, support.SubscriberMixin):
299    
300        """Test cases for Classification"""
301    
302        def setUp(self):
303            self.clazz = Classification()
304            self.clazz.Subscribe(CLASS_CHANGED, self.subscribe_with_params,
305                                 CLASS_CHANGED)
306            self.clear_messages()
307    
308        def tearDown(self):
309            self.clear_messages()
310            self.clazz.Destroy()
311            del self.clazz
312    
313        def test_defaults(self):
314            """Test Classification default settings"""
315            self.assertEqual(self.clazz.FindGroup(-1),
316                             self.clazz.GetDefaultGroup())
317            self.assertEqual(self.clazz.GetDefaultLineColor(), Black)
318            self.assertEqual(self.clazz.GetDefaultFill(), Transparent)
319            self.assertEqual(self.clazz.GetDefaultLineWidth(), 1)
320    
321            # The default group is not counted, hence 0 groups
322            self.assertEqual(self.clazz.GetNumGroups(), 0)
323    
324            # No messages should have been sent so far
325            self.check_messages([])
326    
327        def test_set_default_properties(self):
328            """Test Classification.SetDefaultLineColor and SetDefaultFill"""
329            # No messages so far
330            self.check_messages([])
331    
332            # Change the default line color
333            self.clazz.SetDefaultLineColor(red)
334            self.assertEqual(self.clazz.GetDefaultLineColor(), red)
335            self.assertEqual(self.clazz.GetDefaultFill(), Transparent)
336            self.assertEqual(self.clazz.GetDefaultLineWidth(), 1)
337    
338            self.check_messages([(CLASS_CHANGED,)])
339            self.clear_messages()
340    
341            self.clazz.SetDefaultFill(green)
342            self.assertEqual(self.clazz.GetDefaultFill(), green)
343            self.assertEqual(self.clazz.GetDefaultLineColor(), red)
344            self.assertEqual(self.clazz.GetDefaultLineWidth(), 1)
345            self.check_messages([(CLASS_CHANGED,)])
346    
347            self.check_messages([(CLASS_CHANGED,)])
348            self.clear_messages()
349    
350            self.clazz.SetDefaultLineWidth(10)
351            self.assertEqual(self.clazz.GetDefaultFill(), green)
352            self.assertEqual(self.clazz.GetDefaultLineColor(), red)
353            self.assertEqual(self.clazz.GetDefaultLineWidth(), 10)
354            self.check_messages([(CLASS_CHANGED,)])
355    
356        def test_set_default_group(self):
357            """Test Classification.SetDefaultGroup()"""
358            prop = ClassGroupProperties()
359            prop.SetLineColor(blue)
360            prop.SetLineWidth(5)
361            prop.SetFill(red)
362    
363            self.clazz.SetDefaultGroup(ClassGroupDefault(prop))
364            self.assertEqual(self.clazz.GetDefaultFill(), red)
365            self.assertEqual(self.clazz.GetDefaultLineColor(), blue)
366            self.assertEqual(self.clazz.GetDefaultLineWidth(), 5)
367            self.check_messages([(CLASS_CHANGED,)])
368    
369        def test_add_singleton(self):
370            """Test Classification.AppendGroup(ClassGroupSingleton())"""
371            self.assertEquals(self.clazz.FindGroup(5),
372                              self.clazz.GetDefaultGroup())
373    
374            s = ClassGroupSingleton(5)
375            self.clazz.AppendGroup(s)
376            self.check_messages([(CLASS_CHANGED,)])
377            self.assertEquals(self.clazz.FindGroup(5), s)
378            self.assertEquals(self.clazz.FindGroup(0),
379                              self.clazz.GetDefaultGroup())
380    
381        def test_add_range(self):
382            """Test Classification.AppendGroup(ClassGroupRange())"""
383            self.assertEquals(self.clazz.FindGroup(0),
384                              self.clazz.GetDefaultGroup())
385    
386            r = ClassGroupRange((-10, 10))
387            self.clazz.AppendGroup(r)
388            self.check_messages([(CLASS_CHANGED,)])
389            self.assertEquals(self.clazz.FindGroup(-11),
390                              self.clazz.GetDefaultGroup())
391            self.assertEquals(self.clazz.FindGroup(-10), r)
392            self.assertEquals(self.clazz.FindGroup(9), r)
393            self.assertEquals(self.clazz.FindGroup(5), r)
394            self.assertEquals(self.clazz.FindGroup(10),
395                              self.clazz.GetDefaultGroup())
396    
397        def test_add_pattern(self):
398            """Test Classification.AppendGroup(ClassGroupPattern())"""
399            self.assertEquals(self.clazz.FindGroup(5),
400                              self.clazz.GetDefaultGroup())
401    
402            s = ClassGroupPattern("A")
403            self.clazz.AppendGroup(s)
404            self.check_messages([(CLASS_CHANGED,)])
405            self.assertEquals(self.clazz.FindGroup("A"), s)
406            self.assertEquals(self.clazz.FindGroup("B"),
407                              self.clazz.GetDefaultGroup())
408    
409        def test_multiple_groups_numerical(self):
410            """Test numerical Classification with multiple groups"""
411            # two singletons matching 1 to test whether they're tested in
412            # the right order. Use a non default fill on the second to make
413            # it compare unequal to the first.
414            s1 = ClassGroupSingleton(1)
415            s1a = ClassGroupSingleton(1)
416            s1a.GetProperties().SetFill(blue)
417            # Sanity check: are they considered different?
418            self.assertNotEqual(s1, s1a)
419    
420            s2 = ClassGroupSingleton(2)
421            r = ClassGroupRange((-10, 10))
422    
423            self.clazz.AppendGroup(s1)
424            self.clazz.AppendGroup(s2)
425            self.clazz.AppendGroup(s1a)
426            self.clazz.AppendGroup(r)
427            self.check_messages([(CLASS_CHANGED,), (CLASS_CHANGED,),
428                                 (CLASS_CHANGED,), (CLASS_CHANGED,)])
429    
430            self.assertEquals(self.clazz.FindGroup(-11),
431                              self.clazz.GetDefaultGroup())
432            self.assertEquals(self.clazz.FindGroup(-10), r)
433            self.assertEquals(self.clazz.FindGroup(1), s1)
434            self.assertEquals(self.clazz.FindGroup(2), s2)
435            self.assertEquals(self.clazz.FindGroup(3), r)
436            self.assertEquals(self.clazz.FindGroup(9), r)
437            self.assertEquals(self.clazz.FindGroup(10),
438                              self.clazz.GetDefaultGroup())
439    
440        def test_multiple_groups_textual(self):
441            """Test textual Classification with multiple groups"""
442            # A singleton and a pattern matching 'A' to test whether
443            # they're tested in the right order. Use a non default fill
444            # on the pattern to make it compare unequal to the first.
445            s = ClassGroupSingleton("A")
446            p = ClassGroupPattern("A")
447            p.GetProperties().SetFill(blue)
448            # Sanity check: are they considered different?
449            self.assertNotEqual(s, p)
450    
451            self.clazz.AppendGroup(s)
452            self.clazz.AppendGroup(p)
453            self.check_messages([(CLASS_CHANGED,), (CLASS_CHANGED,)])
454    
455            self.assertEquals(self.clazz.FindGroup("bca"),
456                              self.clazz.GetDefaultGroup())
457            self.assertEquals(self.clazz.FindGroup("A"), s)
458            self.assertEquals(self.clazz.FindGroup("Abc"), p)
459            self.assertEquals(self.clazz.FindGroup("abc"),
460                              self.clazz.GetDefaultGroup())
461    
462        def test_insert_group(self):
463            """Test Classification.InsertGroup()"""
464            s1 = ClassGroupSingleton(1)
465            s2 = ClassGroupSingleton(2)
466            r = ClassGroupRange((0, 10))
467    
468            self.clazz.AppendGroup(s1)
469            self.clazz.AppendGroup(r)
470            self.assertEquals(self.clazz.FindGroup(2), r)
471            self.clear_messages()
472    
473            self.clazz.InsertGroup(1, s2)
474            self.assertEquals(self.clazz.FindGroup(2), s2)
475            self.check_messages([(CLASS_CHANGED,)])
476    
477        def test_remove_group(self):
478            """Test Classification.RemoveGroup()"""
479            s1 = ClassGroupSingleton(1)
480            s2 = ClassGroupSingleton(2)
481            r = ClassGroupRange((0, 10))
482    
483            self.clazz.AppendGroup(s1)
484            self.clazz.AppendGroup(s2)
485            self.clazz.AppendGroup(r)
486            self.assertEquals(self.clazz.FindGroup(2), s2)
487            self.clear_messages()
488    
489            self.clazz.RemoveGroup(1)
490            self.assertEquals(self.clazz.FindGroup(2), r)
491            self.check_messages([(CLASS_CHANGED,)])
492    
493        def test_replace_group(self):
494            """Test Classification.ReplaceGroup()"""
495            s1 = ClassGroupSingleton(1)
496            s2 = ClassGroupSingleton(2)
497            r = ClassGroupRange((0, 10))
498    
499            self.clazz.AppendGroup(s2)
500            self.clazz.AppendGroup(r)
501            self.assertEquals(self.clazz.FindGroup(2), s2)
502            self.assertEquals(self.clazz.FindGroup(1), r)
503            self.clear_messages()
504    
505            self.clazz.ReplaceGroup(0, s1)
506            self.assertEquals(self.clazz.FindGroup(2), r)
507            self.assertEquals(self.clazz.FindGroup(1), s1)
508            self.check_messages([(CLASS_CHANGED,)])
509    
510        def test_deepcopy_numerical(self):
511            """Test deepcopy(numerical Classification())"""
512            self.clazz.AppendGroup(ClassGroupSingleton(5))
513            self.clazz.AppendGroup(ClassGroupRange((-10, 10)))
514    
515            clazz = copy.deepcopy(self.clazz)
516    
517            self.assertEquals(clazz.GetNumGroups(), self.clazz.GetNumGroups())
518    
519            for i in range(clazz.GetNumGroups()):
520                self.assertEquals(clazz.GetGroup(i), self.clazz.GetGroup(i))
521    
522        def test_deepcopy_textual(self):
523            """Test deepcopy(textual Classification())"""
524            self.clazz.AppendGroup(ClassGroupSingleton("A"))
525            self.clazz.AppendGroup(ClassGroupPattern("B"))
526    
527            clazz = copy.deepcopy(self.clazz)
528    
529            self.assertEquals(clazz.GetNumGroups(), self.clazz.GetNumGroups())
530    
531            for i in range(clazz.GetNumGroups()):
532                self.assertEquals(clazz.GetGroup(i), self.clazz.GetGroup(i))
533    
534    
535        def test_iterator(self):
536            """Test Classification iteration"""
537            groups = [ClassGroupSingleton(5), ClassGroupSingleton(5),
538                      ClassGroupRange((-3, 3)), ClassGroupSingleton(-5),
539                      ClassGroupDefault()]
540    
541            for g in groups:
542                self.clazz.AppendGroup(g)
543    
544            def convert(group):
545                if isinstance(group, ClassGroupDefault):   return 0
546                if isinstance(group, ClassGroupSingleton): return 1
547                if isinstance(group, ClassGroupRange):     return 2
548    
549            list = []
550            for g in self.clazz:
551                list.append(convert(g))
552    
553            self.assertEquals(list, [0, 1, 1, 2, 1, 0])
554    
 #       self.assertEqual(c0.GetProperties(-10), "1")  
 #       self.assertEqual(c0.GetProperties(-11), default0)  
 #       self.assertEqual(c0.GetProperties(0), "2") # min <= x < max  
 #       self.assertEqual(c0.GetProperties(10), default0)  
 #       self.assertEqual(c0.GetProperties(11), default0)  
   
 #       self.assertEqual(c1.GetProperties(0), "1")  
 #       self.assertEqual(c1.GetProperties("0"), "2")  
 #       self.assertEqual(c1.GetProperties(-1), default1)  
 #       self.assertEqual(c1.GetProperties(1), default1)  
 #       self.assertRaises(TypeError, c1.GetProperties, {'monty':'python'})  
   
 #       #  
 #       # toggle field  
 #       #  
   
 #       c0.SetField(None)  
 #       self.assertEqual(c0.GetProperties(10), default0)  
 #       self.assertEqual(c0.GetProperties(11), default0)  
   
 #       c1.SetField(None)  
 #       self.assertEqual(c1.GetProperties(0), default1)  
 #       self.assertEqual(c1.GetProperties("0"), default1)  
   
 #       c0.SetField("c0")  
 #       self.assertEqual(c0.GetProperties(10), default0)  
 #       self.assertEqual(c0.GetProperties(11), default0)  
   
 #       c1.SetField("c1")  
 #       self.assertEqual(c1.GetProperties(0), "1")  
 #       self.assertEqual(c1.GetProperties("0"), "2")  
555    
556  if __name__ == "__main__":  if __name__ == "__main__":
557      unittest.main()      support.run_tests()
Legend:
Removed from v.446  
changed lines
  Added in v.2688
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26