[NFCI][Support] Avoid ASSERT_/EXPECT_TRUE(A <op> B)

[lenary]

Summary

The error messages in tests are far better when a test fails if the test
is written using ASSERT_/EXPECT_<operator>(A, B) rather than
ASSERT_/EXPECT_TRUE(A <operator> B).

This commit updates all of llvm/unittests/Support to use these macros
where possible.

This change has not been possible in:

• llvm/unittests/Support/FSUniqueIDTest.cpp - due to not overloading operators beyond ==, != and <.
• llvm/unittests/Support/BranchProbabilityTest.cpp - where the unchanged tests are of the operator overloads themselves.

There are other possibilities of this conversion not being valid, which
have not applied in these tests, as they do not use NULL (they use
nullptr), and they do not use const char* (they use std::string or
StringRef).

[mubashar_]

It seems ok to me.

llvm/unittests/Support/Casting.cpp

 };
 
 // Even with no explicit classof() in Base, we should still be able to cast
 // Derived to its base class.
 TEST(CastingTest, UpcastIsInferred) {
   Derived D;
   EXPECT_TRUE(isa<Base>(D));
   Base *BP = dyn_cast<Base>(&D);
-  EXPECT_TRUE(BP != nullptr);
+  EXPECT_NE(BP, nullptr);
 }
 
 
 // This test verifies that the inferred upcast takes precedence over an
 // explicitly written one. This is important because it verifies that the
 // dynamic check gets optimized away.
 class UseInferredUpcast {
 public:

 TEST(CastingTest, smart_isa) {
   EXPECT_TRUE(!isa<pointer_wrappers::Derived>(MB));
   EXPECT_TRUE(!isa<pointer_wrappers::Derived>(CB));
   EXPECT_TRUE(isa<pointer_wrappers::Derived>(MD));
   EXPECT_TRUE(isa<pointer_wrappers::Derived>(CD));
 }
 
 TEST(CastingTest, smart_cast) {
-  EXPECT_TRUE(cast<pointer_wrappers::Derived>(MD) == &D);
-  EXPECT_TRUE(cast<pointer_wrappers::Derived>(CD) == &D);
+  EXPECT_EQ(cast<pointer_wrappers::Derived>(MD), &D);
+  EXPECT_EQ(cast<pointer_wrappers::Derived>(CD), &D);
 }
 
 TEST(CastingTest, smart_cast_or_null) {
-  EXPECT_TRUE(cast_or_null<pointer_wrappers::Derived>(MN) == nullptr);
-  EXPECT_TRUE(cast_or_null<pointer_wrappers::Derived>(CN) == nullptr);
-  EXPECT_TRUE(cast_or_null<pointer_wrappers::Derived>(MD) == &D);
-  EXPECT_TRUE(cast_or_null<pointer_wrappers::Derived>(CD) == &D);
+  EXPECT_EQ(cast_or_null<pointer_wrappers::Derived>(MN), nullptr);
+  EXPECT_EQ(cast_or_null<pointer_wrappers::Derived>(CN), nullptr);
+  EXPECT_EQ(cast_or_null<pointer_wrappers::Derived>(MD), &D);
+  EXPECT_EQ(cast_or_null<pointer_wrappers::Derived>(CD), &D);
 }
 
 TEST(CastingTest, smart_dyn_cast) {
-  EXPECT_TRUE(dyn_cast<pointer_wrappers::Derived>(MB) == nullptr);
-  EXPECT_TRUE(dyn_cast<pointer_wrappers::Derived>(CB) == nullptr);
-  EXPECT_TRUE(dyn_cast<pointer_wrappers::Derived>(MD) == &D);
-  EXPECT_TRUE(dyn_cast<pointer_wrappers::Derived>(CD) == &D);
+  EXPECT_EQ(dyn_cast<pointer_wrappers::Derived>(MB), nullptr);
+  EXPECT_EQ(dyn_cast<pointer_wrappers::Derived>(CB), nullptr);
+  EXPECT_EQ(dyn_cast<pointer_wrappers::Derived>(MD), &D);
+  EXPECT_EQ(dyn_cast<pointer_wrappers::Derived>(CD), &D);
 }
 
 TEST(CastingTest, smart_dyn_cast_or_null) {
-  EXPECT_TRUE(dyn_cast_or_null<pointer_wrappers::Derived>(MN) == nullptr);
-  EXPECT_TRUE(dyn_cast_or_null<pointer_wrappers::Derived>(CN) == nullptr);
-  EXPECT_TRUE(dyn_cast_or_null<pointer_wrappers::Derived>(MB) == nullptr);
-  EXPECT_TRUE(dyn_cast_or_null<pointer_wrappers::Derived>(CB) == nullptr);
-  EXPECT_TRUE(dyn_cast_or_null<pointer_wrappers::Derived>(MD) == &D);
-  EXPECT_TRUE(dyn_cast_or_null<pointer_wrappers::Derived>(CD) == &D);
+  EXPECT_EQ(dyn_cast_or_null<pointer_wrappers::Derived>(MN), nullptr);
+  EXPECT_EQ(dyn_cast_or_null<pointer_wrappers::Derived>(CN), nullptr);
+  EXPECT_EQ(dyn_cast_or_null<pointer_wrappers::Derived>(MB), nullptr);
+  EXPECT_EQ(dyn_cast_or_null<pointer_wrappers::Derived>(CB), nullptr);
+  EXPECT_EQ(dyn_cast_or_null<pointer_wrappers::Derived>(MD), &D);
+  EXPECT_EQ(dyn_cast_or_null<pointer_wrappers::Derived>(CD), &D);
 }
 
 } // end namespace pointer_wrappers
 } // end namespace

llvm/unittests/Support/CommandLineTest.cpp

TEST(CommandLineTest, ModifyExisitingOption) {
 
   static const char Description[] = "New description";
   static const char ArgString[] = "new-test-option";
   static const char ValueString[] = "Integer";
 
   StringMap<cl::Option *> &Map =
       cl::getRegisteredOptions(*cl::TopLevelSubCommand);
 
-  ASSERT_TRUE(Map.count("test-option") == 1) <<
-    "Could not find option in map.";
+  ASSERT_EQ(Map.count("test-option"), 1u) << "Could not find option in map.";
 
   cl::Option *Retrieved = Map["test-option"];
   ASSERT_EQ(&TestOption, Retrieved) << "Retrieved wrong option.";
 
   ASSERT_NE(Retrieved->Categories.end(),
             find_if(Retrieved->Categories,
                     [&](const llvm::cl::OptionCategory *Cat) {
                       return Cat == &cl::getGeneralCategory();
TEST(CommandLineTest, DefaultOptions) {
   StackSubCommand SC2("sc2", "Second subcommand");
   // Override "-foo" and change type in sc2 SubCommand.  Note that this does not
   // affect "-f" alias, which continues to work correctly.
   StackOption<std::string> SC2_Foo("foo", cl::sub(SC2));
 
   const char *args0[] = {"prog", "-b", "args0 bar string", "-f"};
   EXPECT_TRUE(cl::ParseCommandLineOptions(sizeof(args0) / sizeof(char *), args0,
                                           StringRef(), &llvm::nulls()));
-  EXPECT_TRUE(Bar == "args0 bar string");
+  EXPECT_EQ(Bar, "args0 bar string");
   EXPECT_TRUE(Foo);
   EXPECT_FALSE(SC1_B);
   EXPECT_TRUE(SC2_Foo.empty());
 
   cl::ResetAllOptionOccurrences();
 
   const char *args1[] = {"prog", "sc1", "-b", "-bar", "args1 bar string", "-f"};
   EXPECT_TRUE(cl::ParseCommandLineOptions(sizeof(args1) / sizeof(char *), args1,
                                           StringRef(), &llvm::nulls()));
-  EXPECT_TRUE(Bar == "args1 bar string");
+  EXPECT_EQ(Bar, "args1 bar string");
   EXPECT_TRUE(Foo);
   EXPECT_TRUE(SC1_B);
   EXPECT_TRUE(SC2_Foo.empty());
   for (auto *S : cl::getRegisteredSubcommands()) {
     if (*S) {
       EXPECT_EQ("sc1", S->getName());
     }
   }
 
   cl::ResetAllOptionOccurrences();
 
   const char *args2[] = {"prog", "sc2", "-b", "args2 bar string",
                          "-f", "-foo", "foo string"};
   EXPECT_TRUE(cl::ParseCommandLineOptions(sizeof(args2) / sizeof(char *), args2,
                                           StringRef(), &llvm::nulls()));
-  EXPECT_TRUE(Bar == "args2 bar string");
+  EXPECT_EQ(Bar, "args2 bar string");
   EXPECT_TRUE(Foo);
   EXPECT_FALSE(SC1_B);
-  EXPECT_TRUE(SC2_Foo == "foo string");
+  EXPECT_EQ(SC2_Foo, "foo string");
   for (auto *S : cl::getRegisteredSubcommands()) {
     if (*S) {
       EXPECT_EQ("sc2", S->getName());
     }
   }
   cl::ResetCommandLineParser();
 }
 
TEST(CommandLineTest, ResponseFileWindows) {
   llvm::SmallString<128> RspOpt;
   RspOpt.append(1, '@');
   RspOpt.append(ResponseFile.path());
   const char *args[] = {"prog", RspOpt.c_str()};
   EXPECT_FALSE(TopLevelOpt);
   EXPECT_TRUE(
       cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
   EXPECT_TRUE(TopLevelOpt);
-  EXPECT_TRUE(InputFilenames[0] == "path\\dir\\file1");
-  EXPECT_TRUE(InputFilenames[1] == "path/dir/file2");
+  EXPECT_EQ(InputFilenames[0], "path\\dir\\file1");
+  EXPECT_EQ(InputFilenames[1], "path/dir/file2");
 }
 
 TEST(CommandLineTest, ResponseFiles) {
   vfs::InMemoryFileSystem FS;
 #ifdef _WIN32
   const char *TestRoot = "C:\\";
 #else
   const char *TestRoot = "/";
TEST(CommandLineTest, SetDefautValue) {
   cl::alias Alias("alias", llvm::cl::aliasopt(Opt2));
   StackOption<int> Opt3("opt3", cl::init(3));
 
   const char *args[] = {"prog", "-opt1=false", "-opt2", "-opt3"};
 
   EXPECT_TRUE(
     cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
 
-  EXPECT_TRUE(Opt1 == "false");
+  EXPECT_EQ(Opt1, "false");
   EXPECT_TRUE(Opt2);
-  EXPECT_TRUE(Opt3 == 3);
+  EXPECT_EQ(Opt3, 3);
 
   Opt2 = false;
   Opt3 = 1;
 
   cl::ResetAllOptionOccurrences();
 
   for (auto &OM : cl::getRegisteredOptions(*cl::TopLevelSubCommand)) {
     cl::Option *O = OM.second;
     if (O->ArgStr == "opt2") {
       continue;
     }
     O->setDefault();
   }
 
-  EXPECT_TRUE(Opt1 == "true");
+  EXPECT_EQ(Opt1, "true");
   EXPECT_TRUE(Opt2);
-  EXPECT_TRUE(Opt3 == 3);
+  EXPECT_EQ(Opt3, 3);
   Alias.removeArgument();
 }
 
 TEST(CommandLineTest, ReadConfigFile) {
   llvm::SmallVector<const char *, 1> Argv;
 
   TempDir TestDir("unittest", /*Unique*/ true);
   TempDir TestSubDir(TestDir.path("subdir"), /*Unique*/ false);
TEST(CommandLineTest, PositionalEatArgsError) {
   EXPECT_FALSE(Errs.empty()); Errs.clear();
   EXPECT_FALSE(cl::ParseCommandLineOptions(3, args2, StringRef(), &OS)); OS.flush();
   EXPECT_FALSE(Errs.empty()); Errs.clear();
   EXPECT_TRUE(cl::ParseCommandLineOptions(3, args3, StringRef(), &OS)); OS.flush();
   EXPECT_TRUE(Errs.empty()); Errs.clear();
 
   cl::ResetAllOptionOccurrences();
   EXPECT_TRUE(cl::ParseCommandLineOptions(6, args4, StringRef(), &OS)); OS.flush();
-  EXPECT_TRUE(PosEatArgs.size() == 1);
-  EXPECT_TRUE(PosEatArgs2.size() == 2);
+  EXPECT_EQ(PosEatArgs.size(), 1u);
+  EXPECT_EQ(PosEatArgs2.size(), 2u);
   EXPECT_TRUE(Errs.empty());
 }
 
 #ifdef _WIN32
 void checkSeparators(StringRef Path) {
   char UndesiredSeparator = sys::path::get_separator()[0] == '/' ? '\\' : '/';
   ASSERT_EQ(Path.find(UndesiredSeparator), StringRef::npos);
 }
TEST(CommandLineTest, PrefixOptions) {
   StackOption<std::string, cl::list<std::string>> IncludeDirs(
       "I", cl::Prefix, cl::desc("Declare an include directory"));
 
   // Test non-prefixed variant works with cl::Prefix options.
   EXPECT_TRUE(IncludeDirs.empty());
   const char *args[] = {"prog", "-I=/usr/include"};
   EXPECT_TRUE(
       cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
-  EXPECT_TRUE(IncludeDirs.size() == 1);
-  EXPECT_TRUE(IncludeDirs.front().compare("/usr/include") == 0);
+  EXPECT_EQ(IncludeDirs.size(), 1u);
+  EXPECT_EQ(IncludeDirs.front().compare("/usr/include"), 0);
 
   IncludeDirs.erase(IncludeDirs.begin());
   cl::ResetAllOptionOccurrences();
 
   // Test non-prefixed variant works with cl::Prefix options when value is
   // passed in following argument.
   EXPECT_TRUE(IncludeDirs.empty());
   const char *args2[] = {"prog", "-I", "/usr/include"};
   EXPECT_TRUE(
       cl::ParseCommandLineOptions(3, args2, StringRef(), &llvm::nulls()));
-  EXPECT_TRUE(IncludeDirs.size() == 1);
-  EXPECT_TRUE(IncludeDirs.front().compare("/usr/include") == 0);
+  EXPECT_EQ(IncludeDirs.size(), 1u);
+  EXPECT_EQ(IncludeDirs.front().compare("/usr/include"), 0);
 
   IncludeDirs.erase(IncludeDirs.begin());
   cl::ResetAllOptionOccurrences();
 
   // Test prefixed variant works with cl::Prefix options.
   EXPECT_TRUE(IncludeDirs.empty());
   const char *args3[] = {"prog", "-I/usr/include"};
   EXPECT_TRUE(
       cl::ParseCommandLineOptions(2, args3, StringRef(), &llvm::nulls()));
-  EXPECT_TRUE(IncludeDirs.size() == 1);
-  EXPECT_TRUE(IncludeDirs.front().compare("/usr/include") == 0);
+  EXPECT_EQ(IncludeDirs.size(), 1u);
+  EXPECT_EQ(IncludeDirs.front().compare("/usr/include"), 0);
 
   StackOption<std::string, cl::list<std::string>> MacroDefs(
       "D", cl::AlwaysPrefix, cl::desc("Define a macro"),
       cl::value_desc("MACRO[=VALUE]"));
 
   cl::ResetAllOptionOccurrences();
 
   // Test non-prefixed variant does not work with cl::AlwaysPrefix options:
   // equal sign is part of the value.
   EXPECT_TRUE(MacroDefs.empty());
   const char *args4[] = {"prog", "-D=HAVE_FOO"};
   EXPECT_TRUE(
       cl::ParseCommandLineOptions(2, args4, StringRef(), &llvm::nulls()));
-  EXPECT_TRUE(MacroDefs.size() == 1);
-  EXPECT_TRUE(MacroDefs.front().compare("=HAVE_FOO") == 0);
+  EXPECT_EQ(MacroDefs.size(), 1u);
+  EXPECT_EQ(MacroDefs.front().compare("=HAVE_FOO"), 0);
 
   MacroDefs.erase(MacroDefs.begin());
   cl::ResetAllOptionOccurrences();
 
   // Test non-prefixed variant does not allow value to be passed in following
   // argument with cl::AlwaysPrefix options.
   EXPECT_TRUE(MacroDefs.empty());
   const char *args5[] = {"prog", "-D", "HAVE_FOO"};
   EXPECT_FALSE(
       cl::ParseCommandLineOptions(3, args5, StringRef(), &llvm::nulls()));
   EXPECT_TRUE(MacroDefs.empty());
 
   cl::ResetAllOptionOccurrences();
 
   // Test prefixed variant works with cl::AlwaysPrefix options.
   EXPECT_TRUE(MacroDefs.empty());
   const char *args6[] = {"prog", "-DHAVE_FOO"};
   EXPECT_TRUE(
       cl::ParseCommandLineOptions(2, args6, StringRef(), &llvm::nulls()));
-  EXPECT_TRUE(MacroDefs.size() == 1);
-  EXPECT_TRUE(MacroDefs.front().compare("HAVE_FOO") == 0);
+  EXPECT_EQ(MacroDefs.size(), 1u);
+  EXPECT_EQ(MacroDefs.front().compare("HAVE_FOO"), 0);
 }
 
 TEST(CommandLineTest, GroupingWithValue) {
   cl::ResetCommandLineParser();
 
   StackOption<bool> OptF("f", cl::Grouping, cl::desc("Some flag"));
   StackOption<bool> OptB("b", cl::Grouping, cl::desc("Another flag"));
   StackOption<bool> OptD("d", cl::Grouping, cl::ValueDisallowed,
TEST(CommandLineTest, OptionErrorMessage) {
   StackOption<bool> OptA("a", cl::desc("Some option"));
   StackOption<bool> OptLong("long", cl::desc("Some long option"));
 
   std::string Errs;
   raw_string_ostream OS(Errs);
 
   OptA.error("custom error", OS);
   OS.flush();
-  EXPECT_FALSE(Errs.find("for the -a option:") == std::string::npos);
+  EXPECT_NE(Errs.find("for the -a option:"), std::string::npos);
   Errs.clear();
 
   OptLong.error("custom error", OS);
   OS.flush();
-  EXPECT_FALSE(Errs.find("for the --long option:") == std::string::npos);
+  EXPECT_NE(Errs.find("for the --long option:"), std::string::npos);
   Errs.clear();
 
   cl::ResetAllOptionOccurrences();
 }
 
 TEST(CommandLineTest, OptionErrorMessageSuggest) {
   // When there is an error, and the edit-distance is not very large,
   // we expect some error message like:
   //   prog: did you mean '--option'?
   //
   // Test whether this message is well-formatted.
   cl::ResetCommandLineParser();
 
   StackOption<bool> OptLong("aluminium", cl::desc("Some long option"));
 
   const char *args[] = {"prog", "--aluminum"};
 
   std::string Errs;
   raw_string_ostream OS(Errs);
 
   EXPECT_FALSE(cl::ParseCommandLineOptions(2, args, StringRef(), &OS));
   OS.flush();
-  EXPECT_FALSE(Errs.find("prog: Did you mean '--aluminium'?\n") ==
-               std::string::npos);
+  EXPECT_NE(Errs.find("prog: Did you mean '--aluminium'?\n"),
   Errs.clear();
 
   cl::ResetAllOptionOccurrences();
 }
 
 TEST(CommandLineTest, OptionErrorMessageSuggestNoHidden) {
   // We expect that 'really hidden' option do not show up in option
   // suggestions.
   cl::ResetCommandLineParser();
 
   StackOption<bool> OptLong("aluminium", cl::desc("Some long option"));
   StackOption<bool> OptLong2("aluminum", cl::desc("Bad option"),
                              cl::ReallyHidden);
 
   const char *args[] = {"prog", "--alumnum"};
 
   std::string Errs;
   raw_string_ostream OS(Errs);
 
   EXPECT_FALSE(cl::ParseCommandLineOptions(2, args, StringRef(), &OS));
   OS.flush();
-  EXPECT_FALSE(Errs.find("prog: Did you mean '--aluminium'?\n") ==
-               std::string::npos);
+  EXPECT_NE(Errs.find("prog: Did you mean '--aluminium'?\n"),
   Errs.clear();
 
   cl::ResetAllOptionOccurrences();
 }
 
 TEST(CommandLineTest, Callback) {
   cl::ResetCommandLineParser();
 
StackOption<std::string, cl::list<std::string>> List(
           OptC = true;
       }));
 
   const char *args1[] = {"prog", "-a"};
   EXPECT_TRUE(cl::ParseCommandLineOptions(2, args1));
   EXPECT_TRUE(OptA);
   EXPECT_FALSE(OptB);
   EXPECT_FALSE(OptC);
-  EXPECT_TRUE(List.size() == 0);
+  EXPECT_EQ(List.size(), 0u);
   cl::ResetAllOptionOccurrences();
 
   const char *args2[] = {"prog", "-b"};
   EXPECT_TRUE(cl::ParseCommandLineOptions(2, args2));
   EXPECT_TRUE(OptA);
   EXPECT_TRUE(OptB);
   EXPECT_FALSE(OptC);
-  EXPECT_TRUE(List.size() == 0);
+  EXPECT_EQ(List.size(), 0u);
   cl::ResetAllOptionOccurrences();
 
   const char *args3[] = {"prog", "-c"};
   EXPECT_TRUE(cl::ParseCommandLineOptions(2, args3));
   EXPECT_TRUE(OptA);
   EXPECT_TRUE(OptB);
   EXPECT_TRUE(OptC);
-  EXPECT_TRUE(List.size() == 0);
+  EXPECT_EQ(List.size(), 0u);
   cl::ResetAllOptionOccurrences();
 
   const char *args4[] = {"prog", "--list=foo,bar"};
   EXPECT_TRUE(cl::ParseCommandLineOptions(2, args4));
   EXPECT_TRUE(OptA);
   EXPECT_TRUE(OptB);
   EXPECT_TRUE(OptC);
-  EXPECT_TRUE(List.size() == 2);
+  EXPECT_EQ(List.size(), 2u);
   cl::ResetAllOptionOccurrences();
 
   const char *args5[] = {"prog", "--list=bar"};
   EXPECT_TRUE(cl::ParseCommandLineOptions(2, args5));
   EXPECT_FALSE(OptA);
   EXPECT_FALSE(OptB);
   EXPECT_FALSE(OptC);
-  EXPECT_TRUE(List.size() == 1);
+  EXPECT_EQ(List.size(), 1u);
 
   cl::ResetAllOptionOccurrences();
 }
 
 enum Enum { Val1, Val2 };
 static cl::bits<Enum> ExampleBits(
     cl::desc("An example cl::bits to ensure it compiles"),
     cl::values(
TEST(CommandLineTest, ConsumeAfterOnePositional) {
 
   const char *Args[] = {"prog", "input", "arg1", "arg2"};
 
   std::string Errs;
   raw_string_ostream OS(Errs);
   EXPECT_TRUE(cl::ParseCommandLineOptions(4, Args, StringRef(), &OS));
   OS.flush();
   EXPECT_EQ("input", Input);
-  EXPECT_TRUE(ExtraArgs.size() == 2);
-  EXPECT_TRUE(ExtraArgs[0] == "arg1");
-  EXPECT_TRUE(ExtraArgs[1] == "arg2");
+  EXPECT_EQ(ExtraArgs.size(), 2u);
+  EXPECT_EQ(ExtraArgs[0], "arg1");
+  EXPECT_EQ(ExtraArgs[1], "arg2");
   EXPECT_TRUE(Errs.empty());
 }
 
 TEST(CommandLineTest, ConsumeAfterTwoPositionals) {
   cl::ResetCommandLineParser();
 
   // input1 input2 [args]
   StackOption<std::string, cl::opt<std::string>> Input1(cl::Positional,
                                                         cl::Required);
   StackOption<std::string, cl::opt<std::string>> Input2(cl::Positional,
                                                         cl::Required);
   StackOption<std::string, cl::list<std::string>> ExtraArgs(cl::ConsumeAfter);
 
   const char *Args[] = {"prog", "input1", "input2", "arg1", "arg2"};
 
   std::string Errs;
   raw_string_ostream OS(Errs);
   EXPECT_TRUE(cl::ParseCommandLineOptions(5, Args, StringRef(), &OS));
   OS.flush();
   EXPECT_EQ("input1", Input1);
   EXPECT_EQ("input2", Input2);
-  EXPECT_TRUE(ExtraArgs.size() == 2);
-  EXPECT_TRUE(ExtraArgs[0] == "arg1");
-  EXPECT_TRUE(ExtraArgs[1] == "arg2");
+  EXPECT_EQ(ExtraArgs.size(), 2u);
+  EXPECT_EQ(ExtraArgs[0], "arg1");
+  EXPECT_EQ(ExtraArgs[1], "arg2");
   EXPECT_TRUE(Errs.empty());
 }
 
 TEST(CommandLineTest, ResetAllOptionOccurrences) {
   cl::ResetCommandLineParser();
 
   // -option [sink] input [args]
   StackOption<bool> Option("option");
   StackOption<std::string, cl::list<std::string>> Sink(cl::Sink);
   StackOption<std::string> Input(cl::Positional);
   StackOption<std::string, cl::list<std::string>> ExtraArgs(cl::ConsumeAfter);
 
   const char *Args[] = {"prog", "-option", "-unknown", "input", "-arg"};
 
   std::string Errs;
   raw_string_ostream OS(Errs);
   EXPECT_TRUE(cl::ParseCommandLineOptions(5, Args, StringRef(), &OS));
   EXPECT_TRUE(OS.str().empty());
 
   EXPECT_TRUE(Option);
-  EXPECT_EQ(1, (int)Sink.size());
+  EXPECT_EQ(1u, Sink.size());
   EXPECT_EQ("-unknown", Sink[0]);
   EXPECT_EQ("input", Input);
-  EXPECT_EQ(1, (int)ExtraArgs.size());
+  EXPECT_EQ(1u, ExtraArgs.size());
   EXPECT_EQ("-arg", ExtraArgs[0]);
 
   cl::ResetAllOptionOccurrences();
   EXPECT_FALSE(Option);
-  EXPECT_EQ(0, (int)Sink.size());
+  EXPECT_EQ(0u, Sink.size());
   EXPECT_EQ(0, Input.getNumOccurrences());
-  EXPECT_EQ(0, (int)ExtraArgs.size());
+  EXPECT_EQ(0u, ExtraArgs.size());
 }
 
 } // anonymous namespace

llvm/unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp

TEST(DynamicLibrary, Overload) {
     std::string Err;
     llvm_shutdown_obj Shutdown;
     DynamicLibrary DL =
         DynamicLibrary::getPermanentLibrary(LibPath().c_str(), &Err);
     EXPECT_TRUE(DL.isValid());
     EXPECT_TRUE(Err.empty());
 
     GetString GS = FuncPtr<GetString>(DL.getAddressOfSymbol("TestA"));
-    EXPECT_TRUE(GS != nullptr && GS != &TestA);
+    EXPECT_NE(GS, nullptr);
+    EXPECT_NE(GS, &TestA);
     EXPECT_EQ(StdString(GS()), "LibCall");
 
     GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
-    EXPECT_TRUE(GS != nullptr && GS != &TestA);
+    EXPECT_NE(GS, nullptr);
+    EXPECT_NE(GS, &TestA);
     EXPECT_EQ(StdString(GS()), "LibCall");
 
     DL = DynamicLibrary::getPermanentLibrary(nullptr, &Err);
     EXPECT_TRUE(DL.isValid());
     EXPECT_TRUE(Err.empty());
 
     // Test overloading local symbols does not occur by default
     GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
-    EXPECT_TRUE(GS != nullptr && GS == &TestA);
+    EXPECT_NE(GS, nullptr);
+    EXPECT_EQ(GS, &TestA);
     EXPECT_EQ(StdString(GS()), "ProcessCall");
 
     GS = FuncPtr<GetString>(DL.getAddressOfSymbol("TestA"));
-    EXPECT_TRUE(GS != nullptr && GS == &TestA);
+    EXPECT_NE(GS, nullptr);
+    EXPECT_EQ(GS, &TestA);
     EXPECT_EQ(StdString(GS()), "ProcessCall");
 
     // Test overloading by forcing library priority when searching for a symbol
     DynamicLibrary::SearchOrder = DynamicLibrary::SO_LoadedFirst;
     GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
-    EXPECT_TRUE(GS != nullptr && GS != &TestA);
+    EXPECT_NE(GS, nullptr);
+    EXPECT_NE(GS, &TestA);
     EXPECT_EQ(StdString(GS()), "LibCall");
 
     DynamicLibrary::AddSymbol("TestA", PtrFunc(&OverloadTestA));
     GS = FuncPtr<GetString>(DL.getAddressOfSymbol("TestA"));
-    EXPECT_TRUE(GS != nullptr && GS != &OverloadTestA);
+    EXPECT_NE(GS, nullptr);
+    EXPECT_NE(GS, &OverloadTestA);
 
     GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
-    EXPECT_TRUE(GS != nullptr && GS == &OverloadTestA);
+    EXPECT_NE(GS, nullptr);
+    EXPECT_EQ(GS, &OverloadTestA);
     EXPECT_EQ(StdString(GS()), "OverloadCall");
   }
   EXPECT_TRUE(FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol(
                   "TestA")) == nullptr);
 
   // Check serach ordering is reset to default after call to llvm_shutdown
-  EXPECT_TRUE(DynamicLibrary::SearchOrder == DynamicLibrary::SO_Linker);
+  EXPECT_EQ(DynamicLibrary::SearchOrder, DynamicLibrary::SO_Linker);
 }
 
 TEST(DynamicLibrary, Shutdown) {
   std::string A("PipSqueak"), B, C("SecondLib");
   std::vector<std::string> Order;
   {
     std::string Err;
     llvm_shutdown_obj Shutdown;
     DynamicLibrary DL =
         DynamicLibrary::getPermanentLibrary(LibPath(A).c_str(), &Err);
     EXPECT_TRUE(DL.isValid());
     EXPECT_TRUE(Err.empty());
 
     SetStrings SS_0 = FuncPtr<SetStrings>(
         DynamicLibrary::SearchForAddressOfSymbol("SetStrings"));
-    EXPECT_TRUE(SS_0 != nullptr);
+    EXPECT_NE(SS_0, nullptr);
 
     SS_0(A, B);
     EXPECT_EQ(B, "Local::Local(PipSqueak)");
 
     TestOrder TO_0 = FuncPtr<TestOrder>(
         DynamicLibrary::SearchForAddressOfSymbol("TestOrder"));
-    EXPECT_TRUE(TO_0 != nullptr);
-    
+    EXPECT_NE(TO_0, nullptr);
     DynamicLibrary DL2 =
         DynamicLibrary::getPermanentLibrary(LibPath(C).c_str(), &Err);
     EXPECT_TRUE(DL2.isValid());
     EXPECT_TRUE(Err.empty());
 
     // Should find latest version of symbols in SecondLib
     SetStrings SS_1 = FuncPtr<SetStrings>(
         DynamicLibrary::SearchForAddressOfSymbol("SetStrings"));
-    EXPECT_TRUE(SS_1 != nullptr);
-    EXPECT_TRUE(SS_0 != SS_1);
+    EXPECT_NE(SS_1, nullptr);
+    EXPECT_NE(SS_0, SS_1);
 
     TestOrder TO_1 = FuncPtr<TestOrder>(
         DynamicLibrary::SearchForAddressOfSymbol("TestOrder"));
-    EXPECT_TRUE(TO_1 != nullptr);
-    EXPECT_TRUE(TO_0 != TO_1);
+    EXPECT_NE(TO_1, nullptr);
+    EXPECT_NE(TO_0, TO_1);
 
     B.clear();
     SS_1(C, B);
     EXPECT_EQ(B, "Local::Local(SecondLib)");
 
     TO_0(Order);
     TO_1(Order);
   }
   EXPECT_EQ(A, "Global::~Global");
   EXPECT_EQ(B, "Local::~Local");
-  EXPECT_TRUE(FuncPtr<SetStrings>(DynamicLibrary::SearchForAddressOfSymbol(
-                  "SetStrings")) == nullptr);
+  EXPECT_EQ(FuncPtr<SetStrings>(
+                DynamicLibrary::SearchForAddressOfSymbol("SetStrings")),
+            nullptr);
 
   // Test unload/destruction ordering
   EXPECT_EQ(Order.size(), 2UL);
   EXPECT_EQ(Order.front(), "SecondLib");
   EXPECT_EQ(Order.back(), "PipSqueak");
 }
 
 #else

llvm/unittests/Support/ErrorTest.cpp

 
 // Check that we can handle a custom error.
 TEST(Error, HandleCustomError) {
   int CaughtErrorInfo = 0;
   handleAllErrors(make_error<CustomError>(42), [&](const CustomError &CE) {
     CaughtErrorInfo = CE.getInfo();
   });
 
-  EXPECT_TRUE(CaughtErrorInfo == 42) << "Wrong result from CustomError handler";
+  EXPECT_EQ(CaughtErrorInfo, 42) << "Wrong result from CustomError handler";
 }
 
 // Check that handler type deduction also works for handlers
 // of the following types:
 // void (const Err&)
 // Error (const Err&) mutable
 // void (const Err&) mutable
 // Error (Err&)
TEST(Error, HandleCustomErrorWithCustomBaseClass) {
   int CaughtErrorInfo = 0;
   int CaughtErrorExtraInfo = 0;
   handleAllErrors(make_error<CustomSubError>(42, 7),
                   [&](const CustomSubError &SE) {
                     CaughtErrorInfo = SE.getInfo();
                     CaughtErrorExtraInfo = SE.getExtraInfo();
                   });
 
-  EXPECT_TRUE(CaughtErrorInfo == 42 && CaughtErrorExtraInfo == 7)
+  EXPECT_EQ(CaughtErrorInfo, 42) << "Wrong result from CustomSubError handler";
+  EXPECT_EQ(CaughtErrorExtraInfo, 7)
       << "Wrong result from CustomSubError handler";
 }
 
 // Check that we trigger only the first handler that applies.
 TEST(Error, FirstHandlerOnly) {
   int DummyInfo = 0;
   int CaughtErrorInfo = 0;
   int CaughtErrorExtraInfo = 0;
 
   handleAllErrors(make_error<CustomSubError>(42, 7),
                   [&](const CustomSubError &SE) {
                     CaughtErrorInfo = SE.getInfo();
                     CaughtErrorExtraInfo = SE.getExtraInfo();
                   },
                   [&](const CustomError &CE) { DummyInfo = CE.getInfo(); });
 
-  EXPECT_TRUE(CaughtErrorInfo == 42 && CaughtErrorExtraInfo == 7 &&
-              DummyInfo == 0)
-      << "Activated the wrong Error handler(s)";
+  EXPECT_EQ(CaughtErrorInfo, 42) << "Activated the wrong Error handler(s)";
+  EXPECT_EQ(CaughtErrorExtraInfo, 7) << "Activated the wrong Error handler(s)";
+  EXPECT_EQ(DummyInfo, 0) << "Activated the wrong Error handler(s)";
 }
 
 // Check that general handlers shadow specific ones.
 TEST(Error, HandlerShadowing) {
   int CaughtErrorInfo = 0;
   int DummyInfo = 0;
   int DummyExtraInfo = 0;
 
   handleAllErrors(
       make_error<CustomSubError>(42, 7),
       [&](const CustomError &CE) { CaughtErrorInfo = CE.getInfo(); },
       [&](const CustomSubError &SE) {
         DummyInfo = SE.getInfo();
         DummyExtraInfo = SE.getExtraInfo();
       });
 
-  EXPECT_TRUE(CaughtErrorInfo == 42 && DummyInfo == 0 && DummyExtraInfo == 0)
+  EXPECT_EQ(CaughtErrorInfo, 42)
+      << "General Error handler did not shadow specific handler";
+  EXPECT_EQ(DummyInfo, 0)
+      << "General Error handler did not shadow specific handler";
+  EXPECT_EQ(DummyExtraInfo, 0)
       << "General Error handler did not shadow specific handler";
 }
 
 // Test joinErrors.
 TEST(Error, CheckJoinErrors) {
   int CustomErrorInfo1 = 0;
   int CustomErrorInfo2 = 0;
   int CustomErrorExtraInfo = 0;
handleAllErrors(std::move(E),
                     // CustomSubError - joinErrors should preserve error
                     // ordering.
                     EXPECT_EQ(CustomErrorInfo2, 0)
                         << "CustomErrorInfo2 should be 0 here. "
                            "joinErrors failed to preserve ordering.\n";
                     CustomErrorInfo1 = CE.getInfo();
                   });
 
-  EXPECT_TRUE(CustomErrorInfo1 == 7 && CustomErrorInfo2 == 42 &&
-              CustomErrorExtraInfo == 7)
-      << "Failed handling compound Error.";
+  EXPECT_EQ(CustomErrorInfo1, 7) << "Failed handling compound Error.";
+  EXPECT_EQ(CustomErrorInfo2, 42) << "Failed handling compound Error.";
+  EXPECT_EQ(CustomErrorExtraInfo, 7) << "Failed handling compound Error.";
 
   // Test appending a single item to a list.
   {
     int Sum = 0;
     handleAllErrors(
         joinErrors(
             joinErrors(make_error<CustomError>(7),
                        make_error<CustomError>(7)),

llvm/unittests/Support/FSUniqueIDTest.cpp

 namespace {
 
 TEST(FSUniqueIDTest, construct) {
   EXPECT_EQ(20u, UniqueID(20, 10).getDevice());
   EXPECT_EQ(10u, UniqueID(20, 10).getFile());
 }
 
 TEST(FSUniqueIDTest, equals) {
-  EXPECT_TRUE(UniqueID(20, 10) == UniqueID(20, 10));
-  EXPECT_FALSE(UniqueID(20, 20) == UniqueID(20, 10));
-  EXPECT_FALSE(UniqueID(10, 10) == UniqueID(20, 10));
+  EXPECT_EQ(UniqueID(20, 10), UniqueID(20, 10));
+  EXPECT_NE(UniqueID(20, 20), UniqueID(20, 10));
+  EXPECT_NE(UniqueID(10, 10), UniqueID(20, 10));
 }
 
 TEST(FSUniqueIDTest, less) {
   EXPECT_FALSE(UniqueID(20, 2) < UniqueID(20, 2));
   EXPECT_FALSE(UniqueID(20, 3) < UniqueID(20, 2));
   EXPECT_FALSE(UniqueID(30, 2) < UniqueID(20, 2));
   EXPECT_FALSE(UniqueID(30, 2) < UniqueID(20, 40));
   EXPECT_TRUE(UniqueID(20, 2) < UniqueID(20, 3));
   EXPECT_TRUE(UniqueID(20, 2) < UniqueID(30, 2));
   EXPECT_TRUE(UniqueID(20, 40) < UniqueID(30, 2));
 }
 
 } // anonymous namespace

llvm/unittests/Support/IndexedAccessorTest.cpp

struct ArrayIndexedAccessorRange
   /// See `llvm::indexed_accessor_range` for details.
   static T &dereference(T *data, ptrdiff_t index) { return data[index]; }
 };
 } // end anonymous namespace
 
 template <typename T>
 static void compareData(ArrayIndexedAccessorRange<T> range,
                         ArrayRef<T> referenceData) {
-  ASSERT_TRUE(referenceData.size() == range.size());
+  ASSERT_EQ(referenceData.size(), range.size());
   ASSERT_TRUE(std::equal(range.begin(), range.end(), referenceData.begin()));
 }
 
 namespace {
 TEST(AccessorRange, SliceTest) {
   int rawData[] = {0, 1, 2, 3, 4};
   ArrayRef<int> data = llvm::makeArrayRef(rawData);
 
   ArrayIndexedAccessorRange<int> range(rawData, /*start=*/0, /*numElements=*/5);
   compareData(range, data);
   compareData(range.slice(2, 3), data.slice(2, 3));
   compareData(range.slice(0, 5), data.slice(0, 5));
 }
 } // end anonymous namespace

llvm/unittests/Support/JSONTest.cpp

 }
 
 TEST(JSONTest, Object) {
   Object O{{"a", 1}, {"b", 2}, {"c", 3}};
   EXPECT_TRUE(O.try_emplace("d", 4).second);
   EXPECT_FALSE(O.try_emplace("a", 4).second);
 
   auto D = O.find("d");
-  EXPECT_FALSE(D == O.end());
+  EXPECT_NE(D, O.end());
   auto E = O.find("e");
-  EXPECT_TRUE(E == O.end());
+  EXPECT_EQ(E, O.end());
 
   O.erase("b");
   O.erase(D);
   EXPECT_EQ(O.size(), 2u);
   EXPECT_EQ(R"({"a":1,"c":3})", s(std::move(O)));
 }
 
 TEST(JSONTest, Parse) {

llvm/unittests/Support/MemoryBufferTest.cpp

protected:
   typedef std::unique_ptr<MemoryBuffer> OwningBuffer;
 
   std::string data;
 };
 
 TEST_F(MemoryBufferTest, get) {
   // Default name and null-terminator flag
   OwningBuffer MB1(MemoryBuffer::getMemBuffer(data));
-  EXPECT_TRUE(nullptr != MB1.get());
+  EXPECT_NE(nullptr, MB1.get());
 
   // RequiresNullTerminator = false
   OwningBuffer MB2(MemoryBuffer::getMemBuffer(data, "one", false));
-  EXPECT_TRUE(nullptr != MB2.get());
+  EXPECT_NE(nullptr, MB2.get());
 
   // RequiresNullTerminator = true
   OwningBuffer MB3(MemoryBuffer::getMemBuffer(data, "two", true));
-  EXPECT_TRUE(nullptr != MB3.get());
+  EXPECT_NE(nullptr, MB3.get());
 
   // verify all 3 buffers point to the same address
   EXPECT_EQ(MB1->getBufferStart(), MB2->getBufferStart());
   EXPECT_EQ(MB2->getBufferStart(), MB3->getBufferStart());
 
   // verify the original data is unmodified after deleting the buffers
   MB1.reset();
   MB2.reset();
TEST_F(MemoryBufferTest, NullTerminator4K) {
   const char *BufData = MB.get()->getBufferStart();
   EXPECT_EQ('f', BufData[4095]);
   EXPECT_EQ('\0', BufData[4096]);
 }
 
 TEST_F(MemoryBufferTest, copy) {
   // copy with no name
   OwningBuffer MBC1(MemoryBuffer::getMemBufferCopy(data));
-  EXPECT_TRUE(nullptr != MBC1.get());
+  EXPECT_NE(nullptr, MBC1.get());
 
   // copy with a name
   OwningBuffer MBC2(MemoryBuffer::getMemBufferCopy(data, "copy"));
-  EXPECT_TRUE(nullptr != MBC2.get());
+  EXPECT_NE(nullptr, MBC2.get());
 
   // verify the two copies do not point to the same place
   EXPECT_NE(MBC1->getBufferStart(), MBC2->getBufferStart());
 }
 
 #if LLVM_ENABLE_THREADS
 TEST_F(MemoryBufferTest, createFromPipe) {
   sys::fs::file_t pipes[2];
#endif
   ASSERT_NO_ERROR(MB.getError());
   EXPECT_EQ(MB.get()->getBuffer(), "foofoofoofoofoo");
 }
 #endif
 
 TEST_F(MemoryBufferTest, make_new) {
   // 0-sized buffer
   OwningBuffer Zero(WritableMemoryBuffer::getNewUninitMemBuffer(0));
-  EXPECT_TRUE(nullptr != Zero.get());
+  EXPECT_NE(nullptr, Zero.get());
 
   // uninitialized buffer with no name
   OwningBuffer One(WritableMemoryBuffer::getNewUninitMemBuffer(321));
-  EXPECT_TRUE(nullptr != One.get());
+  EXPECT_NE(nullptr, One.get());
 
   // uninitialized buffer with name
   OwningBuffer Two(WritableMemoryBuffer::getNewUninitMemBuffer(123, "bla"));
-  EXPECT_TRUE(nullptr != Two.get());
+  EXPECT_NE(nullptr, Two.get());
 
   // 0-initialized buffer with no name
   OwningBuffer Three(WritableMemoryBuffer::getNewMemBuffer(321, data));
-  EXPECT_TRUE(nullptr != Three.get());
+  EXPECT_NE(nullptr, Three.get());
   for (size_t i = 0; i < 321; ++i)
     EXPECT_EQ(0, Three->getBufferStart()[0]);
 
   // 0-initialized buffer with name
   OwningBuffer Four(WritableMemoryBuffer::getNewMemBuffer(123, "zeros"));
-  EXPECT_TRUE(nullptr != Four.get());
+  EXPECT_NE(nullptr, Four.get());
   for (size_t i = 0; i < 123; ++i)
     EXPECT_EQ(0, Four->getBufferStart()[0]);
 }
 
 void MemoryBufferTest::testGetOpenFileSlice(bool Reopen) {
   // Test that MemoryBuffer::getOpenFile works properly when no null
   // terminator is requested and the size is large enough to trigger
   // the usage of memory mapping.

llvm/unittests/Support/Path.cpp

TEST_F(FileSystemTest, widenPath) {
   // UTF-8 length.
   std::string Input("C:\\foldername\\");
   const std::string Pi("\xcf\x80"); // UTF-8 lower case pi.
   // Add Pi up to the MAX_PATH limit.
   const size_t NumChars = MAX_PATH - Input.size() - 1;
   for (size_t i = 0; i < NumChars; ++i)
     Input += Pi;
   // Check that UTF-8 length already exceeds MAX_PATH.
-  EXPECT_TRUE(Input.size() > MAX_PATH);
+  EXPECT_GT(Input.size(), MAX_PATH);
   SmallVector<wchar_t, MAX_PATH + 16> Result;
   ASSERT_NO_ERROR(windows::widenPath(Input, Result));
   // Result should not start with the long path prefix.
   EXPECT_TRUE(std::wmemcmp(Result.data(), LongPathPrefix.c_str(),
                            LongPathPrefix.size()) != 0);
   EXPECT_EQ(Result.size(), (size_t)MAX_PATH - 1);
 
   // Add another Pi to exceed the MAX_PATH limit.

llvm/unittests/Support/ProgramTest.cpp

TEST(ProgramTest, TestExecuteNegative) {
   std::string Executable = "i_dont_exist";
   StringRef argv[] = {Executable};
 
   {
     std::string Error;
     bool ExecutionFailed;
     int RetCode = ExecuteAndWait(Executable, argv, llvm::None, {}, 0, 0, &Error,
                                  &ExecutionFailed);
-    ASSERT_TRUE(RetCode < 0) << "On error ExecuteAndWait should return 0 or "
-                                "positive value indicating the result code";
+    ASSERT_LT(RetCode, 0) << "On error ExecuteAndWait should return 0 or "
     ASSERT_TRUE(ExecutionFailed);
     ASSERT_FALSE(Error.empty());
   }
 
   {
     std::string Error;
     bool ExecutionFailed;
     ProcessInfo PI = ExecuteNoWait(Executable, argv, llvm::None, {}, 0, &Error,

llvm/unittests/Support/TarWriterTest.cpp

static std::vector<uint8_t> createTar(StringRef Base, StringRef Filename) {
   // unmap first and then remove the temporary file.
   MB = nullptr;
 
   return Buf;
 }
 
 static UstarHeader createUstar(StringRef Base, StringRef Filename) {
   std::vector<uint8_t> Buf = createTar(Base, Filename);
-  EXPECT_TRUE(Buf.size() >= sizeof(UstarHeader));
+  EXPECT_GE(Buf.size(), sizeof(UstarHeader));
   return *reinterpret_cast<const UstarHeader *>(Buf.data());
 }
 
 TEST_F(TarWriterTest, Basics) {
   UstarHeader Hdr = createUstar("base", "file");
   EXPECT_EQ("ustar", StringRef(Hdr.Magic));
   EXPECT_EQ("00", StringRef(Hdr.Version, 2));
   EXPECT_EQ("base/file", StringRef(Hdr.Name));
TEST_F(TarWriterTest, LongFilename) {
   std::string yz = "yyyyyyyyyyyyyyyyyyyy/zzzzzzzzzzzzzzzzzzzz";
   UstarHeader Hdr5 = createUstar("", x136 + "/" + yz);
   EXPECT_EQ("/" + x136, StringRef(Hdr5.Prefix));
   EXPECT_EQ(yz, StringRef(Hdr5.Name));
 }
 
 TEST_F(TarWriterTest, Pax) {
   std::vector<uint8_t> Buf = createTar("", std::string(200, 'x'));
-  EXPECT_TRUE(Buf.size() >= 1024);
+  EXPECT_GE(Buf.size(), 1024u);
 
   auto *Hdr = reinterpret_cast<const UstarHeader *>(Buf.data());
   EXPECT_EQ("", StringRef(Hdr->Prefix));
   EXPECT_EQ("", StringRef(Hdr->Name));
 
   StringRef Pax = StringRef((char *)(Buf.data() + 512), 512);
   EXPECT_TRUE(Pax.startswith("211 path=/" + std::string(200, 'x')));
 }

llvm/unittests/Support/TargetParserTest.cpp

TEST(TargetParserTest, ARMExtensionFeatures) {
 
   EXPECT_FALSE(ARM::getExtensionFeatures(ARM::AEK_INVALID, Features));
 
   for (auto &E : Extensions) {
     // test +extension
     Features.clear();
     ARM::getExtensionFeatures(E.first, Features);
     EXPECT_TRUE(llvm::is_contained(Features, E.second.at(0)));
-    EXPECT_TRUE(Extensions.size() == Features.size());
+    EXPECT_EQ(Extensions.size(), Features.size());
 
     // test -extension
     Features.clear();
     ARM::getExtensionFeatures(~E.first, Features);
     EXPECT_TRUE(llvm::is_contained(Features, E.second.at(1)));
-    EXPECT_TRUE(Extensions.size() == Features.size());
+    EXPECT_EQ(Extensions.size(), Features.size());
   }
 }
 
 TEST(TargetParserTest, ARMFPUFeatures) {
   std::vector<StringRef> Features;
   for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
        FK <= ARM::FPUKind::FK_LAST;
-       FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
-    EXPECT_TRUE((FK == ARM::FK_INVALID || FK >= ARM::FK_LAST)
-                    ? !ARM::getFPUFeatures(FK, Features)
-                    : ARM::getFPUFeatures(FK, Features));
+       FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1)) {
+    if (FK == ARM::FK_INVALID || FK >= ARM::FK_LAST)
+      EXPECT_FALSE(ARM::getFPUFeatures(FK, Features));
+    else
+      EXPECT_TRUE(ARM::getFPUFeatures(FK, Features));
+  }
 }
 
 TEST(TargetParserTest, ARMArchExtFeature) {
   const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"},
                               {"crypto", "nocrypto", "+crypto", "-crypto"},
                               {"dsp", "nodsp", "+dsp", "-dsp"},
                               {"fp", "nofp", nullptr, nullptr},
                               {"idiv", "noidiv", nullptr, nullptr},
TEST(TargetParserTest, AArch64ExtensionFeatures) {
   uint64_t ExtVal = 0;
   for (auto Ext : Extensions)
     ExtVal |= Ext;
 
   EXPECT_FALSE(AArch64::getExtensionFeatures(AArch64::AEK_INVALID, Features));
   EXPECT_TRUE(!Features.size());
 
   AArch64::getExtensionFeatures(ExtVal, Features);
-  EXPECT_TRUE(Extensions.size() == Features.size());
+  EXPECT_EQ(Extensions.size(), Features.size());
 
   EXPECT_TRUE(llvm::is_contained(Features, "+crc"));
   EXPECT_TRUE(llvm::is_contained(Features, "+crypto"));
   EXPECT_TRUE(llvm::is_contained(Features, "+fp-armv8"));
   EXPECT_TRUE(llvm::is_contained(Features, "+neon"));
   EXPECT_TRUE(llvm::is_contained(Features, "+fullfp16"));
   EXPECT_TRUE(llvm::is_contained(Features, "+spe"));
   EXPECT_TRUE(llvm::is_contained(Features, "+ras"));
TEST(TargetParserTest, AArch64ExtensionFeatures) {
   EXPECT_TRUE(llvm::is_contained(Features, "+sme-f64"));
   EXPECT_TRUE(llvm::is_contained(Features, "+sme-i64"));
   EXPECT_TRUE(llvm::is_contained(Features, "+perfmon"));
 }
 
 TEST(TargetParserTest, AArch64ArchFeatures) {
   std::vector<StringRef> Features;
 
-  for (auto AK : AArch64::ArchKinds)
-    EXPECT_TRUE((AK == AArch64::ArchKind::INVALID)
-                    ? !AArch64::getArchFeatures(AK, Features)
-                    : AArch64::getArchFeatures(AK, Features));
+  for (auto AK : AArch64::ArchKinds) {
+    if (AK == AArch64::ArchKind::INVALID)
+      EXPECT_FALSE(AArch64::getArchFeatures(AK, Features));
+    else
+      EXPECT_TRUE(AArch64::getArchFeatures(AK, Features));
+  }
 }
 
 TEST(TargetParserTest, AArch64ArchExtFeature) {
   const char *ArchExt[][4] = {
       {"crc", "nocrc", "+crc", "-crc"},
       {"crypto", "nocrypto", "+crypto", "-crypto"},
       {"flagm", "noflagm", "+flagm", "-flagm"},
       {"fp", "nofp", "+fp-armv8", "-fp-armv8"},

llvm/unittests/Support/TimerTest.cpp

TEST(Timer, Additivity) {
   T1.stopTimer();
   auto TR1 = T1.getTotalTime();
 
   T1.startTimer();
   SleepMS();
   T1.stopTimer();
   auto TR2 = T1.getTotalTime();
 
-  EXPECT_TRUE(TR1 < TR2);
+  EXPECT_LT(TR1, TR2);
 }
 
 TEST(Timer, CheckIfTriggered) {
   Timer T1("T1", "T1");
 
   EXPECT_FALSE(T1.hasTriggered());
   T1.startTimer();
   EXPECT_TRUE(T1.hasTriggered());
   T1.stopTimer();
   EXPECT_TRUE(T1.hasTriggered());
 
   T1.clear();
   EXPECT_FALSE(T1.hasTriggered());
 }
 
 } // end anon namespace

llvm/unittests/Support/UnicodeTest.cpp

TEST(Unicode, isPrintable) {
   // test the validity of a fast path in columnWidthUTF8
   for (unsigned char c = 0; c < 128; ++c) {
     const UTF8 buf8[2] = {c, 0};
     const UTF8 *Target8 = &buf8[0];
     UTF32 buf32[1];
     UTF32 *Target32 = &buf32[0];
     auto status = ConvertUTF8toUTF32(&Target8, Target8 + 1, &Target32,
                                      Target32 + 1, strictConversion);
-    EXPECT_TRUE(status == conversionOK);
-    EXPECT_TRUE((columnWidthUTF8(reinterpret_cast<const char *>(buf8)) == 1) ==
-                (bool)isPrintable(buf32[0]));
+    EXPECT_EQ(status, conversionOK);
+    EXPECT_EQ((columnWidthUTF8(reinterpret_cast<const char *>(buf8)) == 1),
   }
 }
 
 } // namespace
 } // namespace unicode
 } // namespace sys
 } // namespace llvm

llvm/unittests/Support/VirtualFileSystemTest.cpp

TEST(VirtualFileSystemTest, BasicRealFSRecursiveIteration) {
   }
 
   // Check contents, which may be in any order
   EXPECT_EQ(4U, Contents.size());
   int Counts[4] = {0, 0, 0, 0};
   for (const std::string &Name : Contents) {
     ASSERT_FALSE(Name.empty());
     int Index = Name[Name.size() - 1] - 'a';
-    ASSERT_TRUE(Index >= 0 && Index < 4);
+    ASSERT_GE(Index, 0);
+    ASSERT_LT(Index, 4);
     Counts[Index]++;
   }
   EXPECT_EQ(1, Counts[0]); // a
   EXPECT_EQ(1, Counts[1]); // b
   EXPECT_EQ(1, Counts[2]); // c
   EXPECT_EQ(1, Counts[3]); // d
 }
 
// Test that calling no_push skips subdirectories.
     }
 
     // Check contents, which may be in any order
     EXPECT_EQ(4U, Contents.size());
     int Counts[7] = {0, 0, 0, 0, 0, 0, 0};
     for (const std::string &Name : Contents) {
       ASSERT_FALSE(Name.empty());
       int Index = Name[Name.size() - 1] - 'a';
-      ASSERT_TRUE(Index >= 0 && Index < 7);
+      ASSERT_GE(Index, 0);
+      ASSERT_LT(Index, 7);
       Counts[Index]++;
     }
     EXPECT_EQ(1, Counts[0]); // a
     EXPECT_EQ(0, Counts[1]); // b
     EXPECT_EQ(1, Counts[2]); // c
     EXPECT_EQ(0, Counts[3]); // d
     EXPECT_EQ(1, Counts[4]); // e
     EXPECT_EQ(0, Counts[5]); // f

 }
 
 TEST_F(InMemoryFileSystemTest, AddHardLinkToFile) {
   StringRef FromLink = "/path/to/FROM/link";
   StringRef Target = "/path/to/TO/file";
   FS.addFile(Target, 0, MemoryBuffer::getMemBuffer("content of target"));
   EXPECT_TRUE(FS.addHardLink(FromLink, Target));
   EXPECT_THAT(FromLink, IsHardLinkTo(&FS, Target));
-  EXPECT_TRUE(FS.status(FromLink)->getSize() == FS.status(Target)->getSize());
-  EXPECT_TRUE(FS.getBufferForFile(FromLink)->get()->getBuffer() ==
-              FS.getBufferForFile(Target)->get()->getBuffer());
+  EXPECT_EQ(FS.status(FromLink)->getSize(), FS.status(Target)->getSize());
+  EXPECT_EQ(FS.getBufferForFile(FromLink)->get()->getBuffer(),
 }
 
 TEST_F(InMemoryFileSystemTest, AddHardLinkInChainPattern) {
   StringRef Link0 = "/path/to/0/link";
   StringRef Link1 = "/path/to/1/link";
   StringRef Link2 = "/path/to/2/link";
   StringRef Target = "/path/to/target";
   FS.addFile(Target, 0, MemoryBuffer::getMemBuffer("content of target file"));
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "                  'use-external-name': false,\n"
       "                  'external-contents': '//root/foo/bar'\n"
       "                }\n"
       "              ]\n"
       "}\n"
       "]\n"
       "}",
       Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(FS);
 
   // file
   ErrorOr<vfs::Status> S = O->status("//root/file1");
   ASSERT_FALSE(S.getError());
IntrusiveRefCntPtr<vfs::FileSystem> FS =
                         "{\n"
                         "  'type': 'directory-remap',\n"
                         "  'name': '//mappedroot/',\n"
                         "  'external-contents': '//root/foo/bar'\n"
                         "}\n"
                         "]\n"
                         "}",
                         Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(FS);
 
   // file
   ErrorOr<vfs::Status> S = O->status("//mappedroot/a");
   ASSERT_FALSE(S.getError());
IntrusiveRefCntPtr<vfs::FileSystem> FS =
                         "  'contents': [ {\n"
                         "                  'type': 'directory-remap',\n"
                         "                  'name': 'bar',\n"
                         "                  'external-contents': '//root/foo'\n"
                         "                }\n"
                         "              ]\n"
                         "}]}",
                         Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(FS);
 
   ErrorOr<vfs::Status> S = O->status("//root/foo");
   ASSERT_FALSE(S.getError());
 
IntrusiveRefCntPtr<vfs::FileSystem> FS =
                         "  'contents': [ {\n"
                         "                  'type': 'directory-remap',\n"
                         "                  'name': 'bar',\n"
                         "                  'external-contents': '//root/foo'\n"
                         "                }\n"
                         "              ]\n"
                         "}]}",
                         Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   ErrorOr<vfs::Status> S = FS->status("//root/foo");
   ASSERT_FALSE(S.getError());
 
   ErrorOr<vfs::Status> SS = FS->status("//root/bar");
   ASSERT_FALSE(SS.getError());
   EXPECT_TRUE(S->equivalent(*SS));
 
IntrusiveRefCntPtr<vfs::FileSystem> FS =
                         "  'contents': [ {\n"
                         "                  'type': 'directory-remap',\n"
                         "                  'name': 'bar',\n"
                         "                  'external-contents': '//root/foo'\n"
                         "                }\n"
                         "              ]\n"
                         "}]}",
                         Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   ErrorOr<vfs::Status> S = Lower->status("//root/foo");
   ASSERT_FALSE(S.getError());
 
   ErrorOr<vfs::Status> SS = FS->status("//root/bar");
   ASSERT_FALSE(SS.getError());
   EXPECT_TRUE(S->equivalent(*SS));
 
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "  'contents': [ {\n"
       "                  'type': 'file',\n"
       "                  'name': 'XX',\n"
       "                  'external-contents': '//root/foo/bar/a'\n"
       "                }\n"
       "              ]\n"
       "}]}",
       Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(FS);
 
   ErrorOr<vfs::Status> S = O->status("//root/XX");
   ASSERT_FALSE(S.getError());
 
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "  'contents': [ {\n"
       "                  'type': 'file',\n"
       "                  'name': 'XX',\n"
       "                  'external-contents': '//root/foo/bar/a'\n"
       "                }\n"
       "              ]\n"
       "}]}",
       Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(FS);
 
   ErrorOr<vfs::Status> SS = O->status("//root/xx");
   EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory);
   SS = O->status("//root/xX");
IntrusiveRefCntPtr<vfs::FileSystem> FS =
                         "    'external-contents': '//root/external/file'\n"
                         "  },\n"
                         "  { 'type': 'file', 'name': '//root/C',\n"
                         "    'use-external-name': false,\n"
                         "    'external-contents': '//root/external/file'\n"
                         "  }\n"
                         "] }",
                         Lower);
-  ASSERT_TRUE(nullptr != FS.get());
+  ASSERT_NE(nullptr, FS.get());
 
   // default true
   EXPECT_EQ("//root/external/file", FS->status("//root/A")->getName());
   // explicit
   EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName());
   EXPECT_EQ("//root/C", FS->status("//root/C")->getName());
 
   // global configuration
   FS = getFromYAMLString("{ 'use-external-names': false,\n"
                          "  'roots': [\n"
                          "  { 'type': 'file', 'name': '//root/A',\n"
                          "    'external-contents': '//root/external/file'\n"
                          "  },\n"
                          "  { 'type': 'file', 'name': '//root/B',\n"
                          "    'use-external-name': true,\n"
                          "    'external-contents': '//root/external/file'\n"
                          "  },\n"
                          "  { 'type': 'file', 'name': '//root/C',\n"
                          "    'use-external-name': false,\n"
                          "    'external-contents': '//root/external/file'\n"
                          "  }\n"
                          "] }",
                          Lower);
-  ASSERT_TRUE(nullptr != FS.get());
+  ASSERT_NE(nullptr, FS.get());
 
   // default
   EXPECT_EQ("//root/A", FS->status("//root/A")->getName());
   // explicit
   EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName());
   EXPECT_EQ("//root/C", FS->status("//root/C")->getName());
 }
 
 TEST_F(VFSFromYAMLTest, MultiComponentPath) {
   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
   Lower->addRegularFile("//root/other");
 
   // file in roots
   IntrusiveRefCntPtr<vfs::FileSystem> FS =
       getFromYAMLString("{ 'roots': [\n"
                         "  { 'type': 'file', 'name': '//root/path/to/file',\n"
                         "    'external-contents': '//root/other' }]\n"
                         "}",
                         Lower);
-  ASSERT_TRUE(nullptr != FS.get());
+  ASSERT_NE(nullptr, FS.get());
   EXPECT_FALSE(FS->status("//root/path/to/file").getError());
   EXPECT_FALSE(FS->status("//root/path/to").getError());
   EXPECT_FALSE(FS->status("//root/path").getError());
   EXPECT_FALSE(FS->status("//root/").getError());
 
   // at the start
   FS = getFromYAMLString(
       "{ 'roots': [\n"
       "  { 'type': 'directory', 'name': '//root/path/to',\n"
       "    'contents': [ { 'type': 'file', 'name': 'file',\n"
       "                    'external-contents': '//root/other' }]}]\n"
       "}",
       Lower);
-  ASSERT_TRUE(nullptr != FS.get());
+  ASSERT_NE(nullptr, FS.get());
   EXPECT_FALSE(FS->status("//root/path/to/file").getError());
   EXPECT_FALSE(FS->status("//root/path/to").getError());
   EXPECT_FALSE(FS->status("//root/path").getError());
   EXPECT_FALSE(FS->status("//root/").getError());
 
   // at the end
   FS = getFromYAMLString(
       "{ 'roots': [\n"
       "  { 'type': 'directory', 'name': '//root/',\n"
       "    'contents': [ { 'type': 'file', 'name': 'path/to/file',\n"
       "                    'external-contents': '//root/other' }]}]\n"
       "}",
       Lower);
-  ASSERT_TRUE(nullptr != FS.get());
+  ASSERT_NE(nullptr, FS.get());
   EXPECT_FALSE(FS->status("//root/path/to/file").getError());
   EXPECT_FALSE(FS->status("//root/path/to").getError());
   EXPECT_FALSE(FS->status("//root/path").getError());
   EXPECT_FALSE(FS->status("//root/").getError());
 }
 
 TEST_F(VFSFromYAMLTest, TrailingSlashes) {
   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
   Lower->addRegularFile("//root/other");
 
   // file in roots
   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "{ 'roots': [\n"
       "  { 'type': 'directory', 'name': '//root/path/to////',\n"
       "    'contents': [ { 'type': 'file', 'name': 'file',\n"
       "                    'external-contents': '//root/other' }]}]\n"
       "}",
       Lower);
-  ASSERT_TRUE(nullptr != FS.get());
+  ASSERT_NE(nullptr, FS.get());
   EXPECT_FALSE(FS->status("//root/path/to/file").getError());
   EXPECT_FALSE(FS->status("//root/path/to").getError());
   EXPECT_FALSE(FS->status("//root/path").getError());
   EXPECT_FALSE(FS->status("//root/").getError());
 }
 
 TEST_F(VFSFromYAMLTest, DirectoryIteration) {
   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "                  'name': 'file2',\n"
       "                  'external-contents': '//root/foo/bar/b'\n"
       "                }\n"
       "              ]\n"
       "}\n"
       "]\n"
       "}",
       Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(FS);
 
   std::error_code EC;
   checkContents(O->dir_begin("//root/", EC),
                 {"//root/file1", "//root/file2", "//root/file3", "//root/foo"});
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "                  'name': 'y',\n"
       "                  'external-contents': '//root/zab/b'\n"
       "                }\n"
       "              ]\n"
       "}\n"
       "]\n"
       "}",
       Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(FS);
 
   std::error_code EC;
 
   checkContents(O->dir_begin("//root/baz/", EC),
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "                  'name': 'file',\n"
       "                  'external-contents': '//root/a/b/c/file'\n"
       "                }\n"
       "              ]\n"
       "},\n"
       "]\n"
       "}",
       Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
       new vfs::OverlayFileSystem(Lower));
   O->pushOverlay(FS);
 
   std::error_code EC;
 
   // Test recursive_directory_iterator level()
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "                  'name': 'c',\n"
       "                  'external-contents': '//root/a'\n"
       "                }\n"
       "              ]\n"
       "}\n"
       "]\n"
       "}",
       Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   std::error_code EC;
   checkContents(FS->dir_begin("//root/", EC),
                 {"//root/c"});
 }
 
 TEST_F(VFSFromYAMLTest, DirectoryIterationWithDuplicates) {
   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "                  'name': 'a',\n"
       "                  'external-contents': '//root/a'\n"
       "                }\n"
       "              ]\n"
       "}\n"
       "]\n"
       "}",
     Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   std::error_code EC;
   checkContents(FS->dir_begin("//root/", EC),
                 {"//root/a", "//root/b"});
 }
 
 TEST_F(VFSFromYAMLTest, DirectoryIterationErrorInVFSLayer) {
   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "                  'name': 'bar/a',\n"
       "                  'external-contents': '//root/foo/a'\n"
       "                }\n"
       "              ]\n"
       "}\n"
       "]\n"
       "}",
       Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   std::error_code EC;
   checkContents(FS->dir_begin("//root/foo", EC),
                 {"//root/foo/a", "//root/foo/b"});
 }
 
 TEST_F(VFSFromYAMLTest, GetRealPath) {
   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "{\n"
       "  'type': 'directory',\n"
       "  'name': '//dir/',\n"
       "  'contents': []\n"
       "}\n"
       "]\n"
       "}",
       Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   // Regular file present in underlying file system.
   SmallString<16> RealPath;
   EXPECT_FALSE(FS->getRealPath("/foo", RealPath));
   EXPECT_EQ(RealPath.str(), "/foo");
 
   // File present in YAML pointing to symlink in underlying file system.
   EXPECT_FALSE(FS->getRealPath("//root/bar", RealPath));
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "                  'name': 'a',\n"
       "                  'external-contents': '//root/foo/a'\n"
       "                }\n"
       "              ]\n"
       "}\n"
       "]\n"
       "}",
       Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
   std::error_code EC = FS->setCurrentWorkingDirectory("//root/bar");
   ASSERT_FALSE(EC);
 
   llvm::ErrorOr<std::string> WorkingDir = FS->getCurrentWorkingDirectory();
   ASSERT_TRUE(WorkingDir);
   EXPECT_EQ(*WorkingDir, "//root/bar");
 
   llvm::ErrorOr<vfs::Status> Status = FS->status("./a");
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "                  'name': 'a',\n"
       "                  'external-contents': '//root/foo/a'\n"
       "                }\n"
       "              ]\n"
       "}\n"
       "]\n"
       "}",
       Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
   std::error_code EC = FS->setCurrentWorkingDirectory("//root/");
   ASSERT_FALSE(EC);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   llvm::ErrorOr<vfs::Status> Status = FS->status("bar/a");
   ASSERT_FALSE(Status.getError());
   EXPECT_TRUE(Status->exists());
 
   Status = FS->status("foo/a");
   ASSERT_FALSE(Status.getError());
   EXPECT_TRUE(Status->exists());
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "                  'name': 'a',\n"
       "                  'external-contents': '//root/foo/a'\n"
       "                }\n"
       "              ]\n"
       "}\n"
       "]\n"
       "}",
       Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
   std::error_code EC = FS->setCurrentWorkingDirectory("//root/");
   ASSERT_FALSE(EC);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   llvm::ErrorOr<vfs::Status> Status = FS->status("bar/a");
   ASSERT_FALSE(Status.getError());
   EXPECT_TRUE(Status->exists());
 
   Status = FS->status("foo/a");
   ASSERT_FALSE(Status.getError());
   EXPECT_TRUE(Status->exists());
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
       "                  'name': 'a',\n"
       "                  'external-contents': '//root/foo/a'\n"
       "                }\n"
       "              ]\n"
       "}\n"
       "]\n"
       "}",
       Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
   std::error_code EC = FS->setCurrentWorkingDirectory("//root/bar");
   ASSERT_FALSE(EC);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   llvm::ErrorOr<vfs::Status> Status = FS->status("a");
   ASSERT_FALSE(Status.getError());
   EXPECT_TRUE(Status->exists());
 }
 
 TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest) {
   TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest) {
   Lower->addDirectory("//root/c");
   Lower->addRegularFile("//root/c/d");
   Lower->addDirectory("//root/e");
   Lower->addDirectory("//root/e/f");
   Lower->addRegularFile("//root/g");
   Lower->addDirectory("//root/h");
 
   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   EXPECT_TRUE(FS->exists(_a.path()));
   EXPECT_TRUE(FS->exists(_ab.path()));
   EXPECT_TRUE(FS->exists(_c.path()));
   EXPECT_TRUE(FS->exists(_cd.path()));
   EXPECT_TRUE(FS->exists(_e.path()));
   EXPECT_TRUE(FS->exists(_ef.path()));
   EXPECT_TRUE(FS->exists(_g.path()));
TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest2) {
 
   std::string Buffer;
   raw_string_ostream OS(Buffer);
   VFSWriter.write(OS);
   OS.flush();
 
   IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem());
   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower);
-  EXPECT_TRUE(FS.get() != nullptr);
+  EXPECT_NE(FS.get(), nullptr);
 }
 
 TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest3) {
   TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
   TempDir _a(TestDirectory.path("a"));
   TempFile _ab(TestDirectory.path("a/b"));
   TempDir _ac(TestDirectory.path("a/c"));
   TempDir _acd(TestDirectory.path("a/c/d"));
TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest3) {
 
   std::string Buffer;
   raw_string_ostream OS(Buffer);
   VFSWriter.write(OS);
   OS.flush();
 
   IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem());
   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower);
-  EXPECT_TRUE(FS.get() != nullptr);
+  EXPECT_NE(FS.get(), nullptr);
 }
 
 TEST_F(VFSFromYAMLTest, YAMLVFSWriterTestHandleDirs) {
   TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
   TempDir _a(TestDirectory.path("a"));
   TempDir _b(TestDirectory.path("b"));
   TempDir _c(TestDirectory.path("c"));
 
   vfs::YAMLVFSWriter VFSWriter;
   VFSWriter.addDirectoryMapping(_a.path(), "//root/a");
   VFSWriter.addDirectoryMapping(_b.path(), "//root/b");
   VFSWriter.addDirectoryMapping(_c.path(), "//root/c");
 
   std::string Buffer;
   raw_string_ostream OS(Buffer);
   VFSWriter.write(OS);
   OS.flush();
 
   // We didn't add a single file - only directories.
-  EXPECT_TRUE(Buffer.find("'type': 'file'") == std::string::npos);
+  EXPECT_EQ(Buffer.find("'type': 'file'"), std::string::npos);
 
   IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem());
   Lower->addDirectory("//root/a");
   Lower->addDirectory("//root/b");
   Lower->addDirectory("//root/c");
   // canaries
   Lower->addRegularFile("//root/a/a");
   Lower->addRegularFile("//root/b/b");
   Lower->addRegularFile("//root/c/c");
 
   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower);
-  ASSERT_TRUE(FS.get() != nullptr);
+  ASSERT_NE(FS.get(), nullptr);
 
   EXPECT_FALSE(FS->exists(_a.path("a")));
   EXPECT_FALSE(FS->exists(_b.path("b")));
   EXPECT_FALSE(FS->exists(_c.path("c")));
 }
 
 TEST(VFSFromRemappedFilesTest, Basic) {
   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> BaseFS =

llvm/unittests/Support/YAMLIOTest.cpp

Input yin("---\n"
             "h8:       0xFF\n"
             "h16:      0x8765\n"
             "h32:      0xFEDCBA98\n"
             "h64:      0xFEDCBA9876543210\n"
            "...\n");
   yin >> map;
 
   EXPECT_FALSE(yin.error());
-  EXPECT_TRUE(map.str.equals("hello there"));
-  EXPECT_TRUE(map.stdstr == "hello where?");
+  EXPECT_EQ(map.str, "hello there");
+  EXPECT_EQ(map.stdstr, "hello where?");
   EXPECT_EQ(map.u64, 5000000000ULL);
   EXPECT_EQ(map.u32, 4000000000U);
   EXPECT_EQ(map.u16, 65000);
   EXPECT_EQ(map.u8,  255);
   EXPECT_EQ(map.b,   false);
   EXPECT_EQ(map.s64, -5000000000LL);
   EXPECT_EQ(map.s32, -2000000000L);
   EXPECT_EQ(map.s16, -32000);
TEST(YAMLIO, TestReadWriteBuiltInTypes) {
   }
 
   {
     Input yin(intermediate);
     BuiltInTypes map;
     yin >> map;
 
     EXPECT_FALSE(yin.error());
-    EXPECT_TRUE(map.str.equals("one two"));
-    EXPECT_TRUE(map.stdstr == "three four");
-    EXPECT_EQ(map.u64,      6000000000ULL);
-    EXPECT_EQ(map.u32,      3000000000U);
-    EXPECT_EQ(map.u16,      50000);
-    EXPECT_EQ(map.u8,       254);
-    EXPECT_EQ(map.b,        true);
-    EXPECT_EQ(map.s64,      -6000000000LL);
-    EXPECT_EQ(map.s32,      -2000000000L);
-    EXPECT_EQ(map.s16,      -32000);
-    EXPECT_EQ(map.s8,       -128);
-    EXPECT_EQ(map.f,        3.25);
-    EXPECT_EQ(map.d,        -2.8625);
-    EXPECT_EQ(map.h8,       Hex8(254));
-    EXPECT_EQ(map.h16,      Hex16(50000));
-    EXPECT_EQ(map.h32,      Hex32(3000000000U));
-    EXPECT_EQ(map.h64,      Hex64(6000000000LL));
+    EXPECT_EQ(map.str, "one two");
+    EXPECT_EQ(map.stdstr, "three four");
+    EXPECT_EQ(map.u64, 6000000000ULL);
+    EXPECT_EQ(map.u32, 3000000000U);
+    EXPECT_EQ(map.u16, 50000);
+    EXPECT_EQ(map.u8, 254);
+    EXPECT_EQ(map.b, true);
+    EXPECT_EQ(map.s64, -6000000000LL);
+    EXPECT_EQ(map.s32, -2000000000L);
+    EXPECT_EQ(map.s16, -32000);
+    EXPECT_EQ(map.s8, -128);
+    EXPECT_EQ(map.f, 3.25);
+    EXPECT_EQ(map.d, -2.8625);
+    EXPECT_EQ(map.h8, Hex8(254));
+    EXPECT_EQ(map.h16, Hex16(50000));
+    EXPECT_EQ(map.h32, Hex32(3000000000U));
+    EXPECT_EQ(map.h64, Hex64(6000000000LL));
   }
 }
 
 //===----------------------------------------------------------------------===//
 //  Test endian-aware types
 //===----------------------------------------------------------------------===//
 
 struct EndianTypes {
TEST(YAMLIO, TestReadWriteStringTypes) {
   EXPECT_NE(std::string::npos, flowOut.find("\"\\0a\\0b\\0\""));
 
   {
     Input yin(intermediate);
     StringTypes map;
     yin >> map;
 
     EXPECT_FALSE(yin.error());
-    EXPECT_TRUE(map.str1.equals("'aaa"));
-    EXPECT_TRUE(map.str2.equals("\"bbb"));
-    EXPECT_TRUE(map.str3.equals("`ccc"));
-    EXPECT_TRUE(map.str4.equals("@ddd"));
-    EXPECT_TRUE(map.str5.equals(""));
-    EXPECT_TRUE(map.str6.equals("0000000004000000"));
-    EXPECT_TRUE(map.stdstr1 == "'eee");
-    EXPECT_TRUE(map.stdstr2 == "\"fff");
-    EXPECT_TRUE(map.stdstr3 == "`ggg");
-    EXPECT_TRUE(map.stdstr4 == "@hhh");
-    EXPECT_TRUE(map.stdstr5 == "");
-    EXPECT_TRUE(map.stdstr6 == "0000000004000000");
+    EXPECT_EQ(map.str1, "'aaa");
+    EXPECT_EQ(map.str2, "\"bbb");
+    EXPECT_EQ(map.str3, "`ccc");
+    EXPECT_EQ(map.str4, "@ddd");
+    EXPECT_EQ(map.str5, "");
+    EXPECT_EQ(map.str6, "0000000004000000");
+    EXPECT_EQ(map.stdstr1, "'eee");
+    EXPECT_EQ(map.stdstr2, "\"fff");
+    EXPECT_EQ(map.stdstr3, "`ggg");
+    EXPECT_EQ(map.stdstr4, "@hhh");
+    EXPECT_EQ(map.stdstr5, "");
+    EXPECT_EQ(map.stdstr6, "0000000004000000");
     EXPECT_EQ(std::string("\0a\0b\0", 5), map.stdstr13);
   }
 }
 
 //===----------------------------------------------------------------------===//
 //  Test ScalarEnumerationTraits
 //===----------------------------------------------------------------------===//
 
TEST(YAMLIO, TestReadBuiltInTypesHex8Error) {
   std::vector<Hex8> seq2;
   Input yin2("---\n"
              "[ 0x12, 0xFE, 0x123 ]\n"
              "...\n",
              /*Ctxt=*/nullptr, suppressErrorMessages);
   yin2 >> seq2;
   EXPECT_TRUE(!!yin2.error());
 
-  EXPECT_TRUE(seq.size() == 3);
-  EXPECT_TRUE(seq.size() == seq2.size());
+  EXPECT_EQ(seq.size(), 3u);
+  EXPECT_EQ(seq.size(), seq2.size());
   for (size_t i = 0; i < seq.size(); ++i)
-    EXPECT_TRUE(seq[i] == seq2[i]);
+    EXPECT_EQ(seq[i], seq2[i]);
 }
 
 
 //
 // Test error handling reading built-in Hex16 type
 //
 TEST(YAMLIO, TestReadBuiltInTypesHex16Error) {
   std::vector<Hex16> seq;
TEST(YAMLIO, TestReadBuiltInTypesHex16Error) {
   std::vector<Hex16> seq2;
   Input yin2("---\n"
              "[ 0x0012, 0xFEFF, 0x12345 ]\n"
              "...\n",
              /*Ctxt=*/nullptr, suppressErrorMessages);
   yin2 >> seq2;
   EXPECT_TRUE(!!yin2.error());
 
-  EXPECT_TRUE(seq.size() == 3);
-  EXPECT_TRUE(seq.size() == seq2.size());
+  EXPECT_EQ(seq.size(), 3u);
+  EXPECT_EQ(seq.size(), seq2.size());
   for (size_t i = 0; i < seq.size(); ++i)
-    EXPECT_TRUE(seq[i] == seq2[i]);
+    EXPECT_EQ(seq[i], seq2[i]);
 }
 
 //
 // Test error handling reading built-in Hex32 type
 //
 TEST(YAMLIO, TestReadBuiltInTypesHex32Error) {
   std::vector<Hex32> seq;
   Input yin("---\n"
TEST(YAMLIO, TestReadBuiltInTypesHex32Error) {
   std::vector<Hex32> seq2;
   Input yin2("---\n"
              "[ 0x0012, 0xFEFF0000, 0x1234556789 ]\n"
              "...\n",
              /*Ctxt=*/nullptr, suppressErrorMessages);
   yin2 >> seq2;
   EXPECT_TRUE(!!yin2.error());
 
-  EXPECT_TRUE(seq.size() == 3);
-  EXPECT_TRUE(seq.size() == seq2.size());
+  EXPECT_EQ(seq.size(), 3u);
+  EXPECT_EQ(seq.size(), seq2.size());
   for (size_t i = 0; i < seq.size(); ++i)
-    EXPECT_TRUE(seq[i] == seq2[i]);
+    EXPECT_EQ(seq[i], seq2[i]);
 }
 
 //
 // Test error handling reading built-in Hex64 type
 //
 TEST(YAMLIO, TestReadBuiltInTypesHex64Error) {
   std::vector<Hex64> seq;
   Input yin("---\n"
TEST(YAMLIO, TestReadBuiltInTypesHex64Error) {
   std::vector<Hex64> seq2;
   Input yin2("---\n"
              "[ 0x0012, 0xFFEEDDCCBBAA9988, 0x12345567890ABCDEF0 ]\n"
              "...\n",
              /*Ctxt=*/nullptr, suppressErrorMessages);
   yin2 >> seq2;
   EXPECT_TRUE(!!yin2.error());
 
-  EXPECT_TRUE(seq.size() == 3);
-  EXPECT_TRUE(seq.size() == seq2.size());
+  EXPECT_EQ(seq.size(), 3u);
+  EXPECT_EQ(seq.size(), seq2.size());
   for (size_t i = 0; i < seq.size(); ++i)
-    EXPECT_TRUE(seq[i] == seq2[i]);
+    EXPECT_EQ(seq[i], seq2[i]);
 }
 
 TEST(YAMLIO, TestMalformedMapFailsGracefully) {
   FooBar doc;
   {
     // We pass the suppressErrorMessages handler to handle the error
     // message generated in the constructor of Input.
     Input yin("{foo:3, bar: 5}", /*Ctxt=*/nullptr, suppressErrorMessages);

llvm/unittests/Support/YAMLParserTest.cpp

TEST(YAMLParser, SameNodeIteratorOperatorNotEquals) {
   yaml::Stream Stream("[\"1\", \"2\"]", SM);
 
   yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
                                               Stream.begin()->getRoot());
 
   auto Begin = Node->begin();
   auto End = Node->end();
 
-  EXPECT_TRUE(Begin != End);
-  EXPECT_FALSE(Begin != Begin);
-  EXPECT_FALSE(End != End);
+  EXPECT_NE(Begin, End);
+  EXPECT_EQ(Begin, Begin);
+  EXPECT_EQ(End, End);
 }
 
 TEST(YAMLParser, SameNodeIteratorOperatorEquals) {
   SourceMgr SM;
   yaml::Stream Stream("[\"1\", \"2\"]", SM);
 
   yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
                                               Stream.begin()->getRoot());
 
   auto Begin = Node->begin();
   auto End = Node->end();
 
-  EXPECT_FALSE(Begin == End);
-  EXPECT_TRUE(Begin == Begin);
-  EXPECT_TRUE(End == End);
+  EXPECT_NE(Begin, End);
+  EXPECT_EQ(Begin, Begin);
+  EXPECT_EQ(End, End);
 }
 
 TEST(YAMLParser, DifferentNodesIteratorOperatorNotEquals) {
   SourceMgr SM;
   yaml::Stream Stream("[\"1\", \"2\"]", SM);
   yaml::Stream AnotherStream("[\"1\", \"2\"]", SM);
 
   yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
                                                   Stream.begin()->getRoot());
   yaml::SequenceNode *AnotherNode = dyn_cast<yaml::SequenceNode>(
                                               AnotherStream.begin()->getRoot());
 
   auto Begin = Node->begin();
   auto End = Node->end();
 
   auto AnotherBegin = AnotherNode->begin();
   auto AnotherEnd = AnotherNode->end();
 
-  EXPECT_TRUE(Begin != AnotherBegin);
-  EXPECT_TRUE(Begin != AnotherEnd);
-  EXPECT_FALSE(End != AnotherEnd);
+  EXPECT_NE(Begin, AnotherBegin);
+  EXPECT_NE(Begin, AnotherEnd);
+  EXPECT_EQ(End, AnotherEnd);
 }
 
 TEST(YAMLParser, DifferentNodesIteratorOperatorEquals) {
   SourceMgr SM;
   yaml::Stream Stream("[\"1\", \"2\"]", SM);
   yaml::Stream AnotherStream("[\"1\", \"2\"]", SM);
 
   yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
                                                     Stream.begin()->getRoot());
   yaml::SequenceNode *AnotherNode = dyn_cast<yaml::SequenceNode>(
                                              AnotherStream.begin()->getRoot());
 
   auto Begin = Node->begin();
   auto End = Node->end();
 
   auto AnotherBegin = AnotherNode->begin();
   auto AnotherEnd = AnotherNode->end();
 
-  EXPECT_FALSE(Begin == AnotherBegin);
-  EXPECT_FALSE(Begin == AnotherEnd);
-  EXPECT_TRUE(End == AnotherEnd);
+  EXPECT_NE(Begin, AnotherBegin);
+  EXPECT_NE(Begin, AnotherEnd);
+  EXPECT_EQ(End, AnotherEnd);
 }
 
 TEST(YAMLParser, FlowSequenceTokensOutsideFlowSequence) {
   auto FlowSequenceStrs = {",", "]", "}"};
   SourceMgr SM;
 
   for (auto &Str : FlowSequenceStrs) {
     yaml::Stream Stream(Str, SM);

llvm/unittests/Support/raw_ostream_test.cpp

 }
 
 TEST(raw_ostreamTest, reserve_stream) {
   std::string Str;
   raw_string_ostream OS(Str);
   OS << "11111111111111111111";
   uint64_t CurrentPos = OS.tell();
   OS.reserveExtraSpace(1000);
-  EXPECT_TRUE(Str.capacity() >= CurrentPos + 1000);
+  EXPECT_GE(Str.capacity(), CurrentPos + 1000);
   OS << "hello";
   OS << 1;
   OS << 'w' << 'o' << 'r' << 'l' << 'd';
   OS.flush();
   EXPECT_EQ("11111111111111111111hello1world", Str);
 }
 
 static void checkFileData(StringRef FileName, StringRef GoldenData) {