src/build_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 "build.h"
  16
  17 #include "build_log.h"
  18 #include "graph.h"
  19 #include "test.h"
  20
  21 /// Fixture for tests involving Plan.
  22 // Though Plan doesn't use State, it's useful to have one around
  23 // to create Nodes and Edges.
  24 struct PlanTest : public StateTestWithBuiltinRules {
  25   Plan plan_;
  26 };
  27
  28 TEST_F(PlanTest, Basic) {
  29   AssertParse(&state_,
  30 "build out: cat mid\n"
  31 "build mid: cat in\n");
  32   GetNode("mid")->MarkDirty();
  33   GetNode("out")->MarkDirty();
  34   string err;
  35   EXPECT_TRUE(plan_.AddTarget(GetNode("out"), &err));
  36   ASSERT_EQ("", err);
  37   ASSERT_TRUE(plan_.more_to_do());
  38
  39   Edge* edge = plan_.FindWork();
  40   ASSERT_TRUE(edge);
  41   ASSERT_EQ("in",  edge->inputs_[0]->path());
  42   ASSERT_EQ("mid", edge->outputs_[0]->path());
  43
  44   ASSERT_FALSE(plan_.FindWork());
  45
  46   plan_.EdgeFinished(edge);
  47
  48   edge = plan_.FindWork();
  49   ASSERT_TRUE(edge);
  50   ASSERT_EQ("mid", edge->inputs_[0]->path());
  51   ASSERT_EQ("out", edge->outputs_[0]->path());
  52
  53   plan_.EdgeFinished(edge);
  54
  55   ASSERT_FALSE(plan_.more_to_do());
  56   edge = plan_.FindWork();
  57   ASSERT_EQ(0, edge);
  58 }
  59
  60 // Test that two outputs from one rule can be handled as inputs to the next.
  61 TEST_F(PlanTest, DoubleOutputDirect) {
  62   AssertParse(&state_,
  63 "build out: cat mid1 mid2\n"
  64 "build mid1 mid2: cat in\n");
  65   GetNode("mid1")->MarkDirty();
  66   GetNode("mid2")->MarkDirty();
  67   GetNode("out")->MarkDirty();
  68
  69   string err;
  70   EXPECT_TRUE(plan_.AddTarget(GetNode("out"), &err));
  71   ASSERT_EQ("", err);
  72   ASSERT_TRUE(plan_.more_to_do());
  73
  74   Edge* edge;
  75   edge = plan_.FindWork();
  76   ASSERT_TRUE(edge);  // cat in
  77   plan_.EdgeFinished(edge);
  78
  79   edge = plan_.FindWork();
  80   ASSERT_TRUE(edge);  // cat mid1 mid2
  81   plan_.EdgeFinished(edge);
  82
  83   edge = plan_.FindWork();
  84   ASSERT_FALSE(edge);  // done
  85 }
  86
  87 // Test that two outputs from one rule can eventually be routed to another.
  88 TEST_F(PlanTest, DoubleOutputIndirect) {
  89   AssertParse(&state_,
  90 "build out: cat b1 b2\n"
  91 "build b1: cat a1\n"
  92 "build b2: cat a2\n"
  93 "build a1 a2: cat in\n");
  94   GetNode("a1")->MarkDirty();
  95   GetNode("a2")->MarkDirty();
  96   GetNode("b1")->MarkDirty();
  97   GetNode("b2")->MarkDirty();
  98   GetNode("out")->MarkDirty();
  99   string err;
 100   EXPECT_TRUE(plan_.AddTarget(GetNode("out"), &err));
 101   ASSERT_EQ("", err);
 102   ASSERT_TRUE(plan_.more_to_do());
 103
 104   Edge* edge;
 105   edge = plan_.FindWork();
 106   ASSERT_TRUE(edge);  // cat in
 107   plan_.EdgeFinished(edge);
 108
 109   edge = plan_.FindWork();
 110   ASSERT_TRUE(edge);  // cat a1
 111   plan_.EdgeFinished(edge);
 112
 113   edge = plan_.FindWork();
 114   ASSERT_TRUE(edge);  // cat a2
 115   plan_.EdgeFinished(edge);
 116
 117   edge = plan_.FindWork();
 118   ASSERT_TRUE(edge);  // cat b1 b2
 119   plan_.EdgeFinished(edge);
 120
 121   edge = plan_.FindWork();
 122   ASSERT_FALSE(edge);  // done
 123 }
 124
 125 // Test that two edges from one output can both execute.
 126 TEST_F(PlanTest, DoubleDependent) {
 127   AssertParse(&state_,
 128 "build out: cat a1 a2\n"
 129 "build a1: cat mid\n"
 130 "build a2: cat mid\n"
 131 "build mid: cat in\n");
 132   GetNode("mid")->MarkDirty();
 133   GetNode("a1")->MarkDirty();
 134   GetNode("a2")->MarkDirty();
 135   GetNode("out")->MarkDirty();
 136
 137   string err;
 138   EXPECT_TRUE(plan_.AddTarget(GetNode("out"), &err));
 139   ASSERT_EQ("", err);
 140   ASSERT_TRUE(plan_.more_to_do());
 141
 142   Edge* edge;
 143   edge = plan_.FindWork();
 144   ASSERT_TRUE(edge);  // cat in
 145   plan_.EdgeFinished(edge);
 146
 147   edge = plan_.FindWork();
 148   ASSERT_TRUE(edge);  // cat mid
 149   plan_.EdgeFinished(edge);
 150
 151   edge = plan_.FindWork();
 152   ASSERT_TRUE(edge);  // cat mid
 153   plan_.EdgeFinished(edge);
 154
 155   edge = plan_.FindWork();
 156   ASSERT_TRUE(edge);  // cat a1 a2
 157   plan_.EdgeFinished(edge);
 158
 159   edge = plan_.FindWork();
 160   ASSERT_FALSE(edge);  // done
 161 }
 162
 163 TEST_F(PlanTest, DependencyCycle) {
 164   AssertParse(&state_,
 165 "build out: cat mid\n"
 166 "build mid: cat in\n"
 167 "build in: cat pre\n"
 168 "build pre: cat out\n");
 169   GetNode("out")->MarkDirty();
 170   GetNode("mid")->MarkDirty();
 171   GetNode("in")->MarkDirty();
 172   GetNode("pre")->MarkDirty();
 173
 174   string err;
 175   EXPECT_FALSE(plan_.AddTarget(GetNode("out"), &err));
 176   ASSERT_EQ("dependency cycle: out -> mid -> in -> pre -> out", err);
 177 }
 178
 179 TEST_F(PlanTest, PoolWithDepthOne) {
 180   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 181 "pool foobar\n"
 182 "  depth = 1\n"
 183 "rule poolcat\n"
 184 "  command = cat $in > $out\n"
 185 "  pool = foobar\n"
 186 "build out1: poolcat in\n"
 187 "build out2: poolcat in\n"));
 188   GetNode("out1")->MarkDirty();
 189   GetNode("out2")->MarkDirty();
 190   string err;
 191   EXPECT_TRUE(plan_.AddTarget(GetNode("out1"), &err));
 192   ASSERT_EQ("", err);
 193   EXPECT_TRUE(plan_.AddTarget(GetNode("out2"), &err));
 194   ASSERT_EQ("", err);
 195   ASSERT_TRUE(plan_.more_to_do());
 196
 197   Edge* edge = plan_.FindWork();
 198   ASSERT_TRUE(edge);
 199   ASSERT_EQ("in",  edge->inputs_[0]->path());
 200   ASSERT_EQ("out1", edge->outputs_[0]->path());
 201
 202   // This will be false since poolcat is serialized
 203   ASSERT_FALSE(plan_.FindWork());
 204
 205   plan_.EdgeFinished(edge);
 206
 207   edge = plan_.FindWork();
 208   ASSERT_TRUE(edge);
 209   ASSERT_EQ("in", edge->inputs_[0]->path());
 210   ASSERT_EQ("out2", edge->outputs_[0]->path());
 211
 212   ASSERT_FALSE(plan_.FindWork());
 213
 214   plan_.EdgeFinished(edge);
 215
 216   ASSERT_FALSE(plan_.more_to_do());
 217   edge = plan_.FindWork();
 218   ASSERT_EQ(0, edge);
 219 }
 220
 221 TEST_F(PlanTest, PoolsWithDepthTwo) {
 222   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 223 "pool foobar\n"
 224 "  depth = 2\n"
 225 "pool bazbin\n"
 226 "  depth = 2\n"
 227 "rule foocat\n"
 228 "  command = cat $in > $out\n"
 229 "  pool = foobar\n"
 230 "rule bazcat\n"
 231 "  command = cat $in > $out\n"
 232 "  pool = bazbin\n"
 233 "build out1: foocat in\n"
 234 "build out2: foocat in\n"
 235 "build out3: foocat in\n"
 236 "build outb1: bazcat in\n"
 237 "build outb2: bazcat in\n"
 238 "build outb3: bazcat in\n"
 239 "  pool =\n"
 240 "build allTheThings: cat out1 out2 out3 outb1 outb2 outb3\n"
 241 ));
 242   // Mark all the out* nodes dirty
 243   for (int i = 0; i < 3; ++i) {
 244     GetNode("out" + string(1, '1' + i))->MarkDirty();
 245     GetNode("outb" + string(1, '1' + i))->MarkDirty();
 246   }
 247   GetNode("allTheThings")->MarkDirty();
 248
 249   string err;
 250   EXPECT_TRUE(plan_.AddTarget(GetNode("allTheThings"), &err));
 251   ASSERT_EQ("", err);
 252
 253   // Grab the first 4 edges, out1 out2 outb1 outb2
 254   deque<Edge*> edges;
 255   for (int i = 0; i < 4; ++i) {
 256     ASSERT_TRUE(plan_.more_to_do());
 257     Edge* edge = plan_.FindWork();
 258     ASSERT_TRUE(edge);
 259     ASSERT_EQ("in",  edge->inputs_[0]->path());
 260     string base_name(i < 2 ? "out" : "outb");
 261     ASSERT_EQ(base_name + string(1, '1' + (i % 2)), edge->outputs_[0]->path());
 262     edges.push_back(edge);
 263   }
 264
 265   // outb3 is exempt because it has an empty pool
 266   ASSERT_TRUE(plan_.more_to_do());
 267   Edge* edge = plan_.FindWork();
 268   ASSERT_TRUE(edge);
 269   ASSERT_EQ("in",  edge->inputs_[0]->path());
 270   ASSERT_EQ("outb3", edge->outputs_[0]->path());
 271   edges.push_back(edge);
 272
 273   ASSERT_FALSE(plan_.FindWork());
 274
 275   // finish out1
 276   plan_.EdgeFinished(edges.front());
 277   edges.pop_front();
 278
 279   // out3 should be available
 280   Edge* out3 = plan_.FindWork();
 281   ASSERT_TRUE(out3);
 282   ASSERT_EQ("in",  out3->inputs_[0]->path());
 283   ASSERT_EQ("out3", out3->outputs_[0]->path());
 284
 285   ASSERT_FALSE(plan_.FindWork());
 286
 287   plan_.EdgeFinished(out3);
 288
 289   ASSERT_FALSE(plan_.FindWork());
 290
 291   for (deque<Edge*>::iterator it = edges.begin(); it != edges.end(); ++it) {
 292     plan_.EdgeFinished(*it);
 293   }
 294
 295   Edge* final = plan_.FindWork();
 296   ASSERT_TRUE(final);
 297   ASSERT_EQ("allTheThings", final->outputs_[0]->path());
 298
 299   plan_.EdgeFinished(final);
 300
 301   ASSERT_FALSE(plan_.more_to_do());
 302   ASSERT_FALSE(plan_.FindWork());
 303 }
 304
 305 TEST_F(PlanTest, PoolWithRedundantEdges) {
 306   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 307     "pool compile\n"
 308     "  depth = 1\n"
 309     "rule gen_foo\n"
 310     "  command = touch foo.cpp\n"
 311     "rule gen_bar\n"
 312     "  command = touch bar.cpp\n"
 313     "rule echo\n"
 314     "  command = echo $out > $out\n"
 315     "build foo.cpp.obj: echo foo.cpp || foo.cpp\n"
 316     "  pool = compile\n"
 317     "build bar.cpp.obj: echo bar.cpp || bar.cpp\n"
 318     "  pool = compile\n"
 319     "build libfoo.a: echo foo.cpp.obj bar.cpp.obj\n"
 320     "build foo.cpp: gen_foo\n"
 321     "build bar.cpp: gen_bar\n"
 322     "build all: phony libfoo.a\n"));
 323   GetNode("foo.cpp")->MarkDirty();
 324   GetNode("foo.cpp.obj")->MarkDirty();
 325   GetNode("bar.cpp")->MarkDirty();
 326   GetNode("bar.cpp.obj")->MarkDirty();
 327   GetNode("libfoo.a")->MarkDirty();
 328   GetNode("all")->MarkDirty();
 329   string err;
 330   EXPECT_TRUE(plan_.AddTarget(GetNode("all"), &err));
 331   ASSERT_EQ("", err);
 332   ASSERT_TRUE(plan_.more_to_do());
 333
 334   Edge* edge = NULL;
 335
 336   edge = plan_.FindWork();
 337   ASSERT_TRUE(edge);
 338   ASSERT_EQ("foo.cpp", edge->outputs_[0]->path());
 339   plan_.EdgeFinished(edge);
 340
 341   edge = plan_.FindWork();
 342   ASSERT_TRUE(edge);
 343   ASSERT_EQ("foo.cpp", edge->inputs_[0]->path());
 344   ASSERT_EQ("foo.cpp", edge->inputs_[1]->path());
 345   ASSERT_EQ("foo.cpp.obj", edge->outputs_[0]->path());
 346   plan_.EdgeFinished(edge);
 347
 348   edge = plan_.FindWork();
 349   ASSERT_TRUE(edge);
 350   ASSERT_EQ("bar.cpp", edge->outputs_[0]->path());
 351   plan_.EdgeFinished(edge);
 352
 353   edge = plan_.FindWork();
 354   ASSERT_TRUE(edge);
 355   ASSERT_EQ("bar.cpp", edge->inputs_[0]->path());
 356   ASSERT_EQ("bar.cpp", edge->inputs_[1]->path());
 357   ASSERT_EQ("bar.cpp.obj", edge->outputs_[0]->path());
 358   plan_.EdgeFinished(edge);
 359
 360   edge = plan_.FindWork();
 361   ASSERT_TRUE(edge);
 362   ASSERT_EQ("foo.cpp.obj", edge->inputs_[0]->path());
 363   ASSERT_EQ("bar.cpp.obj", edge->inputs_[1]->path());
 364   ASSERT_EQ("libfoo.a", edge->outputs_[0]->path());
 365   plan_.EdgeFinished(edge);
 366
 367   edge = plan_.FindWork();
 368   ASSERT_TRUE(edge);
 369   ASSERT_EQ("libfoo.a", edge->inputs_[0]->path());
 370   ASSERT_EQ("all", edge->outputs_[0]->path());
 371   plan_.EdgeFinished(edge);
 372
 373   edge = plan_.FindWork();
 374   ASSERT_FALSE(edge);
 375   ASSERT_FALSE(plan_.more_to_do());
 376 }
 377
 378 /// Fake implementation of CommandRunner, useful for tests.
 379 struct FakeCommandRunner : public CommandRunner {
 380   explicit FakeCommandRunner(VirtualFileSystem* fs) :
 381       last_command_(NULL), fs_(fs) {}
 382
 383   // CommandRunner impl
 384   virtual bool CanRunMore();
 385   virtual bool StartCommand(Edge* edge);
 386   virtual bool WaitForCommand(Result* result);
 387   virtual vector<Edge*> GetActiveEdges();
 388   virtual void Abort();
 389
 390   vector<string> commands_ran_;
 391   Edge* last_command_;
 392   VirtualFileSystem* fs_;
 393 };
 394
 395 struct BuildTest : public StateTestWithBuiltinRules {
 396   BuildTest() : config_(MakeConfig()), command_runner_(&fs_),
 397                 builder_(&state_, config_, NULL, NULL, &fs_),
 398                 status_(config_) {
 399     builder_.command_runner_.reset(&command_runner_);
 400     AssertParse(&state_,
 401 "build cat1: cat in1\n"
 402 "build cat2: cat in1 in2\n"
 403 "build cat12: cat cat1 cat2\n");
 404
 405     fs_.Create("in1", "");
 406     fs_.Create("in2", "");
 407   }
 408
 409   ~BuildTest() {
 410     builder_.command_runner_.release();
 411   }
 412
 413   // Mark a path dirty.
 414   void Dirty(const string& path);
 415
 416   BuildConfig MakeConfig() {
 417     BuildConfig config;
 418     config.verbosity = BuildConfig::QUIET;
 419     return config;
 420   }
 421
 422   BuildConfig config_;
 423   FakeCommandRunner command_runner_;
 424   VirtualFileSystem fs_;
 425   Builder builder_;
 426
 427   BuildStatus status_;
 428 };
 429
 430 bool FakeCommandRunner::CanRunMore() {
 431   // Only run one at a time.
 432   return last_command_ == NULL;
 433 }
 434
 435 bool FakeCommandRunner::StartCommand(Edge* edge) {
 436   assert(!last_command_);
 437   commands_ran_.push_back(edge->EvaluateCommand());
 438   if (edge->rule().name() == "cat"  ||
 439       edge->rule().name() == "cat_rsp" ||
 440       edge->rule().name() == "cc" ||
 441       edge->rule().name() == "touch" ||
 442       edge->rule().name() == "touch-interrupt") {
 443     for (vector<Node*>::iterator out = edge->outputs_.begin();
 444          out != edge->outputs_.end(); ++out) {
 445       fs_->Create((*out)->path(), "");
 446     }
 447   } else if (edge->rule().name() == "true" ||
 448              edge->rule().name() == "fail" ||
 449              edge->rule().name() == "interrupt") {
 450     // Don't do anything.
 451   } else {
 452     printf("unknown command\n");
 453     return false;
 454   }
 455
 456   last_command_ = edge;
 457   return true;
 458 }
 459
 460 bool FakeCommandRunner::WaitForCommand(Result* result) {
 461   if (!last_command_)
 462     return false;
 463
 464   Edge* edge = last_command_;
 465   result->edge = edge;
 466
 467   if (edge->rule().name() == "interrupt" ||
 468       edge->rule().name() == "touch-interrupt") {
 469     result->status = ExitInterrupted;
 470     return true;
 471   }
 472
 473   if (edge->rule().name() == "fail")
 474     result->status = ExitFailure;
 475   else
 476     result->status = ExitSuccess;
 477   last_command_ = NULL;
 478   return true;
 479 }
 480
 481 vector<Edge*> FakeCommandRunner::GetActiveEdges() {
 482   vector<Edge*> edges;
 483   if (last_command_)
 484     edges.push_back(last_command_);
 485   return edges;
 486 }
 487
 488 void FakeCommandRunner::Abort() {
 489   last_command_ = NULL;
 490 }
 491
 492 void BuildTest::Dirty(const string& path) {
 493   Node* node = GetNode(path);
 494   node->MarkDirty();
 495
 496   // If it's an input file, mark that we've already stat()ed it and
 497   // it's missing.
 498   if (!node->in_edge())
 499     node->MarkMissing();
 500 }
 501
 502 TEST_F(BuildTest, NoWork) {
 503   string err;
 504   EXPECT_TRUE(builder_.AlreadyUpToDate());
 505 }
 506
 507 TEST_F(BuildTest, OneStep) {
 508   // Given a dirty target with one ready input,
 509   // we should rebuild the target.
 510   Dirty("cat1");
 511   string err;
 512   EXPECT_TRUE(builder_.AddTarget("cat1", &err));
 513   ASSERT_EQ("", err);
 514   EXPECT_TRUE(builder_.Build(&err));
 515   ASSERT_EQ("", err);
 516
 517   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 518   EXPECT_EQ("cat in1 > cat1", command_runner_.commands_ran_[0]);
 519 }
 520
 521 TEST_F(BuildTest, OneStep2) {
 522   // Given a target with one dirty input,
 523   // we should rebuild the target.
 524   Dirty("cat1");
 525   string err;
 526   EXPECT_TRUE(builder_.AddTarget("cat1", &err));
 527   ASSERT_EQ("", err);
 528   EXPECT_TRUE(builder_.Build(&err));
 529   EXPECT_EQ("", err);
 530
 531   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 532   EXPECT_EQ("cat in1 > cat1", command_runner_.commands_ran_[0]);
 533 }
 534
 535 TEST_F(BuildTest, TwoStep) {
 536   string err;
 537   EXPECT_TRUE(builder_.AddTarget("cat12", &err));
 538   ASSERT_EQ("", err);
 539   EXPECT_TRUE(builder_.Build(&err));
 540   EXPECT_EQ("", err);
 541   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
 542   // Depending on how the pointers work out, we could've ran
 543   // the first two commands in either order.
 544   EXPECT_TRUE((command_runner_.commands_ran_[0] == "cat in1 > cat1" &&
 545                command_runner_.commands_ran_[1] == "cat in1 in2 > cat2") ||
 546               (command_runner_.commands_ran_[1] == "cat in1 > cat1" &&
 547                command_runner_.commands_ran_[0] == "cat in1 in2 > cat2"));
 548
 549   EXPECT_EQ("cat cat1 cat2 > cat12", command_runner_.commands_ran_[2]);
 550
 551   fs_.Tick();
 552
 553   // Modifying in2 requires rebuilding one intermediate file
 554   // and the final file.
 555   fs_.Create("in2", "");
 556   state_.Reset();
 557   EXPECT_TRUE(builder_.AddTarget("cat12", &err));
 558   ASSERT_EQ("", err);
 559   EXPECT_TRUE(builder_.Build(&err));
 560   ASSERT_EQ("", err);
 561   ASSERT_EQ(5u, command_runner_.commands_ran_.size());
 562   EXPECT_EQ("cat in1 in2 > cat2", command_runner_.commands_ran_[3]);
 563   EXPECT_EQ("cat cat1 cat2 > cat12", command_runner_.commands_ran_[4]);
 564 }
 565
 566 TEST_F(BuildTest, TwoOutputs) {
 567   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 568 "rule touch\n"
 569 "  command = touch $out\n"
 570 "build out1 out2: touch in.txt\n"));
 571
 572   fs_.Create("in.txt", "");
 573
 574   string err;
 575   EXPECT_TRUE(builder_.AddTarget("out1", &err));
 576   ASSERT_EQ("", err);
 577   EXPECT_TRUE(builder_.Build(&err));
 578   EXPECT_EQ("", err);
 579   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 580   EXPECT_EQ("touch out1 out2", command_runner_.commands_ran_[0]);
 581 }
 582
 583 // Test case from
 584 //   https://github.com/martine/ninja/issues/148
 585 TEST_F(BuildTest, MultiOutIn) {
 586   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 587 "rule touch\n"
 588 "  command = touch $out\n"
 589 "build in1 otherfile: touch in\n"
 590 "build out: touch in | in1\n"));
 591
 592   fs_.Create("in", "");
 593   fs_.Tick();
 594   fs_.Create("in1", "");
 595
 596   string err;
 597   EXPECT_TRUE(builder_.AddTarget("out", &err));
 598   ASSERT_EQ("", err);
 599   EXPECT_TRUE(builder_.Build(&err));
 600   EXPECT_EQ("", err);
 601 }
 602
 603 TEST_F(BuildTest, Chain) {
 604   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 605 "build c2: cat c1\n"
 606 "build c3: cat c2\n"
 607 "build c4: cat c3\n"
 608 "build c5: cat c4\n"));
 609
 610   fs_.Create("c1", "");
 611
 612   string err;
 613   EXPECT_TRUE(builder_.AddTarget("c5", &err));
 614   ASSERT_EQ("", err);
 615   EXPECT_TRUE(builder_.Build(&err));
 616   EXPECT_EQ("", err);
 617   ASSERT_EQ(4u, command_runner_.commands_ran_.size());
 618
 619   err.clear();
 620   command_runner_.commands_ran_.clear();
 621   state_.Reset();
 622   EXPECT_TRUE(builder_.AddTarget("c5", &err));
 623   ASSERT_EQ("", err);
 624   EXPECT_TRUE(builder_.AlreadyUpToDate());
 625
 626   fs_.Tick();
 627
 628   fs_.Create("c3", "");
 629   err.clear();
 630   command_runner_.commands_ran_.clear();
 631   state_.Reset();
 632   EXPECT_TRUE(builder_.AddTarget("c5", &err));
 633   ASSERT_EQ("", err);
 634   EXPECT_FALSE(builder_.AlreadyUpToDate());
 635   EXPECT_TRUE(builder_.Build(&err));
 636   ASSERT_EQ(2u, command_runner_.commands_ran_.size());  // 3->4, 4->5
 637 }
 638
 639 TEST_F(BuildTest, MissingInput) {
 640   // Input is referenced by build file, but no rule for it.
 641   string err;
 642   Dirty("in1");
 643   EXPECT_FALSE(builder_.AddTarget("cat1", &err));
 644   EXPECT_EQ("'in1', needed by 'cat1', missing and no known rule to make it",
 645             err);
 646 }
 647
 648 TEST_F(BuildTest, MissingTarget) {
 649   // Target is not referenced by build file.
 650   string err;
 651   EXPECT_FALSE(builder_.AddTarget("meow", &err));
 652   EXPECT_EQ("unknown target: 'meow'", err);
 653 }
 654
 655 TEST_F(BuildTest, MakeDirs) {
 656   string err;
 657
 658 #ifdef _WIN32
 659   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 660                                       "build subdir\\dir2\\file: cat in1\n"));
 661   EXPECT_TRUE(builder_.AddTarget("subdir\\dir2\\file", &err));
 662 #else
 663   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 664                                       "build subdir/dir2/file: cat in1\n"));
 665   EXPECT_TRUE(builder_.AddTarget("subdir/dir2/file", &err));
 666 #endif
 667
 668   EXPECT_EQ("", err);
 669   EXPECT_TRUE(builder_.Build(&err));
 670   ASSERT_EQ("", err);
 671   ASSERT_EQ(2u, fs_.directories_made_.size());
 672   EXPECT_EQ("subdir", fs_.directories_made_[0]);
 673 #ifdef _WIN32
 674   EXPECT_EQ("subdir\\dir2", fs_.directories_made_[1]);
 675 #else
 676   EXPECT_EQ("subdir/dir2", fs_.directories_made_[1]);
 677 #endif
 678 }
 679
 680 TEST_F(BuildTest, DepFileMissing) {
 681   string err;
 682   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 683 "rule cc\n  command = cc $in\n  depfile = $out.d\n"
 684 "build foo.o: cc foo.c\n"));
 685   fs_.Create("foo.c", "");
 686
 687   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 688   ASSERT_EQ("", err);
 689   ASSERT_EQ(1u, fs_.files_read_.size());
 690   EXPECT_EQ("foo.o.d", fs_.files_read_[0]);
 691 }
 692
 693 TEST_F(BuildTest, DepFileOK) {
 694   string err;
 695   int orig_edges = state_.edges_.size();
 696   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 697 "rule cc\n  command = cc $in\n  depfile = $out.d\n"
 698 "build foo.o: cc foo.c\n"));
 699   Edge* edge = state_.edges_.back();
 700
 701   fs_.Create("foo.c", "");
 702   GetNode("bar.h")->MarkDirty();  // Mark bar.h as missing.
 703   fs_.Create("foo.o.d", "foo.o: blah.h bar.h\n");
 704   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 705   ASSERT_EQ("", err);
 706   ASSERT_EQ(1u, fs_.files_read_.size());
 707   EXPECT_EQ("foo.o.d", fs_.files_read_[0]);
 708
 709   // Expect three new edges: one generating foo.o, and two more from
 710   // loading the depfile.
 711   ASSERT_EQ(orig_edges + 3, (int)state_.edges_.size());
 712   // Expect our edge to now have three inputs: foo.c and two headers.
 713   ASSERT_EQ(3u, edge->inputs_.size());
 714
 715   // Expect the command line we generate to only use the original input.
 716   ASSERT_EQ("cc foo.c", edge->EvaluateCommand());
 717 }
 718
 719 TEST_F(BuildTest, DepFileParseError) {
 720   string err;
 721   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 722 "rule cc\n  command = cc $in\n  depfile = $out.d\n"
 723 "build foo.o: cc foo.c\n"));
 724   fs_.Create("foo.c", "");
 725   fs_.Create("foo.o.d", "randomtext\n");
 726   EXPECT_FALSE(builder_.AddTarget("foo.o", &err));
 727   EXPECT_EQ("expected depfile 'foo.o.d' to mention 'foo.o', got 'randomtext'",
 728             err);
 729 }
 730
 731 TEST_F(BuildTest, OrderOnlyDeps) {
 732   string err;
 733   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 734 "rule cc\n  command = cc $in\n  depfile = $out.d\n"
 735 "build foo.o: cc foo.c || otherfile\n"));
 736   Edge* edge = state_.edges_.back();
 737
 738   fs_.Create("foo.c", "");
 739   fs_.Create("otherfile", "");
 740   fs_.Create("foo.o.d", "foo.o: blah.h bar.h\n");
 741   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 742   ASSERT_EQ("", err);
 743
 744   // One explicit, two implicit, one order only.
 745   ASSERT_EQ(4u, edge->inputs_.size());
 746   EXPECT_EQ(2, edge->implicit_deps_);
 747   EXPECT_EQ(1, edge->order_only_deps_);
 748   // Verify the inputs are in the order we expect
 749   // (explicit then implicit then orderonly).
 750   EXPECT_EQ("foo.c", edge->inputs_[0]->path());
 751   EXPECT_EQ("blah.h", edge->inputs_[1]->path());
 752   EXPECT_EQ("bar.h", edge->inputs_[2]->path());
 753   EXPECT_EQ("otherfile", edge->inputs_[3]->path());
 754
 755   // Expect the command line we generate to only use the original input.
 756   ASSERT_EQ("cc foo.c", edge->EvaluateCommand());
 757
 758   // explicit dep dirty, expect a rebuild.
 759   EXPECT_TRUE(builder_.Build(&err));
 760   ASSERT_EQ("", err);
 761   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 762
 763   fs_.Tick();
 764
 765   // Recreate the depfile, as it should have been deleted by the build.
 766   fs_.Create("foo.o.d", "foo.o: blah.h bar.h\n");
 767
 768   // implicit dep dirty, expect a rebuild.
 769   fs_.Create("blah.h", "");
 770   fs_.Create("bar.h", "");
 771   command_runner_.commands_ran_.clear();
 772   state_.Reset();
 773   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 774   EXPECT_TRUE(builder_.Build(&err));
 775   ASSERT_EQ("", err);
 776   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 777
 778   fs_.Tick();
 779
 780   // Recreate the depfile, as it should have been deleted by the build.
 781   fs_.Create("foo.o.d", "foo.o: blah.h bar.h\n");
 782
 783   // order only dep dirty, no rebuild.
 784   fs_.Create("otherfile", "");
 785   command_runner_.commands_ran_.clear();
 786   state_.Reset();
 787   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 788   EXPECT_EQ("", err);
 789   EXPECT_TRUE(builder_.AlreadyUpToDate());
 790
 791   // implicit dep missing, expect rebuild.
 792   fs_.RemoveFile("bar.h");
 793   command_runner_.commands_ran_.clear();
 794   state_.Reset();
 795   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 796   EXPECT_TRUE(builder_.Build(&err));
 797   ASSERT_EQ("", err);
 798   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 799 }
 800
 801 TEST_F(BuildTest, RebuildOrderOnlyDeps) {
 802   string err;
 803   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 804 "rule cc\n  command = cc $in\n"
 805 "rule true\n  command = true\n"
 806 "build oo.h: cc oo.h.in\n"
 807 "build foo.o: cc foo.c || oo.h\n"));
 808
 809   fs_.Create("foo.c", "");
 810   fs_.Create("oo.h.in", "");
 811
 812   // foo.o and order-only dep dirty, build both.
 813   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 814   EXPECT_TRUE(builder_.Build(&err));
 815   ASSERT_EQ("", err);
 816   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
 817
 818   // all clean, no rebuild.
 819   command_runner_.commands_ran_.clear();
 820   state_.Reset();
 821   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 822   EXPECT_EQ("", err);
 823   EXPECT_TRUE(builder_.AlreadyUpToDate());
 824
 825   // order-only dep missing, build it only.
 826   fs_.RemoveFile("oo.h");
 827   command_runner_.commands_ran_.clear();
 828   state_.Reset();
 829   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 830   EXPECT_TRUE(builder_.Build(&err));
 831   ASSERT_EQ("", err);
 832   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 833   ASSERT_EQ("cc oo.h.in", command_runner_.commands_ran_[0]);
 834
 835   fs_.Tick();
 836
 837   // order-only dep dirty, build it only.
 838   fs_.Create("oo.h.in", "");
 839   command_runner_.commands_ran_.clear();
 840   state_.Reset();
 841   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 842   EXPECT_TRUE(builder_.Build(&err));
 843   ASSERT_EQ("", err);
 844   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 845   ASSERT_EQ("cc oo.h.in", command_runner_.commands_ran_[0]);
 846 }
 847
 848 TEST_F(BuildTest, Phony) {
 849   string err;
 850   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 851 "build out: cat bar.cc\n"
 852 "build all: phony out\n"));
 853   fs_.Create("bar.cc", "");
 854
 855   EXPECT_TRUE(builder_.AddTarget("all", &err));
 856   ASSERT_EQ("", err);
 857
 858   // Only one command to run, because phony runs no command.
 859   EXPECT_FALSE(builder_.AlreadyUpToDate());
 860   EXPECT_TRUE(builder_.Build(&err));
 861   ASSERT_EQ("", err);
 862   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 863 }
 864
 865 TEST_F(BuildTest, PhonyNoWork) {
 866   string err;
 867   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 868 "build out: cat bar.cc\n"
 869 "build all: phony out\n"));
 870   fs_.Create("bar.cc", "");
 871   fs_.Create("out", "");
 872
 873   EXPECT_TRUE(builder_.AddTarget("all", &err));
 874   ASSERT_EQ("", err);
 875   EXPECT_TRUE(builder_.AlreadyUpToDate());
 876 }
 877
 878 TEST_F(BuildTest, Fail) {
 879   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 880 "rule fail\n"
 881 "  command = fail\n"
 882 "build out1: fail\n"));
 883
 884   string err;
 885   EXPECT_TRUE(builder_.AddTarget("out1", &err));
 886   ASSERT_EQ("", err);
 887
 888   EXPECT_FALSE(builder_.Build(&err));
 889   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 890   ASSERT_EQ("subcommand failed", err);
 891 }
 892
 893 TEST_F(BuildTest, SwallowFailures) {
 894   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 895 "rule fail\n"
 896 "  command = fail\n"
 897 "build out1: fail\n"
 898 "build out2: fail\n"
 899 "build out3: fail\n"
 900 "build all: phony out1 out2 out3\n"));
 901
 902   // Swallow two failures, die on the third.
 903   config_.failures_allowed = 3;
 904
 905   string err;
 906   EXPECT_TRUE(builder_.AddTarget("all", &err));
 907   ASSERT_EQ("", err);
 908
 909   EXPECT_FALSE(builder_.Build(&err));
 910   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
 911   ASSERT_EQ("subcommands failed", err);
 912 }
 913
 914 TEST_F(BuildTest, SwallowFailuresLimit) {
 915   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 916 "rule fail\n"
 917 "  command = fail\n"
 918 "build out1: fail\n"
 919 "build out2: fail\n"
 920 "build out3: fail\n"
 921 "build final: cat out1 out2 out3\n"));
 922
 923   // Swallow ten failures; we should stop before building final.
 924   config_.failures_allowed = 11;
 925
 926   string err;
 927   EXPECT_TRUE(builder_.AddTarget("final", &err));
 928   ASSERT_EQ("", err);
 929
 930   EXPECT_FALSE(builder_.Build(&err));
 931   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
 932   ASSERT_EQ("cannot make progress due to previous errors", err);
 933 }
 934
 935 struct BuildWithLogTest : public BuildTest {
 936   BuildWithLogTest() {
 937     builder_.SetBuildLog(&build_log_);
 938   }
 939
 940   BuildLog build_log_;
 941 };
 942
 943 TEST_F(BuildWithLogTest, NotInLogButOnDisk) {
 944   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 945 "rule cc\n"
 946 "  command = cc\n"
 947 "build out1: cc in\n"));
 948
 949   // Create input/output that would be considered up to date when
 950   // not considering the command line hash.
 951   fs_.Create("in", "");
 952   fs_.Create("out1", "");
 953   string err;
 954
 955   // Because it's not in the log, it should not be up-to-date until
 956   // we build again.
 957   EXPECT_TRUE(builder_.AddTarget("out1", &err));
 958   EXPECT_FALSE(builder_.AlreadyUpToDate());
 959
 960   command_runner_.commands_ran_.clear();
 961   state_.Reset();
 962
 963   EXPECT_TRUE(builder_.AddTarget("out1", &err));
 964   EXPECT_TRUE(builder_.Build(&err));
 965   EXPECT_TRUE(builder_.AlreadyUpToDate());
 966 }
 967
 968 TEST_F(BuildWithLogTest, RestatTest) {
 969   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 970 "rule true\n"
 971 "  command = true\n"
 972 "  restat = 1\n"
 973 "rule cc\n"
 974 "  command = cc\n"
 975 "  restat = 1\n"
 976 "build out1: cc in\n"
 977 "build out2: true out1\n"
 978 "build out3: cat out2\n"));
 979
 980   fs_.Create("out1", "");
 981   fs_.Create("out2", "");
 982   fs_.Create("out3", "");
 983
 984   fs_.Tick();
 985
 986   fs_.Create("in", "");
 987
 988   // Do a pre-build so that there's commands in the log for the outputs,
 989   // otherwise, the lack of an entry in the build log will cause out3 to rebuild
 990   // regardless of restat.
 991   string err;
 992   EXPECT_TRUE(builder_.AddTarget("out3", &err));
 993   ASSERT_EQ("", err);
 994   EXPECT_TRUE(builder_.Build(&err));
 995   ASSERT_EQ("", err);
 996   command_runner_.commands_ran_.clear();
 997   state_.Reset();
 998
 999   fs_.Tick();
1000
1001   fs_.Create("in", "");
1002   // "cc" touches out1, so we should build out2.  But because "true" does not
1003   // touch out2, we should cancel the build of out3.
1004   EXPECT_TRUE(builder_.AddTarget("out3", &err));
1005   ASSERT_EQ("", err);
1006   EXPECT_TRUE(builder_.Build(&err));
1007   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
1008
1009   // If we run again, it should be a no-op, because the build log has recorded
1010   // that we've already built out2 with an input timestamp of 2 (from out1).
1011   command_runner_.commands_ran_.clear();
1012   state_.Reset();
1013   EXPECT_TRUE(builder_.AddTarget("out3", &err));
1014   ASSERT_EQ("", err);
1015   EXPECT_TRUE(builder_.AlreadyUpToDate());
1016
1017   fs_.Tick();
1018
1019   fs_.Create("in", "");
1020
1021   // The build log entry should not, however, prevent us from rebuilding out2
1022   // if out1 changes.
1023   command_runner_.commands_ran_.clear();
1024   state_.Reset();
1025   EXPECT_TRUE(builder_.AddTarget("out3", &err));
1026   ASSERT_EQ("", err);
1027   EXPECT_TRUE(builder_.Build(&err));
1028   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
1029 }
1030
1031 TEST_F(BuildWithLogTest, RestatMissingFile) {
1032   // If a restat rule doesn't create its output, and the output didn't
1033   // exist before the rule was run, consider that behavior equivalent
1034   // to a rule that doesn't modify its existent output file.
1035
1036   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1037 "rule true\n"
1038 "  command = true\n"
1039 "  restat = 1\n"
1040 "rule cc\n"
1041 "  command = cc\n"
1042 "build out1: true in\n"
1043 "build out2: cc out1\n"));
1044
1045   fs_.Create("in", "");
1046   fs_.Create("out2", "");
1047
1048   // Do a pre-build so that there's commands in the log for the outputs,
1049   // otherwise, the lack of an entry in the build log will cause out2 to rebuild
1050   // regardless of restat.
1051   string err;
1052   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1053   ASSERT_EQ("", err);
1054   EXPECT_TRUE(builder_.Build(&err));
1055   ASSERT_EQ("", err);
1056   command_runner_.commands_ran_.clear();
1057   state_.Reset();
1058
1059   fs_.Tick();
1060   fs_.Create("in", "");
1061   fs_.Create("out2", "");
1062
1063   // Run a build, expect only the first command to run.
1064   // It doesn't touch its output (due to being the "true" command), so
1065   // we shouldn't run the dependent build.
1066   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1067   ASSERT_EQ("", err);
1068   EXPECT_TRUE(builder_.Build(&err));
1069   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1070 }
1071
1072 // Test scenario, in which an input file is removed, but output isn't changed
1073 // https://github.com/martine/ninja/issues/295
1074 TEST_F(BuildWithLogTest, RestatMissingInput) {
1075   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1076     "rule true\n"
1077     "  command = true\n"
1078     "  depfile = $out.d\n"
1079     "  restat = 1\n"
1080     "rule cc\n"
1081     "  command = cc\n"
1082     "build out1: true in\n"
1083     "build out2: cc out1\n"));
1084
1085   // Create all necessary files
1086   fs_.Create("in", "");
1087
1088   // The implicit dependencies and the depfile itself
1089   // are newer than the output
1090   TimeStamp restat_mtime = fs_.Tick();
1091   fs_.Create("out1.d", "out1: will.be.deleted restat.file\n");
1092   fs_.Create("will.be.deleted", "");
1093   fs_.Create("restat.file", "");
1094
1095   // Run the build, out1 and out2 get built
1096   string err;
1097   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1098   ASSERT_EQ("", err);
1099   EXPECT_TRUE(builder_.Build(&err));
1100   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
1101
1102   // See that an entry in the logfile is created, capturing
1103   // the right mtime
1104   BuildLog::LogEntry * log_entry = build_log_.LookupByOutput("out1");
1105   ASSERT_TRUE(NULL != log_entry);
1106   ASSERT_EQ(restat_mtime, log_entry->restat_mtime);
1107
1108   // Now remove a file, referenced from depfile, so that target becomes
1109   // dirty, but the output does not change
1110   fs_.RemoveFile("will.be.deleted");
1111
1112   // Trigger the build again - only out1 gets built
1113   command_runner_.commands_ran_.clear();
1114   state_.Reset();
1115   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1116   ASSERT_EQ("", err);
1117   EXPECT_TRUE(builder_.Build(&err));
1118   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1119
1120   // Check that the logfile entry remains correctly set
1121   log_entry = build_log_.LookupByOutput("out1");
1122   ASSERT_TRUE(NULL != log_entry);
1123   ASSERT_EQ(restat_mtime, log_entry->restat_mtime);
1124 }
1125
1126 struct BuildDryRun : public BuildWithLogTest {
1127   BuildDryRun() {
1128     config_.dry_run = true;
1129   }
1130 };
1131
1132 TEST_F(BuildDryRun, AllCommandsShown) {
1133   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1134 "rule true\n"
1135 "  command = true\n"
1136 "  restat = 1\n"
1137 "rule cc\n"
1138 "  command = cc\n"
1139 "  restat = 1\n"
1140 "build out1: cc in\n"
1141 "build out2: true out1\n"
1142 "build out3: cat out2\n"));
1143
1144   fs_.Create("out1", "");
1145   fs_.Create("out2", "");
1146   fs_.Create("out3", "");
1147
1148   fs_.Tick();
1149
1150   fs_.Create("in", "");
1151
1152   // "cc" touches out1, so we should build out2.  But because "true" does not
1153   // touch out2, we should cancel the build of out3.
1154   string err;
1155   EXPECT_TRUE(builder_.AddTarget("out3", &err));
1156   ASSERT_EQ("", err);
1157   EXPECT_TRUE(builder_.Build(&err));
1158   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
1159 }
1160
1161 // Test that RSP files are created when & where appropriate and deleted after
1162 // successful execution.
1163 TEST_F(BuildTest, RspFileSuccess)
1164 {
1165   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1166     "rule cat_rsp\n"
1167     "  command = cat $rspfile > $out\n"
1168     "  rspfile = $rspfile\n"
1169     "  rspfile_content = $long_command\n"
1170     "build out1: cat in\n"
1171     "build out2: cat_rsp in\n"
1172     "  rspfile = out2.rsp\n"
1173     "  long_command = Some very long command\n"));
1174
1175   fs_.Create("out1", "");
1176   fs_.Create("out2", "");
1177   fs_.Create("out3", "");
1178
1179   fs_.Tick();
1180
1181   fs_.Create("in", "");
1182
1183   string err;
1184   EXPECT_TRUE(builder_.AddTarget("out1", &err));
1185   ASSERT_EQ("", err);
1186   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1187   ASSERT_EQ("", err);
1188
1189   size_t files_created = fs_.files_created_.size();
1190   size_t files_removed = fs_.files_removed_.size();
1191
1192   EXPECT_TRUE(builder_.Build(&err));
1193   ASSERT_EQ(2u, command_runner_.commands_ran_.size()); // cat + cat_rsp
1194
1195   // The RSP file was created
1196   ASSERT_EQ(files_created + 1, fs_.files_created_.size());
1197   ASSERT_EQ(1u, fs_.files_created_.count("out2.rsp"));
1198
1199   // The RSP file was removed
1200   ASSERT_EQ(files_removed + 1, fs_.files_removed_.size());
1201   ASSERT_EQ(1u, fs_.files_removed_.count("out2.rsp"));
1202 }
1203
1204 // Test that RSP file is created but not removed for commands, which fail
1205 TEST_F(BuildTest, RspFileFailure) {
1206   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1207     "rule fail\n"
1208     "  command = fail\n"
1209     "  rspfile = $rspfile\n"
1210     "  rspfile_content = $long_command\n"
1211     "build out: fail in\n"
1212     "  rspfile = out.rsp\n"
1213     "  long_command = Another very long command\n"));
1214
1215   fs_.Create("out", "");
1216   fs_.Tick();
1217   fs_.Create("in", "");
1218
1219   string err;
1220   EXPECT_TRUE(builder_.AddTarget("out", &err));
1221   ASSERT_EQ("", err);
1222
1223   size_t files_created = fs_.files_created_.size();
1224   size_t files_removed = fs_.files_removed_.size();
1225
1226   EXPECT_FALSE(builder_.Build(&err));
1227   ASSERT_EQ("subcommand failed", err);
1228   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1229
1230   // The RSP file was created
1231   ASSERT_EQ(files_created + 1, fs_.files_created_.size());
1232   ASSERT_EQ(1u, fs_.files_created_.count("out.rsp"));
1233
1234   // The RSP file was NOT removed
1235   ASSERT_EQ(files_removed, fs_.files_removed_.size());
1236   ASSERT_EQ(0u, fs_.files_removed_.count("out.rsp"));
1237
1238   // The RSP file contains what it should
1239   ASSERT_EQ("Another very long command", fs_.files_["out.rsp"].contents);
1240 }
1241
1242 // Test that contens of the RSP file behaves like a regular part of
1243 // command line, i.e. triggers a rebuild if changed
1244 TEST_F(BuildWithLogTest, RspFileCmdLineChange) {
1245   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1246     "rule cat_rsp\n"
1247     "  command = cat $rspfile > $out\n"
1248     "  rspfile = $rspfile\n"
1249     "  rspfile_content = $long_command\n"
1250     "build out: cat_rsp in\n"
1251     "  rspfile = out.rsp\n"
1252     "  long_command = Original very long command\n"));
1253
1254   fs_.Create("out", "");
1255   fs_.Tick();
1256   fs_.Create("in", "");
1257
1258   string err;
1259   EXPECT_TRUE(builder_.AddTarget("out", &err));
1260   ASSERT_EQ("", err);
1261
1262   // 1. Build for the 1st time (-> populate log)
1263   EXPECT_TRUE(builder_.Build(&err));
1264   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1265
1266   // 2. Build again (no change)
1267   command_runner_.commands_ran_.clear();
1268   state_.Reset();
1269   EXPECT_TRUE(builder_.AddTarget("out", &err));
1270   EXPECT_EQ("", err);
1271   ASSERT_TRUE(builder_.AlreadyUpToDate());
1272
1273   // 3. Alter the entry in the logfile
1274   // (to simulate a change in the command line between 2 builds)
1275   BuildLog::LogEntry * log_entry = build_log_.LookupByOutput("out");
1276   ASSERT_TRUE(NULL != log_entry);
1277   ASSERT_NO_FATAL_FAILURE(AssertHash(
1278         "cat out.rsp > out;rspfile=Original very long command",
1279         log_entry->command_hash));
1280   log_entry->command_hash++;  // Change the command hash to something else.
1281   // Now expect the target to be rebuilt
1282   command_runner_.commands_ran_.clear();
1283   state_.Reset();
1284   EXPECT_TRUE(builder_.AddTarget("out", &err));
1285   EXPECT_EQ("", err);
1286   EXPECT_TRUE(builder_.Build(&err));
1287   EXPECT_EQ(1u, command_runner_.commands_ran_.size());
1288 }
1289
1290 TEST_F(BuildTest, InterruptCleanup) {
1291   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1292 "rule interrupt\n"
1293 "  command = interrupt\n"
1294 "rule touch-interrupt\n"
1295 "  command = touch-interrupt\n"
1296 "build out1: interrupt in1\n"
1297 "build out2: touch-interrupt in2\n"));
1298
1299   fs_.Create("out1", "");
1300   fs_.Create("out2", "");
1301   fs_.Tick();
1302   fs_.Create("in1", "");
1303   fs_.Create("in2", "");
1304
1305   // An untouched output of an interrupted command should be retained.
1306   string err;
1307   EXPECT_TRUE(builder_.AddTarget("out1", &err));
1308   EXPECT_EQ("", err);
1309   EXPECT_FALSE(builder_.Build(&err));
1310   EXPECT_EQ("interrupted by user", err);
1311   builder_.Cleanup();
1312   EXPECT_GT(fs_.Stat("out1"), 0);
1313   err = "";
1314
1315   // A touched output of an interrupted command should be deleted.
1316   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1317   EXPECT_EQ("", err);
1318   EXPECT_FALSE(builder_.Build(&err));
1319   EXPECT_EQ("interrupted by user", err);
1320   builder_.Cleanup();
1321   EXPECT_EQ(0, fs_.Stat("out2"));
1322 }
1323
1324 TEST_F(BuildTest, PhonyWithNoInputs) {
1325   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1326 "build nonexistent: phony\n"
1327 "build out1: cat || nonexistent\n"
1328 "build out2: cat nonexistent\n"));
1329   fs_.Create("out1", "");
1330   fs_.Create("out2", "");
1331
1332   // out1 should be up to date even though its input is dirty, because its
1333   // order-only dependency has nothing to do.
1334   string err;
1335   EXPECT_TRUE(builder_.AddTarget("out1", &err));
1336   ASSERT_EQ("", err);
1337   EXPECT_TRUE(builder_.AlreadyUpToDate());
1338
1339   // out2 should still be out of date though, because its input is dirty.
1340   err.clear();
1341   command_runner_.commands_ran_.clear();
1342   state_.Reset();
1343   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1344   ASSERT_EQ("", err);
1345   EXPECT_TRUE(builder_.Build(&err));
1346   EXPECT_EQ("", err);
1347   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1348 }
1349
1350 TEST_F(BuildTest, StatusFormatReplacePlaceholder) {
1351   EXPECT_EQ("[%/s0/t0/r0/u0/f0]",
1352             status_.FormatProgressStatus("[%%/s%s/t%t/r%r/u%u/f%f]"));
1353 }
1354