src/tools/gn/substitution_writer_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <sstream>
   6
   7 #include "testing/gtest/include/gtest/gtest.h"
   8 #include "tools/gn/err.h"
   9 #include "tools/gn/escape.h"
  10 #include "tools/gn/substitution_list.h"
  11 #include "tools/gn/substitution_pattern.h"
  12 #include "tools/gn/substitution_writer.h"
  13 #include "tools/gn/target.h"
  14 #include "tools/gn/test_with_scope.h"
  15
  16 TEST(SubstitutionWriter, GetListAs) {
  17   TestWithScope setup;
  18
  19   SubstitutionList list = SubstitutionList::MakeForTest(
  20       "//foo/bar/a.cc",
  21       "//foo/bar/b.cc");
  22
  23   std::vector<SourceFile> sources;
  24   SubstitutionWriter::GetListAsSourceFiles(list, &sources);
  25   ASSERT_EQ(2u, sources.size());
  26   EXPECT_EQ("//foo/bar/a.cc", sources[0].value());
  27   EXPECT_EQ("//foo/bar/b.cc", sources[1].value());
  28
  29   std::vector<OutputFile> outputs;
  30   SubstitutionWriter::GetListAsOutputFiles(setup.settings(), list, &outputs);
  31   ASSERT_EQ(2u, outputs.size());
  32   EXPECT_EQ("../../foo/bar/a.cc", outputs[0].value());
  33   EXPECT_EQ("../../foo/bar/b.cc", outputs[1].value());
  34 }
  35
  36 TEST(SubstitutionWriter, ApplyPatternToSource) {
  37   TestWithScope setup;
  38
  39   SubstitutionPattern pattern;
  40   Err err;
  41   ASSERT_TRUE(pattern.Parse("{{source_gen_dir}}/{{source_name_part}}.tmp",
  42                             NULL, &err));
  43
  44   SourceFile result = SubstitutionWriter::ApplyPatternToSource(
  45       setup.settings(), pattern, SourceFile("//foo/bar/myfile.txt"));
  46   ASSERT_EQ("//out/Debug/gen/foo/bar/myfile.tmp", result.value());
  47 }
  48
  49 TEST(SubstitutionWriter, ApplyPatternToSourceAsOutputFile) {
  50   TestWithScope setup;
  51
  52   SubstitutionPattern pattern;
  53   Err err;
  54   ASSERT_TRUE(pattern.Parse("{{source_gen_dir}}/{{source_name_part}}.tmp",
  55                             NULL, &err));
  56
  57   OutputFile result = SubstitutionWriter::ApplyPatternToSourceAsOutputFile(
  58       setup.settings(), pattern, SourceFile("//foo/bar/myfile.txt"));
  59   ASSERT_EQ("gen/foo/bar/myfile.tmp", result.value());
  60 }
  61
  62 TEST(SubstitutionWriter, WriteNinjaVariablesForSource) {
  63   TestWithScope setup;
  64
  65   std::vector<SubstitutionType> types;
  66   types.push_back(SUBSTITUTION_SOURCE);
  67   types.push_back(SUBSTITUTION_SOURCE_NAME_PART);
  68   types.push_back(SUBSTITUTION_SOURCE_DIR);
  69
  70   EscapeOptions options;
  71   options.mode = ESCAPE_NONE;
  72
  73   std::ostringstream out;
  74   SubstitutionWriter::WriteNinjaVariablesForSource(
  75       setup.settings(), SourceFile("//foo/bar/baz.txt"), types, options, out);
  76
  77   // The "source" should be skipped since that will expand to $in which is
  78   // implicit.
  79   EXPECT_EQ(
  80       "  source_name_part = baz\n"
  81       "  source_dir = ../../foo/bar\n",
  82       out.str());
  83 }
  84
  85 TEST(SubstitutionWriter, WriteWithNinjaVariables) {
  86   Err err;
  87   SubstitutionPattern pattern;
  88   ASSERT_TRUE(pattern.Parse(
  89       "-i {{source}} --out=bar\"{{source_name_part}}\".o",
  90       NULL, &err));
  91   EXPECT_FALSE(err.has_error());
  92
  93   EscapeOptions options;
  94   options.mode = ESCAPE_NONE;
  95
  96   std::ostringstream out;
  97   SubstitutionWriter::WriteWithNinjaVariables(pattern, options, out);
  98
  99   EXPECT_EQ(
 100       "-i ${in} --out=bar\"${source_name_part}\".o",
 101       out.str());
 102 }
 103
 104 TEST(SubstitutionWriter, SourceSubstitutions) {
 105   TestWithScope setup;
 106
 107   // Call to get substitutions relative to the build dir.
 108   #define GetRelSubst(str, what) \
 109       SubstitutionWriter::GetSourceSubstitution( \
 110           setup.settings(), \
 111           SourceFile(str), \
 112           what, \
 113           SubstitutionWriter::OUTPUT_RELATIVE, \
 114           setup.settings()->build_settings()->build_dir())
 115
 116   // Call to get absolute directory substitutions.
 117   #define GetAbsSubst(str, what) \
 118       SubstitutionWriter::GetSourceSubstitution( \
 119           setup.settings(), \
 120           SourceFile(str), \
 121           what, \
 122           SubstitutionWriter::OUTPUT_ABSOLUTE, \
 123           SourceDir())
 124
 125   // Try all possible templates with a normal looking string.
 126   EXPECT_EQ("../../foo/bar/baz.txt",
 127             GetRelSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE));
 128   EXPECT_EQ("//foo/bar/baz.txt",
 129             GetAbsSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE));
 130
 131   EXPECT_EQ("baz",
 132             GetRelSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_NAME_PART));
 133   EXPECT_EQ("baz",
 134             GetAbsSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_NAME_PART));
 135
 136   EXPECT_EQ("baz.txt",
 137             GetRelSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_FILE_PART));
 138   EXPECT_EQ("baz.txt",
 139             GetAbsSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_FILE_PART));
 140
 141   EXPECT_EQ("../../foo/bar",
 142             GetRelSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_DIR));
 143   EXPECT_EQ("//foo/bar",
 144             GetAbsSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_DIR));
 145
 146   EXPECT_EQ("foo/bar", GetRelSubst("//foo/bar/baz.txt",
 147                                    SUBSTITUTION_SOURCE_ROOT_RELATIVE_DIR));
 148   EXPECT_EQ("foo/bar", GetAbsSubst("//foo/bar/baz.txt",
 149                                    SUBSTITUTION_SOURCE_ROOT_RELATIVE_DIR));
 150
 151   EXPECT_EQ("gen/foo/bar",
 152             GetRelSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_GEN_DIR));
 153   EXPECT_EQ("//out/Debug/gen/foo/bar",
 154             GetAbsSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_GEN_DIR));
 155
 156   EXPECT_EQ("obj/foo/bar",
 157             GetRelSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_OUT_DIR));
 158   EXPECT_EQ("//out/Debug/obj/foo/bar",
 159             GetAbsSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_OUT_DIR));
 160
 161   // Operations on an absolute path.
 162   EXPECT_EQ("/baz.txt", GetRelSubst("/baz.txt", SUBSTITUTION_SOURCE));
 163   EXPECT_EQ("/.", GetRelSubst("/baz.txt", SUBSTITUTION_SOURCE_DIR));
 164   EXPECT_EQ("gen", GetRelSubst("/baz.txt", SUBSTITUTION_SOURCE_GEN_DIR));
 165   EXPECT_EQ("obj", GetRelSubst("/baz.txt", SUBSTITUTION_SOURCE_OUT_DIR));
 166
 167   EXPECT_EQ(".",
 168             GetRelSubst("//baz.txt", SUBSTITUTION_SOURCE_ROOT_RELATIVE_DIR));
 169
 170   #undef GetAbsSubst
 171   #undef GetRelSubst
 172 }
 173
 174 TEST(SubstitutionWriter, TargetSubstitutions) {
 175   TestWithScope setup;
 176   Err err;
 177
 178   Target target(setup.settings(), Label(SourceDir("//foo/bar/"), "baz"));
 179   target.set_output_type(Target::STATIC_LIBRARY);
 180   target.SetToolchain(setup.toolchain());
 181   ASSERT_TRUE(target.OnResolved(&err));
 182
 183   std::string result;
 184   EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
 185       &target, SUBSTITUTION_LABEL, &result));
 186   EXPECT_EQ("//foo/bar:baz", result);
 187
 188   EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
 189       &target, SUBSTITUTION_ROOT_GEN_DIR, &result));
 190   EXPECT_EQ("gen", result);
 191
 192   EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
 193       &target, SUBSTITUTION_ROOT_OUT_DIR, &result));
 194   EXPECT_EQ(".", result);
 195
 196   EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
 197       &target, SUBSTITUTION_TARGET_GEN_DIR, &result));
 198   EXPECT_EQ("gen/foo/bar", result);
 199
 200   EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
 201       &target, SUBSTITUTION_TARGET_OUT_DIR, &result));
 202   EXPECT_EQ("obj/foo/bar", result);
 203
 204   EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
 205       &target, SUBSTITUTION_TARGET_OUTPUT_NAME, &result));
 206   EXPECT_EQ("libbaz", result);
 207 }
 208
 209 TEST(SubstitutionWriter, CompilerSubstitutions) {
 210   TestWithScope setup;
 211   Err err;
 212
 213   Target target(setup.settings(), Label(SourceDir("//foo/bar/"), "baz"));
 214   target.set_output_type(Target::STATIC_LIBRARY);
 215   target.SetToolchain(setup.toolchain());
 216   ASSERT_TRUE(target.OnResolved(&err));
 217
 218   // The compiler substitution is just source + target combined. So test one
 219   // of each of those classes of things to make sure this is hooked up.
 220   EXPECT_EQ("file",
 221             SubstitutionWriter::GetCompilerSubstitution(
 222                 &target, SourceFile("//foo/bar/file.txt"),
 223                 SUBSTITUTION_SOURCE_NAME_PART));
 224   EXPECT_EQ("gen/foo/bar",
 225             SubstitutionWriter::GetCompilerSubstitution(
 226                 &target, SourceFile("//foo/bar/file.txt"),
 227                 SUBSTITUTION_TARGET_GEN_DIR));
 228 }
 229
 230 TEST(SubstitutionWriter, LinkerSubstitutions) {
 231   TestWithScope setup;
 232   Err err;
 233
 234   Target target(setup.settings(), Label(SourceDir("//foo/bar/"), "baz"));
 235   target.set_output_type(Target::SHARED_LIBRARY);
 236   target.SetToolchain(setup.toolchain());
 237   ASSERT_TRUE(target.OnResolved(&err));
 238
 239   const Tool* tool = setup.toolchain()->GetToolForTargetFinalOutput(&target);
 240
 241   // The compiler substitution is just target + OUTPUT_EXTENSION combined. So
 242   // test one target one plus the output extension.
 243   EXPECT_EQ(".so",
 244             SubstitutionWriter::GetLinkerSubstitution(
 245                 &target, tool, SUBSTITUTION_OUTPUT_EXTENSION));
 246   EXPECT_EQ("gen/foo/bar",
 247             SubstitutionWriter::GetLinkerSubstitution(
 248                 &target, tool, SUBSTITUTION_TARGET_GEN_DIR));
 249
 250   // Test that we handle paths that end up in the root build dir properly
 251   // (no leading "./" or "/").
 252   SubstitutionPattern pattern;
 253   ASSERT_TRUE(
 254       pattern.Parse("{{root_out_dir}}/{{target_output_name}}.so", NULL, &err));
 255
 256   OutputFile output = SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
 257       &target, tool, pattern);
 258   EXPECT_EQ("./libbaz.so", output.value());
 259 }