Support more configurability in GN toolchains

tools/gn/filesystem_utils_unittest.cc

 // Copyright (c) 2013 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 "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/filesystem_utils.h"
+#include "tools/gn/target.h"
 
 TEST(FilesystemUtils, FileExtensionOffset) {
   EXPECT_EQ(std::string::npos, FindExtensionOffset(""));
   EXPECT_EQ(std::string::npos, FindExtensionOffset("foo/bar/baz"));
   EXPECT_EQ(4u, FindExtensionOffset("foo."));
   EXPECT_EQ(4u, FindExtensionOffset("f.o.bar"));
   EXPECT_EQ(std::string::npos, FindExtensionOffset("foo.bar/"));
   EXPECT_EQ(std::string::npos, FindExtensionOffset("foo.bar/baz"));
 }
 
@@ skipping 68 matching lines @@
 
   SourceDir regular2("//foo/bar/");
   EXPECT_EQ("bar", FindLastDirComponent(regular2));
 }
 
 TEST(FilesystemUtils, EnsureStringIsInOutputDir) {
   SourceDir output_dir("//out/Debug/");
 
   // Some outside.
   Err err;
-  EXPECT_FALSE(EnsureStringIsInOutputDir(output_dir, "//foo", Value(), &err));
+  EXPECT_FALSE(EnsureStringIsInOutputDir(output_dir, "//foo", NULL, &err));
   EXPECT_TRUE(err.has_error());
   err = Err();
-  EXPECT_FALSE(EnsureStringIsInOutputDir(output_dir, "//out/Debugit", Value(),
+  EXPECT_FALSE(EnsureStringIsInOutputDir(output_dir, "//out/Debugit", NULL,
                                          &err));
   EXPECT_TRUE(err.has_error());
 
   // Some inside.
   err = Err();
-  EXPECT_TRUE(EnsureStringIsInOutputDir(output_dir, "//out/Debug/", Value(),
+  EXPECT_TRUE(EnsureStringIsInOutputDir(output_dir, "//out/Debug/", NULL,
                                         &err));
   EXPECT_FALSE(err.has_error());
-  EXPECT_TRUE(EnsureStringIsInOutputDir(output_dir, "//out/Debug/foo", Value(),
+  EXPECT_TRUE(EnsureStringIsInOutputDir(output_dir, "//out/Debug/foo", NULL,
                                         &err));
   EXPECT_FALSE(err.has_error());
 
   // Pattern but no template expansions are allowed.
   EXPECT_FALSE(EnsureStringIsInOutputDir(output_dir, "{{source_gen_dir}}",
-                                         Value(), &err));
+                                         NULL, &err));
   EXPECT_TRUE(err.has_error());
 }
 
 TEST(FilesystemUtils, IsPathAbsolute) {
   EXPECT_TRUE(IsPathAbsolute("/foo/bar"));
   EXPECT_TRUE(IsPathAbsolute("/"));
   EXPECT_FALSE(IsPathAbsolute(""));
   EXPECT_FALSE(IsPathAbsolute("//"));
   EXPECT_FALSE(IsPathAbsolute("//foo/bar"));
 
@@ skipping 223 matching lines @@
   // Should be case-sensitive.
   EXPECT_EQ("/SOURCE/foo/bar/", SourceDirForPath(root,
             base::FilePath("/SOURCE/foo/bar/")).value());
 #endif
 }
 
 TEST(FilesystemUtils, GetToolchainDirs) {
   BuildSettings build_settings;
   build_settings.SetBuildDir(SourceDir("//out/Debug/"));
 
+  // The default toolchain.
   Settings default_settings(&build_settings, "");
+  Label default_toolchain_label(SourceDir("//toolchain/"), "default");
+  default_settings.set_toolchain_label(default_toolchain_label);
+  default_settings.set_default_toolchain_label(default_toolchain_label);
+
+  // Default toolchain out dir.
   EXPECT_EQ("//out/Debug/",
             GetToolchainOutputDir(&default_settings).value());
+  EXPECT_EQ("//out/Debug/",
+            GetToolchainOutputDir(&build_settings, default_toolchain_label,
+                                  true).value());
+
+  // Default toolchain gen dir.
   EXPECT_EQ("//out/Debug/gen/",
             GetToolchainGenDir(&default_settings).value());
+  EXPECT_EQ("gen/",
+            GetToolchainGenDirAsOutputFile(&default_settings).value());
+  EXPECT_EQ("//out/Debug/gen/",
+            GetToolchainGenDir(&build_settings, default_toolchain_label,
+                               true).value());
 
+  // Check a secondary toolchain.
   Settings other_settings(&build_settings, "two/");
+  Label other_toolchain_label(SourceDir("//toolchain/"), "two");
+  default_settings.set_toolchain_label(other_toolchain_label);
+  default_settings.set_default_toolchain_label(default_toolchain_label);
+
+  // Secondary toolchain out dir.
   EXPECT_EQ("//out/Debug/two/",
             GetToolchainOutputDir(&other_settings).value());
+  EXPECT_EQ("//out/Debug/two/",
+            GetToolchainOutputDir(&build_settings, other_toolchain_label,
+                                  false).value());
+
+  // Secondary toolchain gen dir.
   EXPECT_EQ("//out/Debug/two/gen/",
             GetToolchainGenDir(&other_settings).value());
+  EXPECT_EQ("two/gen/",
+            GetToolchainGenDirAsOutputFile(&other_settings).value());
+  EXPECT_EQ("//out/Debug/two/gen/",
+            GetToolchainGenDir(&build_settings, other_toolchain_label,
+                               false).value());
 }
 
 TEST(FilesystemUtils, GetOutDirForSourceDir) {
   BuildSettings build_settings;
   build_settings.SetBuildDir(SourceDir("//out/Debug/"));
 
   // Test the default toolchain.
   Settings default_settings(&build_settings, "");
   EXPECT_EQ("//out/Debug/obj/",
-            GetOutputDirForSourceDir(&default_settings,
-                                     SourceDir("//")).value());
+            GetOutputDirForSourceDir(
+                &default_settings, SourceDir("//")).value());
+  EXPECT_EQ("obj/",
+            GetOutputDirForSourceDirAsOutputFile(
+                &default_settings, SourceDir("//")).value());
+
   EXPECT_EQ("//out/Debug/obj/foo/bar/",
-            GetOutputDirForSourceDir(&default_settings,
-                                     SourceDir("//foo/bar/")).value());
+            GetOutputDirForSourceDir(
+                &default_settings, SourceDir("//foo/bar/")).value());
+  EXPECT_EQ("obj/foo/bar/",
+            GetOutputDirForSourceDirAsOutputFile(
+                &default_settings, SourceDir("//foo/bar/")).value());
 
   // Secondary toolchain.
   Settings other_settings(&build_settings, "two/");
   EXPECT_EQ("//out/Debug/two/obj/",
-            GetOutputDirForSourceDir(&other_settings, SourceDir("//")).value());
+            GetOutputDirForSourceDir(
+                &other_settings, SourceDir("//")).value());
+  EXPECT_EQ("two/obj/",
+            GetOutputDirForSourceDirAsOutputFile(
+                &other_settings, SourceDir("//")).value());
+
   EXPECT_EQ("//out/Debug/two/obj/foo/bar/",
             GetOutputDirForSourceDir(&other_settings,
                                      SourceDir("//foo/bar/")).value());
+  EXPECT_EQ("two/obj/foo/bar/",
+            GetOutputDirForSourceDirAsOutputFile(
+                &other_settings, SourceDir("//foo/bar/")).value());
 }
 
 TEST(FilesystemUtils, GetGenDirForSourceDir) {
   BuildSettings build_settings;
   build_settings.SetBuildDir(SourceDir("//out/Debug/"));
 
   // Test the default toolchain.
   Settings default_settings(&build_settings, "");
   EXPECT_EQ("//out/Debug/gen/",
-            GetGenDirForSourceDir(&default_settings, SourceDir("//")).value());
+            GetGenDirForSourceDir(
+                &default_settings, SourceDir("//")).value());
+  EXPECT_EQ("gen/",
+            GetGenDirForSourceDirAsOutputFile(
+                &default_settings, SourceDir("//")).value());
+
   EXPECT_EQ("//out/Debug/gen/foo/bar/",
-            GetGenDirForSourceDir(&default_settings,
-                                  SourceDir("//foo/bar/")).value());
+            GetGenDirForSourceDir(
+                &default_settings, SourceDir("//foo/bar/")).value());
+  EXPECT_EQ("gen/foo/bar/",
+            GetGenDirForSourceDirAsOutputFile(
+                &default_settings, SourceDir("//foo/bar/")).value());
 
   // Secondary toolchain.
   Settings other_settings(&build_settings, "two/");
   EXPECT_EQ("//out/Debug/two/gen/",
-            GetGenDirForSourceDir(&other_settings, SourceDir("//")).value());
+            GetGenDirForSourceDir(
+                &other_settings, SourceDir("//")).value());
+  EXPECT_EQ("two/gen/",
+            GetGenDirForSourceDirAsOutputFile(
+                &other_settings, SourceDir("//")).value());
+
   EXPECT_EQ("//out/Debug/two/gen/foo/bar/",
-            GetGenDirForSourceDir(&other_settings,
-                                  SourceDir("//foo/bar/")).value());
+            GetGenDirForSourceDir(
+                &other_settings, SourceDir("//foo/bar/")).value());
+  EXPECT_EQ("two/gen/foo/bar/",
+            GetGenDirForSourceDirAsOutputFile(
+                &other_settings, SourceDir("//foo/bar/")).value());
+}
+
+TEST(FilesystemUtils, GetTargetDirs) {
+  BuildSettings build_settings;
+  build_settings.SetBuildDir(SourceDir("//out/Debug/"));
+  Settings settings(&build_settings, "");
+
+  Target a(&settings, Label(SourceDir("//foo/bar/"), "baz"));
+  EXPECT_EQ("//out/Debug/obj/foo/bar/", GetTargetOutputDir(&a).value());
+  EXPECT_EQ("obj/foo/bar/", GetTargetOutputDirAsOutputFile(&a).value());
+  EXPECT_EQ("//out/Debug/gen/foo/bar/", GetTargetGenDir(&a).value());
+  EXPECT_EQ("gen/foo/bar/", GetTargetGenDirAsOutputFile(&a).value());
 }
 
 // Tests handling of output dirs when build dir is the same as the root.
 TEST(FilesystemUtils, GetDirForEmptyBuildDir) {
   BuildSettings build_settings;
   build_settings.SetBuildDir(SourceDir("//"));
   Settings settings(&build_settings, "");
 
   EXPECT_EQ("//", GetToolchainOutputDir(&settings).value());
   EXPECT_EQ("//gen/", GetToolchainGenDir(&settings).value());
+  EXPECT_EQ("gen/", GetToolchainGenDirAsOutputFile(&settings).value());
   EXPECT_EQ("//obj/",
             GetOutputDirForSourceDir(&settings, SourceDir("//")).value());
-  EXPECT_EQ("//gen/",
-            GetGenDirForSourceDir(&settings, SourceDir("//")).value());
+  EXPECT_EQ("obj/",
+            GetOutputDirForSourceDirAsOutputFile(
+                &settings, SourceDir("//")).value());
+  EXPECT_EQ("gen/",
+            GetGenDirForSourceDirAsOutputFile(
+                &settings, SourceDir("//")).value());
 }