New upstream version 3.1.0upstream/3.1.0

8 files changed, 534 insertions, 438 deletions

diff --git a/src/engine/SCons/Node/Alias.py b/src/engine/SCons/Node/Alias.py
index 9ea2fe0..a9defb6 100644
--- a/src/engine/SCons/Node/Alias.py
+++ b/src/engine/SCons/Node/Alias.py
@@ -30,7 +30,7 @@ This creates a hash of global Aliases (dummy targets).
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 
-__revision__ = "src/engine/SCons/Node/Alias.py 103260fce95bf5db1c35fb2371983087d85dd611 2019-07-13 18:25:30 bdbaddog"
+__revision__ = "src/engine/SCons/Node/Alias.py e724ae812eb96f4858a132f5b8c769724744faf6 2019-07-21 00:04:47 bdeegan"
 
 import collections
 
diff --git a/src/engine/SCons/Node/AliasTests.py b/src/engine/SCons/Node/AliasTests.py
index 21829b6..764ac67 100644
--- a/src/engine/SCons/Node/AliasTests.py
+++ b/src/engine/SCons/Node/AliasTests.py
@@ -21,7 +21,7 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 
-__revision__ = "src/engine/SCons/Node/AliasTests.py 103260fce95bf5db1c35fb2371983087d85dd611 2019-07-13 18:25:30 bdbaddog"
+__revision__ = "src/engine/SCons/Node/AliasTests.py e724ae812eb96f4858a132f5b8c769724744faf6 2019-07-21 00:04:47 bdeegan"
 
 import sys
 import unittest
diff --git a/src/engine/SCons/Node/FS.py b/src/engine/SCons/Node/FS.py
index 6319ace..21ccecc 100644
--- a/src/engine/SCons/Node/FS.py
+++ b/src/engine/SCons/Node/FS.py
@@ -33,7 +33,7 @@ that can be used by scripts or modules looking for the canonical default.
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 from __future__ import print_function
 
-__revision__ = "src/engine/SCons/Node/FS.py 103260fce95bf5db1c35fb2371983087d85dd611 2019-07-13 18:25:30 bdbaddog"
+__revision__ = "src/engine/SCons/Node/FS.py e724ae812eb96f4858a132f5b8c769724744faf6 2019-07-21 00:04:47 bdeegan"
 
 import fnmatch
 import os
@@ -57,7 +57,6 @@ import SCons.Util
 import SCons.Warnings
 
 from SCons.Debug import Trace
-from . import DeciderNeedsNode
 
 print_duplicate = 0
 
@@ -282,7 +281,7 @@ def set_duplicate(duplicate):
         'copy' : _copy_func
     }
 
-    if not duplicate in Valid_Duplicates:
+    if duplicate not in Valid_Duplicates:
         raise SCons.Errors.InternalError("The argument of set_duplicate "
                                            "should be in Valid_Duplicates")
     global Link_Funcs
@@ -480,7 +479,7 @@ class EntryProxy(SCons.Util.Proxy):
             return SCons.Subst.SpecialAttrWrapper(r, entry.name + "_posix")
 
     def __get_windows_path(self):
-        """Return the path with \ as the path separator,
+        r"""Return the path with \ as the path separator,
         regardless of platform."""
         if OS_SEP == '\\':
             return self
@@ -531,7 +530,7 @@ class EntryProxy(SCons.Util.Proxy):
         except KeyError:
             try:
                 attr = SCons.Util.Proxy.__getattr__(self, name)
-            except AttributeError as e:
+            except AttributeError:
                 # Raise our own AttributeError subclass with an
                 # overridden __str__() method that identifies the
                 # name of the entry that caused the exception.
@@ -699,13 +698,13 @@ class Base(SCons.Node.Node):
 
     @SCons.Memoize.CountMethodCall
     def stat(self):
-        try: 
+        try:
             return self._memo['stat']
-        except KeyError: 
+        except KeyError:
             pass
-        try: 
+        try:
             result = self.fs.stat(self.get_abspath())
-        except os.error: 
+        except os.error:
             result = None
 
         self._memo['stat'] = result
@@ -719,16 +718,16 @@ class Base(SCons.Node.Node):
 
     def getmtime(self):
         st = self.stat()
-        if st: 
+        if st:
             return st[stat.ST_MTIME]
-        else: 
+        else:
             return None
 
     def getsize(self):
         st = self.stat()
-        if st: 
+        if st:
             return st[stat.ST_SIZE]
-        else: 
+        else:
             return None
 
     def isdir(self):
@@ -1418,7 +1417,7 @@ class FS(LocalFS):
             self.Top.addRepository(d)
 
     def PyPackageDir(self, modulename):
-        """Locate the directory of a given python module name
+        r"""Locate the directory of a given python module name
 
         For example scons might resolve to
         Windows: C:\Python27\Lib\site-packages\scons-2.5.1
@@ -1689,7 +1688,7 @@ class Dir(Base):
         return result
 
     def addRepository(self, dir):
-        if dir != self and not dir in self.repositories:
+        if dir != self and dir not in self.repositories:
             self.repositories.append(dir)
             dir._tpath = '.'
             self.__clearRepositoryCache()
@@ -1729,7 +1728,7 @@ class Dir(Base):
         if self is other:
             result = '.'
 
-        elif not other in self._path_elements:
+        elif other not in self._path_elements:
             try:
                 other_dir = other.get_dir()
             except AttributeError:
@@ -2261,7 +2260,7 @@ class RootDir(Dir):
     this directory.
     """
 
-    __slots__ = ['_lookupDict']
+    __slots__ = ('_lookupDict', )
 
     def __init__(self, drive, fs):
         if SCons.Debug.track_instances: logInstanceCreation(self, 'Node.FS.RootDir')
@@ -2467,7 +2466,7 @@ class FileNodeInfo(SCons.Node.NodeInfoBase):
         """
         state = getattr(self, '__dict__', {}).copy()
         for obj in type(self).mro():
-            for name in getattr(obj,'__slots__',()):
+            for name in getattr(obj, '__slots__', ()):
                 if hasattr(self, name):
                     state[name] = getattr(self, name)
 
@@ -2511,7 +2510,7 @@ class FileBuildInfo(SCons.Node.BuildInfoBase):
                     or count of any of these could yield writing wrong csig, and then false positive
                     rebuilds
     """
-    __slots__ = ('dependency_map')
+    __slots__ = ['dependency_map', ]
     current_version_id = 2
 
     def __setattr__(self, key, value):
@@ -3283,14 +3282,14 @@ class File(Base):
             self._memo['changed'] = has_changed
         return has_changed
 
-    def changed_content(self, target, prev_ni):
+    def changed_content(self, target, prev_ni, repo_node=None):
         cur_csig = self.get_csig()
         try:
             return cur_csig != prev_ni.csig
         except AttributeError:
             return 1
 
-    def changed_state(self, target, prev_ni):
+    def changed_state(self, target, prev_ni, repo_node=None):
         return self.state != SCons.Node.up_to_date
 
 
@@ -3317,13 +3316,26 @@ class File(Base):
             len(binfo.bimplicitsigs)) == 0:
             return {}
 
-
-        # store this info so we can avoid regenerating it.
-        binfo.dependency_map = { str(child):signature for child, signature in zip(chain(binfo.bsources, binfo.bdepends, binfo.bimplicit),
+        binfo.dependency_map = { child:signature for child, signature in zip(chain(binfo.bsources, binfo.bdepends, binfo.bimplicit),
                                      chain(binfo.bsourcesigs, binfo.bdependsigs, binfo.bimplicitsigs))}
 
         return binfo.dependency_map
 
+    # @profile
+    def _add_strings_to_dependency_map(self, dmap):
+        """
+        In the case comparing node objects isn't sufficient, we'll add the strings for the nodes to the dependency map
+        :return:
+        """
+
+        first_string = str(next(iter(dmap)))
+
+        # print("DMAP:%s"%id(dmap))
+        if first_string not in dmap:
+                string_dict = {str(child): signature for child, signature in dmap.items()}
+                dmap.update(string_dict)
+        return dmap
+
     def _get_previous_signatures(self, dmap):
         """
         Return a list of corresponding csigs from previous
@@ -3342,37 +3354,62 @@ class File(Base):
         if len(dmap) == 0:
             if MD5_TIMESTAMP_DEBUG: print("Nothing dmap shortcutting")
             return None
+        elif MD5_TIMESTAMP_DEBUG: print("len(dmap):%d"%len(dmap))
+
 
-        if MD5_TIMESTAMP_DEBUG: print("len(dmap):%d"%len(dmap))
-        # First try the simple name for node
-        c_str = str(self)
-        if MD5_TIMESTAMP_DEBUG: print("Checking   :%s"%c_str)
-        df = dmap.get(c_str, None)
+        # First try retrieving via Node
+        if MD5_TIMESTAMP_DEBUG: print("Checking if self is in  map:%s id:%s type:%s"%(str(self), id(self), type(self)))
+        df = dmap.get(self, False)
         if df:
             return df
-        
+
+        # Now check if self's repository file is in map.
+        rf = self.rfile()
+        if MD5_TIMESTAMP_DEBUG: print("Checking if self.rfile  is in  map:%s id:%s type:%s"%(str(rf), id(rf), type(rf)))
+        rfm = dmap.get(rf, False)
+        if rfm:
+            return rfm
+
+        # get default string for node and then also string swapping os.altsep for os.sep (/ for \)
+        c_strs = [str(self)]
+
         if os.altsep:
-            c_str = c_str.replace(os.sep, os.altsep)
-            df = dmap.get(c_str, None)
-            if MD5_TIMESTAMP_DEBUG: print("-->%s"%df)
+            c_strs.append(c_strs[0].replace(os.sep, os.altsep))
+
+        # In some cases the dependency_maps' keys are already strings check.
+        # Check if either string is now in dmap.
+        for s in c_strs:
+            if MD5_TIMESTAMP_DEBUG: print("Checking if str(self) is in map  :%s" % s)
+            df = dmap.get(s, False)
+            if df:
+                return df
+
+        # Strings don't exist in map, add them and try again
+        # If there are no strings in this dmap, then add them.
+        # This may not be necessary, we could walk the nodes in the dmap and check each string
+        # rather than adding ALL the strings to dmap. In theory that would be n/2 vs 2n str() calls on node
+        # if not dmap.has_strings:
+        dmap = self._add_strings_to_dependency_map(dmap)
+
+        # In some cases the dependency_maps' keys are already strings check.
+        # Check if either string is now in dmap.
+        for s in c_strs:
+            if MD5_TIMESTAMP_DEBUG: print("Checking if str(self) is in map (now with strings)  :%s" % s)
+            df = dmap.get(s, False)
             if df:
                 return df
 
+        # Lastly use nodes get_path() to generate string and see if that's in dmap
         if not df:
             try:
                 # this should yield a path which matches what's in the sconsign
                 c_str = self.get_path()
-                df = dmap.get(c_str, None)
-                if MD5_TIMESTAMP_DEBUG: print("-->%s"%df)
-                if df:
-                    return df
-
                 if os.altsep:
                     c_str = c_str.replace(os.sep, os.altsep)
-                    df = dmap.get(c_str, None)
-                    if MD5_TIMESTAMP_DEBUG: print("-->%s"%df)
-                    if df:
-                        return df
+
+                if MD5_TIMESTAMP_DEBUG: print("Checking if self.get_path is in map (now with strings)  :%s" % s)
+
+                df = dmap.get(c_str, None)
 
             except AttributeError as e:
                 raise FileBuildInfoFileToCsigMappingError("No mapping from file name to content signature for :%s"%c_str)
@@ -3387,21 +3424,17 @@ class File(Base):
               file and just copy the prev_ni provided.  If the prev_ni
               is wrong. It will propagate it.
               See: https://github.com/SCons/scons/issues/2980
-        
+
         Args:
             self - dependency
             target - target
             prev_ni - The NodeInfo object loaded from previous builds .sconsign
-            node - Node instance.  This is the only changed* function which requires
-                   node to function. So if we detect that it's not passed.
-                   we throw DeciderNeedsNode, and caller should handle this and pass node.
+            node - Node instance.  Check this node for file existence/timestamp
+                   if specified.
 
-        Returns: 
+        Returns:
             Boolean - Indicates if node(File) has changed.
         """
-        if node is None:
-            # We need required node argument to get BuildInfo to function
-            raise DeciderNeedsNode(self.changed_timestamp_then_content)
 
         # Now get sconsign name -> csig map and then get proper prev_ni if possible
         bi = node.get_stored_info().binfo
@@ -3433,7 +3466,6 @@ class File(Base):
                 print("Mismatch self.changed_timestamp_match(%s, prev_ni) old:%s new:%s"%(str(target), old, new))
                 new_prev_ni = self._get_previous_signatures(dependency_map)
 
-
         if not new:
             try:
                 # NOTE: We're modifying the current node's csig in a query.
@@ -3443,13 +3475,13 @@ class File(Base):
             return False
         return self.changed_content(target, new_prev_ni)
 
-    def changed_timestamp_newer(self, target, prev_ni):
+    def changed_timestamp_newer(self, target, prev_ni, repo_node=None):
         try:
             return self.get_timestamp() > target.get_timestamp()
         except AttributeError:
             return 1
 
-    def changed_timestamp_match(self, target, prev_ni):
+    def changed_timestamp_match(self, target, prev_ni, repo_node=None):
         """
         Return True if the timestamps don't match or if there is no previous timestamp
         :param target:
@@ -3462,14 +3494,18 @@ class File(Base):
             return 1
 
     def is_up_to_date(self):
+        """Check for whether the Node is current
+           In all cases self is the target we're checking to see if it's up to date
+        """
+
         T = 0
         if T: Trace('is_up_to_date(%s):' % self)
         if not self.exists():
             if T: Trace(' not self.exists():')
-            # The file doesn't exist locally...
+            # The file (always a target) doesn't exist locally...
             r = self.rfile()
             if r != self:
-                # ...but there is one in a Repository...
+                # ...but there is one (always a target) in a Repository...
                 if not self.changed(r):
                     if T: Trace(' changed(%s):' % r)
                     # ...and it's even up-to-date...
diff --git a/src/engine/SCons/Node/FSTests.py b/src/engine/SCons/Node/FSTests.py
index 021d433..2366a4d 100644
--- a/src/engine/SCons/Node/FSTests.py
+++ b/src/engine/SCons/Node/FSTests.py
@@ -22,7 +22,7 @@
 #
 from __future__ import division, print_function
 
-__revision__ = "src/engine/SCons/Node/FSTests.py 103260fce95bf5db1c35fb2371983087d85dd611 2019-07-13 18:25:30 bdbaddog"
+__revision__ = "src/engine/SCons/Node/FSTests.py e724ae812eb96f4858a132f5b8c769724744faf6 2019-07-21 00:04:47 bdeegan"
 
 import SCons.compat
 
@@ -47,54 +47,73 @@ built_it = None
 
 scanner_count = 0
 
+
 class Scanner(object):
     def __init__(self, node=None):
         global scanner_count
         scanner_count = scanner_count + 1
         self.hash = scanner_count
         self.node = node
+
     def path(self, env, dir, target=None, source=None):
         return ()
+
     def __call__(self, node, env, path):
         return [self.node]
+
     def __hash__(self):
         return self.hash
+
     def select(self, node):
         return self
+
     def recurse_nodes(self, nodes):
         return nodes
 
+
 class Environment(object):
     def __init__(self):
         self.scanner = Scanner()
+
     def Dictionary(self, *args):
         return {}
+
     def autogenerate(self, **kw):
         return {}
+
     def get_scanner(self, skey):
         return self.scanner
+
     def Override(self, overrides):
         return self
+
     def _update(self, dict):
         pass
 
+
 class Action(object):
     def __call__(self, targets, sources, env, **kw):
         global built_it
         if kw.get('execute', 1):
             built_it = 1
         return 0
+
     def show(self, string):
         pass
+
     def get_contents(self, target, source, env):
-        return bytearray("",'utf-8')
+        return bytearray("", 'utf-8')
+
     def genstring(self, target, source, env):
         return ""
+
     def strfunction(self, targets, sources, env):
         return ""
+
     def get_implicit_deps(self, target, source, env):
         return []
 
+
 class Builder(object):
     def __init__(self, factory, action=Action()):
         self.factory = factory
@@ -110,6 +129,7 @@ class Builder(object):
     def source_factory(self, name):
         return self.factory(name)
 
+
 class _tempdirTestCase(unittest.TestCase):
     def setUp(self):
         self.save_cwd = os.getcwd()
@@ -121,10 +141,11 @@ class _tempdirTestCase(unittest.TestCase):
     def tearDown(self):
         os.chdir(self.save_cwd)
 
+
 class VariantDirTestCase(unittest.TestCase):
     def runTest(self):
         """Test variant dir functionality"""
-        test=TestCmd(workdir='')
+        test = TestCmd(workdir='')
 
         fs = SCons.Node.FS.FS()
         f1 = fs.File('build/test1')
@@ -169,30 +190,30 @@ class VariantDirTestCase(unittest.TestCase):
         test.subdir(['rep1', 'build', 'var2'])
 
         # A source file in the source directory
-        test.write([ 'work', 'src', 'test.in' ], 'test.in')
+        test.write(['work', 'src', 'test.in'], 'test.in')
 
         # A source file in a subdir of the source directory
-        test.subdir([ 'work', 'src', 'new_dir' ])
-        test.write([ 'work', 'src', 'new_dir', 'test9.out' ], 'test9.out\n')
+        test.subdir(['work', 'src', 'new_dir'])
+        test.write(['work', 'src', 'new_dir', 'test9.out'], 'test9.out\n')
 
         # A source file in the repository
-        test.write([ 'rep1', 'src', 'test2.in' ], 'test2.in')
+        test.write(['rep1', 'src', 'test2.in'], 'test2.in')
 
         # Some source files in the variant directory
-        test.write([ 'work', 'build', 'var2', 'test.in' ], 'test.old')
-        test.write([ 'work', 'build', 'var2', 'test2.in' ], 'test2.old')
+        test.write(['work', 'build', 'var2', 'test.in'], 'test.old')
+        test.write(['work', 'build', 'var2', 'test2.in'], 'test2.old')
 
         # An old derived file in the variant directories
-        test.write([ 'work', 'build', 'var1', 'test.out' ], 'test.old')
-        test.write([ 'work', 'build', 'var2', 'test.out' ], 'test.old')
+        test.write(['work', 'build', 'var1', 'test.out'], 'test.old')
+        test.write(['work', 'build', 'var2', 'test.out'], 'test.old')
 
         # And just in case we are weird, a derived file in the source
         # dir.
-        test.write([ 'work', 'src', 'test.out' ], 'test.out.src')
+        test.write(['work', 'src', 'test.out'], 'test.out.src')
 
         # A derived file in the repository
-        test.write([ 'rep1', 'build', 'var1', 'test2.out' ], 'test2.out_rep')
-        test.write([ 'rep1', 'build', 'var2', 'test2.out' ], 'test2.out_rep')
+        test.write(['rep1', 'build', 'var1', 'test2.out'], 'test2.out_rep')
+        test.write(['rep1', 'build', 'var2', 'test2.out'], 'test2.out_rep')
 
         os.chdir(test.workpath('work'))
 
@@ -211,8 +232,8 @@ class VariantDirTestCase(unittest.TestCase):
         f2out_2.builder = 1
         fs.Repository(test.workpath('rep1'))
 
-        assert f1.srcnode().get_internal_path() == os.path.normpath('src/test.in'),\
-               f1.srcnode().get_internal_path()
+        assert f1.srcnode().get_internal_path() == os.path.normpath('src/test.in'), \
+            f1.srcnode().get_internal_path()
         # str(node) returns source path for duplicate = 0
         assert str(f1) == os.path.normpath('src/test.in'), str(f1)
         # Build path does not exist
@@ -222,26 +243,26 @@ class VariantDirTestCase(unittest.TestCase):
         # And duplicate=0 should also work just like a Repository
         assert f1.rexists()
         # rfile() should point to the source path
-        assert f1.rfile().get_internal_path() == os.path.normpath('src/test.in'),\
-               f1.rfile().get_internal_path()
+        assert f1.rfile().get_internal_path() == os.path.normpath('src/test.in'), \
+            f1.rfile().get_internal_path()
 
-        assert f2.srcnode().get_internal_path() == os.path.normpath('src/test.in'),\
-               f2.srcnode().get_internal_path()
+        assert f2.srcnode().get_internal_path() == os.path.normpath('src/test.in'), \
+            f2.srcnode().get_internal_path()
         # str(node) returns build path for duplicate = 1
         assert str(f2) == os.path.normpath('build/var2/test.in'), str(f2)
         # Build path exists
         assert f2.exists()
         # ...and exists() should copy the file from src to build path
-        assert test.read(['work', 'build', 'var2', 'test.in']) == bytearray('test.in','utf-8'),\
-               test.read(['work', 'build', 'var2', 'test.in'])
+        assert test.read(['work', 'build', 'var2', 'test.in']) == bytearray('test.in', 'utf-8'), \
+            test.read(['work', 'build', 'var2', 'test.in'])
         # Since exists() is true, so should rexists() be
         assert f2.rexists()
 
         f3 = fs.File('build/var1/test2.in')
         f4 = fs.File('build/var2/test2.in')
 
-        assert f3.srcnode().get_internal_path() == os.path.normpath('src/test2.in'),\
-               f3.srcnode().get_internal_path()
+        assert f3.srcnode().get_internal_path() == os.path.normpath('src/test2.in'), \
+            f3.srcnode().get_internal_path()
         # str(node) returns source path for duplicate = 0
         assert str(f3) == os.path.normpath('src/test2.in'), str(f3)
         # Build path does not exist
@@ -251,22 +272,22 @@ class VariantDirTestCase(unittest.TestCase):
         # But we do have a file in the Repository
         assert f3.rexists()
         # rfile() should point to the source path
-        assert f3.rfile().get_internal_path() == os.path.normpath(test.workpath('rep1/src/test2.in')),\
-               f3.rfile().get_internal_path()
+        assert f3.rfile().get_internal_path() == os.path.normpath(test.workpath('rep1/src/test2.in')), \
+            f3.rfile().get_internal_path()
 
-        assert f4.srcnode().get_internal_path() == os.path.normpath('src/test2.in'),\
-               f4.srcnode().get_internal_path()
+        assert f4.srcnode().get_internal_path() == os.path.normpath('src/test2.in'), \
+            f4.srcnode().get_internal_path()
         # str(node) returns build path for duplicate = 1
         assert str(f4) == os.path.normpath('build/var2/test2.in'), str(f4)
         # Build path should exist
         assert f4.exists()
         # ...and copy over the file into the local build path
-        assert test.read(['work', 'build', 'var2', 'test2.in']) == bytearray('test2.in','utf-8')
+        assert test.read(['work', 'build', 'var2', 'test2.in']) == bytearray('test2.in', 'utf-8')
         # should exist in repository, since exists() is true
         assert f4.rexists()
         # rfile() should point to ourselves
-        assert f4.rfile().get_internal_path() == os.path.normpath('build/var2/test2.in'),\
-               f4.rfile().get_internal_path()
+        assert f4.rfile().get_internal_path() == os.path.normpath('build/var2/test2.in'), \
+            f4.rfile().get_internal_path()
 
         f5 = fs.File('build/var1/test.out')
         f6 = fs.File('build/var2/test.out')
@@ -274,12 +295,12 @@ class VariantDirTestCase(unittest.TestCase):
         assert f5.exists()
         # We should not copy the file from the source dir, since this is
         # a derived file.
-        assert test.read(['work', 'build', 'var1', 'test.out']) == bytearray('test.old','utf-8')
+        assert test.read(['work', 'build', 'var1', 'test.out']) == bytearray('test.old', 'utf-8')
 
         assert f6.exists()
         # We should not copy the file from the source dir, since this is
         # a derived file.
-        assert test.read(['work', 'build', 'var2', 'test.out']) == bytearray('test.old','utf-8')
+        assert test.read(['work', 'build', 'var2', 'test.out']) == bytearray('test.old', 'utf-8')
 
         f7 = fs.File('build/var1/test2.out')
         f8 = fs.File('build/var2/test2.out')
@@ -292,8 +313,8 @@ class VariantDirTestCase(unittest.TestCase):
 
         assert not f8.exists()
         assert f8.rexists()
-        assert f8.rfile().get_internal_path() == os.path.normpath(test.workpath('rep1/build/var2/test2.out')),\
-               f8.rfile().get_internal_path()
+        assert f8.rfile().get_internal_path() == os.path.normpath(test.workpath('rep1/build/var2/test2.out')), \
+            f8.rfile().get_internal_path()
 
         # Verify the Mkdir and Link actions are called
         d9 = fs.Dir('build/var2/new_dir')
@@ -302,6 +323,7 @@ class VariantDirTestCase(unittest.TestCase):
         class MkdirAction(Action):
             def __init__(self, dir_made):
                 self.dir_made = dir_made
+
             def __call__(self, target, source, env, executor=None):
                 if executor:
                     target = executor.get_all_targets()
@@ -310,8 +332,10 @@ class VariantDirTestCase(unittest.TestCase):
 
         save_Link = SCons.Node.FS.Link
         link_made = []
+
         def link_func(target, source, env, link_made=link_made):
             link_made.append(target)
+
         SCons.Node.FS.Link = link_func
 
         try:
@@ -332,10 +356,10 @@ class VariantDirTestCase(unittest.TestCase):
         # happen if you switch from duplicate=1 to duplicate=0, then
         # delete a source file.  At one time, this would cause exists()
         # to return a 1 but get_contents() to throw.
-        test.write([ 'work', 'build', 'var1', 'asourcefile' ], 'stuff')
+        test.write(['work', 'build', 'var1', 'asourcefile'], 'stuff')
         f10 = fs.File('build/var1/asourcefile')
         assert f10.exists()
-        assert f10.get_contents() == bytearray('stuff','utf-8'), f10.get_contents()
+        assert f10.get_contents() == bytearray('stuff', 'utf-8'), f10.get_contents()
 
         f11 = fs.File('src/file11')
         t, m = f11.alter_targets()
@@ -361,8 +385,10 @@ class VariantDirTestCase(unittest.TestCase):
         fIO = fs.File("build/var2/IOError")
 
         save_Link = SCons.Node.FS.Link
+
         def Link_IOError(target, source, env):
             raise IOError(17, "Link_IOError")
+
         SCons.Node.FS.Link = SCons.Action.Action(Link_IOError, None)
 
         test.write(['work', 'src', 'IOError'], "work/src/IOError\n")
@@ -379,16 +405,16 @@ class VariantDirTestCase(unittest.TestCase):
             SCons.Node.FS.Link = save_Link
 
         # Test to see if Link() works...
-        test.subdir('src','build')
+        test.subdir('src', 'build')
         test.write('src/foo', 'src/foo\n')
         os.chmod(test.workpath('src/foo'), stat.S_IRUSR)
         SCons.Node.FS.Link(fs.File(test.workpath('build/foo')),
                            fs.File(test.workpath('src/foo')),
                            None)
         os.chmod(test.workpath('src/foo'), stat.S_IRUSR | stat.S_IWRITE)
-        st=os.stat(test.workpath('build/foo'))
+        st = os.stat(test.workpath('build/foo'))
         assert (stat.S_IMODE(st[stat.ST_MODE]) & stat.S_IWRITE), \
-               stat.S_IMODE(st[stat.ST_MODE])
+            stat.S_IMODE(st[stat.ST_MODE])
 
         # This used to generate a UserError when we forbid the source
         # directory from being outside the top-level SConstruct dir.
@@ -404,8 +430,8 @@ class VariantDirTestCase(unittest.TestCase):
                 exc_caught = 1
             assert exc_caught, "Should have caught a UserError."
         finally:
-            test.unlink( "src/foo" )
-            test.unlink( "build/foo" )
+            test.unlink("src/foo")
+            test.unlink("build/foo")
 
         fs = SCons.Node.FS.FS()
         fs.VariantDir('build', 'src1')
@@ -424,18 +450,20 @@ class VariantDirTestCase(unittest.TestCase):
 
         # Test against a former bug.  Make sure we can get a repository
         # path for the variant directory itself!
-        fs=SCons.Node.FS.FS(test.workpath('work'))
-        test.subdir('work')
+        fs = SCons.Node.FS.FS(test.workpath('work'))
+
+        # not needed this subdir is created above near line 188
+        # test.subdir('work')
         fs.VariantDir('build/var3', 'src', duplicate=0)
         d1 = fs.Dir('build/var3')
         r = d1.rdir()
         assert r == d1, "%s != %s" % (r, d1)
 
         # verify the link creation attempts in file_link()
-        class LinkSimulator (object):
+        class LinkSimulator(object):
             """A class to intercept os.[sym]link() calls and track them."""
 
-            def __init__( self, duplicate, link, symlink, copy ) :
+            def __init__(self, duplicate, link, symlink, copy):
                 self.duplicate = duplicate
                 self.have = {}
                 self.have['hard'] = link
@@ -447,27 +475,28 @@ class VariantDirTestCase(unittest.TestCase):
                     if self.have[link]:
                         self.links_to_be_called.append(link)
 
-            def link_fail( self , src , dest ) :
+            def link_fail(self, src, dest):
                 next_link = self.links_to_be_called.pop(0)
                 assert next_link == "hard", \
-                       "Wrong link order: expected %s to be called "\
-                       "instead of hard" % next_link
-                raise OSError( "Simulating hard link creation error." )
+                    "Wrong link order: expected %s to be called " \
+                    "instead of hard" % next_link
+                raise OSError("Simulating hard link creation error.")
 
-            def symlink_fail( self , src , dest ) :
+            def symlink_fail(self, src, dest):
                 next_link = self.links_to_be_called.pop(0)
                 assert next_link == "soft", \
-                       "Wrong link order: expected %s to be called "\
-                       "instead of soft" % next_link
-                raise OSError( "Simulating symlink creation error." )
+                    "Wrong link order: expected %s to be called " \
+                    "instead of soft" % next_link
+                raise OSError("Simulating symlink creation error.")
 
-            def copy( self , src , dest ) :
+            def copy(self, src, dest):
                 next_link = self.links_to_be_called.pop(0)
                 assert next_link == "copy", \
-                       "Wrong link order: expected %s to be called "\
-                       "instead of copy" % next_link
+                    "Wrong link order: expected %s to be called " \
+                    "instead of copy" % next_link
                 # copy succeeds, but use the real copy
                 self.have['copy'](src, dest)
+
         # end class LinkSimulator
 
         try:
@@ -539,33 +568,33 @@ class VariantDirTestCase(unittest.TestCase):
         fs.VariantDir('work/src/b1/b2', 'work/src')
 
         dir_list = [
-                'work/src',
-                'work/src/b1',
-                'work/src/b1/b2',
-                'work/src/b1/b2/b1',
-                'work/src/b1/b2/b1/b2',
-                'work/src/b1/b2/b1/b2/b1',
-                'work/src/b1/b2/b1/b2/b1/b2',
+            'work/src',
+            'work/src/b1',
+            'work/src/b1/b2',
+            'work/src/b1/b2/b1',
+            'work/src/b1/b2/b1/b2',
+            'work/src/b1/b2/b1/b2/b1',
+            'work/src/b1/b2/b1/b2/b1/b2',
         ]
 
         srcnode_map = {
-                'work/src/b1/b2' : 'work/src',
-                'work/src/b1/b2/f' : 'work/src/f',
-                'work/src/b1/b2/b1' : 'work/src/b1/',
-                'work/src/b1/b2/b1/f' : 'work/src/b1/f',
-                'work/src/b1/b2/b1/b2' : 'work/src/b1/b2',
-                'work/src/b1/b2/b1/b2/f' : 'work/src/b1/b2/f',
-                'work/src/b1/b2/b1/b2/b1' : 'work/src/b1/b2/b1',
-                'work/src/b1/b2/b1/b2/b1/f' : 'work/src/b1/b2/b1/f',
-                'work/src/b1/b2/b1/b2/b1/b2' : 'work/src/b1/b2/b1/b2',
-                'work/src/b1/b2/b1/b2/b1/b2/f' : 'work/src/b1/b2/b1/b2/f',
+            'work/src/b1/b2': 'work/src',
+            'work/src/b1/b2/f': 'work/src/f',
+            'work/src/b1/b2/b1': 'work/src/b1/',
+            'work/src/b1/b2/b1/f': 'work/src/b1/f',
+            'work/src/b1/b2/b1/b2': 'work/src/b1/b2',
+            'work/src/b1/b2/b1/b2/f': 'work/src/b1/b2/f',
+            'work/src/b1/b2/b1/b2/b1': 'work/src/b1/b2/b1',
+            'work/src/b1/b2/b1/b2/b1/f': 'work/src/b1/b2/b1/f',
+            'work/src/b1/b2/b1/b2/b1/b2': 'work/src/b1/b2/b1/b2',
+            'work/src/b1/b2/b1/b2/b1/b2/f': 'work/src/b1/b2/b1/b2/f',
         }
 
         alter_map = {
-                'work/src' : 'work/src/b1/b2',
-                'work/src/f' : 'work/src/b1/b2/f',
-                'work/src/b1' : 'work/src/b1/b2/b1',
-                'work/src/b1/f' : 'work/src/b1/b2/b1/f',
+            'work/src': 'work/src/b1/b2',
+            'work/src/f': 'work/src/b1/b2/f',
+            'work/src/b1': 'work/src/b1/b2/b1',
+            'work/src/b1/f': 'work/src/b1/b2/b1/f',
         }
 
         errors = 0
@@ -608,6 +637,7 @@ class VariantDirTestCase(unittest.TestCase):
 
         self.assertFalse(errors)
 
+
 class BaseTestCase(_tempdirTestCase):
     def test_stat(self):
         """Test the Base.stat() method"""
@@ -703,18 +733,21 @@ class BaseTestCase(_tempdirTestCase):
             nonexistent = fs.Entry('nonexistent')
             assert not nonexistent.islink()
 
+
 class DirNodeInfoTestCase(_tempdirTestCase):
     def test___init__(self):
         """Test DirNodeInfo initialization"""
         ddd = self.fs.Dir('ddd')
         ni = SCons.Node.FS.DirNodeInfo()
 
+
 class DirBuildInfoTestCase(_tempdirTestCase):
     def test___init__(self):
         """Test DirBuildInfo initialization"""
         ddd = self.fs.Dir('ddd')
         bi = SCons.Node.FS.DirBuildInfo()
 
+
 class FileNodeInfoTestCase(_tempdirTestCase):
     def test___init__(self):
         """Test FileNodeInfo initialization"""
@@ -760,6 +793,7 @@ class FileNodeInfoTestCase(_tempdirTestCase):
         size = st[stat.ST_SIZE]
         assert ni.size != size, (ni.size, size)
 
+
 class FileBuildInfoTestCase(_tempdirTestCase):
     def test___init__(self):
         """Test File.BuildInfo initialization"""
@@ -821,6 +855,7 @@ class FileBuildInfoTestCase(_tempdirTestCase):
         format = bi1.format()
         assert format == expect, (repr(expect), repr(format))
 
+
 class FSTestCase(_tempdirTestCase):
     def test_needs_normpath(self):
         """Test the needs_normpath Regular expression
@@ -862,7 +897,6 @@ class FSTestCase(_tempdirTestCase):
             "/a./",
             "/a../",
 
-
             ".a",
             "..a",
             "/.a",
@@ -871,7 +905,7 @@ class FSTestCase(_tempdirTestCase):
             "..a/",
             "/.a/",
             "/..a/",
-            ]
+        ]
         for p in do_not_need_normpath:
             assert needs_normpath_match(p) is None, p
 
@@ -919,7 +953,7 @@ class FSTestCase(_tempdirTestCase):
             "../a",
             "a/./a",
             "a/../a",
-            ]
+        ]
         for p in needs_normpath:
             assert needs_normpath_match(p) is not None, p
 
@@ -952,7 +986,7 @@ class FSTestCase(_tempdirTestCase):
         assert isinstance(d1, SCons.Node.FS.Dir)
         assert d1.cwd is d1, d1
 
-        f1 = fs.File('f1', directory = d1)
+        f1 = fs.File('f1', directory=d1)
         assert isinstance(f1, SCons.Node.FS.File)
 
         d1_f1 = os.path.join('d1', 'f1')
@@ -1035,6 +1069,7 @@ class FSTestCase(_tempdirTestCase):
                 if p[0] == os.sep:
                     p = drive + p
                 return p
+
             path = strip_slash(path_)
             abspath = strip_slash(abspath_)
             up_path = strip_slash(up_path_)
@@ -1048,51 +1083,51 @@ class FSTestCase(_tempdirTestCase):
                     name = os.sep
 
             if dir.up() is None:
-                dir_up_path =  dir.get_internal_path()
+                dir_up_path = dir.get_internal_path()
             else:
-                dir_up_path =  dir.up().get_internal_path()
+                dir_up_path = dir.up().get_internal_path()
 
             assert dir.name == name, \
-                   "dir.name %s != expected name %s" % \
-                   (dir.name, name)
+                "dir.name %s != expected name %s" % \
+                (dir.name, name)
             assert dir.get_internal_path() == path, \
-                   "dir.path %s != expected path %s" % \
-                   (dir.get_internal_path(), path)
+                "dir.path %s != expected path %s" % \
+                (dir.get_internal_path(), path)
             assert str(dir) == path, \
-                   "str(dir) %s != expected path %s" % \
-                   (str(dir), path)
+                "str(dir) %s != expected path %s" % \
+                (str(dir), path)
             assert dir.get_abspath() == abspath, \
-                   "dir.abspath %s != expected absolute path %s" % \
-                   (dir.get_abspath(), abspath)
+                "dir.abspath %s != expected absolute path %s" % \
+                (dir.get_abspath(), abspath)
             assert dir_up_path == up_path, \
-                   "dir.up().path %s != expected parent path %s" % \
-                   (dir_up_path, up_path)
+                "dir.up().path %s != expected parent path %s" % \
+                (dir_up_path, up_path)
 
         for sep in seps:
 
             def Dir_test(lpath, path_, abspath_, up_path_, sep=sep, func=_do_Dir_test):
                 return func(lpath, path_, abspath_, up_path_, sep)
-            
-            Dir_test('/',           '/',           '/',               '/')
-            Dir_test('',            './',          sub_dir,           sub)
-            Dir_test('foo',         'foo/',        sub_dir_foo,       './')
-            Dir_test('foo/bar',     'foo/bar/',    sub_dir_foo_bar,   'foo/')
-            Dir_test('/foo',        '/foo/',       '/foo/',           '/')
-            Dir_test('/foo/bar',    '/foo/bar/',   '/foo/bar/',       '/foo/')
-            Dir_test('..',          sub,           sub,               wp)
-            Dir_test('foo/..',      './',          sub_dir,           sub)
-            Dir_test('../foo',      sub_foo,       sub_foo,           sub)
-            Dir_test('.',           './',          sub_dir,           sub)
-            Dir_test('./.',         './',          sub_dir,           sub)
-            Dir_test('foo/./bar',   'foo/bar/',    sub_dir_foo_bar,   'foo/')
-            Dir_test('#../foo',     sub_foo,       sub_foo,           sub)
-            Dir_test('#/../foo',    sub_foo,       sub_foo,           sub)
-            Dir_test('#foo/bar',    'foo/bar/',    sub_dir_foo_bar,   'foo/')
-            Dir_test('#/foo/bar',   'foo/bar/',    sub_dir_foo_bar,   'foo/')
-            Dir_test('#',           './',          sub_dir,           sub)
+
+            Dir_test('/', '/', '/', '/')
+            Dir_test('', './', sub_dir, sub)
+            Dir_test('foo', 'foo/', sub_dir_foo, './')
+            Dir_test('foo/bar', 'foo/bar/', sub_dir_foo_bar, 'foo/')
+            Dir_test('/foo', '/foo/', '/foo/', '/')
+            Dir_test('/foo/bar', '/foo/bar/', '/foo/bar/', '/foo/')
+            Dir_test('..', sub, sub, wp)
+            Dir_test('foo/..', './', sub_dir, sub)
+            Dir_test('../foo', sub_foo, sub_foo, sub)
+            Dir_test('.', './', sub_dir, sub)
+            Dir_test('./.', './', sub_dir, sub)
+            Dir_test('foo/./bar', 'foo/bar/', sub_dir_foo_bar, 'foo/')
+            Dir_test('#../foo', sub_foo, sub_foo, sub)
+            Dir_test('#/../foo', sub_foo, sub_foo, sub)
+            Dir_test('#foo/bar', 'foo/bar/', sub_dir_foo_bar, 'foo/')
+            Dir_test('#/foo/bar', 'foo/bar/', sub_dir_foo_bar, 'foo/')
+            Dir_test('#', './', sub_dir, sub)
 
             try:
-                f2 = fs.File(sep.join(['f1', 'f2']), directory = d1)
+                f2 = fs.File(sep.join(['f1', 'f2']), directory=d1)
             except TypeError as x:
                 assert str(x) == ("Tried to lookup File '%s' as a Dir." %
                                   d1_f1), x
@@ -1134,16 +1169,15 @@ class FSTestCase(_tempdirTestCase):
             e1 = fs.Entry(p)
             e2 = fs.Entry(path)
             assert e1 is e2, (e1, e2)
-            a=str(e1)
-            b=str(e2)
-            assert a == b, ("Strings should match for same file/node\n%s\n%s"%(a,b))
-
+            a = str(e1)
+            b = str(e2)
+            assert a == b, ("Strings should match for same file/node\n%s\n%s" % (a, b))
 
         # Test for a bug in 0.04 that did not like looking up
         # dirs with a trailing slash on Windows.
-        d=fs.Dir('./')
+        d = fs.Dir('./')
         assert d.get_internal_path() == '.', d.get_abspath()
-        d=fs.Dir('foo/')
+        d = fs.Dir('foo/')
         assert d.get_internal_path() == 'foo', d.get_abspath()
 
         # Test for sub-classing of node building.
@@ -1151,7 +1185,7 @@ class FSTestCase(_tempdirTestCase):
 
         built_it = None
         assert not built_it
-        d1.add_source([SCons.Node.Node()])    # XXX FAKE SUBCLASS ATTRIBUTE
+        d1.add_source([SCons.Node.Node()])  # XXX FAKE SUBCLASS ATTRIBUTE
         d1.builder_set(Builder(fs.File))
         d1.reset_executor()
         d1.env_set(Environment())
@@ -1160,7 +1194,7 @@ class FSTestCase(_tempdirTestCase):
 
         built_it = None
         assert not built_it
-        f1.add_source([SCons.Node.Node()])    # XXX FAKE SUBCLASS ATTRIBUTE
+        f1.add_source([SCons.Node.Node()])  # XXX FAKE SUBCLASS ATTRIBUTE
         f1.builder_set(Builder(fs.File))
         f1.reset_executor()
         f1.env_set(Environment())
@@ -1244,9 +1278,11 @@ class FSTestCase(_tempdirTestCase):
 
         class MyScanner(Scanner):
             call_count = 0
+
             def __call__(self, node, env, path):
                 self.call_count = self.call_count + 1
                 return Scanner.__call__(self, node, env, path)
+
         s = MyScanner(xyz)
 
         deps = f12.get_found_includes(env, s, t1)
@@ -1265,8 +1301,6 @@ class FSTestCase(_tempdirTestCase):
         assert deps == [xyz], deps
         assert s.call_count == 3, s.call_count
 
-
-
         # Make sure we can scan this file even if the target isn't
         # a file that has a scanner (it might be an Alias, e.g.).
         class DummyNode(object):
@@ -1296,7 +1330,7 @@ class FSTestCase(_tempdirTestCase):
 
         f1 = fs.File(test.workpath("do_i_exist"))
         assert not f1.exists()
-        test.write("do_i_exist","\n")
+        test.write("do_i_exist", "\n")
         assert not f1.exists(), "exists() call not cached"
         f1.built()
         assert f1.exists(), "exists() call caching not reset"
@@ -1310,14 +1344,14 @@ class FSTestCase(_tempdirTestCase):
         # get_contents() returns the binary contents.
         test.write("binary_file", "Foo\x1aBar")
         f1 = fs.File(test.workpath("binary_file"))
-        assert f1.get_contents() == bytearray("Foo\x1aBar",'utf-8'), f1.get_contents()
+        assert f1.get_contents() == bytearray("Foo\x1aBar", 'utf-8'), f1.get_contents()
 
         # This tests to make sure we can decode UTF-8 text files.
         test_string = u"Foo\x1aBar"
         test.write("utf8_file", test_string.encode('utf-8'))
         f1 = fs.File(test.workpath("utf8_file"))
         assert eval('f1.get_text_contents() == u"Foo\x1aBar"'), \
-               f1.get_text_contents()
+            f1.get_text_contents()
 
         # Check for string which doesn't have BOM and isn't valid
         # ASCII
@@ -1325,11 +1359,11 @@ class FSTestCase(_tempdirTestCase):
         test.write('latin1_file', test_string)
         f1 = fs.File(test.workpath("latin1_file"))
         assert f1.get_text_contents() == test_string.decode('latin-1'), \
-               f1.get_text_contents()
+            f1.get_text_contents()
 
         def nonexistent(method, s):
             try:
-                x = method(s, create = 0)
+                x = method(s, create=0)
             except SCons.Errors.UserError:
                 pass
             else:
@@ -1367,15 +1401,15 @@ class FSTestCase(_tempdirTestCase):
         f = fs.File('f_local')
         assert f._local == 0
 
-        #XXX test_is_up_to_date() for directories
+        # XXX test_is_up_to_date() for directories
 
-        #XXX test_sconsign() for directories
+        # XXX test_sconsign() for directories
 
-        #XXX test_set_signature() for directories
+        # XXX test_set_signature() for directories
 
-        #XXX test_build() for directories
+        # XXX test_build() for directories
 
-        #XXX test_root()
+        # XXX test_root()
 
         # test Entry.get_contents()
         e = fs.Entry('does_not_exist')
@@ -1387,7 +1421,7 @@ class FSTestCase(_tempdirTestCase):
         try:
             e = fs.Entry('file')
             c = e.get_contents()
-            assert c == bytearray("file\n",'utf-8'), c
+            assert c == bytearray("file\n", 'utf-8'), c
             assert e.__class__ == SCons.Node.FS.File
         finally:
             test.unlink("file")
@@ -1541,7 +1575,7 @@ class FSTestCase(_tempdirTestCase):
         f = fs.Entry('foo/bar/baz')
         assert f.for_signature() == 'baz', f.for_signature()
         assert f.get_string(0) == os.path.normpath('foo/bar/baz'), \
-               f.get_string(0)
+            f.get_string(0)
         assert f.get_string(1) == 'baz', f.get_string(1)
 
     def test_drive_letters(self):
@@ -1556,26 +1590,26 @@ class FSTestCase(_tempdirTestCase):
             drive, path = os.path.splitdrive(x)
             return 'X:' + path
 
-        wp              = drive_workpath([''])
+        wp = drive_workpath([''])
 
         if wp[-1] in (os.sep, '/'):
-            tmp         = os.path.split(wp[:-1])[0]
+            tmp = os.path.split(wp[:-1])[0]
         else:
-            tmp         = os.path.split(wp)[0]
+            tmp = os.path.split(wp)[0]
 
-        parent_tmp      = os.path.split(tmp)[0]
+        parent_tmp = os.path.split(tmp)[0]
         if parent_tmp == 'X:':
             parent_tmp = 'X:' + os.sep
 
-        tmp_foo         = os.path.join(tmp, 'foo')
+        tmp_foo = os.path.join(tmp, 'foo')
 
-        foo             = drive_workpath(['foo'])
-        foo_bar         = drive_workpath(['foo', 'bar'])
-        sub             = drive_workpath(['sub', ''])
-        sub_dir         = drive_workpath(['sub', 'dir', ''])
-        sub_dir_foo     = drive_workpath(['sub', 'dir', 'foo', ''])
+        foo = drive_workpath(['foo'])
+        foo_bar = drive_workpath(['foo', 'bar'])
+        sub = drive_workpath(['sub', ''])
+        sub_dir = drive_workpath(['sub', 'dir', ''])
+        sub_dir_foo = drive_workpath(['sub', 'dir', 'foo', ''])
         sub_dir_foo_bar = drive_workpath(['sub', 'dir', 'foo', 'bar', ''])
-        sub_foo         = drive_workpath(['sub', 'foo', ''])
+        sub_foo = drive_workpath(['sub', 'foo', ''])
 
         fs = SCons.Node.FS.FS()
 
@@ -1594,22 +1628,23 @@ class FSTestCase(_tempdirTestCase):
                 if p[-1] == os.sep and len(p) > 3:
                     p = p[:-1]
                 return p
+
             path = strip_slash(path_)
             up_path = strip_slash(up_path_)
             name = path.split(os.sep)[-1]
 
             assert dir.name == name, \
-                   "dir.name %s != expected name %s" % \
-                   (dir.name, name)
+                "dir.name %s != expected name %s" % \
+                (dir.name, name)
             assert dir.get_internal_path() == path, \
-                   "dir.path %s != expected path %s" % \
-                   (dir.get_internal_path(), path)
+                "dir.path %s != expected path %s" % \
+                (dir.get_internal_path(), path)
             assert str(dir) == path, \
-                   "str(dir) %s != expected path %s" % \
-                   (str(dir), path)
+                "str(dir) %s != expected path %s" % \
+                (str(dir), path)
             assert dir.up().get_internal_path() == up_path, \
-                   "dir.up().path %s != expected parent path %s" % \
-                   (dir.up().get_internal_path(), up_path)
+                "dir.up().path %s != expected parent path %s" % \
+                (dir.up().get_internal_path(), up_path)
 
         save_os_path = os.path
         save_os_sep = os.sep
@@ -1620,26 +1655,25 @@ class FSTestCase(_tempdirTestCase):
             SCons.Node.FS.initialize_do_splitdrive()
 
             for sep in seps:
-
                 def Dir_test(lpath, path_, up_path_, sep=sep, func=_do_Dir_test):
                     return func(lpath, path_, up_path_, sep)
 
-                Dir_test('#X:',         wp,             tmp)
-                Dir_test('X:foo',       foo,            wp)
-                Dir_test('X:foo/bar',   foo_bar,        foo)
-                Dir_test('X:/foo',      'X:/foo',       'X:/')
-                Dir_test('X:/foo/bar',  'X:/foo/bar/',  'X:/foo/')
-                Dir_test('X:..',        tmp,            parent_tmp)
-                Dir_test('X:foo/..',    wp,             tmp)
-                Dir_test('X:../foo',    tmp_foo,        tmp)
-                Dir_test('X:.',         wp,             tmp)
-                Dir_test('X:./.',       wp,             tmp)
-                Dir_test('X:foo/./bar', foo_bar,        foo)
-                Dir_test('#X:../foo',   tmp_foo,        tmp)
-                Dir_test('#X:/../foo',  tmp_foo,        tmp)
-                Dir_test('#X:foo/bar',  foo_bar,        foo)
-                Dir_test('#X:/foo/bar', foo_bar,        foo)
-                Dir_test('#X:/',        wp,             tmp)
+                Dir_test('#X:', wp, tmp)
+                Dir_test('X:foo', foo, wp)
+                Dir_test('X:foo/bar', foo_bar, foo)
+                Dir_test('X:/foo', 'X:/foo', 'X:/')
+                Dir_test('X:/foo/bar', 'X:/foo/bar/', 'X:/foo/')
+                Dir_test('X:..', tmp, parent_tmp)
+                Dir_test('X:foo/..', wp, tmp)
+                Dir_test('X:../foo', tmp_foo, tmp)
+                Dir_test('X:.', wp, tmp)
+                Dir_test('X:./.', wp, tmp)
+                Dir_test('X:foo/./bar', foo_bar, foo)
+                Dir_test('#X:../foo', tmp_foo, tmp)
+                Dir_test('#X:/../foo', tmp_foo, tmp)
+                Dir_test('#X:foo/bar', foo_bar, foo)
+                Dir_test('#X:/foo/bar', foo_bar, foo)
+                Dir_test('#X:/', wp, tmp)
         finally:
             os.path = save_os_path
             os.sep = save_os_sep
@@ -1670,24 +1704,24 @@ class FSTestCase(_tempdirTestCase):
             path = strip_slash(path)
             return '//' + path[1:]
 
-        wp              = unc_workpath([''])
+        wp = unc_workpath([''])
 
         if wp[-1] in (os.sep, '/'):
-            tmp         = os.path.split(wp[:-1])[0]
+            tmp = os.path.split(wp[:-1])[0]
         else:
-            tmp         = os.path.split(wp)[0]
+            tmp = os.path.split(wp)[0]
 
-        parent_tmp      = os.path.split(tmp)[0]
+        parent_tmp = os.path.split(tmp)[0]
 
-        tmp_foo         = os.path.join(tmp, 'foo')
+        tmp_foo = os.path.join(tmp, 'foo')
 
-        foo             = unc_workpath(['foo'])
-        foo_bar         = unc_workpath(['foo', 'bar'])
-        sub             = unc_workpath(['sub', ''])
-        sub_dir         = unc_workpath(['sub', 'dir', ''])
-        sub_dir_foo     = unc_workpath(['sub', 'dir', 'foo', ''])
+        foo = unc_workpath(['foo'])
+        foo_bar = unc_workpath(['foo', 'bar'])
+        sub = unc_workpath(['sub', ''])
+        sub_dir = unc_workpath(['sub', 'dir', ''])
+        sub_dir_foo = unc_workpath(['sub', 'dir', 'foo', ''])
         sub_dir_foo_bar = unc_workpath(['sub', 'dir', 'foo', 'bar', ''])
-        sub_foo         = unc_workpath(['sub', 'foo', ''])
+        sub_foo = unc_workpath(['sub', 'foo', ''])
 
         fs = SCons.Node.FS.FS()
 
@@ -1708,22 +1742,22 @@ class FSTestCase(_tempdirTestCase):
                 name = path.split(os.sep)[-1]
 
             if dir.up() is None:
-                dir_up_path =  dir.get_internal_path()
+                dir_up_path = dir.get_internal_path()
             else:
-                dir_up_path =  dir.up().get_internal_path()
+                dir_up_path = dir.up().get_internal_path()
 
             assert dir.name == name, \
-                   "dir.name %s != expected name %s" % \
-                   (dir.name, name)
+                "dir.name %s != expected name %s" % \
+                (dir.name, name)
             assert dir.get_internal_path() == path, \
-                   "dir.path %s != expected path %s" % \
-                   (dir.get_internal_path(), path)
+                "dir.path %s != expected path %s" % \
+                (dir.get_internal_path(), path)
             assert str(dir) == path, \
-                   "str(dir) %s != expected path %s" % \
-                   (str(dir), path)
+                "str(dir) %s != expected path %s" % \
+                (str(dir), path)
             assert dir_up_path == up_path, \
-                   "dir.up().path %s != expected parent path %s" % \
-                   (dir.up().get_internal_path(), up_path)
+                "dir.up().path %s != expected parent path %s" % \
+                (dir.up().get_internal_path(), up_path)
 
         save_os_path = os.path
         save_os_sep = os.sep
@@ -1734,28 +1768,27 @@ class FSTestCase(_tempdirTestCase):
             SCons.Node.FS.initialize_do_splitdrive()
 
             for sep in seps:
-
                 def Dir_test(lpath, path_, up_path_, sep=sep, func=_do_Dir_test):
                     return func(lpath, path_, up_path_, sep)
 
-                Dir_test('//foo',           '//foo',       '//')
-                Dir_test('//foo/bar',       '//foo/bar',   '//foo')
-                Dir_test('//',              '//',          '//')
-                Dir_test('//..',            '//',          '//')
-                Dir_test('//foo/..',        '//',          '//')
-                Dir_test('//../foo',        '//foo',       '//')
-                Dir_test('//.',             '//',          '//')
-                Dir_test('//./.',           '//',          '//')
-                Dir_test('//foo/./bar',     '//foo/bar',   '//foo')
-                Dir_test('//foo/../bar',    '//bar',       '//')
-                Dir_test('//foo/../../bar', '//bar',       '//')
-                Dir_test('//foo/bar/../..', '//',          '//')
-                Dir_test('#//',         wp,            tmp)
-                Dir_test('#//../foo',   tmp_foo,       tmp)
-                Dir_test('#//../foo',   tmp_foo,       tmp)
-                Dir_test('#//foo/bar',  foo_bar,       foo)
-                Dir_test('#//foo/bar',  foo_bar,       foo)
-                Dir_test('#//',         wp,            tmp)
+                Dir_test('//foo', '//foo', '//')
+                Dir_test('//foo/bar', '//foo/bar', '//foo')
+                Dir_test('//', '//', '//')
+                Dir_test('//..', '//', '//')
+                Dir_test('//foo/..', '//', '//')
+                Dir_test('//../foo', '//foo', '//')
+                Dir_test('//.', '//', '//')
+                Dir_test('//./.', '//', '//')
+                Dir_test('//foo/./bar', '//foo/bar', '//foo')
+                Dir_test('//foo/../bar', '//bar', '//')
+                Dir_test('//foo/../../bar', '//bar', '//')
+                Dir_test('//foo/bar/../..', '//', '//')
+                Dir_test('#//', wp, tmp)
+                Dir_test('#//../foo', tmp_foo, tmp)
+                Dir_test('#//../foo', tmp_foo, tmp)
+                Dir_test('#//foo/bar', foo_bar, foo)
+                Dir_test('#//foo/bar', foo_bar, foo)
+                Dir_test('#//', wp, tmp)
         finally:
             os.path = save_os_path
             os.sep = save_os_sep
@@ -1810,7 +1843,7 @@ class FSTestCase(_tempdirTestCase):
         d1 = fs.Dir('d1')
         d2 = d1.Dir('d2')
         dirs = os.path.normpath(d2.get_abspath()).split(os.sep)
-        above_path = os.path.join(*['..']*len(dirs) + ['above'])
+        above_path = os.path.join(*['..'] * len(dirs) + ['above'])
         above = d2.Dir(above_path)
 
     def test_lookup_abs(self):
@@ -1828,13 +1861,13 @@ class FSTestCase(_tempdirTestCase):
             return
         test = self.test
         fs = self.fs
-        path='//servername/C$/foo'
+        path = '//servername/C$/foo'
         f = self.fs._lookup('//servername/C$/foo', fs.Dir('#'), SCons.Node.FS.File)
         # before the fix in this commit, this returned 'C:\servername\C$\foo'
         # Should be a normalized Windows UNC path as below.
         assert str(f) == r'\\servername\C$\foo', \
-        'UNC path %s got looked up as %s'%(path, f)
- 
+            'UNC path %s got looked up as %s' % (path, f)
+
     def test_unc_drive_letter(self):
         """Test drive-letter lookup for windows UNC-style directories"""
         if sys.platform not in ('win32',):
@@ -1869,56 +1902,56 @@ class FSTestCase(_tempdirTestCase):
         d3_d4_f = d3_d4.File('f')
 
         cases = [
-                d1,             d1,             '.',
-                d1,             d1_f,           'f',
-                d1,             d1_d2,          'd2',
-                d1,             d1_d2_f,        'd2/f',
-                d1,             d3,             '../d3',
-                d1,             d3_f,           '../d3/f',
-                d1,             d3_d4,          '../d3/d4',
-                d1,             d3_d4_f,        '../d3/d4/f',
-
-                d1_f,           d1,             '.',
-                d1_f,           d1_f,           'f',
-                d1_f,           d1_d2,          'd2',
-                d1_f,           d1_d2_f,        'd2/f',
-                d1_f,           d3,             '../d3',
-                d1_f,           d3_f,           '../d3/f',
-                d1_f,           d3_d4,          '../d3/d4',
-                d1_f,           d3_d4_f,        '../d3/d4/f',
-
-                d1_d2,          d1,             '..',
-                d1_d2,          d1_f,           '../f',
-                d1_d2,          d1_d2,          '.',
-                d1_d2,          d1_d2_f,        'f',
-                d1_d2,          d3,             '../../d3',
-                d1_d2,          d3_f,           '../../d3/f',
-                d1_d2,          d3_d4,          '../../d3/d4',
-                d1_d2,          d3_d4_f,        '../../d3/d4/f',
-
-                d1_d2_f,        d1,             '..',
-                d1_d2_f,        d1_f,           '../f',
-                d1_d2_f,        d1_d2,          '.',
-                d1_d2_f,        d1_d2_f,        'f',
-                d1_d2_f,        d3,             '../../d3',
-                d1_d2_f,        d3_f,           '../../d3/f',
-                d1_d2_f,        d3_d4,          '../../d3/d4',
-                d1_d2_f,        d3_d4_f,        '../../d3/d4/f',
+            d1, d1, '.',
+            d1, d1_f, 'f',
+            d1, d1_d2, 'd2',
+            d1, d1_d2_f, 'd2/f',
+            d1, d3, '../d3',
+            d1, d3_f, '../d3/f',
+            d1, d3_d4, '../d3/d4',
+            d1, d3_d4_f, '../d3/d4/f',
+
+            d1_f, d1, '.',
+            d1_f, d1_f, 'f',
+            d1_f, d1_d2, 'd2',
+            d1_f, d1_d2_f, 'd2/f',
+            d1_f, d3, '../d3',
+            d1_f, d3_f, '../d3/f',
+            d1_f, d3_d4, '../d3/d4',
+            d1_f, d3_d4_f, '../d3/d4/f',
+
+            d1_d2, d1, '..',
+            d1_d2, d1_f, '../f',
+            d1_d2, d1_d2, '.',
+            d1_d2, d1_d2_f, 'f',
+            d1_d2, d3, '../../d3',
+            d1_d2, d3_f, '../../d3/f',
+            d1_d2, d3_d4, '../../d3/d4',
+            d1_d2, d3_d4_f, '../../d3/d4/f',
+
+            d1_d2_f, d1, '..',
+            d1_d2_f, d1_f, '../f',
+            d1_d2_f, d1_d2, '.',
+            d1_d2_f, d1_d2_f, 'f',
+            d1_d2_f, d3, '../../d3',
+            d1_d2_f, d3_f, '../../d3/f',
+            d1_d2_f, d3_d4, '../../d3/d4',
+            d1_d2_f, d3_d4_f, '../../d3/d4/f',
         ]
 
         if sys.platform in ('win32',):
-            x_d1        = fs.Dir(r'X:\d1')
-            x_d1_d2     = x_d1.Dir('d2')
-            y_d1        = fs.Dir(r'Y:\d1')
-            y_d1_d2     = y_d1.Dir('d2')
-            y_d2        = fs.Dir(r'Y:\d2')
+            x_d1 = fs.Dir(r'X:\d1')
+            x_d1_d2 = x_d1.Dir('d2')
+            y_d1 = fs.Dir(r'Y:\d1')
+            y_d1_d2 = y_d1.Dir('d2')
+            y_d2 = fs.Dir(r'Y:\d2')
 
             win32_cases = [
-                x_d1,           x_d1,           '.',
-                x_d1,           x_d1_d2,        'd2',
-                x_d1,           y_d1,           r'Y:\d1',
-                x_d1,           y_d1_d2,        r'Y:\d1\d2',
-                x_d1,           y_d2,           r'Y:\d2',
+                x_d1, x_d1, '.',
+                x_d1, x_d1_d2, 'd2',
+                x_d1, y_d1, r'Y:\d1',
+                x_d1, y_d1_d2, r'Y:\d1\d2',
+                x_d1, y_d2, r'Y:\d2',
             ]
 
             cases.extend(win32_cases)
@@ -1939,14 +1972,15 @@ class FSTestCase(_tempdirTestCase):
     def test_proxy(self):
         """Test a Node.FS object wrapped in a proxy instance"""
         f1 = self.fs.File('fff')
+
         class MyProxy(SCons.Util.Proxy):
             __str__ = SCons.Util.Delegate('__str__')
+
         p = MyProxy(f1)
         f2 = self.fs.Entry(p)
         assert f1 is f2, (f1, str(f1), f2, str(f2))
 
 
-
 class DirTestCase(_tempdirTestCase):
 
     def test__morph(self):
@@ -1963,8 +1997,10 @@ class DirTestCase(_tempdirTestCase):
 
     def test_subclass(self):
         """Test looking up subclass of Dir nodes"""
+
         class DirSubclass(SCons.Node.FS.Dir):
             pass
+
         sd = self.fs._lookup('special_dir', None, DirSubclass, create=1)
         sd.must_be_same(SCons.Node.FS.Dir)
 
@@ -2011,9 +2047,9 @@ class DirTestCase(_tempdirTestCase):
         test.subdir('d')
         test.write(['d', 'g'], "67890\n")
         test.write(['d', 'f'], "12345\n")
-        test.subdir(['d','sub'])
-        test.write(['d', 'sub','h'], "abcdef\n")
-        test.subdir(['d','empty'])
+        test.subdir(['d', 'sub'])
+        test.write(['d', 'sub', 'h'], "abcdef\n")
+        test.subdir(['d', 'empty'])
 
         d = self.fs.Dir('d')
         g = self.fs.File(os.path.join('d', 'g'))
@@ -2026,10 +2062,10 @@ class DirTestCase(_tempdirTestCase):
 
         assert e.get_contents() == '', e.get_contents()
         assert e.get_text_contents() == '', e.get_text_contents()
-        assert e.get_csig()+" empty" == files[0], files
-        assert f.get_csig()+" f" == files[1], files
-        assert g.get_csig()+" g" == files[2], files
-        assert s.get_csig()+" sub" == files[3], files
+        assert e.get_csig() + " empty" == files[0], files
+        assert f.get_csig() + " f" == files[1], files
+        assert g.get_csig() + " g" == files[2], files
+        assert s.get_csig() + " sub" == files[3], files
 
     def test_implicit_re_scans(self):
         """Test that adding entries causes a directory to be re-scanned
@@ -2087,7 +2123,7 @@ class DirTestCase(_tempdirTestCase):
         d = self.fs.Dir('d')
         r = self.fs.Dir('r')
         d.addRepository(r)
-        
+
         assert d.rentry_exists_on_disk('exists')
         assert d.rentry_exists_on_disk('rexists')
         assert not d.rentry_exists_on_disk('does_not_exist')
@@ -2193,7 +2229,7 @@ class DirTestCase(_tempdirTestCase):
 
         SCons.Node._is_derived_map[2] = return_true
         SCons.Node._exists_map[5] = return_true
-        
+
         test.subdir('src0')
         test.write(['src0', 'on-disk-f1'], "src0/on-disk-f1\n")
         test.write(['src0', 'on-disk-f2'], "src0/on-disk-f2\n")
@@ -2341,6 +2377,7 @@ class DirTestCase(_tempdirTestCase):
         r = sub.file_on_disk('dir')
         assert not r, r
 
+
 class EntryTestCase(_tempdirTestCase):
     def test_runTest(self):
         """Test methods specific to the Entry sub-class.
@@ -2391,16 +2428,20 @@ class EntryTestCase(_tempdirTestCase):
         class MyCalc(object):
             def __init__(self, val):
                 self.max_drift = 0
+
                 class M(object):
                     def __init__(self, val):
                         self.val = val
+
                     def collect(self, args):
                         result = 0
                         for a in args:
                             result += a
                         return result
+
                     def signature(self, executor):
                         return self.val + 222
+
                 self.module = M(val)
 
         test.subdir('e5d')
@@ -2412,13 +2453,14 @@ class EntryTestCase(_tempdirTestCase):
         self.fs.Entry('#topdir/a/b/c')
 
 
-
 class FileTestCase(_tempdirTestCase):
 
     def test_subclass(self):
         """Test looking up subclass of File nodes"""
+
         class FileSubclass(SCons.Node.FS.File):
             pass
+
         sd = self.fs._lookup('special_file', None, FileSubclass, create=1)
         sd.must_be_same(SCons.Node.FS.File)
 
@@ -2462,7 +2504,8 @@ class FileTestCase(_tempdirTestCase):
         build_f1.clear()
         build_f1.linked = None
         assert not build_f1.exists(), "%s did not realize that %s disappeared" % (build_f1, src_f1)
-        assert not os.path.exists(build_f1.get_abspath()), "%s did not get removed after %s was removed" % (build_f1, src_f1)
+        assert not os.path.exists(build_f1.get_abspath()), "%s did not get removed after %s was removed" % (
+        build_f1, src_f1)
 
     def test_changed(self):
         """ 
@@ -2471,6 +2514,7 @@ class FileTestCase(_tempdirTestCase):
         when using CacheDir and Timestamp-MD5 decider.
         This is for issue #2980
         """
+
         # node should have
         # 1 source (for example main.cpp)
         # 0 depends
@@ -2527,18 +2571,18 @@ class FileTestCase(_tempdirTestCase):
                 self.csig = csig
                 self.timestamp = timestamp
 
-        #Create nodes
+        # Create nodes
         fs = SCons.Node.FS.FS()
         d = self.fs.Dir('.')
 
-        node = ChangedNode('main.o',d,fs)  # main.o
-        s1 = ChangedNode('main.cpp',d,fs) # main.cpp
-        s1.timestamp = 2 # this changed
-        i1 = ChangedNode('alpha.h',d,fs) # alpha.h - The bug is caused because the second build adds this file
-        i1.timestamp = 2 # This is the new file.
-        i2 = ChangedNode('beta.h',d,fs) # beta.h
-        i3 = ChangedNode('gamma.h',d,fs) # gamma.h - In the bug beta.h's csig from binfo overwrites this ones
-        i4 = ChangedNode('/usr/bin/g++',d,fs) # /usr/bin/g++
+        node = ChangedNode('main.o', d, fs)  # main.o
+        s1 = ChangedNode('main.cpp', d, fs)  # main.cpp
+        s1.timestamp = 2  # this changed
+        i1 = ChangedNode('alpha.h', d, fs)  # alpha.h - The bug is caused because the second build adds this file
+        i1.timestamp = 2  # This is the new file.
+        i2 = ChangedNode('beta.h', d, fs)  # beta.h
+        i3 = ChangedNode('gamma.h', d, fs)  # gamma.h - In the bug beta.h's csig from binfo overwrites this ones
+        i4 = ChangedNode('/usr/bin/g++', d, fs)  # /usr/bin/g++
 
         node.add_source([s1])
         node.add_dependency([])
@@ -2569,34 +2613,35 @@ class FileTestCase(_tempdirTestCase):
         # "bdepends","bdependsigs", "bimplicit", "bimplicitsigs"
         bi = sconsign_entry.binfo
         bi.bsources = ['main.cpp']
-        bi.bsourcesigs=[FakeNodeInfo('main.cpp',1),]
+        bi.bsourcesigs = [FakeNodeInfo('main.cpp', 1), ]
 
         bi.bdepends = []
         bi.bdependsigs = []
 
-        bi.bimplicit = ['beta.h','gamma.h']
-        bi.bimplicitsigs = [FakeNodeInfo('beta.h',1), FakeNodeInfo('gamma.h',1)]
+        bi.bimplicit = ['beta.h', 'gamma.h']
+        bi.bimplicitsigs = [FakeNodeInfo('beta.h', 1), FakeNodeInfo('gamma.h', 1)]
 
         ni = sconsign_entry.ninfo
         # We'll set the following attributes (which are lists): sources, depends, implicit lists
 
-        #Set timestamp-md5
-        #Call changed
-        #Check results
+        # Set timestamp-md5
+        # Call changed
+        # Check results
         node.build_env = ChangedEnvironment()
 
         changed = node.changed()
 
         # change to true to debug
         if False:
-            print("Changed:%s"%changed)
-            print("%15s -> csig:%s"%(s1.name, s1.ninfo.csig))
-            print("%15s -> csig:%s"%(i1.name, i1.ninfo.csig))
-            print("%15s -> csig:%s"%(i2.name, i2.ninfo.csig))
-            print("%15s -> csig:%s"%(i3.name, i3.ninfo.csig))
-            print("%15s -> csig:%s"%(i4.name, i4.ninfo.csig))
+            print("Changed:%s" % changed)
+            print("%15s -> csig:%s" % (s1.name, s1.ninfo.csig))
+            print("%15s -> csig:%s" % (i1.name, i1.ninfo.csig))
+            print("%15s -> csig:%s" % (i2.name, i2.ninfo.csig))
+            print("%15s -> csig:%s" % (i3.name, i3.ninfo.csig))
+            print("%15s -> csig:%s" % (i4.name, i4.ninfo.csig))
 
-        self.assertEqual(i2.name,i2.ninfo.csig, "gamma.h's fake csig should equal gamma.h but equals:%s"%i2.ninfo.csig)
+        self.assertEqual(i2.name, i2.ninfo.csig,
+                         "gamma.h's fake csig should equal gamma.h but equals:%s" % i2.ninfo.csig)
 
 
 class GlobTestCase(_tempdirTestCase):
@@ -2665,7 +2710,6 @@ class GlobTestCase(_tempdirTestCase):
         self.sub_dir3_jjj = self.sub_dir3.File('jjj')
         self.sub_dir3_lll = self.sub_dir3.File('lll')
 
-
     def do_cases(self, cases, **kwargs):
 
         # First, execute all of the cases with string=True and verify
@@ -2713,17 +2757,17 @@ class GlobTestCase(_tempdirTestCase):
         join = os.path.join
 
         cases = (
-            ('ggg',         ['ggg'],                    [self.ggg]),
+            ('ggg', ['ggg'], [self.ggg]),
 
-            ('subdir1',     ['subdir1'],                [self.subdir1]),
+            ('subdir1', ['subdir1'], [self.subdir1]),
 
-            ('subdir1/jjj', [join('subdir1', 'jjj')],   [self.subdir1_jjj]),
+            ('subdir1/jjj', [join('subdir1', 'jjj')], [self.subdir1_jjj]),
 
-            ('disk-aaa',    ['disk-aaa'],               None),
+            ('disk-aaa', ['disk-aaa'], None),
 
-            ('disk-sub',    ['disk-sub'],               None),
+            ('disk-sub', ['disk-sub'], None),
 
-            ('both-aaa',    ['both-aaa'],               []),
+            ('both-aaa', ['both-aaa'], []),
         )
 
         self.do_cases(cases)
@@ -2818,8 +2862,8 @@ class GlobTestCase(_tempdirTestCase):
         """Test globbing for things that don't exist"""
 
         cases = (
-            ('does_not_exist',  [], []),
-            ('no_subdir/*',     [], []),
+            ('does_not_exist', [], []),
+            ('no_subdir/*', [], []),
             ('subdir?/no_file', [], []),
         )
 
@@ -2927,7 +2971,7 @@ class GlobTestCase(_tempdirTestCase):
         assert g == expect, str(g) + " is not sorted, but should be!"
 
         g = self.fs.Glob('disk-*', strings=True)
-        expect = [ 'disk-aaa', 'disk-bbb', 'disk-ccc', 'disk-sub' ]
+        expect = ['disk-aaa', 'disk-bbb', 'disk-ccc', 'disk-sub']
         assert g == expect, str(g) + " is not sorted, but should be!"
 
 
@@ -3060,10 +3104,13 @@ class RepositoryTestCase(_tempdirTestCase):
 
     def test_rdir(self):
         """Test the Dir.rdir() method"""
+
         def return_true(obj):
             return 1
+
         def return_false(obj):
             return 0
+
         SCons.Node._exists_map[5] = return_true
         SCons.Node._exists_map[6] = return_false
         SCons.Node._is_derived_map[2] = return_true
@@ -3113,10 +3160,13 @@ class RepositoryTestCase(_tempdirTestCase):
 
     def test_rfile(self):
         """Test the File.rfile() method"""
+
         def return_true(obj):
             return 1
+
         def return_false(obj):
             return 0
+
         SCons.Node._exists_map[5] = return_true
         SCons.Node._exists_map[6] = return_false
         SCons.Node._is_derived_map[2] = return_true
@@ -3255,7 +3305,7 @@ class RepositoryTestCase(_tempdirTestCase):
         test.write(["rep3", "contents"], "Con\x1aTents\n")
         try:
             c = fs.File("contents").get_contents()
-            assert c == bytearray("Con\x1aTents\n",'utf-8'), "got '%s'" % c
+            assert c == bytearray("Con\x1aTents\n", 'utf-8'), "got '%s'" % c
         finally:
             test.unlink(["rep3", "contents"])
 
@@ -3274,8 +3324,8 @@ class RepositoryTestCase(_tempdirTestCase):
             class FakeUnicodeString(collections.UserString):
                 def encode(self, encoding):
                     return str(self)
-            test_string = FakeUnicodeString("Con\x1aTents\n")
 
+            test_string = FakeUnicodeString("Con\x1aTents\n")
 
         # Test with ASCII.
         test.write(["rep3", "contents"], test_string.encode('ascii'))
@@ -3301,14 +3351,13 @@ class RepositoryTestCase(_tempdirTestCase):
         finally:
             test.unlink(["rep3", "contents"])
 
-    #def test_is_up_to_date(self):
-
+    # def test_is_up_to_date(self):
 
 
 class find_fileTestCase(unittest.TestCase):
     def runTest(self):
         """Testing find_file function"""
-        test = TestCmd(workdir = '')
+        test = TestCmd(workdir='')
         test.write('./foo', 'Some file\n')
         test.write('./foo2', 'Another file\n')
         test.subdir('same')
@@ -3321,9 +3370,9 @@ class find_fileTestCase(unittest.TestCase):
         os.chdir(test.workpath(""))
 
         node_derived = fs.File(test.workpath('bar/baz'))
-        node_derived.builder_set(1) # Any non-zero value.
+        node_derived.builder_set(1)  # Any non-zero value.
         node_pseudo = fs.File(test.workpath('pseudo'))
-        node_pseudo.set_src_builder(1) # Any non-zero value.
+        node_pseudo.set_src_builder(1)  # Any non-zero value.
 
         paths = tuple(map(fs.Dir, ['.', 'same', './bar']))
         nodes = [SCons.Node.FS.find_file('foo', paths)]
@@ -3376,12 +3425,13 @@ class find_fileTestCase(unittest.TestCase):
         finally:
             sys.stdout = save_sys_stdout
 
+
 class StringDirTestCase(unittest.TestCase):
     def runTest(self):
         """Test using a string as the second argument of
         File() and Dir()"""
 
-        test = TestCmd(workdir = '')
+        test = TestCmd(workdir='')
         test.subdir('sub')
         fs = SCons.Node.FS.FS(test.workpath(''))
 
@@ -3392,10 +3442,11 @@ class StringDirTestCase(unittest.TestCase):
         assert str(f) == os.path.join('sub', 'file')
         assert not f.exists()
 
+
 class stored_infoTestCase(unittest.TestCase):
     def runTest(self):
         """Test how we store build information"""
-        test = TestCmd(workdir = '')
+        test = TestCmd(workdir='')
         test.subdir('sub')
         fs = SCons.Node.FS.FS(test.workpath(''))
 
@@ -3408,9 +3459,10 @@ class stored_infoTestCase(unittest.TestCase):
             class Null(object):
                 def __init__(self):
                     self.xyzzy = 7
+
             def get_entry(self, name):
                 return self.Null()
-            
+
         def test_sconsign(node):
             return MySConsign()
 
@@ -3420,10 +3472,11 @@ class stored_infoTestCase(unittest.TestCase):
         bi = f.get_stored_info()
         assert bi.xyzzy == 7, bi
 
+
 class has_src_builderTestCase(unittest.TestCase):
     def runTest(self):
         """Test the has_src_builder() method"""
-        test = TestCmd(workdir = '')
+        test = TestCmd(workdir='')
         fs = SCons.Node.FS.FS(test.workpath(''))
         os.chdir(test.workpath(''))
         test.subdir('sub1')
@@ -3442,9 +3495,9 @@ class has_src_builderTestCase(unittest.TestCase):
         sub1.set_src_builder(b1)
 
         test.write(['sub1', 'f2'], "sub1/f2\n")
-        h = f1.has_src_builder()        # cached from previous call
+        h = f1.has_src_builder()  # cached from previous call
         assert not h, h
-        h = f1.has_builder()            # cached from previous call
+        h = f1.has_builder()  # cached from previous call
         assert not h, h
         h = f2.has_src_builder()
         assert not h, h
@@ -3456,6 +3509,7 @@ class has_src_builderTestCase(unittest.TestCase):
         assert h, h
         assert f3.builder is b1, f3.builder
 
+
 class prepareTestCase(unittest.TestCase):
     def runTest(self):
         """Test the prepare() method"""
@@ -3463,6 +3517,7 @@ class prepareTestCase(unittest.TestCase):
         class MyFile(SCons.Node.FS.File):
             def _createDir(self, update=None):
                 raise SCons.Errors.StopError
+
             def exists(self):
                 return None
 
@@ -3479,6 +3534,7 @@ class prepareTestCase(unittest.TestCase):
         class MkdirAction(Action):
             def __init__(self, dir_made):
                 self.dir_made = dir_made
+
             def __call__(self, target, source, env, executor=None):
                 if executor:
                     target = executor.get_all_targets()
@@ -3503,7 +3559,6 @@ class prepareTestCase(unittest.TestCase):
         dir.prepare()
 
 
-
 class SConstruct_dirTestCase(unittest.TestCase):
     def runTest(self):
         """Test setting the SConstruct directory"""
@@ -3513,7 +3568,6 @@ class SConstruct_dirTestCase(unittest.TestCase):
         assert fs.SConstruct_dir.get_internal_path() == 'xxx'
 
 
-
 class CacheDirTestCase(unittest.TestCase):
 
     def test_get_cachedir_csig(self):
@@ -3524,7 +3578,6 @@ class CacheDirTestCase(unittest.TestCase):
         assert r == 'd41d8cd98f00b204e9800998ecf8427e', r
 
 
-
 class clearTestCase(unittest.TestCase):
     def runTest(self):
         """Test clearing FS nodes of cached data."""
@@ -3534,11 +3587,11 @@ class clearTestCase(unittest.TestCase):
         e = fs.Entry('e')
         assert not e.exists()
         assert not e.rexists()
-        assert str(e) == 'e', str(d)
+        assert str(e) == 'e', str(e)
         e.clear()
         assert not e.exists()
         assert not e.rexists()
-        assert str(e) == 'e', str(d)
+        assert str(e) == 'e', str(e)
 
         d = fs.Dir(test.workpath('d'))
         test.subdir('d')
@@ -3552,10 +3605,10 @@ class clearTestCase(unittest.TestCase):
         assert str(d) == test.workpath('d'), str(d)
         # Now verify clear() resets the cache
         d.clear()
-        assert not d.exists()      
+        assert not d.exists()
         assert not d.rexists()
         assert str(d) == test.workpath('d'), str(d)
-        
+
         f = fs.File(test.workpath('f'))
         test.write(test.workpath('f'), 'file f')
         assert f.exists()
@@ -3573,7 +3626,6 @@ class clearTestCase(unittest.TestCase):
         assert str(f) == test.workpath('f'), str(f)
 
 
-
 class disambiguateTestCase(unittest.TestCase):
     def runTest(self):
         """Test calling the disambiguate() method."""
@@ -3635,6 +3687,7 @@ class disambiguateTestCase(unittest.TestCase):
         f = build_nonexistant.disambiguate()
         assert f.__class__ is fff.__class__, f.__class__
 
+
 class postprocessTestCase(unittest.TestCase):
     def runTest(self):
         """Test calling the postprocess() method."""
@@ -3650,11 +3703,10 @@ class postprocessTestCase(unittest.TestCase):
         f.postprocess()
 
 
-
 class SpecialAttrTestCase(unittest.TestCase):
     def runTest(self):
         """Test special attributes of file nodes."""
-        test=TestCmd(workdir='')
+        test = TestCmd(workdir='')
         fs = SCons.Node.FS.FS(test.workpath('work'))
 
         f = fs.Entry('foo/bar/baz.blat').get_subst_proxy()
@@ -3809,11 +3861,10 @@ class SpecialAttrTestCase(unittest.TestCase):
         assert caught, "did not catch expected AttributeError"
 
 
-
 class SaveStringsTestCase(unittest.TestCase):
     def runTest(self):
         """Test caching string values of nodes."""
-        test=TestCmd(workdir='')
+        test = TestCmd(workdir='')
 
         def setup(fs):
             fs.Dir('src')
@@ -3867,13 +3918,13 @@ class SaveStringsTestCase(unittest.TestCase):
 
         s = list(map(str, nodes))
         expect = list(map(os.path.normpath, ['src/f', 'd1/f', 'd0/b', 'd1/b']))
-        assert s == expect, 'node str() not cached: %s'%s
+        assert s == expect, 'node str() not cached: %s' % s
 
 
 class AbsolutePathTestCase(unittest.TestCase):
     def test_root_lookup_equivalence(self):
         """Test looking up /fff vs. fff in the / directory"""
-        test=TestCmd(workdir='')
+        test = TestCmd(workdir='')
 
         fs = SCons.Node.FS.FS('/')
 
@@ -3887,7 +3938,6 @@ class AbsolutePathTestCase(unittest.TestCase):
             os.chdir(save_cwd)
 
 
-
 if __name__ == "__main__":
     unittest.main()
 
diff --git a/src/engine/SCons/Node/NodeTests.py b/src/engine/SCons/Node/NodeTests.py
index 39b928b..ce44b7d 100644
--- a/src/engine/SCons/Node/NodeTests.py
+++ b/src/engine/SCons/Node/NodeTests.py
@@ -20,7 +20,7 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-__revision__ = "src/engine/SCons/Node/NodeTests.py 103260fce95bf5db1c35fb2371983087d85dd611 2019-07-13 18:25:30 bdbaddog"
+__revision__ = "src/engine/SCons/Node/NodeTests.py e724ae812eb96f4858a132f5b8c769724744faf6 2019-07-21 00:04:47 bdeegan"
 
 import SCons.compat
 
@@ -271,7 +271,7 @@ class NodeInfoBaseTestCase(unittest.TestCase):
 
         f = ni1.format()
         assert f == ['x', 'y', 'z'], f
- 
+
         field_list = ['xxx', 'zzz', 'aaa']
 
         f = ni1.format(field_list)
@@ -751,7 +751,7 @@ class NodeTestCase(unittest.TestCase):
         e = node.exists()
         assert e == 1, e
 
-    def test_exists(self):
+    def test_exists_repo(self):
         """Test evaluating whether a Node exists locally or in a repository.
         """
         node = SCons.Node.Node()
diff --git a/src/engine/SCons/Node/Python.py b/src/engine/SCons/Node/Python.py
index 30daf9a..d338051 100644
--- a/src/engine/SCons/Node/Python.py
+++ b/src/engine/SCons/Node/Python.py
@@ -27,7 +27,7 @@ Python nodes.
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 
-__revision__ = "src/engine/SCons/Node/Python.py 103260fce95bf5db1c35fb2371983087d85dd611 2019-07-13 18:25:30 bdbaddog"
+__revision__ = "src/engine/SCons/Node/Python.py e724ae812eb96f4858a132f5b8c769724744faf6 2019-07-21 00:04:47 bdeegan"
 
 import SCons.Node
 
diff --git a/src/engine/SCons/Node/PythonTests.py b/src/engine/SCons/Node/PythonTests.py
index 2b35f00..98137c7 100644
--- a/src/engine/SCons/Node/PythonTests.py
+++ b/src/engine/SCons/Node/PythonTests.py
@@ -21,7 +21,7 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 
-__revision__ = "src/engine/SCons/Node/PythonTests.py 103260fce95bf5db1c35fb2371983087d85dd611 2019-07-13 18:25:30 bdbaddog"
+__revision__ = "src/engine/SCons/Node/PythonTests.py e724ae812eb96f4858a132f5b8c769724744faf6 2019-07-21 00:04:47 bdeegan"
 
 import sys
 import unittest
diff --git a/src/engine/SCons/Node/__init__.py b/src/engine/SCons/Node/__init__.py
index 564e8de..5455bd6 100644
--- a/src/engine/SCons/Node/__init__.py
+++ b/src/engine/SCons/Node/__init__.py
@@ -43,13 +43,18 @@ from __future__ import print_function
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-__revision__ = "src/engine/SCons/Node/__init__.py 103260fce95bf5db1c35fb2371983087d85dd611 2019-07-13 18:25:30 bdbaddog"
+__revision__ = "src/engine/SCons/Node/__init__.py e724ae812eb96f4858a132f5b8c769724744faf6 2019-07-21 00:04:47 bdeegan"
 
 import os
 import collections
 import copy
 from itertools import chain
 
+try:
+    from itertools import zip_longest
+except ImportError:
+    from itertools import izip_longest as zip_longest
+
 import SCons.Debug
 from SCons.Debug import logInstanceCreation
 import SCons.Executor
@@ -103,9 +108,9 @@ implicit_deps_changed = 0
 
 # A variable that can be set to an interface-specific function be called
 # to annotate a Node with information about its creation.
-def do_nothing(node): pass
+def do_nothing_node(node): pass
 
-Annotate = do_nothing
+Annotate = do_nothing_node
 
 # Gets set to 'True' if we're running in interactive mode. Is
 # currently used to release parts of a target's info during
@@ -248,25 +253,10 @@ _target_from_source_map = {0 : target_from_source_none,
 # used by it.
 #
 
-
-class DeciderNeedsNode(Exception):
-    """
-    Indicate that the decider needs the node as well as the target and the dependency.
-    Normally the node and the target are the same, but in the case of repository
-    They may be different. Also the NodeInfo is retrieved from the node
-    """
-    def __init__(self, call_this_decider):
-        """
-        :param call_this_decider: to return the decider to call directly since deciders
-               are called through several levels of indirection
-        """
-        self.decider = call_this_decider
-
-
 #
 # First, the single decider functions
 #
-def changed_since_last_build_node(node, target, prev_ni):
+def changed_since_last_build_node(node, target, prev_ni, repo_node=None):
     """
 
     Must be overridden in a specific subclass to return True if this
@@ -287,7 +277,7 @@ def changed_since_last_build_node(node, target, prev_ni):
     raise NotImplementedError
 
 
-def changed_since_last_build_alias(node, target, prev_ni):
+def changed_since_last_build_alias(node, target, prev_ni, repo_node=None):
     cur_csig = node.get_csig()
     try:
         return cur_csig != prev_ni.csig
@@ -295,24 +285,24 @@ def changed_since_last_build_alias(node, target, prev_ni):
         return 1
 
 
-def changed_since_last_build_entry(node, target, prev_ni):
+def changed_since_last_build_entry(node, target, prev_ni, repo_node=None):
     node.disambiguate()
-    return _decider_map[node.changed_since_last_build](node, target, prev_ni)
+    return _decider_map[node.changed_since_last_build](node, target, prev_ni, repo_node)
 
 
-def changed_since_last_build_state_changed(node, target, prev_ni):
+def changed_since_last_build_state_changed(node, target, prev_ni, repo_node=None):
     return node.state != SCons.Node.up_to_date
 
 
-def decide_source(node, target, prev_ni):
-    return target.get_build_env().decide_source(node, target, prev_ni)
+def decide_source(node, target, prev_ni, repo_node=None):
+    return target.get_build_env().decide_source(node, target, prev_ni, repo_node)
 
 
-def decide_target(node, target, prev_ni):
-    return target.get_build_env().decide_target(node, target, prev_ni)
+def decide_target(node, target, prev_ni, repo_node=None):
+    return target.get_build_env().decide_target(node, target, prev_ni, repo_node)
 
 
-def changed_since_last_build_python(node, target, prev_ni):
+def changed_since_last_build_python(node, target, prev_ni, repo_node=None):
     cur_csig = node.get_csig()
     try:
         return cur_csig != prev_ni.csig
@@ -529,6 +519,7 @@ class Node(object, with_metaclass(NoSlotsPyPy)):
 
     __slots__ = ['sources',
                  'sources_set',
+                 'target_peers',
                  '_specific_sources',
                  'depends',
                  'depends_set',
@@ -784,6 +775,25 @@ class Node(object, with_metaclass(NoSlotsPyPy)):
         for parent in self.waiting_parents:
             parent.implicit = None
 
+            # Handle issue where builder emits more than one target and
+            # the source file for the builder is generated.
+            # in that case only the first target was getting it's .implicit
+            # cleared when the source file is built (second scan). 
+            # leaving only partial implicits from scan before source file is generated
+            # typically the compiler only. Then scanned files are appended
+            # This is persisted to sconsign and rebuild causes false rebuilds
+            # because the ordering of the implicit list then changes to what it
+            # should have been.
+            # This is at least the following bugs
+            # https://github.com/SCons/scons/issues/2811
+            # https://jira.mongodb.org/browse/SERVER-33111
+            try:
+                for peer in parent.target_peers:
+                    peer.implicit = None
+            except AttributeError:
+                pass
+
+
         self.clear()
 
         if self.pseudo:
@@ -1160,7 +1170,7 @@ class Node(object, with_metaclass(NoSlotsPyPy)):
             binfo.bactsig = SCons.Util.MD5signature(executor.get_contents())
 
         if self._specific_sources:
-            sources = [s for s in self.sources if not s in ignore_set]
+            sources = [s for s in self.sources if s not in ignore_set]
 
         else:
             sources = executor.get_unignored_sources(self, self.ignore)
@@ -1480,17 +1490,11 @@ class Node(object, with_metaclass(NoSlotsPyPy)):
             result = True
 
         for child, prev_ni in zip(children, then):
-            try:
-                if _decider_map[child.changed_since_last_build](child, self, prev_ni):
-                    if t: Trace(': %s changed' % child)
-                    result = True
-            except DeciderNeedsNode as e:
-                if e.decider(self, prev_ni, node=node):
-                    if t: Trace(': %s changed' % child)
-                    result = True
+            if _decider_map[child.changed_since_last_build](child, self, prev_ni, node):
+                if t: Trace(': %s changed' % child)
+                result = True
 
         if self.has_builder():
-            import SCons.Util
             contents = self.get_executor().get_contents()
             newsig = SCons.Util.MD5signature(contents)
             if bi.bactsig != newsig:
@@ -1647,14 +1651,14 @@ class Node(object, with_metaclass(NoSlotsPyPy)):
 
         lines = []
 
-        removed = [x for x in old_bkids if not x in new_bkids]
+        removed = [x for x in old_bkids if x not in new_bkids]
         if removed:
             removed = [stringify(r) for r in removed]
             fmt = "`%s' is no longer a dependency\n"
             lines.extend([fmt % s for s in removed])
 
         for k in new_bkids:
-            if not k in old_bkids:
+            if k not in old_bkids:
                 lines.append("`%s' is a new dependency\n" % stringify(k))
             else:
                 try:
@@ -1666,9 +1670,16 @@ class Node(object, with_metaclass(NoSlotsPyPy)):
                     lines.append("`%s' changed\n" % stringify(k))
 
         if len(lines) == 0 and old_bkids != new_bkids:
-            lines.append("the dependency order changed:\n" +
-                         "%sold: %s\n" % (' '*15, list(map(stringify, old_bkids))) +
-                         "%snew: %s\n" % (' '*15, list(map(stringify, new_bkids))))
+            lines.append("the dependency order changed:\n")
+            lines.append("->Sources\n")
+            for (o,n) in zip_longest(old.bsources, new.bsources, fillvalue=None):
+                lines.append("Old:%s\tNew:%s\n"%(o,n))
+            lines.append("->Depends\n")
+            for (o,n) in zip_longest(old.bdepends, new.bdepends, fillvalue=None):
+                lines.append("Old:%s\tNew:%s\n"%(o,n))
+            lines.append("->Implicit\n")
+            for (o,n) in zip_longest(old.bimplicit, new.bimplicit, fillvalue=None):
+                lines.append("Old:%s\tNew:%s\n"%(o,n))
 
         if len(lines) == 0:
             def fmt_with_title(title, strlines):
@@ -1711,7 +1722,6 @@ class Walker(object):
     This is depth-first, children are visited before the parent.
     The Walker object can be initialized with any node, and
     returns the next node on the descent with each get_next() call.
-    'kids_func' is an optional function that will be called to
     get the children of a node instead of calling 'children'.
     'cycle_func' is an optional function that will be called
     when a cycle is detected.