WIP-pyshapelib-bramz/test/test_layer.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 Layer class
"""

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

import os
import unittest

import support
support.initthuban()

import shapelib
import dbflib

from Thuban.Model.layer import Layer, SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
     SHAPETYPE_POINT
from Thuban.Model.messages import LAYER_LEGEND_CHANGED, \
     LAYER_VISIBILITY_CHANGED
from Thuban.Model.color import Color

class TestLayer(unittest.TestCase, support.FileTestMixin,
                support.FloatComparisonMixin):

    """Test cases for different layer (shape) types"""

    def assertFloatTuplesEqual(self, test, value):
        """Assert equality of two lists of tuples of float"""
        for i in range(len(test)):
            self.assertFloatSeqEqual(test[i], value[i])

    def test_arc_layer(self):
        """Test Layer with arc shapes"""
        layer = Layer("Test Layer",
                      os.path.join("..", "Data", "iceland", "roads-line.shp"))
        self.assertEquals(layer.Title(), "Test Layer")
        self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
        self.assertEquals(layer.NumShapes(), 839)
        shape = layer.Shape(32)
        self.assertFloatTuplesEqual(shape.Points(),
                                    [(-15.082174301147461, 66.27738189697265),
                                     (-15.026350021362305, 66.27339172363281)])
        self.assertFloatSeqEqual(layer.BoundingBox(),
                                 [-24.450359344482422, 63.426830291748047,
                                  -13.55668830871582, 66.520111083984375])
        self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25)),
                          [613, 726, 838])
        layer.Destroy()

    def test_polygon_layer(self):
        """Test Layer with polygon shapes"""
        layer = Layer("Test Layer",
                      os.path.join("..", "Data", "iceland", "political.shp"))
        self.assertEquals(layer.Title(), "Test Layer")
        self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)
        self.assertEquals(layer.NumShapes(), 156)
        shape = layer.Shape(4)
        self.assertFloatTuplesEqual(shape.Points(),
                                    [(-22.406391143798828, 64.714111328125),
                                     (-22.41621208190918, 64.71600341796875),
                                     (-22.406051635742188, 64.719200134277344),
                                     (-22.406391143798828, 64.714111328125)])
        self.assertFloatSeqEqual(layer.BoundingBox(),
                                 [-24.546524047851562, 63.286754608154297,
                                  -13.495815277099609, 66.563774108886719])
        self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.9, 64.1)),
                          [91, 92, 144, 146, 148, 150, 152, 153])
        layer.Destroy()

    def test_point_layer(self):
        """Test Layer with point shapes"""
        layer = Layer("Test Layer",
                      os.path.join("..", "Data", "iceland",
                                   "cultural_landmark-point.shp"))
        self.assertEquals(layer.Title(), "Test Layer")
        self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)
        self.assertEquals(layer.NumShapes(), 34)
        shape = layer.Shape(0)
        self.assertFloatTuplesEqual(shape.Points(),
                                    [(-22.711074829101562, 66.36572265625)])
        self.assertFloatSeqEqual(layer.BoundingBox(),
                                 [-23.806047439575195, 63.405960083007812,
                                  -15.12291431427002, 66.36572265625])
        self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.80, 64.1)),
                          [0, 1, 2, 3, 4, 5, 27, 28, 29, 30, 31])
        layer.Destroy()

    def test_empty_layer(self):
        """Test Layer with empty shape file"""
        # create an empty shape file
        shapefilename = self.temp_file_name("layer_empty.shp")
        shp = shapelib.create(shapefilename, shapelib.SHPT_POLYGON)
        shp.close()
        # create an empty DBF file too because Thuban can't cope yet
        # with missing DBF file.
        dbffilename = self.temp_file_name("layer_empty.dbf")
        dbf = dbflib.create(dbffilename)
        dbf.add_field("NAME", dbflib.FTString, 20, 0)

        # Now try to open it.
        layer = Layer("Empty Layer", shapefilename)
        self.assertEquals(layer.BoundingBox(), None)
        self.assertEquals(layer.LatLongBoundingBox(), None)
        self.assertEquals(layer.NumShapes(), 0)
        layer.Destroy()


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

    """Test cases for Layer method that modify the layer.
    """

    def setUp(self):
        """Clear the list of received messages and create a layer

        The layer is bound to self.layer.
        """
        self.clear_messages()
        self.layer = Layer("Test Layer",
                           os.path.join("..", "Data", "iceland",
                                        "political.shp"))
        self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,
                             LAYER_LEGEND_CHANGED)
        self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
                             self.subscribe_with_params,
                             LAYER_VISIBILITY_CHANGED)

    def tearDown(self):
        """Clear the list of received messages and explictly destroy self.layer
        """
        self.layer.Destroy()
        self.clear_messages()

    def test_initial_settings(self):
        """Test Layer's initial legend attributes"""
        # test default settings
        self.failIf(self.layer.WasModified())
        #self.assertEquals(self.layer.fill, None)
        #self.assertEquals(self.layer.stroke.hex(), "#000000")
        #self.assertEquals(self.layer.stroke_width, 1)
        self.assertEquals(self.layer.Visible(), 1)
        # no messages should have been produced
        self.check_messages([])

    def test_visibility(self):
        """Test Layer visibility"""
        self.layer.SetVisible(0)
        self.assertEquals(self.layer.Visible(), 0)
        self.check_messages([(self.layer, LAYER_VISIBILITY_CHANGED)])

        # currently, modifying the visibility doesn't count as changing
        # the layer.
        self.failIf(self.layer.WasModified())

    
#
# the tree info now contains Color objects which are difficult to test
#
#   def test_tree_info(self):
#       """Test Layer.TreeInfo"""
#       self.assertEquals(self.layer.TreeInfo(),
#                         ("Layer 'Test Layer'",
#                          ['Shown',
#                           'Shapes: 156',
#                           ('Extent (lat-lon):'
#                            ' (-24.5465, 63.2868, -13.4958, 66.5638)'),
#                           'Shapetype: Polygon',
#                           'Fill: None',
#                           'Outline: (0.000, 0.000, 0.000)']))


if __name__ == "__main__":
    support.run_tests()
1	bh	599	# Copyright (c) 2002, 2003 by Intevation GmbH
2	bh	331	# 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 Layer 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			import shapelib
23	bh	336	import dbflib
24	bh	331
25			from Thuban.Model.layer import Layer, SHAPETYPE_POLYGON, SHAPETYPE_ARC, \
26			SHAPETYPE_POINT
27			from Thuban.Model.messages import LAYER_LEGEND_CHANGED, \
28			LAYER_VISIBILITY_CHANGED
29			from Thuban.Model.color import Color
30
31			class TestLayer(unittest.TestCase, support.FileTestMixin,
32			support.FloatComparisonMixin):
33
34			"""Test cases for different layer (shape) types"""
35
36			def assertFloatTuplesEqual(self, test, value):
37			"""Assert equality of two lists of tuples of float"""
38			for i in range(len(test)):
39			self.assertFloatSeqEqual(test[i], value[i])
40
41			def test_arc_layer(self):
42			"""Test Layer with arc shapes"""
43			layer = Layer("Test Layer",
44			os.path.join("..", "Data", "iceland", "roads-line.shp"))
45			self.assertEquals(layer.Title(), "Test Layer")
46			self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
47			self.assertEquals(layer.NumShapes(), 839)
48			shape = layer.Shape(32)
49			self.assertFloatTuplesEqual(shape.Points(),
50			[(-15.082174301147461, 66.27738189697265),
51			(-15.026350021362305, 66.27339172363281)])
52			self.assertFloatSeqEqual(layer.BoundingBox(),
53			[-24.450359344482422, 63.426830291748047,
54			-13.55668830871582, 66.520111083984375])
55			self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25)),
56			[613, 726, 838])
57	bh	599	layer.Destroy()
58	bh	331
59			def test_polygon_layer(self):
60			"""Test Layer with polygon shapes"""
61			layer = Layer("Test Layer",
62			os.path.join("..", "Data", "iceland", "political.shp"))
63			self.assertEquals(layer.Title(), "Test Layer")
64			self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)
65			self.assertEquals(layer.NumShapes(), 156)
66			shape = layer.Shape(4)
67			self.assertFloatTuplesEqual(shape.Points(),
68			[(-22.406391143798828, 64.714111328125),
69			(-22.41621208190918, 64.71600341796875),
70			(-22.406051635742188, 64.719200134277344),
71			(-22.406391143798828, 64.714111328125)])
72			self.assertFloatSeqEqual(layer.BoundingBox(),
73			[-24.546524047851562, 63.286754608154297,
74			-13.495815277099609, 66.563774108886719])
75			self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.9, 64.1)),
76			[91, 92, 144, 146, 148, 150, 152, 153])
77	bh	599	layer.Destroy()
78	bh	331
79			def test_point_layer(self):
80			"""Test Layer with point shapes"""
81			layer = Layer("Test Layer",
82			os.path.join("..", "Data", "iceland",
83			"cultural_landmark-point.shp"))
84			self.assertEquals(layer.Title(), "Test Layer")
85			self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)
86			self.assertEquals(layer.NumShapes(), 34)
87			shape = layer.Shape(0)
88			self.assertFloatTuplesEqual(shape.Points(),
89			[(-22.711074829101562, 66.36572265625)])
90			self.assertFloatSeqEqual(layer.BoundingBox(),
91			[-23.806047439575195, 63.405960083007812,
92			-15.12291431427002, 66.36572265625])
93			self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.80, 64.1)),
94			[0, 1, 2, 3, 4, 5, 27, 28, 29, 30, 31])
95	bh	599	layer.Destroy()
96	bh	331
97			def test_empty_layer(self):
98			"""Test Layer with empty shape file"""
99			# create an empty shape file
100			shapefilename = self.temp_file_name("layer_empty.shp")
101			shp = shapelib.create(shapefilename, shapelib.SHPT_POLYGON)
102			shp.close()
103	bh	336	# create an empty DBF file too because Thuban can't cope yet
104			# with missing DBF file.
105			dbffilename = self.temp_file_name("layer_empty.dbf")
106			dbf = dbflib.create(dbffilename)
107			dbf.add_field("NAME", dbflib.FTString, 20, 0)
108	bh	331
109	bh	336	# Now try to open it.
110	bh	331	layer = Layer("Empty Layer", shapefilename)
111			self.assertEquals(layer.BoundingBox(), None)
112			self.assertEquals(layer.LatLongBoundingBox(), None)
113			self.assertEquals(layer.NumShapes(), 0)
114	bh	599	layer.Destroy()
115	bh	331
116
117			class TestLayerLegend(unittest.TestCase, support.SubscriberMixin):
118
119			"""Test cases for Layer method that modify the layer.
120			"""
121
122			def setUp(self):
123			"""Clear the list of received messages and create a layer
124
125			The layer is bound to self.layer.
126			"""
127			self.clear_messages()
128			self.layer = Layer("Test Layer",
129			os.path.join("..", "Data", "iceland",
130			"political.shp"))
131			self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,
132			LAYER_LEGEND_CHANGED)
133			self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
134			self.subscribe_with_params,
135			LAYER_VISIBILITY_CHANGED)
136
137			def tearDown(self):
138			"""Clear the list of received messages and explictly destroy self.layer
139			"""
140			self.layer.Destroy()
141			self.clear_messages()
142
143			def test_initial_settings(self):
144			"""Test Layer's initial legend attributes"""
145			# test default settings
146			self.failIf(self.layer.WasModified())
147	jonathan	409	#self.assertEquals(self.layer.fill, None)
148			#self.assertEquals(self.layer.stroke.hex(), "#000000")
149			#self.assertEquals(self.layer.stroke_width, 1)
150	bh	331	self.assertEquals(self.layer.Visible(), 1)
151			# no messages should have been produced
152			self.check_messages([])
153
154			def test_visibility(self):
155			"""Test Layer visibility"""
156			self.layer.SetVisible(0)
157			self.assertEquals(self.layer.Visible(), 0)
158			self.check_messages([(self.layer, LAYER_VISIBILITY_CHANGED)])
159
160			# currently, modifying the visibility doesn't count as changing
161			# the layer.
162			self.failIf(self.layer.WasModified())
163
164	jonathan	395
165			#
166			# the tree info now contains Color objects which are difficult to test
167			#
168			# def test_tree_info(self):
169			# """Test Layer.TreeInfo"""
170			# self.assertEquals(self.layer.TreeInfo(),
171			# ("Layer 'Test Layer'",
172			# ['Shown',
173			# 'Shapes: 156',
174			# ('Extent (lat-lon):'
175			# ' (-24.5465, 63.2868, -13.4958, 66.5638)'),
176			# 'Shapetype: Polygon',
177			# 'Fill: None',
178			# 'Outline: (0.000, 0.000, 0.000)']))
179	bh	331
180
181			if __name__ == "__main__":
182	bh	599	support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision