Remove the 'test' (gtest) knowledge and instead support the generic run_as sy...

pylib/gyp/generator/xcode.py

 #!/usr/bin/python
 
 # Copyright (c) 2010 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
@@ skipping 207 matching lines @@
       if xcode_target.support_target:
         support_targets.append(xcode_target.support_target)
         targets.append(xcode_target.support_target)
 
       if not int(target.get('suppress_wildcard', False)):
         targets_for_all.append(xcode_target)
 
       if target_name.lower() == 'all':
         has_custom_all = True;
 
-      # If this target has a 'run_as' attribute, or is a test, add its
-      # target to the targets, and (if it's a test) add it the to the
-      # test targets.
-      is_test = int(target.get('test', 0))
-      if target.get('run_as') or is_test:
+      # If this target has a 'run_as' attribute, add its target to the
+      # targets, and add it to the test targets.
+      if target.get('run_as'):
         # Make a target to run something.  It should have one
         # dependency, the parent xcode target.
         xccl = CreateXCConfigurationList(configurations)
         run_target = gyp.xcodeproj_file.PBXAggregateTarget({
               'name':                   'Run ' + target_name,
               'productName':            xcode_target.GetProperty('productName'),
               'buildConfigurationList': xccl,
             },
             parent=self.project)
         run_target.AddDependency(xcode_target)
 
-        # The test runner target has a build phase that executes the
-        # test, if this has the 'test' attribute.  If the 'run_as' tag
-        # doesn't exist (meaning that this must be a test), then we
-        # define a default test command line.
-        command = target.get('run_as', {
-          'action': ['${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}']
-          })
-
+        command = target['run_as']
         script = ''
         if command.get('working_directory'):
           script = script + 'cd "%s"\n' % \
                    gyp.xcodeproj_file.ConvertVariablesToShellSyntax(
                        command.get('working_directory'))
 
         if command.get('environment'):
           script = script + "\n".join(
             ['export %s="%s"' %
              (key, gyp.xcodeproj_file.ConvertVariablesToShellSyntax(val))
              for (key, val) in command.get('environment').iteritems()]) + "\n"
 
         # Some test end up using sockets, files on disk, etc. and can get
         # confused if more then one test runs at a time.  The generator
         # flag 'xcode_serialize_all_test_runs' controls the forcing of all
         # tests serially.  It defaults to True.  To get serial runs this
         # little bit of python does the same as the linux flock utility to
         # make sure only one runs at a time.
         command_prefix = ''
-        if is_test and serialize_all_tests:
+        if serialize_all_tests:
           command_prefix = \
 """python -c "import fcntl, subprocess, sys
 file = open('$TMPDIR/GYP_serialize_test_runs', 'a')
 fcntl.flock(file.fileno(), fcntl.LOCK_EX)
 sys.exit(subprocess.call(sys.argv[1:]))" """
 
         # If we were unable to exec for some reason, we want to exit
         # with an error, and fixup variable references to be shell
         # syntax instead of xcode syntax.
         script = script + 'exec ' + command_prefix + '%s\nexit 1\n' % \
                  gyp.xcodeproj_file.ConvertVariablesToShellSyntax(
                      gyp.common.EncodePOSIXShellList(command.get('action')))
 
         ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase({
               'shellScript':      script,
               'showEnvVarsInLog': 0,
             })
         run_target.AppendProperty('buildPhases', ssbp)
 
         # Add the run target to the project file.
         targets.append(run_target)
-        if is_test:
-          run_test_targets.append(run_target)
-          xcode_target.test_runner = run_target
+        run_test_targets.append(run_target)
+        xcode_target.test_runner = run_target
 
 
     # Make sure that the list of targets being replaced is the same length as
     # the one replacing it, but allow for the added test runner targets.
     assert len(self.project._properties['targets']) == \
       len(ordinary_targets) + len(support_targets)
 
     self.project._properties['targets'] = targets
 
     # Get rid of unnecessary levels of depth in groups like the Source group.
@@ skipping 59 matching lines @@
         qualified_target = gyp.common.QualifiedTarget(self.gyp_path,
                                                       tgt_name, toolset)
         xcode_target = xcode_targets[qualified_target]
         if isinstance(xcode_target, gyp.xcodeproj_file.PBXAggregateTarget):
           # Collect all the run test targets.
           all_run_tests = []
           pbxtds = xcode_target.GetProperty('dependencies')
           for pbxtd in pbxtds:
             pbxcip = pbxtd.GetProperty('targetProxy')
             dependency_xct = pbxcip.GetProperty('remoteGlobalIDString')
-            target_dict = xcode_target_to_target_dict[dependency_xct]
-            if target_dict and int(target_dict.get('test', 0)):
-              assert dependency_xct.test_runner
+            if hasattr(dependency_xct, 'test_runner'):
               all_run_tests.append(dependency_xct.test_runner)
 
           # Directly depend on all the runners as they depend on the target
           # that builds them.
           if len(all_run_tests) > 0:
             run_all_target = gyp.xcodeproj_file.PBXAggregateTarget({
                   'name':        'Run %s Tests' % tgt_name,
                   'productName': tgt_name,
                 },
                 parent=self.project)
@@ skipping 774 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()