Merge pull request #3409 from grossag/topic/grossag/msvs

Upgrade and improve Visual Studio solution/project generation code

4 files changed, 285 insertions, 67 deletions

diff --git a/src/CHANGES.txt b/src/CHANGES.txt
index 89e0124..ce7e43a 100755
--- a/src/CHANGES.txt
+++ b/src/CHANGES.txt
@@ -52,6 +52,13 @@ RELEASE  VERSION/DATE TO BE FILLED IN LATER
           def my_decider(dependency, target, prev_ni, repo_node):
       Where repo_node is the repository (or other) node to use to check if the node is out of date instead of dependency.
 
+  From Adam Gross:
+    - Upgraded and improved Visual Studio solution/project generation code using the MSVSProject builder.
+      - Added support for Visual Studio 2017 and 2019.
+      - Added support for the following per-variant parameters to the builder:
+        - cpppaths: Provides per-variant include paths.
+        - cppdefines: Provides per-variant preprocessor definitions.
+
   From Michael Hartmann:
     - Fix handling of Visual Studio Compilers to properly reject any unknown HOST_PLATFORM or TARGET_PLATFORM
 
diff --git a/src/engine/SCons/Tool/msvs.py b/src/engine/SCons/Tool/msvs.py
index 297c083..d27294b 100644
--- a/src/engine/SCons/Tool/msvs.py
+++ b/src/engine/SCons/Tool/msvs.py
@@ -70,10 +70,14 @@ def xmlify(s):
     s = s.replace('\n', '
')
     return s
 
-# Process a CPPPATH list in includes, given the env, target and source.
-# Returns a tuple of nodes.
 def processIncludes(includes, env, target, source):
-    return SCons.PathList.PathList(includes).subst_path(env, target, source)
+    """
+    Process a CPPPATH list in includes, given the env, target and source.
+    Returns a list of directory paths. These paths are absolute so we avoid
+    putting pound-prefixed paths in a Visual Studio project file.
+    """
+    return [env.Dir(i).abspath for i in
+            SCons.PathList.PathList(includes).subst_path(env, target, source)]
 
 
 external_makefile_guid = '{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}'
@@ -348,10 +352,20 @@ V10DebugSettings = {
 }
 
 class _GenerateV10User(_UserGenerator):
-    """Generates a Project'user file for MSVS 2010"""
+    """Generates a Project'user file for MSVS 2010 or later"""
 
     def __init__(self, dspfile, source, env):
-        self.versionstr = '4.0'
+        version_num, suite = msvs_parse_version(env['MSVS_VERSION'])
+        if version_num >= 14.2:
+            # Visual Studio 2019 is considered to be version 16.
+            self.versionstr = '16.0'
+        elif version_num >= 14.1:
+            # Visual Studio 2017 is considered to be version 15.
+            self.versionstr = '15.0'
+        elif version_num == 14.0:
+            self.versionstr = '14.0'
+        else:
+            self.versionstr = '4.0'
         self.usrhead = V10UserHeader
         self.usrconf = V10UserConfiguration
         self.usrdebg = V10DebugSettings
@@ -462,15 +476,41 @@ class _DSPGenerator(object):
 
         self.sconscript = env['MSVSSCONSCRIPT']
 
-        if 'cmdargs' not in env or env['cmdargs'] is None:
-            cmdargs = [''] * len(variants)
-        elif SCons.Util.is_String(env['cmdargs']):
-            cmdargs = [env['cmdargs']] * len(variants)
-        elif SCons.Util.is_List(env['cmdargs']):
-            if len(env['cmdargs']) != len(variants):
-                raise SCons.Errors.InternalError("Sizes of 'cmdargs' and 'variant' lists must be the same.")
+        def GetKeyFromEnv(env, key, variants):
+            """
+            Retrieves a specific key from the environment. If the key is
+            present, it is expected to either be a string or a list with length
+            equal to the number of variants. The function returns a list of
+            the desired value (e.g. cpp include paths) guaranteed to be of
+            length equal to the length of the variants list.
+            """
+            if key not in env or env[key] is None:
+                return [''] * len(variants)
+            elif SCons.Util.is_String(env[key]):
+                return [env[key]] * len(variants)
+            elif SCons.Util.is_List(env[key]):
+                if len(env[key]) != len(variants):
+                    raise SCons.Errors.InternalError("Sizes of '%s' and 'variant' lists must be the same." % key)
+                else:
+                    return env[key]
             else:
-                cmdargs = env['cmdargs']
+                raise SCons.Errors.InternalError("Unsupported type for key '%s' in environment: %s" %
+                                                 (key, type(env[key])))
+
+        cmdargs = GetKeyFromEnv(env, 'cmdargs', variants)
+
+        # The caller is allowed to put 'cppdefines' and/or 'cpppaths' in the
+        # environment, which is useful if they want to provide per-variant
+        # values for these. Otherwise, we fall back to using the global
+        # 'CPPDEFINES' and 'CPPPATH' functions.
+        if 'cppdefines' in env:
+            cppdefines = GetKeyFromEnv(env, 'cppdefines', variants)
+        else:
+            cppdefines = [env.get('CPPDEFINES', [])] * len(variants)
+        if 'cpppaths' in env:
+            cpppaths = GetKeyFromEnv(env, 'cpppaths', variants)
+        else:
+            cpppaths = [env.get('CPPPATH', [])] * len(variants)
 
         self.env = env
 
@@ -513,13 +553,17 @@ class _DSPGenerator(object):
         for n in sourcenames:
             self.sources[n].sort(key=lambda a: a.lower())
 
-        def AddConfig(self, variant, buildtarget, outdir, runfile, cmdargs, dspfile=dspfile):
+        def AddConfig(self, variant, buildtarget, outdir, runfile, cmdargs, cppdefines, cpppaths, dspfile=dspfile, env=env):
             config = Config()
             config.buildtarget = buildtarget
             config.outdir = outdir
             config.cmdargs = cmdargs
+            config.cppdefines = cppdefines
             config.runfile = runfile
 
+            # Dir objects can't be pickled, so we need an absolute path here.
+            config.cpppaths = processIncludes(cpppaths, env, None, None)
+
             match = re.match(r'(.*)\|(.*)', variant)
             if match:
                 config.variant = match.group(1)
@@ -532,7 +576,7 @@ class _DSPGenerator(object):
             print("Adding '" + self.name + ' - ' + config.variant + '|' + config.platform + "' to '" + str(dspfile) + "'")
 
         for i in range(len(variants)):
-            AddConfig(self, variants[i], buildtarget[i], outdir[i], runfile[i], cmdargs[i])
+            AddConfig(self, variants[i], buildtarget[i], outdir[i], runfile[i], cmdargs[i], cppdefines[i], cpppaths[i])
 
         self.platforms = []
         for key in list(self.configs.keys()):
@@ -882,6 +926,8 @@ class _GenerateV7DSP(_DSPGenerator, _GenerateV7User):
             buildtarget = self.configs[kind].buildtarget
             runfile     = self.configs[kind].runfile
             cmdargs = self.configs[kind].cmdargs
+            cpppaths = self.configs[kind].cpppaths
+            cppdefines = self.configs[kind].cppdefines
 
             env_has_buildtarget = 'MSVSBUILDTARGET' in self.env
             if not env_has_buildtarget:
@@ -899,9 +945,8 @@ class _GenerateV7DSP(_DSPGenerator, _GenerateV7User):
             # This isn't perfect; CPPDEFINES and CPPPATH can contain $TARGET and $SOURCE,
             # so they could vary depending on the command being generated.  This code
             # assumes they don't.
-            preprocdefs = xmlify(';'.join(processDefines(self.env.get('CPPDEFINES', []))))
-            includepath_Dirs = processIncludes(self.env.get('CPPPATH', []), self.env, None, None)
-            includepath = xmlify(';'.join([str(x) for x in includepath_Dirs]))
+            preprocdefs = xmlify(';'.join(processDefines(cppdefines)))
+            includepath = xmlify(';'.join(processIncludes(cpppaths, self.env, None, None)))
 
             if not env_has_buildtarget:
                 del self.env['MSVSBUILDTARGET']
@@ -1060,7 +1105,7 @@ class _GenerateV7DSP(_DSPGenerator, _GenerateV7User):
 
 V10DSPHeader = """\
 <?xml version="1.0" encoding="%(encoding)s"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="%(versionstr)s" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 """
 
 V10DSPProjectConfiguration = """\
@@ -1075,6 +1120,7 @@ V10DSPGlobals = """\
 \t\t<ProjectGuid>%(project_guid)s</ProjectGuid>
 %(scc_attrs)s\t\t<RootNamespace>%(name)s</RootNamespace>
 \t\t<Keyword>MakeFileProj</Keyword>
+\t\t<VCProjectUpgraderObjectName>NoUpgrade</VCProjectUpgraderObjectName>
 \t</PropertyGroup>
 """
 
@@ -1112,9 +1158,9 @@ V15DSPHeader = """\
 class _GenerateV10DSP(_DSPGenerator, _GenerateV10User):
     """Generates a Project file for MSVS 2010"""
 
-    def __init__(self, dspfile, header, source, env):
+    def __init__(self, dspfile, source, env):
         _DSPGenerator.__init__(self, dspfile, source, env)
-        self.dspheader = header
+        self.dspheader = V10DSPHeader
         self.dspconfiguration = V10DSPProjectConfiguration
         self.dspglobals = V10DSPGlobals
 
@@ -1123,6 +1169,7 @@ class _GenerateV10DSP(_DSPGenerator, _GenerateV10User):
     def PrintHeader(self):
         env = self.env
         name = self.name
+        versionstr = self.versionstr
         encoding = env.subst('$MSVSENCODING')
         project_guid = env.get('MSVS_PROJECT_GUID', '')
         scc_provider = env.get('MSVS_SCC_PROVIDER', '')
@@ -1198,6 +1245,8 @@ class _GenerateV10DSP(_DSPGenerator, _GenerateV10User):
             buildtarget = self.configs[kind].buildtarget
             runfile     = self.configs[kind].runfile
             cmdargs = self.configs[kind].cmdargs
+            cpppaths = self.configs[kind].cpppaths
+            cppdefines = self.configs[kind].cppdefines
 
             env_has_buildtarget = 'MSVSBUILDTARGET' in self.env
             if not env_has_buildtarget:
@@ -1215,9 +1264,8 @@ class _GenerateV10DSP(_DSPGenerator, _GenerateV10User):
             # This isn't perfect; CPPDEFINES and CPPPATH can contain $TARGET and $SOURCE,
             # so they could vary depending on the command being generated.  This code
             # assumes they don't.
-            preprocdefs = xmlify(';'.join(processDefines(self.env.get('CPPDEFINES', []))))
-            includepath_Dirs = processIncludes(self.env.get('CPPPATH', []), self.env, None, None)
-            includepath = xmlify(';'.join([str(x) for x in includepath_Dirs]))
+            preprocdefs = xmlify(';'.join(processDefines(cppdefines)))
+            includepath = xmlify(';'.join(processIncludes(cpppaths, self.env, None, None)))
 
             if not env_has_buildtarget:
                 del self.env['MSVSBUILDTARGET']
@@ -1234,7 +1282,8 @@ class _GenerateV10DSP(_DSPGenerator, _GenerateV10User):
             raise SCons.Errors.InternalError('Unable to open "' + self.filtersabs + '" for writing:' + str(detail))
 
         self.filters_file.write('<?xml version="1.0" encoding="utf-8"?>\n'
-                                '<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\n')
+                                '<Project ToolsVersion="%s" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\n' %
+                                self.versionstr)
 
         self.PrintSourceFiles()
 
@@ -1466,6 +1515,9 @@ class _GenerateV7DSW(_DSWGenerator):
             for dspfile in self.dspfiles:
                 dsp_folder_path, name = os.path.split(dspfile)
                 dsp_folder_path = os.path.abspath(dsp_folder_path)
+                if SCons.Util.splitext(name)[1] == '.filters':
+                    # Ignore .filters project files
+                    continue
                 dsp_relative_folder_path = os.path.relpath(dsp_folder_path, self.dsw_folder_path)
                 if dsp_relative_folder_path == os.curdir:
                     dsp_relative_file_path = name
@@ -1515,7 +1567,11 @@ class _GenerateV7DSW(_DSWGenerator):
     def PrintSolution(self):
         """Writes a solution file"""
         self.file.write('Microsoft Visual Studio Solution File, Format Version %s\n' % self.versionstr)
-        if self.version_num > 14.0:
+        if self.version_num >= 14.2:
+            # Visual Studio 2019 is considered to be version 16.
+            self.file.write('# Visual Studio 16\n')
+        elif self.version_num > 14.0:
+            # Visual Studio 2015 and 2017 are both considered to be version 15.
             self.file.write('# Visual Studio 15\n')
         elif self.version_num >= 12.0:
             self.file.write('# Visual Studio 14\n')
@@ -1695,11 +1751,8 @@ def GenerateDSP(dspfile, source, env):
     version_num = 6.0
     if 'MSVS_VERSION' in env:
         version_num, suite = msvs_parse_version(env['MSVS_VERSION'])
-    if version_num > 14.0:
-        g = _GenerateV10DSP(dspfile, V15DSPHeader, source, env)
-        g.Build()
-    elif version_num >= 10.0:
-        g = _GenerateV10DSP(dspfile, V10DSPHeader, source, env)
+    if version_num >= 10.0:
+        g = _GenerateV10DSP(dspfile, source, env)
         g.Build()
     elif version_num >= 7.0:
         g = _GenerateV7DSP(dspfile, source, env)
@@ -1792,8 +1845,7 @@ def projectEmitter(target, source, env):
 
         # Project file depends on CPPDEFINES and CPPPATH
         preprocdefs = xmlify(';'.join(processDefines(env.get('CPPDEFINES', []))))
-        includepath_Dirs = processIncludes(env.get('CPPPATH', []), env, None, None)
-        includepath = xmlify(';'.join([str(x) for x in includepath_Dirs]))
+        includepath = xmlify(';'.join(processIncludes(env.get('CPPPATH', []), env, None, None)))
         source = source + "; ppdefs:%s incpath:%s"%(preprocdefs, includepath)
 
         if 'buildtarget' in env and env['buildtarget'] is not None:
@@ -1973,8 +2025,14 @@ def generate(env):
             default_MSVS_SConscript = env.File('SConstruct')
         env['MSVSSCONSCRIPT'] = default_MSVS_SConscript
 
-    env['MSVSSCONS'] = '"%s" -c "%s"' % (python_executable, getExecScriptMain(env))
-    env['MSVSSCONSFLAGS'] = '-C "${MSVSSCONSCRIPT.dir.get_abspath()}" -f ${MSVSSCONSCRIPT.name}'
+    # Allow consumers to provide their own versions of MSVSSCONS and
+    # MSVSSCONSFLAGS. This helps support consumers who use wrapper scripts to
+    # invoke scons.
+    if 'MSVSSCONS' not in env:
+        env['MSVSSCONS'] = '"%s" -c "%s"' % (python_executable, getExecScriptMain(env))
+    if 'MSVSSCONSFLAGS' not in env:
+        env['MSVSSCONSFLAGS'] = '-C "${MSVSSCONSCRIPT.dir.get_abspath()}" -f ${MSVSSCONSCRIPT.name}'
+
     env['MSVSSCONSCOM'] = '$MSVSSCONS $MSVSSCONSFLAGS'
     env['MSVSBUILDCOM'] = '$MSVSSCONSCOM "$MSVSBUILDTARGET"'
     env['MSVSREBUILDCOM'] = '$MSVSSCONSCOM "$MSVSBUILDTARGET"'
diff --git a/src/engine/SCons/Tool/msvs.xml b/src/engine/SCons/Tool/msvs.xml
index 6467a2b..3a9fdf0 100644
--- a/src/engine/SCons/Tool/msvs.xml
+++ b/src/engine/SCons/Tool/msvs.xml
@@ -48,14 +48,16 @@ See its __doc__ string for a discussion of the format.
         latest installed version, or the version specified by
         &cv-link-MSVS_VERSION; in the Environment constructor). For
         Visual Studio 6, it will generate a <filename>.dsp</filename>
-        file. For Visual Studio 7 (.NET) and later versions, it will
-        generate a <filename>.vcproj</filename> file.
+        file. For Visual Studio 7, 8, and 9, it will
+        generate a <filename>.vcproj</filename> file.  For Visual
+        Studio 10 and later, it will generate a
+        <filename>.vcxproj</filename> file.
       </para>
       <para>
         By default, this also generates a solution file for the
         specified project, a <filename>.dsw</filename> file for
         Visual Studio 6 or a <filename>.sln</filename> file for
-        Visual Studio 7 (.NET). This behavior may be disabled by
+        Visual Studio 7 and later. This behavior may be disabled by
         specifying <literal>auto_build_solution=0</literal> when you
         call &b-MSVSProject;, in which case you presumably want to
         build the solution file(s) by calling the &b-MSVSSolution;
@@ -128,6 +130,36 @@ See its __doc__ string for a discussion of the format.
           </listitem>
         </varlistentry>
         <varlistentry>
+          <term>cppdefines</term>
+          <listitem>
+            <para>
+              Preprocessor definitions for the different variants.
+              The number of <literal>cppdefines</literal> entries
+              must match the number of <literal>variant</literal>
+              entries, or be empty (not specified). If you give
+              only one, it will automatically be propagated to all
+              variants. If you don't give this parameter, SCons
+              will use the invoking environment's
+              <literal>CPPDEFINES</literal> entry for all variants.
+            </para>
+          </listitem>
+        </varlistentry>
+        <varlistentry>
+          <term>cpppaths</term>
+          <listitem>
+            <para>
+              Compiler include paths for the different variants.
+              The number of <literal>cpppaths</literal> entries
+              must match the number of <literal>variant</literal>
+              entries, or be empty (not specified). If you give
+              only one, it will automatically be propagated to all
+              variants. If you don't give this parameter, SCons
+              will use the invoking environment's
+              <literal>CPPPATH</literal> entry for all variants.
+            </para>
+          </listitem>
+        </varlistentry>
+        <varlistentry>
           <term>buildtarget</term>
           <listitem>
             <para>
diff --git a/src/engine/SCons/Tool/msvsTests.py b/src/engine/SCons/Tool/msvsTests.py
index 477694a..cc4f717 100644
--- a/src/engine/SCons/Tool/msvsTests.py
+++ b/src/engine/SCons/Tool/msvsTests.py
@@ -34,6 +34,7 @@ import TestUnit
 
 from SCons.Tool.msvs import *
 from SCons.Tool.MSCommon.vs import SupportedVSList
+import SCons.Node.FS
 import SCons.Util
 import SCons.Warnings
 
@@ -352,6 +353,36 @@ regdata_80 = r'''
 "VCXDCMakeTool"="*.xdc"
 '''.split('\n')
 
+regdata_140 = r'''
+[HKEY_LOCAL_MACHINE\Software\Microsoft\VisualStudio\14.0\Setup\VS]
+"MSMDir"="C:\\Program Files (x86)\\Common Files\\Merge Modules\\"
+"ProductDir"="C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\"
+"VS7EnvironmentLocation"="C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\Common7\\IDE\\devenv.exe"
+"EnvironmentPath"="C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\Common7\\IDE\\devenv.exe"
+"EnvironmentDirectory"="C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\Common7\\IDE\\"
+"VS7CommonDir"="C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\Common7\\"
+"VS7CommonBinDir"=""
+[HKEY_LOCAL_MACHINE\Software\Microsoft\VisualStudio\14.0\Setup\VS\BuildNumber]
+"1033"="14.0"
+[HKEY_LOCAL_MACHINE\Software\Microsoft\VisualStudio\14.0\Setup\VS\Community]
+"ProductDir"="C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\"
+[HKEY_LOCAL_MACHINE\Software\Microsoft\VisualStudio\14.0\Setup\VS\JSLS_MSI]
+"Version"="14.0.25527"
+[HKEY_LOCAL_MACHINE\Software\Microsoft\VisualStudio\14.0\Setup\VS\JSPS_MSI]
+"Version"="14.0.25527"
+[HKEY_LOCAL_MACHINE\Software\Microsoft\VisualStudio\14.0\Setup\VS\Pro]
+"ProductDir"="C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\"
+[HKEY_LOCAL_MACHINE\Software\Microsoft\VisualStudio\14.0\Setup\VS\professional]
+"IsInstallInProgress"="0"
+"CurrentOperation"="install"
+"SetupFeedUri"="http://go.microsoft.com/fwlink/?LinkID=659004&clcid=0x409"
+"SetupFeedLocalCache"="C:\\ProgramData\\Microsoft\\VisualStudioSecondaryInstaller\\14.0\\LastUsedFeed\\{68432bbb-c9a5-4a7b-bab3-ae5a49b28303}\\Feed.xml"
+"InstallResult"="0"
+[HKEY_LOCAL_MACHINE\Software\Microsoft\VisualStudio\14.0\Setup\VS\SecondaryInstaller]
+[HKEY_LOCAL_MACHINE\Software\Microsoft\VisualStudio\14.0\Setup\VS\SecondaryInstaller\AppInsightsTools]
+"Version"="7.0.20620.1"
+'''.split('\n')
+
 regdata_cv = r'''[HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion]
 "ProgramFilesDir"="C:\Program Files"
 "CommonFilesDir"="C:\Program Files\Common Files"
@@ -363,6 +394,7 @@ regdata_none = []
 
 class DummyEnv(object):
     def __init__(self, dict=None):
+        self.fs = SCons.Node.FS.FS()
         if dict:
             self.dict = dict
         else:
@@ -385,6 +417,16 @@ class DummyEnv(object):
     def has_key(self,name):
         return name in self.dict
 
+    def get(self, name, value=None):
+        if self.has_key(name):
+            return self.dict[name]
+        else:
+            return value
+
+    def Dir(self, name):
+        return self.fs.Dir(name)
+
+
 class RegKey(object):
     """key class for storing an 'open' registry key"""
     def __init__(self,key):
@@ -554,6 +596,11 @@ class msvsTestCase(unittest.TestCase):
         from SCons.Tool.MSCommon.vs import reset_installed_visual_studios
         reset_installed_visual_studios()
 
+        self.test = TestCmd.TestCmd(workdir='')
+        # FS doesn't like the cwd to be something other than its root.
+        os.chdir(self.test.workpath(""))
+        self.fs = SCons.Node.FS.FS()
+
     def test_get_default_version(self):
         """Test retrieval of the default visual studio version"""
 
@@ -607,13 +654,19 @@ class msvsTestCase(unittest.TestCase):
         version_num, suite = msvs_parse_version(self.highest_version)
         if version_num >= 10.0:
             function_test = _GenerateV10DSP
+            suffix = '.vcxproj'
         elif version_num >= 7.0:
             function_test = _GenerateV7DSP
+            suffix = '.dsp'
         else:
             function_test = _GenerateV6DSP
+            suffix = '.dsp'
+
+        # Avoid any race conditions between the test cases when we test
+        # actually writing the files.
+        dspfile = 'test%s%s' % (hash(self), suffix)
             
         str_function_test = str(function_test.__init__)
-        dspfile = 'test.dsp'
         source = 'test.cpp'
         
         # Create the cmdargs test list
@@ -623,50 +676,95 @@ class msvsTestCase(unittest.TestCase):
                         'debug=False target_arch=32',
                         'debug=True target_arch=x64', 
                         'debug=False target_arch=x64']
-        
-        # Tuple list :   (parameter,        dictionary of expected result per variant)
-        tests_cmdargs = [(None,            dict.fromkeys(list_variant, '')), 
-                         ('',              dict.fromkeys(list_variant, '')), 
-                         (list_cmdargs[0], dict.fromkeys(list_variant, list_cmdargs[0])),
-                         (list_cmdargs,    dict(list(zip(list_variant, list_cmdargs))))]
-        
+        list_cppdefines = [['_A', '_B', 'C'], ['_B', '_C_'], ['D'], []]
+        list_cpppaths = [[r'C:\test1'], [r'C:\test1;C:\test2'],
+                         [self.fs.Dir('subdir')], []]
+
+        def TestParamsFromList(test_variant, test_list):
+            """
+            Generates test data based on the parameters passed in.
+
+            Returns tuple list:
+                1. Parameter.
+                2. Dictionary of expected result per variant.
+            """
+            def normalizeParam(param):
+                """
+                Converts the raw data based into the AddConfig function of
+                msvs.py to the expected result.
+
+                Expects the following behavior:
+                    1. A value of None will be converted to an empty list.
+                    2. A File or Directory object will be converted to an
+                       absolute path (because those objects can't be pickled).
+                    3. Otherwise, the parameter will be used.
+                """
+                if param is None:
+                    return []
+                elif isinstance(param, list):
+                    return [normalizeParam(p) for p in param]
+                elif hasattr(param, 'abspath'):
+                    return param.abspath
+                else:
+                    return param
+
+            return [
+                (None, dict.fromkeys(test_variant, '')),
+                ('', dict.fromkeys(test_variant, '')),
+                (test_list[0], dict.fromkeys(test_variant, normalizeParam(test_list[0]))),
+                (test_list, dict(list(zip(test_variant, [normalizeParam(x) for x in test_list]))))
+            ]
+
+        tests_cmdargs = TestParamsFromList(list_variant, list_cmdargs)
+        tests_cppdefines = TestParamsFromList(list_variant, list_cppdefines)
+        tests_cpppaths = TestParamsFromList(list_variant, list_cpppaths)
+
         # Run the test for each test case
         for param_cmdargs, expected_cmdargs in tests_cmdargs:
-            debug('Testing %s. with :\n  variant = %s \n  cmdargs = "%s"' % \
-                  (str_function_test, list_variant, param_cmdargs))
-            param_configs = []
-            expected_configs = {}
-            for platform in ['Win32', 'x64']:
-                for variant in ['Debug', 'Release']:
-                    variant_platform = '%s|%s' % (variant, platform)
-                    runfile = '%s\\%s\\test.exe' % (platform, variant)
-                    buildtarget = '%s\\%s\\test.exe' % (platform, variant)
-                    outdir = '%s\\%s' % (platform, variant)
+            for param_cppdefines, expected_cppdefines in tests_cppdefines:
+                for param_cpppaths, expected_cpppaths in tests_cpppaths:
+                    debug('Testing %s. with :\n  variant = %s \n  cmdargs = "%s" \n  cppdefines = "%s" \n  cpppaths = "%s"' % \
+                          (str_function_test, list_variant, param_cmdargs, param_cppdefines, param_cpppaths))
+                    param_configs = []
+                    expected_configs = {}
+                    for platform in ['Win32', 'x64']:
+                        for variant in ['Debug', 'Release']:
+                            variant_platform = '%s|%s' % (variant, platform)
+                            runfile = '%s\\%s\\test.exe' % (platform, variant)
+                            buildtarget = '%s\\%s\\test.exe' % (platform, variant)
+                            outdir = '%s\\%s' % (platform, variant)
             
-                    # Create parameter list for this variant_platform
-                    param_configs.append([variant_platform, runfile, buildtarget, outdir])
-            
-                    # Create expected dictionary result for this variant_platform
-                    expected_configs[variant_platform] = \
-                    {'variant': variant, 'platform': platform, 
-                     'runfile': runfile,
-                     'buildtarget': buildtarget, 
-                     'outdir': outdir,
-                     'cmdargs': expected_cmdargs[variant_platform]}
+                            # Create parameter list for this variant_platform
+                            param_configs.append([variant_platform, runfile, buildtarget, outdir])
             
+                            # Create expected dictionary result for this variant_platform
+                            expected_configs[variant_platform] = {
+                                'variant': variant,
+                                'platform': platform, 
+                                'runfile': runfile,
+                                'buildtarget': buildtarget, 
+                                'outdir': outdir,
+                                'cmdargs': expected_cmdargs[variant_platform],
+                                'cppdefines': expected_cppdefines[variant_platform],
+                                'cpppaths': expected_cpppaths[variant_platform],
+                            }
+
             # Create parameter environment with final parameter dictionary
             param_dict = dict(list(zip(('variant', 'runfile', 'buildtarget', 'outdir'),
                                   [list(l) for l in zip(*param_configs)])))
             param_dict['cmdargs'] = param_cmdargs
+            param_dict['cppdefines'] = param_cppdefines
+            param_dict['cpppaths'] = param_cpppaths
 
             # Hack to be able to run the test with a 'DummyEnv'
             class _DummyEnv(DummyEnv):
-                def subst(self, string) : 
+                def subst(self, string, *args, **kwargs):
                     return string
             
             env = _DummyEnv(param_dict)
             env['MSVSSCONSCRIPT'] = ''
             env['MSVS_VERSION'] = self.highest_version
+            env['MSVSBUILDTARGET'] = 'target'
            
             # Call function to test
             genDSP = function_test(dspfile, source, env)
@@ -676,6 +774,16 @@ class msvsTestCase(unittest.TestCase):
             for key in list(genDSP.configs.keys()):
                 self.assertDictEqual(genDSP.configs[key].__dict__, expected_configs[key])
 
+            genDSP.Build()
+
+            # Delete the resulting file so we don't leave anything behind.
+            for file in [dspfile, dspfile + '.filters']:
+                path = os.path.realpath(file)
+                try:
+                    os.remove(path)
+                except OSError:
+                    pass
+
 class msvs6aTestCase(msvsTestCase):
     """Test MSVS 6 Registry"""
     registry = DummyRegistry(regdata_6a + regdata_cv)
@@ -787,6 +895,18 @@ class msvs80TestCase(msvsTestCase):
     }
     default_install_loc = install_locs['8.0']
 
+class msvs140TestCase(msvsTestCase):
+    """Test MSVS 140 Registry"""
+    registry = DummyRegistry(regdata_140 + regdata_cv)
+    default_version = '14.0'
+    highest_version = '14.0'
+    number_of_versions = 2
+    install_locs = {
+        '14.0' : {'VSINSTALLDIR': 'C:\\Program Files\\Microsoft Visual Studio 14.0',
+                  'VCINSTALLDIR': 'C:\\Program Files\\Microsoft Visual Studio 14.0\\VC'},
+    }
+    default_install_loc = install_locs['14.0']
+
 class msvsEmptyTestCase(msvsTestCase):
     """Test Empty Registry"""
     registry = DummyRegistry(regdata_none)
@@ -829,6 +949,7 @@ if __name__ == "__main__":
         msvs71TestCase,
         msvs8ExpTestCase,
         msvs80TestCase,
+        msvs140TestCase,
         msvsEmptyTestCase,
     ]