/[thuban]/branches/WIP-pyshapelib-bramz/test/test_layer.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/test/test_layer.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 331 by bh, Fri Sep 20 14:34:23 2002 UTC revision 996 by bh, Thu May 22 18:21:10 2003 UTC
# Line 1  Line 1 
1  # Copyright (c) 2002 by Intevation GmbH  # Copyright (c) 2002, 2003 by Intevation GmbH
2  # Authors:  # Authors:
3  # Bernhard Herzog <[email protected]>  # Bernhard Herzog <[email protected]>
4  #  #
# Line 20  import support Line 20  import support
20  support.initthuban()  support.initthuban()
21    
22  import shapelib  import shapelib
23    import dbflib
24    
25  from Thuban.Model.layer import Layer, SHAPETYPE_POLYGON, SHAPETYPE_ARC, \  from Thuban.Model.session import Session
26       SHAPETYPE_POINT  from Thuban.Model.layer import BaseLayer, Layer, RasterLayer, \
27         SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT
28  from Thuban.Model.messages import LAYER_LEGEND_CHANGED, \  from Thuban.Model.messages import LAYER_LEGEND_CHANGED, \
29       LAYER_VISIBILITY_CHANGED       LAYER_VISIBILITY_CHANGED
30  from Thuban.Model.color import Color  from Thuban.Model.color import Color
31    from Thuban.Model.table import FIELDTYPE_DOUBLE
32    from Thuban.Model.proj import Projection
33    from Thuban.Model.data import DerivedShapeStore
34    
35  class TestLayer(unittest.TestCase, support.FileTestMixin,  class TestLayer(unittest.TestCase, support.FileTestMixin,
36                  support.FloatComparisonMixin):                  support.FloatComparisonMixin):
# Line 37  class TestLayer(unittest.TestCase, suppo Line 42  class TestLayer(unittest.TestCase, suppo
42          for i in range(len(test)):          for i in range(len(test)):
43              self.assertFloatSeqEqual(test[i], value[i])              self.assertFloatSeqEqual(test[i], value[i])
44    
45        def setUp(self):
46            """Create a session self.session and initialize self.layer to None"""
47            self.session = Session("Test session for %s" % self.__class__)
48            self.layer = None
49    
50        def tearDown(self):
51            """Call the layer's Destroy method and set session and layer to None"""
52            self.session = None
53            if self.layer is not None:
54                self.layer.Destroy()
55                self.layer = None
56    
57        def build_path(self, filename):
58            return os.path.join("..", "Data", "iceland", filename)
59    
60        def open_shapefile(self, filename):
61            """Open and return a shapestore for filename in the iceland data set"""
62            return self.session.OpenShapefile(self.build_path(filename))
63    
64        def test_base_layer(self):
65            layer = self.layer = BaseLayer("Test BaseLayer")
66            self.assertEquals(layer.Title(), "Test BaseLayer")
67            self.failUnless(layer.Visible())
68    
69            # toggle visibility
70            layer.SetVisible(False)
71            self.failIf(layer.Visible())
72    
73            layer.SetVisible(True)
74            self.failUnless(layer.Visible())
75    
76            self.failIf(layer.HasClassification())
77            self.assertEquals(layer.GetProjection(), None)
78    
79            # set/get projection
80            proj = Projection(["proj=utm", "zone=26"])
81    
82            layer.SetProjection(proj)
83            self.failUnless(layer.GetProjection() is proj)
84    
85            # __init__ with other arguments
86            layer = BaseLayer("Test BaseLayer", False, proj)
87            self.failIf(layer.Visible())
88            self.failUnless(layer.GetProjection() is proj)
89    
90      def test_arc_layer(self):      def test_arc_layer(self):
91          """Test Layer with arc shapes"""          """Test Layer with arc shapes"""
92          layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
93                        os.path.join("..", "Data", "iceland", "roads-line.shp"))                                     self.open_shapefile("roads-line.shp"))
         self.assertEquals(layer.Title(), "Test Layer")  
94          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
95          self.assertEquals(layer.NumShapes(), 839)          self.assertEquals(layer.NumShapes(), 839)
96          shape = layer.Shape(32)          shape = layer.Shape(32)
# Line 54  class TestLayer(unittest.TestCase, suppo Line 103  class TestLayer(unittest.TestCase, suppo
103          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25)),          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25)),
104                            [613, 726, 838])                            [613, 726, 838])
105    
106            self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
107                              [-15.082174301147461, 66.27339172363281,
108                               -15.026350021362305, 66.27738189697265])
109    
110            shape = layer.Shape(33)
111            self.assertFloatTuplesEqual(shape.Points(),
112                                        [(-22.248506546020508, 66.30645751953125),
113                                         (-22.232730865478516, 66.294075012207031),
114                                         (-22.23158073425293,  66.287689208984375),
115                                         (-22.246318817138672, 66.270065307617188)])
116    
117            self.assertFloatSeqEqual(layer.ShapesBoundingBox([32, 33]),
118                                     [-22.248506546020508, 66.270065307617188,
119                                      -15.026350021362305, 66.30645751953125])
120    
121            self.assertEquals(layer.ShapesBoundingBox([]), None)
122            self.assertEquals(layer.ShapesBoundingBox(None), None)
123    
124      def test_polygon_layer(self):      def test_polygon_layer(self):
125          """Test Layer with polygon shapes"""          """Test Layer with polygon shapes"""
126          layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
127                        os.path.join("..", "Data", "iceland", "political.shp"))                                     self.open_shapefile("political.shp"))
         self.assertEquals(layer.Title(), "Test Layer")  
128          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)
129          self.assertEquals(layer.NumShapes(), 156)          self.assertEquals(layer.NumShapes(), 156)
130          shape = layer.Shape(4)          shape = layer.Shape(4)
# Line 75  class TestLayer(unittest.TestCase, suppo Line 141  class TestLayer(unittest.TestCase, suppo
141    
142      def test_point_layer(self):      def test_point_layer(self):
143          """Test Layer with point shapes"""          """Test Layer with point shapes"""
144          layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
145                        os.path.join("..", "Data", "iceland",                             self.open_shapefile("cultural_landmark-point.shp"))
                                    "cultural_landmark-point.shp"))  
         self.assertEquals(layer.Title(), "Test Layer")  
146          self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)
147          self.assertEquals(layer.NumShapes(), 34)          self.assertEquals(layer.NumShapes(), 34)
148          shape = layer.Shape(0)          shape = layer.Shape(0)
# Line 96  class TestLayer(unittest.TestCase, suppo Line 160  class TestLayer(unittest.TestCase, suppo
160          shapefilename = self.temp_file_name("layer_empty.shp")          shapefilename = self.temp_file_name("layer_empty.shp")
161          shp = shapelib.create(shapefilename, shapelib.SHPT_POLYGON)          shp = shapelib.create(shapefilename, shapelib.SHPT_POLYGON)
162          shp.close()          shp.close()
163            # create an empty DBF file too because Thuban can't cope yet
164          layer = Layer("Empty Layer", shapefilename)          # with missing DBF file.
165            dbffilename = self.temp_file_name("layer_empty.dbf")
166            dbf = dbflib.create(dbffilename)
167            dbf.add_field("NAME", dbflib.FTString, 20, 0)
168    
169            # Now try to open it.
170            layer = self.layer = Layer("Empty Layer",
171                                       self.session.OpenShapefile(shapefilename))
172          self.assertEquals(layer.BoundingBox(), None)          self.assertEquals(layer.BoundingBox(), None)
173          self.assertEquals(layer.LatLongBoundingBox(), None)          self.assertEquals(layer.LatLongBoundingBox(), None)
174          self.assertEquals(layer.NumShapes(), 0)          self.assertEquals(layer.NumShapes(), 0)
175    
176        def test_get_field_type(self):
177            """Test Layer.GetFieldType()"""
178            layer = self.layer = Layer("Test Layer",
179                                       self.open_shapefile("roads-line.shp"))
180            self.assertEquals(layer.GetFieldType("LENGTH"), FIELDTYPE_DOUBLE)
181            self.assertEquals(layer.GetFieldType("non existing"), None)
182    
183        def test_raster_layer(self):
184            filename = self.build_path("island.tif")
185            layer = RasterLayer("Test RasterLayer", filename)
186            self.assertEquals(layer.GetImageFilename(), filename)
187            self.assertFloatSeqEqual(layer.BoundingBox(),
188                                     [-24.5500000, 63.2833330,
189                                      -13.4916670, 66.5666670])
190            self.assertFloatSeqEqual(layer.LatLongBoundingBox(),
191                                     [-24.5500000, 63.2833330,
192                                      -13.4916670, 66.5666670])
193    
194        def test_derived_store(self):
195            """Test layer with derived store"""
196            layer = self.layer = Layer("Test Layer",
197                                       self.open_shapefile("roads-line.shp"))
198            try:
199                store = layer.ShapeStore()
200                derived = DerivedShapeStore(store, store.Table())
201                layer.SetShapeStore(derived)
202                self.assert_(layer.ShapeStore() is derived)
203            finally:
204                store = derived = None
205    
206    
207  class TestLayerLegend(unittest.TestCase, support.SubscriberMixin):  class TestLayerLegend(unittest.TestCase, support.SubscriberMixin):
208    
# Line 109  class TestLayerLegend(unittest.TestCase, Line 210  class TestLayerLegend(unittest.TestCase,
210      """      """
211    
212      def setUp(self):      def setUp(self):
213          """Clear the list of received messages and create a layer          """Clear the list of received messages and create a layer and a session
214    
215          The layer is bound to self.layer.          The layer is bound to self.layer and the session to self.session.
216          """          """
217          self.clear_messages()          self.clear_messages()
218            self.session = Session("Test session for %s" % self.__class__)
219            filename = os.path.join("..", "Data", "iceland", "political.shp")
220          self.layer = Layer("Test Layer",          self.layer = Layer("Test Layer",
221                             os.path.join("..", "Data", "iceland",                             self.session.OpenShapefile(filename))
                                         "political.shp"))  
222          self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,          self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,
223                               LAYER_LEGEND_CHANGED)                               LAYER_LEGEND_CHANGED)
224          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
# Line 127  class TestLayerLegend(unittest.TestCase, Line 229  class TestLayerLegend(unittest.TestCase,
229          """Clear the list of received messages and explictly destroy self.layer          """Clear the list of received messages and explictly destroy self.layer
230          """          """
231          self.layer.Destroy()          self.layer.Destroy()
232            self.layer = None
233            self.session.Destroy()
234            self.session = None
235          self.clear_messages()          self.clear_messages()
236    
237      def test_initial_settings(self):      def test_initial_settings(self):
238          """Test Layer's initial legend attributes"""          """Test Layer's initial legend attributes"""
239          # test default settings          # test default settings
240          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
241          self.assertEquals(self.layer.fill, None)          #self.assertEquals(self.layer.fill, None)
242          self.assertEquals(self.layer.stroke.hex(), "#000000")          #self.assertEquals(self.layer.stroke.hex(), "#000000")
243          self.assertEquals(self.layer.stroke_width, 1)          #self.assertEquals(self.layer.stroke_width, 1)
244          self.assertEquals(self.layer.Visible(), 1)          self.assertEquals(self.layer.Visible(), 1)
245          # no messages should have been produced          # no messages should have been produced
246          self.check_messages([])          self.check_messages([])
247    
     def test_fill(self):  
         """Test Layer's fill attribute"""  
         # modify the fill  
         self.layer.SetFill(Color(0.5, 1.0, 0.75))  
         self.check_messages([(self.layer, LAYER_LEGEND_CHANGED)])  
         self.assertEquals(self.layer.fill.hex().lower(), "#7fffbf")  
         self.assert_(self.layer.WasModified())  
   
     def test_stroke(self):  
         """Test Layer's stroke attribute"""  
         self.layer.SetStroke(Color(0.5, 1.0, 0.75))  
         self.assertEquals(self.layer.stroke.hex().lower(), "#7fffbf")  
         self.check_messages([(self.layer, LAYER_LEGEND_CHANGED)])  
         self.assert_(self.layer.WasModified())  
   
     def test_stroke_width(self):  
         """Test Layer's stroke_width attribute"""  
         self.layer.SetStrokeWidth(3.0)  
         self.assertEquals(self.layer.stroke_width, 3.0)  
         self.check_messages([(self.layer, LAYER_LEGEND_CHANGED)])  
         self.assert_(self.layer.WasModified())  
   
248      def test_visibility(self):      def test_visibility(self):
249          """Test Layer visibility"""          """Test Layer visibility"""
250          self.layer.SetVisible(0)          self.layer.SetVisible(0)
# Line 172  class TestLayerLegend(unittest.TestCase, Line 255  class TestLayerLegend(unittest.TestCase,
255          # the layer.          # the layer.
256          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
257    
258      def test_tree_info(self):      
259          """Test Layer.TreeInfo"""  #
260          self.assertEquals(self.layer.TreeInfo(),  # the tree info now contains Color objects which are difficult to test
261                            ("Layer 'Test Layer'",  #
262                             ['Shown',  #   def test_tree_info(self):
263                              'Shapes: 156',  #       """Test Layer.TreeInfo"""
264                              ('Extent (lat-lon):'  #       self.assertEquals(self.layer.TreeInfo(),
265                               ' (-24.5465, 63.2868, -13.4958, 66.5638)'),  #                         ("Layer 'Test Layer'",
266                              'Shapetype: Polygon',  #                          ['Shown',
267                              'Fill: None',  #                           'Shapes: 156',
268                              'Outline: (0.000, 0.000, 0.000)']))  #                           ('Extent (lat-lon):'
269    #                            ' (-24.5465, 63.2868, -13.4958, 66.5638)'),
270    #                           'Shapetype: Polygon',
271    #                           'Fill: None',
272    #                           'Outline: (0.000, 0.000, 0.000)']))
273    
274    
275  if __name__ == "__main__":  if __name__ == "__main__":
276      unittest.main()      support.run_tests()
Legend:
Removed from v.331  
changed lines
  Added in v.996
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26