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$

import unittest

import support
support.initthuban()

import copy

from Thuban.Model.color import Color, Transparent, Black
from Thuban.Model.classification import \
    Classification, ClassGroup, \
    ClassGroupDefault, ClassGroupSingleton, ClassGroupRange,\
    ClassGroupPattern, ClassGroupProperties
from Thuban.Model.messages import CLASS_CHANGED

from Thuban.Model.range import Range


# A few colors for use by the test cases
red = Color(1, 0, 0)
green = Color(0, 1, 0)
blue = Color(0, 0, 1)


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)

        props.SetLineColor(red)
        self.assertEqual(props.GetLineColor(), red)

        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 TestClassGroupPattern(unittest.TestCase):

    def test(self):
        """Test ClassGroupPattern"""

        defProps = ClassGroupProperties()
        newProps = ClassGroupProperties()
        newProps.SetLineColor(Color(.25, .5, .75))
        newProps.SetLineWidth(5)
        newProps.SetFill(Color(.12, .24, .36))

        # test empty constructor
        group = ClassGroupPattern()

        self.assertEqual(group.GetPattern(), "")
        self.assertEqual(group.GetProperties(), defProps)
        self.assertEqual(group.GetLabel(), "")

        # test SetProperties()/GetProperties()
        group.SetProperties(newProps)
        self.assertEqual(group.GetProperties(), newProps)

        # test SetPattern()
        group.SetPattern("A")
        self.assertEqual(group.GetPattern(), "A")

        # test Matches()
        self.assertEqual(group.Matches("CBA"), False)
        self.assertEqual(group.Matches("ABC"), True)

        group.SetPattern("a")
        self.assertNotEqual(group.GetPattern(), "A")

        # test Matches()
        self.assertEqual(group.Matches("Abc"), False)
        self.assertEqual(group.Matches("aBC"), True)

        group.SetPattern("hallo")
        self.assertEqual(group.GetPattern(), "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 TestClassification(unittest.TestCase, support.SubscriberMixin):

    """Test cases for Classification"""

    def setUp(self):
        self.clazz = Classification()
        self.clazz.Subscribe(CLASS_CHANGED, self.subscribe_with_params,
                             CLASS_CHANGED)
        self.clear_messages()

    def tearDown(self):
        self.clear_messages()
        self.clazz.Destroy()
        del self.clazz

    def test_defaults(self):
        """Test Classification default settings"""
        self.assertEqual(self.clazz.FindGroup(-1),
                         self.clazz.GetDefaultGroup())
        self.assertEqual(self.clazz.GetDefaultLineColor(), Black)
        self.assertEqual(self.clazz.GetDefaultFill(), Transparent)
        self.assertEqual(self.clazz.GetDefaultLineWidth(), 1)

        # The default group is not counted, hence 0 groups
        self.assertEqual(self.clazz.GetNumGroups(), 0)

        # No messages should have been sent so far
        self.check_messages([])

    def test_set_default_properties(self):
        """Test Classification.SetDefaultLineColor and SetDefaultFill"""
        # No messages so far
        self.check_messages([])

        # Change the default line color
        self.clazz.SetDefaultLineColor(red)
        self.assertEqual(self.clazz.GetDefaultLineColor(), red)
        self.assertEqual(self.clazz.GetDefaultFill(), Transparent)
        self.assertEqual(self.clazz.GetDefaultLineWidth(), 1)

        self.check_messages([(CLASS_CHANGED,)])
        self.clear_messages()

        self.clazz.SetDefaultFill(green)
        self.assertEqual(self.clazz.GetDefaultFill(), green)
        self.assertEqual(self.clazz.GetDefaultLineColor(), red)
        self.assertEqual(self.clazz.GetDefaultLineWidth(), 1)
        self.check_messages([(CLASS_CHANGED,)])

        self.check_messages([(CLASS_CHANGED,)])
        self.clear_messages()

        self.clazz.SetDefaultLineWidth(10)
        self.assertEqual(self.clazz.GetDefaultFill(), green)
        self.assertEqual(self.clazz.GetDefaultLineColor(), red)
        self.assertEqual(self.clazz.GetDefaultLineWidth(), 10)
        self.check_messages([(CLASS_CHANGED,)])

    def test_set_default_group(self):
        """Test Classification.SetDefaultGroup()"""
        prop = ClassGroupProperties()
        prop.SetLineColor(blue)
        prop.SetLineWidth(5)
        prop.SetFill(red)

        self.clazz.SetDefaultGroup(ClassGroupDefault(prop))
        self.assertEqual(self.clazz.GetDefaultFill(), red)
        self.assertEqual(self.clazz.GetDefaultLineColor(), blue)
        self.assertEqual(self.clazz.GetDefaultLineWidth(), 5)
        self.check_messages([(CLASS_CHANGED,)])

    def test_add_singleton(self):
        """Test Classification.AppendGroup(ClassGroupSingleton())"""
        self.assertEquals(self.clazz.FindGroup(5),
                          self.clazz.GetDefaultGroup())

        s = ClassGroupSingleton(5)
        self.clazz.AppendGroup(s)
        self.check_messages([(CLASS_CHANGED,)])
        self.assertEquals(self.clazz.FindGroup(5), s)
        self.assertEquals(self.clazz.FindGroup(0),
                          self.clazz.GetDefaultGroup())

    def test_add_range(self):
        """Test Classification.AppendGroup(ClassGroupRange())"""
        self.assertEquals(self.clazz.FindGroup(0),
                          self.clazz.GetDefaultGroup())

        r = ClassGroupRange((-10, 10))
        self.clazz.AppendGroup(r)
        self.check_messages([(CLASS_CHANGED,)])
        self.assertEquals(self.clazz.FindGroup(-11),
                          self.clazz.GetDefaultGroup())
        self.assertEquals(self.clazz.FindGroup(-10), r)
        self.assertEquals(self.clazz.FindGroup(9), r)
        self.assertEquals(self.clazz.FindGroup(5), r)
        self.assertEquals(self.clazz.FindGroup(10),
                          self.clazz.GetDefaultGroup())

    def test_add_pattern(self):
        """Test Classification.AppendGroup(ClassGroupPattern())"""
        self.assertEquals(self.clazz.FindGroup(5),
                          self.clazz.GetDefaultGroup())

        s = ClassGroupPattern("A")
        self.clazz.AppendGroup(s)
        self.check_messages([(CLASS_CHANGED,)])
        self.assertEquals(self.clazz.FindGroup("A"), s)
        self.assertEquals(self.clazz.FindGroup("B"),
                          self.clazz.GetDefaultGroup())

    def test_multiple_groups_numerical(self):
        """Test numerical Classification with multiple groups"""
        # two singletons matching 1 to test whether they're tested in
        # the right order. Use a non default fill on the second to make
        # it compare unequal to the first.
        s1 = ClassGroupSingleton(1)
        s1a = ClassGroupSingleton(1)
        s1a.GetProperties().SetFill(blue)
        # Sanity check: are they considered different?
        self.assertNotEqual(s1, s1a)

        s2 = ClassGroupSingleton(2)
        r = ClassGroupRange((-10, 10))

        self.clazz.AppendGroup(s1)
        self.clazz.AppendGroup(s2)
        self.clazz.AppendGroup(s1a)
        self.clazz.AppendGroup(r)
        self.check_messages([(CLASS_CHANGED,), (CLASS_CHANGED,),
                             (CLASS_CHANGED,), (CLASS_CHANGED,)])

        self.assertEquals(self.clazz.FindGroup(-11),
                          self.clazz.GetDefaultGroup())
        self.assertEquals(self.clazz.FindGroup(-10), r)
        self.assertEquals(self.clazz.FindGroup(1), s1)
        self.assertEquals(self.clazz.FindGroup(2), s2)
        self.assertEquals(self.clazz.FindGroup(3), r)
        self.assertEquals(self.clazz.FindGroup(9), r)
        self.assertEquals(self.clazz.FindGroup(10),
                          self.clazz.GetDefaultGroup())

    def test_multiple_groups_textual(self):
        """Test textual Classification with multiple groups"""
        # A singleton and a pattern matching 'A' to test whether 
        # they're tested in the right order. Use a non default fill 
        # on the pattern to make it compare unequal to the first.
        s = ClassGroupSingleton("A")
        p = ClassGroupPattern("A")
        p.GetProperties().SetFill(blue)
        # Sanity check: are they considered different?
        self.assertNotEqual(s, p)

        self.clazz.AppendGroup(s)
        self.clazz.AppendGroup(p)
        self.check_messages([(CLASS_CHANGED,), (CLASS_CHANGED,)])

        self.assertEquals(self.clazz.FindGroup("bca"),
                          self.clazz.GetDefaultGroup())
        self.assertEquals(self.clazz.FindGroup("A"), s)
        self.assertEquals(self.clazz.FindGroup("Abc"), p)
        self.assertEquals(self.clazz.FindGroup("abc"),
                          self.clazz.GetDefaultGroup())

    def test_insert_group(self):
        """Test Classification.InsertGroup()"""
        s1 = ClassGroupSingleton(1)
        s2 = ClassGroupSingleton(2)
        r = ClassGroupRange((0, 10))

        self.clazz.AppendGroup(s1)
        self.clazz.AppendGroup(r)
        self.assertEquals(self.clazz.FindGroup(2), r)
        self.clear_messages()

        self.clazz.InsertGroup(1, s2)
        self.assertEquals(self.clazz.FindGroup(2), s2)
        self.check_messages([(CLASS_CHANGED,)])

    def test_remove_group(self):
        """Test Classification.RemoveGroup()"""
        s1 = ClassGroupSingleton(1)
        s2 = ClassGroupSingleton(2)
        r = ClassGroupRange((0, 10))

        self.clazz.AppendGroup(s1)
        self.clazz.AppendGroup(s2)
        self.clazz.AppendGroup(r)
        self.assertEquals(self.clazz.FindGroup(2), s2)
        self.clear_messages()

        self.clazz.RemoveGroup(1)
        self.assertEquals(self.clazz.FindGroup(2), r)
        self.check_messages([(CLASS_CHANGED,)])

    def test_replace_group(self):
        """Test Classification.ReplaceGroup()"""
        s1 = ClassGroupSingleton(1)
        s2 = ClassGroupSingleton(2)
        r = ClassGroupRange((0, 10))

        self.clazz.AppendGroup(s2)
        self.clazz.AppendGroup(r)
        self.assertEquals(self.clazz.FindGroup(2), s2)
        self.assertEquals(self.clazz.FindGroup(1), r)
        self.clear_messages()

        self.clazz.ReplaceGroup(0, s1)
        self.assertEquals(self.clazz.FindGroup(2), r)
        self.assertEquals(self.clazz.FindGroup(1), s1)
        self.check_messages([(CLASS_CHANGED,)])

    def test_deepcopy_numerical(self):
        """Test deepcopy(numerical Classification())"""
        self.clazz.AppendGroup(ClassGroupSingleton(5))
        self.clazz.AppendGroup(ClassGroupRange((-10, 10)))

        clazz = copy.deepcopy(self.clazz)

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

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

    def test_deepcopy_textual(self):
        """Test deepcopy(textual Classification())"""
        self.clazz.AppendGroup(ClassGroupSingleton("A"))
        self.clazz.AppendGroup(ClassGroupPattern("B"))

        clazz = copy.deepcopy(self.clazz)

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

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


    def test_iterator(self):
        """Test Classification iteration"""
        groups = [ClassGroupSingleton(5), ClassGroupSingleton(5),
                  ClassGroupRange((-3, 3)), ClassGroupSingleton(-5),
                  ClassGroupDefault()]

        for g in groups:
            self.clazz.AppendGroup(g)

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

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

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


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			import unittest
17
18			import support
19			support.initthuban()
20
21	bh	1903	import copy
22
23	jonathan	1346	from Thuban.Model.color import Color, Transparent, Black
24	jonathan	884	from Thuban.Model.classification import \
25			Classification, ClassGroup, \
26			ClassGroupDefault, ClassGroupSingleton, ClassGroupRange,\
27	frank	2688	ClassGroupPattern, ClassGroupProperties
28	bh	1907	from Thuban.Model.messages import CLASS_CHANGED
29	jonathan	884
30	jonathan	1356	from Thuban.Model.range import Range
31	jonathan	369
32
33	jonathan	482
34	bh	1903	# 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
40	bh	1898	class TestClassGroupProperties(unittest.TestCase):
41	jonathan	369
42	bh	1898	def test(self):
43	jonathan	482	"""Test ClassGroupProperties"""
44
45			props = ClassGroupProperties()
46	jonathan	1346	self.assertEqual(props.GetLineColor(), Black)
47	jonathan	482	self.assertEqual(props.GetLineWidth(), 1)
48	jonathan	1346	self.assertEqual(props.GetFill(), Transparent)
49	jonathan	482
50			props.SetLineColor(red)
51			self.assertEqual(props.GetLineColor(), red)
52
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	frank	2688	class TestClassGroupPattern(unittest.TestCase):
250
251			def test(self):
252			"""Test ClassGroupPattern"""
253
254			defProps = ClassGroupProperties()
255			newProps = ClassGroupProperties()
256			newProps.SetLineColor(Color(.25, .5, .75))
257			newProps.SetLineWidth(5)
258			newProps.SetFill(Color(.12, .24, .36))
259
260			# test empty constructor
261			group = ClassGroupPattern()
262
263			self.assertEqual(group.GetPattern(), "")
264			self.assertEqual(group.GetProperties(), defProps)
265			self.assertEqual(group.GetLabel(), "")
266
267			# test SetProperties()/GetProperties()
268			group.SetProperties(newProps)
269			self.assertEqual(group.GetProperties(), newProps)
270
271			# test SetPattern()
272			group.SetPattern("A")
273			self.assertEqual(group.GetPattern(), "A")
274
275			# test Matches()
276			self.assertEqual(group.Matches("CBA"), False)
277			self.assertEqual(group.Matches("ABC"), True)
278
279			group.SetPattern("a")
280			self.assertNotEqual(group.GetPattern(), "A")
281
282			# test Matches()
283			self.assertEqual(group.Matches("Abc"), False)
284			self.assertEqual(group.Matches("aBC"), True)
285
286			group.SetPattern("hallo")
287			self.assertEqual(group.GetPattern(), "hallo")
288
289			# test Matches()
290			self.assertEqual(group.Matches("HALLO"), False)
291			self.assertEqual(group.Matches("hallo"), True)
292
293			# test copy
294			groupCopy = copy.copy(group)
295			self.assertEqual(group, groupCopy)
296
297
298	bh	1907	class TestClassification(unittest.TestCase, support.SubscriberMixin):
299	bh	1898
300	bh	1903	"""Test cases for Classification"""
301	jonathan	369
302	bh	1905	def setUp(self):
303			self.clazz = Classification()
304	bh	1907	self.clazz.Subscribe(CLASS_CHANGED, self.subscribe_with_params,
305			CLASS_CHANGED)
306			self.clear_messages()
307	bh	1905
308	bh	1907	def tearDown(self):
309			self.clear_messages()
310			self.clazz.Destroy()
311			del self.clazz
312
313	bh	1903	def test_defaults(self):
314			"""Test Classification default settings"""
315	bh	1905	self.assertEqual(self.clazz.FindGroup(-1),
316			self.clazz.GetDefaultGroup())
317			self.assertEqual(self.clazz.GetDefaultLineColor(), Black)
318			self.assertEqual(self.clazz.GetDefaultFill(), Transparent)
319	bh	1907	self.assertEqual(self.clazz.GetDefaultLineWidth(), 1)
320	jonathan	482
321	bh	1903	# The default group is not counted, hence 0 groups
322	bh	1905	self.assertEqual(self.clazz.GetNumGroups(), 0)
323	jonathan	395
324	bh	1907	# No messages should have been sent so far
325			self.check_messages([])
326
327	bh	1903	def test_set_default_properties(self):
328			"""Test Classification.SetDefaultLineColor and SetDefaultFill"""
329	bh	1907	# No messages so far
330			self.check_messages([])
331	jonathan	369
332	bh	1907	# Change the default line color
333	bh	1905	self.clazz.SetDefaultLineColor(red)
334			self.assertEqual(self.clazz.GetDefaultLineColor(), red)
335			self.assertEqual(self.clazz.GetDefaultFill(), Transparent)
336	bh	1907	self.assertEqual(self.clazz.GetDefaultLineWidth(), 1)
337	jonathan	369
338	bh	1907	self.check_messages([(CLASS_CHANGED,)])
339			self.clear_messages()
340
341	bh	1905	self.clazz.SetDefaultFill(green)
342			self.assertEqual(self.clazz.GetDefaultFill(), green)
343			self.assertEqual(self.clazz.GetDefaultLineColor(), red)
344	bh	1907	self.assertEqual(self.clazz.GetDefaultLineWidth(), 1)
345			self.check_messages([(CLASS_CHANGED,)])
346	jonathan	369
347	bh	1907	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	bh	1910	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	bh	1903	def test_add_singleton(self):
370			"""Test Classification.AppendGroup(ClassGroupSingleton())"""
371	bh	1905	self.assertEquals(self.clazz.FindGroup(5),
372			self.clazz.GetDefaultGroup())
373	jonathan	369
374	jonathan	482	s = ClassGroupSingleton(5)
375	bh	1905	self.clazz.AppendGroup(s)
376	bh	1907	self.check_messages([(CLASS_CHANGED,)])
377	bh	1905	self.assertEquals(self.clazz.FindGroup(5), s)
378			self.assertEquals(self.clazz.FindGroup(0),
379			self.clazz.GetDefaultGroup())
380	jonathan	369
381	bh	1903	def test_add_range(self):
382			"""Test Classification.AppendGroup(ClassGroupRange())"""
383	bh	1905	self.assertEquals(self.clazz.FindGroup(0),
384			self.clazz.GetDefaultGroup())
385	bh	1903
386	jonathan	1356	r = ClassGroupRange((-10, 10))
387	bh	1905	self.clazz.AppendGroup(r)
388	bh	1907	self.check_messages([(CLASS_CHANGED,)])
389	bh	1905	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	jonathan	369
397	frank	2688	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	bh	1905	# 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	bh	1903	s1 = ClassGroupSingleton(1)
415			s1a = ClassGroupSingleton(1)
416	bh	1905	s1a.GetProperties().SetFill(blue)
417			# Sanity check: are they considered different?
418			self.assertNotEqual(s1, s1a)
419
420	bh	1903	s2 = ClassGroupSingleton(2)
421			r = ClassGroupRange((-10, 10))
422
423	bh	1905	self.clazz.AppendGroup(s1)
424			self.clazz.AppendGroup(s2)
425			self.clazz.AppendGroup(s1a)
426			self.clazz.AppendGroup(r)
427	bh	1907	self.check_messages([(CLASS_CHANGED,), (CLASS_CHANGED,),
428			(CLASS_CHANGED,), (CLASS_CHANGED,)])
429	bh	1903
430	bh	1905	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	bh	1903
440	frank	2688	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	bh	1910	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	frank	2688	def test_deepcopy_numerical(self):
511			"""Test deepcopy(numerical Classification())"""
512	bh	1905	self.clazz.AppendGroup(ClassGroupSingleton(5))
513			self.clazz.AppendGroup(ClassGroupRange((-10, 10)))
514	bh	1903
515	bh	1905	clazz = copy.deepcopy(self.clazz)
516	jonathan	656
517	bh	1905	self.assertEquals(clazz.GetNumGroups(), self.clazz.GetNumGroups())
518	jonathan	656
519			for i in range(clazz.GetNumGroups()):
520	bh	1905	self.assertEquals(clazz.GetGroup(i), self.clazz.GetGroup(i))
521	jonathan	656
522	frank	2688	def test_deepcopy_textual(self):
523			"""Test deepcopy(textual Classification())"""
524			self.clazz.AppendGroup(ClassGroupSingleton("A"))
525			self.clazz.AppendGroup(ClassGroupPattern("B"))
526	bh	598
527	frank	2688	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	bh	1903	def test_iterator(self):
536			"""Test Classification iteration"""
537			groups = [ClassGroupSingleton(5), ClassGroupSingleton(5),
538			ClassGroupRange((-3, 3)), ClassGroupSingleton(-5),
539			ClassGroupDefault()]
540	bh	1898
541	bh	1903	for g in groups:
542	bh	1905	self.clazz.AppendGroup(g)
543	bh	1903
544	bh	1905	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	bh	1903
549			list = []
550	bh	1905	for g in self.clazz:
551	bh	1903	list.append(convert(g))
552
553			self.assertEquals(list, [0, 1, 1, 2, 1, 0])
554
555
556	jonathan	369	if __name__ == "__main__":
557	bh	598	support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision