Ninja
clean_test.cc
Go to the documentation of this file.
00001 // Copyright 2011 Google Inc. All Rights Reserved.
00002 //
00003 // Licensed under the Apache License, Version 2.0 (the "License");
00004 // you may not use this file except in compliance with the License.
00005 // You may obtain a copy of the License at
00006 //
00007 //     http://www.apache.org/licenses/LICENSE-2.0
00008 //
00009 // Unless required by applicable law or agreed to in writing, software
00010 // distributed under the License is distributed on an "AS IS" BASIS,
00011 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00012 // See the License for the specific language governing permissions and
00013 // limitations under the License.
00014 
00015 #include "clean.h"
00016 #include "build.h"
00017 
00018 #include "test.h"
00019 
00020 struct CleanTest : public StateTestWithBuiltinRules {
00021   VirtualFileSystem fs_;
00022   BuildConfig config_;
00023   virtual void SetUp() {
00024     config_.verbosity = BuildConfig::QUIET;
00025   }
00026 };
00027 
00028 TEST_F(CleanTest, CleanAll) {
00029   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
00030 "build in1: cat src1\n"
00031 "build out1: cat in1\n"
00032 "build in2: cat src2\n"
00033 "build out2: cat in2\n"));
00034   fs_.Create("in1", "");
00035   fs_.Create("out1", "");
00036   fs_.Create("in2", "");
00037   fs_.Create("out2", "");
00038 
00039   Cleaner cleaner(&state_, config_, &fs_);
00040 
00041   ASSERT_EQ(0, cleaner.cleaned_files_count());
00042   EXPECT_EQ(0, cleaner.CleanAll());
00043   EXPECT_EQ(4, cleaner.cleaned_files_count());
00044   EXPECT_EQ(4u, fs_.files_removed_.size());
00045 
00046   // Check they are removed.
00047   EXPECT_EQ(0, fs_.Stat("in1"));
00048   EXPECT_EQ(0, fs_.Stat("out1"));
00049   EXPECT_EQ(0, fs_.Stat("in2"));
00050   EXPECT_EQ(0, fs_.Stat("out2"));
00051   fs_.files_removed_.clear();
00052 
00053   EXPECT_EQ(0, cleaner.CleanAll());
00054   EXPECT_EQ(0, cleaner.cleaned_files_count());
00055   EXPECT_EQ(0u, fs_.files_removed_.size());
00056 }
00057 
00058 TEST_F(CleanTest, CleanAllDryRun) {
00059   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
00060 "build in1: cat src1\n"
00061 "build out1: cat in1\n"
00062 "build in2: cat src2\n"
00063 "build out2: cat in2\n"));
00064   fs_.Create("in1", "");
00065   fs_.Create("out1", "");
00066   fs_.Create("in2", "");
00067   fs_.Create("out2", "");
00068 
00069   config_.dry_run = true;
00070   Cleaner cleaner(&state_, config_, &fs_);
00071 
00072   ASSERT_EQ(0, cleaner.cleaned_files_count());
00073   EXPECT_EQ(0, cleaner.CleanAll());
00074   EXPECT_EQ(4, cleaner.cleaned_files_count());
00075   EXPECT_EQ(0u, fs_.files_removed_.size());
00076 
00077   // Check they are not removed.
00078   EXPECT_NE(0, fs_.Stat("in1"));
00079   EXPECT_NE(0, fs_.Stat("out1"));
00080   EXPECT_NE(0, fs_.Stat("in2"));
00081   EXPECT_NE(0, fs_.Stat("out2"));
00082   fs_.files_removed_.clear();
00083 
00084   EXPECT_EQ(0, cleaner.CleanAll());
00085   EXPECT_EQ(4, cleaner.cleaned_files_count());
00086   EXPECT_EQ(0u, fs_.files_removed_.size());
00087 }
00088 
00089 TEST_F(CleanTest, CleanTarget) {
00090   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
00091 "build in1: cat src1\n"
00092 "build out1: cat in1\n"
00093 "build in2: cat src2\n"
00094 "build out2: cat in2\n"));
00095   fs_.Create("in1", "");
00096   fs_.Create("out1", "");
00097   fs_.Create("in2", "");
00098   fs_.Create("out2", "");
00099 
00100   Cleaner cleaner(&state_, config_, &fs_);
00101 
00102   ASSERT_EQ(0, cleaner.cleaned_files_count());
00103   ASSERT_EQ(0, cleaner.CleanTarget("out1"));
00104   EXPECT_EQ(2, cleaner.cleaned_files_count());
00105   EXPECT_EQ(2u, fs_.files_removed_.size());
00106 
00107   // Check they are removed.
00108   EXPECT_EQ(0, fs_.Stat("in1"));
00109   EXPECT_EQ(0, fs_.Stat("out1"));
00110   EXPECT_NE(0, fs_.Stat("in2"));
00111   EXPECT_NE(0, fs_.Stat("out2"));
00112   fs_.files_removed_.clear();
00113 
00114   ASSERT_EQ(0, cleaner.CleanTarget("out1"));
00115   EXPECT_EQ(0, cleaner.cleaned_files_count());
00116   EXPECT_EQ(0u, fs_.files_removed_.size());
00117 }
00118 
00119 TEST_F(CleanTest, CleanTargetDryRun) {
00120   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
00121 "build in1: cat src1\n"
00122 "build out1: cat in1\n"
00123 "build in2: cat src2\n"
00124 "build out2: cat in2\n"));
00125   fs_.Create("in1", "");
00126   fs_.Create("out1", "");
00127   fs_.Create("in2", "");
00128   fs_.Create("out2", "");
00129 
00130   config_.dry_run = true;
00131   Cleaner cleaner(&state_, config_, &fs_);
00132 
00133   ASSERT_EQ(0, cleaner.cleaned_files_count());
00134   ASSERT_EQ(0, cleaner.CleanTarget("out1"));
00135   EXPECT_EQ(2, cleaner.cleaned_files_count());
00136   EXPECT_EQ(0u, fs_.files_removed_.size());
00137 
00138   // Check they are removed.
00139   EXPECT_NE(0, fs_.Stat("in1"));
00140   EXPECT_NE(0, fs_.Stat("out1"));
00141   EXPECT_NE(0, fs_.Stat("in2"));
00142   EXPECT_NE(0, fs_.Stat("out2"));
00143   fs_.files_removed_.clear();
00144 
00145   ASSERT_EQ(0, cleaner.CleanTarget("out1"));
00146   EXPECT_EQ(2, cleaner.cleaned_files_count());
00147   EXPECT_EQ(0u, fs_.files_removed_.size());
00148 }
00149 
00150 TEST_F(CleanTest, CleanRule) {
00151   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
00152 "rule cat_e\n"
00153 "  command = cat -e $in > $out\n"
00154 "build in1: cat_e src1\n"
00155 "build out1: cat in1\n"
00156 "build in2: cat_e src2\n"
00157 "build out2: cat in2\n"));
00158   fs_.Create("in1", "");
00159   fs_.Create("out1", "");
00160   fs_.Create("in2", "");
00161   fs_.Create("out2", "");
00162 
00163   Cleaner cleaner(&state_, config_, &fs_);
00164 
00165   ASSERT_EQ(0, cleaner.cleaned_files_count());
00166   ASSERT_EQ(0, cleaner.CleanRule("cat_e"));
00167   EXPECT_EQ(2, cleaner.cleaned_files_count());
00168   EXPECT_EQ(2u, fs_.files_removed_.size());
00169 
00170   // Check they are removed.
00171   EXPECT_EQ(0, fs_.Stat("in1"));
00172   EXPECT_NE(0, fs_.Stat("out1"));
00173   EXPECT_EQ(0, fs_.Stat("in2"));
00174   EXPECT_NE(0, fs_.Stat("out2"));
00175   fs_.files_removed_.clear();
00176 
00177   ASSERT_EQ(0, cleaner.CleanRule("cat_e"));
00178   EXPECT_EQ(0, cleaner.cleaned_files_count());
00179   EXPECT_EQ(0u, fs_.files_removed_.size());
00180 }
00181 
00182 TEST_F(CleanTest, CleanRuleDryRun) {
00183   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
00184 "rule cat_e\n"
00185 "  command = cat -e $in > $out\n"
00186 "build in1: cat_e src1\n"
00187 "build out1: cat in1\n"
00188 "build in2: cat_e src2\n"
00189 "build out2: cat in2\n"));
00190   fs_.Create("in1", "");
00191   fs_.Create("out1", "");
00192   fs_.Create("in2", "");
00193   fs_.Create("out2", "");
00194 
00195   config_.dry_run = true;
00196   Cleaner cleaner(&state_, config_, &fs_);
00197 
00198   ASSERT_EQ(0, cleaner.cleaned_files_count());
00199   ASSERT_EQ(0, cleaner.CleanRule("cat_e"));
00200   EXPECT_EQ(2, cleaner.cleaned_files_count());
00201   EXPECT_EQ(0u, fs_.files_removed_.size());
00202 
00203   // Check they are removed.
00204   EXPECT_NE(0, fs_.Stat("in1"));
00205   EXPECT_NE(0, fs_.Stat("out1"));
00206   EXPECT_NE(0, fs_.Stat("in2"));
00207   EXPECT_NE(0, fs_.Stat("out2"));
00208   fs_.files_removed_.clear();
00209 
00210   ASSERT_EQ(0, cleaner.CleanRule("cat_e"));
00211   EXPECT_EQ(2, cleaner.cleaned_files_count());
00212   EXPECT_EQ(0u, fs_.files_removed_.size());
00213 }
00214 
00215 TEST_F(CleanTest, CleanRuleGenerator) {
00216   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
00217 "rule regen\n"
00218 "  command = cat $in > $out\n"
00219 "  generator = 1\n"
00220 "build out1: cat in1\n"
00221 "build out2: regen in2\n"));
00222   fs_.Create("out1", "");
00223   fs_.Create("out2", "");
00224 
00225   Cleaner cleaner(&state_, config_, &fs_);
00226   EXPECT_EQ(0, cleaner.CleanAll());
00227   EXPECT_EQ(1, cleaner.cleaned_files_count());
00228   EXPECT_EQ(1u, fs_.files_removed_.size());
00229 
00230   fs_.Create("out1", "");
00231 
00232   EXPECT_EQ(0, cleaner.CleanAll(/*generator=*/true));
00233   EXPECT_EQ(2, cleaner.cleaned_files_count());
00234   EXPECT_EQ(2u, fs_.files_removed_.size());
00235 }
00236 
00237 TEST_F(CleanTest, CleanDepFile) {
00238   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
00239 "rule cc\n"
00240 "  command = cc $in > $out\n"
00241 "  depfile = $out.d\n"
00242 "build out1: cc in1\n"));
00243   fs_.Create("out1", "");
00244   fs_.Create("out1.d", "");
00245 
00246   Cleaner cleaner(&state_, config_, &fs_);
00247   EXPECT_EQ(0, cleaner.CleanAll());
00248   EXPECT_EQ(2, cleaner.cleaned_files_count());
00249   EXPECT_EQ(2u, fs_.files_removed_.size());
00250 }
00251 
00252 TEST_F(CleanTest, CleanDepFileOnCleanTarget) {
00253   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
00254 "rule cc\n"
00255 "  command = cc $in > $out\n"
00256 "  depfile = $out.d\n"
00257 "build out1: cc in1\n"));
00258   fs_.Create("out1", "");
00259   fs_.Create("out1.d", "");
00260 
00261   Cleaner cleaner(&state_, config_, &fs_);
00262   EXPECT_EQ(0, cleaner.CleanTarget("out1"));
00263   EXPECT_EQ(2, cleaner.cleaned_files_count());
00264   EXPECT_EQ(2u, fs_.files_removed_.size());
00265 }
00266 
00267 TEST_F(CleanTest, CleanDepFileOnCleanRule) {
00268   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
00269 "rule cc\n"
00270 "  command = cc $in > $out\n"
00271 "  depfile = $out.d\n"
00272 "build out1: cc in1\n"));
00273   fs_.Create("out1", "");
00274   fs_.Create("out1.d", "");
00275 
00276   Cleaner cleaner(&state_, config_, &fs_);
00277   EXPECT_EQ(0, cleaner.CleanRule("cc"));
00278   EXPECT_EQ(2, cleaner.cleaned_files_count());
00279   EXPECT_EQ(2u, fs_.files_removed_.size());
00280 }
00281 
00282 TEST_F(CleanTest, CleanRspFile) {
00283   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
00284 "rule cc\n"
00285 "  command = cc $in > $out\n"
00286 "  rspfile = $rspfile\n"
00287 "  rspfile_content=$in\n"
00288 "build out1: cc in1\n"
00289 "  rspfile = cc1.rsp\n"
00290 "  rspfile_content=$in\n"));
00291   fs_.Create("out1", "");
00292   fs_.Create("cc1.rsp", "");
00293 
00294   Cleaner cleaner(&state_, config_, &fs_);
00295   EXPECT_EQ(0, cleaner.CleanAll());
00296   EXPECT_EQ(2, cleaner.cleaned_files_count());
00297   EXPECT_EQ(2u, fs_.files_removed_.size());
00298 }
00299 
00300 TEST_F(CleanTest, CleanRsp) {
00301   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
00302 "rule cat_rsp \n"
00303 "  command = cat $rspfile > $out\n"
00304 "  rspfile = $rspfile\n"
00305 "  rspfile_content = $in\n"
00306 "build in1: cat src1\n"
00307 "build out1: cat in1\n"
00308 "build in2: cat_rsp src2\n"
00309 "  rspfile=in2.rsp\n"
00310 "  rspfile_content=$in\n"
00311 "build out2: cat_rsp in2\n"
00312 "  rspfile=out2.rsp\n"
00313 "  rspfile_content=$in\n"));
00314   fs_.Create("in1", "");
00315   fs_.Create("out1", "");
00316   fs_.Create("in2.rsp", "");
00317   fs_.Create("out2.rsp", "");
00318   fs_.Create("in2", "");
00319   fs_.Create("out2", "");
00320 
00321   Cleaner cleaner(&state_, config_, &fs_);
00322   ASSERT_EQ(0, cleaner.cleaned_files_count());
00323   ASSERT_EQ(0, cleaner.CleanTarget("out1"));
00324   EXPECT_EQ(2, cleaner.cleaned_files_count()); 
00325   ASSERT_EQ(0, cleaner.CleanTarget("in2"));
00326   EXPECT_EQ(2, cleaner.cleaned_files_count());
00327   ASSERT_EQ(0, cleaner.CleanRule("cat_rsp"));
00328   EXPECT_EQ(2, cleaner.cleaned_files_count());
00329 
00330   EXPECT_EQ(6u, fs_.files_removed_.size());
00331 
00332   // Check they are removed.
00333   EXPECT_EQ(0, fs_.Stat("in1"));
00334   EXPECT_EQ(0, fs_.Stat("out1"));
00335   EXPECT_EQ(0, fs_.Stat("in2"));
00336   EXPECT_EQ(0, fs_.Stat("out2"));
00337   EXPECT_EQ(0, fs_.Stat("in2.rsp"));
00338   EXPECT_EQ(0, fs_.Stat("out2.rsp"));
00339 
00340   fs_.files_removed_.clear();
00341 }
00342 
00343 TEST_F(CleanTest, CleanFailure) {
00344   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
00345                                       "build dir: cat src1\n"));
00346   fs_.MakeDir("dir");
00347   Cleaner cleaner(&state_, config_, &fs_);
00348   EXPECT_NE(0, cleaner.CleanAll());
00349 }
00350 
00351 TEST_F(CleanTest, CleanPhony) {
00352   ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
00353 "build phony: phony t1 t2\n"
00354 "build t1: cat\n"
00355 "build t2: cat\n"));
00356 
00357   fs_.Create("phony", "");
00358   fs_.Create("t1", "");
00359   fs_.Create("t2", "");
00360 
00361   // Check that CleanAll does not remove "phony".
00362   Cleaner cleaner(&state_, config_, &fs_);
00363   EXPECT_EQ(0, cleaner.CleanAll());
00364   EXPECT_EQ(2, cleaner.cleaned_files_count());
00365   EXPECT_NE(0, fs_.Stat("phony"));
00366 
00367   fs_.Create("t1", "");
00368   fs_.Create("t2", "");
00369 
00370   // Check that CleanTarget does not remove "phony".
00371   EXPECT_EQ(0, cleaner.CleanTarget("phony"));
00372   EXPECT_EQ(2, cleaner.cleaned_files_count());
00373   EXPECT_NE(0, fs_.Stat("phony"));
00374 }