/[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 947 by jonathan, Tue May 20 15:27:19 2003 UTC revision 1452 by bh, Fri Jul 18 12:57:59 2003 UTC
# Line 26  from Thuban.Model.session import Session Line 26  from Thuban.Model.session import Session
26  from Thuban.Model.layer import BaseLayer, Layer, RasterLayer, \  from Thuban.Model.layer import BaseLayer, Layer, RasterLayer, \
27       SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT       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, LAYER_SHAPESTORE_REPLACED, LAYER_CHANGED
30  from Thuban.Model.color import Color  from Thuban.Model.table import FIELDTYPE_DOUBLE, FIELDTYPE_STRING, MemoryTable
 from Thuban.Model.table import FIELDTYPE_DOUBLE  
31  from Thuban.Model.proj import Projection  from Thuban.Model.proj import Projection
32    from Thuban.Model.data import DerivedShapeStore
33    from Thuban.Model.classification import Classification, ClassGroupSingleton, \
34         ClassGroupRange
35    
36    import Thuban.Model.resource
37    
38  class TestLayer(unittest.TestCase, support.FileTestMixin,  class TestLayer(unittest.TestCase, support.FileTestMixin,
39                  support.FloatComparisonMixin):                  support.FloatComparisonMixin):
# Line 42  class TestLayer(unittest.TestCase, suppo Line 46  class TestLayer(unittest.TestCase, suppo
46              self.assertFloatSeqEqual(test[i], value[i])              self.assertFloatSeqEqual(test[i], value[i])
47    
48      def setUp(self):      def setUp(self):
49          """Create a session"""          """Create a session self.session and initialize self.layer to None"""
50          self.session = Session("Test session for %s" % self.__class__)          self.session = Session("Test session for %s" % self.__class__)
51            self.layer = None
52    
53      def tearDown(self):      def tearDown(self):
54            """Call the layer's Destroy method and set session and layer to None"""
55          self.session = None          self.session = None
56            if self.layer is not None:
57                self.layer.Destroy()
58                self.layer = None
59    
60      def build_path(self, filename):      def build_path(self, filename):
61          return os.path.join("..", "Data", "iceland", filename)          return os.path.join("..", "Data", "iceland", filename)
62            
63      def open_shapefile(self, filename):      def open_shapefile(self, filename):
64          """Open and return a shapestore for filename in the iceland data set"""          """Open and return a shapestore for filename in the iceland data set"""
65          return self.session.OpenShapefile(self.build_path(filename))          return self.session.OpenShapefile(self.build_path(filename))
66    
67      def test_base_layer(self):      def test_base_layer(self):
68          layer = BaseLayer("Test BaseLayer")          layer = self.layer = BaseLayer("Test BaseLayer")
69          self.assertEquals(layer.Title(), "Test BaseLayer")          self.assertEquals(layer.Title(), "Test BaseLayer")
70          self.failUnless(layer.Visible())          self.failUnless(layer.Visible())
71    
# Line 68  class TestLayer(unittest.TestCase, suppo Line 77  class TestLayer(unittest.TestCase, suppo
77          self.failUnless(layer.Visible())          self.failUnless(layer.Visible())
78    
79          self.failIf(layer.HasClassification())          self.failIf(layer.HasClassification())
80            self.failIf(layer.HasShapes())
81    
82          self.assertEquals(layer.GetProjection(), None)          self.assertEquals(layer.GetProjection(), None)
83    
84          # set/get projection          # set/get projection
# Line 83  class TestLayer(unittest.TestCase, suppo Line 94  class TestLayer(unittest.TestCase, suppo
94    
95      def test_arc_layer(self):      def test_arc_layer(self):
96          """Test Layer with arc shapes"""          """Test Layer with arc shapes"""
97          layer = Layer("Test Layer", self.open_shapefile("roads-line.shp"))          layer = self.layer = Layer("Test Layer",
98                                       self.open_shapefile("roads-line.shp"))
99            self.failUnless(layer.HasClassification())
100            self.failUnless(layer.HasShapes())
101          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
102          self.assertEquals(layer.NumShapes(), 839)          self.assertEquals(layer.NumShapes(), 839)
103          shape = layer.Shape(32)          shape = layer.Shape(32)
# Line 114  class TestLayer(unittest.TestCase, suppo Line 128  class TestLayer(unittest.TestCase, suppo
128          self.assertEquals(layer.ShapesBoundingBox([]), None)          self.assertEquals(layer.ShapesBoundingBox([]), None)
129          self.assertEquals(layer.ShapesBoundingBox(None), None)          self.assertEquals(layer.ShapesBoundingBox(None), None)
130    
         layer.Destroy()  
   
131      def test_polygon_layer(self):      def test_polygon_layer(self):
132          """Test Layer with polygon shapes"""          """Test Layer with polygon shapes"""
133          layer = Layer("Test Layer", self.open_shapefile("political.shp"))          layer = self.layer = Layer("Test Layer",
134                                       self.open_shapefile("political.shp"))
135            self.failUnless(layer.HasClassification())
136            self.failUnless(layer.HasShapes())
137          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)
138          self.assertEquals(layer.NumShapes(), 156)          self.assertEquals(layer.NumShapes(), 156)
139          shape = layer.Shape(4)          shape = layer.Shape(4)
# Line 132  class TestLayer(unittest.TestCase, suppo Line 147  class TestLayer(unittest.TestCase, suppo
147                                    -13.495815277099609, 66.563774108886719])                                    -13.495815277099609, 66.563774108886719])
148          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.9, 64.1)),          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.9, 64.1)),
149                            [91, 92, 144, 146, 148, 150, 152, 153])                            [91, 92, 144, 146, 148, 150, 152, 153])
         layer.Destroy()  
150    
151      def test_point_layer(self):      def test_point_layer(self):
152          """Test Layer with point shapes"""          """Test Layer with point shapes"""
153          layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
154                        self.open_shapefile("cultural_landmark-point.shp"))                             self.open_shapefile("cultural_landmark-point.shp"))
155            self.failUnless(layer.HasClassification())
156            self.failUnless(layer.HasShapes())
157          self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)
158          self.assertEquals(layer.NumShapes(), 34)          self.assertEquals(layer.NumShapes(), 34)
159          shape = layer.Shape(0)          shape = layer.Shape(0)
# Line 148  class TestLayer(unittest.TestCase, suppo Line 164  class TestLayer(unittest.TestCase, suppo
164                                    -15.12291431427002, 66.36572265625])                                    -15.12291431427002, 66.36572265625])
165          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.80, 64.1)),          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.80, 64.1)),
166                            [0, 1, 2, 3, 4, 5, 27, 28, 29, 30, 31])                            [0, 1, 2, 3, 4, 5, 27, 28, 29, 30, 31])
         layer.Destroy()  
167    
168      def test_empty_layer(self):      def test_empty_layer(self):
169          """Test Layer with empty shape file"""          """Test Layer with empty shape file"""
# Line 163  class TestLayer(unittest.TestCase, suppo Line 178  class TestLayer(unittest.TestCase, suppo
178          dbf.add_field("NAME", dbflib.FTString, 20, 0)          dbf.add_field("NAME", dbflib.FTString, 20, 0)
179    
180          # Now try to open it.          # Now try to open it.
181          layer = Layer("Empty Layer",          layer = self.layer = Layer("Empty Layer",
182                        self.session.OpenShapefile(shapefilename))                                     self.session.OpenShapefile(shapefilename))
183          self.assertEquals(layer.BoundingBox(), None)          self.assertEquals(layer.BoundingBox(), None)
184          self.assertEquals(layer.LatLongBoundingBox(), None)          self.assertEquals(layer.LatLongBoundingBox(), None)
185          self.assertEquals(layer.NumShapes(), 0)          self.assertEquals(layer.NumShapes(), 0)
         layer.Destroy()  
186    
187      def test_get_field_type(self):      def test_get_field_type(self):
188          """Test Layer.GetFieldType()"""          """Test Layer.GetFieldType()"""
189          layer = Layer("Test Layer", self.open_shapefile("roads-line.shp"))          layer = self.layer = Layer("Test Layer",
190                                       self.open_shapefile("roads-line.shp"))
191          self.assertEquals(layer.GetFieldType("LENGTH"), FIELDTYPE_DOUBLE)          self.assertEquals(layer.GetFieldType("LENGTH"), FIELDTYPE_DOUBLE)
192          self.assertEquals(layer.GetFieldType("non existing"), None)          self.assertEquals(layer.GetFieldType("non existing"), None)
         layer.Destroy()  
193    
194      def test_raster_layer(self):      def test_raster_layer(self):
195            if not Thuban.Model.resource.has_gdal_support():
196                return
197    
198          filename = self.build_path("island.tif")          filename = self.build_path("island.tif")
199          layer = RasterLayer("Test RasterLayer", filename)          layer = RasterLayer("Test RasterLayer", filename)
200            self.failIf(layer.HasClassification())
201            self.failIf(layer.HasShapes())
202          self.assertEquals(layer.GetImageFilename(), filename)          self.assertEquals(layer.GetImageFilename(), filename)
203          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
204                                   [-24.5500000, 63.2833330,                                   [-24.5500000, 63.2833330,
# Line 188  class TestLayer(unittest.TestCase, suppo Line 207  class TestLayer(unittest.TestCase, suppo
207                                   [-24.5500000, 63.2833330,                                   [-24.5500000, 63.2833330,
208                                    -13.4916670, 66.5666670])                                    -13.4916670, 66.5666670])
209    
210        def test_derived_store(self):
211            """Test layer with derived store"""
212            layer = self.layer = Layer("Test Layer",
213                                       self.open_shapefile("roads-line.shp"))
214            try:
215                store = layer.ShapeStore()
216                derived = DerivedShapeStore(store, store.Table())
217                layer.SetShapeStore(derived)
218                self.assert_(layer.ShapeStore() is derived)
219    
220                # check that an exception is raised when the number
221                # of shapes differ from the number of rows in a table.
222                layer2 = Layer("Test Layer",
223                               self.open_shapefile("political.shp"))
224                store2 = layer2.ShapeStore()
225                self.assertRaises(ValueError,
226                                  DerivedShapeStore, store2, store.Table())
227    
228            finally:
229                store = derived = None
230                layer2.Destroy()
231                store2 = None
232    
233  class TestLayerLegend(unittest.TestCase, support.SubscriberMixin):  
234    class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):
235    
236        def setUp(self):
237            """Create a layer with a classification as self.layer"""
238            self.clear_messages()
239            self.session = Session("Test session for %s" % self.__class__)
240            self.shapefilename = os.path.join("..", "Data", "iceland",
241                                              "cultural_landmark-point.dbf")
242            self.store = self.session.OpenShapefile(self.shapefilename)
243            self.layer = Layer("test layer", self.store)
244            self.classification = Classification()
245            self.classification.AppendGroup(ClassGroupSingleton("FARM"))
246            self.layer.SetClassificationColumn("CLPTLABEL")
247            self.layer.SetClassification(self.classification)
248            self.layer.UnsetModified()
249            self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,
250                                 self.subscribe_with_params,
251                                 LAYER_SHAPESTORE_REPLACED)
252            self.layer.Subscribe(LAYER_CHANGED,
253                                 self.subscribe_with_params, LAYER_CHANGED)
254    
255        def tearDown(self):
256            self.clear_messages()
257            self.layer.Destroy()
258            self.session.Destroy()
259            self.session = self.layer = self.store = self.classification = None
260    
261        def test_sanity(self):
262            """SetShapeStoreTests sanity check
263    
264            Test the initial state of the test case instances after setUp.
265            """
266            cls = self.layer.GetClassification()
267            self.assert_(cls is self.classification)
268            field = self.layer.GetClassificationColumn()
269            self.assertEquals(field, "CLPTLABEL")
270            self.assertEquals(self.layer.GetFieldType(field), FIELDTYPE_STRING)
271            self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)
272            self.failIf(self.layer.WasModified())
273    
274        def test_set_shape_store_modified_flag(self):
275            """Test whether Layer.SetShapeStore() sets the modified flag"""
276            memtable = MemoryTable([("FOO", FIELDTYPE_STRING)],
277                          [("bla",)] * self.layer.ShapeStore().Table().NumRows())
278            self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
279    
280            self.assert_(self.layer.WasModified())
281    
282        def test_set_shape_store_different_field_name(self):
283            """Test Layer.SetShapeStore() with different column name"""
284            memtable = MemoryTable([("FOO", FIELDTYPE_STRING)],
285                          [("bla",)] * self.layer.ShapeStore().Table().NumRows())
286            self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
287            # The classification should contain only the default group now.
288            self.assertEquals(self.layer.GetClassification().GetNumGroups(), 0)
289            self.check_messages([(self.layer, LAYER_CHANGED),
290                                 (self.layer, LAYER_SHAPESTORE_REPLACED)])
291    
292        def test_set_shape_store_same_field(self):
293            """Test Layer.SetShapeStore() with same column name and type"""
294            memtable = MemoryTable([("CLPTLABEL", FIELDTYPE_STRING)],
295                          [("bla",)] * self.layer.ShapeStore().Table().NumRows())
296            self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
297            # The classification should be the same as before
298            self.assert_(self.layer.GetClassification() is self.classification)
299            self.check_messages([(self.layer, LAYER_SHAPESTORE_REPLACED)])
300    
301        def test_set_shape_store_same_field_different_type(self):
302            """Test Layer.SetShapeStore() with same column name but different type
303            """
304            memtable = MemoryTable([("CLPTLABEL", FIELDTYPE_DOUBLE)],
305                          [(0.0,)] * self.layer.ShapeStore().Table().NumRows())
306            self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
307            # The classification should contain only the default group now.
308            self.assertEquals(self.layer.GetClassification().GetNumGroups(), 0)
309            self.check_messages([(self.layer, LAYER_CHANGED),
310                                 (self.layer, LAYER_SHAPESTORE_REPLACED)])
311    
312    
313    class TestLayerModification(unittest.TestCase, support.SubscriberMixin):
314    
315      """Test cases for Layer method that modify the layer.      """Test cases for Layer method that modify the layer.
316      """      """
# Line 209  class TestLayerLegend(unittest.TestCase, Line 330  class TestLayerLegend(unittest.TestCase,
330          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
331                               self.subscribe_with_params,                               self.subscribe_with_params,
332                               LAYER_VISIBILITY_CHANGED)                               LAYER_VISIBILITY_CHANGED)
333            self.layer.Subscribe(LAYER_CHANGED, self.subscribe_with_params,
334                                 LAYER_CHANGED)
335    
336      def tearDown(self):      def tearDown(self):
337          """Clear the list of received messages and explictly destroy self.layer          """Clear the list of received messages and explictly destroy self.layer
# Line 219  class TestLayerLegend(unittest.TestCase, Line 342  class TestLayerLegend(unittest.TestCase,
342          self.session = None          self.session = None
343          self.clear_messages()          self.clear_messages()
344    
345      def test_initial_settings(self):      def test_sanity(self):
346          """Test Layer's initial legend attributes"""          """TestLayerModification Sanity Checks"""
347          # test default settings          # test default settings
348          self.failIf(self.layer.WasModified())          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)  
349          self.assertEquals(self.layer.Visible(), 1)          self.assertEquals(self.layer.Visible(), 1)
350          # no messages should have been produced          # no messages should have been produced
351          self.check_messages([])          self.check_messages([])
# Line 240  class TestLayerLegend(unittest.TestCase, Line 360  class TestLayerLegend(unittest.TestCase,
360          # the layer.          # the layer.
361          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
362    
363            def test_set_classification(self):
364            """Test Layer.SetClassification"""
365            classification = Classification()
366            classification.AppendGroup(ClassGroupRange((0.0, 0.1)))
367    
368            self.layer.SetClassification(classification)
369            self.layer.SetClassificationColumn("AREA")
370    
371            self.check_messages([(self.layer, LAYER_CHANGED),
372                                 (self.layer, LAYER_CHANGED)])
373            self.failUnless(self.layer.WasModified())
374    
375            self.clear_messages()
376            self.layer.UnsetModified()
377    
378            # change only the classification column. This should issue a
379            # LAYER_CHANGED message as well.
380            self.layer.SetClassificationColumn("PERIMETER")
381    
382            self.check_messages([(self.layer, LAYER_CHANGED)])
383            self.failUnless(self.layer.WasModified())
384    
385    
386  #  #
387  # the tree info now contains Color objects which are difficult to test  # the tree info now contains Color objects which are difficult to test
388  #  #
Legend:
Removed from v.947  
changed lines
  Added in v.1452
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26