Ninja
|
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 }