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)
 
+    realFormat = self.format.split('-')[-1]

[scottmg, 2014/05/30 16:41:37]

realFormat -> real_format

[bungeman-chromium, 2014/05/30 22:18:09]

Done.

     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 ('!'+realFormat in excluded_formats or
+        included_formats and realFormat 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 707 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)
 
 
+def FindMSBuildInstallation():

[scottmg, 2014/05/30 16:41:37]

This looks very similar to FindVisualStudioInstallation. Could it be shared
somehow?

[bungeman-chromium, 2014/05/30 22:18:09]

It is, but it needn't be. I think I shied away from it due to
FindVisualStudioInstallation having dead code and generally wanting to use just
MSBuild in the future and drop devenv (though we still need dumpbin, so we're
still looking for the vs path). Also, this is the wrong way to go about finding
MSBuild anyway (as described in the comments).

+  """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_roots.extend(['%s:\\Windows' % (chr(drive),)
+                         for drive in range(ord('C'), ord('Z') + 1)])
+  possible_paths = {
+      '2013': r'MSBuild\12.0\Bin\MSBuild.exe', #Program Files
+      '2012': r'Microsoft.NET\Framework\v4.0.30319\MSBuild.exe', #Windows
+      '2010': r'Microsoft.NET\Framework\v4.0\MSBuild.exe',
+      '2008': r'Microsoft.NET\Framework\v3.5\MSBuild.exe'}
+  #The reccommended way to find this is
+  #reg.exe query "HKLM\SOFTWARE\Microsoft\MSBuild\ToolsVersions\12.0" /v MSBuildToolsPath
+  #2013 : 12.0
+  #2012 : 4.0 (really v4.0.30319 which comes with 4.5)
+  #2010 : 4.0
+  #2008 : 3.5
+
+  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
+        return build_tool
+    else:
+      print ('Warning: Environment variable GYP_MSVS_VERSION specifies "%s" '
+              'but corresponding "%s" was not found.' % (msvs_version, path))
+  if build_tool:
+    # We found 'MSBuild' on the path, use that and try to guess the version.
+    for version, path in possible_paths.iteritems():
+      if build_tool.find(path) >= 0:
+        return build_tool
+    return build_tool
+  # 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
+        return build_tool
+  print 'Error: could not find MSBuild'
+  sys.exit(1)
+
+
+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()
+    self.msbuild_path = FindMSBuildInstallation()
+    # 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 not in (None, self.ALL, self.DEFAULT):
+      # 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'])
+    else:
+      # Note: the Visual Studio generator doesn't add an explicit 'all' target.
+     if 1:
+      # 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:
+      # This is a cheat which just runs ninja's 'all' target directly.
+      # However, this doesn't test what we want to test here,
+      # which is that the thin msbuild projects call ninja correctly.
+      return super(TestGypMSVSNinja, self).build(gyp_file, target=target, **kw)
+
+    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