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 <assert.h>
  18
  19 #include "build_log.h"
  20 #include "deps_log.h"
  21 #include "graph.h"
  22 #include "test.h"
  23
  24 /// Fixture for tests involving Plan.
  25 // Though Plan doesn't use State, it's useful to have one around
  26 // to create Nodes and Edges.
  27 struct PlanTest : public StateTestWithBuiltinRules {
  28   Plan plan_;
  29
  30   /// Because FindWork does not return Edges in any sort of predictable order,
  31   // provide a means to get available Edges in order and in a format which is
  32   // easy to write tests around.
  33   void FindWorkSorted(deque<Edge*>* ret, int count) {
  34     struct CompareEdgesByOutput {
  35       static bool cmp(const Edge* a, const Edge* b) {
  36         return a->outputs_[0]->path() < b->outputs_[0]->path();
  37       }
  38     };
  39
  40     for (int i = 0; i < count; ++i) {
  41       ASSERT_TRUE(plan_.more_to_do());
  42       Edge* edge = plan_.FindWork();
  43       ASSERT_TRUE(edge);
  44       ret->push_back(edge);
  45     }
  46     ASSERT_FALSE(plan_.FindWork());
  47     sort(ret->begin(), ret->end(), CompareEdgesByOutput::cmp);
  48   }
  49
  50   void TestPoolWithDepthOne(const char *test_case);
  51 };
  52
  53 TEST_F(PlanTest, Basic) {
  54   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
  55 "build out: cat mid\n"
  56 "build mid: cat in\n"));
  57   GetNode("mid")->MarkDirty();
  58   GetNode("out")->MarkDirty();
  59   string err;
  60   EXPECT_TRUE(plan_.AddTarget(GetNode("out"), &err));
  61   ASSERT_EQ("", err);
  62   ASSERT_TRUE(plan_.more_to_do());
  63
  64   Edge* edge = plan_.FindWork();
  65   ASSERT_TRUE(edge);
  66   ASSERT_EQ("in",  edge->inputs_[0]->path());
  67   ASSERT_EQ("mid", edge->outputs_[0]->path());
  68
  69   ASSERT_FALSE(plan_.FindWork());
  70
  71   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
  72
  73   edge = plan_.FindWork();
  74   ASSERT_TRUE(edge);
  75   ASSERT_EQ("mid", edge->inputs_[0]->path());
  76   ASSERT_EQ("out", edge->outputs_[0]->path());
  77
  78   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
  79
  80   ASSERT_FALSE(plan_.more_to_do());
  81   edge = plan_.FindWork();
  82   ASSERT_EQ(0, edge);
  83 }
  84
  85 // Test that two outputs from one rule can be handled as inputs to the next.
  86 TEST_F(PlanTest, DoubleOutputDirect) {
  87   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
  88 "build out: cat mid1 mid2\n"
  89 "build mid1 mid2: cat in\n"));
  90   GetNode("mid1")->MarkDirty();
  91   GetNode("mid2")->MarkDirty();
  92   GetNode("out")->MarkDirty();
  93
  94   string err;
  95   EXPECT_TRUE(plan_.AddTarget(GetNode("out"), &err));
  96   ASSERT_EQ("", err);
  97   ASSERT_TRUE(plan_.more_to_do());
  98
  99   Edge* edge;
 100   edge = plan_.FindWork();
 101   ASSERT_TRUE(edge);  // cat in
 102   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 103
 104   edge = plan_.FindWork();
 105   ASSERT_TRUE(edge);  // cat mid1 mid2
 106   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 107
 108   edge = plan_.FindWork();
 109   ASSERT_FALSE(edge);  // done
 110 }
 111
 112 // Test that two outputs from one rule can eventually be routed to another.
 113 TEST_F(PlanTest, DoubleOutputIndirect) {
 114   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 115 "build out: cat b1 b2\n"
 116 "build b1: cat a1\n"
 117 "build b2: cat a2\n"
 118 "build a1 a2: cat in\n"));
 119   GetNode("a1")->MarkDirty();
 120   GetNode("a2")->MarkDirty();
 121   GetNode("b1")->MarkDirty();
 122   GetNode("b2")->MarkDirty();
 123   GetNode("out")->MarkDirty();
 124   string err;
 125   EXPECT_TRUE(plan_.AddTarget(GetNode("out"), &err));
 126   ASSERT_EQ("", err);
 127   ASSERT_TRUE(plan_.more_to_do());
 128
 129   Edge* edge;
 130   edge = plan_.FindWork();
 131   ASSERT_TRUE(edge);  // cat in
 132   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 133
 134   edge = plan_.FindWork();
 135   ASSERT_TRUE(edge);  // cat a1
 136   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 137
 138   edge = plan_.FindWork();
 139   ASSERT_TRUE(edge);  // cat a2
 140   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 141
 142   edge = plan_.FindWork();
 143   ASSERT_TRUE(edge);  // cat b1 b2
 144   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 145
 146   edge = plan_.FindWork();
 147   ASSERT_FALSE(edge);  // done
 148 }
 149
 150 // Test that two edges from one output can both execute.
 151 TEST_F(PlanTest, DoubleDependent) {
 152   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 153 "build out: cat a1 a2\n"
 154 "build a1: cat mid\n"
 155 "build a2: cat mid\n"
 156 "build mid: cat in\n"));
 157   GetNode("mid")->MarkDirty();
 158   GetNode("a1")->MarkDirty();
 159   GetNode("a2")->MarkDirty();
 160   GetNode("out")->MarkDirty();
 161
 162   string err;
 163   EXPECT_TRUE(plan_.AddTarget(GetNode("out"), &err));
 164   ASSERT_EQ("", err);
 165   ASSERT_TRUE(plan_.more_to_do());
 166
 167   Edge* edge;
 168   edge = plan_.FindWork();
 169   ASSERT_TRUE(edge);  // cat in
 170   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 171
 172   edge = plan_.FindWork();
 173   ASSERT_TRUE(edge);  // cat mid
 174   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 175
 176   edge = plan_.FindWork();
 177   ASSERT_TRUE(edge);  // cat mid
 178   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 179
 180   edge = plan_.FindWork();
 181   ASSERT_TRUE(edge);  // cat a1 a2
 182   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 183
 184   edge = plan_.FindWork();
 185   ASSERT_FALSE(edge);  // done
 186 }
 187
 188 TEST_F(PlanTest, DependencyCycle) {
 189   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 190 "build out: cat mid\n"
 191 "build mid: cat in\n"
 192 "build in: cat pre\n"
 193 "build pre: cat out\n"));
 194   GetNode("out")->MarkDirty();
 195   GetNode("mid")->MarkDirty();
 196   GetNode("in")->MarkDirty();
 197   GetNode("pre")->MarkDirty();
 198
 199   string err;
 200   EXPECT_FALSE(plan_.AddTarget(GetNode("out"), &err));
 201   ASSERT_EQ("dependency cycle: out -> mid -> in -> pre -> out", err);
 202 }
 203
 204 TEST_F(PlanTest, CycleInEdgesButNotInNodes1) {
 205   string err;
 206   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 207 "build a b: cat a\n"));
 208   EXPECT_FALSE(plan_.AddTarget(GetNode("b"), &err));
 209   ASSERT_EQ("dependency cycle: a -> a", err);
 210 }
 211
 212 TEST_F(PlanTest, CycleInEdgesButNotInNodes2) {
 213   string err;
 214   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 215 "build b a: cat a\n"));
 216   EXPECT_FALSE(plan_.AddTarget(GetNode("b"), &err));
 217   ASSERT_EQ("dependency cycle: a -> a", err);
 218 }
 219
 220 TEST_F(PlanTest, CycleInEdgesButNotInNodes3) {
 221   string err;
 222   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 223 "build a b: cat c\n"
 224 "build c: cat a\n"));
 225   EXPECT_FALSE(plan_.AddTarget(GetNode("b"), &err));
 226   ASSERT_EQ("dependency cycle: c -> a -> c", err);
 227 }
 228
 229 TEST_F(PlanTest, CycleInEdgesButNotInNodes4) {
 230   string err;
 231   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 232 "build d: cat c\n"
 233 "build c: cat b\n"
 234 "build b: cat a\n"
 235 "build a e: cat d\n"
 236 "build f: cat e\n"));
 237   EXPECT_FALSE(plan_.AddTarget(GetNode("f"), &err));
 238   ASSERT_EQ("dependency cycle: d -> c -> b -> a -> d", err);
 239 }
 240
 241 void PlanTest::TestPoolWithDepthOne(const char* test_case) {
 242   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_, test_case));
 243   GetNode("out1")->MarkDirty();
 244   GetNode("out2")->MarkDirty();
 245   string err;
 246   EXPECT_TRUE(plan_.AddTarget(GetNode("out1"), &err));
 247   ASSERT_EQ("", err);
 248   EXPECT_TRUE(plan_.AddTarget(GetNode("out2"), &err));
 249   ASSERT_EQ("", err);
 250   ASSERT_TRUE(plan_.more_to_do());
 251
 252   Edge* edge = plan_.FindWork();
 253   ASSERT_TRUE(edge);
 254   ASSERT_EQ("in",  edge->inputs_[0]->path());
 255   ASSERT_EQ("out1", edge->outputs_[0]->path());
 256
 257   // This will be false since poolcat is serialized
 258   ASSERT_FALSE(plan_.FindWork());
 259
 260   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 261
 262   edge = plan_.FindWork();
 263   ASSERT_TRUE(edge);
 264   ASSERT_EQ("in", edge->inputs_[0]->path());
 265   ASSERT_EQ("out2", edge->outputs_[0]->path());
 266
 267   ASSERT_FALSE(plan_.FindWork());
 268
 269   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 270
 271   ASSERT_FALSE(plan_.more_to_do());
 272   edge = plan_.FindWork();
 273   ASSERT_EQ(0, edge);
 274 }
 275
 276 TEST_F(PlanTest, PoolWithDepthOne) {
 277   TestPoolWithDepthOne(
 278 "pool foobar\n"
 279 "  depth = 1\n"
 280 "rule poolcat\n"
 281 "  command = cat $in > $out\n"
 282 "  pool = foobar\n"
 283 "build out1: poolcat in\n"
 284 "build out2: poolcat in\n");
 285 }
 286
 287 TEST_F(PlanTest, ConsolePool) {
 288   TestPoolWithDepthOne(
 289 "rule poolcat\n"
 290 "  command = cat $in > $out\n"
 291 "  pool = console\n"
 292 "build out1: poolcat in\n"
 293 "build out2: poolcat in\n");
 294 }
 295
 296 TEST_F(PlanTest, PoolsWithDepthTwo) {
 297   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 298 "pool foobar\n"
 299 "  depth = 2\n"
 300 "pool bazbin\n"
 301 "  depth = 2\n"
 302 "rule foocat\n"
 303 "  command = cat $in > $out\n"
 304 "  pool = foobar\n"
 305 "rule bazcat\n"
 306 "  command = cat $in > $out\n"
 307 "  pool = bazbin\n"
 308 "build out1: foocat in\n"
 309 "build out2: foocat in\n"
 310 "build out3: foocat in\n"
 311 "build outb1: bazcat in\n"
 312 "build outb2: bazcat in\n"
 313 "build outb3: bazcat in\n"
 314 "  pool =\n"
 315 "build allTheThings: cat out1 out2 out3 outb1 outb2 outb3\n"
 316 ));
 317   // Mark all the out* nodes dirty
 318   for (int i = 0; i < 3; ++i) {
 319     GetNode("out" + string(1, '1' + static_cast<char>(i)))->MarkDirty();
 320     GetNode("outb" + string(1, '1' + static_cast<char>(i)))->MarkDirty();
 321   }
 322   GetNode("allTheThings")->MarkDirty();
 323
 324   string err;
 325   EXPECT_TRUE(plan_.AddTarget(GetNode("allTheThings"), &err));
 326   ASSERT_EQ("", err);
 327
 328   deque<Edge*> edges;
 329   FindWorkSorted(&edges, 5);
 330
 331   for (int i = 0; i < 4; ++i) {
 332     Edge *edge = edges[i];
 333     ASSERT_EQ("in",  edge->inputs_[0]->path());
 334     string base_name(i < 2 ? "out" : "outb");
 335     ASSERT_EQ(base_name + string(1, '1' + (i % 2)), edge->outputs_[0]->path());
 336   }
 337
 338   // outb3 is exempt because it has an empty pool
 339   Edge* edge = edges[4];
 340   ASSERT_TRUE(edge);
 341   ASSERT_EQ("in",  edge->inputs_[0]->path());
 342   ASSERT_EQ("outb3", edge->outputs_[0]->path());
 343
 344   // finish out1
 345   plan_.EdgeFinished(edges.front(), Plan::kEdgeSucceeded);
 346   edges.pop_front();
 347
 348   // out3 should be available
 349   Edge* out3 = plan_.FindWork();
 350   ASSERT_TRUE(out3);
 351   ASSERT_EQ("in",  out3->inputs_[0]->path());
 352   ASSERT_EQ("out3", out3->outputs_[0]->path());
 353
 354   ASSERT_FALSE(plan_.FindWork());
 355
 356   plan_.EdgeFinished(out3, Plan::kEdgeSucceeded);
 357
 358   ASSERT_FALSE(plan_.FindWork());
 359
 360   for (deque<Edge*>::iterator it = edges.begin(); it != edges.end(); ++it) {
 361     plan_.EdgeFinished(*it, Plan::kEdgeSucceeded);
 362   }
 363
 364   Edge* last = plan_.FindWork();
 365   ASSERT_TRUE(last);
 366   ASSERT_EQ("allTheThings", last->outputs_[0]->path());
 367
 368   plan_.EdgeFinished(last, Plan::kEdgeSucceeded);
 369
 370   ASSERT_FALSE(plan_.more_to_do());
 371   ASSERT_FALSE(plan_.FindWork());
 372 }
 373
 374 TEST_F(PlanTest, PoolWithRedundantEdges) {
 375   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 376     "pool compile\n"
 377     "  depth = 1\n"
 378     "rule gen_foo\n"
 379     "  command = touch foo.cpp\n"
 380     "rule gen_bar\n"
 381     "  command = touch bar.cpp\n"
 382     "rule echo\n"
 383     "  command = echo $out > $out\n"
 384     "build foo.cpp.obj: echo foo.cpp || foo.cpp\n"
 385     "  pool = compile\n"
 386     "build bar.cpp.obj: echo bar.cpp || bar.cpp\n"
 387     "  pool = compile\n"
 388     "build libfoo.a: echo foo.cpp.obj bar.cpp.obj\n"
 389     "build foo.cpp: gen_foo\n"
 390     "build bar.cpp: gen_bar\n"
 391     "build all: phony libfoo.a\n"));
 392   GetNode("foo.cpp")->MarkDirty();
 393   GetNode("foo.cpp.obj")->MarkDirty();
 394   GetNode("bar.cpp")->MarkDirty();
 395   GetNode("bar.cpp.obj")->MarkDirty();
 396   GetNode("libfoo.a")->MarkDirty();
 397   GetNode("all")->MarkDirty();
 398   string err;
 399   EXPECT_TRUE(plan_.AddTarget(GetNode("all"), &err));
 400   ASSERT_EQ("", err);
 401   ASSERT_TRUE(plan_.more_to_do());
 402
 403   Edge* edge = NULL;
 404
 405   deque<Edge*> initial_edges;
 406   FindWorkSorted(&initial_edges, 2);
 407
 408   edge = initial_edges[1];  // Foo first
 409   ASSERT_EQ("foo.cpp", edge->outputs_[0]->path());
 410   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 411
 412   edge = plan_.FindWork();
 413   ASSERT_TRUE(edge);
 414   ASSERT_FALSE(plan_.FindWork());
 415   ASSERT_EQ("foo.cpp", edge->inputs_[0]->path());
 416   ASSERT_EQ("foo.cpp", edge->inputs_[1]->path());
 417   ASSERT_EQ("foo.cpp.obj", edge->outputs_[0]->path());
 418   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 419
 420   edge = initial_edges[0];  // Now for bar
 421   ASSERT_EQ("bar.cpp", edge->outputs_[0]->path());
 422   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 423
 424   edge = plan_.FindWork();
 425   ASSERT_TRUE(edge);
 426   ASSERT_FALSE(plan_.FindWork());
 427   ASSERT_EQ("bar.cpp", edge->inputs_[0]->path());
 428   ASSERT_EQ("bar.cpp", edge->inputs_[1]->path());
 429   ASSERT_EQ("bar.cpp.obj", edge->outputs_[0]->path());
 430   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 431
 432   edge = plan_.FindWork();
 433   ASSERT_TRUE(edge);
 434   ASSERT_FALSE(plan_.FindWork());
 435   ASSERT_EQ("foo.cpp.obj", edge->inputs_[0]->path());
 436   ASSERT_EQ("bar.cpp.obj", edge->inputs_[1]->path());
 437   ASSERT_EQ("libfoo.a", edge->outputs_[0]->path());
 438   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 439
 440   edge = plan_.FindWork();
 441   ASSERT_TRUE(edge);
 442   ASSERT_FALSE(plan_.FindWork());
 443   ASSERT_EQ("libfoo.a", edge->inputs_[0]->path());
 444   ASSERT_EQ("all", edge->outputs_[0]->path());
 445   plan_.EdgeFinished(edge, Plan::kEdgeSucceeded);
 446
 447   edge = plan_.FindWork();
 448   ASSERT_FALSE(edge);
 449   ASSERT_FALSE(plan_.more_to_do());
 450 }
 451
 452 TEST_F(PlanTest, PoolWithFailingEdge) {
 453   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 454     "pool foobar\n"
 455     "  depth = 1\n"
 456     "rule poolcat\n"
 457     "  command = cat $in > $out\n"
 458     "  pool = foobar\n"
 459     "build out1: poolcat in\n"
 460     "build out2: poolcat in\n"));
 461   GetNode("out1")->MarkDirty();
 462   GetNode("out2")->MarkDirty();
 463   string err;
 464   EXPECT_TRUE(plan_.AddTarget(GetNode("out1"), &err));
 465   ASSERT_EQ("", err);
 466   EXPECT_TRUE(plan_.AddTarget(GetNode("out2"), &err));
 467   ASSERT_EQ("", err);
 468   ASSERT_TRUE(plan_.more_to_do());
 469
 470   Edge* edge = plan_.FindWork();
 471   ASSERT_TRUE(edge);
 472   ASSERT_EQ("in",  edge->inputs_[0]->path());
 473   ASSERT_EQ("out1", edge->outputs_[0]->path());
 474
 475   // This will be false since poolcat is serialized
 476   ASSERT_FALSE(plan_.FindWork());
 477
 478   plan_.EdgeFinished(edge, Plan::kEdgeFailed);
 479
 480   edge = plan_.FindWork();
 481   ASSERT_TRUE(edge);
 482   ASSERT_EQ("in", edge->inputs_[0]->path());
 483   ASSERT_EQ("out2", edge->outputs_[0]->path());
 484
 485   ASSERT_FALSE(plan_.FindWork());
 486
 487   plan_.EdgeFinished(edge, Plan::kEdgeFailed);
 488
 489   ASSERT_TRUE(plan_.more_to_do()); // Jobs have failed
 490   edge = plan_.FindWork();
 491   ASSERT_EQ(0, edge);
 492 }
 493
 494 /// Fake implementation of CommandRunner, useful for tests.
 495 struct FakeCommandRunner : public CommandRunner {
 496   explicit FakeCommandRunner(VirtualFileSystem* fs) :
 497       last_command_(NULL), fs_(fs) {}
 498
 499   // CommandRunner impl
 500   virtual bool CanRunMore();
 501   virtual bool StartCommand(Edge* edge);
 502   virtual bool WaitForCommand(Result* result);
 503   virtual vector<Edge*> GetActiveEdges();
 504   virtual void Abort();
 505
 506   vector<string> commands_ran_;
 507   Edge* last_command_;
 508   VirtualFileSystem* fs_;
 509 };
 510
 511 struct BuildTest : public StateTestWithBuiltinRules, public BuildLogUser {
 512   BuildTest() : config_(MakeConfig()), command_runner_(&fs_),
 513                 builder_(&state_, config_, NULL, NULL, &fs_),
 514                 status_(config_) {
 515   }
 516
 517   virtual void SetUp() {
 518     StateTestWithBuiltinRules::SetUp();
 519
 520     builder_.command_runner_.reset(&command_runner_);
 521     AssertParse(&state_,
 522 "build cat1: cat in1\n"
 523 "build cat2: cat in1 in2\n"
 524 "build cat12: cat cat1 cat2\n");
 525
 526     fs_.Create("in1", "");
 527     fs_.Create("in2", "");
 528   }
 529
 530   ~BuildTest() {
 531     builder_.command_runner_.release();
 532   }
 533
 534   virtual bool IsPathDead(StringPiece s) const { return false; }
 535
 536   /// Rebuild target in the 'working tree' (fs_).
 537   /// State of command_runner_ and logs contents (if specified) ARE MODIFIED.
 538   /// Handy to check for NOOP builds, and higher-level rebuild tests.
 539   void RebuildTarget(const string& target, const char* manifest,
 540                      const char* log_path = NULL, const char* deps_path = NULL,
 541                      State* state = NULL);
 542
 543   // Mark a path dirty.
 544   void Dirty(const string& path);
 545
 546   BuildConfig MakeConfig() {
 547     BuildConfig config;
 548     config.verbosity = BuildConfig::QUIET;
 549     return config;
 550   }
 551
 552   BuildConfig config_;
 553   FakeCommandRunner command_runner_;
 554   VirtualFileSystem fs_;
 555   Builder builder_;
 556
 557   BuildStatus status_;
 558 };
 559
 560 void BuildTest::RebuildTarget(const string& target, const char* manifest,
 561                               const char* log_path, const char* deps_path,
 562                               State* state) {
 563   State local_state, *pstate = &local_state;
 564   if (state)
 565     pstate = state;
 566   ASSERT_NO_FATAL_FAILURE(AddCatRule(pstate));
 567   AssertParse(pstate, manifest);
 568
 569   string err;
 570   BuildLog build_log, *pbuild_log = NULL;
 571   if (log_path) {
 572     ASSERT_TRUE(build_log.Load(log_path, &err));
 573     ASSERT_TRUE(build_log.OpenForWrite(log_path, *this, &err));
 574     ASSERT_EQ("", err);
 575     pbuild_log = &build_log;
 576   }
 577
 578   DepsLog deps_log, *pdeps_log = NULL;
 579   if (deps_path) {
 580     ASSERT_TRUE(deps_log.Load(deps_path, pstate, &err));
 581     ASSERT_TRUE(deps_log.OpenForWrite(deps_path, &err));
 582     ASSERT_EQ("", err);
 583     pdeps_log = &deps_log;
 584   }
 585
 586   Builder builder(pstate, config_, pbuild_log, pdeps_log, &fs_);
 587   EXPECT_TRUE(builder.AddTarget(target, &err));
 588
 589   command_runner_.commands_ran_.clear();
 590   builder.command_runner_.reset(&command_runner_);
 591   if (!builder.AlreadyUpToDate()) {
 592     bool build_res = builder.Build(&err);
 593     EXPECT_TRUE(build_res);
 594   }
 595   builder.command_runner_.release();
 596 }
 597
 598 bool FakeCommandRunner::CanRunMore() {
 599   // Only run one at a time.
 600   return last_command_ == NULL;
 601 }
 602
 603 bool FakeCommandRunner::StartCommand(Edge* edge) {
 604   assert(!last_command_);
 605   commands_ran_.push_back(edge->EvaluateCommand());
 606   if (edge->rule().name() == "cat"  ||
 607       edge->rule().name() == "cat_rsp" ||
 608       edge->rule().name() == "cat_rsp_out" ||
 609       edge->rule().name() == "cc" ||
 610       edge->rule().name() == "touch" ||
 611       edge->rule().name() == "touch-interrupt") {
 612     for (vector<Node*>::iterator out = edge->outputs_.begin();
 613          out != edge->outputs_.end(); ++out) {
 614       fs_->Create((*out)->path(), "");
 615     }
 616   } else if (edge->rule().name() == "true" ||
 617              edge->rule().name() == "fail" ||
 618              edge->rule().name() == "interrupt" ||
 619              edge->rule().name() == "console") {
 620     // Don't do anything.
 621   } else {
 622     printf("unknown command\n");
 623     return false;
 624   }
 625
 626   last_command_ = edge;
 627   return true;
 628 }
 629
 630 bool FakeCommandRunner::WaitForCommand(Result* result) {
 631   if (!last_command_)
 632     return false;
 633
 634   Edge* edge = last_command_;
 635   result->edge = edge;
 636
 637   if (edge->rule().name() == "interrupt" ||
 638       edge->rule().name() == "touch-interrupt") {
 639     result->status = ExitInterrupted;
 640     return true;
 641   }
 642
 643   if (edge->rule().name() == "console") {
 644     if (edge->use_console())
 645       result->status = ExitSuccess;
 646     else
 647       result->status = ExitFailure;
 648     last_command_ = NULL;
 649     return true;
 650   }
 651
 652   if (edge->rule().name() == "fail")
 653     result->status = ExitFailure;
 654   else
 655     result->status = ExitSuccess;
 656   last_command_ = NULL;
 657   return true;
 658 }
 659
 660 vector<Edge*> FakeCommandRunner::GetActiveEdges() {
 661   vector<Edge*> edges;
 662   if (last_command_)
 663     edges.push_back(last_command_);
 664   return edges;
 665 }
 666
 667 void FakeCommandRunner::Abort() {
 668   last_command_ = NULL;
 669 }
 670
 671 void BuildTest::Dirty(const string& path) {
 672   Node* node = GetNode(path);
 673   node->MarkDirty();
 674
 675   // If it's an input file, mark that we've already stat()ed it and
 676   // it's missing.
 677   if (!node->in_edge())
 678     node->MarkMissing();
 679 }
 680
 681 TEST_F(BuildTest, NoWork) {
 682   string err;
 683   EXPECT_TRUE(builder_.AlreadyUpToDate());
 684 }
 685
 686 TEST_F(BuildTest, OneStep) {
 687   // Given a dirty target with one ready input,
 688   // we should rebuild the target.
 689   Dirty("cat1");
 690   string err;
 691   EXPECT_TRUE(builder_.AddTarget("cat1", &err));
 692   ASSERT_EQ("", err);
 693   EXPECT_TRUE(builder_.Build(&err));
 694   ASSERT_EQ("", err);
 695
 696   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 697   EXPECT_EQ("cat in1 > cat1", command_runner_.commands_ran_[0]);
 698 }
 699
 700 TEST_F(BuildTest, OneStep2) {
 701   // Given a target with one dirty input,
 702   // we should rebuild the target.
 703   Dirty("cat1");
 704   string err;
 705   EXPECT_TRUE(builder_.AddTarget("cat1", &err));
 706   ASSERT_EQ("", err);
 707   EXPECT_TRUE(builder_.Build(&err));
 708   EXPECT_EQ("", err);
 709
 710   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 711   EXPECT_EQ("cat in1 > cat1", command_runner_.commands_ran_[0]);
 712 }
 713
 714 TEST_F(BuildTest, TwoStep) {
 715   string err;
 716   EXPECT_TRUE(builder_.AddTarget("cat12", &err));
 717   ASSERT_EQ("", err);
 718   EXPECT_TRUE(builder_.Build(&err));
 719   EXPECT_EQ("", err);
 720   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
 721   // Depending on how the pointers work out, we could've ran
 722   // the first two commands in either order.
 723   EXPECT_TRUE((command_runner_.commands_ran_[0] == "cat in1 > cat1" &&
 724                command_runner_.commands_ran_[1] == "cat in1 in2 > cat2") ||
 725               (command_runner_.commands_ran_[1] == "cat in1 > cat1" &&
 726                command_runner_.commands_ran_[0] == "cat in1 in2 > cat2"));
 727
 728   EXPECT_EQ("cat cat1 cat2 > cat12", command_runner_.commands_ran_[2]);
 729
 730   fs_.Tick();
 731
 732   // Modifying in2 requires rebuilding one intermediate file
 733   // and the final file.
 734   fs_.Create("in2", "");
 735   state_.Reset();
 736   EXPECT_TRUE(builder_.AddTarget("cat12", &err));
 737   ASSERT_EQ("", err);
 738   EXPECT_TRUE(builder_.Build(&err));
 739   ASSERT_EQ("", err);
 740   ASSERT_EQ(5u, command_runner_.commands_ran_.size());
 741   EXPECT_EQ("cat in1 in2 > cat2", command_runner_.commands_ran_[3]);
 742   EXPECT_EQ("cat cat1 cat2 > cat12", command_runner_.commands_ran_[4]);
 743 }
 744
 745 TEST_F(BuildTest, TwoOutputs) {
 746   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 747 "rule touch\n"
 748 "  command = touch $out\n"
 749 "build out1 out2: touch in.txt\n"));
 750
 751   fs_.Create("in.txt", "");
 752
 753   string err;
 754   EXPECT_TRUE(builder_.AddTarget("out1", &err));
 755   ASSERT_EQ("", err);
 756   EXPECT_TRUE(builder_.Build(&err));
 757   EXPECT_EQ("", err);
 758   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 759   EXPECT_EQ("touch out1 out2", command_runner_.commands_ran_[0]);
 760 }
 761
 762 TEST_F(BuildTest, ImplicitOutput) {
 763   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 764 "rule touch\n"
 765 "  command = touch $out $out.imp\n"
 766 "build out | out.imp: touch in.txt\n"));
 767   fs_.Create("in.txt", "");
 768
 769   string err;
 770   EXPECT_TRUE(builder_.AddTarget("out.imp", &err));
 771   ASSERT_EQ("", err);
 772   EXPECT_TRUE(builder_.Build(&err));
 773   EXPECT_EQ("", err);
 774   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 775   EXPECT_EQ("touch out out.imp", command_runner_.commands_ran_[0]);
 776 }
 777
 778 // Test case from
 779 //   https://github.com/ninja-build/ninja/issues/148
 780 TEST_F(BuildTest, MultiOutIn) {
 781   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 782 "rule touch\n"
 783 "  command = touch $out\n"
 784 "build in1 otherfile: touch in\n"
 785 "build out: touch in | in1\n"));
 786
 787   fs_.Create("in", "");
 788   fs_.Tick();
 789   fs_.Create("in1", "");
 790
 791   string err;
 792   EXPECT_TRUE(builder_.AddTarget("out", &err));
 793   ASSERT_EQ("", err);
 794   EXPECT_TRUE(builder_.Build(&err));
 795   EXPECT_EQ("", err);
 796 }
 797
 798 TEST_F(BuildTest, Chain) {
 799   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 800 "build c2: cat c1\n"
 801 "build c3: cat c2\n"
 802 "build c4: cat c3\n"
 803 "build c5: cat c4\n"));
 804
 805   fs_.Create("c1", "");
 806
 807   string err;
 808   EXPECT_TRUE(builder_.AddTarget("c5", &err));
 809   ASSERT_EQ("", err);
 810   EXPECT_TRUE(builder_.Build(&err));
 811   EXPECT_EQ("", err);
 812   ASSERT_EQ(4u, command_runner_.commands_ran_.size());
 813
 814   err.clear();
 815   command_runner_.commands_ran_.clear();
 816   state_.Reset();
 817   EXPECT_TRUE(builder_.AddTarget("c5", &err));
 818   ASSERT_EQ("", err);
 819   EXPECT_TRUE(builder_.AlreadyUpToDate());
 820
 821   fs_.Tick();
 822
 823   fs_.Create("c3", "");
 824   err.clear();
 825   command_runner_.commands_ran_.clear();
 826   state_.Reset();
 827   EXPECT_TRUE(builder_.AddTarget("c5", &err));
 828   ASSERT_EQ("", err);
 829   EXPECT_FALSE(builder_.AlreadyUpToDate());
 830   EXPECT_TRUE(builder_.Build(&err));
 831   ASSERT_EQ(2u, command_runner_.commands_ran_.size());  // 3->4, 4->5
 832 }
 833
 834 TEST_F(BuildTest, MissingInput) {
 835   // Input is referenced by build file, but no rule for it.
 836   string err;
 837   Dirty("in1");
 838   EXPECT_FALSE(builder_.AddTarget("cat1", &err));
 839   EXPECT_EQ("'in1', needed by 'cat1', missing and no known rule to make it",
 840             err);
 841 }
 842
 843 TEST_F(BuildTest, MissingTarget) {
 844   // Target is not referenced by build file.
 845   string err;
 846   EXPECT_FALSE(builder_.AddTarget("meow", &err));
 847   EXPECT_EQ("unknown target: 'meow'", err);
 848 }
 849
 850 TEST_F(BuildTest, MakeDirs) {
 851   string err;
 852
 853 #ifdef _WIN32
 854   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 855                                       "build subdir\\dir2\\file: cat in1\n"));
 856 #else
 857   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 858                                       "build subdir/dir2/file: cat in1\n"));
 859 #endif
 860   EXPECT_TRUE(builder_.AddTarget("subdir/dir2/file", &err));
 861
 862   EXPECT_EQ("", err);
 863   EXPECT_TRUE(builder_.Build(&err));
 864   ASSERT_EQ("", err);
 865   ASSERT_EQ(2u, fs_.directories_made_.size());
 866   EXPECT_EQ("subdir", fs_.directories_made_[0]);
 867   EXPECT_EQ("subdir/dir2", fs_.directories_made_[1]);
 868 }
 869
 870 TEST_F(BuildTest, DepFileMissing) {
 871   string err;
 872   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 873 "rule cc\n  command = cc $in\n  depfile = $out.d\n"
 874 "build fo$ o.o: cc foo.c\n"));
 875   fs_.Create("foo.c", "");
 876
 877   EXPECT_TRUE(builder_.AddTarget("fo o.o", &err));
 878   ASSERT_EQ("", err);
 879   ASSERT_EQ(1u, fs_.files_read_.size());
 880   EXPECT_EQ("fo o.o.d", fs_.files_read_[0]);
 881 }
 882
 883 TEST_F(BuildTest, DepFileOK) {
 884   string err;
 885   int orig_edges = state_.edges_.size();
 886   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 887 "rule cc\n  command = cc $in\n  depfile = $out.d\n"
 888 "build foo.o: cc foo.c\n"));
 889   Edge* edge = state_.edges_.back();
 890
 891   fs_.Create("foo.c", "");
 892   GetNode("bar.h")->MarkDirty();  // Mark bar.h as missing.
 893   fs_.Create("foo.o.d", "foo.o: blah.h bar.h\n");
 894   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 895   ASSERT_EQ("", err);
 896   ASSERT_EQ(1u, fs_.files_read_.size());
 897   EXPECT_EQ("foo.o.d", fs_.files_read_[0]);
 898
 899   // Expect three new edges: one generating foo.o, and two more from
 900   // loading the depfile.
 901   ASSERT_EQ(orig_edges + 3, (int)state_.edges_.size());
 902   // Expect our edge to now have three inputs: foo.c and two headers.
 903   ASSERT_EQ(3u, edge->inputs_.size());
 904
 905   // Expect the command line we generate to only use the original input.
 906   ASSERT_EQ("cc foo.c", edge->EvaluateCommand());
 907 }
 908
 909 TEST_F(BuildTest, DepFileParseError) {
 910   string err;
 911   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 912 "rule cc\n  command = cc $in\n  depfile = $out.d\n"
 913 "build foo.o: cc foo.c\n"));
 914   fs_.Create("foo.c", "");
 915   fs_.Create("foo.o.d", "randomtext\n");
 916   EXPECT_FALSE(builder_.AddTarget("foo.o", &err));
 917   EXPECT_EQ("foo.o.d: expected ':' in depfile", err);
 918 }
 919
 920 TEST_F(BuildTest, EncounterReadyTwice) {
 921   string err;
 922   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 923 "rule touch\n"
 924 "  command = touch $out\n"
 925 "build c: touch\n"
 926 "build b: touch || c\n"
 927 "build a: touch | b || c\n"));
 928
 929   vector<Edge*> c_out = GetNode("c")->out_edges();
 930   ASSERT_EQ(2u, c_out.size());
 931   EXPECT_EQ("b", c_out[0]->outputs_[0]->path());
 932   EXPECT_EQ("a", c_out[1]->outputs_[0]->path());
 933
 934   fs_.Create("b", "");
 935   EXPECT_TRUE(builder_.AddTarget("a", &err));
 936   ASSERT_EQ("", err);
 937
 938   EXPECT_TRUE(builder_.Build(&err));
 939   ASSERT_EQ("", err);
 940   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
 941 }
 942
 943 TEST_F(BuildTest, OrderOnlyDeps) {
 944   string err;
 945   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
 946 "rule cc\n  command = cc $in\n  depfile = $out.d\n"
 947 "build foo.o: cc foo.c || otherfile\n"));
 948   Edge* edge = state_.edges_.back();
 949
 950   fs_.Create("foo.c", "");
 951   fs_.Create("otherfile", "");
 952   fs_.Create("foo.o.d", "foo.o: blah.h bar.h\n");
 953   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 954   ASSERT_EQ("", err);
 955
 956   // One explicit, two implicit, one order only.
 957   ASSERT_EQ(4u, edge->inputs_.size());
 958   EXPECT_EQ(2, edge->implicit_deps_);
 959   EXPECT_EQ(1, edge->order_only_deps_);
 960   // Verify the inputs are in the order we expect
 961   // (explicit then implicit then orderonly).
 962   EXPECT_EQ("foo.c", edge->inputs_[0]->path());
 963   EXPECT_EQ("blah.h", edge->inputs_[1]->path());
 964   EXPECT_EQ("bar.h", edge->inputs_[2]->path());
 965   EXPECT_EQ("otherfile", edge->inputs_[3]->path());
 966
 967   // Expect the command line we generate to only use the original input.
 968   ASSERT_EQ("cc foo.c", edge->EvaluateCommand());
 969
 970   // explicit dep dirty, expect a rebuild.
 971   EXPECT_TRUE(builder_.Build(&err));
 972   ASSERT_EQ("", err);
 973   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 974
 975   fs_.Tick();
 976
 977   // Recreate the depfile, as it should have been deleted by the build.
 978   fs_.Create("foo.o.d", "foo.o: blah.h bar.h\n");
 979
 980   // implicit dep dirty, expect a rebuild.
 981   fs_.Create("blah.h", "");
 982   fs_.Create("bar.h", "");
 983   command_runner_.commands_ran_.clear();
 984   state_.Reset();
 985   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
 986   EXPECT_TRUE(builder_.Build(&err));
 987   ASSERT_EQ("", err);
 988   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
 989
 990   fs_.Tick();
 991
 992   // Recreate the depfile, as it should have been deleted by the build.
 993   fs_.Create("foo.o.d", "foo.o: blah.h bar.h\n");
 994
 995   // order only dep dirty, no rebuild.
 996   fs_.Create("otherfile", "");
 997   command_runner_.commands_ran_.clear();
 998   state_.Reset();
 999   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
1000   EXPECT_EQ("", err);
1001   EXPECT_TRUE(builder_.AlreadyUpToDate());
1002
1003   // implicit dep missing, expect rebuild.
1004   fs_.RemoveFile("bar.h");
1005   command_runner_.commands_ran_.clear();
1006   state_.Reset();
1007   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
1008   EXPECT_TRUE(builder_.Build(&err));
1009   ASSERT_EQ("", err);
1010   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1011 }
1012
1013 TEST_F(BuildTest, RebuildOrderOnlyDeps) {
1014   string err;
1015   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1016 "rule cc\n  command = cc $in\n"
1017 "rule true\n  command = true\n"
1018 "build oo.h: cc oo.h.in\n"
1019 "build foo.o: cc foo.c || oo.h\n"));
1020
1021   fs_.Create("foo.c", "");
1022   fs_.Create("oo.h.in", "");
1023
1024   // foo.o and order-only dep dirty, build both.
1025   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
1026   EXPECT_TRUE(builder_.Build(&err));
1027   ASSERT_EQ("", err);
1028   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
1029
1030   // all clean, no rebuild.
1031   command_runner_.commands_ran_.clear();
1032   state_.Reset();
1033   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
1034   EXPECT_EQ("", err);
1035   EXPECT_TRUE(builder_.AlreadyUpToDate());
1036
1037   // order-only dep missing, build it only.
1038   fs_.RemoveFile("oo.h");
1039   command_runner_.commands_ran_.clear();
1040   state_.Reset();
1041   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
1042   EXPECT_TRUE(builder_.Build(&err));
1043   ASSERT_EQ("", err);
1044   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1045   ASSERT_EQ("cc oo.h.in", command_runner_.commands_ran_[0]);
1046
1047   fs_.Tick();
1048
1049   // order-only dep dirty, build it only.
1050   fs_.Create("oo.h.in", "");
1051   command_runner_.commands_ran_.clear();
1052   state_.Reset();
1053   EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
1054   EXPECT_TRUE(builder_.Build(&err));
1055   ASSERT_EQ("", err);
1056   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1057   ASSERT_EQ("cc oo.h.in", command_runner_.commands_ran_[0]);
1058 }
1059
1060 #ifdef _WIN32
1061 TEST_F(BuildTest, DepFileCanonicalize) {
1062   string err;
1063   int orig_edges = state_.edges_.size();
1064   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1065 "rule cc\n  command = cc $in\n  depfile = $out.d\n"
1066 "build gen/stuff\\things/foo.o: cc x\\y/z\\foo.c\n"));
1067   Edge* edge = state_.edges_.back();
1068
1069   fs_.Create("x/y/z/foo.c", "");
1070   GetNode("bar.h")->MarkDirty();  // Mark bar.h as missing.
1071   // Note, different slashes from manifest.
1072   fs_.Create("gen/stuff\\things/foo.o.d",
1073              "gen\\stuff\\things\\foo.o: blah.h bar.h\n");
1074   EXPECT_TRUE(builder_.AddTarget("gen/stuff/things/foo.o", &err));
1075   ASSERT_EQ("", err);
1076   ASSERT_EQ(1u, fs_.files_read_.size());
1077   // The depfile path does not get Canonicalize as it seems unnecessary.
1078   EXPECT_EQ("gen/stuff\\things/foo.o.d", fs_.files_read_[0]);
1079
1080   // Expect three new edges: one generating foo.o, and two more from
1081   // loading the depfile.
1082   ASSERT_EQ(orig_edges + 3, (int)state_.edges_.size());
1083   // Expect our edge to now have three inputs: foo.c and two headers.
1084   ASSERT_EQ(3u, edge->inputs_.size());
1085
1086   // Expect the command line we generate to only use the original input, and
1087   // using the slashes from the manifest.
1088   ASSERT_EQ("cc x\\y/z\\foo.c", edge->EvaluateCommand());
1089 }
1090 #endif
1091
1092 TEST_F(BuildTest, Phony) {
1093   string err;
1094   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1095 "build out: cat bar.cc\n"
1096 "build all: phony out\n"));
1097   fs_.Create("bar.cc", "");
1098
1099   EXPECT_TRUE(builder_.AddTarget("all", &err));
1100   ASSERT_EQ("", err);
1101
1102   // Only one command to run, because phony runs no command.
1103   EXPECT_FALSE(builder_.AlreadyUpToDate());
1104   EXPECT_TRUE(builder_.Build(&err));
1105   ASSERT_EQ("", err);
1106   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1107 }
1108
1109 TEST_F(BuildTest, PhonyNoWork) {
1110   string err;
1111   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1112 "build out: cat bar.cc\n"
1113 "build all: phony out\n"));
1114   fs_.Create("bar.cc", "");
1115   fs_.Create("out", "");
1116
1117   EXPECT_TRUE(builder_.AddTarget("all", &err));
1118   ASSERT_EQ("", err);
1119   EXPECT_TRUE(builder_.AlreadyUpToDate());
1120 }
1121
1122 TEST_F(BuildTest, Fail) {
1123   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1124 "rule fail\n"
1125 "  command = fail\n"
1126 "build out1: fail\n"));
1127
1128   string err;
1129   EXPECT_TRUE(builder_.AddTarget("out1", &err));
1130   ASSERT_EQ("", err);
1131
1132   EXPECT_FALSE(builder_.Build(&err));
1133   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1134   ASSERT_EQ("subcommand failed", err);
1135 }
1136
1137 TEST_F(BuildTest, SwallowFailures) {
1138   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1139 "rule fail\n"
1140 "  command = fail\n"
1141 "build out1: fail\n"
1142 "build out2: fail\n"
1143 "build out3: fail\n"
1144 "build all: phony out1 out2 out3\n"));
1145
1146   // Swallow two failures, die on the third.
1147   config_.failures_allowed = 3;
1148
1149   string err;
1150   EXPECT_TRUE(builder_.AddTarget("all", &err));
1151   ASSERT_EQ("", err);
1152
1153   EXPECT_FALSE(builder_.Build(&err));
1154   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
1155   ASSERT_EQ("subcommands failed", err);
1156 }
1157
1158 TEST_F(BuildTest, SwallowFailuresLimit) {
1159   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1160 "rule fail\n"
1161 "  command = fail\n"
1162 "build out1: fail\n"
1163 "build out2: fail\n"
1164 "build out3: fail\n"
1165 "build final: cat out1 out2 out3\n"));
1166
1167   // Swallow ten failures; we should stop before building final.
1168   config_.failures_allowed = 11;
1169
1170   string err;
1171   EXPECT_TRUE(builder_.AddTarget("final", &err));
1172   ASSERT_EQ("", err);
1173
1174   EXPECT_FALSE(builder_.Build(&err));
1175   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
1176   ASSERT_EQ("cannot make progress due to previous errors", err);
1177 }
1178
1179 TEST_F(BuildTest, SwallowFailuresPool) {
1180   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1181 "pool failpool\n"
1182 "  depth = 1\n"
1183 "rule fail\n"
1184 "  command = fail\n"
1185 "  pool = failpool\n"
1186 "build out1: fail\n"
1187 "build out2: fail\n"
1188 "build out3: fail\n"
1189 "build final: cat out1 out2 out3\n"));
1190
1191   // Swallow ten failures; we should stop before building final.
1192   config_.failures_allowed = 11;
1193
1194   string err;
1195   EXPECT_TRUE(builder_.AddTarget("final", &err));
1196   ASSERT_EQ("", err);
1197
1198   EXPECT_FALSE(builder_.Build(&err));
1199   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
1200   ASSERT_EQ("cannot make progress due to previous errors", err);
1201 }
1202
1203 TEST_F(BuildTest, PoolEdgesReadyButNotWanted) {
1204   fs_.Create("x", "");
1205
1206   const char* manifest =
1207     "pool some_pool\n"
1208     "  depth = 4\n"
1209     "rule touch\n"
1210     "  command = touch $out\n"
1211     "  pool = some_pool\n"
1212     "rule cc\n"
1213     "  command = touch grit\n"
1214     "\n"
1215     "build B.d.stamp: cc | x\n"
1216     "build C.stamp: touch B.d.stamp\n"
1217     "build final.stamp: touch || C.stamp\n";
1218
1219   RebuildTarget("final.stamp", manifest);
1220
1221   fs_.RemoveFile("B.d.stamp");
1222
1223   State save_state;
1224   RebuildTarget("final.stamp", manifest, NULL, NULL, &save_state);
1225   EXPECT_GE(save_state.LookupPool("some_pool")->current_use(), 0);
1226 }
1227
1228 struct BuildWithLogTest : public BuildTest {
1229   BuildWithLogTest() {
1230     builder_.SetBuildLog(&build_log_);
1231   }
1232
1233   BuildLog build_log_;
1234 };
1235
1236 TEST_F(BuildWithLogTest, NotInLogButOnDisk) {
1237   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1238 "rule cc\n"
1239 "  command = cc\n"
1240 "build out1: cc in\n"));
1241
1242   // Create input/output that would be considered up to date when
1243   // not considering the command line hash.
1244   fs_.Create("in", "");
1245   fs_.Create("out1", "");
1246   string err;
1247
1248   // Because it's not in the log, it should not be up-to-date until
1249   // we build again.
1250   EXPECT_TRUE(builder_.AddTarget("out1", &err));
1251   EXPECT_FALSE(builder_.AlreadyUpToDate());
1252
1253   command_runner_.commands_ran_.clear();
1254   state_.Reset();
1255
1256   EXPECT_TRUE(builder_.AddTarget("out1", &err));
1257   EXPECT_TRUE(builder_.Build(&err));
1258   EXPECT_TRUE(builder_.AlreadyUpToDate());
1259 }
1260
1261 TEST_F(BuildWithLogTest, RestatTest) {
1262   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1263 "rule true\n"
1264 "  command = true\n"
1265 "  restat = 1\n"
1266 "rule cc\n"
1267 "  command = cc\n"
1268 "  restat = 1\n"
1269 "build out1: cc in\n"
1270 "build out2: true out1\n"
1271 "build out3: cat out2\n"));
1272
1273   fs_.Create("out1", "");
1274   fs_.Create("out2", "");
1275   fs_.Create("out3", "");
1276
1277   fs_.Tick();
1278
1279   fs_.Create("in", "");
1280
1281   // Do a pre-build so that there's commands in the log for the outputs,
1282   // otherwise, the lack of an entry in the build log will cause out3 to rebuild
1283   // regardless of restat.
1284   string err;
1285   EXPECT_TRUE(builder_.AddTarget("out3", &err));
1286   ASSERT_EQ("", err);
1287   EXPECT_TRUE(builder_.Build(&err));
1288   ASSERT_EQ("", err);
1289   EXPECT_EQ("[3/3]", builder_.status_->FormatProgressStatus("[%s/%t]",
1290       BuildStatus::kEdgeStarted));
1291   command_runner_.commands_ran_.clear();
1292   state_.Reset();
1293
1294   fs_.Tick();
1295
1296   fs_.Create("in", "");
1297   // "cc" touches out1, so we should build out2.  But because "true" does not
1298   // touch out2, we should cancel the build of out3.
1299   EXPECT_TRUE(builder_.AddTarget("out3", &err));
1300   ASSERT_EQ("", err);
1301   EXPECT_TRUE(builder_.Build(&err));
1302   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
1303
1304   // If we run again, it should be a no-op, because the build log has recorded
1305   // that we've already built out2 with an input timestamp of 2 (from out1).
1306   command_runner_.commands_ran_.clear();
1307   state_.Reset();
1308   EXPECT_TRUE(builder_.AddTarget("out3", &err));
1309   ASSERT_EQ("", err);
1310   EXPECT_TRUE(builder_.AlreadyUpToDate());
1311
1312   fs_.Tick();
1313
1314   fs_.Create("in", "");
1315
1316   // The build log entry should not, however, prevent us from rebuilding out2
1317   // if out1 changes.
1318   command_runner_.commands_ran_.clear();
1319   state_.Reset();
1320   EXPECT_TRUE(builder_.AddTarget("out3", &err));
1321   ASSERT_EQ("", err);
1322   EXPECT_TRUE(builder_.Build(&err));
1323   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
1324 }
1325
1326 TEST_F(BuildWithLogTest, RestatMissingFile) {
1327   // If a restat rule doesn't create its output, and the output didn't
1328   // exist before the rule was run, consider that behavior equivalent
1329   // to a rule that doesn't modify its existent output file.
1330
1331   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1332 "rule true\n"
1333 "  command = true\n"
1334 "  restat = 1\n"
1335 "rule cc\n"
1336 "  command = cc\n"
1337 "build out1: true in\n"
1338 "build out2: cc out1\n"));
1339
1340   fs_.Create("in", "");
1341   fs_.Create("out2", "");
1342
1343   // Do a pre-build so that there's commands in the log for the outputs,
1344   // otherwise, the lack of an entry in the build log will cause out2 to rebuild
1345   // regardless of restat.
1346   string err;
1347   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1348   ASSERT_EQ("", err);
1349   EXPECT_TRUE(builder_.Build(&err));
1350   ASSERT_EQ("", err);
1351   command_runner_.commands_ran_.clear();
1352   state_.Reset();
1353
1354   fs_.Tick();
1355   fs_.Create("in", "");
1356   fs_.Create("out2", "");
1357
1358   // Run a build, expect only the first command to run.
1359   // It doesn't touch its output (due to being the "true" command), so
1360   // we shouldn't run the dependent build.
1361   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1362   ASSERT_EQ("", err);
1363   EXPECT_TRUE(builder_.Build(&err));
1364   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1365 }
1366
1367 TEST_F(BuildWithLogTest, RestatSingleDependentOutputDirty) {
1368   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1369     "rule true\n"
1370     "  command = true\n"
1371     "  restat = 1\n"
1372     "rule touch\n"
1373     "  command = touch\n"
1374     "build out1: true in\n"
1375     "build out2 out3: touch out1\n"
1376     "build out4: touch out2\n"
1377     ));
1378
1379   // Create the necessary files
1380   fs_.Create("in", "");
1381
1382   string err;
1383   EXPECT_TRUE(builder_.AddTarget("out4", &err));
1384   ASSERT_EQ("", err);
1385   EXPECT_TRUE(builder_.Build(&err));
1386   ASSERT_EQ("", err);
1387   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
1388
1389   fs_.Tick();
1390   fs_.Create("in", "");
1391   fs_.RemoveFile("out3");
1392
1393   // Since "in" is missing, out1 will be built. Since "out3" is missing,
1394   // out2 and out3 will be built even though "in" is not touched when built.
1395   // Then, since out2 is rebuilt, out4 should be rebuilt -- the restat on the
1396   // "true" rule should not lead to the "touch" edge writing out2 and out3 being
1397   // cleard.
1398   command_runner_.commands_ran_.clear();
1399   state_.Reset();
1400   EXPECT_TRUE(builder_.AddTarget("out4", &err));
1401   ASSERT_EQ("", err);
1402   EXPECT_TRUE(builder_.Build(&err));
1403   ASSERT_EQ("", err);
1404   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
1405 }
1406
1407 // Test scenario, in which an input file is removed, but output isn't changed
1408 // https://github.com/ninja-build/ninja/issues/295
1409 TEST_F(BuildWithLogTest, RestatMissingInput) {
1410   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1411     "rule true\n"
1412     "  command = true\n"
1413     "  depfile = $out.d\n"
1414     "  restat = 1\n"
1415     "rule cc\n"
1416     "  command = cc\n"
1417     "build out1: true in\n"
1418     "build out2: cc out1\n"));
1419
1420   // Create all necessary files
1421   fs_.Create("in", "");
1422
1423   // The implicit dependencies and the depfile itself
1424   // are newer than the output
1425   TimeStamp restat_mtime = fs_.Tick();
1426   fs_.Create("out1.d", "out1: will.be.deleted restat.file\n");
1427   fs_.Create("will.be.deleted", "");
1428   fs_.Create("restat.file", "");
1429
1430   // Run the build, out1 and out2 get built
1431   string err;
1432   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1433   ASSERT_EQ("", err);
1434   EXPECT_TRUE(builder_.Build(&err));
1435   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
1436
1437   // See that an entry in the logfile is created, capturing
1438   // the right mtime
1439   BuildLog::LogEntry* log_entry = build_log_.LookupByOutput("out1");
1440   ASSERT_TRUE(NULL != log_entry);
1441   ASSERT_EQ(restat_mtime, log_entry->restat_mtime);
1442
1443   // Now remove a file, referenced from depfile, so that target becomes
1444   // dirty, but the output does not change
1445   fs_.RemoveFile("will.be.deleted");
1446
1447   // Trigger the build again - only out1 gets built
1448   command_runner_.commands_ran_.clear();
1449   state_.Reset();
1450   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1451   ASSERT_EQ("", err);
1452   EXPECT_TRUE(builder_.Build(&err));
1453   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1454
1455   // Check that the logfile entry remains correctly set
1456   log_entry = build_log_.LookupByOutput("out1");
1457   ASSERT_TRUE(NULL != log_entry);
1458   ASSERT_EQ(restat_mtime, log_entry->restat_mtime);
1459 }
1460
1461 struct BuildDryRun : public BuildWithLogTest {
1462   BuildDryRun() {
1463     config_.dry_run = true;
1464   }
1465 };
1466
1467 TEST_F(BuildDryRun, AllCommandsShown) {
1468   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1469 "rule true\n"
1470 "  command = true\n"
1471 "  restat = 1\n"
1472 "rule cc\n"
1473 "  command = cc\n"
1474 "  restat = 1\n"
1475 "build out1: cc in\n"
1476 "build out2: true out1\n"
1477 "build out3: cat out2\n"));
1478
1479   fs_.Create("out1", "");
1480   fs_.Create("out2", "");
1481   fs_.Create("out3", "");
1482
1483   fs_.Tick();
1484
1485   fs_.Create("in", "");
1486
1487   // "cc" touches out1, so we should build out2.  But because "true" does not
1488   // touch out2, we should cancel the build of out3.
1489   string err;
1490   EXPECT_TRUE(builder_.AddTarget("out3", &err));
1491   ASSERT_EQ("", err);
1492   EXPECT_TRUE(builder_.Build(&err));
1493   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
1494 }
1495
1496 // Test that RSP files are created when & where appropriate and deleted after
1497 // successful execution.
1498 TEST_F(BuildTest, RspFileSuccess)
1499 {
1500   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1501     "rule cat_rsp\n"
1502     "  command = cat $rspfile > $out\n"
1503     "  rspfile = $rspfile\n"
1504     "  rspfile_content = $long_command\n"
1505     "rule cat_rsp_out\n"
1506     "  command = cat $rspfile > $out\n"
1507     "  rspfile = $out.rsp\n"
1508     "  rspfile_content = $long_command\n"
1509     "build out1: cat in\n"
1510     "build out2: cat_rsp in\n"
1511     "  rspfile = out 2.rsp\n"
1512     "  long_command = Some very long command\n"
1513     "build out$ 3: cat_rsp_out in\n"
1514     "  long_command = Some very long command\n"));
1515
1516   fs_.Create("out1", "");
1517   fs_.Create("out2", "");
1518   fs_.Create("out 3", "");
1519
1520   fs_.Tick();
1521
1522   fs_.Create("in", "");
1523
1524   string err;
1525   EXPECT_TRUE(builder_.AddTarget("out1", &err));
1526   ASSERT_EQ("", err);
1527   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1528   ASSERT_EQ("", err);
1529   EXPECT_TRUE(builder_.AddTarget("out 3", &err));
1530   ASSERT_EQ("", err);
1531
1532   size_t files_created = fs_.files_created_.size();
1533   size_t files_removed = fs_.files_removed_.size();
1534
1535   EXPECT_TRUE(builder_.Build(&err));
1536   ASSERT_EQ(3u, command_runner_.commands_ran_.size());
1537
1538   // The RSP files were created
1539   ASSERT_EQ(files_created + 2, fs_.files_created_.size());
1540   ASSERT_EQ(1u, fs_.files_created_.count("out 2.rsp"));
1541   ASSERT_EQ(1u, fs_.files_created_.count("out 3.rsp"));
1542
1543   // The RSP files were removed
1544   ASSERT_EQ(files_removed + 2, fs_.files_removed_.size());
1545   ASSERT_EQ(1u, fs_.files_removed_.count("out 2.rsp"));
1546   ASSERT_EQ(1u, fs_.files_removed_.count("out 3.rsp"));
1547 }
1548
1549 // Test that RSP file is created but not removed for commands, which fail
1550 TEST_F(BuildTest, RspFileFailure) {
1551   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1552     "rule fail\n"
1553     "  command = fail\n"
1554     "  rspfile = $rspfile\n"
1555     "  rspfile_content = $long_command\n"
1556     "build out: fail in\n"
1557     "  rspfile = out.rsp\n"
1558     "  long_command = Another very long command\n"));
1559
1560   fs_.Create("out", "");
1561   fs_.Tick();
1562   fs_.Create("in", "");
1563
1564   string err;
1565   EXPECT_TRUE(builder_.AddTarget("out", &err));
1566   ASSERT_EQ("", err);
1567
1568   size_t files_created = fs_.files_created_.size();
1569   size_t files_removed = fs_.files_removed_.size();
1570
1571   EXPECT_FALSE(builder_.Build(&err));
1572   ASSERT_EQ("subcommand failed", err);
1573   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1574
1575   // The RSP file was created
1576   ASSERT_EQ(files_created + 1, fs_.files_created_.size());
1577   ASSERT_EQ(1u, fs_.files_created_.count("out.rsp"));
1578
1579   // The RSP file was NOT removed
1580   ASSERT_EQ(files_removed, fs_.files_removed_.size());
1581   ASSERT_EQ(0u, fs_.files_removed_.count("out.rsp"));
1582
1583   // The RSP file contains what it should
1584   ASSERT_EQ("Another very long command", fs_.files_["out.rsp"].contents);
1585 }
1586
1587 // Test that contents of the RSP file behaves like a regular part of
1588 // command line, i.e. triggers a rebuild if changed
1589 TEST_F(BuildWithLogTest, RspFileCmdLineChange) {
1590   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1591     "rule cat_rsp\n"
1592     "  command = cat $rspfile > $out\n"
1593     "  rspfile = $rspfile\n"
1594     "  rspfile_content = $long_command\n"
1595     "build out: cat_rsp in\n"
1596     "  rspfile = out.rsp\n"
1597     "  long_command = Original very long command\n"));
1598
1599   fs_.Create("out", "");
1600   fs_.Tick();
1601   fs_.Create("in", "");
1602
1603   string err;
1604   EXPECT_TRUE(builder_.AddTarget("out", &err));
1605   ASSERT_EQ("", err);
1606
1607   // 1. Build for the 1st time (-> populate log)
1608   EXPECT_TRUE(builder_.Build(&err));
1609   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1610
1611   // 2. Build again (no change)
1612   command_runner_.commands_ran_.clear();
1613   state_.Reset();
1614   EXPECT_TRUE(builder_.AddTarget("out", &err));
1615   EXPECT_EQ("", err);
1616   ASSERT_TRUE(builder_.AlreadyUpToDate());
1617
1618   // 3. Alter the entry in the logfile
1619   // (to simulate a change in the command line between 2 builds)
1620   BuildLog::LogEntry* log_entry = build_log_.LookupByOutput("out");
1621   ASSERT_TRUE(NULL != log_entry);
1622   ASSERT_NO_FATAL_FAILURE(AssertHash(
1623         "cat out.rsp > out;rspfile=Original very long command",
1624         log_entry->command_hash));
1625   log_entry->command_hash++;  // Change the command hash to something else.
1626   // Now expect the target to be rebuilt
1627   command_runner_.commands_ran_.clear();
1628   state_.Reset();
1629   EXPECT_TRUE(builder_.AddTarget("out", &err));
1630   EXPECT_EQ("", err);
1631   EXPECT_TRUE(builder_.Build(&err));
1632   EXPECT_EQ(1u, command_runner_.commands_ran_.size());
1633 }
1634
1635 TEST_F(BuildTest, InterruptCleanup) {
1636   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1637 "rule interrupt\n"
1638 "  command = interrupt\n"
1639 "rule touch-interrupt\n"
1640 "  command = touch-interrupt\n"
1641 "build out1: interrupt in1\n"
1642 "build out2: touch-interrupt in2\n"));
1643
1644   fs_.Create("out1", "");
1645   fs_.Create("out2", "");
1646   fs_.Tick();
1647   fs_.Create("in1", "");
1648   fs_.Create("in2", "");
1649
1650   // An untouched output of an interrupted command should be retained.
1651   string err;
1652   EXPECT_TRUE(builder_.AddTarget("out1", &err));
1653   EXPECT_EQ("", err);
1654   EXPECT_FALSE(builder_.Build(&err));
1655   EXPECT_EQ("interrupted by user", err);
1656   builder_.Cleanup();
1657   EXPECT_GT(fs_.Stat("out1", &err), 0);
1658   err = "";
1659
1660   // A touched output of an interrupted command should be deleted.
1661   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1662   EXPECT_EQ("", err);
1663   EXPECT_FALSE(builder_.Build(&err));
1664   EXPECT_EQ("interrupted by user", err);
1665   builder_.Cleanup();
1666   EXPECT_EQ(0, fs_.Stat("out2", &err));
1667 }
1668
1669 TEST_F(BuildTest, StatFailureAbortsBuild) {
1670   const string kTooLongToStat(400, 'i');
1671   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1672 ("build " + kTooLongToStat + ": cat " + kTooLongToStat + "\n").c_str()));
1673   // Also cyclic, for good measure.
1674
1675   // This simulates a stat failure:
1676   fs_.files_[kTooLongToStat].mtime = -1;
1677   fs_.files_[kTooLongToStat].stat_error = "stat failed";
1678
1679   string err;
1680   EXPECT_FALSE(builder_.AddTarget(kTooLongToStat, &err));
1681   EXPECT_EQ("stat failed", err);
1682 }
1683
1684 TEST_F(BuildTest, PhonyWithNoInputs) {
1685   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1686 "build nonexistent: phony\n"
1687 "build out1: cat || nonexistent\n"
1688 "build out2: cat nonexistent\n"));
1689   fs_.Create("out1", "");
1690   fs_.Create("out2", "");
1691
1692   // out1 should be up to date even though its input is dirty, because its
1693   // order-only dependency has nothing to do.
1694   string err;
1695   EXPECT_TRUE(builder_.AddTarget("out1", &err));
1696   ASSERT_EQ("", err);
1697   EXPECT_TRUE(builder_.AlreadyUpToDate());
1698
1699   // out2 should still be out of date though, because its input is dirty.
1700   err.clear();
1701   command_runner_.commands_ran_.clear();
1702   state_.Reset();
1703   EXPECT_TRUE(builder_.AddTarget("out2", &err));
1704   ASSERT_EQ("", err);
1705   EXPECT_TRUE(builder_.Build(&err));
1706   EXPECT_EQ("", err);
1707   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1708 }
1709
1710 TEST_F(BuildTest, DepsGccWithEmptyDepfileErrorsOut) {
1711   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1712 "rule cc\n"
1713 "  command = cc\n"
1714 "  deps = gcc\n"
1715 "build out: cc\n"));
1716   Dirty("out");
1717
1718   string err;
1719   EXPECT_TRUE(builder_.AddTarget("out", &err));
1720   ASSERT_EQ("", err);
1721   EXPECT_FALSE(builder_.AlreadyUpToDate());
1722
1723   EXPECT_FALSE(builder_.Build(&err));
1724   ASSERT_EQ("subcommand failed", err);
1725   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1726 }
1727
1728 TEST_F(BuildTest, StatusFormatElapsed) {
1729   status_.BuildStarted();
1730   // Before any task is done, the elapsed time must be zero.
1731   EXPECT_EQ("[%/e0.000]",
1732             status_.FormatProgressStatus("[%%/e%e]",
1733                 BuildStatus::kEdgeStarted));
1734 }
1735
1736 TEST_F(BuildTest, StatusFormatReplacePlaceholder) {
1737   EXPECT_EQ("[%/s0/t0/r0/u0/f0]",
1738             status_.FormatProgressStatus("[%%/s%s/t%t/r%r/u%u/f%f]",
1739                 BuildStatus::kEdgeStarted));
1740 }
1741
1742 TEST_F(BuildTest, FailedDepsParse) {
1743   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1744 "build bad_deps.o: cat in1\n"
1745 "  deps = gcc\n"
1746 "  depfile = in1.d\n"));
1747
1748   string err;
1749   EXPECT_TRUE(builder_.AddTarget("bad_deps.o", &err));
1750   ASSERT_EQ("", err);
1751
1752   // These deps will fail to parse, as they should only have one
1753   // path to the left of the colon.
1754   fs_.Create("in1.d", "AAA BBB");
1755
1756   EXPECT_FALSE(builder_.Build(&err));
1757   EXPECT_EQ("subcommand failed", err);
1758 }
1759
1760 /// Tests of builds involving deps logs necessarily must span
1761 /// multiple builds.  We reuse methods on BuildTest but not the
1762 /// builder_ it sets up, because we want pristine objects for
1763 /// each build.
1764 struct BuildWithDepsLogTest : public BuildTest {
1765   BuildWithDepsLogTest() {}
1766
1767   virtual void SetUp() {
1768     BuildTest::SetUp();
1769
1770     temp_dir_.CreateAndEnter("BuildWithDepsLogTest");
1771   }
1772
1773   virtual void TearDown() {
1774     temp_dir_.Cleanup();
1775   }
1776
1777   ScopedTempDir temp_dir_;
1778
1779   /// Shadow parent class builder_ so we don't accidentally use it.
1780   void* builder_;
1781 };
1782
1783 /// Run a straightforwad build where the deps log is used.
1784 TEST_F(BuildWithDepsLogTest, Straightforward) {
1785   string err;
1786   // Note: in1 was created by the superclass SetUp().
1787   const char* manifest =
1788       "build out: cat in1\n"
1789       "  deps = gcc\n"
1790       "  depfile = in1.d\n";
1791   {
1792     State state;
1793     ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
1794     ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
1795
1796     // Run the build once, everything should be ok.
1797     DepsLog deps_log;
1798     ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
1799     ASSERT_EQ("", err);
1800
1801     Builder builder(&state, config_, NULL, &deps_log, &fs_);
1802     builder.command_runner_.reset(&command_runner_);
1803     EXPECT_TRUE(builder.AddTarget("out", &err));
1804     ASSERT_EQ("", err);
1805     fs_.Create("in1.d", "out: in2");
1806     EXPECT_TRUE(builder.Build(&err));
1807     EXPECT_EQ("", err);
1808
1809     // The deps file should have been removed.
1810     EXPECT_EQ(0, fs_.Stat("in1.d", &err));
1811     // Recreate it for the next step.
1812     fs_.Create("in1.d", "out: in2");
1813     deps_log.Close();
1814     builder.command_runner_.release();
1815   }
1816
1817   {
1818     State state;
1819     ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
1820     ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
1821
1822     // Touch the file only mentioned in the deps.
1823     fs_.Tick();
1824     fs_.Create("in2", "");
1825
1826     // Run the build again.
1827     DepsLog deps_log;
1828     ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
1829     ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
1830
1831     Builder builder(&state, config_, NULL, &deps_log, &fs_);
1832     builder.command_runner_.reset(&command_runner_);
1833     command_runner_.commands_ran_.clear();
1834     EXPECT_TRUE(builder.AddTarget("out", &err));
1835     ASSERT_EQ("", err);
1836     EXPECT_TRUE(builder.Build(&err));
1837     EXPECT_EQ("", err);
1838
1839     // We should have rebuilt the output due to in2 being
1840     // out of date.
1841     EXPECT_EQ(1u, command_runner_.commands_ran_.size());
1842
1843     builder.command_runner_.release();
1844   }
1845 }
1846
1847 /// Verify that obsolete dependency info causes a rebuild.
1848 /// 1) Run a successful build where everything has time t, record deps.
1849 /// 2) Move input/output to time t+1 -- despite files in alignment,
1850 ///    should still need to rebuild due to deps at older time.
1851 TEST_F(BuildWithDepsLogTest, ObsoleteDeps) {
1852   string err;
1853   // Note: in1 was created by the superclass SetUp().
1854   const char* manifest =
1855       "build out: cat in1\n"
1856       "  deps = gcc\n"
1857       "  depfile = in1.d\n";
1858   {
1859     // Run an ordinary build that gathers dependencies.
1860     fs_.Create("in1", "");
1861     fs_.Create("in1.d", "out: ");
1862
1863     State state;
1864     ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
1865     ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
1866
1867     // Run the build once, everything should be ok.
1868     DepsLog deps_log;
1869     ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
1870     ASSERT_EQ("", err);
1871
1872     Builder builder(&state, config_, NULL, &deps_log, &fs_);
1873     builder.command_runner_.reset(&command_runner_);
1874     EXPECT_TRUE(builder.AddTarget("out", &err));
1875     ASSERT_EQ("", err);
1876     EXPECT_TRUE(builder.Build(&err));
1877     EXPECT_EQ("", err);
1878
1879     deps_log.Close();
1880     builder.command_runner_.release();
1881   }
1882
1883   // Push all files one tick forward so that only the deps are out
1884   // of date.
1885   fs_.Tick();
1886   fs_.Create("in1", "");
1887   fs_.Create("out", "");
1888
1889   // The deps file should have been removed, so no need to timestamp it.
1890   EXPECT_EQ(0, fs_.Stat("in1.d", &err));
1891
1892   {
1893     State state;
1894     ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
1895     ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
1896
1897     DepsLog deps_log;
1898     ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
1899     ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
1900
1901     Builder builder(&state, config_, NULL, &deps_log, &fs_);
1902     builder.command_runner_.reset(&command_runner_);
1903     command_runner_.commands_ran_.clear();
1904     EXPECT_TRUE(builder.AddTarget("out", &err));
1905     ASSERT_EQ("", err);
1906
1907     // Recreate the deps file here because the build expects them to exist.
1908     fs_.Create("in1.d", "out: ");
1909
1910     EXPECT_TRUE(builder.Build(&err));
1911     EXPECT_EQ("", err);
1912
1913     // We should have rebuilt the output due to the deps being
1914     // out of date.
1915     EXPECT_EQ(1u, command_runner_.commands_ran_.size());
1916
1917     builder.command_runner_.release();
1918   }
1919 }
1920
1921 TEST_F(BuildWithDepsLogTest, DepsIgnoredInDryRun) {
1922   const char* manifest =
1923       "build out: cat in1\n"
1924       "  deps = gcc\n"
1925       "  depfile = in1.d\n";
1926
1927   fs_.Create("out", "");
1928   fs_.Tick();
1929   fs_.Create("in1", "");
1930
1931   State state;
1932   ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
1933   ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
1934
1935   // The deps log is NULL in dry runs.
1936   config_.dry_run = true;
1937   Builder builder(&state, config_, NULL, NULL, &fs_);
1938   builder.command_runner_.reset(&command_runner_);
1939   command_runner_.commands_ran_.clear();
1940
1941   string err;
1942   EXPECT_TRUE(builder.AddTarget("out", &err));
1943   ASSERT_EQ("", err);
1944   EXPECT_TRUE(builder.Build(&err));
1945   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
1946
1947   builder.command_runner_.release();
1948 }
1949
1950 /// Check that a restat rule generating a header cancels compilations correctly.
1951 TEST_F(BuildTest, RestatDepfileDependency) {
1952   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
1953 "rule true\n"
1954 "  command = true\n"  // Would be "write if out-of-date" in reality.
1955 "  restat = 1\n"
1956 "build header.h: true header.in\n"
1957 "build out: cat in1\n"
1958 "  depfile = in1.d\n"));
1959
1960   fs_.Create("header.h", "");
1961   fs_.Create("in1.d", "out: header.h");
1962   fs_.Tick();
1963   fs_.Create("header.in", "");
1964
1965   string err;
1966   EXPECT_TRUE(builder_.AddTarget("out", &err));
1967   ASSERT_EQ("", err);
1968   EXPECT_TRUE(builder_.Build(&err));
1969   EXPECT_EQ("", err);
1970 }
1971
1972 /// Check that a restat rule generating a header cancels compilations correctly,
1973 /// depslog case.
1974 TEST_F(BuildWithDepsLogTest, RestatDepfileDependencyDepsLog) {
1975   string err;
1976   // Note: in1 was created by the superclass SetUp().
1977   const char* manifest =
1978       "rule true\n"
1979       "  command = true\n"  // Would be "write if out-of-date" in reality.
1980       "  restat = 1\n"
1981       "build header.h: true header.in\n"
1982       "build out: cat in1\n"
1983       "  deps = gcc\n"
1984       "  depfile = in1.d\n";
1985   {
1986     State state;
1987     ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
1988     ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
1989
1990     // Run the build once, everything should be ok.
1991     DepsLog deps_log;
1992     ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
1993     ASSERT_EQ("", err);
1994
1995     Builder builder(&state, config_, NULL, &deps_log, &fs_);
1996     builder.command_runner_.reset(&command_runner_);
1997     EXPECT_TRUE(builder.AddTarget("out", &err));
1998     ASSERT_EQ("", err);
1999     fs_.Create("in1.d", "out: header.h");
2000     EXPECT_TRUE(builder.Build(&err));
2001     EXPECT_EQ("", err);
2002
2003     deps_log.Close();
2004     builder.command_runner_.release();
2005   }
2006
2007   {
2008     State state;
2009     ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
2010     ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
2011
2012     // Touch the input of the restat rule.
2013     fs_.Tick();
2014     fs_.Create("header.in", "");
2015
2016     // Run the build again.
2017     DepsLog deps_log;
2018     ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
2019     ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
2020
2021     Builder builder(&state, config_, NULL, &deps_log, &fs_);
2022     builder.command_runner_.reset(&command_runner_);
2023     command_runner_.commands_ran_.clear();
2024     EXPECT_TRUE(builder.AddTarget("out", &err));
2025     ASSERT_EQ("", err);
2026     EXPECT_TRUE(builder.Build(&err));
2027     EXPECT_EQ("", err);
2028
2029     // Rule "true" should have run again, but the build of "out" should have
2030     // been cancelled due to restat propagating through the depfile header.
2031     EXPECT_EQ(1u, command_runner_.commands_ran_.size());
2032
2033     builder.command_runner_.release();
2034   }
2035 }
2036
2037 TEST_F(BuildWithDepsLogTest, DepFileOKDepsLog) {
2038   string err;
2039   const char* manifest =
2040       "rule cc\n  command = cc $in\n  depfile = $out.d\n  deps = gcc\n"
2041       "build fo$ o.o: cc foo.c\n";
2042
2043   fs_.Create("foo.c", "");
2044
2045   {
2046     State state;
2047     ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
2048
2049     // Run the build once, everything should be ok.
2050     DepsLog deps_log;
2051     ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
2052     ASSERT_EQ("", err);
2053
2054     Builder builder(&state, config_, NULL, &deps_log, &fs_);
2055     builder.command_runner_.reset(&command_runner_);
2056     EXPECT_TRUE(builder.AddTarget("fo o.o", &err));
2057     ASSERT_EQ("", err);
2058     fs_.Create("fo o.o.d", "fo\\ o.o: blah.h bar.h\n");
2059     EXPECT_TRUE(builder.Build(&err));
2060     EXPECT_EQ("", err);
2061
2062     deps_log.Close();
2063     builder.command_runner_.release();
2064   }
2065
2066   {
2067     State state;
2068     ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
2069
2070     DepsLog deps_log;
2071     ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
2072     ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
2073     ASSERT_EQ("", err);
2074
2075     Builder builder(&state, config_, NULL, &deps_log, &fs_);
2076     builder.command_runner_.reset(&command_runner_);
2077
2078     Edge* edge = state.edges_.back();
2079
2080     state.GetNode("bar.h", 0)->MarkDirty();  // Mark bar.h as missing.
2081     EXPECT_TRUE(builder.AddTarget("fo o.o", &err));
2082     ASSERT_EQ("", err);
2083
2084     // Expect three new edges: one generating fo o.o, and two more from
2085     // loading the depfile.
2086     ASSERT_EQ(3u, state.edges_.size());
2087     // Expect our edge to now have three inputs: foo.c and two headers.
2088     ASSERT_EQ(3u, edge->inputs_.size());
2089
2090     // Expect the command line we generate to only use the original input.
2091     ASSERT_EQ("cc foo.c", edge->EvaluateCommand());
2092
2093     deps_log.Close();
2094     builder.command_runner_.release();
2095   }
2096 }
2097
2098 #ifdef _WIN32
2099 TEST_F(BuildWithDepsLogTest, DepFileDepsLogCanonicalize) {
2100   string err;
2101   const char* manifest =
2102       "rule cc\n  command = cc $in\n  depfile = $out.d\n  deps = gcc\n"
2103       "build a/b\\c\\d/e/fo$ o.o: cc x\\y/z\\foo.c\n";
2104
2105   fs_.Create("x/y/z/foo.c", "");
2106
2107   {
2108     State state;
2109     ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
2110
2111     // Run the build once, everything should be ok.
2112     DepsLog deps_log;
2113     ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
2114     ASSERT_EQ("", err);
2115
2116     Builder builder(&state, config_, NULL, &deps_log, &fs_);
2117     builder.command_runner_.reset(&command_runner_);
2118     EXPECT_TRUE(builder.AddTarget("a/b/c/d/e/fo o.o", &err));
2119     ASSERT_EQ("", err);
2120     // Note, different slashes from manifest.
2121     fs_.Create("a/b\\c\\d/e/fo o.o.d",
2122                "a\\b\\c\\d\\e\\fo\\ o.o: blah.h bar.h\n");
2123     EXPECT_TRUE(builder.Build(&err));
2124     EXPECT_EQ("", err);
2125
2126     deps_log.Close();
2127     builder.command_runner_.release();
2128   }
2129
2130   {
2131     State state;
2132     ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
2133
2134     DepsLog deps_log;
2135     ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
2136     ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
2137     ASSERT_EQ("", err);
2138
2139     Builder builder(&state, config_, NULL, &deps_log, &fs_);
2140     builder.command_runner_.reset(&command_runner_);
2141
2142     Edge* edge = state.edges_.back();
2143
2144     state.GetNode("bar.h", 0)->MarkDirty();  // Mark bar.h as missing.
2145     EXPECT_TRUE(builder.AddTarget("a/b/c/d/e/fo o.o", &err));
2146     ASSERT_EQ("", err);
2147
2148     // Expect three new edges: one generating fo o.o, and two more from
2149     // loading the depfile.
2150     ASSERT_EQ(3u, state.edges_.size());
2151     // Expect our edge to now have three inputs: foo.c and two headers.
2152     ASSERT_EQ(3u, edge->inputs_.size());
2153
2154     // Expect the command line we generate to only use the original input.
2155     // Note, slashes from manifest, not .d.
2156     ASSERT_EQ("cc x\\y/z\\foo.c", edge->EvaluateCommand());
2157
2158     deps_log.Close();
2159     builder.command_runner_.release();
2160   }
2161 }
2162 #endif
2163
2164 /// Check that a restat rule doesn't clear an edge if the depfile is missing.
2165 /// Follows from: https://github.com/ninja-build/ninja/issues/603
2166 TEST_F(BuildTest, RestatMissingDepfile) {
2167 const char* manifest =
2168 "rule true\n"
2169 "  command = true\n"  // Would be "write if out-of-date" in reality.
2170 "  restat = 1\n"
2171 "build header.h: true header.in\n"
2172 "build out: cat header.h\n"
2173 "  depfile = out.d\n";
2174
2175   fs_.Create("header.h", "");
2176   fs_.Tick();
2177   fs_.Create("out", "");
2178   fs_.Create("header.in", "");
2179
2180   // Normally, only 'header.h' would be rebuilt, as
2181   // its rule doesn't touch the output and has 'restat=1' set.
2182   // But we are also missing the depfile for 'out',
2183   // which should force its command to run anyway!
2184   RebuildTarget("out", manifest);
2185   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
2186 }
2187
2188 /// Check that a restat rule doesn't clear an edge if the deps are missing.
2189 /// https://github.com/ninja-build/ninja/issues/603
2190 TEST_F(BuildWithDepsLogTest, RestatMissingDepfileDepslog) {
2191   string err;
2192   const char* manifest =
2193 "rule true\n"
2194 "  command = true\n"  // Would be "write if out-of-date" in reality.
2195 "  restat = 1\n"
2196 "build header.h: true header.in\n"
2197 "build out: cat header.h\n"
2198 "  deps = gcc\n"
2199 "  depfile = out.d\n";
2200
2201   // Build once to populate ninja deps logs from out.d
2202   fs_.Create("header.in", "");
2203   fs_.Create("out.d", "out: header.h");
2204   fs_.Create("header.h", "");
2205
2206   RebuildTarget("out", manifest, "build_log", "ninja_deps");
2207   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
2208
2209   // Sanity: this rebuild should be NOOP
2210   RebuildTarget("out", manifest, "build_log", "ninja_deps");
2211   ASSERT_EQ(0u, command_runner_.commands_ran_.size());
2212
2213   // Touch 'header.in', blank dependencies log (create a different one).
2214   // Building header.h triggers 'restat' outputs cleanup.
2215   // Validate that out is rebuilt netherless, as deps are missing.
2216   fs_.Tick();
2217   fs_.Create("header.in", "");
2218
2219   // (switch to a new blank deps_log "ninja_deps2")
2220   RebuildTarget("out", manifest, "build_log", "ninja_deps2");
2221   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
2222
2223   // Sanity: this build should be NOOP
2224   RebuildTarget("out", manifest, "build_log", "ninja_deps2");
2225   ASSERT_EQ(0u, command_runner_.commands_ran_.size());
2226
2227   // Check that invalidating deps by target timestamp also works here
2228   // Repeat the test but touch target instead of blanking the log.
2229   fs_.Tick();
2230   fs_.Create("header.in", "");
2231   fs_.Create("out", "");
2232   RebuildTarget("out", manifest, "build_log", "ninja_deps2");
2233   ASSERT_EQ(2u, command_runner_.commands_ran_.size());
2234
2235   // And this build should be NOOP again
2236   RebuildTarget("out", manifest, "build_log", "ninja_deps2");
2237   ASSERT_EQ(0u, command_runner_.commands_ran_.size());
2238 }
2239
2240 TEST_F(BuildTest, WrongOutputInDepfileCausesRebuild) {
2241   string err;
2242   const char* manifest =
2243 "rule cc\n"
2244 "  command = cc $in\n"
2245 "  depfile = $out.d\n"
2246 "build foo.o: cc foo.c\n";
2247
2248   fs_.Create("foo.c", "");
2249   fs_.Create("foo.o", "");
2250   fs_.Create("header.h", "");
2251   fs_.Create("foo.o.d", "bar.o.d: header.h\n");
2252
2253   RebuildTarget("foo.o", manifest, "build_log", "ninja_deps");
2254   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
2255 }
2256
2257 TEST_F(BuildTest, Console) {
2258   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
2259 "rule console\n"
2260 "  command = console\n"
2261 "  pool = console\n"
2262 "build cons: console in.txt\n"));
2263
2264   fs_.Create("in.txt", "");
2265
2266   string err;
2267   EXPECT_TRUE(builder_.AddTarget("cons", &err));
2268   ASSERT_EQ("", err);
2269   EXPECT_TRUE(builder_.Build(&err));
2270   EXPECT_EQ("", err);
2271   ASSERT_EQ(1u, command_runner_.commands_ran_.size());
2272 }