projects / scons.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
http://scons.tigris.org/issues/show_bug.cgi?id=2345
[scons.git] / src / engine / SCons / Scanner / FortranTests.py
diff --git a/src/engine/SCons/Scanner/FortranTests.py b/src/engine/SCons/Scanner/FortranTests.py
index 4c825221b82d601387b0e5c085075413fd1f18b7..9ebe2e673450146885fa8bb844074f4733dc49be 100644 (file)
--- a/src/engine/SCons/Scanner/FortranTests.py
+++ b/src/engine/SCons/Scanner/FortranTests.py
@@ -210,6 +210,7 @@ test.write(['modules', 'use.mod'], "\n")
 class DummyEnvironment:
     def __init__(self, listCppPath):
         self.path = listCppPath
+        self.fs = SCons.Node.FS.FS(test.workpath(''))
 
     def Dictionary(self, *args):
         if not args:
@@ -217,10 +218,10 @@ class DummyEnvironment:
         elif len(args) == 1 and args[0] == 'FORTRANPATH':
             return self.path
         else:
-            raise KeyError, "Dummy environment only has FORTRANPATH attribute."
+            raise KeyError("Dummy environment only has FORTRANPATH attribute.")
 
     def has_key(self, key):
-        return self.Dictionary().has_key(key)
+        return key in self.Dictionary()
 
     def __getitem__(self,key):
         return self.Dictionary()[key]
@@ -231,27 +232,33 @@ class DummyEnvironment:
     def __delitem__(self,key):
         del self.Dictionary()[key]
 
-    def subst(self, arg):
+    def subst(self, arg, target=None, source=None, conv=None):
         if arg[0] == '$':
             return self[arg[1:]]
         return arg
 
-    def subst_path(self, path, target=None, source=None):
-        if type(path) != type([]):
+    def subst_path(self, path, target=None, source=None, conv=None):
+        if not isinstance(path, list):
             path = [path]
-        return map(self.subst, path)
+        return list(map(self.subst, path))
 
     def get_calculator(self):
         return None
 
+    def get_factory(self, factory):
+        return factory or self.fs.File
+
+    def Dir(self, filename):
+        return self.fs.Dir(filename)
+
+    def File(self, filename):
+        return self.fs.File(filename)
+
 def deps_match(self, deps, headers):
-    scanned = map(os.path.normpath, map(str, deps))
-    expect = map(os.path.normpath, headers)
+    scanned = list(map(os.path.normpath, list(map(str, deps))))
+    expect = list(map(os.path.normpath, headers))
     self.failUnless(scanned == expect, "expect %s != scanned %s" % (expect, scanned))
 
-def make_node(filename, fs=SCons.Node.FS.default_fs):
-    return fs.File(test.workpath(filename))
-
 # define some tests:
 
 class FortranScannerTestCase1(unittest.TestCase):
@@ -261,10 +268,9 @@ class FortranScannerTestCase1(unittest.TestCase):
         env = DummyEnvironment([])
         s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
-        fs = SCons.Node.FS.FS(original)
-        deps = s(make_node('fff1.f', fs), env, path)
+        deps = s(env.File('fff1.f'), env, path)
         headers = ['f1.f', 'f2.f']
-        deps_match(self, deps, map(test.workpath, headers))
+        deps_match(self, deps, headers)
         test.unlink('f1.f')
         test.unlink('f2.f')
 
@@ -275,10 +281,9 @@ class FortranScannerTestCase2(unittest.TestCase):
         env = DummyEnvironment([test.workpath("d1")])
         s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
-        fs = SCons.Node.FS.FS(original)
-        deps = s(make_node('fff1.f', fs), env, path)
+        deps = s(env.File('fff1.f'), env, path)
         headers = ['f1.f', 'f2.f']
-        deps_match(self, deps, map(test.workpath, headers))
+        deps_match(self, deps, headers)
         test.unlink('f1.f')
         test.unlink('f2.f')
 
@@ -287,10 +292,9 @@ class FortranScannerTestCase3(unittest.TestCase):
         env = DummyEnvironment([test.workpath("d1")])
         s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
-        fs = SCons.Node.FS.FS(original)
-        deps = s(make_node('fff1.f', fs), env, path)
+        deps = s(env.File('fff1.f'), env, path)
         headers = ['d1/f1.f', 'd1/f2.f']
-        deps_match(self, deps, map(test.workpath, headers))
+        deps_match(self, deps, headers)
 
 class FortranScannerTestCase4(unittest.TestCase):
     def runTest(self):
@@ -298,10 +302,9 @@ class FortranScannerTestCase4(unittest.TestCase):
         env = DummyEnvironment([test.workpath("d1")])
         s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
-        fs = SCons.Node.FS.FS(original)
-        deps = s(make_node('fff1.f', fs), env, path)
+        deps = s(env.File('fff1.f'), env, path)
         headers = ['d1/f1.f', 'd1/f2.f']
-        deps_match(self, deps, map(test.workpath, headers))
+        deps_match(self, deps, headers)
         test.write(['d1', 'f2.f'], "\n")
 
 class FortranScannerTestCase5(unittest.TestCase):
@@ -309,10 +312,9 @@ class FortranScannerTestCase5(unittest.TestCase):
         env = DummyEnvironment([test.workpath("d1")])
         s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
-        fs = SCons.Node.FS.FS(original)
-        deps = s(make_node('fff2.f', fs), env, path)
+        deps = s(env.File('fff2.f'), env, path)
         headers = ['d1/f2.f', 'd1/d2/f2.f', 'd1/f2.f']
-        deps_match(self, deps, map(test.workpath, headers))
+        deps_match(self, deps, headers)
 
 class FortranScannerTestCase6(unittest.TestCase):
     def runTest(self):
@@ -320,10 +322,9 @@ class FortranScannerTestCase6(unittest.TestCase):
         env = DummyEnvironment([test.workpath("d1")])
         s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
-        fs = SCons.Node.FS.FS(original)
-        deps = s(make_node('fff2.f', fs), env, path)
+        deps = s(env.File('fff2.f'), env, path)
         headers =  ['d1/f2.f', 'd1/d2/f2.f', 'f2.f']
-        deps_match(self, deps, map(test.workpath, headers))
+        deps_match(self, deps, headers)
         test.unlink('f2.f')
 
 class FortranScannerTestCase7(unittest.TestCase):
@@ -331,10 +332,9 @@ class FortranScannerTestCase7(unittest.TestCase):
         env = DummyEnvironment([test.workpath("d1/d2"), test.workpath("d1")])
         s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
-        fs = SCons.Node.FS.FS(original)
-        deps = s(make_node('fff2.f', fs), env, path)
+        deps = s(env.File('fff2.f'), env, path)
         headers =  ['d1/f2.f', 'd1/d2/f2.f', 'd1/d2/f2.f']
-        deps_match(self, deps, map(test.workpath, headers))
+        deps_match(self, deps, headers)
 
 class FortranScannerTestCase8(unittest.TestCase):
     def runTest(self):
@@ -342,10 +342,9 @@ class FortranScannerTestCase8(unittest.TestCase):
         env = DummyEnvironment([test.workpath("d1/d2"), test.workpath("d1")])
         s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
-        fs = SCons.Node.FS.FS(original)
-        deps = s(make_node('fff2.f', fs), env, path)
+        deps = s(env.File('fff2.f'), env, path)
         headers =  ['d1/f2.f', 'd1/d2/f2.f', 'f2.f']
-        deps_match(self, deps, map(test.workpath, headers))
+        deps_match(self, deps, headers)
         test.unlink('f2.f')
 
 class FortranScannerTestCase9(unittest.TestCase):
@@ -355,7 +354,7 @@ class FortranScannerTestCase9(unittest.TestCase):
         s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
 
-        n = make_node('fff3.f')
+        n = env.File('fff3.f')
         def my_rexists(s=n):
             s.rexists_called = 1
             return s.old_rexists()
@@ -365,27 +364,26 @@ class FortranScannerTestCase9(unittest.TestCase):
         deps = s(n, env, path)
 
         # Make sure rexists() got called on the file node being
-        # scanned, essential for cooperation with BuildDir functionality.
+        # scanned, essential for cooperation with VariantDir functionality.
         assert n.rexists_called
 
         headers =  ['d1/f3.f', 'f3.f']
-        deps_match(self, deps, map(test.workpath, headers))
+        deps_match(self, deps, headers)
         test.unlink('f3.f')
 
 class FortranScannerTestCase10(unittest.TestCase):
     def runTest(self):
-        fs = SCons.Node.FS.FS(test.workpath(''))
         env = DummyEnvironment(["include"])
-        s = SCons.Scanner.Fortran.FortranScan(fs = fs)
+        s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
-        deps1 = s(fs.File('fff4.f'), env, path)
-        fs.chdir(fs.Dir('subdir'))
-        dir = fs.getcwd()
-        fs.chdir(fs.Dir('..'))
+        deps1 = s(env.File('fff4.f'), env, path)
+        env.fs.chdir(env.Dir('subdir'))
+        dir = env.fs.getcwd()
+        env.fs.chdir(env.Dir(''))
         path = s.path(env, dir)
-        deps2 = s(fs.File('#fff4.f'), env, path)
-        headers1 =  ['include/f4.f']
-        headers2 =  ['subdir/include/f4.f']
+        deps2 = s(env.File('#fff4.f'), env, path)
+        headers1 =  list(map(test.workpath, ['include/f4.f']))
+        headers2 =  ['include/f4.f']
         deps_match(self, deps1, headers1)
         deps_match(self, deps2, headers2)
 
@@ -399,11 +397,10 @@ class FortranScannerTestCase11(unittest.TestCase):
         to = TestOut()
         to.out = None
         SCons.Warnings._warningOut = to
-        fs = SCons.Node.FS.FS(test.workpath(''))
         env = DummyEnvironment([])
-        s = SCons.Scanner.Fortran.FortranScan(fs=fs)
+        s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
-        deps = s(fs.File('fff5.f'), env, path)
+        deps = s(env.File('fff5.f'), env, path)
 
         # Did we catch the warning from not finding not_there.f?
         assert to.out
@@ -412,15 +409,14 @@ class FortranScannerTestCase11(unittest.TestCase):
 
 class FortranScannerTestCase12(unittest.TestCase):
     def runTest(self):
-        fs = SCons.Node.FS.FS(test.workpath(''))
-        fs.chdir(fs.Dir('include'))
         env = DummyEnvironment([])
-        s = SCons.Scanner.Fortran.FortranScan(fs=fs)
+        env.fs.chdir(env.Dir('include'))
+        s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
         test.write('include/fff4.f', test.read('fff4.f'))
-        deps = s(fs.File('#include/fff4.f'), env, path)
-        fs.chdir(fs.Dir('..'))
-        deps_match(self, deps, ['include/f4.f'])
+        deps = s(env.File('#include/fff4.f'), env, path)
+        env.fs.chdir(env.Dir(''))
+        deps_match(self, deps, ['f4.f'])
         test.unlink('include/fff4.f')
 
 class FortranScannerTestCase13(unittest.TestCase):
@@ -434,7 +430,8 @@ class FortranScannerTestCase13(unittest.TestCase):
         f1=fs.File('include2/jjj.f')
         f1.builder=1
         env = DummyEnvironment(['include','include2'])
-        s = SCons.Scanner.Fortran.FortranScan(fs=fs)
+        env.fs = fs
+        s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
         deps = s(fs.File('src/fff.f'), env, path)
         deps_match(self, deps, [test.workpath('repository/include/iii.f'), 'include2/jjj.f'])
@@ -444,11 +441,12 @@ class FortranScannerTestCase14(unittest.TestCase):
     def runTest(self):
         os.chdir(test.workpath('work'))
         fs = SCons.Node.FS.FS(test.workpath('work'))
-        fs.BuildDir('build1', 'src', 1)
-        fs.BuildDir('build2', 'src', 0)
+        fs.VariantDir('build1', 'src', 1)
+        fs.VariantDir('build2', 'src', 0)
         fs.Repository(test.workpath('repository'))
         env = DummyEnvironment([])
-        s = SCons.Scanner.Fortran.FortranScan(fs = fs)
+        env.fs = fs
+        s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
         deps1 = s(fs.File('build1/aaa.f'), env, path)
         deps_match(self, deps1, [ 'build1/bbb.f' ])
@@ -463,16 +461,18 @@ class FortranScannerTestCase14(unittest.TestCase):
 class FortranScannerTestCase15(unittest.TestCase):
     def runTest(self):
         class SubstEnvironment(DummyEnvironment):
-            def subst(self, arg, test=test):
-                return test.workpath("d1")
+            def subst(self, arg, target=None, source=None, conv=None, test=test):
+                if arg == "$junk":
+                    return test.workpath("d1")
+                else:
+                    return arg
         test.write(['d1', 'f2.f'], "      INCLUDE 'fi.f'\n")
-        env = SubstEnvironment(["junk"])
+        env = SubstEnvironment(["$junk"])
         s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
-        fs = SCons.Node.FS.FS(original)
-        deps = s(make_node('fff1.f', fs), env, path)
+        deps = s(env.File('fff1.f'), env, path)
         headers = ['d1/f1.f', 'd1/f2.f']
-        deps_match(self, deps, map(test.workpath, headers))
+        deps_match(self, deps, headers)
         test.write(['d1', 'f2.f'], "\n")
 
 class FortranScannerTestCase16(unittest.TestCase):
@@ -490,8 +490,7 @@ class FortranScannerTestCase16(unittest.TestCase):
         env = DummyEnvironment([test.workpath('modules')])
         s = SCons.Scanner.Fortran.FortranScan()
         path = s.path(env)
-        fs = SCons.Node.FS.FS(original)
-        deps = s(make_node('fff90a.f90', fs), env, path)
+        deps = s(env.File('fff90a.f90'), env, path)
         headers = ['f1.f', 'f2.f', 'f3.f', 'f4.f', 'f5.f', 'f6.f', 'f7.f', 'f8.f', 'f9.f']
         modules = ['mod01.mod', 'mod02.mod', 'mod03.mod', 'mod04.mod', 'mod05.mod',
                    'mod06.mod', 'mod07.mod', 'mod08.mod', 'mod09.mod', 'mod10.mod',
@@ -499,7 +498,7 @@ class FortranScannerTestCase16(unittest.TestCase):
                    'mod16.mod', 'mod17.mod', 'mod18.mod', 'mod19.mod', 'mod20.mod',
                    'mod21.mod', 'mod22.mod', 'mod23.mod', 'mod24.mod', 'mod25.mod', 'modules/use.mod']
         deps_expected = headers + modules
-        deps_match(self, deps, map(test.workpath, deps_expected))
+        deps_match(self, deps, deps_expected)
         test.unlink('f1.f')
         test.unlink('f2.f')
         test.unlink('f3.f')
@@ -536,3 +535,9 @@ if __name__ == "__main__":
     result = runner.run(suite())
     if not result.wasSuccessful():
         sys.exit(1)
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
Automated build system. A better Make.