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