tools/gn/file_template_unittest.cc

   1 // Copyright (c) 2013 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/escape.h"
   9 #include "tools/gn/file_template.h"
  10 #include "tools/gn/test_with_scope.h"
  11
  12 TEST(FileTemplate, Static) {
  13   TestWithScope setup;
  14
  15   std::vector<std::string> templates;
  16   templates.push_back("something_static");
  17   FileTemplate t(setup.settings(), templates);
  18   EXPECT_FALSE(t.has_substitutions());
  19
  20   std::vector<std::string> result;
  21   t.Apply(SourceFile("//foo/bar"), &result);
  22   ASSERT_EQ(1u, result.size());
  23   EXPECT_EQ("something_static", result[0]);
  24 }
  25
  26 TEST(FileTemplate, Typical) {
  27   TestWithScope setup;
  28
  29   std::vector<std::string> templates;
  30   templates.push_back("foo/{{source_name_part}}.cc");
  31   templates.push_back("foo/{{source_name_part}}.h");
  32   FileTemplate t(setup.settings(), templates);
  33   EXPECT_TRUE(t.has_substitutions());
  34
  35   std::vector<std::string> result;
  36   t.Apply(SourceFile("//sources/ha.idl"), &result);
  37   ASSERT_EQ(2u, result.size());
  38   EXPECT_EQ("foo/ha.cc", result[0]);
  39   EXPECT_EQ("foo/ha.h", result[1]);
  40 }
  41
  42 TEST(FileTemplate, Weird) {
  43   TestWithScope setup;
  44
  45   std::vector<std::string> templates;
  46   templates.push_back("{{{source}}{{source}}{{");
  47   FileTemplate t(setup.settings(), templates);
  48   EXPECT_TRUE(t.has_substitutions());
  49
  50   std::vector<std::string> result;
  51   t.Apply(SourceFile("//foo/lalala.c"), &result);
  52   ASSERT_EQ(1u, result.size());
  53   EXPECT_EQ("{../../foo/lalala.c../../foo/lalala.c{{", result[0]);
  54 }
  55
  56 TEST(FileTemplate, NinjaExpansions) {
  57   TestWithScope setup;
  58
  59   std::vector<std::string> templates;
  60   templates.push_back("-i");
  61   templates.push_back("{{source}}");
  62   templates.push_back("--out=foo bar\"{{source_name_part}}\".o");
  63   templates.push_back("");  // Test empty string.
  64
  65   FileTemplate t(setup.settings(), templates);
  66
  67   std::ostringstream out;
  68   t.WriteWithNinjaExpansions(out);
  69
  70 #if defined(OS_WIN)
  71   // The third argument should get quoted since it contains a space, and the
  72   // embedded quotes should get shell escaped.
  73   EXPECT_EQ(
  74       " -i ${source} \"--out=foo$ bar\\\"${source_name_part}\\\".o\" \"\"",
  75       out.str());
  76 #else
  77   // On Posix we don't need to quote the whole thing and can escape all
  78   // individual bad chars.
  79   EXPECT_EQ(
  80       " -i ${source} --out=foo\\$ bar\\\"${source_name_part}\\\".o \"\"",
  81       out.str());
  82 #endif
  83 }
  84
  85 TEST(FileTemplate, NinjaVariables) {
  86   TestWithScope setup;
  87
  88   std::vector<std::string> templates;
  89   templates.push_back("-i");
  90   templates.push_back("{{source}}");
  91   templates.push_back("--out=foo bar\"{{source_name_part}}\".o");
  92   templates.push_back("{{source_file_part}}");
  93   templates.push_back("{{source_dir}}");
  94   templates.push_back("{{source_root_relative_dir}}");
  95   templates.push_back("{{source_gen_dir}}");
  96   templates.push_back("{{source_out_dir}}");
  97
  98   FileTemplate t(setup.settings(), templates);
  99
 100   std::ostringstream out;
 101   EscapeOptions options;
 102   options.mode = ESCAPE_NINJA_COMMAND;
 103   t.WriteNinjaVariablesForSubstitution(out, setup.settings(),
 104                                        SourceFile("//foo/bar.txt"), options);
 105
 106   // Just the variables used above should be written.
 107   EXPECT_EQ(
 108       "  source = ../../foo/bar.txt\n"
 109       "  source_name_part = bar\n"
 110       "  source_file_part = bar.txt\n"
 111       "  source_dir = ../../foo\n"
 112       "  source_root_rel_dir = foo\n"
 113       "  source_gen_dir = gen/foo\n"
 114       "  source_out_dir = obj/foo\n",
 115       out.str());
 116 }
 117
 118 // Tests in isolation different types of substitutions and that the right
 119 // things are generated.
 120 TEST(FileTemplate, Substitutions) {
 121   TestWithScope setup;
 122
 123   #define GetSubst(str, what) \
 124       FileTemplate::GetSubstitution(setup.settings(), \
 125                                     SourceFile(str), \
 126                                     FileTemplate::Subrange::what)
 127
 128   // Try all possible templates with a normal looking string.
 129   EXPECT_EQ("../../foo/bar/baz.txt", GetSubst("//foo/bar/baz.txt", SOURCE));
 130   EXPECT_EQ("baz", GetSubst("//foo/bar/baz.txt", NAME_PART));
 131   EXPECT_EQ("baz.txt", GetSubst("//foo/bar/baz.txt", FILE_PART));
 132   EXPECT_EQ("../../foo/bar", GetSubst("//foo/bar/baz.txt", SOURCE_DIR));
 133   EXPECT_EQ("foo/bar", GetSubst("//foo/bar/baz.txt", ROOT_RELATIVE_DIR));
 134   EXPECT_EQ("gen/foo/bar", GetSubst("//foo/bar/baz.txt", SOURCE_GEN_DIR));
 135   EXPECT_EQ("obj/foo/bar", GetSubst("//foo/bar/baz.txt", SOURCE_OUT_DIR));
 136
 137   // Operations on an absolute path.
 138   EXPECT_EQ("/baz.txt", GetSubst("/baz.txt", SOURCE));
 139   EXPECT_EQ("/.", GetSubst("/baz.txt", SOURCE_DIR));
 140   EXPECT_EQ("gen", GetSubst("/baz.txt", SOURCE_GEN_DIR));
 141   EXPECT_EQ("obj", GetSubst("/baz.txt", SOURCE_OUT_DIR));
 142
 143   EXPECT_EQ(".", GetSubst("//baz.txt", ROOT_RELATIVE_DIR));
 144
 145   #undef GetSubst
 146 }