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
from Thuban.Model.range import Range

import copy


class TestClassGroupProperties(unittest.TestCase):

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


class TestClassGroup(unittest.TestCase):

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


class TestClassGroupDefault(unittest.TestCase):

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


class TestClassGroupRange(unittest.TestCase):

    def test(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(Range("]-oo;6]"))
        self.assertEqual(group.GetRange(), "]-oo;6]")
        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)


class TestClassGroupSingleton(unittest.TestCase):

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


class TestClassIterator(unittest.TestCase):

    def test(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])


class TestClassification(unittest.TestCase):

    def test(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.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)

        layer.SetClassification(c)

        self.assertEquals(c.FindGroup(5), c.GetDefaultGroup())

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

        session.Destroy()
        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	1356	from Thuban.Model.range import Range
34	jonathan	369
35	jonathan	482	import copy
36	jonathan	369
37	jonathan	482
38	bh	1898	class TestClassGroupProperties(unittest.TestCase):
39	jonathan	369
40	bh	1898	def test(self):
41	jonathan	482	"""Test ClassGroupProperties"""
42
43			props = ClassGroupProperties()
44	jonathan	1346	self.assertEqual(props.GetLineColor(), Black)
45	jonathan	482	self.assertEqual(props.GetLineWidth(), 1)
46	jonathan	1346	self.assertEqual(props.GetFill(), Transparent)
47	jonathan	482
48			red = Color(1, 0, 0)
49			props.SetLineColor(red)
50			self.assertEqual(props.GetLineColor(), red)
51
52			blue = Color(0, 0, 1)
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	bh	1898
68			class TestClassGroup(unittest.TestCase):
69
70			def test(self):
71	jonathan	482	"""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	jonathan	610	# Matches() is a virtual function...can't test it here
91			#
92			#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	jonathan	482
97	jonathan	610	# test GetProperties...also a virtual function
98			#self.assertEqual(group.GetProperties(), None)
99	jonathan	482
100	bh	1898
101			class TestClassGroupDefault(unittest.TestCase):
102
103			def test(self):
104	jonathan	482	"""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	bh	1898
144			class TestClassGroupRange(unittest.TestCase):
145
146			def test(self):
147	jonathan	482	"""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	bh	1898
163	jonathan	482	# 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	jonathan	1356	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	jonathan	884	self.assertEqual(group.GetRange(), "[-5;5[")
187	jonathan	482
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	bh	1898
200			class TestClassGroupSingleton(unittest.TestCase):
201
202			def test(self):
203	jonathan	482	"""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	bh	1898
249			class TestClassIterator(unittest.TestCase):
250
251			def test(self):
252	jonathan	482	"""Test ClassIterator"""
253
254			groups = [ClassGroupSingleton(5), ClassGroupSingleton(5),
255	jonathan	1356	ClassGroupRange((-3, 3)), ClassGroupSingleton(-5),
256	jonathan	482	ClassGroupDefault()]
257
258			clazz = Classification()
259
260			for g in groups:
261	jonathan	618	clazz.AppendGroup(g)
262	jonathan	482
263			def convert(clazz):
264			if isinstance(clazz, ClassGroupDefault): return 0
265			if isinstance(clazz, ClassGroupSingleton): return 1
266			if isinstance(clazz, ClassGroupRange): return 2
267
268			list = []
269			for g in clazz:
270			list.append(convert(g))
271
272	jonathan	618	self.assertEquals(list, [0, 1, 1, 2, 1, 0])
273	jonathan	482
274	bh	1898
275			class TestClassification(unittest.TestCase):
276
277			def test(self):
278	jonathan	369	"""Test Classification"""
279
280	jonathan	482	defProps = ClassGroupProperties()
281			red = Color(1, 0, 0)
282			green = Color(0, 1, 0)
283			blue = Color(0, 0, 1)
284
285	bh	723	session = Session("Test session")
286			filename = os.path.join("..", "Data", "iceland", "political.dbf")
287			layer = Layer("asdf", session.OpenShapefile(filename))
288	jonathan	395
289	jonathan	369	#
290			# init with no params
291			#
292	jonathan	482	c = Classification()
293	jonathan	618	self.assertEqual(c.FindGroup(-1), c.GetDefaultGroup())
294	jonathan	369
295	jonathan	482	c.SetDefaultLineColor(red)
296			self.assertEqual(c.GetDefaultLineColor(), red)
297	jonathan	1346	self.assertEqual(c.GetDefaultFill(), Transparent)
298	jonathan	369
299	jonathan	482	c.SetDefaultFill(green)
300			self.assertEqual(c.GetDefaultFill(), green)
301			self.assertEqual(c.GetDefaultLineColor(), red)
302	jonathan	369
303	jonathan	1346	layer.SetClassification(c)
304	jonathan	369
305	jonathan	618	self.assertEquals(c.FindGroup(5), c.GetDefaultGroup())
306	jonathan	369
307	jonathan	482	s = ClassGroupSingleton(5)
308	jonathan	618	c.AppendGroup(s)
309			self.assertEquals(c.FindGroup(5), s)
310			self.assertEquals(c.FindGroup(0), c.GetDefaultGroup())
311	jonathan	369
312	jonathan	1356	r = ClassGroupRange((-10, 10))
313	jonathan	618	c.AppendGroup(r)
314			self.assertEquals(c.FindGroup(-11), c.GetDefaultGroup())
315			self.assertEquals(c.FindGroup(-10), r)
316			self.assertEquals(c.FindGroup(9), r)
317			self.assertEquals(c.FindGroup(5), s)
318			self.assertEquals(c.FindGroup(10), c.GetDefaultGroup())
319	jonathan	369
320	jonathan	656	clazz = copy.deepcopy(c)
321
322			self.assertEquals(clazz.GetNumGroups(), c.GetNumGroups())
323
324			for i in range(clazz.GetNumGroups()):
325			self.assertEquals(clazz.GetGroup(i), c.GetGroup(i))
326
327	jonathan	1437	session.Destroy()
328	bh	598	layer.Destroy()
329
330	bh	1898
331	jonathan	369	if __name__ == "__main__":
332	bh	598	support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision