test/MSVC/MSVC_SDK_VERSION.py

   1 #!/usr/bin/env python
   2 #
   3 # MIT License
   4 #
   5 # Copyright The SCons Foundation
   6 #
   7 # Permission is hereby granted, free of charge, to any person obtaining
   8 # a copy of this software and associated documentation files (the
   9 # "Software"), to deal in the Software without restriction, including
  10 # without limitation the rights to use, copy, modify, merge, publish,
  11 # distribute, sublicense, and/or sell copies of the Software, and to
  12 # permit persons to whom the Software is furnished to do so, subject to
  13 # the following conditions:
  14 #
  15 # The above copyright notice and this permission notice shall be included
  16 # in all copies or substantial portions of the Software.
  17 #
  18 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
  19 # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  20 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  21 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  22 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26 """
  27 Test the MSVC_SDK_VERSION construction variable.
  28 """
  29 import textwrap
  30
  31 from SCons.Tool.MSCommon.vc import get_installed_vcs_components
  32 from SCons.Tool.MSCommon import msvc_sdk_versions
  33 from SCons.Tool.MSCommon import msvc_toolset_versions
  34 from SCons.Tool.MSCommon.MSVC.Kind import (
  35     msvc_version_is_express,
  36     msvc_version_is_btdispatch,
  37 )
  38 import TestSCons
  39
  40 test = TestSCons.TestSCons()
  41 test.skip_if_not_msvc()
  42
  43 installed_versions = get_installed_vcs_components()
  44 default_version = installed_versions[0]
  45
  46 GE_VS2015_supported_versions = []
  47 GE_VS2015_unsupported_versions = []
  48 LT_VS2015_unsupported_versions = []
  49
  50 for v in installed_versions:
  51     if v.msvc_vernum > 14.0:
  52         GE_VS2015_supported_versions.append(v)
  53     elif v.msvc_verstr == '14.0':
  54         if msvc_version_is_express(v.msvc_version):
  55             GE_VS2015_unsupported_versions.append((v, 'Express'))
  56         elif msvc_version_is_btdispatch(v.msvc_version):
  57             GE_VS2015_unsupported_versions.append((v, 'BTDispatch'))
  58         else:
  59             GE_VS2015_supported_versions.append(v)
  60     else:
  61         LT_VS2015_unsupported_versions.append(v)
  62
  63 default_sdk_versions_uwp = msvc_sdk_versions(version=None, msvc_uwp_app=True)
  64 default_sdk_versions_def = msvc_sdk_versions(version=None, msvc_uwp_app=False)
  65
  66 have_140 = any(v.msvc_verstr == '14.0' for v in installed_versions)
  67
  68 def version_major(version):
  69     components = version.split('.')
  70     if len(components) >= 2:
  71         return components[0] + '.' + components[1][0]
  72     if len(components) == 1:
  73         return components[0] + '.0'
  74     return version
  75
  76 def version_major_list(version_list):
  77     versions = []
  78     seen_major = set()
  79     for version in version_list:
  80         major = version_major(version)
  81         if major in seen_major:
  82             continue
  83         versions.append(version)
  84         seen_major.add(major)
  85     return versions
  86
  87 if GE_VS2015_supported_versions:
  88
  89     for supported in GE_VS2015_supported_versions:
  90         # VS2017+ and VS2015 ('14.0')
  91
  92         sdk_versions_uwp = msvc_sdk_versions(version=supported.msvc_version, msvc_uwp_app=True)
  93         sdk_versions_def = msvc_sdk_versions(version=supported.msvc_version, msvc_uwp_app=False)
  94
  95         # find sdk version for each major SDK
  96         sdk_versions = version_major_list(sdk_versions_def)
  97
  98         for sdk_version in sdk_versions:
  99
 100             # sdk version construction variable
 101             test.write('SConstruct', textwrap.dedent(
 102                 """
 103                 DefaultEnvironment(tools=[])
 104                 env = Environment(MSVC_VERSION={0}, MSVC_SDK_VERSION={1}, tools=['msvc'])
 105                 lib_path = env['ENV']['LIB']
 106                 if '\\\\{2}\\\\' not in lib_path:
 107                     raise RuntimeError("{1} not found in lib path " + lib_path)
 108                 """.format(repr(supported.msvc_version), repr(sdk_version), sdk_version)
 109             ))
 110             test.run(arguments='-Q -s', stdout='')
 111
 112             # sdk version script argument
 113             test.write('SConstruct', textwrap.dedent(
 114                 """
 115                 DefaultEnvironment(tools=[])
 116                 env = Environment(MSVC_VERSION={0}, MSVC_SCRIPT_ARGS={1}, tools=['msvc'])
 117                 lib_path = env['ENV']['LIB']
 118                 if '\\\\{2}\\\\' not in lib_path:
 119                     raise RuntimeError("{1} not found in lib path " + lib_path)
 120                 """.format(repr(supported.msvc_version), repr(sdk_version), sdk_version)
 121             ))
 122             test.run(arguments='-Q -s', stdout='')
 123
 124             # sdk version construction variable and script argument
 125             test.write('SConstruct', textwrap.dedent(
 126                 """
 127                 DefaultEnvironment(tools=[])
 128                 env = Environment(MSVC_VERSION={}, MSVC_SDK_VERSION={}, MSVC_SCRIPT_ARGS={}, tools=['msvc'])
 129                 """.format(repr(supported.msvc_version), repr(sdk_version), repr(sdk_version))
 130             ))
 131             test.run(arguments='-Q -s', status=2, stderr=None)
 132             expect = "MSVCArgumentError: multiple sdk version declarations: MSVC_SDK_VERSION={} and MSVC_SCRIPT_ARGS={}:".format(
 133                 repr(sdk_version), repr(sdk_version)
 134             )
 135             test.must_contain_all(test.stderr(), expect)
 136
 137         # sdk version is not supported
 138         invalid_sdk_version = '9.1'
 139         test.write('SConstruct', textwrap.dedent(
 140             """
 141             DefaultEnvironment(tools=[])
 142             env = Environment(MSVC_VERSION={}, MSVC_SDK_VERSION={}, tools=['msvc'])
 143             """.format(repr(supported.msvc_version), repr(invalid_sdk_version))
 144         ))
 145         test.run(arguments='-Q -s', status=2, stderr=None)
 146         expect = "MSVCArgumentError: MSVC_SDK_VERSION ({}) is not supported:".format(
 147             repr(invalid_sdk_version)
 148         )
 149         test.must_contain_all(test.stderr(), expect)
 150
 151         # sdk version not found
 152         missing_sdk_version = '10.0.12345.6'
 153         test.write('SConstruct', textwrap.dedent(
 154             """
 155             DefaultEnvironment(tools=[])
 156             env = Environment(MSVC_VERSION={}, MSVC_SDK_VERSION={}, tools=['msvc'])
 157             """.format(repr(supported.msvc_version), repr(missing_sdk_version))
 158         ))
 159         test.run(arguments='-Q -s', status=2, stderr=None)
 160         expect = "MSVCSDKVersionNotFound: MSVC_SDK_VERSION {} not found for platform type 'Desktop':".format(
 161             repr(missing_sdk_version)
 162         )
 163         test.must_contain_all(test.stderr(), expect)
 164
 165         # platform contraints: 8.1 and UWP
 166         if '8.1' in sdk_versions:
 167
 168             if supported.msvc_vernum > 14.0:
 169
 170                 toolset_full_versions = msvc_toolset_versions(supported.msvc_version, full=True, sxs=False)
 171                 toolset_versions = version_major_list(toolset_full_versions)
 172
 173                 # toolset msvc_version != current msvc_version and toolset msvc_version != 14.0
 174                 toolset_candidates = [v for v in toolset_versions if version_major(v) not in (supported.msvc_verstr, '14.0')]
 175                 toolset_version = toolset_candidates[0] if toolset_candidates else None
 176
 177                 # sdk version 8.1, UWP, and msvc_verson > VS2015
 178                 test.write('SConstruct', textwrap.dedent(
 179                     """
 180                     DefaultEnvironment(tools=[])
 181                     env = Environment(MSVC_VERSION={}, MSVC_SDK_VERSION='8.1', MSVC_UWP_APP=True, tools=['msvc'])
 182                     """.format(repr(supported.msvc_version))
 183                 ))
 184                 test.run(arguments='-Q -s', status=2, stderr=None)
 185                 expect = "MSVCArgumentError: MSVC_SDK_VERSION ('8.1') and platform type ('UWP') constraint violation: MSVC_VERSION {} > '14.0' VS2015:".format(
 186                     repr(supported.msvc_version)
 187                 )
 188                 test.must_contain_all(test.stderr(), expect)
 189
 190                 if toolset_version:
 191
 192                     # sdk version 8.1, UWP, and msvc_toolset_verson > VS2015
 193                     test.write('SConstruct', textwrap.dedent(
 194                         """
 195                         DefaultEnvironment(tools=[])
 196                         env = Environment(MSVC_VERSION={}, MSVC_TOOLSET_VERSION={}, MSVC_SDK_VERSION='8.1', MSVC_UWP_APP=True, tools=['msvc'])
 197                         """.format(repr(supported.msvc_version), repr(toolset_version))
 198                     ))
 199                     test.run(arguments='-Q -s', status=2, stderr=None)
 200                     expect = "MSVCArgumentError: MSVC_SDK_VERSION ('8.1') and platform type ('UWP') constraint violation: toolset {} MSVC_VERSION {} > '14.0' VS2015:".format(
 201                         repr(toolset_version), repr(supported.msvc_version)
 202                     )
 203                     test.must_contain_all(test.stderr(), expect)
 204
 205                 if have_140:
 206
 207                     # sdk version 8.1, UWP, and msvc_toolset_version > VS2015
 208                     test.write('SConstruct', textwrap.dedent(
 209                         """
 210                         DefaultEnvironment(tools=[])
 211                         env = Environment(MSVC_VERSION={}, MSVC_SDK_VERSION='8.1', MSVC_TOOLSET_VERSION='14.0', MSVC_UWP_APP=True, tools=['msvc'])
 212                         """.format(repr(supported.msvc_version))
 213                     ))
 214                     test.run(arguments='-Q -s', stdout='')
 215
 216             elif supported.msvc_vernum == 14.0:
 217
 218                 # sdk version 8.1, UWP, and msvc_verson == VS2015
 219                 test.write('SConstruct', textwrap.dedent(
 220                     """
 221                     DefaultEnvironment(tools=[])
 222                     env = Environment(MSVC_VERSION={}, MSVC_SDK_VERSION='8.1', MSVC_UWP_APP=True, tools=['msvc'])
 223                     """.format(repr(supported.msvc_version))
 224                 ))
 225                 test.run(arguments='-Q -s', stdout='')
 226
 227 if GE_VS2015_unsupported_versions:
 228
 229     for unsupported, kind_str in GE_VS2015_unsupported_versions:
 230         # VS2015 Express
 231
 232         sdk_version = default_sdk_versions_def[0] if default_sdk_versions_def else '8.1'
 233
 234         test.write('SConstruct', textwrap.dedent(
 235             """
 236             DefaultEnvironment(tools=[])
 237             env = Environment(MSVC_VERSION={}, MSVC_SDK_VERSION={}, tools=['msvc'])
 238             """.format(repr(unsupported.msvc_version), repr(sdk_version))
 239         ))
 240         test.run(arguments='-Q -s', status=2, stderr=None)
 241         expect = "MSVCArgumentError: MSVC_SDK_VERSION ({}) is not supported for MSVC_VERSION {} ({}):".format(
 242             repr(sdk_version), repr(unsupported.msvc_version), repr(kind_str)
 243         )
 244         test.must_contain_all(test.stderr(), expect)
 245
 246         # MSVC_SCRIPT_ARGS sdk_version is not validated
 247         test.write('SConstruct', textwrap.dedent(
 248             """
 249             DefaultEnvironment(tools=[])
 250             env = Environment(MSVC_VERSION={}, MSVC_SCRIPT_ARGS={}, tools=['msvc'])
 251             """.format(repr(unsupported.msvc_version), repr(sdk_version))
 252         ))
 253         test.run(arguments='-Q -s', stdout='')
 254
 255 if LT_VS2015_unsupported_versions:
 256
 257     for unsupported in LT_VS2015_unsupported_versions:
 258         # must be VS2015 or later
 259
 260         sdk_version = default_sdk_versions_def[0] if default_sdk_versions_def else '8.1'
 261
 262         test.write('SConstruct', textwrap.dedent(
 263             """
 264             DefaultEnvironment(tools=[])
 265             env = Environment(MSVC_VERSION={}, MSVC_SDK_VERSION={}, tools=['msvc'])
 266             """.format(repr(unsupported.msvc_version), repr(sdk_version))
 267         ))
 268         test.run(arguments='-Q -s', status=2, stderr=None)
 269         expect = "MSVCArgumentError: MSVC_SDK_VERSION ({}) constraint violation: MSVC_VERSION {} < '14.0' VS2015:".format(
 270             repr(sdk_version), repr(unsupported.msvc_version)
 271         )
 272         test.must_contain_all(test.stderr(), expect)
 273
 274         test.write('SConstruct', textwrap.dedent(
 275             """
 276             DefaultEnvironment(tools=[])
 277             env = Environment(MSVC_VERSION={}, MSVC_SCRIPT_ARGS={}, tools=['msvc'])
 278             """.format(repr(unsupported.msvc_version), repr(sdk_version))
 279         ))
 280         test.run(arguments='-Q -s', status=2, stderr=None)
 281         expect = "MSVCArgumentError: MSVC_SCRIPT_ARGS ({}) constraint violation: MSVC_VERSION {} < '14.0' VS2015:".format(
 282             repr(sdk_version), repr(unsupported.msvc_version)
 283         )
 284         test.must_contain_all(test.stderr(), expect)
 285
 286 test.pass_test()
 287
 288 # Local Variables:
 289 # tab-width:4
 290 # indent-tabs-mode:nil
 291 # End:
 292 # vim: set expandtab tabstop=4 shiftwidth=4: