Return empty list instead of None in msvc_toolset_versions. Expand msvc toolset version tests.

2 files changed, 182 insertions, 120 deletions

diff --git a/SCons/Tool/MSCommon/vc.py b/SCons/Tool/MSCommon/vc.py
index e05f397..68b8f08 100644
--- a/SCons/Tool/MSCommon/vc.py
+++ b/SCons/Tool/MSCommon/vc.py
@@ -1368,12 +1368,12 @@ def msvc_toolset_versions(msvc_version=None, full=True, sxs=False):
     vc_dir = find_vc_pdir(env, msvc_version)
     if not vc_dir:
         debug('VC folder not found for version %s', repr(msvc_version))
-        return
+        return rval
 
     rval = MSVC.ScriptArguments._msvc_toolset_versions_internal(msvc_version, vc_dir, full=full, sxs=sxs)
     return rval
 
-def msvc_query_version_toolset(version, prefer_newest=True):
+def msvc_query_version_toolset(version=None, prefer_newest=True):
     """
     Returns an msvc version and a toolset version given a version
     specification.
diff --git a/test/MSVC/MSVC_TOOLSET_VERSION.py b/test/MSVC/MSVC_TOOLSET_VERSION.py
index 43192af..30dd344 100644
--- a/test/MSVC/MSVC_TOOLSET_VERSION.py
+++ b/test/MSVC/MSVC_TOOLSET_VERSION.py
@@ -56,149 +56,211 @@ def process_version(msvc_version):
 
 installed_versions = [process_version(msvc_version) for msvc_version in get_installed_vcs()]
 
-default = installed_versions[0]
+default_version = installed_versions[0]
 
-if default.msvc_vernum >= 14.1:
+GE_VS2017_versions = [v for v in installed_versions if v.msvc_vernum >= 14.1]
+LT_VS2017_versions = [v for v in installed_versions if v.msvc_vernum < 14.1]
+LT_VS2015_versions = [v for v in installed_versions if v.msvc_vernum < 14.0]
+
+if GE_VS2017_versions:
     # VS2017 and later for toolset argument
 
-    # msvc_version as toolset version
-    test.write('SConstruct', textwrap.dedent(
-        """
-        DefaultEnvironment(tools=[])
-        env = Environment(MSVC_TOOLSET_VERSION={}, tools=['msvc'])
-        """.format(repr(default.msvc_verstr))
-    ))
-    test.run(arguments='-Q -s', stdout='')
+    for supported in GE_VS2017_versions:
 
-    # msvc_version as toolset version using script argument
-    test.write('SConstruct', textwrap.dedent(
-        """
-        DefaultEnvironment(tools=[])
-        env = Environment(MSVC_SCRIPT_ARGS='-vcvars_ver={}', tools=['msvc'])
-        """.format(default.msvc_verstr)
-    ))
-    test.run(arguments='-Q -s', stdout='')
+        # msvc_version as toolset version
+        test.write('SConstruct', textwrap.dedent(
+            """
+            DefaultEnvironment(tools=[])
+            env = Environment(MSVC_VERSION={}, MSVC_TOOLSET_VERSION={}, tools=['msvc'])
+            """.format(repr(supported.msvc_version), repr(supported.msvc_verstr))
+        ))
+        test.run(arguments='-Q -s', stdout='')
 
-    # error toolset version and script argument
-    test.write('SConstruct', textwrap.dedent(
-        """
-        DefaultEnvironment(tools=[])
-        env = Environment(MSVC_TOOLSET_VERSION={}, MSVC_SCRIPT_ARGS='-vcvars_ver={}', tools=['msvc'])
-        """.format(repr(default.msvc_verstr), default.msvc_verstr)
-    ))
-    test.run(arguments='-Q -s', status=2, stderr=None)
-    expect = "MSVCArgumentError: multiple toolset version declarations: MSVC_TOOLSET_VERSION={} and MSVC_SCRIPT_ARGS='-vcvars_ver={}':".format(
-        repr(default.msvc_verstr), default.msvc_verstr
-    )
-    test.fail_test(test.stderr().split('\n')[0].strip() != expect)
+        # msvc_version as toolset version using script argument
+        test.write('SConstruct', textwrap.dedent(
+            """
+            DefaultEnvironment(tools=[])
+            env = Environment(MSVC_VERSION={}, MSVC_SCRIPT_ARGS='-vcvars_ver={}', tools=['msvc'])
+            """.format(repr(supported.msvc_version), supported.msvc_verstr)
+        ))
+        test.run(arguments='-Q -s', stdout='')
 
-    # msvc_toolset_version does not exist (hopefully)
-    missing_toolset_version = default.msvc_verstr + '9.99999'
-    test.write('SConstruct', textwrap.dedent(
-        """
-        DefaultEnvironment(tools=[])
-        env = Environment(MSVC_TOOLSET_VERSION={}, tools=['msvc'])
-        """.format(repr(missing_toolset_version))
-    ))
-    expect = r"^.*MSVCToolsetVersionNotFound: MSVC_TOOLSET_VERSION {} not found for MSVC_VERSION {}.+".format(
-        repr(missing_toolset_version), repr(default.msvc_version)
-    )
-    test.run(arguments='-Q -s', status=2, stderr=expect, match=TestSCons.match_re_dotall)
+        # error toolset version and script argument
+        test.write('SConstruct', textwrap.dedent(
+            """
+            DefaultEnvironment(tools=[])
+            env = Environment(MSVC_VERSION={}, MSVC_TOOLSET_VERSION={}, MSVC_SCRIPT_ARGS='-vcvars_ver={}', tools=['msvc'])
+            """.format(repr(supported.msvc_version), repr(supported.msvc_verstr), supported.msvc_verstr)
+        ))
+        test.run(arguments='-Q -s', status=2, stderr=None)
+        expect = "MSVCArgumentError: multiple toolset version declarations: MSVC_TOOLSET_VERSION={} and MSVC_SCRIPT_ARGS='-vcvars_ver={}':".format(
+            repr(supported.msvc_verstr), supported.msvc_verstr
+        )
+        test.fail_test(test.stderr().split('\n')[0].strip() != expect)
 
-    # msvc_toolset_version is invalid (format)
-    invalid_toolset_version = default.msvc_verstr + '9.99999.99999'
-    test.write('SConstruct', textwrap.dedent(
-        """
-        DefaultEnvironment(tools=[])
-        env = Environment(MSVC_TOOLSET_VERSION={}, tools=['msvc'])
-        """.format(repr(invalid_toolset_version))
-    ))
-    test.run(arguments='-Q -s', status=2, stderr=None)
-    expect = "MSVCArgumentError: MSVC_TOOLSET_VERSION ({}) format is not supported:".format(
-        repr(invalid_toolset_version)
-    )
-    test.fail_test(test.stderr().split('\n')[0].strip() != expect)
+        # msvc_toolset_version does not exist (hopefully)
+        missing_toolset_version = supported.msvc_verstr + '9.99999'
+        test.write('SConstruct', textwrap.dedent(
+            """
+            DefaultEnvironment(tools=[])
+            env = Environment(MSVC_VERSION={}, MSVC_TOOLSET_VERSION={}, tools=['msvc'])
+            """.format(repr(supported.msvc_version), repr(missing_toolset_version))
+        ))
+        expect = r"^.*MSVCToolsetVersionNotFound: MSVC_TOOLSET_VERSION {} not found for MSVC_VERSION {}.+".format(
+            repr(missing_toolset_version), repr(supported.msvc_version)
+        )
+        test.run(arguments='-Q -s', status=2, stderr=expect, match=TestSCons.match_re_dotall)
 
-    # msvc_toolset_version is invalid (version greater than msvc version)
-    invalid_toolset_vernum = default.msvc_vernum + 0.1
-    invalid_toolset_version = str(invalid_toolset_vernum)
-    test.write('SConstruct', textwrap.dedent(
-        """
-        DefaultEnvironment(tools=[])
-        env = Environment(MSVC_TOOLSET_VERSION={}, tools=['msvc'])
-        """.format(repr(invalid_toolset_version))
-    ))
-    test.run(arguments='-Q -s', status=2, stderr=None)
-    expect = "MSVCArgumentError: MSVC_TOOLSET_VERSION ({}) constraint violation: toolset version {} > {} MSVC_VERSION:".format(
-        repr(invalid_toolset_version), repr(invalid_toolset_version), repr(default.msvc_version)
-    )
-    test.fail_test(test.stderr().split('\n')[0].strip() != expect)
+        # msvc_toolset_version is invalid (format)
+        invalid_toolset_version = supported.msvc_verstr + '9.99999.99999'
+        test.write('SConstruct', textwrap.dedent(
+            """
+            DefaultEnvironment(tools=[])
+            env = Environment(MSVC_VERSION={}, MSVC_TOOLSET_VERSION={}, tools=['msvc'])
+            """.format(repr(supported.msvc_version), repr(invalid_toolset_version))
+        ))
+        test.run(arguments='-Q -s', status=2, stderr=None)
+        expect = "MSVCArgumentError: MSVC_TOOLSET_VERSION ({}) format is not supported:".format(
+            repr(invalid_toolset_version)
+        )
+        test.fail_test(test.stderr().split('\n')[0].strip() != expect)
 
-    # msvc_toolset_version is invalid (version less than 14.0)
-    invalid_toolset_version = '12.0'
-    test.write('SConstruct', textwrap.dedent(
-        """
-        DefaultEnvironment(tools=[])
-        env = Environment(MSVC_TOOLSET_VERSION={}, tools=['msvc'])
-        """.format(repr(invalid_toolset_version))
-    ))
-    test.run(arguments='-Q -s', status=2, stderr=None)
-    expect = "MSVCArgumentError: MSVC_TOOLSET_VERSION ({}) constraint violation: toolset version {} < '14.0' VS2015:".format(
-        repr(invalid_toolset_version), repr(invalid_toolset_version)
-    )
-    test.fail_test(test.stderr().split('\n')[0].strip() != expect)
+        # msvc_toolset_version is invalid (version greater than msvc version)
+        invalid_toolset_vernum = round(supported.msvc_vernum + 0.1, 1)
+        invalid_toolset_version = str(invalid_toolset_vernum)
+        test.write('SConstruct', textwrap.dedent(
+            """
+            DefaultEnvironment(tools=[])
+            env = Environment(MSVC_VERSION={}, MSVC_TOOLSET_VERSION={}, tools=['msvc'])
+            """.format(repr(supported.msvc_version), repr(invalid_toolset_version))
+        ))
+        test.run(arguments='-Q -s', status=2, stderr=None)
+        expect = "MSVCArgumentError: MSVC_TOOLSET_VERSION ({}) constraint violation: toolset version {} > {} MSVC_VERSION:".format(
+            repr(invalid_toolset_version), repr(invalid_toolset_version), repr(supported.msvc_version)
+        )
+        test.fail_test(test.stderr().split('\n')[0].strip() != expect)
+
+        # msvc_toolset_version is invalid (version less than 14.0)
+        invalid_toolset_version = '12.0'
+        test.write('SConstruct', textwrap.dedent(
+            """
+            DefaultEnvironment(tools=[])
+            env = Environment(MSVC_VERSION={}, MSVC_TOOLSET_VERSION={}, tools=['msvc'])
+            """.format(repr(supported.msvc_version), repr(invalid_toolset_version))
+        ))
+        test.run(arguments='-Q -s', status=2, stderr=None)
+        expect = "MSVCArgumentError: MSVC_TOOLSET_VERSION ({}) constraint violation: toolset version {} < '14.0' VS2015:".format(
+            repr(invalid_toolset_version), repr(invalid_toolset_version)
+        )
+        test.fail_test(test.stderr().split('\n')[0].strip() != expect)
+
+        # 14.0 toolset is invalid (toolset version != 14.0)
+        invalid_toolset_version = '14.00.00001'
+        test.write('SConstruct', textwrap.dedent(
+            """
+            DefaultEnvironment(tools=[])
+            env = Environment(MSVC_VERSION={}, MSVC_TOOLSET_VERSION={}, tools=['msvc'])
+            """.format(repr(supported.msvc_version), repr(invalid_toolset_version))
+        ))
+        test.run(arguments='-Q -s', status=2, stderr=None)
+        expect = "MSVCArgumentError: MSVC_TOOLSET_VERSION ({}) constraint violation: toolset version {} != '14.0':".format(
+            repr(invalid_toolset_version), repr(invalid_toolset_version)
+        )
+        test.fail_test(test.stderr().split('\n')[0].strip() != expect)
+
+        if supported == default_version:
+            msvc_version_list = ['None', repr(supported.msvc_version)]
+        else:
+            msvc_version_list = [repr(supported.msvc_version)]
+
+        for test_version in msvc_version_list:
+
+            # msvc toolsets detected
+            test.write('SConstruct', textwrap.dedent(
+                """
+                from SCons.Tool.MSCommon import msvc_toolset_versions
+                DefaultEnvironment(tools=[])
+                for full in (True, False):
+                    for sxs in (True, False):
+                        toolsets = msvc_toolset_versions(msvc_version={}, full=full, sxs=sxs)
+                """.format(test_version)
+            ))
+            test.run(arguments='-Q -s', stdout='')
+
+            # msvc query version toolset
+            test.write('SConstruct', textwrap.dedent(
+                """
+                from SCons.Tool.MSCommon import msvc_query_version_toolset
+                DefaultEnvironment(tools=[])
+                for prefer_newest in (True, False):
+                    msvc_version, msvc_toolset_version = msvc_query_version_toolset(version={}, prefer_newest=prefer_newest)
+                """.format(test_version)
+            ))
+            test.run(arguments='-Q -s', stdout='')
 
-    # 14.0 toolset is invalid (toolset version != 14.0)
-    invalid_toolset_version = '14.00.00001'
+    # msvc_version is invalid (version greater than default msvc_version)
+    invalid_msvc_vernum = round(default_version.msvc_vernum + 0.1, 1)
+    invalid_msvc_version = str(invalid_msvc_vernum)
     test.write('SConstruct', textwrap.dedent(
         """
+        from SCons.Tool.MSCommon import msvc_toolset_versions
         DefaultEnvironment(tools=[])
-        env = Environment(MSVC_TOOLSET_VERSION={}, tools=['msvc'])
-        """.format(repr(invalid_toolset_version))
+        toolsets = msvc_toolset_versions(msvc_version={}, full=True, sxs=True)
+        """.format(repr(invalid_msvc_version))
     ))
     test.run(arguments='-Q -s', status=2, stderr=None)
-    expect = "MSVCArgumentError: MSVC_TOOLSET_VERSION ({}) constraint violation: toolset version {} != '14.0':".format(
-        repr(invalid_toolset_version), repr(invalid_toolset_version)
+    expect = "MSVCArgumentError: Unsupported msvc version {}:".format(
+        repr(invalid_msvc_version)
     )
     test.fail_test(test.stderr().split('\n')[0].strip() != expect)
 
-unsupported_versions = [v for v in installed_versions if v.msvc_vernum < 14.1]
-if unsupported_versions:
+if LT_VS2017_versions:
     # VS2015 and earlier for toolset argument error
 
-    unsupported = unsupported_versions[0]
+    for unsupported in LT_VS2017_versions:
 
-    # must be VS2017 or later
-    test.write('SConstruct', textwrap.dedent(
-        """
-        DefaultEnvironment(tools=[])
-        env = Environment(MSVC_VERSION={}, MSVC_TOOLSET_VERSION={}, tools=['msvc'])
-        """.format(repr(unsupported.msvc_version), repr(unsupported.msvc_verstr))
-    ))
-    test.run(arguments='-Q -s', status=2, stderr=None)
-    expect = "MSVCArgumentError: MSVC_TOOLSET_VERSION ({}) constraint violation: MSVC_VERSION {} < '14.1' VS2017:".format(
-        repr(unsupported.msvc_version), repr(unsupported.msvc_version)
-    )
-    test.fail_test(test.stderr().split('\n')[0].strip() != expect)
+        # must be VS2017 or later
+        test.write('SConstruct', textwrap.dedent(
+            """
+            DefaultEnvironment(tools=[])
+            env = Environment(MSVC_VERSION={}, MSVC_TOOLSET_VERSION={}, tools=['msvc'])
+            """.format(repr(unsupported.msvc_version), repr(unsupported.msvc_verstr))
+        ))
+        test.run(arguments='-Q -s', status=2, stderr=None)
+        expect = "MSVCArgumentError: MSVC_TOOLSET_VERSION ({}) constraint violation: MSVC_VERSION {} < '14.1' VS2017:".format(
+            repr(unsupported.msvc_verstr), repr(unsupported.msvc_version)
+        )
+        test.fail_test(test.stderr().split('\n')[0].strip() != expect)
+
+        # msvc_toolset_versions returns None for versions that don't support toolsets
+        test.write('SConstruct', textwrap.dedent(
+            """
+            from SCons.Tool.MSCommon import msvc_toolset_versions
+            DefaultEnvironment(tools=[])
+            toolsets = msvc_toolset_versions(msvc_version={}, full=True, sxs=True)
+            if toolsets is not None:
+                raise RuntimeError("Expected toolsets==None")
+            """.format(repr(unsupported.msvc_version))
+        ))
+        test.run(arguments='-Q -s', stdout='')
 
-unsupported_versions = [v for v in installed_versions if v.msvc_vernum < 14.0]
-if unsupported_versions:
+if LT_VS2015_versions:
     # VS2013 and earlier for script argument error
 
-    unsupported = unsupported_versions[0]
+    for unsupported in LT_VS2015_versions:
 
-    # must be VS2015 or later for MSVC_SCRIPT_ARGS
-    test.write('SConstruct', textwrap.dedent(
-        """
-        DefaultEnvironment(tools=[])
-        env = Environment(MSVC_VERSION={}, MSVC_SCRIPT_ARGS='-vcvars_ver={}', tools=['msvc'])
-        """.format(repr(unsupported.msvc_version), unsupported.msvc_verstr)
-    ))
-    test.run(arguments='-Q -s', status=2, stderr=None)
-    expect = "MSVCArgumentError: MSVC_SCRIPT_ARGS ('-vcvars_ver={}') constraint violation: MSVC_VERSION {} < '14.0' VS2015:".format(
-        unsupported.msvc_verstr, repr(unsupported.msvc_version)
-    )
-    test.fail_test(test.stderr().split('\n')[0].strip() != expect)
+        # must be VS2015 or later for MSVC_SCRIPT_ARGS
+        test.write('SConstruct', textwrap.dedent(
+            """
+            DefaultEnvironment(tools=[])
+            env = Environment(MSVC_VERSION={}, MSVC_SCRIPT_ARGS='-vcvars_ver={}', tools=['msvc'])
+            """.format(repr(unsupported.msvc_version), unsupported.msvc_verstr)
+        ))
+        test.run(arguments='-Q -s', status=2, stderr=None)
+        expect = "MSVCArgumentError: MSVC_SCRIPT_ARGS ('-vcvars_ver={}') constraint violation: MSVC_VERSION {} < '14.0' VS2015:".format(
+            unsupported.msvc_verstr, repr(unsupported.msvc_version)
+        )
+        test.fail_test(test.stderr().split('\n')[0].strip() != expect)
 
 test.pass_test()