Add functionality to find xctest files under application target.

tools/gn/xcode_writer.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "tools/gn/xcode_writer.h"
 
 #include <iomanip>
 #include <map>
 #include <memory>
 #include <sstream>
@@ skipping 13 matching lines @@
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/source_file.h"
 #include "tools/gn/target.h"
 #include "tools/gn/value.h"
 #include "tools/gn/variables.h"
 #include "tools/gn/xcode_object.h"
 
 namespace {
 
+using TargetToFileList = std::unordered_map<const Target*, Target::FileList>;
+
+const char kEarlGreyFileNameIdentifier[] = "egtest.mm";
+const char kXCTestFileNameIdentifier[] = "xctest.mm";
+const char kXCTestModuleTargetNamePostfix[] = "_module";
+
 struct SafeEnvironmentVariableInfo {
   const char* name;
   bool capture_at_generation;
 };
 
 SafeEnvironmentVariableInfo kSafeEnvironmentVariables[] = {
     {"HOME", true}, {"LANG", true},    {"PATH", true},
     {"USER", true}, {"TMPDIR", false},
 };
 
@@ skipping 35 matching lines @@
 
   script << "ninja -C .";
   if (!ninja_extra_args.empty())
     script << " " << ninja_extra_args;
   if (!target_name.empty())
     script << " " << target_name;
   script << "\nexit 1\n";
   return script.str();
 }
 
+bool IsApplicationTarget(const Target* target) {
+  return target->output_type() == Target::CREATE_BUNDLE &&
+         target->bundle_data().product_type() ==
+             "com.apple.product-type.application";
+}
+
+bool IsXCTestModuleTarget(const Target* target) {
+  return target->output_type() == Target::CREATE_BUNDLE &&
+         target->bundle_data().product_type() ==
+             "com.apple.product-type.bundle.unit-test" &&
+         base::EndsWith(target->label().name(), kXCTestModuleTargetNamePostfix,
+                        base::CompareCase::SENSITIVE);
+}
+
+const Target* FindXCTestApplicationTarget(
+    const Target* xctest_module_target,
+    const std::vector<const Target*>& targets) {
+  DCHECK(IsXCTestModuleTarget(xctest_module_target));
+  DCHECK(base::EndsWith(xctest_module_target->label().name(),
+                        kXCTestModuleTargetNamePostfix,
+                        base::CompareCase::SENSITIVE));
+  std::string application_target_name =
+      xctest_module_target->label().name().substr(
+          0, xctest_module_target->label().name().size() -
+                 strlen(kXCTestModuleTargetNamePostfix));
+  for (const Target* target : targets) {
+    if (target->label().name() == application_target_name) {
+      return target;
+    }
+  }
+  NOTREACHED();
+  return nullptr;
+}
+
+// Returns the corresponding application targets given XCTest module targets.
+void FindXCTestApplicationTargets(
+    const std::vector<const Target*>& xctest_module_targets,
+    const std::vector<const Target*>& targets,
+    std::vector<const Target*>* xctest_application_targets) {
+  for (const Target* xctest_module_target : xctest_module_targets) {
+    xctest_application_targets->push_back(
+        FindXCTestApplicationTarget(xctest_module_target, targets));
+  }
+}
+
+// Searches the list of xctest files recursively under |target|.
+void SearchXCTestFiles(const Target* target,
+                       TargetToFileList* xctest_files_per_target) {
+  // Early return if already visited and processed.
+  if (xctest_files_per_target->find(target) != xctest_files_per_target->end())
+    return;
+
+  Target::FileList xctest_files;
+  for (const SourceFile& file : target->sources()) {
+    if (base::EndsWith(file.GetName(), kEarlGreyFileNameIdentifier,
+                       base::CompareCase::SENSITIVE) ||
+        base::EndsWith(file.GetName(), kXCTestFileNameIdentifier,
+                       base::CompareCase::SENSITIVE)) {
+      xctest_files.push_back(file);
+    }
+  }
+
+  // Call recursively on public and private deps.
+  for (const auto& target : target->public_deps()) {
+    SearchXCTestFiles(target.ptr, xctest_files_per_target);
+    const Target::FileList& deps_xctest_files =
+        (*xctest_files_per_target)[target.ptr];
+    xctest_files.insert(xctest_files.end(), deps_xctest_files.begin(),
+                        deps_xctest_files.end());
+  }
+
+  for (const auto& target : target->private_deps()) {
+    SearchXCTestFiles(target.ptr, xctest_files_per_target);
+    const Target::FileList& deps_xctest_files =
+        (*xctest_files_per_target)[target.ptr];
+    xctest_files.insert(xctest_files.end(), deps_xctest_files.begin(),
+                        deps_xctest_files.end());
+  }
+
+  // Sort xctest_files to remove duplicates.
+  std::sort(xctest_files.begin(), xctest_files.end());
+  xctest_files.erase(std::unique(xctest_files.begin(), xctest_files.end()),
+                     xctest_files.end());
+
+  xctest_files_per_target->insert(std::make_pair(target, xctest_files));
+}
+
+// Finds the list of xctest files recursively under each of the application
+// targets.
+void FindXCTestFilesForTargets(
+    const std::vector<const Target*>& application_targets,
+    std::vector<Target::FileList>* file_lists) {
+  TargetToFileList xctest_files_per_target;
+
+  for (const Target* target : application_targets) {
+    DCHECK(IsApplicationTarget(target));
+    SearchXCTestFiles(target, &xctest_files_per_target);
+    file_lists->push_back(xctest_files_per_target[target]);
+  }
+}
+
 class CollectPBXObjectsPerClassHelper : public PBXObjectVisitor {
  public:
   CollectPBXObjectsPerClassHelper() {}
 
   void Visit(PBXObject* object) override {
     DCHECK(object);
     objects_per_class_[object->Class()].push_back(object);
   }
 
   const std::map<PBXObjectClass, std::vector<const PBXObject*>>&
@@ skipping 160 matching lines @@
   // Sort the list of targets per-label to get a consistent ordering of them
   // in the generated Xcode project (and thus stability of the file generated).
   std::sort(targets->begin(), targets->end(),
             [](const Target* a, const Target* b) {
               return a->label().name() < b->label().name();
             });
 
   return true;
 }
 
+// static
+void XcodeWriter::FilterXCTestModuleTargets(
+    const std::vector<const Target*>& targets,
+    std::vector<const Target*>* xctest_module_targets) {
+  for (const Target* target : targets) {
+    if (!IsXCTestModuleTarget(target))
+      continue;
+
+    xctest_module_targets->push_back(target);
+  }
+}
+
 void XcodeWriter::CreateProductsProject(
     const std::vector<const Target*>& targets,
     const PBXAttributes& attributes,
     const std::string& source_path,
     const std::string& config_name,
     const std::string& root_target,
     const std::string& ninja_extra_args,
     const BuildSettings* build_settings,
     TargetOsType target_os) {
   std::unique_ptr<PBXProject> main_project(
       new PBXProject("products", config_name, source_path, attributes));
 
+  // Filter xctest module and application targets and find list of xctest files
+  // recursively under them.
+  std::vector<const Target*> xctest_module_targets;
+  FilterXCTestModuleTargets(targets, &xctest_module_targets);
+
+  std::vector<const Target*> xctest_application_targets;
+  FindXCTestApplicationTargets(xctest_module_targets, targets,
+                               &xctest_application_targets);
+  DCHECK_EQ(xctest_module_targets.size(), xctest_application_targets.size());
+
+  std::vector<Target::FileList> xctest_file_lists;
+  FindXCTestFilesForTargets(xctest_application_targets, &xctest_file_lists);
+  DCHECK_EQ(xctest_application_targets.size(), xctest_file_lists.size());
+
   std::string build_path;
   std::unique_ptr<base::Environment> env(base::Environment::Create());
 
   main_project->AddAggregateTarget(
       "All", GetBuildScript(root_target, ninja_extra_args, env.get()));
 
   for (const Target* target : targets) {
     switch (target->output_type()) {
       case Target::EXECUTABLE:
         if (target_os == XcodeWriter::WRITER_TARGET_OS_IOS)
@@ skipping 136 matching lines @@
     for (auto* object : pair.second) {
       object->Print(out, 2);
     }
     out << "/* End " << ToString(pair.first) << " section */\n";
   }
 
   out << "\t};\n"
       << "\trootObject = " << project->Reference() << ";\n"
       << "}\n";
 }