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 490 matching lines @@
     path = possible_paths[msvs_version]
     for r in possible_roots:
       bt = os.path.join(r, path)
       if os.path.exists(bt):
         build_tool = bt
         uses_msbuild = msvs_version >= '2010'
         return build_tool, uses_msbuild
     else:
       print ('Warning: Environment variable GYP_MSVS_VERSION specifies "%s" '
               'but corresponding "%s" was not found.' % (msvs_version, path))
   if build_tool:

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

This code never runs, so removing it.

     # 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
@@ skipping 196 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():

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

This is the better way to find MSBuild, not integrated with
FindVisualStudioInstallation.

+  """Returns path to MSBuild for GYP_MSVS_VERSION, 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'
+    sys.exit(1)
+
+  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'}
+
+  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)
+
+  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'
+    sys.exit(1)
+
+  msbuild_path = get_reg_key_value(msbuild_key, 'MSBuildToolsPath')
+  if not msbuild_path:
+    print 'Error: could not get MSBuild registry entry value'
+    sys.exit(1)
+
+  return os.path.join(msbuild_path, 'MSBuild.exe')
+
+
+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 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