[llvm] 38ac409 - [NFCI][Support] Avoid ASSERT_/EXPECT_TRUE(A <op> B)
Archibald Elliott via llvm-commits
llvm-commits at lists.llvm.org
Fri Jan 21 05:15:42 PST 2022
Author: Archibald Elliott
Date: 2022-01-21T13:15:04Z
New Revision: 38ac4093d9d2ae28d631ca1cc5802533989165c5
URL: https://github.com/llvm/llvm-project/commit/38ac4093d9d2ae28d631ca1cc5802533989165c5
DIFF: https://github.com/llvm/llvm-project/commit/38ac4093d9d2ae28d631ca1cc5802533989165c5.diff
LOG: [NFCI][Support] Avoid ASSERT_/EXPECT_TRUE(A <op> B)
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).
Reviewed By: mubashar_
Differential Revision: https://reviews.llvm.org/D117319
Added:
Modified:
llvm/unittests/Support/Casting.cpp
llvm/unittests/Support/CommandLineTest.cpp
llvm/unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp
llvm/unittests/Support/ErrorTest.cpp
llvm/unittests/Support/FSUniqueIDTest.cpp
llvm/unittests/Support/IndexedAccessorTest.cpp
llvm/unittests/Support/JSONTest.cpp
llvm/unittests/Support/MemoryBufferTest.cpp
llvm/unittests/Support/Path.cpp
llvm/unittests/Support/ProgramTest.cpp
llvm/unittests/Support/TarWriterTest.cpp
llvm/unittests/Support/TargetParserTest.cpp
llvm/unittests/Support/TimerTest.cpp
llvm/unittests/Support/UnicodeTest.cpp
llvm/unittests/Support/VirtualFileSystemTest.cpp
llvm/unittests/Support/YAMLIOTest.cpp
llvm/unittests/Support/YAMLParserTest.cpp
llvm/unittests/Support/raw_ostream_test.cpp
Removed:
################################################################################
diff --git a/llvm/unittests/Support/Casting.cpp b/llvm/unittests/Support/Casting.cpp
index a196fc2ec5ed3..e99c0d4860315 100644
--- a/llvm/unittests/Support/Casting.cpp
+++ b/llvm/unittests/Support/Casting.cpp
@@ -283,7 +283,7 @@ TEST(CastingTest, UpcastIsInferred) {
Derived D;
EXPECT_TRUE(isa<Base>(D));
Base *BP = dyn_cast<Base>(&D);
- EXPECT_TRUE(BP != nullptr);
+ EXPECT_NE(BP, nullptr);
}
@@ -379,31 +379,31 @@ TEST(CastingTest, smart_isa) {
}
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
diff --git a/llvm/unittests/Support/CommandLineTest.cpp b/llvm/unittests/Support/CommandLineTest.cpp
index 4e1160fe2dbc5..8032d0e7bf403 100644
--- a/llvm/unittests/Support/CommandLineTest.cpp
+++ b/llvm/unittests/Support/CommandLineTest.cpp
@@ -101,8 +101,7 @@ TEST(CommandLineTest, ModifyExisitingOption) {
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.";
@@ -701,7 +700,7 @@ TEST(CommandLineTest, DefaultOptions) {
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());
@@ -711,7 +710,7 @@ TEST(CommandLineTest, DefaultOptions) {
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());
@@ -727,10 +726,10 @@ TEST(CommandLineTest, DefaultOptions) {
"-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());
@@ -777,8 +776,8 @@ TEST(CommandLineTest, ResponseFileWindows) {
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) {
@@ -1011,9 +1010,9 @@ TEST(CommandLineTest, SetDefautValue) {
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;
@@ -1028,9 +1027,9 @@ TEST(CommandLineTest, SetDefautValue) {
O->setDefault();
}
- EXPECT_TRUE(Opt1 == "true");
+ EXPECT_EQ(Opt1, "true");
EXPECT_TRUE(Opt2);
- EXPECT_TRUE(Opt3 == 3);
+ EXPECT_EQ(Opt3, 3);
Alias.removeArgument();
}
@@ -1135,8 +1134,8 @@ TEST(CommandLineTest, PositionalEatArgsError) {
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());
}
@@ -1412,8 +1411,8 @@ TEST(CommandLineTest, PrefixOptions) {
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();
@@ -1424,8 +1423,8 @@ TEST(CommandLineTest, PrefixOptions) {
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();
@@ -1435,8 +1434,8 @@ TEST(CommandLineTest, PrefixOptions) {
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"),
@@ -1450,8 +1449,8 @@ TEST(CommandLineTest, PrefixOptions) {
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();
@@ -1471,8 +1470,8 @@ TEST(CommandLineTest, PrefixOptions) {
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) {
@@ -1757,12 +1756,12 @@ TEST(CommandLineTest, OptionErrorMessage) {
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();
@@ -1785,8 +1784,8 @@ TEST(CommandLineTest, OptionErrorMessageSuggest) {
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"),
+ std::string::npos);
Errs.clear();
cl::ResetAllOptionOccurrences();
@@ -1808,8 +1807,8 @@ TEST(CommandLineTest, OptionErrorMessageSuggestNoHidden) {
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"),
+ std::string::npos);
Errs.clear();
cl::ResetAllOptionOccurrences();
@@ -1840,7 +1839,7 @@ TEST(CommandLineTest, Callback) {
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"};
@@ -1848,7 +1847,7 @@ TEST(CommandLineTest, Callback) {
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"};
@@ -1856,7 +1855,7 @@ TEST(CommandLineTest, Callback) {
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"};
@@ -1864,7 +1863,7 @@ TEST(CommandLineTest, Callback) {
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"};
@@ -1872,7 +1871,7 @@ TEST(CommandLineTest, Callback) {
EXPECT_FALSE(OptA);
EXPECT_FALSE(OptB);
EXPECT_FALSE(OptC);
- EXPECT_TRUE(List.size() == 1);
+ EXPECT_EQ(List.size(), 1u);
cl::ResetAllOptionOccurrences();
}
@@ -1899,9 +1898,9 @@ TEST(CommandLineTest, ConsumeAfterOnePositional) {
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());
}
@@ -1923,9 +1922,9 @@ TEST(CommandLineTest, ConsumeAfterTwoPositionals) {
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());
}
@@ -1946,17 +1945,17 @@ TEST(CommandLineTest, ResetAllOptionOccurrences) {
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
diff --git a/llvm/unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp b/llvm/unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp
index 6c9063775a59d..784b9c1bb2d27 100644
--- a/llvm/unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp
+++ b/llvm/unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp
@@ -66,11 +66,13 @@ TEST(DynamicLibrary, Overload) {
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);
@@ -79,32 +81,37 @@ TEST(DynamicLibrary, Overload) {
// 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) {
@@ -120,15 +127,15 @@ TEST(DynamicLibrary, Shutdown) {
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());
@@ -137,13 +144,13 @@ TEST(DynamicLibrary, Shutdown) {
// 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);
@@ -154,8 +161,9 @@ TEST(DynamicLibrary, Shutdown) {
}
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);
diff --git a/llvm/unittests/Support/ErrorTest.cpp b/llvm/unittests/Support/ErrorTest.cpp
index 3ca94b2a2aef9..d4daceda2b14a 100644
--- a/llvm/unittests/Support/ErrorTest.cpp
+++ b/llvm/unittests/Support/ErrorTest.cpp
@@ -179,7 +179,7 @@ TEST(Error, HandleCustomError) {
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
@@ -253,7 +253,8 @@ TEST(Error, HandleCustomErrorWithCustomBaseClass) {
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";
}
@@ -270,9 +271,9 @@ TEST(Error, FirstHandlerOnly) {
},
[&](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.
@@ -289,7 +290,11 @@ TEST(Error, HandlerShadowing) {
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";
}
@@ -317,9 +322,9 @@ TEST(Error, CheckJoinErrors) {
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.
{
diff --git a/llvm/unittests/Support/FSUniqueIDTest.cpp b/llvm/unittests/Support/FSUniqueIDTest.cpp
index 6c794730e39dc..81e5088bf24cb 100644
--- a/llvm/unittests/Support/FSUniqueIDTest.cpp
+++ b/llvm/unittests/Support/FSUniqueIDTest.cpp
@@ -20,9 +20,9 @@ TEST(FSUniqueIDTest, construct) {
}
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) {
diff --git a/llvm/unittests/Support/IndexedAccessorTest.cpp b/llvm/unittests/Support/IndexedAccessorTest.cpp
index 9981e91df100e..501d7a6ea2ec0 100644
--- a/llvm/unittests/Support/IndexedAccessorTest.cpp
+++ b/llvm/unittests/Support/IndexedAccessorTest.cpp
@@ -32,7 +32,7 @@ struct ArrayIndexedAccessorRange
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()));
}
diff --git a/llvm/unittests/Support/JSONTest.cpp b/llvm/unittests/Support/JSONTest.cpp
index f28c99819d053..ecfd2a5fe1a09 100644
--- a/llvm/unittests/Support/JSONTest.cpp
+++ b/llvm/unittests/Support/JSONTest.cpp
@@ -138,9 +138,9 @@ TEST(JSONTest, Object) {
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);
diff --git a/llvm/unittests/Support/MemoryBufferTest.cpp b/llvm/unittests/Support/MemoryBufferTest.cpp
index c3e7b3c926a6c..bcd25021b5635 100644
--- a/llvm/unittests/Support/MemoryBufferTest.cpp
+++ b/llvm/unittests/Support/MemoryBufferTest.cpp
@@ -75,15 +75,15 @@ class MemoryBufferTest : public testing::Test {
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());
@@ -153,11 +153,11 @@ TEST_F(MemoryBufferTest, NullTerminator4K) {
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());
@@ -198,25 +198,25 @@ TEST_F(MemoryBufferTest, createFromPipe) {
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]);
}
diff --git a/llvm/unittests/Support/Path.cpp b/llvm/unittests/Support/Path.cpp
index e3fa5d0b2c491..b749448141f79 100644
--- a/llvm/unittests/Support/Path.cpp
+++ b/llvm/unittests/Support/Path.cpp
@@ -2315,7 +2315,7 @@ TEST_F(FileSystemTest, widenPath) {
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.
diff --git a/llvm/unittests/Support/ProgramTest.cpp b/llvm/unittests/Support/ProgramTest.cpp
index d899026a358a0..fbbcd847e3c7a 100644
--- a/llvm/unittests/Support/ProgramTest.cpp
+++ b/llvm/unittests/Support/ProgramTest.cpp
@@ -287,8 +287,8 @@ TEST(ProgramTest, TestExecuteNegative) {
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 "
+ "positive value indicating the result code";
ASSERT_TRUE(ExecutionFailed);
ASSERT_FALSE(Error.empty());
}
diff --git a/llvm/unittests/Support/TarWriterTest.cpp b/llvm/unittests/Support/TarWriterTest.cpp
index 5a7d901a2e9d0..b5f072431fd15 100644
--- a/llvm/unittests/Support/TarWriterTest.cpp
+++ b/llvm/unittests/Support/TarWriterTest.cpp
@@ -68,7 +68,7 @@ static std::vector<uint8_t> createTar(StringRef Base, StringRef Filename) {
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());
}
@@ -112,7 +112,7 @@ TEST_F(TarWriterTest, LongFilename) {
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));
diff --git a/llvm/unittests/Support/TargetParserTest.cpp b/llvm/unittests/Support/TargetParserTest.cpp
index 768ec83a0e126..a9a8de6d291a3 100644
--- a/llvm/unittests/Support/TargetParserTest.cpp
+++ b/llvm/unittests/Support/TargetParserTest.cpp
@@ -687,13 +687,13 @@ TEST(TargetParserTest, ARMExtensionFeatures) {
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());
}
}
@@ -701,10 +701,12 @@ 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) {
@@ -1448,7 +1450,7 @@ TEST(TargetParserTest, AArch64ExtensionFeatures) {
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"));
@@ -1477,10 +1479,12 @@ TEST(TargetParserTest, AArch64ExtensionFeatures) {
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) {
diff --git a/llvm/unittests/Support/TimerTest.cpp b/llvm/unittests/Support/TimerTest.cpp
index 9a9b67eaa9f78..09545eb6939ae 100644
--- a/llvm/unittests/Support/TimerTest.cpp
+++ b/llvm/unittests/Support/TimerTest.cpp
@@ -45,7 +45,7 @@ TEST(Timer, Additivity) {
T1.stopTimer();
auto TR2 = T1.getTotalTime();
- EXPECT_TRUE(TR1 < TR2);
+ EXPECT_LT(TR1, TR2);
}
TEST(Timer, CheckIfTriggered) {
diff --git a/llvm/unittests/Support/UnicodeTest.cpp b/llvm/unittests/Support/UnicodeTest.cpp
index 6ce323dc8f380..09f1cb3e1ff66 100644
--- a/llvm/unittests/Support/UnicodeTest.cpp
+++ b/llvm/unittests/Support/UnicodeTest.cpp
@@ -95,9 +95,9 @@ TEST(Unicode, isPrintable) {
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),
+ (bool)isPrintable(buf32[0]));
}
}
diff --git a/llvm/unittests/Support/VirtualFileSystemTest.cpp b/llvm/unittests/Support/VirtualFileSystemTest.cpp
index caae58f74f636..6b191c6401685 100644
--- a/llvm/unittests/Support/VirtualFileSystemTest.cpp
+++ b/llvm/unittests/Support/VirtualFileSystemTest.cpp
@@ -567,7 +567,8 @@ TEST(VirtualFileSystemTest, BasicRealFSRecursiveIteration) {
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
@@ -644,7 +645,8 @@ TEST(VirtualFileSystemTest, BasicRealFSRecursiveIterationNoPush) {
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
@@ -1183,9 +1185,9 @@ TEST_F(InMemoryFileSystemTest, AddHardLinkToFile) {
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(),
+ FS.getBufferForFile(Target)->get()->getBuffer());
}
TEST_F(InMemoryFileSystemTest, AddHardLinkInChainPattern) {
@@ -1381,7 +1383,7 @@ TEST_F(VFSFromYAMLTest, MappedFiles) {
"]\n"
"}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
new vfs::OverlayFileSystem(Lower));
@@ -1474,7 +1476,7 @@ TEST_F(VFSFromYAMLTest, MappedRoot) {
"]\n"
"}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
new vfs::OverlayFileSystem(Lower));
@@ -1522,7 +1524,7 @@ TEST_F(VFSFromYAMLTest, RemappedDirectoryOverlay) {
" ]\n"
"}]}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
new vfs::OverlayFileSystem(Lower));
@@ -1567,7 +1569,7 @@ TEST_F(VFSFromYAMLTest, RemappedDirectoryOverlayNoExternalNames) {
" ]\n"
"}]}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
ErrorOr<vfs::Status> S = FS->status("//root/foo");
ASSERT_FALSE(S.getError());
@@ -1608,7 +1610,7 @@ TEST_F(VFSFromYAMLTest, RemappedDirectoryOverlayNoFallthrough) {
" ]\n"
"}]}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
ErrorOr<vfs::Status> S = Lower->status("//root/foo");
ASSERT_FALSE(S.getError());
@@ -1752,7 +1754,7 @@ TEST_F(VFSFromYAMLTest, CaseInsensitive) {
" ]\n"
"}]}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
new vfs::OverlayFileSystem(Lower));
@@ -1788,7 +1790,7 @@ TEST_F(VFSFromYAMLTest, CaseSensitive) {
" ]\n"
"}]}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
new vfs::OverlayFileSystem(Lower));
@@ -1930,7 +1932,7 @@ TEST_F(VFSFromYAMLTest, UseExternalName) {
" }\n"
"] }",
Lower);
- ASSERT_TRUE(nullptr != FS.get());
+ ASSERT_NE(nullptr, FS.get());
// default true
EXPECT_EQ("//root/external/file", FS->status("//root/A")->getName());
@@ -1954,7 +1956,7 @@ TEST_F(VFSFromYAMLTest, UseExternalName) {
" }\n"
"] }",
Lower);
- ASSERT_TRUE(nullptr != FS.get());
+ ASSERT_NE(nullptr, FS.get());
// default
EXPECT_EQ("//root/A", FS->status("//root/A")->getName());
@@ -1974,7 +1976,7 @@ TEST_F(VFSFromYAMLTest, MultiComponentPath) {
" '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());
@@ -1988,7 +1990,7 @@ TEST_F(VFSFromYAMLTest, MultiComponentPath) {
" '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());
@@ -2002,7 +2004,7 @@ TEST_F(VFSFromYAMLTest, MultiComponentPath) {
" '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());
@@ -2021,7 +2023,7 @@ TEST_F(VFSFromYAMLTest, TrailingSlashes) {
" '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());
@@ -2057,7 +2059,7 @@ TEST_F(VFSFromYAMLTest, DirectoryIteration) {
"]\n"
"}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
new vfs::OverlayFileSystem(Lower));
@@ -2107,7 +2109,7 @@ TEST_F(VFSFromYAMLTest, DirectoryIterationSameDirMultipleEntries) {
"]\n"
"}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
new vfs::OverlayFileSystem(Lower));
@@ -2142,7 +2144,7 @@ TEST_F(VFSFromYAMLTest, RecursiveDirectoryIterationLevel) {
"]\n"
"}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
new vfs::OverlayFileSystem(Lower));
@@ -2238,7 +2240,7 @@ TEST_F(VFSFromYAMLTest, NonFallthroughDirectoryIteration) {
"]\n"
"}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
std::error_code EC;
checkContents(FS->dir_begin("//root/", EC),
@@ -2266,7 +2268,7 @@ TEST_F(VFSFromYAMLTest, DirectoryIterationWithDuplicates) {
"]\n"
"}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
std::error_code EC;
checkContents(FS->dir_begin("//root/", EC),
@@ -2295,7 +2297,7 @@ TEST_F(VFSFromYAMLTest, DirectoryIterationErrorInVFSLayer) {
"]\n"
"}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
std::error_code EC;
checkContents(FS->dir_begin("//root/foo", EC),
@@ -2328,7 +2330,7 @@ TEST_F(VFSFromYAMLTest, GetRealPath) {
"]\n"
"}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
// Regular file present in underlying file system.
SmallString<16> RealPath;
@@ -2370,7 +2372,7 @@ TEST_F(VFSFromYAMLTest, WorkingDirectory) {
"]\n"
"}",
Lower);
- ASSERT_TRUE(FS.get() != nullptr);
+ ASSERT_NE(FS.get(), nullptr);
std::error_code EC = FS->setCurrentWorkingDirectory("//root/bar");
ASSERT_FALSE(EC);
@@ -2439,10 +2441,10 @@ TEST_F(VFSFromYAMLTest, WorkingDirectoryFallthrough) {
"]\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());
@@ -2511,10 +2513,10 @@ TEST_F(VFSFromYAMLTest, WorkingDirectoryFallthroughInvalid) {
"]\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());
@@ -2548,10 +2550,10 @@ TEST_F(VFSFromYAMLTest, VirtualWorkingDirectory) {
"]\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());
@@ -2596,7 +2598,7 @@ TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest) {
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()));
@@ -2636,7 +2638,7 @@ TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest2) {
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) {
@@ -2669,7 +2671,7 @@ TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest3) {
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) {
@@ -2689,7 +2691,7 @@ TEST_F(VFSFromYAMLTest, YAMLVFSWriterTestHandleDirs) {
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");
@@ -2701,7 +2703,7 @@ TEST_F(VFSFromYAMLTest, YAMLVFSWriterTestHandleDirs) {
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")));
diff --git a/llvm/unittests/Support/YAMLIOTest.cpp b/llvm/unittests/Support/YAMLIOTest.cpp
index 3e1efbc755011..a9230c2ca4767 100644
--- a/llvm/unittests/Support/YAMLIOTest.cpp
+++ b/llvm/unittests/Support/YAMLIOTest.cpp
@@ -398,8 +398,8 @@ TEST(YAMLIO, TestReadBuiltInTypes) {
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);
@@ -454,23 +454,23 @@ TEST(YAMLIO, TestReadWriteBuiltInTypes) {
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));
}
}
@@ -785,18 +785,18 @@ TEST(YAMLIO, TestReadWriteStringTypes) {
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);
}
}
@@ -2208,10 +2208,10 @@ TEST(YAMLIO, TestReadBuiltInTypesHex8Error) {
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]);
}
@@ -2238,10 +2238,10 @@ TEST(YAMLIO, TestReadBuiltInTypesHex16Error) {
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]);
}
//
@@ -2268,10 +2268,10 @@ TEST(YAMLIO, TestReadBuiltInTypesHex32Error) {
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]);
}
//
@@ -2297,10 +2297,10 @@ TEST(YAMLIO, TestReadBuiltInTypesHex64Error) {
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) {
diff --git a/llvm/unittests/Support/YAMLParserTest.cpp b/llvm/unittests/Support/YAMLParserTest.cpp
index adda6ce9f5c30..692d963828318 100644
--- a/llvm/unittests/Support/YAMLParserTest.cpp
+++ b/llvm/unittests/Support/YAMLParserTest.cpp
@@ -269,9 +269,9 @@ TEST(YAMLParser, SameNodeIteratorOperatorNotEquals) {
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) {
@@ -284,9 +284,9 @@ TEST(YAMLParser, SameNodeIteratorOperatorEquals) {
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) {
@@ -305,9 +305,9 @@ TEST(YAMLParser, DifferentNodesIteratorOperatorNotEquals) {
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) {
@@ -326,9 +326,9 @@ TEST(YAMLParser, DifferentNodesIteratorOperatorEquals) {
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) {
diff --git a/llvm/unittests/Support/raw_ostream_test.cpp b/llvm/unittests/Support/raw_ostream_test.cpp
index 5125af8ce8a4b..8c695300b745d 100644
--- a/llvm/unittests/Support/raw_ostream_test.cpp
+++ b/llvm/unittests/Support/raw_ostream_test.cpp
@@ -469,7 +469,7 @@ TEST(raw_ostreamTest, reserve_stream) {
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';
More information about the llvm-commits
mailing list