Add TestGypXcodeNinja to run tests against the xcode-ninja generator

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 270 matching lines @@
 
     # TODO:  --depth=. works around Chromium-specific tree climbing.
     depth = kw.pop('depth', '.')
     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)

[sdefresne, 2014/09/02 15:13:05]

I don't really like the fact that you add to change each and every test case to
add "-G xcode_ninja_target_pattern=^${something}$" as additional arguments, with
a default value of .* for something.

What about adding the following here:

  # Default xcode_ninja_target_pattern to ^.*$ to fix xcode-ninja tests
  xcode_ninja_target_pattern = kw.pop('xcode_ninja_target_pattern', '^.*$')
  run_args.extend(['-G', 'xcode_ninja_target_pattern=%s' %
xcode_ninja_target_pattern)

Then you can omit the '-G', 'xcode_ninja_target_pattern=^whatever$' in most of
the call of run_gyp, and pass it as xcode_ninja_target_pattern='^whatever$' when
needed.

BTW, I'm surprised that ^.*$ is not the default value for
xcode_ninja_target_pattern. Maybe a bug should be created and referenced here.

[Tobias, 2014/10/02 18:19:19]

I share your feelings, I also feel a bit uneasy about adding this generator
option to every test.

My thinking behind adding it to the tests instead of the test runner is to make
the behavior of the xcode_ninja generator explicit, i.e. to avoid surprises
where your test works (because of an implicit target pattern of ^.*$), but not
when you run gyp yourself. I totally understand that there are good arguments
for either option, though, and I'd be happy to do whatever you prefer here.

The reason that ^.*$ is not the default generator target pattern is by design as
far as I understand (cf. the docstring of IsValidTargetForWrapper() in
xcode_ninja.py). Just building executable targets seems to be good enough in
'most' cases -- unless you're writing test cases that is ;)



On 2014/09/02 15:13:05, sdefresne wrote:

     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
     the tool-specific subclasses or clutter the tests themselves
@@ skipping 1016 matching lines @@
     result = []
     chdir = kw.get('chdir')
     if chdir:
       result.append(chdir)
     configuration = self.configuration_dirname()
     result.extend(['build', configuration])
     result.append(self.built_file_basename(name, type, **kw))
     return self.workpath(*result)
 
 
+class TestGypXcodeNinja(TestGypXcode):
+  """
+  Subclass for testing the GYP Xcode Ninja generator.
+  """
+  format = 'xcode-ninja'
+
+  def initialize_build_tool(self):
+    super(TestGypXcodeNinja, 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, **kw):
+    """
+    Runs an xcodebuild using the .xcodeproj generated from the specified
+    gyp_file.
+    """
+    build_config = self.configuration
+    if build_config and build_config.endswith(('-iphoneos',
+                                               '-iphonesimulator')):
+      build_config, sdk = self.configuration.split('-')
+      kw['arguments'] = kw.get('arguments', []) + ['-sdk', sdk]
+
+    with self._build_configuration(build_config):
+      return super(TestGypXcodeNinja, self).build(
+        gyp_file.replace('.gyp', '.ninja.gyp'), target, **kw)
+
+  @contextmanager
+  def _build_configuration(self, build_config):
+    config = self.configuration
+    self.configuration = build_config
+    try:
+      yield
+    finally:
+      self.configuration = config
+
+  def built_file_path(self, name, type=None, **kw):
+    result = []
+    chdir = kw.get('chdir')
+    if chdir:
+      result.append(chdir)
+    result.append('out')
+    result.append(self.configuration_dirname())
+    subdir = kw.get('subdir')
+    if subdir and type != self.SHARED_LIB:
+      result.append(subdir)
+    result.append(self.built_file_basename(name, type, **kw))
+    return self.workpath(*result)
+
+  def up_to_date(self, gyp_file, target=None, **kw):
+    result = self.build(gyp_file, target, **kw)
+    if not result:
+      stdout = self.stdout()
+      if 'ninja: no work to do' not in stdout:
+        self.report_not_up_to_date()
+        self.fail_test()
+    return result
+
+  def run_built_executable(self, name, *args, **kw):
+    """
+    Runs an executable built by xcodebuild + ninja.
+    """
+    configuration = self.configuration_dirname()
+    os.environ['DYLD_LIBRARY_PATH'] = os.path.join('out', configuration)
+    # Enclosing the name in a list avoids prepending the original dir.
+    program = [self.built_file_path(name, type=self.EXECUTABLE, **kw)]
+    return self.run(program=program, *args, **kw)
+
+
 format_class_list = [
   TestGypGypd,
   TestGypAndroid,
   TestGypCMake,
   TestGypMake,
   TestGypMSVS,
   TestGypMSVSNinja,
   TestGypNinja,
   TestGypXcode,
+  TestGypXcodeNinja,
 ]
 
 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