WIP-pyshapelib-bramz/test/test_map.py

# Copyright (c) 2002, 2003 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, \
     MAP_LAYERS_CHANGED, MAP_LAYERS_ADDED, MAP_LAYERS_REMOVED,\
     MAP_STACKING_CHANGED, LAYER_VISIBILITY_CHANGED, LAYER_LEGEND_CHANGED, \
     LAYER_CHANGED

from Thuban.Model.session import Session
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, 
                        MAP_LAYERS_CHANGED,
                        MAP_LAYERS_ADDED,
                        MAP_LAYERS_REMOVED,
                        MAP_STACKING_CHANGED,
                        LAYER_VISIBILITY_CHANGED, 
                        LAYER_LEGEND_CHANGED,
                        LAYER_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
        session = Session("Test session for %s" % self.__class__)
        self.failIf(self.map.WasModified())
        self.failIf(self.map.HasLayers())

        # add a layer and check the result
        filename = os.path.join("..", "Data", "iceland", "roads-line.shp")
        roads = Layer("Roads", session.OpenShapefile(filename))
        self.map.AddLayer(roads)
        self.assertEquals(self.map.Layers(), [roads])
        self.check_messages([(self.map, MAP_LAYERS_CHANGED),
                             (self.map, MAP_LAYERS_ADDED)])
        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.session = Session("Test session for %s" % self.__class__)
        open_shp = self.session.OpenShapefile
        self.arc_layer = Layer("Roads",
                               open_shp(os.path.join("..", "Data", "iceland",
                                                     "roads-line.shp")))
        self.poly_layer = Layer("Political",
                                open_shp(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 tearDown(self):
        TestMapBase.tearDown(self)
        self.session = None
        self.map = None
        self.poly_layer = self.arc_layer = None

    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, MAP_LAYERS_CHANGED),
                             (self.map, MAP_LAYERS_REMOVED),
                             (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([(MAP_LAYERS_CHANGED,),
                             (self.map, MAP_LAYERS_CHANGED),
                             (self.map, MAP_LAYERS_REMOVED)])
        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, MAP_LAYERS_CHANGED),
                             (self.map, MAP_STACKING_CHANGED)])
        self.assert_(self.map.WasModified())

    def test_raise_layer_top(self):
        """Test Map.MoveLayerToTop"""
        open_shp = self.session.OpenShapefile
        dummy = Layer("Roads",
                      open_shp(os.path.join("..", "Data", "iceland",
                                            "roads-line.shp")))
        self.map.AddLayer(dummy)
        self.clear_messages()

        self.map.MoveLayerToTop(self.poly_layer)
        self.assertEquals(self.map.Layers(), 
                          [self.arc_layer, dummy, self.poly_layer])
        self.check_messages([(self.map, MAP_LAYERS_CHANGED),
                             (self.map, MAP_STACKING_CHANGED)])
        self.assert_(self.map.WasModified())

        self.map.RemoveLayer(dummy)

    def test_lower_layer_bottom(self):
        """Test Map.MoveLayerToBottom"""
        open_shp = self.session.OpenShapefile
        dummy = Layer("Roads",
                      open_shp(os.path.join("..", "Data", "iceland",
                                            "roads-line.shp")))
        self.map.AddLayer(dummy)
        self.clear_messages()

        self.map.MoveLayerToBottom(dummy)
        self.assertEquals(self.map.Layers(), 
                          [dummy, self.arc_layer, self.poly_layer])
        self.check_messages([(self.map, MAP_LAYERS_CHANGED),
                             (self.map, MAP_STACKING_CHANGED)])
        self.assert_(self.map.WasModified())

        self.map.RemoveLayer(dummy)

    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, MAP_LAYERS_CHANGED),
                             (self.map, MAP_STACKING_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),
                                 epsilon = 1e-5)

    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, None, 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_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.GetClassification().SetDefaultFill(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_CHANGED),
                             (CHANGED,)])

if __name__ == "__main__":
    support.run_tests()

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