Improve reliability of CompilationDatabaseTest

[ellis]

Summary

We've seen CompilationDatabaseTest.cpp fail because the order of the files returned by getAllFiles() was in a different order than expected. Use UnorderedElementsAreArray() to handle different file orders.

clang/unittests/Tooling/CompilationDatabaseTest.cpp

 //===- unittest/Tooling/CompilationDatabaseTest.cpp -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/AST/DeclCXX.h"
-#include "clang/AST/DeclGroup.h"
-#include "clang/Frontend/FrontendAction.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "clang/Tooling/FileMatchTrie.h"
 #include "clang/Tooling/JSONCompilationDatabase.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TargetSelect.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <algorithm>
 
 namespace clang {
 namespace tooling {
 
 using testing::ElementsAre;
 using testing::EndsWith;
+using testing::IsEmpty;
+using testing::UnorderedElementsAreArray;
 
 static void expectFailure(StringRef JSONDatabase, StringRef Explanation) {
   std::string ErrorMessage;
   EXPECT_EQ(nullptr,
             JSONCompilationDatabase::loadFromBuffer(JSONDatabase, ErrorMessage,
                                                     JSONCommandLineSyntax::Gnu))
       << "Expected an error because of: " << Explanation.str();
 }
if (!Database) {
     ADD_FAILURE() << ErrorMessage;
     return std::vector<CompileCommand>();
   }
   return Database->getAllCompileCommands();
 }
 
 TEST(JSONCompilationDatabase, GetAllFiles) {
   std::string ErrorMessage;
-  EXPECT_EQ(std::vector<std::string>(),
-            getAllFiles("[]", ErrorMessage, JSONCommandLineSyntax::Gnu))
+  EXPECT_THAT(getAllFiles("[]", ErrorMessage, JSONCommandLineSyntax::Gnu),
+              IsEmpty())
       << ErrorMessage;
 
   std::vector<std::string> expected_files;
   SmallString<16> PathStorage;
   llvm::sys::path::native("//net/dir/file1", PathStorage);
   expected_files.push_back(std::string(PathStorage.str()));
   llvm::sys::path::native("//net/dir/file2", PathStorage);
   expected_files.push_back(std::string(PathStorage.str()));
   llvm::sys::path::native("//net/dir/file3", PathStorage);
   expected_files.push_back(std::string(PathStorage.str()));
   llvm::sys::path::native("//net/file1", PathStorage);
   expected_files.push_back(std::string(PathStorage.str()));
-  EXPECT_EQ(expected_files,
-            getAllFiles(R"json(
+  EXPECT_THAT(getAllFiles(R"json(
             [
               {
                 "directory": "//net/dir",
                 "command": "command",
                 "file": "file1"
               },
               {
                 "directory": "//net/dir",
                 "command": "command",
                 "file": "../file1"
               },
               {
                 "directory": "//net/dir",
                 "command": "command",
                 "file": "file2"
               },
               {
                 "directory": "//net/dir",
                 "command": "command",
                 "file": "//net/dir/foo/../file3"
               }
             ])json",
-                        ErrorMessage, JSONCommandLineSyntax::Gnu))
+                          ErrorMessage, JSONCommandLineSyntax::Gnu),
+              UnorderedElementsAreArray(expected_files))
       << ErrorMessage;
 }
 
 TEST(JSONCompilationDatabase, GetAllCompileCommands) {
   std::string ErrorMessage;
   EXPECT_EQ(
       0u, getAllCompileCommands(JSONCommandLineSyntax::Gnu, "[]", ErrorMessage)
               .size())

 }
 
 TEST(FixedCompilationDatabase, GetAllFiles) {
   std::vector<std::string> CommandLine;
   CommandLine.push_back("one");
   CommandLine.push_back("two");
   FixedCompilationDatabase Database(".", CommandLine);
 
-  EXPECT_EQ(0ul, Database.getAllFiles().size());
+  EXPECT_THAT(Database.getAllFiles(), IsEmpty());
 }
 
 TEST(FixedCompilationDatabase, GetAllCompileCommands) {
   std::vector<std::string> CommandLine;
   CommandLine.push_back("one");
   CommandLine.push_back("two");
   FixedCompilationDatabase Database(".", CommandLine);