WIP-pyshapelib-bramz/test/test_map.py

# Copyright (c) 2002 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""
Test the Map class
"""

__version__ = "$Revision$"
# $Source$
# $Id$

import os
import unittest

import support
support.initthuban()

from Thuban.Model.messages import CHANGED, MAP_PROJECTION_CHANGED, \
     LAYERS_CHANGED, LAYER_VISIBILITY_CHANGED, LAYER_LEGEND_CHANGED
from Thuban.Model.map import Map
from Thuban.Model.layer import Layer
from Thuban.Model.proj import Projection
from Thuban.Model.color import Color


class TestMapSimple(unittest.TestCase):

    """Very simple test cases for Map"""

    def test_initial_state(self):
        """Test Map's initial state"""
        map = Map("Test Map")
        self.assertEquals(map.Title(), "Test Map")
        self.assertEquals(map.Layers(), [])
        label_layer = map.LabelLayer()
        self.assertEquals(label_layer.Title(), "Labels")
        self.assertEquals(label_layer.Labels(), [])
        self.failIf(map.WasModified())
        map.Destroy()

    def test_empty_map(self):
        """Test empty Map"""
        map = Map("Test Map")
        self.assertEquals(map.BoundingBox(), None)
        self.assertEquals(map.ProjectedBoundingBox(), None)
        self.failIf(map.HasLayers())
        map.Destroy()


class TestMapBase(unittest.TestCase, support.SubscriberMixin):

    """Base class for Map test cases that test messages"""

    def setUp(self):
        """
        Clear the message list, create self.map and subscribe to its messages
        """
        self.clear_messages()

        # Create a Map and subscribe to all interesting channels.
        self.map = Map("Test Map")
        for channel in (CHANGED, MAP_PROJECTION_CHANGED, LAYERS_CHANGED,
                        LAYER_VISIBILITY_CHANGED, LAYER_LEGEND_CHANGED):
            self.map.Subscribe(channel, self.subscribe_with_params, channel)

    def tearDown(self):
        """Destroy self.map and clear the message list"""
        self.map.Destroy()
        self.clear_messages()


class TestMapAddLayer(TestMapBase):

    """Simple test cases involving messages"""

    def test_add_layer(self):
        """Test Map.AddLayer"""
        # make sure the created Map is unmodified
        self.failIf(self.map.WasModified())
        self.failIf(self.map.HasLayers())

        # add a layer and check the result
        roads = Layer("Roads",
                      os.path.join("..", "Data", "iceland", "roads-line.shp"))
        self.map.AddLayer(roads)
        self.assertEquals(self.map.Layers(), [roads])
        self.check_messages([(self.map, LAYERS_CHANGED)])
        self.assert_(self.map.WasModified())
        self.assert_(self.map.HasLayers())


class TestMapWithContents(TestMapBase, support.FloatComparisonMixin):

    """More complex Map test cases with messages that.

    All test cases here start with a non-empty map.
    """

    def setUp(self):
        """Extend the inherited method to also fill the Map.

        Put some layers into the map created by the inherited method and
        reset its modified flag. Make also sure that the list of
        received messages is empty.
        """
        TestMapBase.setUp(self)
        self.arc_layer = Layer("Roads",
                               os.path.join("..", "Data", "iceland",
                                            "roads-line.shp"))
        self.poly_layer = Layer("Political",
                                os.path.join("..", "Data", "iceland",
                                             "political.shp"))
        self.map.AddLayer(self.arc_layer)
        self.map.AddLayer(self.poly_layer)
        self.map.UnsetModified()
        self.clear_messages()

    def test_remove_layer(self):
        """Test Map.RemoveLayer"""
        self.map.RemoveLayer(self.arc_layer)
        self.assert_(self.map.WasModified())
        self.assertEquals(self.map.Layers(), [self.poly_layer])
        self.map.UnsetModified()
        self.check_messages([(self.map, LAYERS_CHANGED),
                             (CHANGED,)])

    def test_clear_layers(self):
        """Test Map.ClearLayers"""
        self.map.ClearLayers()
        self.assertEquals(self.map.Layers(), [])
        self.assertEquals(self.map.LabelLayer().Labels(), [])
        self.check_messages([(LAYERS_CHANGED,),
                             (self.map, LAYERS_CHANGED)])
        self.assert_(self.map.WasModified())
        self.failIf(self.map.HasLayers())

    def test_raise_layer(self):
        """Test Map.RaiseLayer"""
        self.map.RaiseLayer(self.arc_layer)
        self.assertEquals(self.map.Layers(), [self.poly_layer, self.arc_layer])
        self.check_messages([(self.map, LAYERS_CHANGED)])
        self.assert_(self.map.WasModified())

    def test_raise_highest_layer(self):
        """Test Map.RaiseLayer with highest layer

        Attempting to raise the highest layer should not modify the map.
        In particular it should not send any messages.
        """
        self.map.RaiseLayer(self.poly_layer)
        self.assertEquals(self.map.Layers(), [self.arc_layer, self.poly_layer])
        self.check_messages([])
        self.failIf(self.map.WasModified())

    def test_lower_layer(self):
        """Test Map.LowerLayer"""
        self.map.LowerLayer(self.poly_layer)
        self.assertEquals(self.map.Layers(), [self.poly_layer, self.arc_layer])
        self.check_messages([(self.map, LAYERS_CHANGED)])
        self.assert_(self.map.WasModified())

    def test_lower_lowest_layer(self):
        """Test Map.LowerLayer with lowest layer.

        Attempting to lower the lowest layer should not modify the map.
        In particular it should not send any messages.
        """
        self.map.LowerLayer(self.arc_layer)
        self.assertEquals(self.map.Layers(), [self.arc_layer, self.poly_layer])
        self.check_messages([])
        self.failIf(self.map.WasModified())

    def test_bounding_box(self):
        """Test Map.BoundingBox"""
        self.assertFloatSeqEqual(self.map.BoundingBox(),
                                 (-24.546524047851562, 63.286754608154297,
                                  -13.495815277099609, 66.563774108886719))

    def test_projected_bounding_box(self):
        """Test Map.ProjectedBoundingBox"""
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
        self.map.SetProjection(proj)
        self.assertFloatSeqEqual(self.map.ProjectedBoundingBox(),
                                 (608873.03380603762, 7019694.6517963577,
                                  1173560.0288053728, 7447353.2203218574))

    def test_set_projection(self):
        """Test Map.SetProjection"""
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
        self.map.SetProjection(proj)
        self.check_messages([(self.map, MAP_PROJECTION_CHANGED)])
        self.assert_(self.map.WasModified())

    def test_tree_info(self):
        """Test Map.TreeInfo"""
        proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
        self.map.SetProjection(proj)
        # compute the extent string because there are platform
        # differences in the way %g is handled:
        # glibc: "%g" % 7.01969e+06 == "7.01969e+06"
        # w32/VC: "%g" % 7.01969e+06 == "7.01969e+006"
        extent = 'Extent (projected): (%g, %g, %g, %g)'\
                 % (608873, 7.01969e+06, 1.17356e+06, 7.44735e+06)
        self.assertEquals(self.map.TreeInfo(),
                          ('Map: Test Map',
                           [('Extent (lat-lon):'
                             ' (-24.5465, 63.2868, -13.4958, 66.5638)'),
                            extent,
                            ('Projection',
                             ['zone=26', 'proj=utm', 'ellps=clrk66']),
                            self.poly_layer,
                            self.arc_layer]))

    def test_forwarding_fill(self):
        """Test Map's forwarding of Layer.SetFill messages"""
        self.poly_layer.SetFill(Color(0.0, 0.5, 1.0))
        self.check_messages([(self.poly_layer, LAYER_LEGEND_CHANGED)])

    def test_forwarding_stroke(self):
        """Test Map's forwarding of Layer.SetStroke messages"""
        self.poly_layer.SetStroke(Color(0.0, 0.5, 1.0))
        self.check_messages([(self.poly_layer, LAYER_LEGEND_CHANGED)])

    def test_forwarding_stroke_width(self):
        """Test Map's forwarding of Layer.SetStrokeWidth messages"""
        self.poly_layer.SetStrokeWidth(3)
        self.check_messages([(self.poly_layer, LAYER_LEGEND_CHANGED)])

    def test_forwarding_visibility(self):
        """Test Map's forwarding of Layer.SetVisible messages"""
        self.poly_layer.SetVisible(0)
        self.check_messages([(self.poly_layer, LAYER_VISIBILITY_CHANGED)])

    def test_unset_modified(self):
        """Test Map.UnsetModified.

        Test whether a change to a layer results in the map being
        considered modified and test whether then calling the map's
        UnsetModified clears the changed flag in the layer as well.
        """
        self.failIf(self.map.WasModified())
        self.poly_layer.SetFill(Color(0.0, 0.5, 1.0))
        self.assert_(self.map.WasModified())
        self.map.UnsetModified()
        self.failIf(self.map.WasModified())
        self.failIf(self.poly_layer.WasModified())
        self.check_messages([(self.poly_layer, LAYER_LEGEND_CHANGED),
                             (CHANGED,)
                             ])

if __name__ == "__main__":
    unittest.main()
1	# Copyright (c) 2002 by Intevation GmbH
2	# Authors:
3	# Bernhard Herzog <[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 Map class
10	"""
11
12	__version__ = "$Revision$"
13	# $Source$
14	# $Id$
15
16	import os
17	import unittest
18
19	import support
20	support.initthuban()
21
22	from Thuban.Model.messages import CHANGED, MAP_PROJECTION_CHANGED, \
23	LAYERS_CHANGED, LAYER_VISIBILITY_CHANGED, LAYER_LEGEND_CHANGED
24	from Thuban.Model.map import Map
25	from Thuban.Model.layer import Layer
26	from Thuban.Model.proj import Projection
27	from Thuban.Model.color import Color
28
29
30	class TestMapSimple(unittest.TestCase):
31
32	"""Very simple test cases for Map"""
33
34	def test_initial_state(self):
35	"""Test Map's initial state"""
36	map = Map("Test Map")
37	self.assertEquals(map.Title(), "Test Map")
38	self.assertEquals(map.Layers(), [])
39	label_layer = map.LabelLayer()
40	self.assertEquals(label_layer.Title(), "Labels")
41	self.assertEquals(label_layer.Labels(), [])
42	self.failIf(map.WasModified())
43	map.Destroy()
44
45	def test_empty_map(self):
46	"""Test empty Map"""
47	map = Map("Test Map")
48	self.assertEquals(map.BoundingBox(), None)
49	self.assertEquals(map.ProjectedBoundingBox(), None)
50	self.failIf(map.HasLayers())
51	map.Destroy()
52
53
54	class TestMapBase(unittest.TestCase, support.SubscriberMixin):
55
56	"""Base class for Map test cases that test messages"""
57
58	def setUp(self):
59	"""
60	Clear the message list, create self.map and subscribe to its messages
61	"""
62	self.clear_messages()
63
64	# Create a Map and subscribe to all interesting channels.
65	self.map = Map("Test Map")
66	for channel in (CHANGED, MAP_PROJECTION_CHANGED, LAYERS_CHANGED,
67	LAYER_VISIBILITY_CHANGED, LAYER_LEGEND_CHANGED):
68	self.map.Subscribe(channel, self.subscribe_with_params, channel)
69
70	def tearDown(self):
71	"""Destroy self.map and clear the message list"""
72	self.map.Destroy()
73	self.clear_messages()
74
75
76	class TestMapAddLayer(TestMapBase):
77
78	"""Simple test cases involving messages"""
79
80	def test_add_layer(self):
81	"""Test Map.AddLayer"""
82	# make sure the created Map is unmodified
83	self.failIf(self.map.WasModified())
84	self.failIf(self.map.HasLayers())
85
86	# add a layer and check the result
87	roads = Layer("Roads",
88	os.path.join("..", "Data", "iceland", "roads-line.shp"))
89	self.map.AddLayer(roads)
90	self.assertEquals(self.map.Layers(), [roads])
91	self.check_messages([(self.map, LAYERS_CHANGED)])
92	self.assert_(self.map.WasModified())
93	self.assert_(self.map.HasLayers())
94
95
96	class TestMapWithContents(TestMapBase, support.FloatComparisonMixin):
97
98	"""More complex Map test cases with messages that.
99
100	All test cases here start with a non-empty map.
101	"""
102
103	def setUp(self):
104	"""Extend the inherited method to also fill the Map.
105
106	Put some layers into the map created by the inherited method and
107	reset its modified flag. Make also sure that the list of
108	received messages is empty.
109	"""
110	TestMapBase.setUp(self)
111	self.arc_layer = Layer("Roads",
112	os.path.join("..", "Data", "iceland",
113	"roads-line.shp"))
114	self.poly_layer = Layer("Political",
115	os.path.join("..", "Data", "iceland",
116	"political.shp"))
117	self.map.AddLayer(self.arc_layer)
118	self.map.AddLayer(self.poly_layer)
119	self.map.UnsetModified()
120	self.clear_messages()
121
122	def test_remove_layer(self):
123	"""Test Map.RemoveLayer"""
124	self.map.RemoveLayer(self.arc_layer)
125	self.assert_(self.map.WasModified())
126	self.assertEquals(self.map.Layers(), [self.poly_layer])
127	self.map.UnsetModified()
128	self.check_messages([(self.map, LAYERS_CHANGED),
129	(CHANGED,)])
130
131	def test_clear_layers(self):
132	"""Test Map.ClearLayers"""
133	self.map.ClearLayers()
134	self.assertEquals(self.map.Layers(), [])
135	self.assertEquals(self.map.LabelLayer().Labels(), [])
136	self.check_messages([(LAYERS_CHANGED,),
137	(self.map, LAYERS_CHANGED)])
138	self.assert_(self.map.WasModified())
139	self.failIf(self.map.HasLayers())
140
141	def test_raise_layer(self):
142	"""Test Map.RaiseLayer"""
143	self.map.RaiseLayer(self.arc_layer)
144	self.assertEquals(self.map.Layers(), [self.poly_layer, self.arc_layer])
145	self.check_messages([(self.map, LAYERS_CHANGED)])
146	self.assert_(self.map.WasModified())
147
148	def test_raise_highest_layer(self):
149	"""Test Map.RaiseLayer with highest layer
150
151	Attempting to raise the highest layer should not modify the map.
152	In particular it should not send any messages.
153	"""
154	self.map.RaiseLayer(self.poly_layer)
155	self.assertEquals(self.map.Layers(), [self.arc_layer, self.poly_layer])
156	self.check_messages([])
157	self.failIf(self.map.WasModified())
158
159	def test_lower_layer(self):
160	"""Test Map.LowerLayer"""
161	self.map.LowerLayer(self.poly_layer)
162	self.assertEquals(self.map.Layers(), [self.poly_layer, self.arc_layer])
163	self.check_messages([(self.map, LAYERS_CHANGED)])
164	self.assert_(self.map.WasModified())
165
166	def test_lower_lowest_layer(self):
167	"""Test Map.LowerLayer with lowest layer.
168
169	Attempting to lower the lowest layer should not modify the map.
170	In particular it should not send any messages.
171	"""
172	self.map.LowerLayer(self.arc_layer)
173	self.assertEquals(self.map.Layers(), [self.arc_layer, self.poly_layer])
174	self.check_messages([])
175	self.failIf(self.map.WasModified())
176
177	def test_bounding_box(self):
178	"""Test Map.BoundingBox"""
179	self.assertFloatSeqEqual(self.map.BoundingBox(),
180	(-24.546524047851562, 63.286754608154297,
181	-13.495815277099609, 66.563774108886719))
182
183	def test_projected_bounding_box(self):
184	"""Test Map.ProjectedBoundingBox"""
185	proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
186	self.map.SetProjection(proj)
187	self.assertFloatSeqEqual(self.map.ProjectedBoundingBox(),
188	(608873.03380603762, 7019694.6517963577,
189	1173560.0288053728, 7447353.2203218574))
190
191	def test_set_projection(self):
192	"""Test Map.SetProjection"""
193	proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
194	self.map.SetProjection(proj)
195	self.check_messages([(self.map, MAP_PROJECTION_CHANGED)])
196	self.assert_(self.map.WasModified())
197
198	def test_tree_info(self):
199	"""Test Map.TreeInfo"""
200	proj = Projection(["zone=26", "proj=utm", "ellps=clrk66"])
201	self.map.SetProjection(proj)
202	# compute the extent string because there are platform
203	# differences in the way %g is handled:
204	# glibc: "%g" % 7.01969e+06 == "7.01969e+06"
205	# w32/VC: "%g" % 7.01969e+06 == "7.01969e+006"
206	extent = 'Extent (projected): (%g, %g, %g, %g)'\
207	% (608873, 7.01969e+06, 1.17356e+06, 7.44735e+06)
208	self.assertEquals(self.map.TreeInfo(),
209	('Map: Test Map',
210	[('Extent (lat-lon):'
211	' (-24.5465, 63.2868, -13.4958, 66.5638)'),
212	extent,
213	('Projection',
214	['zone=26', 'proj=utm', 'ellps=clrk66']),
215	self.poly_layer,
216	self.arc_layer]))
217
218	def test_forwarding_fill(self):
219	"""Test Map's forwarding of Layer.SetFill messages"""
220	self.poly_layer.SetFill(Color(0.0, 0.5, 1.0))
221	self.check_messages([(self.poly_layer, LAYER_LEGEND_CHANGED)])
222
223	def test_forwarding_stroke(self):
224	"""Test Map's forwarding of Layer.SetStroke messages"""
225	self.poly_layer.SetStroke(Color(0.0, 0.5, 1.0))
226	self.check_messages([(self.poly_layer, LAYER_LEGEND_CHANGED)])
227
228	def test_forwarding_stroke_width(self):
229	"""Test Map's forwarding of Layer.SetStrokeWidth messages"""
230	self.poly_layer.SetStrokeWidth(3)
231	self.check_messages([(self.poly_layer, LAYER_LEGEND_CHANGED)])
232
233	def test_forwarding_visibility(self):
234	"""Test Map's forwarding of Layer.SetVisible messages"""
235	self.poly_layer.SetVisible(0)
236	self.check_messages([(self.poly_layer, LAYER_VISIBILITY_CHANGED)])
237
238	def test_unset_modified(self):
239	"""Test Map.UnsetModified.
240
241	Test whether a change to a layer results in the map being
242	considered modified and test whether then calling the map's
243	UnsetModified clears the changed flag in the layer as well.
244	"""
245	self.failIf(self.map.WasModified())
246	self.poly_layer.SetFill(Color(0.0, 0.5, 1.0))
247	self.assert_(self.map.WasModified())
248	self.map.UnsetModified()
249	self.failIf(self.map.WasModified())
250	self.failIf(self.poly_layer.WasModified())
251	self.check_messages([(self.poly_layer, LAYER_LEGEND_CHANGED),
252	(CHANGED,)
253	])
254
255	if __name__ == "__main__":
256	unittest.main()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision