Fix msvs-ninja OutputDirectory path.

test/lib/TestGyp.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 TestGyp.py:  a testing framework for GYP integration tests.
 """
 
 import collections
 from contextlib import contextmanager
@@ skipping 60 matching lines @@
   The default behavior is to test the 'gyp' or 'gyp.bat' file in the
   current directory.  An alternative may be specified explicitly on
   instantiation, or by setting the TESTGYP_GYP environment variable.
 
   This class should be subclassed for each supported gyp generator
   (format).  Various abstract methods below define calling signatures
   used by the test scripts to invoke builds on the generated build
   configuration and to run executables generated by those builds.
   """
 
+  formats = []
   build_tool = None
   build_tool_list = []
 
   _exe = TestCommon.exe_suffix
   _obj = TestCommon.obj_suffix
   shobj_ = TestCommon.shobj_prefix
   _shobj = TestCommon.shobj_suffix
   lib_ = TestCommon.lib_prefix
   _lib = TestCommon.lib_suffix
   dll_ = TestCommon.dll_prefix
@@ skipping 15 matching lines @@
     if not gyp:
       gyp = os.environ.get('TESTGYP_GYP')
       if not gyp:
         if sys.platform == 'win32':
           gyp = 'gyp.bat'
         else:
           gyp = 'gyp'
     self.gyp = os.path.abspath(gyp)
     self.no_parallel = False
 
+    self.formats = [self.format]
+
     self.initialize_build_tool()
 
     kw.setdefault('match', TestCommon.match_exact)
 
     # Put test output in out/testworkarea by default.
     # Use temporary names so there are no collisions.
     workdir = os.path.join('out', kw.get('workdir', 'testworkarea'))
     # Create work area if it doesn't already exist.
     if not os.path.isdir(workdir):
       os.makedirs(workdir)
 
     kw['workdir'] = tempfile.mktemp(prefix='testgyp.', dir=workdir)
 
     formats = kw.pop('formats', [])
 
     super(TestGypBase, self).__init__(*args, **kw)
 
+    real_format = self.format.split('-')[-1]
     excluded_formats = set([f for f in formats if f[0] == '!'])
     included_formats = set(formats) - excluded_formats
-    if ('!'+self.format in excluded_formats or
-        included_formats and self.format not in included_formats):
+    if ('!'+real_format in excluded_formats or
+        included_formats and real_format not in included_formats):
       msg = 'Invalid test for %r format; skipping test.\n'
       self.skip_test(msg % self.format)
 
     self.copy_test_configuration(self.origin_cwd, self.workdir)
     self.set_configuration(None)
 
     # Set $HOME so that gyp doesn't read the user's actual
     # ~/.gyp/include.gypi file, which may contain variables
     # and other settings that would change the output.
     os.environ['HOME'] = self.workpath()
@@ skipping 118 matching lines @@
     Runs gyp against the specified gyp_file with the specified args.
     """
 
     # When running gyp, and comparing its output we use a comparitor
     # that ignores the line numbers that gyp logs in its debug output.
     if kw.pop('ignore_line_numbers', False):
       kw.setdefault('match', match_modulo_line_numbers)
 
     # TODO:  --depth=. works around Chromium-specific tree climbing.
     depth = kw.pop('depth', '.')
-    run_args = ['--depth='+depth, '--format='+self.format, gyp_file]
+    run_args = ['--depth='+depth]
+    run_args.extend(['--format='+f for f in self.formats]);
+    run_args.append(gyp_file)
     if self.no_parallel:
       run_args += ['--no-parallel']
+    # TODO: if extra_args contains a '--build' flag
+    # we really want that to only apply to the last format (self.format).
     run_args.extend(self.extra_args)
     run_args.extend(args)
     return self.run(program=self.gyp, arguments=run_args, **kw)
 
   def run(self, *args, **kw):
     """
     Executes a program by calling the superclass .run() method.
 
     This exists to provide a common place to filter out keyword
     arguments implemented in this layer, without having to update
@@ skipping 452 matching lines @@
 
 
 def ConvertToCygpath(path):
   """Convert to cygwin path if we are using cygwin."""
   if sys.platform == 'cygwin':
     p = subprocess.Popen(['cygpath', path], stdout=subprocess.PIPE)
     path = p.communicate()[0].strip()
   return path
 
 
+def FindMSBuildInstallation(msvs_version = 'auto'):
+  """Returns path to MSBuild for msvs_version or latest available.
+
+  Looks in the registry to find install location of MSBuild.
+  MSBuild before v4.0 will not build c++ projects, so only use newer versions.
+  """
+  import _winreg
+  def get_reg_key(base, key):
+    try:
+      result = _winreg.OpenKey(base, key, 0,
+                               _winreg.KEY_READ | _winreg.KEY_WOW64_32KEY)
+    except WindowsError:
+      result = None
+    return result
+
+  def get_reg_key_value(key, value):
+    try:
+      result, _ = _winreg.QueryValueEx(key, value)
+    except WindowsError:
+      result = None
+    return result
+
+  msbuild_basekey = get_reg_key(_winreg.HKEY_LOCAL_MACHINE,
+                                'SOFTWARE\Microsoft\MSBuild\ToolsVersions')
+  if not msbuild_basekey:
+    print 'Error: could not find MSBuild base registry entry'
+    return None
+
+  msvs_to_msbuild = {
+      '2013': r'12.0',
+      '2012': r'4.0', #really v4.0.30319 which comes with .NET 4.5
+      '2010': r'4.0'}
+
+  msbuild_key = None
+  if msvs_version in msvs_to_msbuild:
+    msbuild_version = msvs_to_msbuild[msvs_version]
+    msbuild_key = get_reg_key(msbuild_basekey, msbuild_version)
+    if not msbuild_key:
+      print ('Warning: Environment variable GYP_MSVS_VERSION specifies "%s" '
+             'but corresponding MSBuild "%s" was not found.' %
+             (msvs_version, msbuild_version))
+  if not msbuild_key:
+    for msvs_version in sorted(msvs_to_msbuild, reverse=True):
+      msbuild_version = msvs_to_msbuild[msvs_version]
+      msbuild_key = get_reg_key(msbuild_basekey, msbuild_version)
+  if not msbuild_key:
+    print 'Error: could not find MSBuild registry entry'
+    return None
+
+  msbuild_path = get_reg_key_value(msbuild_key, 'MSBuildToolsPath')
+  if not msbuild_path:
+    print 'Error: could not get MSBuild registry entry value'
+    return None
+
+  return os.path.join(msbuild_path, 'MSBuild.exe')
+
+
 def FindVisualStudioInstallation():
   """Returns appropriate values for .build_tool and .uses_msbuild fields
   of TestGypBase for Visual Studio.
 
   We use the value specified by GYP_MSVS_VERSION.  If not specified, we
   search %PATH% and %PATHEXT% for a devenv.{exe,bat,...} executable.
   Failing that, we search for likely deployment paths.
   """
   possible_roots = ['%s:\\Program Files%s' % (chr(drive), suffix)
                     for drive in range(ord('C'), ord('Z') + 1)
                     for suffix in ['', ' (x86)']]
   possible_paths = {
       '2013': r'Microsoft Visual Studio 12.0\Common7\IDE\devenv.com',
       '2012': r'Microsoft Visual Studio 11.0\Common7\IDE\devenv.com',
       '2010': r'Microsoft Visual Studio 10.0\Common7\IDE\devenv.com',
       '2008': r'Microsoft Visual Studio 9.0\Common7\IDE\devenv.com',
       '2005': r'Microsoft Visual Studio 8\Common7\IDE\devenv.com'}
 
   possible_roots = [ConvertToCygpath(r) for r in possible_roots]
 
   msvs_version = 'auto'
   for flag in (f for f in sys.argv if f.startswith('msvs_version=')):
     msvs_version = flag.split('=')[-1]
   msvs_version = os.environ.get('GYP_MSVS_VERSION', msvs_version)
 
-  build_tool = None
   if msvs_version in possible_paths:
     # Check that the path to the specified GYP_MSVS_VERSION exists.
     path = possible_paths[msvs_version]
     for r in possible_roots:
-      bt = os.path.join(r, path)
-      if os.path.exists(bt):
-        build_tool = bt
+      build_tool = os.path.join(r, path)
+      if os.path.exists(build_tool):
         uses_msbuild = msvs_version >= '2010'
-        return build_tool, uses_msbuild
+        msbuild_path = FindMSBuildInstallation(msvs_version)
+        return build_tool, uses_msbuild, msbuild_path
     else:
       print ('Warning: Environment variable GYP_MSVS_VERSION specifies "%s" '
               'but corresponding "%s" was not found.' % (msvs_version, path))
-  if build_tool:
-    # We found 'devenv' on the path, use that and try to guess the version.
-    for version, path in possible_paths.iteritems():
-      if build_tool.find(path) >= 0:
-        uses_msbuild = version >= '2010'
-        return build_tool, uses_msbuild
-    else:
-      # If not, assume not MSBuild.
-      uses_msbuild = False
-    return build_tool, uses_msbuild
   # Neither GYP_MSVS_VERSION nor the path help us out.  Iterate through
   # the choices looking for a match.
   for version in sorted(possible_paths, reverse=True):
     path = possible_paths[version]
     for r in possible_roots:
-      bt = os.path.join(r, path)
-      if os.path.exists(bt):
-        build_tool = bt
+      build_tool = os.path.join(r, path)
+      if os.path.exists(build_tool):
         uses_msbuild = msvs_version >= '2010'
-        return build_tool, uses_msbuild
+        msbuild_path = FindMSBuildInstallation(msvs_version)
+        return build_tool, uses_msbuild, msbuild_path
   print 'Error: could not find devenv'
   sys.exit(1)
 
 class TestGypOnMSToolchain(TestGypBase):
   """
   Common subclass for testing generators that target the Microsoft Visual
   Studio toolchain (cl, link, dumpbin, etc.)
   """
   @staticmethod
   def _ComputeVsvarsPath(devenv_path):
     devenv_dir = os.path.split(devenv_path)[0]
     vsvars_path = os.path.join(devenv_path, '../../Tools/vsvars32.bat')
     return vsvars_path
 
   def initialize_build_tool(self):
     super(TestGypOnMSToolchain, self).initialize_build_tool()
     if sys.platform in ('win32', 'cygwin'):
-      self.devenv_path, self.uses_msbuild = FindVisualStudioInstallation()
+      build_tools = FindVisualStudioInstallation()
+      self.devenv_path, self.uses_msbuild, self.msbuild_path = build_tools
       self.vsvars_path = TestGypOnMSToolchain._ComputeVsvarsPath(
           self.devenv_path)
 
   def run_dumpbin(self, *dumpbin_args):
     """Run the dumpbin tool with the specified arguments, and capturing and
     returning stdout."""
     assert sys.platform in ('win32', 'cygwin')
     cmd = os.environ.get('COMSPEC', 'cmd.exe')
     arguments = [cmd, '/c', self.vsvars_path, '&&', 'dumpbin']
     arguments.extend(dumpbin_args)
@@ skipping 159 matching lines @@
     chdir = kw.get('chdir')
     if chdir:
       result.append(chdir)
     result.append(self.configuration_dirname())
     if type == self.STATIC_LIB:
       result.append('lib')
     result.append(self.built_file_basename(name, type, **kw))
     return self.workpath(*result)
 
 
+class TestGypMSVSNinja(TestGypNinja):
+  """
+  Subclass for testing the GYP Visual Studio Ninja generator.
+  """
+  format = 'msvs-ninja'
+
+  def initialize_build_tool(self):
+    super(TestGypMSVSNinja, self).initialize_build_tool()
+    # When using '--build', make sure ninja is first in the format list.
+    self.formats.insert(0, 'ninja')
+
+  def build(self, gyp_file, target=None, rebuild=False, clean=False, **kw):
+    """
+    Runs a Visual Studio build using the configuration generated
+    from the specified gyp_file.
+    """
+    arguments = kw.get('arguments', [])[:]
+    if target in (None, self.ALL, self.DEFAULT):
+      # Note: the Visual Studio generator doesn't add an explicit 'all' target.
+      # This will build each project. This will work if projects are hermetic,
+      # but may fail if they are not (a project may run more than once).
+      # It would be nice to supply an all.metaproj for MSBuild.
+      arguments.extend([gyp_file.replace('.gyp', '.sln')])
+    else:
+      # MSBuild documentation claims that one can specify a sln but then build a
+      # project target like 'msbuild a.sln /t:proj:target' but this format only
+      # supports 'Clean', 'Rebuild', and 'Publish' (with none meaning Default).
+      # This limitation is due to the .sln -> .sln.metaproj conversion.
+      # The ':' is not special, 'proj:target' is a target in the metaproj.
+      arguments.extend([target+'.vcxproj'])
+
+    if clean:
+      build = 'Clean'
+    elif rebuild:
+      build = 'Rebuild'
+    else:
+      build = 'Build'
+    arguments.extend(['/target:'+build])
+    configuration = self.configuration_buildname()
+    config = configuration.split('|')
+    arguments.extend(['/property:Configuration='+config[0]])
+    if len(config) > 1:
+      arguments.extend(['/property:Platform='+config[1]])
+    arguments.extend(['/property:BuildInParallel=false'])
+    arguments.extend(['/verbosity:minimal'])
+
+    kw['arguments'] = arguments
+    return self.run(program=self.msbuild_path, **kw)
+
+
 class TestGypXcode(TestGypBase):
   """
   Subclass for testing the GYP Xcode generator.
   """
   format = 'xcode'
   build_tool_list = ['xcodebuild']
 
   phase_script_execution = ("\n"
                             "PhaseScriptExecution /\\S+/Script-[0-9A-F]+\\.sh\n"
                             "    cd /\\S+\n"
@@ skipping 96 matching lines @@
     result.append(self.built_file_basename(name, type, **kw))
     return self.workpath(*result)
 
 
 format_class_list = [
   TestGypGypd,
   TestGypAndroid,
   TestGypCMake,
   TestGypMake,
   TestGypMSVS,
+  TestGypMSVSNinja,
   TestGypNinja,
   TestGypXcode,
 ]
 
 def TestGyp(*args, **kw):
   """
   Returns an appropriate TestGyp* instance for a specified GYP format.
   """
   format = kw.pop('format', os.environ.get('TESTGYP_FORMAT'))
   for format_class in format_class_list:
     if format == format_class.format:
       return format_class(*args, **kw)
   raise Exception, "unknown format %r" % format