WIP-pyshapelib-bramz/test/test_classification.py

# Copyright (c) 2002 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$

from __future__ import nested_scopes

import unittest

import support
support.initthuban()

from Thuban.Model.table import *
from Thuban.Model.classification import *
from Thuban.Model.layer import Layer

import copy


class TestClassification(unittest.TestCase):

    def test_ClassGroupProperties(self):
        """Test ClassGroupProperties"""

        props = ClassGroupProperties()
        self.assertEqual(props.GetLineColor(), Color.Black)
        self.assertEqual(props.GetLineWidth(), 1)
        self.assertEqual(props.GetFill(), Color.None)

        red = Color(1, 0, 0)
        props.SetLineColor(red)
        self.assertEqual(props.GetLineColor(), red)

        blue = Color(0, 0, 1)
        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)

    def test_ClassGroup(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
        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
        self.assertEqual(group.GetProperties(), None)

    def test_ClassGroupDefault(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)

    def test_ClassGroupRange(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(-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)

    def test_ClassGroupSingleton(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)
        

    def test_ClassIterator(self):
        """Test ClassIterator"""

        groups = [ClassGroupSingleton(5), ClassGroupSingleton(5),
                  ClassGroupRange(-3, 3), ClassGroupSingleton(-5),
                  ClassGroupDefault()]

        clazz = Classification()

        for g in groups:
            clazz.AddGroup(g)

        def convert(clazz):
            if isinstance(clazz, ClassGroupDefault):   return 0
            if isinstance(clazz, ClassGroupSingleton): return 1
            if isinstance(clazz, ClassGroupRange):     return 2

        list = []
        for g in clazz:
            list.append(convert(g))

        self.assertEquals(list, [0, 1, 1, 2, 1])

    def test_classification(self):
        """Test Classification"""

        defProps = ClassGroupProperties()
        red   = Color(1, 0, 0)
        green = Color(0, 1, 0)
        blue  = Color(0, 0, 1)

        layer = Layer("asdf", "../Data/iceland/political.dbf")

        #
        # init with no params
        #
        c = Classification()
        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())

        c.SetField("AREA")
        s = ClassGroupSingleton(5)
        c.AddGroup(s)
        self.assertEquals(c.GetGroup(5), s)
        self.assertEquals(c.GetGroup(0), c.GetDefaultGroup())

        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())

if __name__ == "__main__":
    unittest.main()
1	jonathan	369	# Copyright (c) 2002 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	jonathan	482	from __future__ import nested_scopes
17
18	jonathan	369	import unittest
19
20			import support
21			support.initthuban()
22
23	jonathan	482	from Thuban.Model.table import *
24			from Thuban.Model.classification import *
25	jonathan	395	from Thuban.Model.layer import Layer
26	jonathan	369
27	jonathan	482	import copy
28	jonathan	369
29	jonathan	482
30	jonathan	369	class TestClassification(unittest.TestCase):
31
32	jonathan	482	def test_ClassGroupProperties(self):
33			"""Test ClassGroupProperties"""
34
35			props = ClassGroupProperties()
36			self.assertEqual(props.GetLineColor(), Color.Black)
37			self.assertEqual(props.GetLineWidth(), 1)
38			self.assertEqual(props.GetFill(), Color.None)
39
40			red = Color(1, 0, 0)
41			props.SetLineColor(red)
42			self.assertEqual(props.GetLineColor(), red)
43
44			blue = Color(0, 0, 1)
45			props.SetLineColor(blue)
46			self.assertEqual(props.GetLineColor(), blue)
47
48			props.SetLineWidth(10)
49			self.assertEqual(props.GetLineWidth(), 10)
50
51			self.assertRaises(ValueError, props.SetLineWidth, -10)
52			self.assertEqual(props.GetLineWidth(), 10)
53
54			newProps1 = ClassGroupProperties()
55			newProps2 = ClassGroupProperties()
56			self.assertNotEqual(newProps1, props)
57			self.assertEqual(newProps1, newProps2)
58
59			def test_ClassGroup(self):
60			"""Test ClassGroup"""
61
62			# test constructor with no label
63			group = ClassGroup()
64			self.assertEqual(group.GetLabel(), "")
65
66			# test constructor with label
67			group = ClassGroup("hallo")
68			self.assertEqual(group.GetLabel(), "hallo")
69
70			# test SetLabel()/GetLabel()
71			group = ClassGroup("welt")
72			group.SetLabel("hallo")
73			self.assertEqual(group.GetLabel(), "hallo")
74
75			group.SetLabel("")
76			self.assertEqual(group.GetLabel(), "")
77
78			# test Matches
79			self.assertEqual(group.Matches(None), False)
80			self.assertEqual(group.Matches(1), False)
81			self.assertEqual(group.Matches("hallo"), False)
82			self.assertEqual(group.Matches([]), False)
83
84			# test GetProperties
85			self.assertEqual(group.GetProperties(), None)
86
87			def test_ClassGroupDefault(self):
88			"""Test ClassGroupDefault"""
89
90			defProps = ClassGroupProperties()
91
92			newProps = ClassGroupProperties()
93			newProps.SetLineColor(Color(.25, .5, .75))
94			newProps.SetLineWidth(5)
95			newProps.SetFill(Color(.12, .24, .36))
96
97			# test constructor
98
99			group = ClassGroupDefault(newProps)
100			self.assertEqual(group.GetProperties(), newProps)
101
102			group = ClassGroupDefault(newProps, "hallo")
103			self.assertEqual(group.GetProperties(), newProps)
104			self.assertEqual(group.GetLabel(), "hallo")
105
106			# test empty constructor
107			group = ClassGroupDefault()
108			props = group.GetProperties()
109
110			self.assertEqual(group.GetLabel(), "")
111			self.assertEqual(defProps, props)
112
113			# test Matches()
114			self.assertEqual(group.Matches(None), True)
115			self.assertEqual(group.Matches(1), True)
116			self.assertEqual(group.Matches("hallo"), True)
117			self.assertEqual(group.Matches([]), True)
118
119			# test SetProperties()/GetProperties()
120			group.SetProperties(newProps)
121			self.assertEqual(group.GetProperties(), newProps)
122
123			# test copy
124			groupCopy = copy.copy(group)
125			self.assertEqual(group, groupCopy)
126
127			def test_ClassGroupRange(self):
128			"""Test ClassGroupRange"""
129
130			defProps = ClassGroupProperties()
131			newProps = ClassGroupProperties()
132			newProps.SetLineColor(Color(.25, .5, .75))
133			newProps.SetLineWidth(5)
134			newProps.SetFill(Color(.12, .24, .36))
135
136			# test empty constructor
137			group = ClassGroupRange()
138
139			self.assertEqual(group.GetMin(), 0)
140			self.assertEqual(group.GetMax(), 1)
141			self.assertEqual(group.GetProperties(), defProps)
142			self.assertEqual(group.GetLabel(), "")
143
144			# test SetMax()
145			self.assertRaises(ValueError, group.SetMax, 0)
146			self.assertRaises(ValueError, group.SetMax, -1)
147			self.assertEquals(group.GetMax(), 1)
148			group.SetMax(2)
149			self.assertEquals(group.GetMax(), 2)
150
151			# test SetMin()
152			self.assertRaises(ValueError, group.SetMin, 2)
153			self.assertRaises(ValueError, group.SetMin, 3)
154			self.assertEquals(group.GetMin(), 0)
155			group.SetMin(-5)
156			self.assertEquals(group.GetMin(), -5)
157
158			# test SetProperties()/GetProperties()
159			group.SetProperties(newProps)
160			self.assertEqual(group.GetProperties(), newProps)
161
162			# test SetRange()
163			self.assertRaises(ValueError, group.SetRange, 1, 0)
164			group.SetRange(-5, 5)
165			self.assertEqual(group.GetRange(), (-5, 5))
166
167			# test Matches()
168			self.assertEqual(group.Matches(-6), False)
169			self.assertEqual(group.Matches(-5), True)
170			self.assertEqual(group.Matches(0), True)
171			self.assertEqual(group.Matches(4), True)
172			self.assertEqual(group.Matches(5), False)
173
174			# test copy
175			groupCopy = copy.copy(group)
176			self.assertEqual(group, groupCopy)
177
178			def test_ClassGroupSingleton(self):
179			"""Test ClassGroupSingleton"""
180
181			defProps = ClassGroupProperties()
182			newProps = ClassGroupProperties()
183			newProps.SetLineColor(Color(.25, .5, .75))
184			newProps.SetLineWidth(5)
185			newProps.SetFill(Color(.12, .24, .36))
186
187			# test empty constructor
188			group = ClassGroupSingleton()
189
190			self.assertEqual(group.GetValue(), 0)
191			self.assertEqual(group.GetProperties(), defProps)
192			self.assertEqual(group.GetLabel(), "")
193
194			# test SetProperties()/GetProperties()
195			group.SetProperties(newProps)
196			self.assertEqual(group.GetProperties(), newProps)
197
198			# test SetValue()
199			group.SetValue(5)
200			self.assertEqual(group.GetValue(), 5)
201
202			# test Matches()
203			self.assertEqual(group.Matches(0), False)
204			self.assertEqual(group.Matches(5), True)
205
206			group.SetValue("5")
207			self.assertNotEqual(group.GetValue(), 5)
208
209			# test Matches()
210			self.assertEqual(group.Matches(5), False)
211			self.assertEqual(group.Matches("5"), True)
212
213			group.SetValue("hallo")
214			self.assertEqual(group.GetValue(), "hallo")
215
216			# test Matches()
217			self.assertEqual(group.Matches("HALLO"), False)
218			self.assertEqual(group.Matches("hallo"), True)
219
220			# test copy
221			groupCopy = copy.copy(group)
222			self.assertEqual(group, groupCopy)
223
224
225			def test_ClassIterator(self):
226			"""Test ClassIterator"""
227
228			groups = [ClassGroupSingleton(5), ClassGroupSingleton(5),
229			ClassGroupRange(-3, 3), ClassGroupSingleton(-5),
230			ClassGroupDefault()]
231
232			clazz = Classification()
233
234			for g in groups:
235			clazz.AddGroup(g)
236
237			def convert(clazz):
238			if isinstance(clazz, ClassGroupDefault): return 0
239			if isinstance(clazz, ClassGroupSingleton): return 1
240			if isinstance(clazz, ClassGroupRange): return 2
241
242			list = []
243			for g in clazz:
244			list.append(convert(g))
245
246			self.assertEquals(list, [0, 1, 1, 2, 1])
247
248	jonathan	369	def test_classification(self):
249			"""Test Classification"""
250
251	jonathan	482	defProps = ClassGroupProperties()
252			red = Color(1, 0, 0)
253			green = Color(0, 1, 0)
254			blue = Color(0, 0, 1)
255
256	jonathan	494	layer = Layer("asdf", "../Data/iceland/political.dbf")
257	jonathan	395
258	jonathan	369	#
259			# init with no params
260			#
261	jonathan	482	c = Classification()
262	jonathan	446	self.assertEqual(c.GetField(), None)
263	jonathan	482	self.assertEqual(c.GetFieldType(), None)
264			self.assertEqual(c.GetGroup(-1), c.GetDefaultGroup())
265	jonathan	369
266	jonathan	482	c.SetDefaultLineColor(red)
267			self.assertEqual(c.GetDefaultLineColor(), red)
268			self.assertEqual(c.GetDefaultFill(), Color.None)
269	jonathan	369
270	jonathan	482	c.SetDefaultFill(green)
271			self.assertEqual(c.GetDefaultFill(), green)
272			self.assertEqual(c.GetDefaultLineColor(), red)
273	jonathan	369
274	jonathan	482	c.SetField("hallo")
275			self.assertEqual(c.GetField(), "hallo")
276	jonathan	369
277	jonathan	482	c.SetFieldType(FIELDTYPE_STRING)
278			self.assertEqual(c.GetFieldType(), FIELDTYPE_STRING)
279	jonathan	369
280	jonathan	494	# should raise an exception because 'hallo' doesn't
281			# exist in the table
282			self.assertRaises(ValueError, c.SetLayer, layer)
283
284			c.SetField("AREA")
285	jonathan	482	c.SetLayer(layer)
286			self.assertEqual(c.GetLayer(), layer)
287	jonathan	494	self.assertEqual(c.GetField(), "AREA")
288			self.assertEqual(c.GetFieldType(), FIELDTYPE_DOUBLE)
289	jonathan	369
290	jonathan	482	c.SetField(None)
291	jonathan	494	self.assertEquals(c.GetFieldType(), None)
292	jonathan	482	self.assertEquals(c.GetGroup(5), c.GetDefaultGroup())
293	jonathan	369
294	jonathan	494	c.SetField("AREA")
295	jonathan	482	s = ClassGroupSingleton(5)
296			c.AddGroup(s)
297			self.assertEquals(c.GetGroup(5), s)
298			self.assertEquals(c.GetGroup(0), c.GetDefaultGroup())
299	jonathan	369
300	jonathan	482	r = ClassGroupRange(-10, 10)
301			c.AddGroup(r)
302			self.assertEquals(c.GetGroup(-11), c.GetDefaultGroup())
303			self.assertEquals(c.GetGroup(-10), r)
304			self.assertEquals(c.GetGroup(9), r)
305			self.assertEquals(c.GetGroup(5), s)
306			self.assertEquals(c.GetGroup(10), c.GetDefaultGroup())
307	jonathan	369
308			if __name__ == "__main__":
309			unittest.main()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision