Adds generator support for Xcode 5 xctest targets.

pylib/gyp/generator/xcode.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.
 
 import filecmp
 import gyp.common
 import gyp.xcodeproj_file
 import errno
 import os
 import sys
@@ skipping 55 matching lines @@
 ]
 
 # The Xcode-specific keys that exist on targets and aren't moved down to
 # configurations.
 generator_additional_non_configuration_keys = [
   'mac_bundle',
   'mac_bundle_resources',
   'mac_framework_headers',
   'mac_framework_private_headers',
   'xcode_create_dependents_test_runner',
+  'xctest_bundle',
+  'xctest_host',
 ]
 
 # We want to let any rules apply to files that are resources also.
 generator_extra_sources_for_rules = [
   'mac_bundle_resources',
   'mac_framework_headers',
   'mac_framework_private_headers',
 ]
 
 # Xcode's standard set of library directories, which don't need to be duplicated
@@ skipping 549 matching lines @@
     # loadable_modules not in a mac_bundle are mapped to
     # com.googlecode.gyp.xcode.bundle, a pseudo-type that xcode.py interprets
     # to create a single-file mh_bundle.
     _types = {
       'executable':             'com.apple.product-type.tool',
       'loadable_module':        'com.googlecode.gyp.xcode.bundle',
       'shared_library':         'com.apple.product-type.library.dynamic',
       'static_library':         'com.apple.product-type.library.static',
       'executable+bundle':      'com.apple.product-type.application',
       'loadable_module+bundle': 'com.apple.product-type.bundle',
+      'loadable_module+xctest': 'com.apple.product-type.bundle.unit-test',
       'shared_library+bundle':  'com.apple.product-type.framework',
     }
 
     target_properties = {
       'buildConfigurationList': xccl,
       'name':                   target_name,
     }
 
     type = spec['type']
     is_bundle = int(spec.get('mac_bundle', 0))
+    is_xctest = int(spec.get('xctest_bundle', 0))
     if type != 'none':
       type_bundle_key = type
       if is_bundle:
         type_bundle_key += '+bundle'
+      if is_xctest:
+        type_bundle_key += '+xctest'

[Mark Mentovai, 2013/10/30 16:40:27]

This code snippet seems to say that loadable_module+bundle+xctest can be
produced, but that doesn’t seem right, and you don’t handle that case.

[jonwall, 2013/10/30 19:07:38]

Done.

+        assert type == 'loadable_module', (
+            'xctest_bundle targets must have type loadable_module (target %s)' %
+            target_name)
+
       xctarget_type = gyp.xcodeproj_file.PBXNativeTarget
       try:
         target_properties['productType'] = _types[type_bundle_key]
       except KeyError, e:
         gyp.common.ExceptionAppend(e, "-- unknown product type while "
                                    "writing target %s" % target_name)
         raise
     else:
       xctarget_type = gyp.xcodeproj_file.PBXAggregateTarget
       assert not is_bundle, (
           'mac_bundle targets cannot have type none (target "%s")' %
           target_name)
+      assert not is_xctest, (
+          'xctest_bundle targets cannot have type none (target "%s")' %
+          target_name)
 
     target_product_name = spec.get('product_name')
     if target_product_name is not None:
       target_properties['productName'] = target_product_name
 
     xct = xctarget_type(target_properties, parent=pbxp,
                         force_outdir=spec.get('product_dir'),
                         force_prefix=spec.get('product_prefix'),
                         force_extension=spec.get('product_extension'))
     pbxp.AppendProperty('targets', xct)
@@ skipping 21 matching lines @@
             target_product_name + ' Support'
       support_xct = \
           gyp.xcodeproj_file.PBXAggregateTarget(support_target_properties,
                                                 parent=pbxp)
       pbxp.AppendProperty('targets', support_xct)
       xct.AddDependency(support_xct)
     # Hang the support target off the main target so it can be tested/found
     # by the generator during Finalize.
     xct.support_target = support_xct
 
+    if is_xctest and 'xctest_host' in spec:
+      test_host = spec['xctest_host']
+      test_host_qualified_target = gyp.common.QualifiedTarget(
+          build_file, test_host, toolset)
+      assert test_host_qualified_target in spec['dependencies'], (
+          'xctest_host (%s) must be listed as a dependency. (target %s)' %

[Mark Mentovai, 2013/10/30 16:40:27]

Why? Can’t it be an indirect dependency?

[jonwall, 2013/10/30 19:07:38]

It looks like spec['dependencies'] includes indirect dependencies, if I'm
understanding you correctly.

[Mark Mentovai, 2013/10/30 19:57:31]

jonwall wrote:
I didn’t think that was true. You’re saying that if target a depends on b, and b
depends on c, when reaching here for target a, spec['dependencies'] will include
c?

[jonwall, 2013/10/30 21:04:57]

Yes. 

+          (test_host, target_name))
+      test_host_target = target_dicts[test_host_qualified_target]
+      assert test_host_target['type'] == 'executable', (
+          'xctest_host must have type executable (target %s)' % target_name)
+      # Prune any duplicated dependencies.

[Mark Mentovai, 2013/10/30 16:40:27]

Why?

[jonwall, 2013/10/30 19:07:38]

If you comment out this line, you'll see the test case I've added fails because
a category method cannot be found at runtime. The test case has this setup:

App target depends on Classes, which depends on shared.
Test target depends on App and test_support, which depends on shared.

By default this results in gyp setting up the Test target to link to
libtest_support.a and libshared.a. None of the dependencies from App are linked
in because App is a linkable target. This can work in many cases, but problems
can occur by linking to objects already linked to the bundle loader (in this
case libshared.a). The test case has a "Shared" class defined in libshared.a,
and category methods are added in libclasses.a and libtest_support.a. Without
this pruning of libshared.a the test bundle uses the definition of Shared class
from the test bundle (via libshared.a), and cannot find the category method
defined in the App bundle (via libclasses.a). Pruning out dependencies linked to
the xctest_host target (in this case, libshared.a) avoids this issue because the
test bundle uses the Shared class from the app bundle. 

[Mark Mentovai, 2013/10/30 19:57:31]

This sounds like a generic problem with making any loadable_module depend on
something its bundle_loader also provides. It’s not a reason to start pruning
dependencies from loadable_modules (or a subset of loadable_modules) here in
some automated fashion in the generator. The problem should be corrected in the
.gyp files, not by this workaround.

If you find yourself in this sort of situation, a better generic solution to the
generic problem is often to make the “shared” target in your example into a
shared_library. Another option more specific to your example is to make
“test_support” not depend on “shared,” or to have a variant of test_support that
doesn’t depend on shared, for use in this situation.

[jonwall, 2013/10/30 21:04:57]

Okay. It looks like I can get this to work by cloning the executable target and
adding any test dependencies to the executable target. 

+      spec['dependencies'] = [dep for dep in spec['dependencies']
+                              if dep not in test_host_target['dependencies']]
+
     prebuild_index = 0
 
     # Add custom shell script phases for "actions" sections.
     for action in spec_actions:
       # There's no need to write anything into the script to ensure that the
       # output directories already exist, because Xcode will look at the
       # declared outputs and automatically ensure that they exist for us.
 
       # Do we have a message to print when this action runs?
       message = action.get('message')
@@ skipping 481 matching lines @@
 
   for build_file in build_files:
     xcode_projects[build_file].Finalize1(xcode_targets, serialize_all_tests)
 
   for build_file in build_files:
     xcode_projects[build_file].Finalize2(xcode_targets,
                                          xcode_target_to_target_dict)
 
   for build_file in build_files:
     xcode_projects[build_file].Write()