/[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 598 by bh, Thu Apr 3 11:37:10 2003 UTC revision 1910 by bh, Fri Oct 31 18:16:46 2003 UTC
# 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        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 TestClassification(unittest.TestCase, support.SubscriberMixin):
                   ClassGroupRange(-3, 3), ClassGroupSingleton(-5),  
                   ClassGroupDefault()]  
250    
251          clazz = Classification()      """Test cases for Classification"""
252    
253          for g in groups:      def setUp(self):
254              clazz.AddGroup(g)          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          def convert(clazz):          s = ClassGroupSingleton(5)
326              if isinstance(clazz, ClassGroupDefault):   return 0          self.clazz.AppendGroup(s)
327              if isinstance(clazz, ClassGroupSingleton): return 1          self.check_messages([(CLASS_CHANGED,)])
328              if isinstance(clazz, ClassGroupRange):     return 2          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          list = []          self.assertEquals(clazz.GetNumGroups(), self.clazz.GetNumGroups())
         for g in clazz:  
             list.append(convert(g))  
435    
436          self.assertEquals(list, [0, 1, 1, 2, 1])          for i in range(clazz.GetNumGroups()):
437                self.assertEquals(clazz.GetGroup(i), self.clazz.GetGroup(i))
438    
     def test_classification(self):  
         """Test Classification"""  
439    
440          defProps = ClassGroupProperties()      def test_iterator(self):
441          red   = Color(1, 0, 0)          """Test Classification iteration"""
442          green = Color(0, 1, 0)          groups = [ClassGroupSingleton(5), ClassGroupSingleton(5),
443          blue  = Color(0, 0, 1)                    ClassGroupRange((-3, 3)), ClassGroupSingleton(-5),
444                      ClassGroupDefault()]
445    
446          layer = Layer("asdf", "../Data/iceland/political.dbf")          for g in groups:
447                self.clazz.AppendGroup(g)
448    
449          #          def convert(group):
450          # init with no params              if isinstance(group, ClassGroupDefault):   return 0
451          #              if isinstance(group, ClassGroupSingleton): return 1
452          c = Classification()              if isinstance(group, ClassGroupRange):     return 2
         self.assertEqual(c.GetField(), None)  
         self.assertEqual(c.GetFieldType(), None)  
         self.assertEqual(c.GetGroup(-1), c.GetDefaultGroup())  
   
         c.SetDefaultLineColor(red)  
         self.assertEqual(c.GetDefaultLineColor(), red)  
         self.assertEqual(c.GetDefaultFill(), Color.None)  
   
         c.SetDefaultFill(green)  
         self.assertEqual(c.GetDefaultFill(), green)  
         self.assertEqual(c.GetDefaultLineColor(), red)  
   
         c.SetField("hallo")  
         self.assertEqual(c.GetField(), "hallo")  
   
         c.SetFieldType(FIELDTYPE_STRING)  
         self.assertEqual(c.GetFieldType(), FIELDTYPE_STRING)  
   
         # should raise an exception because 'hallo' doesn't  
         # exist in the table  
         self.assertRaises(ValueError, c.SetLayer, layer)  
           
         c.SetField("AREA")  
         c.SetLayer(layer)  
         self.assertEqual(c.GetLayer(), layer)  
         self.assertEqual(c.GetField(), "AREA")  
         self.assertEqual(c.GetFieldType(), FIELDTYPE_DOUBLE)  
   
         c.SetField(None)  
         self.assertEquals(c.GetFieldType(), None)  
         self.assertEquals(c.GetGroup(5), c.GetDefaultGroup())  
453    
454          c.SetField("AREA")          list = []
455          s = ClassGroupSingleton(5)          for g in self.clazz:
456          c.AddGroup(s)              list.append(convert(g))
457          self.assertEquals(c.GetGroup(5), s)  
458          self.assertEquals(c.GetGroup(0), c.GetDefaultGroup())          self.assertEquals(list, [0, 1, 1, 2, 1, 0])
   
         r = ClassGroupRange(-10, 10)  
         c.AddGroup(r)  
         self.assertEquals(c.GetGroup(-11), c.GetDefaultGroup())  
         self.assertEquals(c.GetGroup(-10), r)  
         self.assertEquals(c.GetGroup(9), r)  
         self.assertEquals(c.GetGroup(5), s)  
         self.assertEquals(c.GetGroup(10), c.GetDefaultGroup())  
459    
         layer.Destroy()  
460    
461  if __name__ == "__main__":  if __name__ == "__main__":
462      support.run_tests()      support.run_tests()
Legend:
Removed from v.598  
changed lines
  Added in v.1910
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26