WIP-pyshapelib-bramz/test/test_classification.py

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

import os
from Thuban.Model.color import Color, Transparent, Black
from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_STRING, FIELDTYPE_DOUBLE
from Thuban.Model.classification import \
    Classification, ClassGroup, \
    ClassGroupDefault, ClassGroupSingleton, ClassGroupRange,\
    ClassGroupProperties

from Thuban.Model.session import Session
from Thuban.Model.layer import Layer

import copy


class TestClassification(unittest.TestCase):

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

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

        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
        # Matches() is a virtual function...can't test it here
        #
        #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...also a virtual function
        #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.AppendGroup(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, 0])

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

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

        session = Session("Test session")
        filename = os.path.join("..", "Data", "iceland", "political.dbf")
        layer = Layer("asdf", session.OpenShapefile(filename))

        #
        # init with no params
        #
        c = Classification()
        self.assertEqual(c.GetField(), None)
        self.assertEqual(c.GetFieldType(), None)
        self.assertEqual(c.FindGroup(-1), c.GetDefaultGroup())

        c.SetDefaultLineColor(red)
        self.assertEqual(c.GetDefaultLineColor(), red)
        self.assertEqual(c.GetDefaultFill(), Transparent)

        c.SetDefaultFill(green)
        self.assertEqual(c.GetDefaultFill(), green)
        self.assertEqual(c.GetDefaultLineColor(), red)

        c.SetFieldInfo("hallo", FIELDTYPE_STRING)
        self.assertEqual(c.GetField(), "hallo")
        self.assertEqual(c.GetFieldType(), FIELDTYPE_STRING)

        # should raise an exception because 'hallo' doesn't 
        # exist in the table
        self.assertRaises(ValueError, c._set_layer, layer)
        
        c.SetFieldInfo("AREA", None)
        layer.SetClassification(c)
        self.assertEqual(c.GetLayer(), layer)
        self.assertEqual(c.GetField(), "AREA")
        self.assertEqual(c.GetFieldType(), FIELDTYPE_DOUBLE)

        c.SetFieldInfo(None, None)
        self.assertEquals(c.GetFieldType(), None)
        self.assertEquals(c.FindGroup(5), c.GetDefaultGroup())

        c.SetFieldInfo("AREA", None)
        s = ClassGroupSingleton(5)
        c.AppendGroup(s)
        self.assertEquals(c.FindGroup(5), s)
        self.assertEquals(c.FindGroup(0), c.GetDefaultGroup())

        r = ClassGroupRange(-10, 10)
        c.AppendGroup(r)
        self.assertEquals(c.FindGroup(-11), c.GetDefaultGroup())
        self.assertEquals(c.FindGroup(-10), r)
        self.assertEquals(c.FindGroup(9), r)
        self.assertEquals(c.FindGroup(5), s)
        self.assertEquals(c.FindGroup(10), c.GetDefaultGroup())

        clazz = copy.deepcopy(c)

        self.assertEquals(clazz.GetNumGroups(), c.GetNumGroups())

        for i in range(clazz.GetNumGroups()):
            self.assertEquals(clazz.GetGroup(i), c.GetGroup(i))

        layer.Destroy()

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