pygrass raster: Modified several tests and added some new, now all tests are location independent

git-svn-id: https://svn.osgeo.org/grass/grass/trunk@66059 15284696-431f-4ddb-bdfa-cd5b030d7da7

lib/python/pygrass/raster/__init__.py

@@ -79,7 +79,7 @@ class RasterRow(RasterAbstractBase):
         >>> elev.info.rows
         4
 
-	Editing the history
+        Editing the history
 
         >>> elev.hist.read()
         >>> elev.hist.title = "A test map"
@@ -98,22 +98,22 @@ class RasterRow(RasterAbstractBase):
         ...
          ('P', 44, None)]
 
-	>>> elev.cats.labels() # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
-	['A', 'B', 'C', 'D', 'E', 
+        >>> elev.cats.labels() # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+        ['A', 'B', 'C', 'D', 'E', 
          'F', 'G', 'H', 'I', 'J', 
          'K', 'L', 'M', 'n', 'O', 'P']
-	>>> elev.cats[0]
-	('A', 11, None)
-	>>> elev.cats[2]
-	('C', 13, None)
-	>>> elev.cats[0] = ('AA', 11)
-	>>> elev.cats[1] = ('BB', 12)
-	>>> elev.cats.write()
-	>>> elev.cats.read()
-	>>> elev.cats[0]
-	('AA', 11, None)
-	>>> elev.cats[1]
-	('BB', 12, None)
+        >>> elev.cats[0]
+        ('A', 11, None)
+        >>> elev.cats[2]
+        ('C', 13, None)
+        >>> elev.cats[0] = ('AA', 11)
+        >>> elev.cats[1] = ('BB', 12)
+        >>> elev.cats.write()
+        >>> elev.cats.read()
+        >>> elev.cats[0]
+        ('AA', 11, None)
+        >>> elev.cats[1]
+        ('BB', 12, None)
 
         Open a raster map using the *with statement*:
 
@@ -266,14 +266,14 @@ class RasterRowIO(RasterRow):
         :type row_buffer: Buffer object
 
             >>> elev = RasterRowIO(test_raster_name)
-	    >>> elev.open('r')
+            >>> elev.open('r')
             >>> for row in elev:
             ...     row
             Buffer([11, 21, 31, 41], dtype=int32)
             Buffer([12, 22, 32, 42], dtype=int32)
             Buffer([13, 23, 33, 43], dtype=int32)
             Buffer([14, 24, 34, 44], dtype=int32)
-	
+        
             >>> elev.close()
 
         """
@@ -366,14 +366,14 @@ class RasterSegment(RasterAbstractBase):
         :type row_buffer: Buffer object
 
             >>> elev = RasterRowIO(test_raster_name)
-	    >>> elev.open('r')
+            >>> elev.open('r')
             >>> for row in elev:
             ...     row
             Buffer([11, 21, 31, 41], dtype=int32)
             Buffer([12, 22, 32, 42], dtype=int32)
             Buffer([13, 23, 33, 43], dtype=int32)
             Buffer([14, 24, 34, 44], dtype=int32)
-	
+        
             >>> elev.close()
 
 
@@ -397,14 +397,14 @@ class RasterSegment(RasterAbstractBase):
             :param row: a Row object to insert into raster
             :type row: Buffer object
 
-	    Input and output must have the same type in case of row copy
+            Input and output must have the same type in case of row copy
 
             >>> map_a = RasterSegment(test_raster_name)
             >>> map_b = RasterSegment(test_raster_name + "_segment")
-	    >>> map_a.open('r')
-	    >>> map_b.open('w', mtype="CELL", overwrite=True)
+            >>> map_a.open('r')
+            >>> map_b.open('w', mtype="CELL", overwrite=True)
             >>> for row in xrange(map_a.info.rows):
-	    ...     map_b[row] = map_a[row] + 1000
+            ...     map_b[row] = map_a[row] + 1000
             >>> map_a.close()
             >>> map_b.close()
 
@@ -412,11 +412,11 @@ class RasterSegment(RasterAbstractBase):
             >>> map_b.open("r")
             >>> for row in map_b:
             ...         row
-	    Buffer([1011, 1021, 1031, 1041], dtype=int32)
-	    Buffer([1012, 1022, 1032, 1042], dtype=int32)
-	    Buffer([1013, 1023, 1033, 1043], dtype=int32)
-	    Buffer([1014, 1024, 1034, 1044], dtype=int32)
-	    >>> map_b.close()
+            Buffer([1011, 1021, 1031, 1041], dtype=int32)
+            Buffer([1012, 1022, 1032, 1042], dtype=int32)
+            Buffer([1013, 1023, 1033, 1043], dtype=int32)
+            Buffer([1014, 1024, 1034, 1044], dtype=int32)
+            >>> map_b.close()
 
         """
         self.segment.put_row(row, row_buffer)
@@ -432,10 +432,10 @@ class RasterSegment(RasterAbstractBase):
 
 
             >>> elev = RasterSegment(test_raster_name)
-	    >>> elev.open('r')
+            >>> elev.open('r')
             >>> for i in xrange(4):
             ...     elev.get(i,i)
-	    11
+            11
             22
             33
             44
@@ -468,8 +468,8 @@ class RasterSegment(RasterAbstractBase):
 
             >>> map_a = RasterSegment(test_raster_name)
             >>> map_b = RasterSegment(test_raster_name + "_segment")
-	    >>> map_a.open('r')
-	    >>> map_b.open('w', mtype="FCELL", overwrite=True)
+            >>> map_a.open('r')
+            >>> map_b.open('w', mtype="FCELL", overwrite=True)
             >>> for row in xrange(map_a.info.rows):
             ...     for col in xrange(map_a.info.cols):
             ...         value = map_a.get(row,col)
@@ -481,11 +481,11 @@ class RasterSegment(RasterAbstractBase):
             >>> map_b.open("r")
             >>> for row in map_b:
             ...         row
-	    Buffer([ 111.,  121.,  131.,  141.], dtype=float32)
-	    Buffer([ 112.,  122.,  132.,  142.], dtype=float32)
-	    Buffer([ 113.,  123.,  133.,  143.], dtype=float32)
-	    Buffer([ 114.,  124.,  134.,  144.], dtype=float32)
-	    >>> map_b.close()
+            Buffer([ 111.,  121.,  131.,  141.], dtype=float32)
+            Buffer([ 112.,  122.,  132.,  142.], dtype=float32)
+            Buffer([ 113.,  123.,  133.,  143.], dtype=float32)
+            Buffer([ 114.,  124.,  134.,  144.], dtype=float32)
+            >>> map_b.close()
 
         """
         self.segment.val.value = val

lib/python/pygrass/raster/category.py

@@ -50,18 +50,6 @@ class Category(list):
     Rast_copy_cats() <- This should be wrapped so that categories from an
     existing Python category class are copied.
 
-
-    >>> import grass.lib.raster as libraster
-    >>> import ctypes
-    >>> from grass.pygrass.raster.category import Category
-    >>> cats = Category('landuse')
-    >>> cats.read()
-    >>> cats.labels()                                     # doctest: +ELLIPSIS
-    ['undefined', 'developed', 'agriculture', ..., 'water', 'sediment']
-    >>> cats[0]
-    ('undefined', 0, None)
-    >>> cats[1]
-    ('developed', 1, None)
     """
     def __init__(self, name, mapset='', mtype='CELL', *args, **kargs):
         self.name = name

lib/python/pygrass/raster/history.py

@@ -37,6 +37,14 @@ class History(object):
     def __del__(self):
         """Rast_free_history"""
         pass
+        
+    def __eq__(self, hist):
+        attrs = ['name', 'mapset', 'mtype', 'creator', 'src1', 'src2',
+                 'keyword', 'date', 'title']
+        for attr in attrs:
+           if getattr(self, attr) != getattr(hist, attr):
+                return False
+        return True
 
     def __len__(self):
         return self.length()

lib/python/pygrass/raster/testsuite/test_category.py

@@ -13,10 +13,47 @@ from grass.pygrass.raster.category import Category
 from grass.script.core import tempfile
 
 
-class RasterCategoryTestCate(TestCase):
+class RasterCategoryTestCase(TestCase):
 
-    name = 'geology'
-    catsname = ''
+    name = "RasterCategoryTestCase_map"
+
+    @classmethod
+    def setUpClass(cls):
+        """Create test raster map and region"""
+        cls.use_temp_region()
+        cls.runModule("g.region", n=40, s=0, e=40, w=0, res=10)
+        cls.runModule("r.mapcalc", expression="%s = row() + (10.0 * col())"%(cls.name),
+                                   overwrite=True)
+        cls.runModule("r.support", map=cls.name,
+                        title="A test map",
+                        history="Generated by r.mapcalc",
+                        description="This is a test map")
+        cats="""11:A
+                12:B
+                13:C
+                14:D
+                21:E
+                22:F
+                23:G
+                24:H
+                31:I
+                32:J
+                33:K
+                34:L
+                41:M
+                42:n
+                43:O
+                44:P"""
+
+        cls.runModule("r.category", rules="-", map=cls.name,
+                                 stdin_=cats, separator=":")
+
+    @classmethod
+    def tearDownClass(cls):
+        """Remove the generated vector map, if exist"""
+        cls.runModule("g.remove", flags='f', type='raster', 
+                      name=cls.name)
+        cls.del_temp_region()
 
     def testCategory(self):
         r = RasterRow(self.name)
@@ -24,15 +61,18 @@ class RasterCategoryTestCate(TestCase):
         cats = r.cats
         cats1 = Category(self.name)
         cats1.read()
-        # this is not working, I don't know why
         self.assertEqual(cats, cats1)
         r.close()
 
     def testFirstCat(self):
-        cat0 = ('Zml', 1, None)
+        cat0 = ('A', 11, None)
+        cat7 = ('H', 24, None)
+        cat15 = ('P', 44, None)
         cats = Category(self.name)
         cats.read()
         self.assertEqual(cats[0], cat0)
+        self.assertEqual(cats[7], cat7)
+        self.assertEqual(cats[15], cat15)
 
     def testWrite(self):
         tmpfile = tempfile(False)

lib/python/pygrass/raster/testsuite/test_doctests.py

@@ -31,10 +31,42 @@ def load_tests(loader, tests, ignore):
     # for now it is the only place where it works
     grass.gunittest.utils.do_doctest_gettext_workaround()
     # this should be called at some top level
+
+
+    from grass.pygrass.modules import Module
+    Module("g.region", n=40, s=0, e=40, w=0, res=10)
+    Module("r.mapcalc", expression="%s = row() + (10 * col())"%\
+                                   (pgrass.test_raster_name),
+                             overwrite=True)
+    Module("r.support", map=pgrass.test_raster_name,
+                        title="A test map",
+                        history="Generated by r.mapcalc",
+                        description="This is a test map")
+    cats="""11:A
+            12:B
+            13:C
+            14:D
+            21:E
+            22:F
+            23:G
+            24:H
+            31:I
+            32:J
+            33:K
+            34:L
+            41:M
+            42:n
+            43:O
+            44:P"""
+    Module("r.category", rules="-", map=pgrass.test_raster_name,
+           stdin_=cats, separator=":")
+
+    Module("r.mapcalc", expression="%s = row() + (10 * col())"%\
+                                   (pgrass.abstract.test_raster_name),
+                             overwrite=True)
+
     tests.addTests(doctest.DocTestSuite(pgrass))
     tests.addTests(doctest.DocTestSuite(pgrass.abstract))
-    tests.addTests(doctest.DocTestSuite(pgrass.category))
-    tests.addTests(doctest.DocTestSuite(pgrass.history))
     return tests
 
 

lib/python/pygrass/raster/testsuite/test_history.py

@@ -14,21 +14,63 @@ from grass.pygrass.raster.history import History
 
 class RasterHistoryTestCate(TestCase):
 
-    name = 'geology'
+    name = "RasterCategoryTestCase_map"
+
+    @classmethod
+    def setUpClass(cls):
+        """Create test raster map and region"""
+        cls.use_temp_region()
+        cls.runModule("g.region", n=40, s=0, e=40, w=0, res=10)
+        cls.runModule("r.mapcalc", expression="%s = row() + (10 * col())"%(cls.name),
+                                   overwrite=True)
+        cls.runModule("r.support", map=cls.name,
+                        title="A test map",
+                        history="Generated by r.mapcalc",
+                        description="This is a test map")
+
+    @classmethod
+    def tearDownClass(cls):
+        """Remove the generated vector map, if exist"""
+        cls.runModule("g.remove", flags='f', type='raster', 
+                      name=cls.name)
+        cls.del_temp_region()
 
     def testHistory(self):
         r = RasterRow(self.name)
-        r.open()
+        r.open("r")
         hist = r.hist
+        
+        self.assertEqual(hist.title, "A test map")
+        self.assertEqual(hist.keyword,  "This is a test map")
+        
         hist1 = History(self.name)
         hist1.read()
-        # this is not working, I don't know why
-        #self.assertEqual(hist, hist1)
+
+        self.assertEqual(hist1.title, "A test map")
+        self.assertEqual(hist1.keyword,  "This is a test map")
+        
+        self.assertEqual(hist, hist1)
         self.assertEqual(hist.creator, hist1.creator)
-        hist1.creator = 'markus'
+        hist1.creator = "Markus"
         self.assertNotEqual(hist.creator, hist1.creator)
         r.close()
+        
+        hist1.title = "No such title"
+        hist1.keyword = "No such description"
+        hist1.src1 = "No such source 1"
+        hist1.src2 = "No such source 2"
+        hist1.write()
+        
+        r.open("r")
+        hist = r.hist
 
+        self.assertEqual(hist.title, "No such title")
+        self.assertEqual(hist.keyword,  "No such description")
+        self.assertEqual(hist.creator, "Markus")
+        self.assertEqual(hist.creator, "Markus")
+        self.assertEqual(hist.src1, "No such source 1")
+        self.assertEqual(hist.src2, "No such source 2")
+        r.close()
 
 if __name__ == '__main__':
     test()

lib/python/pygrass/raster/testsuite/test_numpy.py

@@ -22,34 +22,35 @@ def check_raster(name):
 
 class NumpyTestCase(TestCase):
 
+    name = "RasterRowTestCase_map"
+
     @classmethod
     def setUpClass(cls):
-        """Create a not empty table instance"""
-
-        cls.name = 'elevation'
-        cls.tmp = 'tmp' + cls.name
+        """Create test raster map and region"""
         cls.use_temp_region()
-        cls.runModule('g.region', raster=cls.name)
+        cls.runModule("g.region", n=40, s=0, e=60, w=0, res=1)
+        cls.runModule("r.mapcalc", expression="%s = float(row() + (10.0 * col()))"%(cls.name),
+                                   overwrite=True)
         cls.numpy_obj = raster2numpy(cls.name)
 
     @classmethod
     def tearDownClass(cls):
         """Remove the generated vector map, if exist"""
-        from grass.pygrass.modules.shortcuts import general as g
-        g.remove(type='raster', name=cls.tmp, flags='f')
+        cls.runModule("g.remove", flags='f', type='raster',
+                      name=cls.name)
         cls.del_temp_region()
 
     def test_type(self):
         self.assertTrue(str(self.numpy_obj.dtype), 'float32')
 
     def test_len(self):
-        self.assertTrue(len(self.numpy_obj), 1350)
-        self.assertTrue(len(self.numpy_obj[0]), 1500)
+        self.assertTrue(len(self.numpy_obj), 40)
+        self.assertTrue(len(self.numpy_obj[0]), 60)
 
     def test_write(self):
-        ran = random([1350, 1500])
-        numpy2raster(ran, 'FCELL', self.tmp, True)
-        self.assertTrue(check_raster(self.tmp))
+        ran = random([40, 60])
+        numpy2raster(ran, 'FCELL', self.name, True)
+        self.assertTrue(check_raster(self.name))
 
 if __name__ == '__main__':
     test()

lib/python/pygrass/raster/testsuite/test_raster.py

@@ -7,27 +7,29 @@ from unittest import skip
 from grass.pygrass.raster import RasterRow
 
 
-class RasterRowTestCate(TestCase):
+class RasterRowTestCase(TestCase):
+
+    name = "RasterRowTestCase_map"
 
     @classmethod
     def setUpClass(cls):
-        """Create a not empty table instance"""
-        from grass.pygrass.modules.shortcuts import general as g
-
-        cls.name = 'elevation'
-        cls.tmp = 'tmp' + cls.name
-        g.copy(raster=[cls.name, cls.tmp], overwrite=True)
+        """Create test raster map and region"""
+        cls.use_temp_region()
+        cls.runModule("g.region", n=40, s=0, e=40, w=0, res=10)
+        cls.runModule("r.mapcalc", expression="%s = row() + (10.0 * col())"%(cls.name),
+                                   overwrite=True)
 
     @classmethod
     def tearDownClass(cls):
         """Remove the generated vector map, if exist"""
-        from grass.pygrass.modules.shortcuts import general as g
-        g.remove(type='raster', name=cls.tmp, flags='f')
+        cls.runModule("g.remove", flags='f', type='raster', 
+                      name=cls.name)
+        cls.del_temp_region()
 
     def test_type(self):
         r = RasterRow(self.name)
         r.open(mode='r')
-        self.assertTrue(r.mtype,'FCELL')
+        self.assertTrue(r.mtype,'DCELL')
         r.close()
 
     def test_isopen(self):
@@ -53,18 +55,18 @@ class RasterRowTestCate(TestCase):
         self.assertTrue(exist.exist())
 
     def test_open_r(self):
-        notexist = RasterRow(self.tmp + 'notexist')
+        notexist = RasterRow(self.name + 'notexist')
         with self.assertRaises(OpenError):
             # raster does not exist
             notexist.open(mode='r')
         r = RasterRow(self.name)
-        r.open(mode='r', mtype='DCELL')
+        r.open(mode='r', mtype='FCELL')
         # ignore the mtype if is open in read mode
-        self.assertEqual(r.mtype, 'FCELL')
+        self.assertEqual(r.mtype, 'DCELL')
         r.close()
 
     def test_open_w(self):
-        r = RasterRow(self.tmp)
+        r = RasterRow(self.name)
         with self.assertRaises(OpenError):
             # raster type is not defined!
             r.open(mode='w')
@@ -74,6 +76,7 @@ class RasterRowTestCate(TestCase):
         # open in write mode and overwrite
         r.open(mode='w', mtype='DCELL', overwrite=True)
         self.assertTrue(r.mtype, 'DCELL')
+        r.close()
 
 
 if __name__ == '__main__':

lib/python/pygrass/raster/testsuite/test_raster_region.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8
+from grass.gunittest.case import TestCase
+from grass.gunittest.main import test
+from unittest import skip
+
+from grass.pygrass.raster import RasterRow
+from grass.pygrass.gis.region import Region
+
+class RasterRowRegionTestCase(TestCase):
+
+    name = "RasterRowRegionTestCase_map"
+
+    @classmethod
+    def setUpClass(cls):
+        """Create test raster map and region"""
+        cls.use_temp_region()
+        cls.runModule("g.region", n=40, s=0, e=40, w=0, res=10)
+        cls.runModule("r.mapcalc", expression="%s = row() + (10.0 * col())"%(cls.name),
+                                   overwrite=True)
+
+    @classmethod
+    def tearDownClass(cls):
+        """Remove the generated vector map, if exist"""
+        cls.runModule("g.remove", flags='f', type='raster', 
+                      name=cls.name)
+        cls.del_temp_region()
+
+    def test_resampling_1(self):
+        
+        region = Region()
+        
+        region.ewres = 4
+        region.nsres = 4
+        region.north = 30
+        region.south = 10
+        region.east = 30
+        region.west = 10
+        region.adjust(rows=True, cols=True)
+        
+        rast = RasterRow(self.name)
+        rast.set_region(region)
+        rast.open(mode='r')
+        
+        self.assertItemsEqual(rast[0].tolist(), [22,22,22,22,22,32,32,32,32,32])        
+        self.assertItemsEqual(rast[5].tolist(), [23,23,23,23,23,33,33,33,33,33])
+        
+        rast.close()
+
+    def test_resampling_2(self):
+        
+        region = Region()
+        
+        region.ewres = 5
+        region.nsres = 5
+        region.north = 60
+        region.south = -20
+        region.east = 60
+        region.west = -20
+        region.adjust(rows=True, cols=True)
+        
+        rast = RasterRow(self.name)
+        rast.set_region(region)
+        rast.open(mode='r')
+        
+        """
+        [nan, nan, nan, nan, nan, nan, nan, nan]
+        [nan, nan, nan, nan, nan, nan, nan, nan]
+        [nan, nan, 11.0, 21.0, 31.0, 41.0, nan, nan]
+        [nan, nan, 12.0, 22.0, 32.0, 42.0, nan, nan]
+        [nan, nan, 13.0, 23.0, 33.0, 43.0, nan, nan]
+        [nan, nan, 14.0, 24.0, 34.0, 44.0, nan, nan]
+        [nan, nan, nan, nan, nan, nan, nan, nan]
+        [nan, nan, nan, nan, nan, nan, nan, nan]
+        """
+
+        self.assertItemsEqual(rast[2].tolist()[2:6], [11.,21.,31.,41.])        
+        self.assertItemsEqual(rast[5].tolist()[2:6], [14.,24.,34.,44.])
+        
+        rast.close()
+
+if __name__ == '__main__':
+    test()