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_log.h"
16
17 #include "util.h"
18 #include "test.h"
19
20 #include <sys/stat.h>
21 #ifdef _WIN32
22 #include <fcntl.h>
23 #include <share.h>
24 #else
25 #include <sys/types.h>
26 #include <unistd.h>
27 #endif
28 #include <cassert>
29
30 namespace {
31
32 const char kTestFilename[] = "BuildLogTest-tempfile";
33
34 struct BuildLogTest : public StateTestWithBuiltinRules, public BuildLogUser {
SetUp__anon6d1576610111::BuildLogTest35 virtual void SetUp() {
36 // In case a crashing test left a stale file behind.
37 unlink(kTestFilename);
38 }
TearDown__anon6d1576610111::BuildLogTest39 virtual void TearDown() {
40 unlink(kTestFilename);
41 }
IsPathDead__anon6d1576610111::BuildLogTest42 virtual bool IsPathDead(StringPiece s) const { return false; }
43 };
44
TEST_F(BuildLogTest,WriteRead)45 TEST_F(BuildLogTest, WriteRead) {
46 AssertParse(&state_,
47 "build out: cat mid\n"
48 "build mid: cat in\n");
49
50 BuildLog log1;
51 string err;
52 EXPECT_TRUE(log1.OpenForWrite(kTestFilename, *this, &err));
53 ASSERT_EQ("", err);
54 log1.RecordCommand(state_.edges_[0], 15, 18);
55 log1.RecordCommand(state_.edges_[1], 20, 25);
56 log1.Close();
57
58 BuildLog log2;
59 EXPECT_TRUE(log2.Load(kTestFilename, &err));
60 ASSERT_EQ("", err);
61
62 ASSERT_EQ(2u, log1.entries().size());
63 ASSERT_EQ(2u, log2.entries().size());
64 BuildLog::LogEntry* e1 = log1.LookupByOutput("out");
65 ASSERT_TRUE(e1);
66 BuildLog::LogEntry* e2 = log2.LookupByOutput("out");
67 ASSERT_TRUE(e2);
68 ASSERT_TRUE(*e1 == *e2);
69 ASSERT_EQ(15, e1->start_time);
70 ASSERT_EQ("out", e1->output);
71 }
72
TEST_F(BuildLogTest,FirstWriteAddsSignature)73 TEST_F(BuildLogTest, FirstWriteAddsSignature) {
74 const char kExpectedVersion[] = "# ninja log vX\n";
75 const size_t kVersionPos = strlen(kExpectedVersion) - 2; // Points at 'X'.
76
77 BuildLog log;
78 string contents, err;
79
80 EXPECT_TRUE(log.OpenForWrite(kTestFilename, *this, &err));
81 ASSERT_EQ("", err);
82 log.Close();
83
84 ASSERT_EQ(0, ReadFile(kTestFilename, &contents, &err));
85 ASSERT_EQ("", err);
86 if (contents.size() >= kVersionPos)
87 contents[kVersionPos] = 'X';
88 EXPECT_EQ(kExpectedVersion, contents);
89
90 // Opening the file anew shouldn't add a second version string.
91 EXPECT_TRUE(log.OpenForWrite(kTestFilename, *this, &err));
92 ASSERT_EQ("", err);
93 log.Close();
94
95 contents.clear();
96 ASSERT_EQ(0, ReadFile(kTestFilename, &contents, &err));
97 ASSERT_EQ("", err);
98 if (contents.size() >= kVersionPos)
99 contents[kVersionPos] = 'X';
100 EXPECT_EQ(kExpectedVersion, contents);
101 }
102
TEST_F(BuildLogTest,DoubleEntry)103 TEST_F(BuildLogTest, DoubleEntry) {
104 FILE* f = fopen(kTestFilename, "wb");
105 fprintf(f, "# ninja log v4\n");
106 fprintf(f, "0\t1\t2\tout\tcommand abc\n");
107 fprintf(f, "3\t4\t5\tout\tcommand def\n");
108 fclose(f);
109
110 string err;
111 BuildLog log;
112 EXPECT_TRUE(log.Load(kTestFilename, &err));
113 ASSERT_EQ("", err);
114
115 BuildLog::LogEntry* e = log.LookupByOutput("out");
116 ASSERT_TRUE(e);
117 ASSERT_NO_FATAL_FAILURE(AssertHash("command def", e->command_hash));
118 }
119
TEST_F(BuildLogTest,Truncate)120 TEST_F(BuildLogTest, Truncate) {
121 AssertParse(&state_,
122 "build out: cat mid\n"
123 "build mid: cat in\n");
124
125 {
126 BuildLog log1;
127 string err;
128 EXPECT_TRUE(log1.OpenForWrite(kTestFilename, *this, &err));
129 ASSERT_EQ("", err);
130 log1.RecordCommand(state_.edges_[0], 15, 18);
131 log1.RecordCommand(state_.edges_[1], 20, 25);
132 log1.Close();
133 }
134
135 struct stat statbuf;
136 ASSERT_EQ(0, stat(kTestFilename, &statbuf));
137 ASSERT_GT(statbuf.st_size, 0);
138
139 // For all possible truncations of the input file, assert that we don't
140 // crash when parsing.
141 for (off_t size = statbuf.st_size; size > 0; --size) {
142 BuildLog log2;
143 string err;
144 EXPECT_TRUE(log2.OpenForWrite(kTestFilename, *this, &err));
145 ASSERT_EQ("", err);
146 log2.RecordCommand(state_.edges_[0], 15, 18);
147 log2.RecordCommand(state_.edges_[1], 20, 25);
148 log2.Close();
149
150 ASSERT_TRUE(Truncate(kTestFilename, size, &err));
151
152 BuildLog log3;
153 err.clear();
154 ASSERT_TRUE(log3.Load(kTestFilename, &err) == LOAD_SUCCESS || !err.empty());
155 }
156 }
157
TEST_F(BuildLogTest,ObsoleteOldVersion)158 TEST_F(BuildLogTest, ObsoleteOldVersion) {
159 FILE* f = fopen(kTestFilename, "wb");
160 fprintf(f, "# ninja log v3\n");
161 fprintf(f, "123 456 0 out command\n");
162 fclose(f);
163
164 string err;
165 BuildLog log;
166 EXPECT_TRUE(log.Load(kTestFilename, &err));
167 ASSERT_NE(err.find("version"), string::npos);
168 }
169
TEST_F(BuildLogTest,SpacesInOutputV4)170 TEST_F(BuildLogTest, SpacesInOutputV4) {
171 FILE* f = fopen(kTestFilename, "wb");
172 fprintf(f, "# ninja log v4\n");
173 fprintf(f, "123\t456\t456\tout with space\tcommand\n");
174 fclose(f);
175
176 string err;
177 BuildLog log;
178 EXPECT_TRUE(log.Load(kTestFilename, &err));
179 ASSERT_EQ("", err);
180
181 BuildLog::LogEntry* e = log.LookupByOutput("out with space");
182 ASSERT_TRUE(e);
183 ASSERT_EQ(123, e->start_time);
184 ASSERT_EQ(456, e->end_time);
185 ASSERT_EQ(456, e->mtime);
186 ASSERT_NO_FATAL_FAILURE(AssertHash("command", e->command_hash));
187 }
188
TEST_F(BuildLogTest,DuplicateVersionHeader)189 TEST_F(BuildLogTest, DuplicateVersionHeader) {
190 // Old versions of ninja accidentally wrote multiple version headers to the
191 // build log on Windows. This shouldn't crash, and the second version header
192 // should be ignored.
193 FILE* f = fopen(kTestFilename, "wb");
194 fprintf(f, "# ninja log v4\n");
195 fprintf(f, "123\t456\t456\tout\tcommand\n");
196 fprintf(f, "# ninja log v4\n");
197 fprintf(f, "456\t789\t789\tout2\tcommand2\n");
198 fclose(f);
199
200 string err;
201 BuildLog log;
202 EXPECT_TRUE(log.Load(kTestFilename, &err));
203 ASSERT_EQ("", err);
204
205 BuildLog::LogEntry* e = log.LookupByOutput("out");
206 ASSERT_TRUE(e);
207 ASSERT_EQ(123, e->start_time);
208 ASSERT_EQ(456, e->end_time);
209 ASSERT_EQ(456, e->mtime);
210 ASSERT_NO_FATAL_FAILURE(AssertHash("command", e->command_hash));
211
212 e = log.LookupByOutput("out2");
213 ASSERT_TRUE(e);
214 ASSERT_EQ(456, e->start_time);
215 ASSERT_EQ(789, e->end_time);
216 ASSERT_EQ(789, e->mtime);
217 ASSERT_NO_FATAL_FAILURE(AssertHash("command2", e->command_hash));
218 }
219
220 struct TestDiskInterface : public DiskInterface {
Stat__anon6d1576610111::TestDiskInterface221 virtual TimeStamp Stat(const string& path, string* err) const {
222 return 4;
223 }
WriteFile__anon6d1576610111::TestDiskInterface224 virtual bool WriteFile(const string& path, const string& contents) {
225 assert(false);
226 return true;
227 }
MakeDir__anon6d1576610111::TestDiskInterface228 virtual bool MakeDir(const string& path) {
229 assert(false);
230 return false;
231 }
ReadFile__anon6d1576610111::TestDiskInterface232 virtual Status ReadFile(const string& path, string* contents, string* err) {
233 assert(false);
234 return NotFound;
235 }
RemoveFile__anon6d1576610111::TestDiskInterface236 virtual int RemoveFile(const string& path) {
237 assert(false);
238 return 0;
239 }
240 };
241
TEST_F(BuildLogTest,Restat)242 TEST_F(BuildLogTest, Restat) {
243 FILE* f = fopen(kTestFilename, "wb");
244 fprintf(f, "# ninja log v4\n"
245 "1\t2\t3\tout\tcommand\n");
246 fclose(f);
247 std::string err;
248 BuildLog log;
249 EXPECT_TRUE(log.Load(kTestFilename, &err));
250 ASSERT_EQ("", err);
251 BuildLog::LogEntry* e = log.LookupByOutput("out");
252 ASSERT_EQ(3, e->mtime);
253
254 TestDiskInterface testDiskInterface;
255 char out2[] = { 'o', 'u', 't', '2', 0 };
256 char* filter2[] = { out2 };
257 EXPECT_TRUE(log.Restat(kTestFilename, testDiskInterface, 1, filter2, &err));
258 ASSERT_EQ("", err);
259 e = log.LookupByOutput("out");
260 ASSERT_EQ(3, e->mtime); // unchanged, since the filter doesn't match
261
262 EXPECT_TRUE(log.Restat(kTestFilename, testDiskInterface, 0, NULL, &err));
263 ASSERT_EQ("", err);
264 e = log.LookupByOutput("out");
265 ASSERT_EQ(4, e->mtime);
266 }
267
TEST_F(BuildLogTest,VeryLongInputLine)268 TEST_F(BuildLogTest, VeryLongInputLine) {
269 // Ninja's build log buffer is currently 256kB. Lines longer than that are
270 // silently ignored, but don't affect parsing of other lines.
271 FILE* f = fopen(kTestFilename, "wb");
272 fprintf(f, "# ninja log v4\n");
273 fprintf(f, "123\t456\t456\tout\tcommand start");
274 for (size_t i = 0; i < (512 << 10) / strlen(" more_command"); ++i)
275 fputs(" more_command", f);
276 fprintf(f, "\n");
277 fprintf(f, "456\t789\t789\tout2\tcommand2\n");
278 fclose(f);
279
280 string err;
281 BuildLog log;
282 EXPECT_TRUE(log.Load(kTestFilename, &err));
283 ASSERT_EQ("", err);
284
285 BuildLog::LogEntry* e = log.LookupByOutput("out");
286 ASSERT_EQ(NULL, e);
287
288 e = log.LookupByOutput("out2");
289 ASSERT_TRUE(e);
290 ASSERT_EQ(456, e->start_time);
291 ASSERT_EQ(789, e->end_time);
292 ASSERT_EQ(789, e->mtime);
293 ASSERT_NO_FATAL_FAILURE(AssertHash("command2", e->command_hash));
294 }
295
TEST_F(BuildLogTest,MultiTargetEdge)296 TEST_F(BuildLogTest, MultiTargetEdge) {
297 AssertParse(&state_,
298 "build out out.d: cat\n");
299
300 BuildLog log;
301 log.RecordCommand(state_.edges_[0], 21, 22);
302
303 ASSERT_EQ(2u, log.entries().size());
304 BuildLog::LogEntry* e1 = log.LookupByOutput("out");
305 ASSERT_TRUE(e1);
306 BuildLog::LogEntry* e2 = log.LookupByOutput("out.d");
307 ASSERT_TRUE(e2);
308 ASSERT_EQ("out", e1->output);
309 ASSERT_EQ("out.d", e2->output);
310 ASSERT_EQ(21, e1->start_time);
311 ASSERT_EQ(21, e2->start_time);
312 ASSERT_EQ(22, e2->end_time);
313 ASSERT_EQ(22, e2->end_time);
314 }
315
316 struct BuildLogRecompactTest : public BuildLogTest {
IsPathDead__anon6d1576610111::BuildLogRecompactTest317 virtual bool IsPathDead(StringPiece s) const { return s == "out2"; }
318 };
319
TEST_F(BuildLogRecompactTest,Recompact)320 TEST_F(BuildLogRecompactTest, Recompact) {
321 AssertParse(&state_,
322 "build out: cat in\n"
323 "build out2: cat in\n");
324
325 BuildLog log1;
326 string err;
327 EXPECT_TRUE(log1.OpenForWrite(kTestFilename, *this, &err));
328 ASSERT_EQ("", err);
329 // Record the same edge several times, to trigger recompaction
330 // the next time the log is opened.
331 for (int i = 0; i < 200; ++i)
332 log1.RecordCommand(state_.edges_[0], 15, 18 + i);
333 log1.RecordCommand(state_.edges_[1], 21, 22);
334 log1.Close();
335
336 // Load...
337 BuildLog log2;
338 EXPECT_TRUE(log2.Load(kTestFilename, &err));
339 ASSERT_EQ("", err);
340 ASSERT_EQ(2u, log2.entries().size());
341 ASSERT_TRUE(log2.LookupByOutput("out"));
342 ASSERT_TRUE(log2.LookupByOutput("out2"));
343 // ...and force a recompaction.
344 EXPECT_TRUE(log2.OpenForWrite(kTestFilename, *this, &err));
345 log2.Close();
346
347 // "out2" is dead, it should've been removed.
348 BuildLog log3;
349 EXPECT_TRUE(log2.Load(kTestFilename, &err));
350 ASSERT_EQ("", err);
351 ASSERT_EQ(1u, log2.entries().size());
352 ASSERT_TRUE(log2.LookupByOutput("out"));
353 ASSERT_FALSE(log2.LookupByOutput("out2"));
354 }
355
356 } // anonymous namespace
357