/[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

trunk/thuban/test/test_classification.py revision 494 by jonathan, Mon Mar 10 10:45:33 2003 UTC branches/WIP-pyshapelib-bramz/test/test_classification.py revision 2734 by bramz, Thu Mar 1 12:42:59 2007 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 13  __version__ = "$Revision$" Line 13  __version__ = "$Revision$"
13  # $Source$  # $Source$
14  # $Id$  # $Id$
15    
 from __future__ import nested_scopes  
   
16  import unittest  import unittest
17    
18  import support  import support
19  support.initthuban()  support.initthuban()
20    
 from Thuban.Model.table import *  
 from Thuban.Model.classification import *  
 from Thuban.Model.layer import Layer  
   
21  import copy  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        ClassGroupPattern, ClassGroupProperties
28    from Thuban.Model.messages import CLASS_CHANGED
29    
30    from Thuban.Model.range import Range
31    
32    
33    
34  class TestClassification(unittest.TestCase):  # 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      def test_ClassGroupProperties(self):  
40    class TestClassGroupProperties(unittest.TestCase):
41    
42        def test(self):
43          """Test ClassGroupProperties"""          """Test ClassGroupProperties"""
44    
45          props = ClassGroupProperties()          props = ClassGroupProperties()
46          self.assertEqual(props.GetLineColor(), Color.Black)          self.assertEqual(props.GetLineColor(), Black)
47          self.assertEqual(props.GetLineWidth(), 1)          self.assertEqual(props.GetLineWidth(), 1)
48          self.assertEqual(props.GetFill(), Color.None)          self.assertEqual(props.GetFill(), Transparent)
49    
         red = Color(1, 0, 0)  
50          props.SetLineColor(red)          props.SetLineColor(red)
51          self.assertEqual(props.GetLineColor(), red)          self.assertEqual(props.GetLineColor(), red)
52    
         blue = Color(0, 0, 1)  
53          props.SetLineColor(blue)          props.SetLineColor(blue)
54          self.assertEqual(props.GetLineColor(), blue)          self.assertEqual(props.GetLineColor(), blue)
55    
# Line 56  class TestClassification(unittest.TestCa Line 64  class TestClassification(unittest.TestCa
64          self.assertNotEqual(newProps1, props)          self.assertNotEqual(newProps1, props)
65          self.assertEqual(newProps1, newProps2)          self.assertEqual(newProps1, newProps2)
66    
67      def test_ClassGroup(self):  
68    class TestClassGroup(unittest.TestCase):
69    
70        def test(self):
71          """Test ClassGroup"""          """Test ClassGroup"""
72    
73          # test constructor with no label          # test constructor with no label
# Line 76  class TestClassification(unittest.TestCa Line 87  class TestClassification(unittest.TestCa
87          self.assertEqual(group.GetLabel(), "")          self.assertEqual(group.GetLabel(), "")
88    
89          # test Matches          # test Matches
90          self.assertEqual(group.Matches(None), False)          # Matches() is a virtual function...can't test it here
91          self.assertEqual(group.Matches(1), False)          #
92          self.assertEqual(group.Matches("hallo"), False)          #self.assertEqual(group.Matches(None), False)
93          self.assertEqual(group.Matches([]), False)          #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    
         # test GetProperties  
         self.assertEqual(group.GetProperties(), None)  
100    
101      def test_ClassGroupDefault(self):  class TestClassGroupDefault(unittest.TestCase):
102    
103        def test(self):
104          """Test ClassGroupDefault"""          """Test ClassGroupDefault"""
105    
106          defProps = ClassGroupProperties()          defProps = ClassGroupProperties()
# Line 124  class TestClassification(unittest.TestCa Line 140  class TestClassification(unittest.TestCa
140          groupCopy = copy.copy(group)          groupCopy = copy.copy(group)
141          self.assertEqual(group, groupCopy)          self.assertEqual(group, groupCopy)
142    
143      def test_ClassGroupRange(self):  
144    class TestClassGroupRange(unittest.TestCase):
145    
146        def test(self):
147          """Test ClassGroupRange"""          """Test ClassGroupRange"""
148    
149          defProps = ClassGroupProperties()          defProps = ClassGroupProperties()
# Line 140  class TestClassification(unittest.TestCa Line 159  class TestClassification(unittest.TestCa
159          self.assertEqual(group.GetMax(), 1)          self.assertEqual(group.GetMax(), 1)
160          self.assertEqual(group.GetProperties(), defProps)          self.assertEqual(group.GetProperties(), defProps)
161          self.assertEqual(group.GetLabel(), "")          self.assertEqual(group.GetLabel(), "")
162            
163          # test SetMax()          # test SetMax()
164          self.assertRaises(ValueError, group.SetMax, 0)          self.assertRaises(ValueError, group.SetMax, 0)
165          self.assertRaises(ValueError, group.SetMax, -1)          self.assertRaises(ValueError, group.SetMax, -1)
# Line 160  class TestClassification(unittest.TestCa Line 179  class TestClassification(unittest.TestCa
179          self.assertEqual(group.GetProperties(), newProps)          self.assertEqual(group.GetProperties(), newProps)
180    
181          # test SetRange()          # test SetRange()
182          self.assertRaises(ValueError, group.SetRange, 1, 0)          self.assertRaises(ValueError, group.SetRange, (1, 0))
183          group.SetRange(-5, 5)          group.SetRange(Range("]-oo;6]"))
184          self.assertEqual(group.GetRange(), (-5, 5))          self.assertEqual(group.GetRange(), "]-oo;6]")
185            group.SetRange((-5, 5))
186            self.assertEqual(group.GetRange(), "[-5;5[")
187    
188          # test Matches()          # test Matches()
189          self.assertEqual(group.Matches(-6), False)          self.assertEqual(group.Matches(-6), False)
# Line 175  class TestClassification(unittest.TestCa Line 196  class TestClassification(unittest.TestCa
196          groupCopy = copy.copy(group)          groupCopy = copy.copy(group)
197          self.assertEqual(group, groupCopy)          self.assertEqual(group, groupCopy)
198    
199      def test_ClassGroupSingleton(self):  
200    class TestClassGroupSingleton(unittest.TestCase):
201    
202        def test(self):
203          """Test ClassGroupSingleton"""          """Test ClassGroupSingleton"""
204    
205          defProps = ClassGroupProperties()          defProps = ClassGroupProperties()
# Line 220  class TestClassification(unittest.TestCa Line 244  class TestClassification(unittest.TestCa
244          # test copy          # test copy
245          groupCopy = copy.copy(group)          groupCopy = copy.copy(group)
246          self.assertEqual(group, groupCopy)          self.assertEqual(group, groupCopy)
           
247    
     def test_ClassIterator(self):  
         """Test ClassIterator"""  
248    
249          groups = [ClassGroupSingleton(5), ClassGroupSingleton(5),  class TestClassGroupPattern(unittest.TestCase):
                   ClassGroupRange(-3, 3), ClassGroupSingleton(-5),  
                   ClassGroupDefault()]  
250    
251          clazz = Classification()      def test(self):
252            """Test ClassGroupPattern"""
253    
254          for g in groups:          defProps = ClassGroupProperties()
255              clazz.AddGroup(g)          newProps = ClassGroupProperties()
256            newProps.SetLineColor(Color(.25, .5, .75))
257            newProps.SetLineWidth(5)
258            newProps.SetFill(Color(.12, .24, .36))
259    
260          def convert(clazz):          # test empty constructor
261              if isinstance(clazz, ClassGroupDefault):   return 0          group = ClassGroupPattern()
             if isinstance(clazz, ClassGroupSingleton): return 1  
             if isinstance(clazz, ClassGroupRange):     return 2  
262    
263          list = []          self.assertEqual(group.GetPattern(), "")
264          for g in clazz:          self.assertEqual(group.GetProperties(), defProps)
265              list.append(convert(g))          self.assertEqual(group.GetLabel(), "")
266    
267          self.assertEquals(list, [0, 1, 1, 2, 1])          # test SetProperties()/GetProperties()
268            group.SetProperties(newProps)
269            self.assertEqual(group.GetProperties(), newProps)
270    
271      def test_classification(self):          # test SetPattern()
272          """Test Classification"""          group.SetPattern("A")
273            self.assertEqual(group.GetPattern(), "A")
274    
275          defProps = ClassGroupProperties()          # test Matches()
276          red   = Color(1, 0, 0)          self.assertEqual(group.Matches("CBA"), False)
277          green = Color(0, 1, 0)          self.assertEqual(group.Matches("ABC"), True)
         blue  = Color(0, 0, 1)  
278    
279          layer = Layer("asdf", "../Data/iceland/political.dbf")          group.SetPattern("a")
280            self.assertNotEqual(group.GetPattern(), "A")
281    
282          #          # test Matches()
283          # init with no params          self.assertEqual(group.Matches("Abc"), False)
284          #          self.assertEqual(group.Matches("aBC"), True)
285          c = Classification()  
286          self.assertEqual(c.GetField(), None)          group.SetPattern("hallo")
287          self.assertEqual(c.GetFieldType(), None)          self.assertEqual(group.GetPattern(), "hallo")
288          self.assertEqual(c.GetGroup(-1), c.GetDefaultGroup())  
289            # test Matches()
290          c.SetDefaultLineColor(red)          self.assertEqual(group.Matches("HALLO"), False)
291          self.assertEqual(c.GetDefaultLineColor(), red)          self.assertEqual(group.Matches("hallo"), True)
292          self.assertEqual(c.GetDefaultFill(), Color.None)  
293            # test copy
294          c.SetDefaultFill(green)          groupCopy = copy.copy(group)
295          self.assertEqual(c.GetDefaultFill(), green)          self.assertEqual(group, groupCopy)
296          self.assertEqual(c.GetDefaultLineColor(), red)  
297    
298          c.SetField("hallo")  class TestClassification(unittest.TestCase, support.SubscriberMixin):
299          self.assertEqual(c.GetField(), "hallo")  
300        """Test cases for Classification"""
301          c.SetFieldType(FIELDTYPE_STRING)  
302          self.assertEqual(c.GetFieldType(), FIELDTYPE_STRING)      def setUp(self):
303            self.clazz = Classification()
304          # should raise an exception because 'hallo' doesn't          self.clazz.Subscribe(CLASS_CHANGED, self.subscribe_with_params,
305          # exist in the table                               CLASS_CHANGED)
306          self.assertRaises(ValueError, c.SetLayer, layer)          self.clear_messages()
307            
308          c.SetField("AREA")      def tearDown(self):
309          c.SetLayer(layer)          self.clear_messages()
310          self.assertEqual(c.GetLayer(), layer)          self.clazz.Destroy()
311          self.assertEqual(c.GetField(), "AREA")          del self.clazz
312          self.assertEqual(c.GetFieldType(), FIELDTYPE_DOUBLE)  
313        def test_defaults(self):
314          c.SetField(None)          """Test Classification default settings"""
315          self.assertEquals(c.GetFieldType(), None)          self.assertEqual(self.clazz.FindGroup(-1),
316          self.assertEquals(c.GetGroup(5), c.GetDefaultGroup())                           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    
         c.SetField("AREA")  
374          s = ClassGroupSingleton(5)          s = ClassGroupSingleton(5)
375          c.AddGroup(s)          self.clazz.AppendGroup(s)
376          self.assertEquals(c.GetGroup(5), s)          self.check_messages([(CLASS_CHANGED,)])
377          self.assertEquals(c.GetGroup(0), c.GetDefaultGroup())          self.assertEquals(self.clazz.FindGroup(5), s)
378            self.assertEquals(self.clazz.FindGroup(0),
379          r = ClassGroupRange(-10, 10)                            self.clazz.GetDefaultGroup())
380          c.AddGroup(r)  
381          self.assertEquals(c.GetGroup(-11), c.GetDefaultGroup())      def test_add_range(self):
382          self.assertEquals(c.GetGroup(-10), r)          """Test Classification.AppendGroup(ClassGroupRange())"""
383          self.assertEquals(c.GetGroup(9), r)          self.assertEquals(self.clazz.FindGroup(0),
384          self.assertEquals(c.GetGroup(5), s)                            self.clazz.GetDefaultGroup())
385          self.assertEquals(c.GetGroup(10), c.GetDefaultGroup())  
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    
555    
556  if __name__ == "__main__":  if __name__ == "__main__":
557      unittest.main()      support.run_tests()
Legend:
Removed from v.494  
changed lines
  Added in v.2734
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26