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 Edge* WaitForCommand(ExitStatus* status, string* output);
 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, &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 Edge* FakeCommandRunner::WaitForCommand(ExitStatus* status,
 461                                         string* /* output */) {
 462   if (Edge* edge = last_command_) {
 463     if (edge->rule().name() == "interrupt" ||
 464         edge->rule().name() == "touch-interrupt") {
 465       *status = ExitInterrupted;
 466       return NULL;
 467     }
 468
 469     if (edge->rule().name() == "fail")
 470       *status = ExitFailure;
 471     else
 472       *status = ExitSuccess;
 473     last_command_ = NULL;
 474     return edge;
 475   }
 476   *status = ExitFailure;
 477   return NULL;
 478 }
 479
 480 vector<Edge*> FakeCommandRunner::GetActiveEdges() {
 481   vector<Edge*> edges;
 482   if (last_command_)
 483     edges.push_back(last_command_);
 484   return edges;
 485 }
 486
 487 void FakeCommandRunner::Abort() {
 488   last_command_ = NULL;
 489 }
 490
 491 void BuildTest::Dirty(const string& path) {
 492   Node* node = GetNode(path);
 493   node->MarkDirty();
 494
 495   // If it's an input file, mark that we've already stat()ed it and
 496   // it's missing.
 497   if (!node->in_edge())
 498     node->MarkMissing();
 499 }
 500
 501 TEST_F(BuildTest, NoWork) {
 502   string err;
 503   EXPECT_TRUE(builder_.AlreadyUpToDate());
 504 }
 505
 506 TEST_F(BuildTest, OneStep) {
 507   // Given a dirty target with one ready input,
 508   // we should rebuild the target.
 509   Dirty("cat1");
 510   string err;
 511   EXPECT_TRUE(builder_.AddTarget("cat1", &err));
 512   ASSERT_EQ("", err);
 513   EXPECT_TRUE(builder_.Build(&err));
 514   ASSERT_EQ("", err);
 515
 516   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 517   EXPECT_EQ("cat in1 > cat1", command_runner_.commands_ran_[0]);
 518 }
 519
 520 TEST_F(BuildTest, OneStep2) {
 521   // Given a target with one dirty input,
 522   // we should rebuild the target.
 523   Dirty("cat1");
 524   string err;
 525   EXPECT_TRUE(builder_.AddTarget("cat1", &err));
 526   ASSERT_EQ("", err);
 527   EXPECT_TRUE(builder_.Build(&err));
 528   EXPECT_EQ("", err);
 529
 530   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 531   EXPECT_EQ("cat in1 > cat1", command_runner_.commands_ran_[0]);
 532 }
 533
 534 TEST_F(BuildTest, TwoStep) {
 535   string err;
 536   EXPECT_TRUE(builder_.AddTarget("cat12", &err));
 537   ASSERT_EQ("", err);
 538   EXPECT_TRUE(builder_.Build(&err));
 539   EXPECT_EQ("", err);
 540   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
 541   // Depending on how the pointers work out, we could've ran
 542   // the first two commands in either order.
 543   EXPECT_TRUE((command_runner_.commands_ran_[0] == "cat in1 > cat1" &&
 544                command_runner_.commands_ran_[1] == "cat in1 in2 > cat2") ||
 545               (command_runner_.commands_ran_[1] == "cat in1 > cat1" &&
 546                command_runner_.commands_ran_[0] == "cat in1 in2 > cat2"));
 547
 548   EXPECT_EQ("cat cat1 cat2 > cat12", command_runner_.commands_ran_[2]);
 549
 550   fs_.Tick();
 551
 552   // Modifying in2 requires rebuilding one intermediate file
 553   // and the final file.
 554   fs_.Create("in2", "");
 555   state_.Reset();
 556   EXPECT_TRUE(builder_.AddTarget("cat12", &err));
 557   ASSERT_EQ("", err);
 558   EXPECT_TRUE(builder_.Build(&err));
 559   ASSERT_EQ("", err);
 560   ASSERT_EQ(5u, command_runner_.commands_ran_.size());
 561   EXPECT_EQ("cat in1 in2 > cat2", command_runner_.commands_ran_[3]);
 562   EXPECT_EQ("cat cat1 cat2 > cat12", command_runner_.commands_ran_[4]);
 563 }
 564
 565 TEST_F(BuildTest, TwoOutputs) {
 566   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 567 "rule touch\n"
 568 "  command = touch $out\n"
 569 "build out1 out2: touch in.txt\n"));
 570
 571   fs_.Create("in.txt", "");
 572
 573   string err;
 574   EXPECT_TRUE(builder_.AddTarget("out1", &err));
 575   ASSERT_EQ("", err);
 576   EXPECT_TRUE(builder_.Build(&err));
 577   EXPECT_EQ("", err);
 578   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 579   EXPECT_EQ("touch out1 out2", command_runner_.commands_ran_[0]);
 580 }
 581
 582 // Test case from
 583 //   https://github.com/martine/ninja/issues/148
 584 TEST_F(BuildTest, MultiOutIn) {
 585   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 586 "rule touch\n"
 587 "  command = touch $out\n"
 588 "build in1 otherfile: touch in\n"
 589 "build out: touch in | in1\n"));
 590
 591   fs_.Create("in", "");
 592   fs_.Tick();
 593   fs_.Create("in1", "");
 594
 595   string err;
 596   EXPECT_TRUE(builder_.AddTarget("out", &err));
 597   ASSERT_EQ("", err);
 598   EXPECT_TRUE(builder_.Build(&err));
 599   EXPECT_EQ("", err);
 600 }
 601
 602 TEST_F(BuildTest, Chain) {
 603   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 604 "build c2: cat c1\n"
 605 "build c3: cat c2\n"
 606 "build c4: cat c3\n"
 607 "build c5: cat c4\n"));
 608
 609   fs_.Create("c1", "");
 610
 611   string err;
 612   EXPECT_TRUE(builder_.AddTarget("c5", &err));
 613   ASSERT_EQ("", err);
 614   EXPECT_TRUE(builder_.Build(&err));
 615   EXPECT_EQ("", err);
 616   ASSERT_EQ(4u, command_runner_.commands_ran_.size());
 617
 618   err.clear();
 619   command_runner_.commands_ran_.clear();
 620   state_.Reset();
 621   EXPECT_TRUE(builder_.AddTarget("c5", &err));
 622   ASSERT_EQ("", err);
 623   EXPECT_TRUE(builder_.AlreadyUpToDate());
 624
 625   fs_.Tick();
 626
 627   fs_.Create("c3", "");
 628   err.clear();
 629   command_runner_.commands_ran_.clear();
 630   state_.Reset();
 631   EXPECT_TRUE(builder_.AddTarget("c5", &err));
 632   ASSERT_EQ("", err);
 633   EXPECT_FALSE(builder_.AlreadyUpToDate());
 634   EXPECT_TRUE(builder_.Build(&err));
 635   ASSERT_EQ(2u, command_runner_.commands_ran_.size());  // 3->4, 4->5
 636 }
 637
 638 TEST_F(BuildTest, MissingInput) {
 639   // Input is referenced by build file, but no rule for it.
 640   string err;
 641   Dirty("in1");
 642   EXPECT_FALSE(builder_.AddTarget("cat1", &err));
 643   EXPECT_EQ("'in1', needed by 'cat1', missing and no known rule to make it",
 644             err);
 645 }
 646
 647 TEST_F(BuildTest, MissingTarget) {
 648   // Target is not referenced by build file.
 649   string err;
 650   EXPECT_FALSE(builder_.AddTarget("meow", &err));
 651   EXPECT_EQ("unknown target: 'meow'", err);
 652 }
 653
 654 TEST_F(BuildTest, MakeDirs) {
 655   string err;
 656
 657 #ifdef _WIN32
 658   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 659                                       "build subdir\\dir2\\file: cat in1\n"));
 660   EXPECT_TRUE(builder_.AddTarget("subdir\\dir2\\file", &err));
 661 #else
 662   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 663                                       "build subdir/dir2/file: cat in1\n"));
 664   EXPECT_TRUE(builder_.AddTarget("subdir/dir2/file", &err));
 665 #endif
 666
 667   EXPECT_EQ("", err);
 668   EXPECT_TRUE(builder_.Build(&err));
 669   ASSERT_EQ("", err);
 670   ASSERT_EQ(2u, fs_.directories_made_.size());
 671   EXPECT_EQ("subdir", fs_.directories_made_[0]);
 672 #ifdef _WIN32
 673   EXPECT_EQ("subdir\\dir2", fs_.directories_made_[1]);
 674 #else
 675   EXPECT_EQ("subdir/dir2", fs_.directories_made_[1]);
 676 #endif
 677 }
 678
 679 TEST_F(BuildTest, DepFileMissing) {
 680   string err;
 681   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 682 "rule cc\n  command = cc $in\n  depfile = $out.d\n"
 683 "build foo.o: cc foo.c\n"));
 684   fs_.Create("foo.c", "");
 685
 686   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 687   ASSERT_EQ("", err);
 688   ASSERT_EQ(1u, fs_.files_read_.size());
 689   EXPECT_EQ("foo.o.d", fs_.files_read_[0]);
 690 }
 691
 692 TEST_F(BuildTest, DepFileOK) {
 693   string err;
 694   int orig_edges = state_.edges_.size();
 695   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 696 "rule cc\n  command = cc $in\n  depfile = $out.d\n"
 697 "build foo.o: cc foo.c\n"));
 698   Edge* edge = state_.edges_.back();
 699
 700   fs_.Create("foo.c", "");
 701   GetNode("bar.h")->MarkDirty();  // Mark bar.h as missing.
 702   fs_.Create("foo.o.d", "foo.o: blah.h bar.h\n");
 703   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 704   ASSERT_EQ("", err);
 705   ASSERT_EQ(1u, fs_.files_read_.size());
 706   EXPECT_EQ("foo.o.d", fs_.files_read_[0]);
 707
 708   // Expect three new edges: one generating foo.o, and two more from
 709   // loading the depfile.
 710   ASSERT_EQ(orig_edges + 3, (int)state_.edges_.size());
 711   // Expect our edge to now have three inputs: foo.c and two headers.
 712   ASSERT_EQ(3u, edge->inputs_.size());
 713
 714   // Expect the command line we generate to only use the original input.
 715   ASSERT_EQ("cc foo.c", edge->EvaluateCommand());
 716 }
 717
 718 TEST_F(BuildTest, DepFileParseError) {
 719   string err;
 720   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 721 "rule cc\n  command = cc $in\n  depfile = $out.d\n"
 722 "build foo.o: cc foo.c\n"));
 723   fs_.Create("foo.c", "");
 724   fs_.Create("foo.o.d", "randomtext\n");
 725   EXPECT_FALSE(builder_.AddTarget("foo.o", &err));
 726   EXPECT_EQ("expected depfile 'foo.o.d' to mention 'foo.o', got 'randomtext'",
 727             err);
 728 }
 729
 730 TEST_F(BuildTest, OrderOnlyDeps) {
 731   string err;
 732   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 733 "rule cc\n  command = cc $in\n  depfile = $out.d\n"
 734 "build foo.o: cc foo.c || otherfile\n"));
 735   Edge* edge = state_.edges_.back();
 736
 737   fs_.Create("foo.c", "");
 738   fs_.Create("otherfile", "");
 739   fs_.Create("foo.o.d", "foo.o: blah.h bar.h\n");
 740   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 741   ASSERT_EQ("", err);
 742
 743   // One explicit, two implicit, one order only.
 744   ASSERT_EQ(4u, edge->inputs_.size());
 745   EXPECT_EQ(2, edge->implicit_deps_);
 746   EXPECT_EQ(1, edge->order_only_deps_);
 747   // Verify the inputs are in the order we expect
 748   // (explicit then implicit then orderonly).
 749   EXPECT_EQ("foo.c", edge->inputs_[0]->path());
 750   EXPECT_EQ("blah.h", edge->inputs_[1]->path());
 751   EXPECT_EQ("bar.h", edge->inputs_[2]->path());
 752   EXPECT_EQ("otherfile", edge->inputs_[3]->path());
 753
 754   // Expect the command line we generate to only use the original input.
 755   ASSERT_EQ("cc foo.c", edge->EvaluateCommand());
 756
 757   // explicit dep dirty, expect a rebuild.
 758   EXPECT_TRUE(builder_.Build(&err));
 759   ASSERT_EQ("", err);
 760   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 761
 762   fs_.Tick();
 763
 764   // implicit dep dirty, expect a rebuild.
 765   fs_.Create("blah.h", "");
 766   fs_.Create("bar.h", "");
 767   command_runner_.commands_ran_.clear();
 768   state_.Reset();
 769   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 770   EXPECT_TRUE(builder_.Build(&err));
 771   ASSERT_EQ("", err);
 772   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 773
 774   fs_.Tick();
 775
 776   // order only dep dirty, no rebuild.
 777   fs_.Create("otherfile", "");
 778   command_runner_.commands_ran_.clear();
 779   state_.Reset();
 780   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 781   EXPECT_EQ("", err);
 782   EXPECT_TRUE(builder_.AlreadyUpToDate());
 783
 784   // implicit dep missing, expect rebuild.
 785   fs_.RemoveFile("bar.h");
 786   command_runner_.commands_ran_.clear();
 787   state_.Reset();
 788   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 789   EXPECT_TRUE(builder_.Build(&err));
 790   ASSERT_EQ("", err);
 791   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 792 }
 793
 794 TEST_F(BuildTest, RebuildOrderOnlyDeps) {
 795   string err;
 796   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 797 "rule cc\n  command = cc $in\n"
 798 "rule true\n  command = true\n"
 799 "build oo.h: cc oo.h.in\n"
 800 "build foo.o: cc foo.c || oo.h\n"));
 801
 802   fs_.Create("foo.c", "");
 803   fs_.Create("oo.h.in", "");
 804
 805   // foo.o and order-only dep dirty, build both.
 806   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 807   EXPECT_TRUE(builder_.Build(&err));
 808   ASSERT_EQ("", err);
 809   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
 810
 811   // all clean, no rebuild.
 812   command_runner_.commands_ran_.clear();
 813   state_.Reset();
 814   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 815   EXPECT_EQ("", err);
 816   EXPECT_TRUE(builder_.AlreadyUpToDate());
 817
 818   // order-only dep missing, build it only.
 819   fs_.RemoveFile("oo.h");
 820   command_runner_.commands_ran_.clear();
 821   state_.Reset();
 822   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 823   EXPECT_TRUE(builder_.Build(&err));
 824   ASSERT_EQ("", err);
 825   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 826   ASSERT_EQ("cc oo.h.in", command_runner_.commands_ran_[0]);
 827
 828   fs_.Tick();
 829
 830   // order-only dep dirty, build it only.
 831   fs_.Create("oo.h.in", "");
 832   command_runner_.commands_ran_.clear();
 833   state_.Reset();
 834   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 835   EXPECT_TRUE(builder_.Build(&err));
 836   ASSERT_EQ("", err);
 837   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 838   ASSERT_EQ("cc oo.h.in", command_runner_.commands_ran_[0]);
 839 }
 840
 841 TEST_F(BuildTest, Phony) {
 842   string err;
 843   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 844 "build out: cat bar.cc\n"
 845 "build all: phony out\n"));
 846   fs_.Create("bar.cc", "");
 847
 848   EXPECT_TRUE(builder_.AddTarget("all", &err));
 849   ASSERT_EQ("", err);
 850
 851   // Only one command to run, because phony runs no command.
 852   EXPECT_FALSE(builder_.AlreadyUpToDate());
 853   EXPECT_TRUE(builder_.Build(&err));
 854   ASSERT_EQ("", err);
 855   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 856 }
 857
 858 TEST_F(BuildTest, PhonyNoWork) {
 859   string err;
 860   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 861 "build out: cat bar.cc\n"
 862 "build all: phony out\n"));
 863   fs_.Create("bar.cc", "");
 864   fs_.Create("out", "");
 865
 866   EXPECT_TRUE(builder_.AddTarget("all", &err));
 867   ASSERT_EQ("", err);
 868   EXPECT_TRUE(builder_.AlreadyUpToDate());
 869 }
 870
 871 TEST_F(BuildTest, Fail) {
 872   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 873 "rule fail\n"
 874 "  command = fail\n"
 875 "build out1: fail\n"));
 876
 877   string err;
 878   EXPECT_TRUE(builder_.AddTarget("out1", &err));
 879   ASSERT_EQ("", err);
 880
 881   EXPECT_FALSE(builder_.Build(&err));
 882   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 883   ASSERT_EQ("subcommand failed", err);
 884 }
 885
 886 TEST_F(BuildTest, SwallowFailures) {
 887   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 888 "rule fail\n"
 889 "  command = fail\n"
 890 "build out1: fail\n"
 891 "build out2: fail\n"
 892 "build out3: fail\n"
 893 "build all: phony out1 out2 out3\n"));
 894
 895   // Swallow two failures, die on the third.
 896   config_.failures_allowed = 3;
 897
 898   string err;
 899   EXPECT_TRUE(builder_.AddTarget("all", &err));
 900   ASSERT_EQ("", err);
 901
 902   EXPECT_FALSE(builder_.Build(&err));
 903   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
 904   ASSERT_EQ("subcommands failed", err);
 905 }
 906
 907 TEST_F(BuildTest, SwallowFailuresLimit) {
 908   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 909 "rule fail\n"
 910 "  command = fail\n"
 911 "build out1: fail\n"
 912 "build out2: fail\n"
 913 "build out3: fail\n"
 914 "build final: cat out1 out2 out3\n"));
 915
 916   // Swallow ten failures; we should stop before building final.
 917   config_.failures_allowed = 11;
 918
 919   string err;
 920   EXPECT_TRUE(builder_.AddTarget("final", &err));
 921   ASSERT_EQ("", err);
 922
 923   EXPECT_FALSE(builder_.Build(&err));
 924   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
 925   ASSERT_EQ("cannot make progress due to previous errors", err);
 926 }
 927
 928 struct BuildWithLogTest : public BuildTest {
 929   BuildWithLogTest() {
 930     builder_.SetBuildLog(&build_log_);
 931   }
 932
 933   BuildLog build_log_;
 934 };
 935
 936 TEST_F(BuildWithLogTest, NotInLogButOnDisk) {
 937   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 938 "rule cc\n"
 939 "  command = cc\n"
 940 "build out1: cc in\n"));
 941
 942   // Create input/output that would be considered up to date when
 943   // not considering the command line hash.
 944   fs_.Create("in", "");
 945   fs_.Create("out1", "");
 946   string err;
 947
 948   // Because it's not in the log, it should not be up-to-date until
 949   // we build again.
 950   EXPECT_TRUE(builder_.AddTarget("out1", &err));
 951   EXPECT_FALSE(builder_.AlreadyUpToDate());
 952
 953   command_runner_.commands_ran_.clear();
 954   state_.Reset();
 955
 956   EXPECT_TRUE(builder_.AddTarget("out1", &err));
 957   EXPECT_TRUE(builder_.Build(&err));
 958   EXPECT_TRUE(builder_.AlreadyUpToDate());
 959 }
 960
 961 TEST_F(BuildWithLogTest, RestatTest) {
 962   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 963 "rule true\n"
 964 "  command = true\n"
 965 "  restat = 1\n"
 966 "rule cc\n"
 967 "  command = cc\n"
 968 "  restat = 1\n"
 969 "build out1: cc in\n"
 970 "build out2: true out1\n"
 971 "build out3: cat out2\n"));
 972
 973   fs_.Create("out1", "");
 974   fs_.Create("out2", "");
 975   fs_.Create("out3", "");
 976
 977   fs_.Tick();
 978
 979   fs_.Create("in", "");
 980
 981   // Do a pre-build so that there's commands in the log for the outputs,
 982   // otherwise, the lack of an entry in the build log will cause out3 to rebuild
 983   // regardless of restat.
 984   string err;
 985   EXPECT_TRUE(builder_.AddTarget("out3", &err));
 986   ASSERT_EQ("", err);
 987   EXPECT_TRUE(builder_.Build(&err));
 988   ASSERT_EQ("", err);
 989   command_runner_.commands_ran_.clear();
 990   state_.Reset();
 991
 992   fs_.Tick();
 993
 994   fs_.Create("in", "");
 995   // "cc" touches out1, so we should build out2.  But because "true" does not
 996   // touch out2, we should cancel the build of out3.
 997   EXPECT_TRUE(builder_.AddTarget("out3", &err));
 998   ASSERT_EQ("", err);
 999   EXPECT_TRUE(builder_.Build(&err));
1000   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
1001
1002   // If we run again, it should be a no-op, because the build log has recorded
1003   // that we've already built out2 with an input timestamp of 2 (from out1).
1004   command_runner_.commands_ran_.clear();
1005   state_.Reset();
1006   EXPECT_TRUE(builder_.AddTarget("out3", &err));
1007   ASSERT_EQ("", err);
1008   EXPECT_TRUE(builder_.AlreadyUpToDate());
1009
1010   fs_.Tick();
1011
1012   fs_.Create("in", "");
1013
1014   // The build log entry should not, however, prevent us from rebuilding out2
1015   // if out1 changes.
1016   command_runner_.commands_ran_.clear();
1017   state_.Reset();
1018   EXPECT_TRUE(builder_.AddTarget("out3", &err));
1019   ASSERT_EQ("", err);
1020   EXPECT_TRUE(builder_.Build(&err));
1021   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
1022 }
1023
1024 TEST_F(BuildWithLogTest, RestatMissingFile) {
1025   // If a restat rule doesn't create its output, and the output didn't
1026   // exist before the rule was run, consider that behavior equivalent
1027   // to a rule that doesn't modify its existent output file.
1028
1029   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1030 "rule true\n"
1031 "  command = true\n"
1032 "  restat = 1\n"
1033 "rule cc\n"
1034 "  command = cc\n"
1035 "build out1: true in\n"
1036 "build out2: cc out1\n"));
1037
1038   fs_.Create("in", "");
1039   fs_.Create("out2", "");
1040
1041   // Do a pre-build so that there's commands in the log for the outputs,
1042   // otherwise, the lack of an entry in the build log will cause out2 to rebuild
1043   // regardless of restat.
1044   string err;
1045   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1046   ASSERT_EQ("", err);
1047   EXPECT_TRUE(builder_.Build(&err));
1048   ASSERT_EQ("", err);
1049   command_runner_.commands_ran_.clear();
1050   state_.Reset();
1051
1052   fs_.Tick();
1053   fs_.Create("in", "");
1054   fs_.Create("out2", "");
1055
1056   // Run a build, expect only the first command to run.
1057   // It doesn't touch its output (due to being the "true" command), so
1058   // we shouldn't run the dependent build.
1059   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1060   ASSERT_EQ("", err);
1061   EXPECT_TRUE(builder_.Build(&err));
1062   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1063 }
1064
1065 // Test scenario, in which an input file is removed, but output isn't changed
1066 // https://github.com/martine/ninja/issues/295
1067 TEST_F(BuildWithLogTest, RestatMissingInput) {
1068   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1069     "rule true\n"
1070     "  command = true\n"
1071     "  depfile = $out.d\n"
1072     "  restat = 1\n"
1073     "rule cc\n"
1074     "  command = cc\n"
1075     "build out1: true in\n"
1076     "build out2: cc out1\n"));
1077
1078   // Create all necessary files
1079   fs_.Create("in", "");
1080
1081   // The implicit dependencies and the depfile itself
1082   // are newer than the output
1083   TimeStamp restat_mtime = fs_.Tick();
1084   fs_.Create("out1.d", "out1: will.be.deleted restat.file\n");
1085   fs_.Create("will.be.deleted", "");
1086   fs_.Create("restat.file", "");
1087
1088   // Run the build, out1 and out2 get built
1089   string err;
1090   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1091   ASSERT_EQ("", err);
1092   EXPECT_TRUE(builder_.Build(&err));
1093   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
1094
1095   // See that an entry in the logfile is created, capturing
1096   // the right mtime
1097   BuildLog::LogEntry * log_entry = build_log_.LookupByOutput("out1");
1098   ASSERT_TRUE(NULL != log_entry);
1099   ASSERT_EQ(restat_mtime, log_entry->restat_mtime);
1100
1101   // Now remove a file, referenced from depfile, so that target becomes
1102   // dirty, but the output does not change
1103   fs_.RemoveFile("will.be.deleted");
1104
1105   // Trigger the build again - only out1 gets built
1106   command_runner_.commands_ran_.clear();
1107   state_.Reset();
1108   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1109   ASSERT_EQ("", err);
1110   EXPECT_TRUE(builder_.Build(&err));
1111   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1112
1113   // Check that the logfile entry remains correctly set
1114   log_entry = build_log_.LookupByOutput("out1");
1115   ASSERT_TRUE(NULL != log_entry);
1116   ASSERT_EQ(restat_mtime, log_entry->restat_mtime);
1117 }
1118
1119 struct BuildDryRun : public BuildWithLogTest {
1120   BuildDryRun() {
1121     config_.dry_run = true;
1122   }
1123 };
1124
1125 TEST_F(BuildDryRun, AllCommandsShown) {
1126   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1127 "rule true\n"
1128 "  command = true\n"
1129 "  restat = 1\n"
1130 "rule cc\n"
1131 "  command = cc\n"
1132 "  restat = 1\n"
1133 "build out1: cc in\n"
1134 "build out2: true out1\n"
1135 "build out3: cat out2\n"));
1136
1137   fs_.Create("out1", "");
1138   fs_.Create("out2", "");
1139   fs_.Create("out3", "");
1140
1141   fs_.Tick();
1142
1143   fs_.Create("in", "");
1144
1145   // "cc" touches out1, so we should build out2.  But because "true" does not
1146   // touch out2, we should cancel the build of out3.
1147   string err;
1148   EXPECT_TRUE(builder_.AddTarget("out3", &err));
1149   ASSERT_EQ("", err);
1150   EXPECT_TRUE(builder_.Build(&err));
1151   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
1152 }
1153
1154 // Test that RSP files are created when & where appropriate and deleted after
1155 // successful execution.
1156 TEST_F(BuildTest, RspFileSuccess)
1157 {
1158   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1159     "rule cat_rsp\n"
1160     "  command = cat $rspfile > $out\n"
1161     "  rspfile = $rspfile\n"
1162     "  rspfile_content = $long_command\n"
1163     "build out1: cat in\n"
1164     "build out2: cat_rsp in\n"
1165     "  rspfile = out2.rsp\n"
1166     "  long_command = Some very long command\n"));
1167
1168   fs_.Create("out1", "");
1169   fs_.Create("out2", "");
1170   fs_.Create("out3", "");
1171
1172   fs_.Tick();
1173
1174   fs_.Create("in", "");
1175
1176   string err;
1177   EXPECT_TRUE(builder_.AddTarget("out1", &err));
1178   ASSERT_EQ("", err);
1179   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1180   ASSERT_EQ("", err);
1181
1182   size_t files_created = fs_.files_created_.size();
1183   size_t files_removed = fs_.files_removed_.size();
1184
1185   EXPECT_TRUE(builder_.Build(&err));
1186   ASSERT_EQ(2u, command_runner_.commands_ran_.size()); // cat + cat_rsp
1187
1188   // The RSP file was created
1189   ASSERT_EQ(files_created + 1, fs_.files_created_.size());
1190   ASSERT_EQ(1u, fs_.files_created_.count("out2.rsp"));
1191
1192   // The RSP file was removed
1193   ASSERT_EQ(files_removed + 1, fs_.files_removed_.size());
1194   ASSERT_EQ(1u, fs_.files_removed_.count("out2.rsp"));
1195 }
1196
1197 // Test that RSP file is created but not removed for commands, which fail
1198 TEST_F(BuildTest, RspFileFailure) {
1199   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1200     "rule fail\n"
1201     "  command = fail\n"
1202     "  rspfile = $rspfile\n"
1203     "  rspfile_content = $long_command\n"
1204     "build out: fail in\n"
1205     "  rspfile = out.rsp\n"
1206     "  long_command = Another very long command\n"));
1207
1208   fs_.Create("out", "");
1209   fs_.Tick();
1210   fs_.Create("in", "");
1211
1212   string err;
1213   EXPECT_TRUE(builder_.AddTarget("out", &err));
1214   ASSERT_EQ("", err);
1215
1216   size_t files_created = fs_.files_created_.size();
1217   size_t files_removed = fs_.files_removed_.size();
1218
1219   EXPECT_FALSE(builder_.Build(&err));
1220   ASSERT_EQ("subcommand failed", err);
1221   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1222
1223   // The RSP file was created
1224   ASSERT_EQ(files_created + 1, fs_.files_created_.size());
1225   ASSERT_EQ(1u, fs_.files_created_.count("out.rsp"));
1226
1227   // The RSP file was NOT removed
1228   ASSERT_EQ(files_removed, fs_.files_removed_.size());
1229   ASSERT_EQ(0u, fs_.files_removed_.count("out.rsp"));
1230
1231   // The RSP file contains what it should
1232   ASSERT_EQ("Another very long command", fs_.files_["out.rsp"].contents);
1233 }
1234
1235 // Test that contens of the RSP file behaves like a regular part of
1236 // command line, i.e. triggers a rebuild if changed
1237 TEST_F(BuildWithLogTest, RspFileCmdLineChange) {
1238   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1239     "rule cat_rsp\n"
1240     "  command = cat $rspfile > $out\n"
1241     "  rspfile = $rspfile\n"
1242     "  rspfile_content = $long_command\n"
1243     "build out: cat_rsp in\n"
1244     "  rspfile = out.rsp\n"
1245     "  long_command = Original very long command\n"));
1246
1247   fs_.Create("out", "");
1248   fs_.Tick();
1249   fs_.Create("in", "");
1250
1251   string err;
1252   EXPECT_TRUE(builder_.AddTarget("out", &err));
1253   ASSERT_EQ("", err);
1254
1255   // 1. Build for the 1st time (-> populate log)
1256   EXPECT_TRUE(builder_.Build(&err));
1257   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1258
1259   // 2. Build again (no change)
1260   command_runner_.commands_ran_.clear();
1261   state_.Reset();
1262   EXPECT_TRUE(builder_.AddTarget("out", &err));
1263   EXPECT_EQ("", err);
1264   ASSERT_TRUE(builder_.AlreadyUpToDate());
1265
1266   // 3. Alter the entry in the logfile
1267   // (to simulate a change in the command line between 2 builds)
1268   BuildLog::LogEntry * log_entry = build_log_.LookupByOutput("out");
1269   ASSERT_TRUE(NULL != log_entry);
1270   ASSERT_NO_FATAL_FAILURE(AssertHash(
1271         "cat out.rsp > out;rspfile=Original very long command",
1272         log_entry->command_hash));
1273   log_entry->command_hash++;  // Change the command hash to something else.
1274   // Now expect the target to be rebuilt
1275   command_runner_.commands_ran_.clear();
1276   state_.Reset();
1277   EXPECT_TRUE(builder_.AddTarget("out", &err));
1278   EXPECT_EQ("", err);
1279   EXPECT_TRUE(builder_.Build(&err));
1280   EXPECT_EQ(1u, command_runner_.commands_ran_.size());
1281 }
1282
1283 TEST_F(BuildTest, InterruptCleanup) {
1284   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1285 "rule interrupt\n"
1286 "  command = interrupt\n"
1287 "rule touch-interrupt\n"
1288 "  command = touch-interrupt\n"
1289 "build out1: interrupt in1\n"
1290 "build out2: touch-interrupt in2\n"));
1291
1292   fs_.Create("out1", "");
1293   fs_.Create("out2", "");
1294   fs_.Tick();
1295   fs_.Create("in1", "");
1296   fs_.Create("in2", "");
1297
1298   // An untouched output of an interrupted command should be retained.
1299   string err;
1300   EXPECT_TRUE(builder_.AddTarget("out1", &err));
1301   EXPECT_EQ("", err);
1302   EXPECT_FALSE(builder_.Build(&err));
1303   EXPECT_EQ("interrupted by user", err);
1304   builder_.Cleanup();
1305   EXPECT_GT(fs_.Stat("out1"), 0);
1306   err = "";
1307
1308   // A touched output of an interrupted command should be deleted.
1309   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1310   EXPECT_EQ("", err);
1311   EXPECT_FALSE(builder_.Build(&err));
1312   EXPECT_EQ("interrupted by user", err);
1313   builder_.Cleanup();
1314   EXPECT_EQ(0, fs_.Stat("out2"));
1315 }
1316
1317 TEST_F(BuildTest, PhonyWithNoInputs) {
1318   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1319 "build nonexistent: phony\n"
1320 "build out1: cat || nonexistent\n"
1321 "build out2: cat nonexistent\n"));
1322   fs_.Create("out1", "");
1323   fs_.Create("out2", "");
1324
1325   // out1 should be up to date even though its input is dirty, because its
1326   // order-only dependency has nothing to do.
1327   string err;
1328   EXPECT_TRUE(builder_.AddTarget("out1", &err));
1329   ASSERT_EQ("", err);
1330   EXPECT_TRUE(builder_.AlreadyUpToDate());
1331
1332   // out2 should still be out of date though, because its input is dirty.
1333   err.clear();
1334   command_runner_.commands_ran_.clear();
1335   state_.Reset();
1336   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1337   ASSERT_EQ("", err);
1338   EXPECT_TRUE(builder_.Build(&err));
1339   EXPECT_EQ("", err);
1340   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1341 }
1342
1343 TEST_F(BuildTest, StatusFormatReplacePlaceholder) {
1344   EXPECT_EQ("[%/s0/t0/r0/u0/f0]",
1345             status_.FormatProgressStatus("[%%/s%s/t%t/r%r/u%u/f%f]"));
1346 }
1347