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