src/manifest_parser_test.cc

   1 // Copyright 2011 Google Inc. All Rights Reserved.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include "manifest_parser.h"
  16
  17 #include <map>
  18 #include <vector>
  19
  20 #include "graph.h"
  21 #include "state.h"
  22 #include "test.h"
  23
  24 struct ParserTest : public testing::Test,
  25                     public ManifestParser::FileReader {
  26   void AssertParse(const char* input) {
  27     ManifestParser parser(&state, this, kDupeEdgeActionWarn);
  28     string err;
  29     EXPECT_TRUE(parser.ParseTest(input, &err));
  30     ASSERT_EQ("", err);
  31     VerifyGraph(state);
  32   }
  33
  34   virtual bool ReadFile(const string& path, string* content, string* err) {
  35     files_read_.push_back(path);
  36     map<string, string>::iterator i = files_.find(path);
  37     if (i == files_.end()) {
  38       *err = "No such file or directory";  // Match strerror() for ENOENT.
  39       return false;
  40     }
  41     *content = i->second;
  42     return true;
  43   }
  44
  45   State state;
  46   map<string, string> files_;
  47   vector<string> files_read_;
  48 };
  49
  50 TEST_F(ParserTest, Empty) {
  51   ASSERT_NO_FATAL_FAILURE(AssertParse(""));
  52 }
  53
  54 TEST_F(ParserTest, Rules) {
  55   ASSERT_NO_FATAL_FAILURE(AssertParse(
  56 "rule cat\n"
  57 "  command = cat $in > $out\n"
  58 "\n"
  59 "rule date\n"
  60 "  command = date > $out\n"
  61 "\n"
  62 "build result: cat in_1.cc in-2.O\n"));
  63
  64   ASSERT_EQ(3u, state.bindings_.GetRules().size());
  65   const Rule* rule = state.bindings_.GetRules().begin()->second;
  66   EXPECT_EQ("cat", rule->name());
  67   EXPECT_EQ("[cat ][$in][ > ][$out]",
  68             rule->GetBinding("command")->Serialize());
  69 }
  70
  71 TEST_F(ParserTest, RuleAttributes) {
  72   // Check that all of the allowed rule attributes are parsed ok.
  73   ASSERT_NO_FATAL_FAILURE(AssertParse(
  74 "rule cat\n"
  75 "  command = a\n"
  76 "  depfile = a\n"
  77 "  deps = a\n"
  78 "  description = a\n"
  79 "  generator = a\n"
  80 "  restat = a\n"
  81 "  rspfile = a\n"
  82 "  rspfile_content = a\n"
  83 ));
  84 }
  85
  86 TEST_F(ParserTest, IgnoreIndentedComments) {
  87   ASSERT_NO_FATAL_FAILURE(AssertParse(
  88 "  #indented comment\n"
  89 "rule cat\n"
  90 "  command = cat $in > $out\n"
  91 "  #generator = 1\n"
  92 "  restat = 1 # comment\n"
  93 "  #comment\n"
  94 "build result: cat in_1.cc in-2.O\n"
  95 "  #comment\n"));
  96
  97   ASSERT_EQ(2u, state.bindings_.GetRules().size());
  98   const Rule* rule = state.bindings_.GetRules().begin()->second;
  99   EXPECT_EQ("cat", rule->name());
 100   Edge* edge = state.GetNode("result", 0)->in_edge();
 101   EXPECT_TRUE(edge->GetBindingBool("restat"));
 102   EXPECT_FALSE(edge->GetBindingBool("generator"));
 103 }
 104
 105 TEST_F(ParserTest, IgnoreIndentedBlankLines) {
 106   // the indented blanks used to cause parse errors
 107   ASSERT_NO_FATAL_FAILURE(AssertParse(
 108 "  \n"
 109 "rule cat\n"
 110 "  command = cat $in > $out\n"
 111 "  \n"
 112 "build result: cat in_1.cc in-2.O\n"
 113 "  \n"
 114 "variable=1\n"));
 115
 116   // the variable must be in the top level environment
 117   EXPECT_EQ("1", state.bindings_.LookupVariable("variable"));
 118 }
 119
 120 TEST_F(ParserTest, ResponseFiles) {
 121   ASSERT_NO_FATAL_FAILURE(AssertParse(
 122 "rule cat_rsp\n"
 123 "  command = cat $rspfile > $out\n"
 124 "  rspfile = $rspfile\n"
 125 "  rspfile_content = $in\n"
 126 "\n"
 127 "build out: cat_rsp in\n"
 128 "  rspfile=out.rsp\n"));
 129
 130   ASSERT_EQ(2u, state.bindings_.GetRules().size());
 131   const Rule* rule = state.bindings_.GetRules().begin()->second;
 132   EXPECT_EQ("cat_rsp", rule->name());
 133   EXPECT_EQ("[cat ][$rspfile][ > ][$out]",
 134             rule->GetBinding("command")->Serialize());
 135   EXPECT_EQ("[$rspfile]", rule->GetBinding("rspfile")->Serialize());
 136   EXPECT_EQ("[$in]", rule->GetBinding("rspfile_content")->Serialize());
 137 }
 138
 139 TEST_F(ParserTest, InNewline) {
 140   ASSERT_NO_FATAL_FAILURE(AssertParse(
 141 "rule cat_rsp\n"
 142 "  command = cat $in_newline > $out\n"
 143 "\n"
 144 "build out: cat_rsp in in2\n"
 145 "  rspfile=out.rsp\n"));
 146
 147   ASSERT_EQ(2u, state.bindings_.GetRules().size());
 148   const Rule* rule = state.bindings_.GetRules().begin()->second;
 149   EXPECT_EQ("cat_rsp", rule->name());
 150   EXPECT_EQ("[cat ][$in_newline][ > ][$out]",
 151             rule->GetBinding("command")->Serialize());
 152
 153   Edge* edge = state.edges_[0];
 154   EXPECT_EQ("cat in\nin2 > out", edge->EvaluateCommand());
 155 }
 156
 157 TEST_F(ParserTest, Variables) {
 158   ASSERT_NO_FATAL_FAILURE(AssertParse(
 159 "l = one-letter-test\n"
 160 "rule link\n"
 161 "  command = ld $l $extra $with_under -o $out $in\n"
 162 "\n"
 163 "extra = -pthread\n"
 164 "with_under = -under\n"
 165 "build a: link b c\n"
 166 "nested1 = 1\n"
 167 "nested2 = $nested1/2\n"
 168 "build supernested: link x\n"
 169 "  extra = $nested2/3\n"));
 170
 171   ASSERT_EQ(2u, state.edges_.size());
 172   Edge* edge = state.edges_[0];
 173   EXPECT_EQ("ld one-letter-test -pthread -under -o a b c",
 174             edge->EvaluateCommand());
 175   EXPECT_EQ("1/2", state.bindings_.LookupVariable("nested2"));
 176
 177   edge = state.edges_[1];
 178   EXPECT_EQ("ld one-letter-test 1/2/3 -under -o supernested x",
 179             edge->EvaluateCommand());
 180 }
 181
 182 TEST_F(ParserTest, VariableScope) {
 183   ASSERT_NO_FATAL_FAILURE(AssertParse(
 184 "foo = bar\n"
 185 "rule cmd\n"
 186 "  command = cmd $foo $in $out\n"
 187 "\n"
 188 "build inner: cmd a\n"
 189 "  foo = baz\n"
 190 "build outer: cmd b\n"
 191 "\n"  // Extra newline after build line tickles a regression.
 192 ));
 193
 194   ASSERT_EQ(2u, state.edges_.size());
 195   EXPECT_EQ("cmd baz a inner", state.edges_[0]->EvaluateCommand());
 196   EXPECT_EQ("cmd bar b outer", state.edges_[1]->EvaluateCommand());
 197 }
 198
 199 TEST_F(ParserTest, Continuation) {
 200   ASSERT_NO_FATAL_FAILURE(AssertParse(
 201 "rule link\n"
 202 "  command = foo bar $\n"
 203 "    baz\n"
 204 "\n"
 205 "build a: link c $\n"
 206 " d e f\n"));
 207
 208   ASSERT_EQ(2u, state.bindings_.GetRules().size());
 209   const Rule* rule = state.bindings_.GetRules().begin()->second;
 210   EXPECT_EQ("link", rule->name());
 211   EXPECT_EQ("[foo bar baz]", rule->GetBinding("command")->Serialize());
 212 }
 213
 214 TEST_F(ParserTest, Backslash) {
 215   ASSERT_NO_FATAL_FAILURE(AssertParse(
 216 "foo = bar\\baz\n"
 217 "foo2 = bar\\ baz\n"
 218 ));
 219   EXPECT_EQ("bar\\baz", state.bindings_.LookupVariable("foo"));
 220   EXPECT_EQ("bar\\ baz", state.bindings_.LookupVariable("foo2"));
 221 }
 222
 223 TEST_F(ParserTest, Comment) {
 224   ASSERT_NO_FATAL_FAILURE(AssertParse(
 225 "# this is a comment\n"
 226 "foo = not # a comment\n"));
 227   EXPECT_EQ("not # a comment", state.bindings_.LookupVariable("foo"));
 228 }
 229
 230 TEST_F(ParserTest, Dollars) {
 231   ASSERT_NO_FATAL_FAILURE(AssertParse(
 232 "rule foo\n"
 233 "  command = ${out}bar$$baz$$$\n"
 234 "blah\n"
 235 "x = $$dollar\n"
 236 "build $x: foo y\n"
 237 ));
 238   EXPECT_EQ("$dollar", state.bindings_.LookupVariable("x"));
 239 #ifdef _WIN32
 240   EXPECT_EQ("$dollarbar$baz$blah", state.edges_[0]->EvaluateCommand());
 241 #else
 242   EXPECT_EQ("'$dollar'bar$baz$blah", state.edges_[0]->EvaluateCommand());
 243 #endif
 244 }
 245
 246 TEST_F(ParserTest, EscapeSpaces) {
 247   ASSERT_NO_FATAL_FAILURE(AssertParse(
 248 "rule spaces\n"
 249 "  command = something\n"
 250 "build foo$ bar: spaces $$one two$$$ three\n"
 251 ));
 252   EXPECT_TRUE(state.LookupNode("foo bar"));
 253   EXPECT_EQ(state.edges_[0]->outputs_[0]->path(), "foo bar");
 254   EXPECT_EQ(state.edges_[0]->inputs_[0]->path(), "$one");
 255   EXPECT_EQ(state.edges_[0]->inputs_[1]->path(), "two$ three");
 256   EXPECT_EQ(state.edges_[0]->EvaluateCommand(), "something");
 257 }
 258
 259 TEST_F(ParserTest, CanonicalizeFile) {
 260   ASSERT_NO_FATAL_FAILURE(AssertParse(
 261 "rule cat\n"
 262 "  command = cat $in > $out\n"
 263 "build out: cat in/1 in//2\n"
 264 "build in/1: cat\n"
 265 "build in/2: cat\n"));
 266
 267   EXPECT_TRUE(state.LookupNode("in/1"));
 268   EXPECT_TRUE(state.LookupNode("in/2"));
 269   EXPECT_FALSE(state.LookupNode("in//1"));
 270   EXPECT_FALSE(state.LookupNode("in//2"));
 271 }
 272
 273 #ifdef _WIN32
 274 TEST_F(ParserTest, CanonicalizeFileBackslashes) {
 275   ASSERT_NO_FATAL_FAILURE(AssertParse(
 276 "rule cat\n"
 277 "  command = cat $in > $out\n"
 278 "build out: cat in\\1 in\\\\2\n"
 279 "build in\\1: cat\n"
 280 "build in\\2: cat\n"));
 281
 282   Node* node = state.LookupNode("in/1");;
 283   EXPECT_TRUE(node);
 284   EXPECT_EQ(1, node->slash_bits());
 285   node = state.LookupNode("in/2");
 286   EXPECT_TRUE(node);
 287   EXPECT_EQ(1, node->slash_bits());
 288   EXPECT_FALSE(state.LookupNode("in//1"));
 289   EXPECT_FALSE(state.LookupNode("in//2"));
 290 }
 291 #endif
 292
 293 TEST_F(ParserTest, PathVariables) {
 294   ASSERT_NO_FATAL_FAILURE(AssertParse(
 295 "rule cat\n"
 296 "  command = cat $in > $out\n"
 297 "dir = out\n"
 298 "build $dir/exe: cat src\n"));
 299
 300   EXPECT_FALSE(state.LookupNode("$dir/exe"));
 301   EXPECT_TRUE(state.LookupNode("out/exe"));
 302 }
 303
 304 TEST_F(ParserTest, CanonicalizePaths) {
 305   ASSERT_NO_FATAL_FAILURE(AssertParse(
 306 "rule cat\n"
 307 "  command = cat $in > $out\n"
 308 "build ./out.o: cat ./bar/baz/../foo.cc\n"));
 309
 310   EXPECT_FALSE(state.LookupNode("./out.o"));
 311   EXPECT_TRUE(state.LookupNode("out.o"));
 312   EXPECT_FALSE(state.LookupNode("./bar/baz/../foo.cc"));
 313   EXPECT_TRUE(state.LookupNode("bar/foo.cc"));
 314 }
 315
 316 #ifdef _WIN32
 317 TEST_F(ParserTest, CanonicalizePathsBackslashes) {
 318   ASSERT_NO_FATAL_FAILURE(AssertParse(
 319 "rule cat\n"
 320 "  command = cat $in > $out\n"
 321 "build ./out.o: cat ./bar/baz/../foo.cc\n"
 322 "build .\\out2.o: cat .\\bar/baz\\..\\foo.cc\n"
 323 "build .\\out3.o: cat .\\bar\\baz\\..\\foo3.cc\n"
 324 ));
 325
 326   EXPECT_FALSE(state.LookupNode("./out.o"));
 327   EXPECT_FALSE(state.LookupNode(".\\out2.o"));
 328   EXPECT_FALSE(state.LookupNode(".\\out3.o"));
 329   EXPECT_TRUE(state.LookupNode("out.o"));
 330   EXPECT_TRUE(state.LookupNode("out2.o"));
 331   EXPECT_TRUE(state.LookupNode("out3.o"));
 332   EXPECT_FALSE(state.LookupNode("./bar/baz/../foo.cc"));
 333   EXPECT_FALSE(state.LookupNode(".\\bar/baz\\..\\foo.cc"));
 334   EXPECT_FALSE(state.LookupNode(".\\bar/baz\\..\\foo3.cc"));
 335   Node* node = state.LookupNode("bar/foo.cc");
 336   EXPECT_TRUE(node);
 337   EXPECT_EQ(0, node->slash_bits());
 338   node = state.LookupNode("bar/foo3.cc");
 339   EXPECT_TRUE(node);
 340   EXPECT_EQ(1, node->slash_bits());
 341 }
 342 #endif
 343
 344 TEST_F(ParserTest, DuplicateEdgeWithMultipleOutputs) {
 345   ASSERT_NO_FATAL_FAILURE(AssertParse(
 346 "rule cat\n"
 347 "  command = cat $in > $out\n"
 348 "build out1 out2: cat in1\n"
 349 "build out1: cat in2\n"
 350 "build final: cat out1\n"
 351 ));
 352   // AssertParse() checks that the generated build graph is self-consistent.
 353   // That's all the checking that this test needs.
 354 }
 355
 356 TEST_F(ParserTest, NoDeadPointerFromDuplicateEdge) {
 357   ASSERT_NO_FATAL_FAILURE(AssertParse(
 358 "rule cat\n"
 359 "  command = cat $in > $out\n"
 360 "build out: cat in\n"
 361 "build out: cat in\n"
 362 ));
 363   // AssertParse() checks that the generated build graph is self-consistent.
 364   // That's all the checking that this test needs.
 365 }
 366
 367 TEST_F(ParserTest, DuplicateEdgeWithMultipleOutputsError) {
 368   const char kInput[] =
 369 "rule cat\n"
 370 "  command = cat $in > $out\n"
 371 "build out1 out2: cat in1\n"
 372 "build out1: cat in2\n"
 373 "build final: cat out1\n";
 374   ManifestParser parser(&state, this, kDupeEdgeActionError);
 375   string err;
 376   EXPECT_FALSE(parser.ParseTest(kInput, &err));
 377   EXPECT_EQ("input:5: multiple rules generate out1 [-w dupbuild=err]\n", err);
 378 }
 379
 380 TEST_F(ParserTest, DuplicateEdgeInIncludedFile) {
 381   files_["sub.ninja"] =
 382     "rule cat\n"
 383     "  command = cat $in > $out\n"
 384     "build out1 out2: cat in1\n"
 385     "build out1: cat in2\n"
 386     "build final: cat out1\n";
 387   const char kInput[] =
 388     "subninja sub.ninja\n";
 389   ManifestParser parser(&state, this, kDupeEdgeActionError);
 390   string err;
 391   EXPECT_FALSE(parser.ParseTest(kInput, &err));
 392   EXPECT_EQ("sub.ninja:5: multiple rules generate out1 [-w dupbuild=err]\n",
 393             err);
 394 }
 395
 396 TEST_F(ParserTest, ReservedWords) {
 397   ASSERT_NO_FATAL_FAILURE(AssertParse(
 398 "rule build\n"
 399 "  command = rule run $out\n"
 400 "build subninja: build include default foo.cc\n"
 401 "default subninja\n"));
 402 }
 403
 404 TEST_F(ParserTest, Errors) {
 405   {
 406     State state;
 407     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 408     string err;
 409     EXPECT_FALSE(parser.ParseTest(string("subn", 4), &err));
 410     EXPECT_EQ("input:1: expected '=', got eof\n"
 411               "subn\n"
 412               "    ^ near here"
 413               , err);
 414   }
 415
 416   {
 417     State state;
 418     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 419     string err;
 420     EXPECT_FALSE(parser.ParseTest("foobar", &err));
 421     EXPECT_EQ("input:1: expected '=', got eof\n"
 422               "foobar\n"
 423               "      ^ near here"
 424               , err);
 425   }
 426
 427   {
 428     State state;
 429     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 430     string err;
 431     EXPECT_FALSE(parser.ParseTest("x 3", &err));
 432     EXPECT_EQ("input:1: expected '=', got identifier\n"
 433               "x 3\n"
 434               "  ^ near here"
 435               , err);
 436   }
 437
 438   {
 439     State state;
 440     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 441     string err;
 442     EXPECT_FALSE(parser.ParseTest("x = 3", &err));
 443     EXPECT_EQ("input:1: unexpected EOF\n"
 444               "x = 3\n"
 445               "     ^ near here"
 446               , err);
 447   }
 448
 449   {
 450     State state;
 451     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 452     string err;
 453     EXPECT_FALSE(parser.ParseTest("x = 3\ny 2", &err));
 454     EXPECT_EQ("input:2: expected '=', got identifier\n"
 455               "y 2\n"
 456               "  ^ near here"
 457               , err);
 458   }
 459
 460   {
 461     State state;
 462     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 463     string err;
 464     EXPECT_FALSE(parser.ParseTest("x = $", &err));
 465     EXPECT_EQ("input:1: bad $-escape (literal $ must be written as $$)\n"
 466               "x = $\n"
 467               "    ^ near here"
 468               , err);
 469   }
 470
 471   {
 472     State state;
 473     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 474     string err;
 475     EXPECT_FALSE(parser.ParseTest("x = $\n $[\n", &err));
 476     EXPECT_EQ("input:2: bad $-escape (literal $ must be written as $$)\n"
 477               " $[\n"
 478               " ^ near here"
 479               , err);
 480   }
 481
 482   {
 483     State state;
 484     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 485     string err;
 486     EXPECT_FALSE(parser.ParseTest("x = a$\n b$\n $\n", &err));
 487     EXPECT_EQ("input:4: unexpected EOF\n"
 488               , err);
 489   }
 490
 491   {
 492     State state;
 493     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 494     string err;
 495     EXPECT_FALSE(parser.ParseTest("build\n", &err));
 496     EXPECT_EQ("input:1: expected path\n"
 497               "build\n"
 498               "     ^ near here"
 499               , err);
 500   }
 501
 502   {
 503     State state;
 504     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 505     string err;
 506     EXPECT_FALSE(parser.ParseTest("build x: y z\n", &err));
 507     EXPECT_EQ("input:1: unknown build rule 'y'\n"
 508               "build x: y z\n"
 509               "       ^ near here"
 510               , err);
 511   }
 512
 513   {
 514     State state;
 515     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 516     string err;
 517     EXPECT_FALSE(parser.ParseTest("build x:: y z\n", &err));
 518     EXPECT_EQ("input:1: expected build command name\n"
 519               "build x:: y z\n"
 520               "       ^ near here"
 521               , err);
 522   }
 523
 524   {
 525     State state;
 526     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 527     string err;
 528     EXPECT_FALSE(parser.ParseTest("rule cat\n  command = cat ok\n"
 529                                   "build x: cat $\n :\n",
 530                                   &err));
 531     EXPECT_EQ("input:4: expected newline, got ':'\n"
 532               " :\n"
 533               " ^ near here"
 534               , err);
 535   }
 536
 537   {
 538     State state;
 539     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 540     string err;
 541     EXPECT_FALSE(parser.ParseTest("rule cat\n",
 542                                   &err));
 543     EXPECT_EQ("input:2: expected 'command =' line\n", err);
 544   }
 545
 546   {
 547     State state;
 548     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 549     string err;
 550     EXPECT_FALSE(parser.ParseTest("rule cat\n"
 551                                   "  command = echo\n"
 552                                   "rule cat\n"
 553                                   "  command = echo\n", &err));
 554     EXPECT_EQ("input:3: duplicate rule 'cat'\n"
 555               "rule cat\n"
 556               "        ^ near here"
 557               , err);
 558   }
 559
 560   {
 561     State state;
 562     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 563     string err;
 564     EXPECT_FALSE(parser.ParseTest("rule cat\n"
 565                                   "  command = echo\n"
 566                                   "  rspfile = cat.rsp\n", &err));
 567     EXPECT_EQ(
 568         "input:4: rspfile and rspfile_content need to be both specified\n",
 569         err);
 570   }
 571
 572   {
 573     State state;
 574     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 575     string err;
 576     EXPECT_FALSE(parser.ParseTest("rule cat\n"
 577                                   "  command = ${fafsd\n"
 578                                   "foo = bar\n",
 579                                   &err));
 580     EXPECT_EQ("input:2: bad $-escape (literal $ must be written as $$)\n"
 581               "  command = ${fafsd\n"
 582               "            ^ near here"
 583               , err);
 584   }
 585
 586
 587   {
 588     State state;
 589     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 590     string err;
 591     EXPECT_FALSE(parser.ParseTest("rule cat\n"
 592                                   "  command = cat\n"
 593                                   "build $.: cat foo\n",
 594                                   &err));
 595     EXPECT_EQ("input:3: bad $-escape (literal $ must be written as $$)\n"
 596               "build $.: cat foo\n"
 597               "      ^ near here"
 598               , err);
 599   }
 600
 601
 602   {
 603     State state;
 604     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 605     string err;
 606     EXPECT_FALSE(parser.ParseTest("rule cat\n"
 607                                   "  command = cat\n"
 608                                   "build $: cat foo\n",
 609                                   &err));
 610     EXPECT_EQ("input:3: expected ':', got newline ($ also escapes ':')\n"
 611               "build $: cat foo\n"
 612               "                ^ near here"
 613               , err);
 614   }
 615
 616   {
 617     State state;
 618     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 619     string err;
 620     EXPECT_FALSE(parser.ParseTest("rule %foo\n",
 621                                   &err));
 622     EXPECT_EQ("input:1: expected rule name\n", err);
 623   }
 624
 625   {
 626     State state;
 627     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 628     string err;
 629     EXPECT_FALSE(parser.ParseTest("rule cc\n"
 630                                   "  command = foo\n"
 631                                   "  othervar = bar\n",
 632                                   &err));
 633     EXPECT_EQ("input:3: unexpected variable 'othervar'\n"
 634               "  othervar = bar\n"
 635               "                ^ near here"
 636               , err);
 637   }
 638
 639   {
 640     State state;
 641     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 642     string err;
 643     EXPECT_FALSE(parser.ParseTest("rule cc\n  command = foo\n"
 644                                   "build $.: cc bar.cc\n",
 645                                   &err));
 646     EXPECT_EQ("input:3: bad $-escape (literal $ must be written as $$)\n"
 647               "build $.: cc bar.cc\n"
 648               "      ^ near here"
 649               , err);
 650   }
 651
 652   {
 653     State state;
 654     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 655     string err;
 656     EXPECT_FALSE(parser.ParseTest("rule cc\n  command = foo\n  && bar",
 657                                   &err));
 658     EXPECT_EQ("input:3: expected variable name\n", err);
 659   }
 660
 661   {
 662     State state;
 663     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 664     string err;
 665     EXPECT_FALSE(parser.ParseTest("rule cc\n  command = foo\n"
 666                                   "build $: cc bar.cc\n",
 667                                   &err));
 668     EXPECT_EQ("input:3: expected ':', got newline ($ also escapes ':')\n"
 669               "build $: cc bar.cc\n"
 670               "                  ^ near here"
 671               , err);
 672   }
 673
 674   {
 675     State state;
 676     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 677     string err;
 678     EXPECT_FALSE(parser.ParseTest("default\n",
 679                                   &err));
 680     EXPECT_EQ("input:1: expected target name\n"
 681               "default\n"
 682               "       ^ near here"
 683               , err);
 684   }
 685
 686   {
 687     State state;
 688     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 689     string err;
 690     EXPECT_FALSE(parser.ParseTest("default nonexistent\n",
 691                                   &err));
 692     EXPECT_EQ("input:1: unknown target 'nonexistent'\n"
 693               "default nonexistent\n"
 694               "                   ^ near here"
 695               , err);
 696   }
 697
 698   {
 699     State state;
 700     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 701     string err;
 702     EXPECT_FALSE(parser.ParseTest("rule r\n  command = r\n"
 703                                   "build b: r\n"
 704                                   "default b:\n",
 705                                   &err));
 706     EXPECT_EQ("input:4: expected newline, got ':'\n"
 707               "default b:\n"
 708               "         ^ near here"
 709               , err);
 710   }
 711
 712   {
 713     State state;
 714     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 715     string err;
 716     EXPECT_FALSE(parser.ParseTest("default $a\n", &err));
 717     EXPECT_EQ("input:1: empty path\n"
 718               "default $a\n"
 719               "          ^ near here"
 720               , err);
 721   }
 722
 723   {
 724     State state;
 725     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 726     string err;
 727     EXPECT_FALSE(parser.ParseTest("rule r\n"
 728                                   "  command = r\n"
 729                                   "build $a: r $c\n", &err));
 730     // XXX the line number is wrong; we should evaluate paths in ParseEdge
 731     // as we see them, not after we've read them all!
 732     EXPECT_EQ("input:4: empty path\n", err);
 733   }
 734
 735   {
 736     State state;
 737     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 738     string err;
 739     // the indented blank line must terminate the rule
 740     // this also verifies that "unexpected (token)" errors are correct
 741     EXPECT_FALSE(parser.ParseTest("rule r\n"
 742                                   "  command = r\n"
 743                                   "  \n"
 744                                   "  generator = 1\n", &err));
 745     EXPECT_EQ("input:4: unexpected indent\n", err);
 746   }
 747
 748   {
 749     State state;
 750     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 751     string err;
 752     EXPECT_FALSE(parser.ParseTest("pool\n", &err));
 753     EXPECT_EQ("input:1: expected pool name\n", err);
 754   }
 755
 756   {
 757     State state;
 758     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 759     string err;
 760     EXPECT_FALSE(parser.ParseTest("pool foo\n", &err));
 761     EXPECT_EQ("input:2: expected 'depth =' line\n", err);
 762   }
 763
 764   {
 765     State state;
 766     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 767     string err;
 768     EXPECT_FALSE(parser.ParseTest("pool foo\n"
 769                                   "  depth = 4\n"
 770                                   "pool foo\n", &err));
 771     EXPECT_EQ("input:3: duplicate pool 'foo'\n"
 772               "pool foo\n"
 773               "        ^ near here"
 774               , err);
 775   }
 776
 777   {
 778     State state;
 779     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 780     string err;
 781     EXPECT_FALSE(parser.ParseTest("pool foo\n"
 782                                   "  depth = -1\n", &err));
 783     EXPECT_EQ("input:2: invalid pool depth\n"
 784               "  depth = -1\n"
 785               "            ^ near here"
 786               , err);
 787   }
 788
 789   {
 790     State state;
 791     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 792     string err;
 793     EXPECT_FALSE(parser.ParseTest("pool foo\n"
 794                                   "  bar = 1\n", &err));
 795     EXPECT_EQ("input:2: unexpected variable 'bar'\n"
 796               "  bar = 1\n"
 797               "         ^ near here"
 798               , err);
 799   }
 800
 801   {
 802     State state;
 803     ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 804     string err;
 805     // Pool names are dereferenced at edge parsing time.
 806     EXPECT_FALSE(parser.ParseTest("rule run\n"
 807                                   "  command = echo\n"
 808                                   "  pool = unnamed_pool\n"
 809                                   "build out: run in\n", &err));
 810     EXPECT_EQ("input:5: unknown pool name 'unnamed_pool'\n", err);
 811   }
 812 }
 813
 814 TEST_F(ParserTest, MissingInput) {
 815   State state;
 816   ManifestParser parser(&state, this, kDupeEdgeActionWarn);
 817   string err;
 818   EXPECT_FALSE(parser.Load("build.ninja", &err));
 819   EXPECT_EQ("loading 'build.ninja': No such file or directory", err);
 820 }
 821
 822 TEST_F(ParserTest, MultipleOutputs) {
 823   State state;
 824   ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 825   string err;
 826   EXPECT_TRUE(parser.ParseTest("rule cc\n  command = foo\n  depfile = bar\n"
 827                                "build a.o b.o: cc c.cc\n",
 828                                &err));
 829   EXPECT_EQ("", err);
 830 }
 831
 832 TEST_F(ParserTest, MultipleOutputsWithDeps) {
 833   State state;
 834   ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 835   string err;
 836   EXPECT_FALSE(parser.ParseTest("rule cc\n  command = foo\n  deps = gcc\n"
 837                                "build a.o b.o: cc c.cc\n",
 838                                &err));
 839   EXPECT_EQ("input:5: multiple outputs aren't (yet?) supported by depslog; "
 840             "bring this up on the mailing list if it affects you\n", err);
 841 }
 842
 843 TEST_F(ParserTest, SubNinja) {
 844   files_["test.ninja"] =
 845     "var = inner\n"
 846     "build $builddir/inner: varref\n";
 847   ASSERT_NO_FATAL_FAILURE(AssertParse(
 848 "builddir = some_dir/\n"
 849 "rule varref\n"
 850 "  command = varref $var\n"
 851 "var = outer\n"
 852 "build $builddir/outer: varref\n"
 853 "subninja test.ninja\n"
 854 "build $builddir/outer2: varref\n"));
 855   ASSERT_EQ(1u, files_read_.size());
 856
 857   EXPECT_EQ("test.ninja", files_read_[0]);
 858   EXPECT_TRUE(state.LookupNode("some_dir/outer"));
 859   // Verify our builddir setting is inherited.
 860   EXPECT_TRUE(state.LookupNode("some_dir/inner"));
 861
 862   ASSERT_EQ(3u, state.edges_.size());
 863   EXPECT_EQ("varref outer", state.edges_[0]->EvaluateCommand());
 864   EXPECT_EQ("varref inner", state.edges_[1]->EvaluateCommand());
 865   EXPECT_EQ("varref outer", state.edges_[2]->EvaluateCommand());
 866 }
 867
 868 TEST_F(ParserTest, MissingSubNinja) {
 869   ManifestParser parser(&state, this, kDupeEdgeActionWarn);
 870   string err;
 871   EXPECT_FALSE(parser.ParseTest("subninja foo.ninja\n", &err));
 872   EXPECT_EQ("input:1: loading 'foo.ninja': No such file or directory\n"
 873             "subninja foo.ninja\n"
 874             "                  ^ near here"
 875             , err);
 876 }
 877
 878 TEST_F(ParserTest, DuplicateRuleInDifferentSubninjas) {
 879   // Test that rules are scoped to subninjas.
 880   files_["test.ninja"] = "rule cat\n"
 881                          "  command = cat\n";
 882   ManifestParser parser(&state, this, kDupeEdgeActionWarn);
 883   string err;
 884   EXPECT_TRUE(parser.ParseTest("rule cat\n"
 885                                 "  command = cat\n"
 886                                 "subninja test.ninja\n", &err));
 887 }
 888
 889 TEST_F(ParserTest, DuplicateRuleInDifferentSubninjasWithInclude) {
 890   // Test that rules are scoped to subninjas even with includes.
 891   files_["rules.ninja"] = "rule cat\n"
 892                          "  command = cat\n";
 893   files_["test.ninja"] = "include rules.ninja\n"
 894                          "build x : cat\n";
 895   ManifestParser parser(&state, this, kDupeEdgeActionWarn);
 896   string err;
 897   EXPECT_TRUE(parser.ParseTest("include rules.ninja\n"
 898                                 "subninja test.ninja\n"
 899                                 "build y : cat\n", &err));
 900 }
 901
 902 TEST_F(ParserTest, Include) {
 903   files_["include.ninja"] = "var = inner\n";
 904   ASSERT_NO_FATAL_FAILURE(AssertParse(
 905 "var = outer\n"
 906 "include include.ninja\n"));
 907
 908   ASSERT_EQ(1u, files_read_.size());
 909   EXPECT_EQ("include.ninja", files_read_[0]);
 910   EXPECT_EQ("inner", state.bindings_.LookupVariable("var"));
 911 }
 912
 913 TEST_F(ParserTest, BrokenInclude) {
 914   files_["include.ninja"] = "build\n";
 915   ManifestParser parser(&state, this, kDupeEdgeActionWarn);
 916   string err;
 917   EXPECT_FALSE(parser.ParseTest("include include.ninja\n", &err));
 918   EXPECT_EQ("include.ninja:1: expected path\n"
 919             "build\n"
 920             "     ^ near here"
 921             , err);
 922 }
 923
 924 TEST_F(ParserTest, Implicit) {
 925   ASSERT_NO_FATAL_FAILURE(AssertParse(
 926 "rule cat\n"
 927 "  command = cat $in > $out\n"
 928 "build foo: cat bar | baz\n"));
 929
 930   Edge* edge = state.LookupNode("foo")->in_edge();
 931   ASSERT_TRUE(edge->is_implicit(1));
 932 }
 933
 934 TEST_F(ParserTest, OrderOnly) {
 935   ASSERT_NO_FATAL_FAILURE(AssertParse(
 936 "rule cat\n  command = cat $in > $out\n"
 937 "build foo: cat bar || baz\n"));
 938
 939   Edge* edge = state.LookupNode("foo")->in_edge();
 940   ASSERT_TRUE(edge->is_order_only(1));
 941 }
 942
 943 TEST_F(ParserTest, ImplicitOutput) {
 944   ASSERT_NO_FATAL_FAILURE(AssertParse(
 945 "rule cat\n"
 946 "  command = cat $in > $out\n"
 947 "build foo | imp: cat bar\n"));
 948
 949   Edge* edge = state.LookupNode("imp")->in_edge();
 950   ASSERT_EQ(edge->outputs_.size(), 2);
 951   EXPECT_TRUE(edge->is_implicit_out(1));
 952 }
 953
 954 TEST_F(ParserTest, ImplicitOutputEmpty) {
 955   ASSERT_NO_FATAL_FAILURE(AssertParse(
 956 "rule cat\n"
 957 "  command = cat $in > $out\n"
 958 "build foo | : cat bar\n"));
 959
 960   Edge* edge = state.LookupNode("foo")->in_edge();
 961   ASSERT_EQ(edge->outputs_.size(), 1);
 962   EXPECT_FALSE(edge->is_implicit_out(0));
 963 }
 964
 965 TEST_F(ParserTest, NoExplicitOutput) {
 966   ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
 967   string err;
 968   EXPECT_FALSE(parser.ParseTest(
 969 "rule cat\n"
 970 "  command = cat $in > $out\n"
 971 "build | imp : cat bar\n", &err));
 972   ASSERT_EQ("input:3: expected path\n"
 973             "build | imp : cat bar\n"
 974             "      ^ near here", err);
 975 }
 976
 977 TEST_F(ParserTest, DefaultDefault) {
 978   ASSERT_NO_FATAL_FAILURE(AssertParse(
 979 "rule cat\n  command = cat $in > $out\n"
 980 "build a: cat foo\n"
 981 "build b: cat foo\n"
 982 "build c: cat foo\n"
 983 "build d: cat foo\n"));
 984
 985   string err;
 986   EXPECT_EQ(4u, state.DefaultNodes(&err).size());
 987   EXPECT_EQ("", err);
 988 }
 989
 990 TEST_F(ParserTest, DefaultDefaultCycle) {
 991   ASSERT_NO_FATAL_FAILURE(AssertParse(
 992 "rule cat\n  command = cat $in > $out\n"
 993 "build a: cat a\n"));
 994
 995   string err;
 996   EXPECT_EQ(0u, state.DefaultNodes(&err).size());
 997   EXPECT_EQ("could not determine root nodes of build graph", err);
 998 }
 999
1000 TEST_F(ParserTest, DefaultStatements) {
1001   ASSERT_NO_FATAL_FAILURE(AssertParse(
1002 "rule cat\n  command = cat $in > $out\n"
1003 "build a: cat foo\n"
1004 "build b: cat foo\n"
1005 "build c: cat foo\n"
1006 "build d: cat foo\n"
1007 "third = c\n"
1008 "default a b\n"
1009 "default $third\n"));
1010
1011   string err;
1012   vector<Node*> nodes = state.DefaultNodes(&err);
1013   EXPECT_EQ("", err);
1014   ASSERT_EQ(3u, nodes.size());
1015   EXPECT_EQ("a", nodes[0]->path());
1016   EXPECT_EQ("b", nodes[1]->path());
1017   EXPECT_EQ("c", nodes[2]->path());
1018 }
1019
1020 TEST_F(ParserTest, UTF8) {
1021   ASSERT_NO_FATAL_FAILURE(AssertParse(
1022 "rule utf8\n"
1023 "  command = true\n"
1024 "  description = compilaci\xC3\xB3\n"));
1025 }
1026
1027 TEST_F(ParserTest, CRLF) {
1028   State state;
1029   ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
1030   string err;
1031
1032   EXPECT_TRUE(parser.ParseTest("# comment with crlf\r\n", &err));
1033   EXPECT_TRUE(parser.ParseTest("foo = foo\nbar = bar\r\n", &err));
1034   EXPECT_TRUE(parser.ParseTest(
1035       "pool link_pool\r\n"
1036       "  depth = 15\r\n\r\n"
1037       "rule xyz\r\n"
1038       "  command = something$expand \r\n"
1039       "  description = YAY!\r\n",
1040       &err));
1041 }