/[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 1262 by jonathan, Fri Jun 20 14:15:30 2003 UTC revision 2562 by jonathan, Wed Feb 16 21:14:47 2005 UTC
# Line 1  Line 1 
1  # Copyright (c) 2002, 2003 by Intevation GmbH  # Copyright (c) 2002, 2003, 2004 by Intevation GmbH
2  # Authors:  # Authors:
3  # Bernhard Herzog <[email protected]>  # Bernhard Herzog <[email protected]>
4  #  #
# Line 16  __version__ = "$Revision$" Line 16  __version__ = "$Revision$"
16  import os  import os
17  import unittest  import unittest
18    
19    import mockgeo
20  import support  import support
21  support.initthuban()  support.initthuban()
22    
# Line 23  import shapelib Line 24  import shapelib
24  import dbflib  import dbflib
25    
26  from Thuban.Model.session import Session  from Thuban.Model.session import Session
27  from Thuban.Model.layer import BaseLayer, Layer, RasterLayer, \  from Thuban.Model.layer import BaseLayer, Layer, RasterLayer
28       SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT  from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT
29  from Thuban.Model.messages import LAYER_LEGEND_CHANGED, \  from Thuban.Model.messages import LAYER_LEGEND_CHANGED, \
30       LAYER_VISIBILITY_CHANGED, LAYER_SHAPESTORE_REPLACED, LAYER_CHANGED       LAYER_VISIBILITY_CHANGED, LAYER_SHAPESTORE_REPLACED, LAYER_CHANGED
 from Thuban.Model.color import Color  
31  from Thuban.Model.table import FIELDTYPE_DOUBLE, FIELDTYPE_STRING, MemoryTable  from Thuban.Model.table import FIELDTYPE_DOUBLE, FIELDTYPE_STRING, MemoryTable
32  from Thuban.Model.proj import Projection  from Thuban.Model.proj import Projection
33  from Thuban.Model.data import DerivedShapeStore  from Thuban.Model.data import DerivedShapeStore
34  from Thuban.Model.classification import Classification, ClassGroupSingleton  from Thuban.Model.classification import Classification, ClassGroupSingleton, \
35         ClassGroupRange
36    from Thuban.Model.color import Color
37    
38  import Thuban.Model.resource  import Thuban.Model.resource
39    
# Line 40  class TestLayer(unittest.TestCase, suppo Line 42  class TestLayer(unittest.TestCase, suppo
42    
43      """Test cases for different layer (shape) types"""      """Test cases for different layer (shape) types"""
44    
     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])  
   
45      def setUp(self):      def setUp(self):
46          """Create a session self.session and initialize self.layer to None"""          """Create a session self.session and initialize self.layer to None"""
47          self.session = Session("Test session for %s" % self.__class__)          self.session = Session("Test session for %s" % self.__class__)
# Line 52  class TestLayer(unittest.TestCase, suppo Line 49  class TestLayer(unittest.TestCase, suppo
49    
50      def tearDown(self):      def tearDown(self):
51          """Call the layer's Destroy method and set session and layer to None"""          """Call the layer's Destroy method and set session and layer to None"""
52            self.session.Destroy()
53          self.session = None          self.session = None
54          if self.layer is not None:          if self.layer is not None:
55              self.layer.Destroy()              self.layer.Destroy()
# Line 77  class TestLayer(unittest.TestCase, suppo Line 75  class TestLayer(unittest.TestCase, suppo
75          self.failUnless(layer.Visible())          self.failUnless(layer.Visible())
76    
77          self.failIf(layer.HasClassification())          self.failIf(layer.HasClassification())
78            self.failIf(layer.HasShapes())
79    
80          self.assertEquals(layer.GetProjection(), None)          self.assertEquals(layer.GetProjection(), None)
81    
82          # set/get projection          # set/get projection
83          proj = Projection(["proj=utm", "zone=26"])          proj = Projection(["proj=utm", "zone=26", "ellps=clrk66"])
84    
85          layer.SetProjection(proj)          layer.SetProjection(proj)
86          self.failUnless(layer.GetProjection() is proj)          self.failUnless(layer.GetProjection() is proj)
# Line 94  class TestLayer(unittest.TestCase, suppo Line 94  class TestLayer(unittest.TestCase, suppo
94          """Test Layer with arc shapes"""          """Test Layer with arc shapes"""
95          layer = self.layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
96                                     self.open_shapefile("roads-line.shp"))                                     self.open_shapefile("roads-line.shp"))
97            self.failUnless(layer.HasClassification())
98            self.failUnless(layer.HasShapes())
99          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
100          self.assertEquals(layer.NumShapes(), 839)          self.assertEquals(layer.NumShapes(), 839)
101          shape = layer.Shape(32)          shape = layer.Shape(32)
102          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
103                                      [(-15.082174301147461, 66.27738189697265),                                     [[(-15.082174301147461, 66.27738189697265),
104                                       (-15.026350021362305, 66.27339172363281)])                                       (-15.026350021362305, 66.27339172363281)]])
105          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
106                                   [-24.450359344482422, 63.426830291748047,                                   [-24.450359344482422, 63.426830291748047,
107                                    -13.55668830871582, 66.520111083984375])                                    -13.55668830871582, 66.520111083984375])
108          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25)),          shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
109            self.assertEquals([s.ShapeID() for s in shapes],
110                            [613, 726, 838])                            [613, 726, 838])
111    
112          self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),          self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
# Line 111  class TestLayer(unittest.TestCase, suppo Line 114  class TestLayer(unittest.TestCase, suppo
114                             -15.026350021362305, 66.27738189697265])                             -15.026350021362305, 66.27738189697265])
115    
116          shape = layer.Shape(33)          shape = layer.Shape(33)
117          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
118                                      [(-22.248506546020508, 66.30645751953125),                                     [[(-22.24850654602050, 66.30645751953125),
119                                       (-22.232730865478516, 66.294075012207031),                                       (-22.23273086547851, 66.29407501220703),
120                                       (-22.23158073425293,  66.287689208984375),                                       (-22.23158073425293,  66.2876892089843),
121                                       (-22.246318817138672, 66.270065307617188)])                                       (-22.24631881713867, 66.27006530761718)]])
122    
123          self.assertFloatSeqEqual(layer.ShapesBoundingBox([32, 33]),          self.assertFloatSeqEqual(layer.ShapesBoundingBox([32, 33]),
124                                   [-22.248506546020508, 66.270065307617188,                                   [-22.248506546020508, 66.270065307617188,
# Line 128  class TestLayer(unittest.TestCase, suppo Line 131  class TestLayer(unittest.TestCase, suppo
131          """Test Layer with polygon shapes"""          """Test Layer with polygon shapes"""
132          layer = self.layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
133                                     self.open_shapefile("political.shp"))                                     self.open_shapefile("political.shp"))
134            self.failUnless(layer.HasClassification())
135            self.failUnless(layer.HasShapes())
136          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)
137          self.assertEquals(layer.NumShapes(), 156)          self.assertEquals(layer.NumShapes(), 156)
138          shape = layer.Shape(4)          shape = layer.Shape(4)
139          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
140                                      [(-22.406391143798828, 64.714111328125),                                     [[(-22.40639114379882, 64.714111328125),
141                                       (-22.41621208190918, 64.71600341796875),                                       (-22.41621208190918, 64.7160034179687),
142                                       (-22.406051635742188, 64.719200134277344),                                       (-22.40605163574218, 64.719200134277),
143                                       (-22.406391143798828, 64.714111328125)])                                       (-22.40639114379882, 64.714111328125)]])
144          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
145                                   [-24.546524047851562, 63.286754608154297,                                   [-24.546524047851562, 63.286754608154297,
146                                    -13.495815277099609, 66.563774108886719])                                    -13.495815277099609, 66.563774108886719])
147          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.9, 64.1)),          shapes = layer.ShapesInRegion((-24.0, 64.0, -23.9, 64.1))
148            self.assertEquals([s.ShapeID() for s in shapes],
149                            [91, 92, 144, 146, 148, 150, 152, 153])                            [91, 92, 144, 146, 148, 150, 152, 153])
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 = self.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)
160          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
161                                      [(-22.711074829101562, 66.36572265625)])                                     [[(-22.711074829101562, 66.36572265625)]])
162          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
163                                   [-23.806047439575195, 63.405960083007812,                                   [-23.806047439575195, 63.405960083007812,
164                                    -15.12291431427002, 66.36572265625])                                    -15.12291431427002, 66.36572265625])
165          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.80, 64.1)),          shapes = layer.ShapesInRegion((-24.0, 64.0, -23.80, 64.1))
166            self.assertEquals([s.ShapeID() for s in shapes],
167                            [0, 1, 2, 3, 4, 5, 27, 28, 29, 30, 31])                            [0, 1, 2, 3, 4, 5, 27, 28, 29, 30, 31])
168    
169        def test_arc_layer_with_projection(self):
170            """Test Layer with point shapes and a projection"""
171            # We use mock data here so that we have precise control over the
172            # values
173            table = MemoryTable([("FOO", FIELDTYPE_STRING)], [("bla",)])
174            store = mockgeo.SimpleShapeStore(SHAPETYPE_ARC,
175                                  [[[(9884828.7209840547, 5607720.9774499247),
176                                     (11298336.04640449, 9287823.2044059951)]]],
177                                             table)
178            layer = self.layer = Layer("Test Layer", store)
179    
180            proj = Projection(["proj=lcc", "lon_0=0", "lat_1=20n", "lat_2=60n",
181                               "ellps=clrk66"])
182            layer.SetProjection(proj)
183    
184            self.assertFloatSeqEqual(layer.BoundingBox(),
185                                     (9884828.7209840547, 5607720.9774499247,
186                                      11298336.04640449, 9287823.2044059951))
187            self.assertFloatSeqEqual(layer.LatLongBoundingBox(),
188                                     (90.0, -8.90043373, 120, 11.1616263))
189            shapes = layer.ShapesInRegion((100, -10, 150, +10))
190            self.assertEquals([s.ShapeID() for s in shapes], [0])
191            self.assertFloatSeqEqual(layer.ShapesBoundingBox([0]),
192                                     (90.0, -8.90043373, 120, 11.1616263))
193    
194            self.assertFloatSeqEqual(layer.ClipBoundingBox((-180, -6, 100, +120)),
195                                     (90.0, -6, 100, 11.1616263))
196            shapes = layer.ShapesInRegion((-180, -170, 200, +120))
197            self.assertEquals([s.ShapeID() for s in shapes],[0])
198    
199      def test_empty_layer(self):      def test_empty_layer(self):
200          """Test Layer with empty shape file"""          """Test Layer with empty shape file"""
201          # create an empty shape file          # create an empty shape file
# Line 168  class TestLayer(unittest.TestCase, suppo Line 207  class TestLayer(unittest.TestCase, suppo
207          dbffilename = self.temp_file_name("layer_empty.dbf")          dbffilename = self.temp_file_name("layer_empty.dbf")
208          dbf = dbflib.create(dbffilename)          dbf = dbflib.create(dbffilename)
209          dbf.add_field("NAME", dbflib.FTString, 20, 0)          dbf.add_field("NAME", dbflib.FTString, 20, 0)
210            dbf.close()
211    
212          # Now try to open it.          # Now try to open it.
213          layer = self.layer = Layer("Empty Layer",          layer = self.layer = Layer("Empty Layer",
# Line 185  class TestLayer(unittest.TestCase, suppo Line 225  class TestLayer(unittest.TestCase, suppo
225    
226      def test_raster_layer(self):      def test_raster_layer(self):
227          if not Thuban.Model.resource.has_gdal_support():          if not Thuban.Model.resource.has_gdal_support():
228              return              raise support.SkipTest("No gdal support")
229    
230          filename = self.build_path("island.tif")          filename = self.build_path("island.tif")
231          layer = RasterLayer("Test RasterLayer", filename)          layer = RasterLayer("Test RasterLayer", filename)
232          self.assertEquals(layer.GetImageFilename(), filename)          self.failIf(layer.HasClassification())
233            self.failIf(layer.HasShapes())
234            self.assertEquals(layer.MaskType(), layer.MASK_BIT)
235            self.assertEquals(layer.GetImageFilename(), os.path.abspath(filename))
236          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
237                                   [-24.5500000, 63.2833330,                                   [-24.5500000, 63.2833330,
238                                    -13.4916670, 66.5666670])                                    -13.4916670, 66.5666670])
# Line 197  class TestLayer(unittest.TestCase, suppo Line 240  class TestLayer(unittest.TestCase, suppo
240                                   [-24.5500000, 63.2833330,                                   [-24.5500000, 63.2833330,
241                                    -13.4916670, 66.5666670])                                    -13.4916670, 66.5666670])
242    
243            info = layer.ImageInfo()
244            self.failIf(info is None)
245            self.failUnless(info.has_key("nBands"))
246            self.failUnless(info.has_key("Size"))
247            self.failUnless(info.has_key("Driver"))
248            self.failUnless(info.has_key("BandData"))
249    
250            self.assertEquals(info["nBands"], 1)
251            self.assertEquals(info["Size"], (5002, 394))
252            self.assertEquals(info["Driver"], "GTiff")
253            self.assertEquals(info["BandData"], [(0.0, 140.0)])
254    
255      def test_derived_store(self):      def test_derived_store(self):
256          """Test layer with derived store"""          """Test layer with derived store"""
257          layer = self.layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
# Line 207  class TestLayer(unittest.TestCase, suppo Line 262  class TestLayer(unittest.TestCase, suppo
262              layer.SetShapeStore(derived)              layer.SetShapeStore(derived)
263              self.assert_(layer.ShapeStore() is derived)              self.assert_(layer.ShapeStore() is derived)
264    
265              # check that an exception is raised when the number              self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
266              # of shapes differ from the number of rows in a table.              self.assertEquals(layer.NumShapes(), 839)
267              layer2 = Layer("Test Layer",              shape = layer.Shape(32)
268                             self.open_shapefile("political.shp"))              self.assertPointListEquals(shape.Points(),
269              store2 = layer2.ShapeStore()                                         [[(-15.082174301147, 66.277381896972),
270              self.assertRaises(ValueError,                                           (-15.026350021362, 66.273391723632)]])
271                                DerivedShapeStore, store2, store.Table())              self.assertFloatSeqEqual(layer.BoundingBox(),
272                                         [-24.450359344482422, 63.426830291748047,
273                                          -13.55668830871582, 66.520111083984375])
274                shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
275                self.assertEquals([s.ShapeID() for s in shapes],
276                                  [613, 726, 838])
277    
278                self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
279                                         [-15.082174301147461, 66.27339172363281,
280                                          -15.026350021362305, 66.27738189697265])
281    
282          finally:          finally:
283              store = derived = None              store = derived = None
             layer2.Destroy()  
             store2 = None  
284    
285    
286  class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):  class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):
# Line 231  class SetShapeStoreTests(unittest.TestCa Line 293  class SetShapeStoreTests(unittest.TestCa
293                                            "cultural_landmark-point.dbf")                                            "cultural_landmark-point.dbf")
294          self.store = self.session.OpenShapefile(self.shapefilename)          self.store = self.session.OpenShapefile(self.shapefilename)
295          self.layer = Layer("test layer", self.store)          self.layer = Layer("test layer", self.store)
296          self.classification = Classification(field = "CLPTLABEL")          self.classification = Classification()
297          self.classification.AppendGroup(ClassGroupSingleton("FARM"))          self.classification.AppendGroup(ClassGroupSingleton("FARM"))
298            self.layer.SetClassificationColumn("CLPTLABEL")
299          self.layer.SetClassification(self.classification)          self.layer.SetClassification(self.classification)
300          self.layer.UnsetModified()          self.layer.UnsetModified()
301          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,
# Line 254  class SetShapeStoreTests(unittest.TestCa Line 317  class SetShapeStoreTests(unittest.TestCa
317          """          """
318          cls = self.layer.GetClassification()          cls = self.layer.GetClassification()
319          self.assert_(cls is self.classification)          self.assert_(cls is self.classification)
320          self.assertEquals(cls.GetField(), "CLPTLABEL")          field = self.layer.GetClassificationColumn()
321          self.assertEquals(cls.GetFieldType(), FIELDTYPE_STRING)          self.assertEquals(field, "CLPTLABEL")
322            self.assertEquals(self.layer.GetFieldType(field), FIELDTYPE_STRING)
323          self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)          self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)
324          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
325    
# Line 298  class SetShapeStoreTests(unittest.TestCa Line 362  class SetShapeStoreTests(unittest.TestCa
362                               (self.layer, LAYER_SHAPESTORE_REPLACED)])                               (self.layer, LAYER_SHAPESTORE_REPLACED)])
363    
364    
365  class TestLayerLegend(unittest.TestCase, support.SubscriberMixin):  class TestLayerModification(unittest.TestCase, support.SubscriberMixin):
366    
367      """Test cases for Layer method that modify the layer.      """Test cases for Layer method that modify the layer.
368      """      """
# Line 310  class TestLayerLegend(unittest.TestCase, Line 374  class TestLayerLegend(unittest.TestCase,
374          """          """
375          self.clear_messages()          self.clear_messages()
376          self.session = Session("Test session for %s" % self.__class__)          self.session = Session("Test session for %s" % self.__class__)
377          filename = os.path.join("..", "Data", "iceland", "political.shp")          self.filename = os.path.join("..", "Data", "iceland", "political.shp")
378          self.layer = Layer("Test Layer",          self.layer = Layer("Test Layer",
379                             self.session.OpenShapefile(filename))                             self.session.OpenShapefile(self.filename))
380          self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,          self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,
381                               LAYER_LEGEND_CHANGED)                               LAYER_LEGEND_CHANGED)
382          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
383                               self.subscribe_with_params,                               self.subscribe_with_params,
384                               LAYER_VISIBILITY_CHANGED)                               LAYER_VISIBILITY_CHANGED)
385            self.layer.Subscribe(LAYER_CHANGED, self.subscribe_with_params,
386                                 LAYER_CHANGED)
387    
388      def tearDown(self):      def tearDown(self):
389          """Clear the list of received messages and explictly destroy self.layer          """Clear the list of received messages and explictly destroy self.layer
# Line 328  class TestLayerLegend(unittest.TestCase, Line 394  class TestLayerLegend(unittest.TestCase,
394          self.session = None          self.session = None
395          self.clear_messages()          self.clear_messages()
396    
397      def test_initial_settings(self):      def build_path(self, filename):
398          """Test Layer's initial legend attributes"""          return os.path.join("..", "Data", "iceland", filename)
399    
400        def test_sanity(self):
401            """TestLayerModification Sanity Checks"""
402          # test default settings          # test default settings
403          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)  
404          self.assertEquals(self.layer.Visible(), 1)          self.assertEquals(self.layer.Visible(), 1)
405          # no messages should have been produced          # no messages should have been produced
406          self.check_messages([])          self.check_messages([])
# Line 349  class TestLayerLegend(unittest.TestCase, Line 415  class TestLayerLegend(unittest.TestCase,
415          # the layer.          # the layer.
416          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
417    
418            def test_set_classification(self):
419  #          """Test Layer.SetClassification"""
420  # the tree info now contains Color objects which are difficult to test          classification = Classification()
421  #          classification.AppendGroup(ClassGroupRange((0.0, 0.1)))
422  #   def test_tree_info(self):  
423  #       """Test Layer.TreeInfo"""          self.layer.SetClassification(classification)
424  #       self.assertEquals(self.layer.TreeInfo(),          self.layer.SetClassificationColumn("AREA")
425  #                         ("Layer 'Test Layer'",  
426  #                          ['Shown',          self.check_messages([(self.layer, LAYER_CHANGED),
427  #                           'Shapes: 156',                               (self.layer, LAYER_CHANGED)])
428  #                           ('Extent (lat-lon):'          self.failUnless(self.layer.WasModified())
429  #                            ' (-24.5465, 63.2868, -13.4958, 66.5638)'),  
430  #                           'Shapetype: Polygon',          self.clear_messages()
431  #                           'Fill: None',          self.layer.UnsetModified()
432  #                           'Outline: (0.000, 0.000, 0.000)']))  
433            # change only the classification column. This should issue a
434            # LAYER_CHANGED message as well.
435            self.layer.SetClassificationColumn("PERIMETER")
436    
437            self.check_messages([(self.layer, LAYER_CHANGED)])
438            self.failUnless(self.layer.WasModified())
439    
440    
441        def test_tree_info(self):
442            """Test Layer.TreeInfo"""
443            self.assertEquals(self.layer.TreeInfo(),
444                              ("Layer 'Test Layer'",
445                               ['Filename: %s' % os.path.abspath(self.filename),
446                                'Shown',
447                                'Shapes: 156',
448                       'Extent (lat-lon): (-24.5465, 63.2868, -13.4958, 66.5638)',
449                                'Shapetype: Polygon',
450                                self.layer.GetClassification()]))
451    
452        def test_raster_layer(self):
453            if not Thuban.Model.resource.has_gdal_support():
454                raise support.SkipTest("No gdal support")
455    
456    
457            filename = self.build_path("island.tif")
458            layer = RasterLayer("Test RasterLayer", filename)
459    
460            layer.Subscribe(LAYER_CHANGED, self.subscribe_with_params,
461                            LAYER_CHANGED)
462    
463            self.assertEquals(layer.MaskType(), layer.MASK_BIT)
464    
465            layer.SetMaskType(layer.MASK_NONE)
466            self.failIf(layer.MaskType() != layer.MASK_NONE)
467            self.check_messages([(layer, LAYER_CHANGED)])
468            self.clear_messages()
469    
470            layer.SetMaskType(layer.MASK_NONE)
471            self.failIf(layer.MaskType() != layer.MASK_NONE)
472            self.check_messages([])
473            self.clear_messages()
474    
475            layer.SetMaskType(layer.MASK_BIT)
476            self.failIf(layer.MaskType() != layer.MASK_BIT)
477            self.check_messages([(layer, LAYER_CHANGED)])
478            self.clear_messages()
479    
480            layer.SetMaskType(layer.MASK_BIT)
481            self.failIf(layer.MaskType() != layer.MASK_BIT)
482            self.check_messages([])
483            self.clear_messages()
484    
485            layer.SetMaskType(layer.MASK_ALPHA)
486            self.failIf(layer.MaskType() != layer.MASK_ALPHA)
487    
488            layer.SetAlphaOpacity(0)
489            self.assertEquals(layer.AlphaOpacity(), 0)
490            layer.SetAlphaOpacity(0.5)
491            self.assertEquals(layer.AlphaOpacity(), 0.5)
492            layer.SetAlphaOpacity(1)
493            self.assertEquals(layer.AlphaOpacity(), 1)
494    
495            self.assertRaises(ValueError, layer.SetAlphaOpacity, -0.1)
496            self.assertRaises(ValueError, layer.SetAlphaOpacity, 1.1)
497    
498            layer.SetMaskType(layer.MASK_NONE)
499            self.assertEquals(layer.AlphaOpacity(), None)
500    
501            self.assertRaises(ValueError, layer.SetMaskType, -1)
502            self.assertRaises(ValueError, layer.SetMaskType, 4)
503    
504    
505  if __name__ == "__main__":  if __name__ == "__main__":
Legend:
Removed from v.1262  
changed lines
  Added in v.2562
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26