1//===- unittest/Tooling/CompilationDatabaseTest.cpp -----------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "clang/AST/ASTConsumer.h"
11#include "clang/AST/DeclCXX.h"
12#include "clang/AST/DeclGroup.h"
13#include "clang/Frontend/FrontendAction.h"
14#include "clang/Tooling/FileMatchTrie.h"
15#include "clang/Tooling/JSONCompilationDatabase.h"
16#include "clang/Tooling/Tooling.h"
17#include "llvm/Support/Path.h"
18#include "gtest/gtest.h"
19
20namespace clang {
21namespace tooling {
22
23static void expectFailure(StringRef JSONDatabase, StringRef Explanation) {
24  std::string ErrorMessage;
25  EXPECT_EQ(nullptr, JSONCompilationDatabase::loadFromBuffer(JSONDatabase,
26                                                             ErrorMessage))
27    << "Expected an error because of: " << Explanation.str();
28}
29
30TEST(JSONCompilationDatabase, ErrsOnInvalidFormat) {
31  expectFailure("", "Empty database");
32  expectFailure("{", "Invalid JSON");
33  expectFailure("[[]]", "Array instead of object");
34  expectFailure("[{\"a\":[]}]", "Array instead of value");
35  expectFailure("[{\"a\":\"b\"}]", "Unknown key");
36  expectFailure("[{[]:\"\"}]", "Incorrectly typed entry");
37  expectFailure("[{}]", "Empty entry");
38  expectFailure("[{\"directory\":\"\",\"command\":\"\"}]", "Missing file");
39  expectFailure("[{\"directory\":\"\",\"file\":\"\"}]", "Missing command");
40  expectFailure("[{\"command\":\"\",\"file\":\"\"}]", "Missing directory");
41}
42
43static std::vector<std::string> getAllFiles(StringRef JSONDatabase,
44                                            std::string &ErrorMessage) {
45  std::unique_ptr<CompilationDatabase> Database(
46      JSONCompilationDatabase::loadFromBuffer(JSONDatabase, ErrorMessage));
47  if (!Database) {
48    ADD_FAILURE() << ErrorMessage;
49    return std::vector<std::string>();
50  }
51  return Database->getAllFiles();
52}
53
54static std::vector<CompileCommand> getAllCompileCommands(StringRef JSONDatabase,
55                                                    std::string &ErrorMessage) {
56  std::unique_ptr<CompilationDatabase> Database(
57      JSONCompilationDatabase::loadFromBuffer(JSONDatabase, ErrorMessage));
58  if (!Database) {
59    ADD_FAILURE() << ErrorMessage;
60    return std::vector<CompileCommand>();
61  }
62  return Database->getAllCompileCommands();
63}
64
65TEST(JSONCompilationDatabase, GetAllFiles) {
66  std::string ErrorMessage;
67  EXPECT_EQ(std::vector<std::string>(),
68            getAllFiles("[]", ErrorMessage)) << ErrorMessage;
69
70  std::vector<std::string> expected_files;
71  SmallString<16> PathStorage;
72  llvm::sys::path::native("//net/dir/file1", PathStorage);
73  expected_files.push_back(PathStorage.str());
74  llvm::sys::path::native("//net/dir/file2", PathStorage);
75  expected_files.push_back(PathStorage.str());
76  EXPECT_EQ(expected_files, getAllFiles(
77    "[{\"directory\":\"//net/dir\","
78      "\"command\":\"command\","
79      "\"file\":\"file1\"},"
80    " {\"directory\":\"//net/dir\","
81      "\"command\":\"command\","
82      "\"file\":\"file2\"}]",
83    ErrorMessage)) << ErrorMessage;
84}
85
86TEST(JSONCompilationDatabase, GetAllCompileCommands) {
87  std::string ErrorMessage;
88  EXPECT_EQ(0u,
89            getAllCompileCommands("[]", ErrorMessage).size()) << ErrorMessage;
90
91  StringRef Directory1("//net/dir1");
92  StringRef FileName1("file1");
93  StringRef Command1("command1");
94  StringRef Directory2("//net/dir2");
95  StringRef FileName2("file1");
96  StringRef Command2("command1");
97
98  std::vector<CompileCommand> Commands = getAllCompileCommands(
99      ("[{\"directory\":\"" + Directory1 + "\"," +
100             "\"command\":\"" + Command1 + "\","
101             "\"file\":\"" + FileName1 + "\"},"
102       " {\"directory\":\"" + Directory2 + "\"," +
103             "\"command\":\"" + Command2 + "\","
104             "\"file\":\"" + FileName2 + "\"}]").str(),
105      ErrorMessage);
106  EXPECT_EQ(2U, Commands.size()) << ErrorMessage;
107  EXPECT_EQ(Directory1, Commands[0].Directory) << ErrorMessage;
108  ASSERT_EQ(1u, Commands[0].CommandLine.size());
109  EXPECT_EQ(Command1, Commands[0].CommandLine[0]) << ErrorMessage;
110  EXPECT_EQ(Directory2, Commands[1].Directory) << ErrorMessage;
111  ASSERT_EQ(1u, Commands[1].CommandLine.size());
112  EXPECT_EQ(Command2, Commands[1].CommandLine[0]) << ErrorMessage;
113}
114
115static CompileCommand findCompileArgsInJsonDatabase(StringRef FileName,
116                                                    StringRef JSONDatabase,
117                                                    std::string &ErrorMessage) {
118  std::unique_ptr<CompilationDatabase> Database(
119      JSONCompilationDatabase::loadFromBuffer(JSONDatabase, ErrorMessage));
120  if (!Database)
121    return CompileCommand();
122  std::vector<CompileCommand> Commands = Database->getCompileCommands(FileName);
123  EXPECT_LE(Commands.size(), 1u);
124  if (Commands.empty())
125    return CompileCommand();
126  return Commands[0];
127}
128
129struct FakeComparator : public PathComparator {
130  virtual ~FakeComparator() {}
131  virtual bool equivalent(StringRef FileA, StringRef FileB) const {
132    return FileA.equals_lower(FileB);
133  }
134};
135
136class FileMatchTrieTest : public ::testing::Test {
137protected:
138  FileMatchTrieTest() : Trie(new FakeComparator()) {}
139
140  StringRef find(StringRef Path) {
141    llvm::raw_string_ostream ES(Error);
142    return Trie.findEquivalent(Path, ES);
143  }
144
145  FileMatchTrie Trie;
146  std::string Error;
147};
148
149TEST_F(FileMatchTrieTest, InsertingRelativePath) {
150  Trie.insert("//net/path/file.cc");
151  Trie.insert("file.cc");
152  EXPECT_EQ("//net/path/file.cc", find("//net/path/file.cc"));
153}
154
155TEST_F(FileMatchTrieTest, MatchingRelativePath) {
156  EXPECT_EQ("", find("file.cc"));
157}
158
159TEST_F(FileMatchTrieTest, ReturnsBestResults) {
160  Trie.insert("//net/d/c/b.cc");
161  Trie.insert("//net/d/b/b.cc");
162  EXPECT_EQ("//net/d/b/b.cc", find("//net/d/b/b.cc"));
163}
164
165TEST_F(FileMatchTrieTest, HandlesSymlinks) {
166  Trie.insert("//net/AA/file.cc");
167  EXPECT_EQ("//net/AA/file.cc", find("//net/aa/file.cc"));
168}
169
170TEST_F(FileMatchTrieTest, ReportsSymlinkAmbiguity) {
171  Trie.insert("//net/Aa/file.cc");
172  Trie.insert("//net/aA/file.cc");
173  EXPECT_TRUE(find("//net/aa/file.cc").empty());
174  EXPECT_EQ("Path is ambiguous", Error);
175}
176
177TEST_F(FileMatchTrieTest, LongerMatchingSuffixPreferred) {
178  Trie.insert("//net/src/Aa/file.cc");
179  Trie.insert("//net/src/aA/file.cc");
180  Trie.insert("//net/SRC/aa/file.cc");
181  EXPECT_EQ("//net/SRC/aa/file.cc", find("//net/src/aa/file.cc"));
182}
183
184TEST_F(FileMatchTrieTest, EmptyTrie) {
185  EXPECT_TRUE(find("//net/some/path").empty());
186}
187
188TEST_F(FileMatchTrieTest, NoResult) {
189  Trie.insert("//net/somepath/otherfile.cc");
190  Trie.insert("//net/otherpath/somefile.cc");
191  EXPECT_EQ("", find("//net/somepath/somefile.cc"));
192}
193
194TEST_F(FileMatchTrieTest, RootElementDifferent) {
195  Trie.insert("//net/path/file.cc");
196  Trie.insert("//net/otherpath/file.cc");
197  EXPECT_EQ("//net/path/file.cc", find("//net/path/file.cc"));
198}
199
200TEST_F(FileMatchTrieTest, CannotResolveRelativePath) {
201  EXPECT_EQ("", find("relative-path.cc"));
202  EXPECT_EQ("Cannot resolve relative paths", Error);
203}
204
205TEST(findCompileArgsInJsonDatabase, FindsNothingIfEmpty) {
206  std::string ErrorMessage;
207  CompileCommand NotFound = findCompileArgsInJsonDatabase(
208    "a-file.cpp", "", ErrorMessage);
209  EXPECT_TRUE(NotFound.CommandLine.empty()) << ErrorMessage;
210  EXPECT_TRUE(NotFound.Directory.empty()) << ErrorMessage;
211}
212
213TEST(findCompileArgsInJsonDatabase, ReadsSingleEntry) {
214  StringRef Directory("//net/some/directory");
215  StringRef FileName("//net/path/to/a-file.cpp");
216  StringRef Command("//net/path/to/compiler and some arguments");
217  std::string ErrorMessage;
218  CompileCommand FoundCommand = findCompileArgsInJsonDatabase(
219    FileName,
220    ("[{\"directory\":\"" + Directory + "\"," +
221       "\"command\":\"" + Command + "\","
222       "\"file\":\"" + FileName + "\"}]").str(),
223    ErrorMessage);
224  EXPECT_EQ(Directory, FoundCommand.Directory) << ErrorMessage;
225  ASSERT_EQ(4u, FoundCommand.CommandLine.size()) << ErrorMessage;
226  EXPECT_EQ("//net/path/to/compiler",
227            FoundCommand.CommandLine[0]) << ErrorMessage;
228  EXPECT_EQ("and", FoundCommand.CommandLine[1]) << ErrorMessage;
229  EXPECT_EQ("some", FoundCommand.CommandLine[2]) << ErrorMessage;
230  EXPECT_EQ("arguments", FoundCommand.CommandLine[3]) << ErrorMessage;
231
232  CompileCommand NotFound = findCompileArgsInJsonDatabase(
233    "a-file.cpp",
234    ("[{\"directory\":\"" + Directory + "\"," +
235       "\"command\":\"" + Command + "\","
236       "\"file\":\"" + FileName + "\"}]").str(),
237    ErrorMessage);
238  EXPECT_TRUE(NotFound.Directory.empty()) << ErrorMessage;
239  EXPECT_TRUE(NotFound.CommandLine.empty()) << ErrorMessage;
240}
241
242TEST(findCompileArgsInJsonDatabase, ReadsCompileCommandLinesWithSpaces) {
243  StringRef Directory("//net/some/directory");
244  StringRef FileName("//net/path/to/a-file.cpp");
245  StringRef Command("\\\"//net/path to compiler\\\" \\\"and an argument\\\"");
246  std::string ErrorMessage;
247  CompileCommand FoundCommand = findCompileArgsInJsonDatabase(
248    FileName,
249    ("[{\"directory\":\"" + Directory + "\"," +
250       "\"command\":\"" + Command + "\","
251       "\"file\":\"" + FileName + "\"}]").str(),
252    ErrorMessage);
253  ASSERT_EQ(2u, FoundCommand.CommandLine.size());
254  EXPECT_EQ("//net/path to compiler",
255            FoundCommand.CommandLine[0]) << ErrorMessage;
256  EXPECT_EQ("and an argument", FoundCommand.CommandLine[1]) << ErrorMessage;
257}
258
259TEST(findCompileArgsInJsonDatabase, ReadsDirectoryWithSpaces) {
260  StringRef Directory("//net/some directory / with spaces");
261  StringRef FileName("//net/path/to/a-file.cpp");
262  StringRef Command("a command");
263  std::string ErrorMessage;
264  CompileCommand FoundCommand = findCompileArgsInJsonDatabase(
265    FileName,
266    ("[{\"directory\":\"" + Directory + "\"," +
267       "\"command\":\"" + Command + "\","
268       "\"file\":\"" + FileName + "\"}]").str(),
269    ErrorMessage);
270  EXPECT_EQ(Directory, FoundCommand.Directory) << ErrorMessage;
271}
272
273TEST(findCompileArgsInJsonDatabase, FindsEntry) {
274  StringRef Directory("//net/directory");
275  StringRef FileName("file");
276  StringRef Command("command");
277  std::string JsonDatabase = "[";
278  for (int I = 0; I < 10; ++I) {
279    if (I > 0) JsonDatabase += ",";
280    JsonDatabase +=
281      ("{\"directory\":\"" + Directory + Twine(I) + "\"," +
282        "\"command\":\"" + Command + Twine(I) + "\","
283        "\"file\":\"" + FileName + Twine(I) + "\"}").str();
284  }
285  JsonDatabase += "]";
286  std::string ErrorMessage;
287  CompileCommand FoundCommand = findCompileArgsInJsonDatabase(
288    "//net/directory4/file4", JsonDatabase, ErrorMessage);
289  EXPECT_EQ("//net/directory4", FoundCommand.Directory) << ErrorMessage;
290  ASSERT_EQ(1u, FoundCommand.CommandLine.size()) << ErrorMessage;
291  EXPECT_EQ("command4", FoundCommand.CommandLine[0]) << ErrorMessage;
292}
293
294static std::vector<std::string> unescapeJsonCommandLine(StringRef Command) {
295  std::string JsonDatabase =
296    ("[{\"directory\":\"//net/root\", \"file\":\"test\", \"command\": \"" +
297     Command + "\"}]").str();
298  std::string ErrorMessage;
299  CompileCommand FoundCommand = findCompileArgsInJsonDatabase(
300    "//net/root/test", JsonDatabase, ErrorMessage);
301  EXPECT_TRUE(ErrorMessage.empty()) << ErrorMessage;
302  return FoundCommand.CommandLine;
303}
304
305TEST(unescapeJsonCommandLine, ReturnsEmptyArrayOnEmptyString) {
306  std::vector<std::string> Result = unescapeJsonCommandLine("");
307  EXPECT_TRUE(Result.empty());
308}
309
310TEST(unescapeJsonCommandLine, SplitsOnSpaces) {
311  std::vector<std::string> Result = unescapeJsonCommandLine("a b c");
312  ASSERT_EQ(3ul, Result.size());
313  EXPECT_EQ("a", Result[0]);
314  EXPECT_EQ("b", Result[1]);
315  EXPECT_EQ("c", Result[2]);
316}
317
318TEST(unescapeJsonCommandLine, MungesMultipleSpaces) {
319  std::vector<std::string> Result = unescapeJsonCommandLine("   a   b   ");
320  ASSERT_EQ(2ul, Result.size());
321  EXPECT_EQ("a", Result[0]);
322  EXPECT_EQ("b", Result[1]);
323}
324
325TEST(unescapeJsonCommandLine, UnescapesBackslashCharacters) {
326  std::vector<std::string> Backslash = unescapeJsonCommandLine("a\\\\\\\\");
327  ASSERT_EQ(1ul, Backslash.size());
328  EXPECT_EQ("a\\", Backslash[0]);
329  std::vector<std::string> Quote = unescapeJsonCommandLine("a\\\\\\\"");
330  ASSERT_EQ(1ul, Quote.size());
331  EXPECT_EQ("a\"", Quote[0]);
332}
333
334TEST(unescapeJsonCommandLine, DoesNotMungeSpacesBetweenQuotes) {
335  std::vector<std::string> Result = unescapeJsonCommandLine("\\\"  a  b  \\\"");
336  ASSERT_EQ(1ul, Result.size());
337  EXPECT_EQ("  a  b  ", Result[0]);
338}
339
340TEST(unescapeJsonCommandLine, AllowsMultipleQuotedArguments) {
341  std::vector<std::string> Result = unescapeJsonCommandLine(
342      "  \\\" a \\\"  \\\" b \\\"  ");
343  ASSERT_EQ(2ul, Result.size());
344  EXPECT_EQ(" a ", Result[0]);
345  EXPECT_EQ(" b ", Result[1]);
346}
347
348TEST(unescapeJsonCommandLine, AllowsEmptyArgumentsInQuotes) {
349  std::vector<std::string> Result = unescapeJsonCommandLine(
350      "\\\"\\\"\\\"\\\"");
351  ASSERT_EQ(1ul, Result.size());
352  EXPECT_TRUE(Result[0].empty()) << Result[0];
353}
354
355TEST(unescapeJsonCommandLine, ParsesEscapedQuotesInQuotedStrings) {
356  std::vector<std::string> Result = unescapeJsonCommandLine(
357      "\\\"\\\\\\\"\\\"");
358  ASSERT_EQ(1ul, Result.size());
359  EXPECT_EQ("\"", Result[0]);
360}
361
362TEST(unescapeJsonCommandLine, ParsesMultipleArgumentsWithEscapedCharacters) {
363  std::vector<std::string> Result = unescapeJsonCommandLine(
364      "  \\\\\\\"  \\\"a \\\\\\\" b \\\"     \\\"and\\\\\\\\c\\\"   \\\\\\\"");
365  ASSERT_EQ(4ul, Result.size());
366  EXPECT_EQ("\"", Result[0]);
367  EXPECT_EQ("a \" b ", Result[1]);
368  EXPECT_EQ("and\\c", Result[2]);
369  EXPECT_EQ("\"", Result[3]);
370}
371
372TEST(unescapeJsonCommandLine, ParsesStringsWithoutSpacesIntoSingleArgument) {
373  std::vector<std::string> QuotedNoSpaces = unescapeJsonCommandLine(
374      "\\\"a\\\"\\\"b\\\"");
375  ASSERT_EQ(1ul, QuotedNoSpaces.size());
376  EXPECT_EQ("ab", QuotedNoSpaces[0]);
377
378  std::vector<std::string> MixedNoSpaces = unescapeJsonCommandLine(
379      "\\\"a\\\"bcd\\\"ef\\\"\\\"\\\"\\\"g\\\"");
380  ASSERT_EQ(1ul, MixedNoSpaces.size());
381  EXPECT_EQ("abcdefg", MixedNoSpaces[0]);
382}
383
384TEST(unescapeJsonCommandLine, ParsesQuotedStringWithoutClosingQuote) {
385  std::vector<std::string> Unclosed = unescapeJsonCommandLine("\\\"abc");
386  ASSERT_EQ(1ul, Unclosed.size());
387  EXPECT_EQ("abc", Unclosed[0]);
388
389  std::vector<std::string> Empty = unescapeJsonCommandLine("\\\"");
390  ASSERT_EQ(1ul, Empty.size());
391  EXPECT_EQ("", Empty[0]);
392}
393
394TEST(unescapeJsonCommandLine, ParsesSingleQuotedString) {
395  std::vector<std::string> Args = unescapeJsonCommandLine("a'\\\\b \\\"c\\\"'");
396  ASSERT_EQ(1ul, Args.size());
397  EXPECT_EQ("a\\b \"c\"", Args[0]);
398}
399
400TEST(FixedCompilationDatabase, ReturnsFixedCommandLine) {
401  std::vector<std::string> CommandLine;
402  CommandLine.push_back("one");
403  CommandLine.push_back("two");
404  FixedCompilationDatabase Database(".", CommandLine);
405  std::vector<CompileCommand> Result =
406    Database.getCompileCommands("source");
407  ASSERT_EQ(1ul, Result.size());
408  std::vector<std::string> ExpectedCommandLine(1, "clang-tool");
409  ExpectedCommandLine.insert(ExpectedCommandLine.end(),
410                             CommandLine.begin(), CommandLine.end());
411  ExpectedCommandLine.push_back("source");
412  EXPECT_EQ(".", Result[0].Directory);
413  EXPECT_EQ(ExpectedCommandLine, Result[0].CommandLine);
414}
415
416TEST(FixedCompilationDatabase, GetAllFiles) {
417  std::vector<std::string> CommandLine;
418  CommandLine.push_back("one");
419  CommandLine.push_back("two");
420  FixedCompilationDatabase Database(".", CommandLine);
421
422  EXPECT_EQ(0ul, Database.getAllFiles().size());
423}
424
425TEST(FixedCompilationDatabase, GetAllCompileCommands) {
426  std::vector<std::string> CommandLine;
427  CommandLine.push_back("one");
428  CommandLine.push_back("two");
429  FixedCompilationDatabase Database(".", CommandLine);
430
431  EXPECT_EQ(0ul, Database.getAllCompileCommands().size());
432}
433
434TEST(ParseFixedCompilationDatabase, ReturnsNullOnEmptyArgumentList) {
435  int Argc = 0;
436  std::unique_ptr<FixedCompilationDatabase> Database(
437      FixedCompilationDatabase::loadFromCommandLine(Argc, nullptr));
438  EXPECT_FALSE(Database);
439  EXPECT_EQ(0, Argc);
440}
441
442TEST(ParseFixedCompilationDatabase, ReturnsNullWithoutDoubleDash) {
443  int Argc = 2;
444  const char *Argv[] = { "1", "2" };
445  std::unique_ptr<FixedCompilationDatabase> Database(
446      FixedCompilationDatabase::loadFromCommandLine(Argc, Argv));
447  EXPECT_FALSE(Database);
448  EXPECT_EQ(2, Argc);
449}
450
451TEST(ParseFixedCompilationDatabase, ReturnsArgumentsAfterDoubleDash) {
452  int Argc = 5;
453  const char *Argv[] = {
454    "1", "2", "--\0no-constant-folding", "-DDEF3", "-DDEF4"
455  };
456  std::unique_ptr<FixedCompilationDatabase> Database(
457      FixedCompilationDatabase::loadFromCommandLine(Argc, Argv));
458  ASSERT_TRUE((bool)Database);
459  std::vector<CompileCommand> Result =
460    Database->getCompileCommands("source");
461  ASSERT_EQ(1ul, Result.size());
462  ASSERT_EQ(".", Result[0].Directory);
463  std::vector<std::string> CommandLine;
464  CommandLine.push_back("clang-tool");
465  CommandLine.push_back("-DDEF3");
466  CommandLine.push_back("-DDEF4");
467  CommandLine.push_back("source");
468  ASSERT_EQ(CommandLine, Result[0].CommandLine);
469  EXPECT_EQ(2, Argc);
470}
471
472TEST(ParseFixedCompilationDatabase, ReturnsEmptyCommandLine) {
473  int Argc = 3;
474  const char *Argv[] = { "1", "2", "--\0no-constant-folding" };
475  std::unique_ptr<FixedCompilationDatabase> Database(
476      FixedCompilationDatabase::loadFromCommandLine(Argc, Argv));
477  ASSERT_TRUE((bool)Database);
478  std::vector<CompileCommand> Result =
479    Database->getCompileCommands("source");
480  ASSERT_EQ(1ul, Result.size());
481  ASSERT_EQ(".", Result[0].Directory);
482  std::vector<std::string> CommandLine;
483  CommandLine.push_back("clang-tool");
484  CommandLine.push_back("source");
485  ASSERT_EQ(CommandLine, Result[0].CommandLine);
486  EXPECT_EQ(2, Argc);
487}
488
489TEST(ParseFixedCompilationDatabase, HandlesPositionalArgs) {
490  const char *Argv[] = {"1", "2", "--", "-c", "somefile.cpp", "-DDEF3"};
491  int Argc = sizeof(Argv) / sizeof(char*);
492  std::unique_ptr<FixedCompilationDatabase> Database(
493      FixedCompilationDatabase::loadFromCommandLine(Argc, Argv));
494  ASSERT_TRUE((bool)Database);
495  std::vector<CompileCommand> Result =
496    Database->getCompileCommands("source");
497  ASSERT_EQ(1ul, Result.size());
498  ASSERT_EQ(".", Result[0].Directory);
499  std::vector<std::string> Expected;
500  Expected.push_back("clang-tool");
501  Expected.push_back("-c");
502  Expected.push_back("-DDEF3");
503  Expected.push_back("source");
504  ASSERT_EQ(Expected, Result[0].CommandLine);
505  EXPECT_EQ(2, Argc);
506}
507
508TEST(ParseFixedCompilationDatabase, HandlesArgv0) {
509  const char *Argv[] = {"1", "2", "--", "mytool", "somefile.cpp"};
510  int Argc = sizeof(Argv) / sizeof(char*);
511  std::unique_ptr<FixedCompilationDatabase> Database(
512      FixedCompilationDatabase::loadFromCommandLine(Argc, Argv));
513  ASSERT_TRUE((bool)Database);
514  std::vector<CompileCommand> Result =
515    Database->getCompileCommands("source");
516  ASSERT_EQ(1ul, Result.size());
517  ASSERT_EQ(".", Result[0].Directory);
518  std::vector<std::string> Expected;
519  Expected.push_back("clang-tool");
520  Expected.push_back("source");
521  ASSERT_EQ(Expected, Result[0].CommandLine);
522  EXPECT_EQ(2, Argc);
523}
524
525} // end namespace tooling
526} // end namespace clang
527