Skip to content

GitLab

Commit b007c54f authored by Abseil Team's avatar Abseil Team Committed by Copybara-Service
Browse files

Running clang-format over all of GoogleTest 

A few tests are examining code locations and looking af the resulting line
numbers to verify that GoogleTest shows those to users correctly. Some of those
locations change when clang-format is run. For those locations, I've wrapped
portions in:
// clang-format off
...
// clang-format on

There may be other locations that are currently not tickled by running
clang-format.

PiperOrigin-RevId: 434844712
Change-Id: I3a9f0a6f39eff741c576b6de389bef9b1d11139d
parent 8a422b83
Hide whitespace changes
Inline Side-by-side
Showing with 747 additions and 859 deletions
googletest/test/gtest_test_macro_stack_footprint_test.cc
View file @ b007c54f
......@@ -39,42 +39,42 @@
// This macro defines 10 dummy tests.
#define TEN_TESTS_(test_case_name) \
TEST(test_case_name, T0) {} \
TEST(test_case_name, T1) {} \
TEST(test_case_name, T2) {} \
TEST(test_case_name, T3) {} \
TEST(test_case_name, T4) {} \
TEST(test_case_name, T5) {} \
TEST(test_case_name, T6) {} \
TEST(test_case_name, T7) {} \
TEST(test_case_name, T8) {} \
TEST(test_case_name, T0) {} \
TEST(test_case_name, T1) {} \
TEST(test_case_name, T2) {} \
TEST(test_case_name, T3) {} \
TEST(test_case_name, T4) {} \
TEST(test_case_name, T5) {} \
TEST(test_case_name, T6) {} \
TEST(test_case_name, T7) {} \
TEST(test_case_name, T8) {} \
TEST(test_case_name, T9) {}
// This macro defines 100 dummy tests.
#define HUNDRED_TESTS_(test_case_name_prefix) \
TEN_TESTS_(test_case_name_prefix ## 0) \
TEN_TESTS_(test_case_name_prefix ## 1) \
TEN_TESTS_(test_case_name_prefix ## 2) \
TEN_TESTS_(test_case_name_prefix ## 3) \
TEN_TESTS_(test_case_name_prefix ## 4) \
TEN_TESTS_(test_case_name_prefix ## 5) \
TEN_TESTS_(test_case_name_prefix ## 6) \
TEN_TESTS_(test_case_name_prefix ## 7) \
TEN_TESTS_(test_case_name_prefix ## 8) \
TEN_TESTS_(test_case_name_prefix ## 9)
TEN_TESTS_(test_case_name_prefix##0) \
TEN_TESTS_(test_case_name_prefix##1) \
TEN_TESTS_(test_case_name_prefix##2) \
TEN_TESTS_(test_case_name_prefix##3) \
TEN_TESTS_(test_case_name_prefix##4) \
TEN_TESTS_(test_case_name_prefix##5) \
TEN_TESTS_(test_case_name_prefix##6) \
TEN_TESTS_(test_case_name_prefix##7) \
TEN_TESTS_(test_case_name_prefix##8) \
TEN_TESTS_(test_case_name_prefix##9)
// This macro defines 1000 dummy tests.
#define THOUSAND_TESTS_(test_case_name_prefix) \
HUNDRED_TESTS_(test_case_name_prefix ## 0) \
HUNDRED_TESTS_(test_case_name_prefix ## 1) \
HUNDRED_TESTS_(test_case_name_prefix ## 2) \
HUNDRED_TESTS_(test_case_name_prefix ## 3) \
HUNDRED_TESTS_(test_case_name_prefix ## 4) \
HUNDRED_TESTS_(test_case_name_prefix ## 5) \
HUNDRED_TESTS_(test_case_name_prefix ## 6) \
HUNDRED_TESTS_(test_case_name_prefix ## 7) \
HUNDRED_TESTS_(test_case_name_prefix ## 8) \
HUNDRED_TESTS_(test_case_name_prefix ## 9)
HUNDRED_TESTS_(test_case_name_prefix##0) \
HUNDRED_TESTS_(test_case_name_prefix##1) \
HUNDRED_TESTS_(test_case_name_prefix##2) \
HUNDRED_TESTS_(test_case_name_prefix##3) \
HUNDRED_TESTS_(test_case_name_prefix##4) \
HUNDRED_TESTS_(test_case_name_prefix##5) \
HUNDRED_TESTS_(test_case_name_prefix##6) \
HUNDRED_TESTS_(test_case_name_prefix##7) \
HUNDRED_TESTS_(test_case_name_prefix##8) \
HUNDRED_TESTS_(test_case_name_prefix##9)
// Ensures that we can define 1000 TEST()s in the same translation
// unit.
......
googletest/test/gtest_testbridge_test_.cc
View file @ b007c54f
......@@ -27,7 +27,6 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// This program is meant to be run by gtest_test_filter_test.py. Do not run
// it directly.
......
googletest/test/gtest_throw_on_failure_ex_test.cc
View file @ b007c54f
......@@ -27,16 +27,16 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Tests Google Test's throw-on-failure mode with exceptions enabled.
#include "gtest/gtest.h"
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdexcept>
#include "gtest/gtest.h"
// Prints the given failure message and exits the program with
// non-zero. We use this instead of a Google Test assertion to
// indicate a failure, as the latter is been tested and cannot be
......@@ -55,14 +55,14 @@ void TestFailureThrowsRuntimeError() {
// A successful assertion shouldn't throw.
try {
EXPECT_EQ(3, 3);
} catch(...) {
} catch (...) {
Fail("A successful assertion wrongfully threw.");
}
// A failed assertion should throw a subclass of std::runtime_error.
try {
EXPECT_EQ(2, 3) << "Expected failure";
} catch(const std::runtime_error& e) {
} catch (const std::runtime_error& e) {
if (strstr(e.what(), "Expected failure") != nullptr) return;
printf("%s",
......@@ -70,7 +70,7 @@ void TestFailureThrowsRuntimeError() {
"but the message is incorrect. Instead of containing \"Expected "
"failure\", it is:\n");
Fail(e.what());
} catch(...) {
} catch (...) {
Fail("A failed assertion threw the wrong type of exception.");
}
Fail("A failed assertion should've thrown but didn't.");
......
googletest/test/gtest_unittest.cc
View file @ b007c54f
......@@ -137,8 +137,8 @@ TEST_F(StreamingListenerTest, OnTestEnd) {
TEST_F(StreamingListenerTest, OnTestPartResult) {
*output() = "";
streamer_.OnTestPartResult(TestPartResult(
TestPartResult::kFatalFailure, "foo.cc", 42, "failed=\n&%"));
streamer_.OnTestPartResult(TestPartResult(TestPartResult::kFatalFailure,
"foo.cc", 42, "failed=\n&%"));
// Meta characters in the failure message should be properly escaped.
EXPECT_EQ(
......@@ -272,11 +272,9 @@ using testing::internal::GetCapturedStdout;
using testing::internal::ThreadWithParam;
#endif
class TestingVector : public std::vector<int> {
};
class TestingVector : public std::vector<int> {};
::std::ostream& operator<<(::std::ostream& os,
const TestingVector& vector) {
::std::ostream& operator<<(::std::ostream& os, const TestingVector& vector) {
os << "{ ";
for (size_t i = 0; i < vector.size(); i++) {
os << vector[i] << " ";
......@@ -420,8 +418,7 @@ class FormatEpochTimeInMillisAsIso8601Test : public Test {
saved_tz_ = nullptr;
GTEST_DISABLE_MSC_DEPRECATED_PUSH_(/* getenv, strdup: deprecated */)
if (getenv("TZ"))
saved_tz_ = strdup(getenv("TZ"));
if (getenv("TZ")) saved_tz_ = strdup(getenv("TZ"));
GTEST_DISABLE_MSC_DEPRECATED_POP_()
// Set up the time zone for FormatEpochTimeInMillisAsIso8601 to use. We
......@@ -476,9 +473,8 @@ TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsTwoDigitSegments) {
}
TEST_F(FormatEpochTimeInMillisAsIso8601Test, IncludesMillisecondsAfterDot) {
EXPECT_EQ(
"2011-10-31T18:52:42.234",
FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec + 234));
EXPECT_EQ("2011-10-31T18:52:42.234",
FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec + 234));
}
TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsLeadingZeroes) {
......@@ -495,10 +491,10 @@ TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsEpochStart) {
EXPECT_EQ("1970-01-01T00:00:00.000", FormatEpochTimeInMillisAsIso8601(0));
}
# ifdef __BORLANDC__
#ifdef __BORLANDC__
// Silences warnings: "Condition is always true", "Unreachable code"
# pragma option push -w-ccc -w-rch
# endif
#pragma option push -w-ccc -w-rch
#endif
// Tests that the LHS of EXPECT_EQ or ASSERT_EQ can be used as a null literal
// when the RHS is a pointer type.
......@@ -572,10 +568,10 @@ TEST(NullLiteralTest, NoConversionNoWarning) {
#pragma clang diagnostic pop
#endif
# ifdef __BORLANDC__
#ifdef __BORLANDC__
// Restores warnings after previous "#pragma option push" suppressed them.
# pragma option pop
# endif
#pragma option pop
#endif
//
// Tests CodePointToUtf8().
......@@ -603,20 +599,17 @@ TEST(CodePointToUtf8Test, CanEncode8To11Bits) {
// Some compilers (e.g., GCC on MinGW) cannot handle non-ASCII codepoints
// in wide strings and wide chars. In order to accommodate them, we have to
// introduce such character constants as integers.
EXPECT_EQ("\xD5\xB6",
CodePointToUtf8(static_cast<wchar_t>(0x576)));
EXPECT_EQ("\xD5\xB6", CodePointToUtf8(static_cast<wchar_t>(0x576)));
}
// Tests that Unicode code-points that have 12 to 16 bits are encoded
// as 1110xxxx 10xxxxxx 10xxxxxx.
TEST(CodePointToUtf8Test, CanEncode12To16Bits) {
// 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011
EXPECT_EQ("\xE0\xA3\x93",
CodePointToUtf8(static_cast<wchar_t>(0x8D3)));
EXPECT_EQ("\xE0\xA3\x93", CodePointToUtf8(static_cast<wchar_t>(0x8D3)));
// 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
EXPECT_EQ("\xEC\x9D\x8D",
CodePointToUtf8(static_cast<wchar_t>(0xC74D)));
EXPECT_EQ("\xEC\x9D\x8D", CodePointToUtf8(static_cast<wchar_t>(0xC74D)));
}
#if !GTEST_WIDE_STRING_USES_UTF16_
......@@ -668,7 +661,7 @@ TEST(WideStringToUtf8Test, CanEncode8To11Bits) {
EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", -1).c_str());
// 101 0111 0110 => 110-10101 10-110110
const wchar_t s[] = { 0x576, '\0' };
const wchar_t s[] = {0x576, '\0'};
EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, 1).c_str());
EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, -1).c_str());
}
......@@ -677,12 +670,12 @@ TEST(WideStringToUtf8Test, CanEncode8To11Bits) {
// as 1110xxxx 10xxxxxx 10xxxxxx.
TEST(WideStringToUtf8Test, CanEncode12To16Bits) {
// 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011
const wchar_t s1[] = { 0x8D3, '\0' };
const wchar_t s1[] = {0x8D3, '\0'};
EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, 1).c_str());
EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, -1).c_str());
// 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
const wchar_t s2[] = { 0xC74D, '\0' };
const wchar_t s2[] = {0xC74D, '\0'};
EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, 1).c_str());
EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, -1).c_str());
}
......@@ -717,11 +710,11 @@ TEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) {
EXPECT_STREQ("(Invalid Unicode 0xABCDFF)",
WideStringToUtf8(L"\xABCDFF", -1).c_str());
}
#else // !GTEST_WIDE_STRING_USES_UTF16_
#else // !GTEST_WIDE_STRING_USES_UTF16_
// Tests that surrogate pairs are encoded correctly on the systems using
// UTF-16 encoding in the wide strings.
TEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) {
const wchar_t s[] = { 0xD801, 0xDC00, '\0' };
const wchar_t s[] = {0xD801, 0xDC00, '\0'};
EXPECT_STREQ("\xF0\x90\x90\x80", WideStringToUtf8(s, -1).c_str());
}
......@@ -729,13 +722,13 @@ TEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) {
// generates the expected result.
TEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) {
// Leading surrogate is at the end of the string.
const wchar_t s1[] = { 0xD800, '\0' };
const wchar_t s1[] = {0xD800, '\0'};
EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(s1, -1).c_str());
// Leading surrogate is not followed by the trailing surrogate.
const wchar_t s2[] = { 0xD800, 'M', '\0' };
const wchar_t s2[] = {0xD800, 'M', '\0'};
EXPECT_STREQ("\xED\xA0\x80M", WideStringToUtf8(s2, -1).c_str());
// Trailing surrogate appearas without a leading surrogate.
const wchar_t s3[] = { 0xDC00, 'P', 'Q', 'R', '\0' };
const wchar_t s3[] = {0xDC00, 'P', 'Q', 'R', '\0'};
EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(s3, -1).c_str());
}
#endif // !GTEST_WIDE_STRING_USES_UTF16_
......@@ -743,21 +736,24 @@ TEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) {
// Tests that codepoint concatenation works correctly.
#if !GTEST_WIDE_STRING_USES_UTF16_
TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
const wchar_t s[] = { 0x108634, 0xC74D, '\n', 0x576, 0x8D3, 0x108634, '\0'};
const wchar_t s[] = {0x108634, 0xC74D, '\n', 0x576, 0x8D3, 0x108634, '\0'};
EXPECT_STREQ(
"\xF4\x88\x98\xB4"
"\xEC\x9D\x8D"
"\n"
"\xD5\xB6"
"\xE0\xA3\x93"
"\xF4\x88\x98\xB4",
"\xEC\x9D\x8D"
"\n"
"\xD5\xB6"
"\xE0\xA3\x93"
"\xF4\x88\x98\xB4",
WideStringToUtf8(s, -1).c_str());
}
#else
TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
const wchar_t s[] = { 0xC74D, '\n', 0x576, 0x8D3, '\0'};
const wchar_t s[] = {0xC74D, '\n', 0x576, 0x8D3, '\0'};
EXPECT_STREQ(
"\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93",
"\xEC\x9D\x8D"
"\n"
"\xD5\xB6"
"\xE0\xA3\x93",
WideStringToUtf8(s, -1).c_str());
}
#endif // !GTEST_WIDE_STRING_USES_UTF16_
......@@ -766,9 +762,8 @@ TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
TEST(RandomDeathTest, GeneratesCrashesOnInvalidRange) {
testing::internal::Random random(42);
EXPECT_DEATH_IF_SUPPORTED(
random.Generate(0),
"Cannot generate a number in the range \\[0, 0\\)");
EXPECT_DEATH_IF_SUPPORTED(random.Generate(0),
"Cannot generate a number in the range \\[0, 0\\)");
EXPECT_DEATH_IF_SUPPORTED(
random.Generate(testing::internal::Random::kMaxRange + 1),
"Generation of a number in \\[0, 2147483649\\) was requested, "
......@@ -897,7 +892,7 @@ class VectorShuffleTest : public Test {
return true;
}
bool found_in_vector[kVectorSize] = { false };
bool found_in_vector[kVectorSize] = {false};
for (size_t i = 0; i < vector.size(); i++) {
const int e = vector[i];
if (e < 0 || e >= static_cast<int>(kVectorSize) || found_in_vector[e]) {
......@@ -924,8 +919,8 @@ class VectorShuffleTest : public Test {
return false;
}
static bool RangeIsUnshuffled(
const TestingVector& vector, int begin, int end) {
static bool RangeIsUnshuffled(const TestingVector& vector, int begin,
int end) {
return !RangeIsShuffled(vector, begin, end);
}
......@@ -950,7 +945,7 @@ TEST_F(VectorShuffleTest, HandlesEmptyRange) {
ASSERT_PRED1(VectorIsUnshuffled, vector_);
// ...in the middle...
ShuffleRange(&random_, kVectorSize/2, kVectorSize/2, &vector_);
ShuffleRange(&random_, kVectorSize / 2, kVectorSize / 2, &vector_);
ASSERT_PRED1(VectorIsNotCorrupt, vector_);
ASSERT_PRED1(VectorIsUnshuffled, vector_);
......@@ -972,7 +967,7 @@ TEST_F(VectorShuffleTest, HandlesRangeOfSizeOne) {
ASSERT_PRED1(VectorIsUnshuffled, vector_);
// ...in the middle...
ShuffleRange(&random_, kVectorSize/2, kVectorSize/2 + 1, &vector_);
ShuffleRange(&random_, kVectorSize / 2, kVectorSize / 2 + 1, &vector_);
ASSERT_PRED1(VectorIsNotCorrupt, vector_);
ASSERT_PRED1(VectorIsUnshuffled, vector_);
......@@ -997,7 +992,7 @@ TEST_F(VectorShuffleTest, ShufflesEntireVector) {
}
TEST_F(VectorShuffleTest, ShufflesStartOfVector) {
const int kRangeSize = kVectorSize/2;
const int kRangeSize = kVectorSize / 2;
ShuffleRange(&random_, 0, kRangeSize, &vector_);
......@@ -1019,11 +1014,11 @@ TEST_F(VectorShuffleTest, ShufflesEndOfVector) {
TEST_F(VectorShuffleTest, ShufflesMiddleOfVector) {
const int kRangeSize = static_cast<int>(kVectorSize) / 3;
ShuffleRange(&random_, kRangeSize, 2*kRangeSize, &vector_);
ShuffleRange(&random_, kRangeSize, 2 * kRangeSize, &vector_);
ASSERT_PRED1(VectorIsNotCorrupt, vector_);
EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);
EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, 2*kRangeSize);
EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, 2 * kRangeSize);
EXPECT_PRED3(RangeIsUnshuffled, vector_, 2 * kRangeSize,
static_cast<int>(kVectorSize));
}
......@@ -1088,13 +1083,12 @@ TEST(StringTest, CaseInsensitiveWideCStringEquals) {
// Tests String::ShowWideCString().
TEST(StringTest, ShowWideCString) {
EXPECT_STREQ("(null)",
String::ShowWideCString(NULL).c_str());
EXPECT_STREQ("(null)", String::ShowWideCString(NULL).c_str());
EXPECT_STREQ("", String::ShowWideCString(L"").c_str());
EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str());
}
# if GTEST_OS_WINDOWS_MOBILE
#if GTEST_OS_WINDOWS_MOBILE
TEST(StringTest, AnsiAndUtf16Null) {
EXPECT_EQ(NULL, String::AnsiToUtf16(NULL));
EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL));
......@@ -1103,21 +1097,21 @@ TEST(StringTest, AnsiAndUtf16Null) {
TEST(StringTest, AnsiAndUtf16ConvertBasic) {
const char* ansi = String::Utf16ToAnsi(L"str");
EXPECT_STREQ("str", ansi);
delete [] ansi;
delete[] ansi;
const WCHAR* utf16 = String::AnsiToUtf16("str");
EXPECT_EQ(0, wcsncmp(L"str", utf16, 3));
delete [] utf16;
delete[] utf16;
}
TEST(StringTest, AnsiAndUtf16ConvertPathChars) {
const char* ansi = String::Utf16ToAnsi(L".:\\ \"*?");
EXPECT_STREQ(".:\\ \"*?", ansi);
delete [] ansi;
delete[] ansi;
const WCHAR* utf16 = String::AnsiToUtf16(".:\\ \"*?");
EXPECT_EQ(0, wcsncmp(L".:\\ \"*?", utf16, 3));
delete [] utf16;
delete[] utf16;
}
# endif // GTEST_OS_WINDOWS_MOBILE
#endif // GTEST_OS_WINDOWS_MOBILE
#endif // GTEST_OS_WINDOWS
......@@ -1139,9 +1133,7 @@ TEST(TestPropertyTest, ReplaceStringValue) {
// AddFatalFailure() and AddNonfatalFailure() must be stand-alone
// functions (i.e. their definitions cannot be inlined at the call
// sites), or C++Builder won't compile the code.
static void AddFatalFailure() {
FAIL() << "Expected fatal failure.";
}
static void AddFatalFailure() { FAIL() << "Expected fatal failure."; }
static void AddNonfatalFailure() {
ADD_FAILURE() << "Expected non-fatal failure.";
......@@ -1149,10 +1141,7 @@ static void AddNonfatalFailure() {
class ScopedFakeTestPartResultReporterTest : public Test {
public: // Must be public and not protected due to a bug in g++ 3.4.2.
enum FailureMode {
FATAL_FAILURE,
NONFATAL_FAILURE
};
enum FailureMode { FATAL_FAILURE, NONFATAL_FAILURE };
static void AddFailure(FailureMode failure) {
if (failure == FATAL_FAILURE) {
AddFatalFailure();
......@@ -1192,7 +1181,7 @@ TEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) {
#if GTEST_IS_THREADSAFE
class ScopedFakeTestPartResultReporterWithThreadsTest
: public ScopedFakeTestPartResultReporterTest {
: public ScopedFakeTestPartResultReporterTest {
protected:
static void AddFailureInOtherThread(FailureMode failure) {
ThreadWithParam<FailureMode> thread(&AddFailure, failure, nullptr);
......@@ -1245,7 +1234,7 @@ TEST_F(ExpectFatalFailureTest, CatchesFatalFailureOnAllThreads) {
#ifdef __BORLANDC__
// Silences warnings: "Condition is always true"
# pragma option push -w-ccc
#pragma option push -w-ccc
#endif
// Tests that EXPECT_FATAL_FAILURE() can be used in a non-void
......@@ -1273,7 +1262,7 @@ void DoesNotAbortHelper(bool* aborted) {
#ifdef __BORLANDC__
// Restores warnings after previous "#pragma option push" suppressed them.
# pragma option pop
#pragma option pop
#endif
TEST_F(ExpectFatalFailureTest, DoesNotAbort) {
......@@ -1292,16 +1281,20 @@ static int global_var = 0;
TEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
#ifndef __BORLANDC__
// ICE's in C++Builder.
EXPECT_FATAL_FAILURE({
GTEST_USE_UNPROTECTED_COMMA_;
AddFatalFailure();
}, "");
EXPECT_FATAL_FAILURE(
{
GTEST_USE_UNPROTECTED_COMMA_;
AddFatalFailure();
},
"");
#endif
EXPECT_FATAL_FAILURE_ON_ALL_THREADS({
GTEST_USE_UNPROTECTED_COMMA_;
AddFatalFailure();
}, "");
EXPECT_FATAL_FAILURE_ON_ALL_THREADS(
{
GTEST_USE_UNPROTECTED_COMMA_;
AddFatalFailure();
},
"");
}
// Tests EXPECT_NONFATAL_FAILURE{,ON_ALL_THREADS}.
......@@ -1309,8 +1302,7 @@ TEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
typedef ScopedFakeTestPartResultReporterTest ExpectNonfatalFailureTest;
TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailure) {
EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
"Expected non-fatal failure.");
EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(), "Expected non-fatal failure.");
}
TEST_F(ExpectNonfatalFailureTest, AcceptsStdStringObject) {
......@@ -1329,15 +1321,19 @@ TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailureOnAllThreads) {
// statement that contains a macro which expands to code containing an
// unprotected comma.
TEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
EXPECT_NONFATAL_FAILURE({
GTEST_USE_UNPROTECTED_COMMA_;
AddNonfatalFailure();
}, "");
EXPECT_NONFATAL_FAILURE(
{
GTEST_USE_UNPROTECTED_COMMA_;
AddNonfatalFailure();
},
"");
EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS({
GTEST_USE_UNPROTECTED_COMMA_;
AddNonfatalFailure();
}, "");
EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(
{
GTEST_USE_UNPROTECTED_COMMA_;
AddNonfatalFailure();
},
"");
}
#if GTEST_IS_THREADSAFE
......@@ -1381,21 +1377,18 @@ class TestResultTest : public Test {
typedef std::vector<TestPartResult> TPRVector;
// We make use of 2 TestPartResult objects,
TestPartResult * pr1, * pr2;
TestPartResult *pr1, *pr2;
// ... and 3 TestResult objects.
TestResult * r0, * r1, * r2;
TestResult *r0, *r1, *r2;
void SetUp() override {
// pr1 is for success.
pr1 = new TestPartResult(TestPartResult::kSuccess,
"foo/bar.cc",
10,
pr1 = new TestPartResult(TestPartResult::kSuccess, "foo/bar.cc", 10,
"Success!");
// pr2 is for fatal failure.
pr2 = new TestPartResult(TestPartResult::kFatalFailure,
"foo/bar.cc",
pr2 = new TestPartResult(TestPartResult::kFatalFailure, "foo/bar.cc",
-1, // This line number means "unknown"
"Failure!");
......@@ -1408,10 +1401,10 @@ class TestResultTest : public Test {
// state, in particular the TestPartResult vector it holds.
// test_part_results() returns a const reference to this vector.
// We cast it to a non-const object s.t. it can be modified
TPRVector* results1 = const_cast<TPRVector*>(
&TestResultAccessor::test_part_results(*r1));
TPRVector* results2 = const_cast<TPRVector*>(
&TestResultAccessor::test_part_results(*r2));
TPRVector* results1 =
const_cast<TPRVector*>(&TestResultAccessor::test_part_results(*r1));
TPRVector* results2 =
const_cast<TPRVector*>(&TestResultAccessor::test_part_results(*r2));
// r0 is an empty TestResult.
......@@ -1662,15 +1655,11 @@ GTestFlagSaver* GTestFlagSaverTest::saver_ = nullptr;
// tests are designed to work regardless of their order.
// Modifies the Google Test flags in the test body.
TEST_F(GTestFlagSaverTest, ModifyGTestFlags) {
VerifyAndModifyFlags();
}
TEST_F(GTestFlagSaverTest, ModifyGTestFlags) { VerifyAndModifyFlags(); }
// Verifies that the Google Test flags in the body of the previous test were
// restored to their original values.
TEST_F(GTestFlagSaverTest, VerifyGTestFlags) {
VerifyAndModifyFlags();
}
TEST_F(GTestFlagSaverTest, VerifyGTestFlags) { VerifyAndModifyFlags(); }
// Sets an environment variable with the given name to the given
// value. If the value argument is "", unsets the environment
......@@ -1687,12 +1676,12 @@ static void SetEnv(const char* name, const char* value) {
// Because putenv stores a pointer to the string buffer, we can't delete the
// previous string (if present) until after it's replaced.
std::string *prev_env = NULL;
std::string* prev_env = NULL;
if (added_env.find(name) != added_env.end()) {
prev_env = added_env[name];
}
added_env[name] = new std::string(
(Message() << name << "=" << value).GetString());
added_env[name] =
new std::string((Message() << name << "=" << value).GetString());
// The standard signature of putenv accepts a 'char*' argument. Other
// implementations, like C++Builder's, accept a 'const char*'.
......@@ -1724,7 +1713,7 @@ TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) {
EXPECT_EQ(10, Int32FromGTestEnv("temp", 10));
}
# if !defined(GTEST_GET_INT32_FROM_ENV_)
#if !defined(GTEST_GET_INT32_FROM_ENV_)
// Tests that Int32FromGTestEnv() returns the default value when the
// environment variable overflows as an Int32.
......@@ -1750,7 +1739,7 @@ TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) {
EXPECT_EQ(50, Int32FromGTestEnv("temp", 50));
}
# endif // !defined(GTEST_GET_INT32_FROM_ENV_)
#endif // !defined(GTEST_GET_INT32_FROM_ENV_)
// Tests that Int32FromGTestEnv() parses and returns the value of the
// environment variable when it represents a valid decimal integer in
......@@ -1834,8 +1823,7 @@ TEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) {
TEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) {
SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "xxx");
EXPECT_DEATH_IF_SUPPORTED(
Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123),
".*");
Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123), ".*");
}
// Tests that Int32FromEnvOrDie() aborts with an error message
......@@ -1843,8 +1831,7 @@ TEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) {
TEST(Int32FromEnvOrDieDeathTest, AbortsOnInt32Overflow) {
SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "1234567891234567891234");
EXPECT_DEATH_IF_SUPPORTED(
Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123),
".*");
Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123), ".*");
}
// Tests that ShouldRunTestOnShard() selects all tests
......@@ -1951,7 +1938,8 @@ TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) {
prev_selected_shard_index = shard_index;
} else {
ADD_FAILURE() << "Shard " << prev_selected_shard_index << " and "
<< shard_index << " are both selected to run test " << test_id;
<< shard_index << " are both selected to run test "
<< test_id;
}
}
}
......@@ -1963,7 +1951,7 @@ TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) {
int num_tests_on_shard = 0;
for (int test_id = 0; test_id < num_tests; test_id++) {
num_tests_on_shard +=
ShouldRunTestOnShard(num_shards, shard_index, test_id);
ShouldRunTestOnShard(num_shards, shard_index, test_id);
}
EXPECT_GE(num_tests_on_shard, num_tests / num_shards);
}
......@@ -1995,8 +1983,8 @@ TEST(UnitTestTest, ReturnsPlausibleTimestamp) {
void ExpectNonFatalFailureRecordingPropertyWithReservedKey(
const TestResult& test_result, const char* key) {
EXPECT_NONFATAL_FAILURE(Test::RecordProperty(key, "1"), "Reserved key");
ASSERT_EQ(0, test_result.test_property_count()) << "Property for key '" << key
<< "' recorded unexpectedly.";
ASSERT_EQ(0, test_result.test_property_count())
<< "Property for key '" << key << "' recorded unexpectedly.";
}
void ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
......@@ -2025,8 +2013,8 @@ void ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestSuite(
// Tests that property recording functions in UnitTest outside of tests
// functions correctly. Creating a separate instance of UnitTest ensures it
// is in a state similar to the UnitTest's singleton's between tests.
class UnitTestRecordPropertyTest :
public testing::internal::UnitTestRecordPropertyTestHelper {
class UnitTestRecordPropertyTest
: public testing::internal::UnitTestRecordPropertyTestHelper {
public:
static void SetUpTestSuite() {
ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestSuite(
......@@ -2065,8 +2053,7 @@ TEST_F(UnitTestRecordPropertyTest, OnePropertyFoundWhenAdded) {
EXPECT_STREQ("key_1",
unit_test_.ad_hoc_test_result().GetTestProperty(0).key());
EXPECT_STREQ("1",
unit_test_.ad_hoc_test_result().GetTestProperty(0).value());
EXPECT_STREQ("1", unit_test_.ad_hoc_test_result().GetTestProperty(0).value());
}
// Tests TestResult has multiple properties when added.
......@@ -2107,16 +2094,13 @@ TEST_F(UnitTestRecordPropertyTest, OverridesValuesForDuplicateKeys) {
TEST_F(UnitTestRecordPropertyTest,
AddFailureInsideTestsWhenUsingTestSuiteReservedKeys) {
ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
"name");
ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest("name");
ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
"value_param");
ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
"type_param");
ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
"status");
ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
"time");
ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest("status");
ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest("time");
ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest(
"classname");
}
......@@ -2164,9 +2148,7 @@ static Environment* record_property_env GTEST_ATTRIBUTE_UNUSED_ =
// First, some predicates and predicate-formatters needed by the tests.
// Returns true if and only if the argument is an even number.
bool IsEven(int n) {
return (n % 2) == 0;
}
bool IsEven(int n) { return (n % 2) == 0; }
// A functor that returns true if and only if the argument is an even number.
struct IsEvenFunctor {
......@@ -2213,41 +2195,37 @@ struct AssertIsEvenFunctor {
};
// Returns true if and only if the sum of the arguments is an even number.
bool SumIsEven2(int n1, int n2) {
return IsEven(n1 + n2);
}
bool SumIsEven2(int n1, int n2) { return IsEven(n1 + n2); }
// A functor that returns true if and only if the sum of the arguments is an
// even number.
struct SumIsEven3Functor {
bool operator()(int n1, int n2, int n3) {
return IsEven(n1 + n2 + n3);
}
bool operator()(int n1, int n2, int n3) { return IsEven(n1 + n2 + n3); }
};
// A predicate-formatter function that asserts the sum of the
// arguments is an even number.
AssertionResult AssertSumIsEven4(
const char* e1, const char* e2, const char* e3, const char* e4,
int n1, int n2, int n3, int n4) {
AssertionResult AssertSumIsEven4(const char* e1, const char* e2, const char* e3,
const char* e4, int n1, int n2, int n3,
int n4) {
const int sum = n1 + n2 + n3 + n4;
if (IsEven(sum)) {
return AssertionSuccess();
}
Message msg;
msg << e1 << " + " << e2 << " + " << e3 << " + " << e4
<< " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4
<< ") evaluates to " << sum << ", which is not even.";
msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " (" << n1 << " + "
<< n2 << " + " << n3 << " + " << n4 << ") evaluates to " << sum
<< ", which is not even.";
return AssertionFailure(msg);
}
// A predicate-formatter functor that asserts the sum of the arguments
// is an even number.
struct AssertSumIsEven5Functor {
AssertionResult operator()(
const char* e1, const char* e2, const char* e3, const char* e4,
const char* e5, int n1, int n2, int n3, int n4, int n5) {
AssertionResult operator()(const char* e1, const char* e2, const char* e3,
const char* e4, const char* e5, int n1, int n2,
int n3, int n4, int n5) {
const int sum = n1 + n2 + n3 + n4 + n5;
if (IsEven(sum)) {
return AssertionSuccess();
......@@ -2255,14 +2233,12 @@ struct AssertSumIsEven5Functor {
Message msg;
msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
<< " ("
<< n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5
<< ") evaluates to " << sum << ", which is not even.";
<< " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + "
<< n5 << ") evaluates to " << sum << ", which is not even.";
return AssertionFailure(msg);
}
};
// Tests unary predicate assertions.
// Tests unary predicate assertions that don't use a custom formatter.
......@@ -2272,11 +2248,12 @@ TEST(Pred1Test, WithoutFormat) {
ASSERT_PRED1(IsEven, 4);
// Failure cases.
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_PRED1(IsEven, 5) << "This failure is expected.";
}, "This failure is expected.");
EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5),
"evaluates to false");
EXPECT_NONFATAL_FAILURE(
{ // NOLINT
EXPECT_PRED1(IsEven, 5) << "This failure is expected.";
},
"This failure is expected.");
EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5), "evaluates to false");
}
// Tests unary predicate assertions that use a custom formatter.
......@@ -2284,15 +2261,17 @@ TEST(Pred1Test, WithFormat) {
// Success cases.
EXPECT_PRED_FORMAT1(AssertIsEven, 2);
ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), 4)
<< "This failure is UNEXPECTED!";
<< "This failure is UNEXPECTED!";
// Failure cases.
const int n = 5;
EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT1(AssertIsEvenFunctor(), n),
"n evaluates to 5, which is not even.");
EXPECT_FATAL_FAILURE({ // NOLINT
ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected.";
}, "This failure is expected.");
EXPECT_FATAL_FAILURE(
{ // NOLINT
ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected.";
},
"This failure is expected.");
}
// Tests that unary predicate assertions evaluates their arguments
......@@ -2304,14 +2283,15 @@ TEST(Pred1Test, SingleEvaluationOnFailure) {
EXPECT_EQ(1, n) << "The argument is not evaluated exactly once.";
// A failure case.
EXPECT_FATAL_FAILURE({ // NOLINT
ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++)
<< "This failure is expected.";
}, "This failure is expected.");
EXPECT_FATAL_FAILURE(
{ // NOLINT
ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++)
<< "This failure is expected.";
},
"This failure is expected.");
EXPECT_EQ(2, n) << "The argument is not evaluated exactly once.";
}
// Tests predicate assertions whose arity is >= 2.
// Tests predicate assertions that don't use a custom formatter.
......@@ -2323,19 +2303,23 @@ TEST(PredTest, WithoutFormat) {
// Failure cases.
const int n1 = 1;
const int n2 = 2;
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected.";
}, "This failure is expected.");
EXPECT_FATAL_FAILURE({ // NOLINT
ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4);
}, "evaluates to false");
EXPECT_NONFATAL_FAILURE(
{ // NOLINT
EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected.";
},
"This failure is expected.");
EXPECT_FATAL_FAILURE(
{ // NOLINT
ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4);
},
"evaluates to false");
}
// Tests predicate assertions that use a custom formatter.
TEST(PredTest, WithFormat) {
// Success cases.
ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10) <<
"This failure is UNEXPECTED!";
ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10)
<< "This failure is UNEXPECTED!";
EXPECT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2, 4, 6, 8, 10);
// Failure cases.
......@@ -2343,13 +2327,17 @@ TEST(PredTest, WithFormat) {
const int n2 = 2;
const int n3 = 4;
const int n4 = 6;
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4);
}, "evaluates to 13, which is not even.");
EXPECT_FATAL_FAILURE({ // NOLINT
ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8)
<< "This failure is expected.";
}, "This failure is expected.");
EXPECT_NONFATAL_FAILURE(
{ // NOLINT
EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4);
},
"evaluates to 13, which is not even.");
EXPECT_FATAL_FAILURE(
{ // NOLINT
ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8)
<< "This failure is expected.";
},
"This failure is expected.");
}
// Tests that predicate assertions evaluates their arguments
......@@ -2367,9 +2355,8 @@ TEST(PredTest, SingleEvaluationOnFailure) {
int n3 = 0;
int n4 = 0;
int n5 = 0;
ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(),
n1++, n2++, n3++, n4++, n5++)
<< "This failure is UNEXPECTED!";
ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), n1++, n2++, n3++, n4++, n5++)
<< "This failure is UNEXPECTED!";
EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
......@@ -2378,19 +2365,23 @@ TEST(PredTest, SingleEvaluationOnFailure) {
// A failure case.
n1 = n2 = n3 = 0;
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++)
<< "This failure is expected.";
}, "This failure is expected.");
EXPECT_NONFATAL_FAILURE(
{ // NOLINT
EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++)
<< "This failure is expected.";
},
"This failure is expected.");
EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
// Another failure case.
n1 = n2 = n3 = n4 = 0;
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++);
}, "evaluates to 1, which is not even.");
EXPECT_NONFATAL_FAILURE(
{ // NOLINT
EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++);
},
"evaluates to 1, which is not even.");
EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
......@@ -2401,7 +2392,7 @@ TEST(PredTest, SingleEvaluationOnFailure) {
TEST(PredTest, ExpectPredEvalFailure) {
std::set<int> set_a = {2, 1, 3, 4, 5};
std::set<int> set_b = {0, 4, 8};
const auto compare_sets = [] (std::set<int>, std::set<int>) { return false; };
const auto compare_sets = [](std::set<int>, std::set<int>) { return false; };
EXPECT_NONFATAL_FAILURE(
EXPECT_PRED2(compare_sets, set_a, set_b),
"compare_sets(set_a, set_b) evaluates to false, where\nset_a evaluates "
......@@ -2411,9 +2402,7 @@ TEST(PredTest, ExpectPredEvalFailure) {
// Some helper functions for testing using overloaded/template
// functions with ASSERT_PREDn and EXPECT_PREDn.
bool IsPositive(double x) {
return x > 0;
}
bool IsPositive(double x) { return x > 0; }
template <typename T>
bool IsNegative(T x) {
......@@ -2429,7 +2418,7 @@ bool GreaterThan(T1 x1, T2 x2) {
// their types are explicitly specified.
TEST(PredicateAssertionTest, AcceptsOverloadedFunction) {
// C++Builder requires C-style casts rather than static_cast.
EXPECT_PRED1((bool (*)(int))(IsPositive), 5); // NOLINT
EXPECT_PRED1((bool (*)(int))(IsPositive), 5); // NOLINT
ASSERT_PRED1((bool (*)(double))(IsPositive), 6.0); // NOLINT
}
......@@ -2442,31 +2431,27 @@ TEST(PredicateAssertionTest, AcceptsTemplateFunction) {
ASSERT_PRED2((GreaterThan<int, int>), 5, 0);
}
// Some helper functions for testing using overloaded/template
// functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn.
AssertionResult IsPositiveFormat(const char* /* expr */, int n) {
return n > 0 ? AssertionSuccess() :
AssertionFailure(Message() << "Failure");
return n > 0 ? AssertionSuccess() : AssertionFailure(Message() << "Failure");
}
AssertionResult IsPositiveFormat(const char* /* expr */, double x) {
return x > 0 ? AssertionSuccess() :
AssertionFailure(Message() << "Failure");
return x > 0 ? AssertionSuccess() : AssertionFailure(Message() << "Failure");
}
template <typename T>
AssertionResult IsNegativeFormat(const char* /* expr */, T x) {
return x < 0 ? AssertionSuccess() :
AssertionFailure(Message() << "Failure");
return x < 0 ? AssertionSuccess() : AssertionFailure(Message() << "Failure");
}
template <typename T1, typename T2>
AssertionResult EqualsFormat(const char* /* expr1 */, const char* /* expr2 */,
const T1& x1, const T2& x2) {
return x1 == x2 ? AssertionSuccess() :
AssertionFailure(Message() << "Failure");
return x1 == x2 ? AssertionSuccess()
: AssertionFailure(Message() << "Failure");
}
// Tests that overloaded functions can be used in *_PRED_FORMAT*
......@@ -2483,20 +2468,18 @@ TEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) {
ASSERT_PRED_FORMAT2(EqualsFormat, 3, 3);
}
// Tests string assertions.
// Tests ASSERT_STREQ with non-NULL arguments.
TEST(StringAssertionTest, ASSERT_STREQ) {
const char * const p1 = "good";
const char* const p1 = "good";
ASSERT_STREQ(p1, p1);
// Let p2 have the same content as p1, but be at a different address.
const char p2[] = "good";
ASSERT_STREQ(p1, p2);
EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"),
" \"bad\"\n \"good\"");
EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"), " \"bad\"\n \"good\"");
}
// Tests ASSERT_STREQ with NULL arguments.
......@@ -2519,8 +2502,7 @@ TEST(StringAssertionTest, ASSERT_STRNE) {
ASSERT_STRNE(nullptr, "");
ASSERT_STRNE("", "Hi");
ASSERT_STRNE("Hi", "");
EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"),
"\"Hi\" vs \"Hi\"");
EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"), "\"Hi\" vs \"Hi\"");
}
// Tests ASSERT_STRCASEEQ.
......@@ -2529,8 +2511,7 @@ TEST(StringAssertionTest, ASSERT_STRCASEEQ) {
ASSERT_STRCASEEQ(static_cast<const char*>(nullptr), nullptr);
ASSERT_STRCASEEQ("", "");
EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"),
"Ignoring case");
EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"), "Ignoring case");
}
// Tests ASSERT_STRCASENE.
......@@ -2542,8 +2523,7 @@ TEST(StringAssertionTest, ASSERT_STRCASENE) {
ASSERT_STRCASENE(nullptr, "");
ASSERT_STRCASENE("", "Hi");
ASSERT_STRCASENE("Hi", "");
EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"),
"(ignoring case)");
EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"), "(ignoring case)");
}
// Tests *_STREQ on wide strings.
......@@ -2561,17 +2541,17 @@ TEST(StringAssertionTest, STREQ_Wide) {
EXPECT_STREQ(L"Hi", L"Hi");
// Unequal strings.
EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"),
"Abc");
EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"), "Abc");
// Strings containing wide characters.
EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"),
"abc");
EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"), "abc");
// The streaming variation.
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_STREQ(L"abc\x8119", L"abc\x8121") << "Expected failure";
}, "Expected failure");
EXPECT_NONFATAL_FAILURE(
{ // NOLINT
EXPECT_STREQ(L"abc\x8119", L"abc\x8121") << "Expected failure";
},
"Expected failure");
}
// Tests *_STRNE on wide strings.
......@@ -2584,22 +2564,19 @@ TEST(StringAssertionTest, STRNE_Wide) {
"");
// Empty strings.
EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""),
"L\"\"");
EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""), "L\"\"");
// Non-null vs NULL.
ASSERT_STRNE(L"non-null", nullptr);
// Equal strings.
EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"),
"L\"Hi\"");
EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"), "L\"Hi\"");
// Unequal strings.
EXPECT_STRNE(L"abc", L"Abc");
// Strings containing wide characters.
EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"),
"abc");
EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"), "abc");
// The streaming variation.
ASSERT_STRNE(L"abc\x8119", L"abc\x8120") << "This shouldn't happen";
......@@ -2633,12 +2610,13 @@ TEST(IsSubstringTest, ReturnsCorrectResultForWideCString) {
// Tests that IsSubstring() generates the correct message when the input
// argument type is const char*.
TEST(IsSubstringTest, GeneratesCorrectMessageForCString) {
EXPECT_STREQ("Value of: needle_expr\n"
" Actual: \"needle\"\n"
"Expected: a substring of haystack_expr\n"
"Which is: \"haystack\"",
IsSubstring("needle_expr", "haystack_expr",
"needle", "haystack").failure_message());
EXPECT_STREQ(
"Value of: needle_expr\n"
" Actual: \"needle\"\n"
"Expected: a substring of haystack_expr\n"
"Which is: \"haystack\"",
IsSubstring("needle_expr", "haystack_expr", "needle", "haystack")
.failure_message());
}
// Tests that IsSubstring returns the correct result when the input
......@@ -2659,13 +2637,14 @@ TEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) {
// Tests that IsSubstring() generates the correct message when the input
// argument type is ::std::wstring.
TEST(IsSubstringTest, GeneratesCorrectMessageForWstring) {
EXPECT_STREQ("Value of: needle_expr\n"
" Actual: L\"needle\"\n"
"Expected: a substring of haystack_expr\n"
"Which is: L\"haystack\"",
IsSubstring(
"needle_expr", "haystack_expr",
::std::wstring(L"needle"), L"haystack").failure_message());
EXPECT_STREQ(
"Value of: needle_expr\n"
" Actual: L\"needle\"\n"
"Expected: a substring of haystack_expr\n"
"Which is: L\"haystack\"",
IsSubstring("needle_expr", "haystack_expr", ::std::wstring(L"needle"),
L"haystack")
.failure_message());
}
#endif // GTEST_HAS_STD_WSTRING
......@@ -2689,13 +2668,13 @@ TEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) {
// Tests that IsNotSubstring() generates the correct message when the input
// argument type is const wchar_t*.
TEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) {
EXPECT_STREQ("Value of: needle_expr\n"
" Actual: L\"needle\"\n"
"Expected: not a substring of haystack_expr\n"
"Which is: L\"two needles\"",
IsNotSubstring(
"needle_expr", "haystack_expr",
L"needle", L"two needles").failure_message());
EXPECT_STREQ(
"Value of: needle_expr\n"
" Actual: L\"needle\"\n"
"Expected: not a substring of haystack_expr\n"
"Which is: L\"two needles\"",
IsNotSubstring("needle_expr", "haystack_expr", L"needle", L"two needles")
.failure_message());
}
// Tests that IsNotSubstring returns the correct result when the input
......@@ -2708,13 +2687,14 @@ TEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) {
// Tests that IsNotSubstring() generates the correct message when the input
// argument type is ::std::string.
TEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) {
EXPECT_STREQ("Value of: needle_expr\n"
" Actual: \"needle\"\n"
"Expected: not a substring of haystack_expr\n"
"Which is: \"two needles\"",
IsNotSubstring(
"needle_expr", "haystack_expr",
::std::string("needle"), "two needles").failure_message());
EXPECT_STREQ(
"Value of: needle_expr\n"
" Actual: \"needle\"\n"
"Expected: not a substring of haystack_expr\n"
"Which is: \"two needles\"",
IsNotSubstring("needle_expr", "haystack_expr", ::std::string("needle"),
"two needles")
.failure_message());
}
#if GTEST_HAS_STD_WSTRING
......@@ -2761,20 +2741,20 @@ class FloatingPointTest : public Test {
const Bits zero_bits = Floating(0).bits();
// Makes some numbers close to 0.0.
values_.close_to_positive_zero = Floating::ReinterpretBits(
zero_bits + max_ulps/2);
values_.close_to_negative_zero = -Floating::ReinterpretBits(
zero_bits + max_ulps - max_ulps/2);
values_.further_from_negative_zero = -Floating::ReinterpretBits(
zero_bits + max_ulps + 1 - max_ulps/2);
values_.close_to_positive_zero =
Floating::ReinterpretBits(zero_bits + max_ulps / 2);
values_.close_to_negative_zero =
-Floating::ReinterpretBits(zero_bits + max_ulps - max_ulps / 2);
values_.further_from_negative_zero =
-Floating::ReinterpretBits(zero_bits + max_ulps + 1 - max_ulps / 2);
// The bits that represent 1.0.
const Bits one_bits = Floating(1).bits();
// Makes some numbers close to 1.0.
values_.close_to_one = Floating::ReinterpretBits(one_bits + max_ulps);
values_.further_from_one = Floating::ReinterpretBits(
one_bits + max_ulps + 1);
values_.further_from_one =
Floating::ReinterpretBits(one_bits + max_ulps + 1);
// +infinity.
values_.infinity = Floating::Infinity();
......@@ -2783,23 +2763,23 @@ class FloatingPointTest : public Test {
const Bits infinity_bits = Floating(values_.infinity).bits();
// Makes some numbers close to infinity.
values_.close_to_infinity = Floating::ReinterpretBits(
infinity_bits - max_ulps);
values_.further_from_infinity = Floating::ReinterpretBits(
infinity_bits - max_ulps - 1);
values_.close_to_infinity =
Floating::ReinterpretBits(infinity_bits - max_ulps);
values_.further_from_infinity =
Floating::ReinterpretBits(infinity_bits - max_ulps - 1);
// Makes some NAN's. Sets the most significant bit of the fraction so that
// our NaN's are quiet; trying to process a signaling NaN would raise an
// exception if our environment enables floating point exceptions.
values_.nan1 = Floating::ReinterpretBits(Floating::kExponentBitMask
| (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1);
values_.nan2 = Floating::ReinterpretBits(Floating::kExponentBitMask
| (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200);
values_.nan1 = Floating::ReinterpretBits(
Floating::kExponentBitMask |
(static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1);
values_.nan2 = Floating::ReinterpretBits(
Floating::kExponentBitMask |
(static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200);
}
void TestSize() {
EXPECT_EQ(sizeof(RawType), sizeof(Bits));
}
void TestSize() { EXPECT_EQ(sizeof(RawType), sizeof(Bits)); }
static TestValues values_;
};
......@@ -2812,17 +2792,13 @@ typename FloatingPointTest<RawType>::TestValues
typedef FloatingPointTest<float> FloatTest;
// Tests that the size of Float::Bits matches the size of float.
TEST_F(FloatTest, Size) {
TestSize();
}
TEST_F(FloatTest, Size) { TestSize(); }
// Tests comparing with +0 and -0.
TEST_F(FloatTest, Zeros) {
EXPECT_FLOAT_EQ(0.0, -0.0);
EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0),
"1.0");
EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5),
"1.5");
EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0), "1.0");
EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5), "1.5");
}
// Tests comparing numbers close to 0.
......@@ -2843,10 +2819,11 @@ TEST_F(FloatTest, AlmostZeros) {
EXPECT_FLOAT_EQ(-0.0, v.close_to_negative_zero);
EXPECT_FLOAT_EQ(v.close_to_positive_zero, v.close_to_negative_zero);
EXPECT_FATAL_FAILURE({ // NOLINT
ASSERT_FLOAT_EQ(v.close_to_positive_zero,
v.further_from_negative_zero);
}, "v.further_from_negative_zero");
EXPECT_FATAL_FAILURE(
{ // NOLINT
ASSERT_FLOAT_EQ(v.close_to_positive_zero, v.further_from_negative_zero);
},
"v.further_from_negative_zero");
}
// Tests comparing numbers close to each other.
......@@ -2858,8 +2835,7 @@ TEST_F(FloatTest, SmallDiff) {
// Tests comparing numbers far apart.
TEST_F(FloatTest, LargeDiff) {
EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0),
"3.0");
EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0), "3.0");
}
// Tests comparing with infinity.
......@@ -2888,15 +2864,11 @@ TEST_F(FloatTest, NaN) {
// (parentheses).
static const FloatTest::TestValues& v = this->values_;
EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1),
"v.nan1");
EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2),
"v.nan2");
EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1),
"v.nan1");
EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1), "v.nan1");
EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2), "v.nan2");
EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1), "v.nan1");
EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity),
"v.infinity");
EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity), "v.infinity");
}
// Tests that *_FLOAT_EQ are reflexive.
......@@ -2950,36 +2922,40 @@ TEST_F(FloatTest, FloatLEFails) {
"(2.0f) <= (1.0f)");
// or by a small yet non-negligible margin,
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f);
}, "(values_.further_from_one) <= (1.0f)");
EXPECT_NONFATAL_FAILURE(
{ // NOLINT
EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f);
},
"(values_.further_from_one) <= (1.0f)");
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity);
}, "(values_.nan1) <= (values_.infinity)");
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1);
}, "(-values_.infinity) <= (values_.nan1)");
EXPECT_FATAL_FAILURE({ // NOLINT
ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1);
}, "(values_.nan1) <= (values_.nan1)");
EXPECT_NONFATAL_FAILURE(
{ // NOLINT
EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity);
},
"(values_.nan1) <= (values_.infinity)");
EXPECT_NONFATAL_FAILURE(
{ // NOLINT
EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1);
},
"(-values_.infinity) <= (values_.nan1)");
EXPECT_FATAL_FAILURE(
{ // NOLINT
ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1);
},
"(values_.nan1) <= (values_.nan1)");
}
// Instantiates FloatingPointTest for testing *_DOUBLE_EQ.
typedef FloatingPointTest<double> DoubleTest;
// Tests that the size of Double::Bits matches the size of double.
TEST_F(DoubleTest, Size) {
TestSize();
}
TEST_F(DoubleTest, Size) { TestSize(); }
// Tests comparing with +0 and -0.
TEST_F(DoubleTest, Zeros) {
EXPECT_DOUBLE_EQ(0.0, -0.0);
EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0),
"1.0");
EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0),
"1.0");
EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0), "1.0");
EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0), "1.0");
}
// Tests comparing numbers close to 0.
......@@ -3000,10 +2976,12 @@ TEST_F(DoubleTest, AlmostZeros) {
EXPECT_DOUBLE_EQ(-0.0, v.close_to_negative_zero);
EXPECT_DOUBLE_EQ(v.close_to_positive_zero, v.close_to_negative_zero);
EXPECT_FATAL_FAILURE({ // NOLINT
ASSERT_DOUBLE_EQ(v.close_to_positive_zero,
v.further_from_negative_zero);
}, "v.further_from_negative_zero");
EXPECT_FATAL_FAILURE(
{ // NOLINT
ASSERT_DOUBLE_EQ(v.close_to_positive_zero,
v.further_from_negative_zero);
},
"v.further_from_negative_zero");
}
// Tests comparing numbers close to each other.
......@@ -3015,8 +2993,7 @@ TEST_F(DoubleTest, SmallDiff) {
// Tests comparing numbers far apart.
TEST_F(DoubleTest, LargeDiff) {
EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0),
"3.0");
EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0), "3.0");
}
// Tests comparing with infinity.
......@@ -3040,12 +3017,10 @@ TEST_F(DoubleTest, NaN) {
static const DoubleTest::TestValues& v = this->values_;
// Nokia's STLport crashes if we try to output infinity or NaN.
EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1),
"v.nan1");
EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1), "v.nan1");
EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan2), "v.nan2");
EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, v.nan1), "v.nan1");
EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity),
"v.infinity");
EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity), "v.infinity");
}
// Tests that *_DOUBLE_EQ are reflexive.
......@@ -3106,22 +3081,29 @@ TEST_F(DoubleTest, DoubleLEFails) {
"(2.0) <= (1.0)");
// or by a small yet non-negligible margin,
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0);
}, "(values_.further_from_one) <= (1.0)");
EXPECT_NONFATAL_FAILURE(
{ // NOLINT
EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0);
},
"(values_.further_from_one) <= (1.0)");
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity);
}, "(values_.nan1) <= (values_.infinity)");
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1);
}, " (-values_.infinity) <= (values_.nan1)");
EXPECT_FATAL_FAILURE({ // NOLINT
ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1);
}, "(values_.nan1) <= (values_.nan1)");
EXPECT_NONFATAL_FAILURE(
{ // NOLINT
EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity);
},
"(values_.nan1) <= (values_.infinity)");
EXPECT_NONFATAL_FAILURE(
{ // NOLINT
EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1);
},
" (-values_.infinity) <= (values_.nan1)");
EXPECT_FATAL_FAILURE(
{ // NOLINT
ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1);
},
"(values_.nan1) <= (values_.nan1)");
}
// Verifies that a test or test case whose name starts with DISABLED_ is
// not run.
......@@ -3133,9 +3115,7 @@ TEST(DisabledTest, DISABLED_TestShouldNotRun) {
// A test whose name does not start with DISABLED_.
// Should run.
TEST(DisabledTest, NotDISABLED_TestShouldRun) {
EXPECT_EQ(1, 1);
}
TEST(DisabledTest, NotDISABLED_TestShouldRun) { EXPECT_EQ(1, 1); }
// A test case whose name starts with DISABLED_.
// Should not run.
......@@ -3175,8 +3155,7 @@ TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) {
// Tests that disabled typed tests aren't run.
template <typename T>
class TypedTest : public Test {
};
class TypedTest : public Test {};
typedef testing::Types<int, double> NumericTypes;
TYPED_TEST_SUITE(TypedTest, NumericTypes);
......@@ -3186,8 +3165,7 @@ TYPED_TEST(TypedTest, DISABLED_ShouldNotRun) {
}
template <typename T>
class DISABLED_TypedTest : public Test {
};
class DISABLED_TypedTest : public Test {};
TYPED_TEST_SUITE(DISABLED_TypedTest, NumericTypes);
......@@ -3198,8 +3176,7 @@ TYPED_TEST(DISABLED_TypedTest, ShouldNotRun) {
// Tests that disabled type-parameterized tests aren't run.
template <typename T>
class TypedTestP : public Test {
};
class TypedTestP : public Test {};
TYPED_TEST_SUITE_P(TypedTestP);
......@@ -3213,8 +3190,7 @@ REGISTER_TYPED_TEST_SUITE_P(TypedTestP, DISABLED_ShouldNotRun);
INSTANTIATE_TYPED_TEST_SUITE_P(My, TypedTestP, NumericTypes);
template <typename T>
class DISABLED_TypedTestP : public Test {
};
class DISABLED_TypedTestP : public Test {};
TYPED_TEST_SUITE_P(DISABLED_TypedTestP);
......@@ -3234,15 +3210,11 @@ class SingleEvaluationTest : public Test {
// This helper function is needed by the FailedASSERT_STREQ test
// below. It's public to work around C++Builder's bug with scoping local
// classes.
static void CompareAndIncrementCharPtrs() {
ASSERT_STREQ(p1_++, p2_++);
}
static void CompareAndIncrementCharPtrs() { ASSERT_STREQ(p1_++, p2_++); }
// This helper function is needed by the FailedASSERT_NE test below. It's
// public to work around C++Builder's bug with scoping local classes.
static void CompareAndIncrementInts() {
ASSERT_NE(a_++, b_++);
}
static void CompareAndIncrementInts() { ASSERT_NE(a_++, b_++); }
protected:
SingleEvaluationTest() {
......@@ -3285,8 +3257,7 @@ TEST_F(SingleEvaluationTest, ASSERT_STR) {
EXPECT_EQ(s2_ + 1, p2_);
// failed EXPECT_STRCASEEQ
EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++),
"Ignoring case");
EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++), "Ignoring case");
EXPECT_EQ(s1_ + 2, p1_);
EXPECT_EQ(s2_ + 2, p2_);
}
......@@ -3346,34 +3317,39 @@ TEST_F(SingleEvaluationTest, OtherCases) {
#endif // GTEST_HAS_RTTI
void ThrowAnInteger() {
throw 1;
}
void ThrowRuntimeError(const char* what) {
throw std::runtime_error(what);
}
void ThrowAnInteger() { throw 1; }
void ThrowRuntimeError(const char* what) { throw std::runtime_error(what); }
// Tests that assertion arguments are evaluated exactly once.
TEST_F(SingleEvaluationTest, ExceptionTests) {
// successful EXPECT_THROW
EXPECT_THROW({ // NOLINT
a_++;
ThrowAnInteger();
}, int);
EXPECT_THROW(
{ // NOLINT
a_++;
ThrowAnInteger();
},
int);
EXPECT_EQ(1, a_);
// failed EXPECT_THROW, throws different
EXPECT_NONFATAL_FAILURE(EXPECT_THROW({ // NOLINT
a_++;
ThrowAnInteger();
}, bool), "throws a different type");
EXPECT_NONFATAL_FAILURE(EXPECT_THROW(
{ // NOLINT
a_++;
ThrowAnInteger();
},
bool),
"throws a different type");
EXPECT_EQ(2, a_);
// failed EXPECT_THROW, throws runtime error
EXPECT_NONFATAL_FAILURE(EXPECT_THROW({ // NOLINT
a_++;
ThrowRuntimeError("A description");
}, bool), "throws " ERROR_DESC " with description \"A description\"");
EXPECT_NONFATAL_FAILURE(EXPECT_THROW(
{ // NOLINT
a_++;
ThrowRuntimeError("A description");
},
bool),
"throws " ERROR_DESC
" with description \"A description\"");
EXPECT_EQ(3, a_);
// failed EXPECT_THROW, throws nothing
......@@ -3386,9 +3362,10 @@ TEST_F(SingleEvaluationTest, ExceptionTests) {
// failed EXPECT_NO_THROW
EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({ // NOLINT
a_++;
ThrowAnInteger();
}), "it throws");
a_++;
ThrowAnInteger();
}),
"it throws");
EXPECT_EQ(6, a_);
// successful EXPECT_ANY_THROW
......@@ -3409,12 +3386,8 @@ TEST_F(SingleEvaluationTest, ExceptionTests) {
class NoFatalFailureTest : public Test {
protected:
void Succeeds() {}
void FailsNonFatal() {
ADD_FAILURE() << "some non-fatal failure";
}
void Fails() {
FAIL() << "some fatal failure";
}
void FailsNonFatal() { ADD_FAILURE() << "some non-fatal failure"; }
void Fails() { FAIL() << "some fatal failure"; }
void DoAssertNoFatalFailureOnFails() {
ASSERT_NO_FATAL_FAILURE(Fails());
......@@ -3433,12 +3406,10 @@ TEST_F(NoFatalFailureTest, NoFailure) {
}
TEST_F(NoFatalFailureTest, NonFatalIsNoFailure) {
EXPECT_NONFATAL_FAILURE(
EXPECT_NO_FATAL_FAILURE(FailsNonFatal()),
"some non-fatal failure");
EXPECT_NONFATAL_FAILURE(
ASSERT_NO_FATAL_FAILURE(FailsNonFatal()),
"some non-fatal failure");
EXPECT_NONFATAL_FAILURE(EXPECT_NO_FATAL_FAILURE(FailsNonFatal()),
"some non-fatal failure");
EXPECT_NONFATAL_FAILURE(ASSERT_NO_FATAL_FAILURE(FailsNonFatal()),
"some non-fatal failure");
}
TEST_F(NoFatalFailureTest, AssertNoFatalFailureOnFatalFailure) {
......@@ -3561,8 +3532,9 @@ TEST(EditDistance, TestSuites) {
EditsToString(CalculateOptimalEdits(CharsToIndices(c->left),
CharsToIndices(c->right))))
<< "Left <" << c->left << "> Right <" << c->right << "> Edits <"
<< EditsToString(CalculateOptimalEdits(
CharsToIndices(c->left), CharsToIndices(c->right))) << ">";
<< EditsToString(CalculateOptimalEdits(CharsToIndices(c->left),
CharsToIndices(c->right)))
<< ">";
EXPECT_TRUE(c->expected_diff == CreateUnifiedDiff(CharsToLines(c->left),
CharsToLines(c->right)))
<< "Left <" << c->left << "> Right <" << c->right << "> Diff <"
......@@ -3575,8 +3547,7 @@ TEST(EditDistance, TestSuites) {
TEST(AssertionTest, EqFailure) {
const std::string foo_val("5"), bar_val("6");
const std::string msg1(
EqFailure("foo", "bar", foo_val, bar_val, false)
.failure_message());
EqFailure("foo", "bar", foo_val, bar_val, false).failure_message());
EXPECT_STREQ(
"Expected equality of these values:\n"
" foo\n"
......@@ -3586,8 +3557,7 @@ TEST(AssertionTest, EqFailure) {
msg1.c_str());
const std::string msg2(
EqFailure("foo", "6", foo_val, bar_val, false)
.failure_message());
EqFailure("foo", "6", foo_val, bar_val, false).failure_message());
EXPECT_STREQ(
"Expected equality of these values:\n"
" foo\n"
......@@ -3596,8 +3566,7 @@ TEST(AssertionTest, EqFailure) {
msg2.c_str());
const std::string msg3(
EqFailure("5", "bar", foo_val, bar_val, false)
.failure_message());
EqFailure("5", "bar", foo_val, bar_val, false).failure_message());
EXPECT_STREQ(
"Expected equality of these values:\n"
" 5\n"
......@@ -3614,9 +3583,8 @@ TEST(AssertionTest, EqFailure) {
msg4.c_str());
const std::string msg5(
EqFailure("foo", "bar",
std::string("\"x\""), std::string("\"y\""),
true).failure_message());
EqFailure("foo", "bar", std::string("\"x\""), std::string("\"y\""), true)
.failure_message());
EXPECT_STREQ(
"Expected equality of these values:\n"
" foo\n"
......@@ -3651,24 +3619,21 @@ TEST(AssertionTest, AppendUserMessage) {
const std::string foo("foo");
Message msg;
EXPECT_STREQ("foo",
AppendUserMessage(foo, msg).c_str());
EXPECT_STREQ("foo", AppendUserMessage(foo, msg).c_str());
msg << "bar";
EXPECT_STREQ("foo\nbar",
AppendUserMessage(foo, msg).c_str());
EXPECT_STREQ("foo\nbar", AppendUserMessage(foo, msg).c_str());
}
#ifdef __BORLANDC__
// Silences warnings: "Condition is always true", "Unreachable code"
# pragma option push -w-ccc -w-rch
#pragma option push -w-ccc -w-rch
#endif
// Tests ASSERT_TRUE.
TEST(AssertionTest, ASSERT_TRUE) {
ASSERT_TRUE(2 > 1); // NOLINT
EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1),
"2 < 1");
EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1), "2 < 1");
}
// Tests ASSERT_TRUE(predicate) for predicates returning AssertionResult.
......@@ -3716,7 +3681,7 @@ TEST(AssertionTest, AssertFalseWithAssertionResult) {
#ifdef __BORLANDC__
// Restores warnings after previous "#pragma option push" suppressed them
# pragma option pop
#pragma option pop
#endif
// Tests using ASSERT_EQ on double values. The purpose is to make
......@@ -3727,18 +3692,19 @@ TEST(ExpectTest, ASSERT_EQ_Double) {
ASSERT_EQ(5.6, 5.6);
// A failure.
EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2),
"5.1");
EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2), "5.1");
}
// Tests ASSERT_EQ.
TEST(AssertionTest, ASSERT_EQ) {
ASSERT_EQ(5, 2 + 3);
// clang-format off
EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3),
"Expected equality of these values:\n"
" 5\n"
" 2*3\n"
" Which is: 6");
// clang-format on
}
// Tests ASSERT_EQ(NULL, pointer).
......@@ -3763,8 +3729,7 @@ TEST(ExpectTest, ASSERT_EQ_0) {
ASSERT_EQ(0, n);
// A failure.
EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6),
" 0\n 5.6");
EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6), " 0\n 5.6");
}
// Tests ASSERT_NE.
......@@ -3779,30 +3744,26 @@ TEST(AssertionTest, ASSERT_NE) {
TEST(AssertionTest, ASSERT_LE) {
ASSERT_LE(2, 3);
ASSERT_LE(2, 2);
EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0),
"Expected: (2) <= (0), actual: 2 vs 0");
EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0), "Expected: (2) <= (0), actual: 2 vs 0");
}
// Tests ASSERT_LT.
TEST(AssertionTest, ASSERT_LT) {
ASSERT_LT(2, 3);
EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2),
"Expected: (2) < (2), actual: 2 vs 2");
EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2), "Expected: (2) < (2), actual: 2 vs 2");
}
// Tests ASSERT_GE.
TEST(AssertionTest, ASSERT_GE) {
ASSERT_GE(2, 1);
ASSERT_GE(2, 2);
EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3),
"Expected: (2) >= (3), actual: 2 vs 3");
EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3), "Expected: (2) >= (3), actual: 2 vs 3");
}
// Tests ASSERT_GT.
TEST(AssertionTest, ASSERT_GT) {
ASSERT_GT(2, 1);
EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2),
"Expected: (2) > (2), actual: 2 vs 2");
EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2), "Expected: (2) > (2), actual: 2 vs 2");
}
#if GTEST_HAS_EXCEPTIONS
......@@ -3813,7 +3774,7 @@ void ThrowNothing() {}
TEST(AssertionTest, ASSERT_THROW) {
ASSERT_THROW(ThrowAnInteger(), int);
# ifndef __BORLANDC__
#ifndef __BORLANDC__
// ICE's in C++Builder 2007 and 2009.
EXPECT_FATAL_FAILURE(
......@@ -3824,9 +3785,10 @@ TEST(AssertionTest, ASSERT_THROW) {
ASSERT_THROW(ThrowRuntimeError("A description"), std::logic_error),
"Expected: ThrowRuntimeError(\"A description\") "
"throws an exception of type std::logic_error.\n "
"Actual: it throws " ERROR_DESC " "
"Actual: it throws " ERROR_DESC
" "
"with description \"A description\".");
# endif
#endif
EXPECT_FATAL_FAILURE(
ASSERT_THROW(ThrowNothing(), bool),
......@@ -3843,17 +3805,17 @@ TEST(AssertionTest, ASSERT_NO_THROW) {
EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowRuntimeError("A description")),
"Expected: ThrowRuntimeError(\"A description\") "
"doesn't throw an exception.\n "
"Actual: it throws " ERROR_DESC " "
"Actual: it throws " ERROR_DESC
" "
"with description \"A description\".");
}
// Tests ASSERT_ANY_THROW.
TEST(AssertionTest, ASSERT_ANY_THROW) {
ASSERT_ANY_THROW(ThrowAnInteger());
EXPECT_FATAL_FAILURE(
ASSERT_ANY_THROW(ThrowNothing()),
"Expected: ThrowNothing() throws an exception.\n"
" Actual: it doesn't.");
EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()),
"Expected: ThrowNothing() throws an exception.\n"
" Actual: it doesn't.");
}
#endif // GTEST_HAS_EXCEPTIONS
......@@ -3867,14 +3829,11 @@ TEST(AssertionTest, AssertPrecedence) {
}
// A subroutine used by the following test.
void TestEq1(int x) {
ASSERT_EQ(1, x);
}
void TestEq1(int x) { ASSERT_EQ(1, x); }
// Tests calling a test subroutine that's not part of a fixture.
TEST(AssertionTest, NonFixtureSubroutine) {
EXPECT_FATAL_FAILURE(TestEq1(2),
" x\n Which is: 2");
EXPECT_FATAL_FAILURE(TestEq1(2), " x\n Which is: 2");
}
// An uncopyable class.
......@@ -3886,6 +3845,7 @@ class Uncopyable {
bool operator==(const Uncopyable& rhs) const {
return value() == rhs.value();
}
private:
// This constructor deliberately has no implementation, as we don't
// want this class to be copyable.
......@@ -3898,10 +3858,7 @@ class Uncopyable {
return os << value.value();
}
bool IsPositiveUncopyable(const Uncopyable& x) {
return x.value() > 0;
}
bool IsPositiveUncopyable(const Uncopyable& x) { return x.value() > 0; }
// A subroutine used by the following test.
void TestAssertNonPositive() {
......@@ -3920,8 +3877,9 @@ TEST(AssertionTest, AssertWorksWithUncopyableObject) {
Uncopyable x(5);
ASSERT_PRED1(IsPositiveUncopyable, x);
ASSERT_EQ(x, x);
EXPECT_FATAL_FAILURE(TestAssertNonPositive(),
"IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
EXPECT_FATAL_FAILURE(
TestAssertNonPositive(),
"IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(),
"Expected equality of these values:\n"
" x\n Which is: 5\n y\n Which is: -1");
......@@ -3932,18 +3890,16 @@ TEST(AssertionTest, ExpectWorksWithUncopyableObject) {
Uncopyable x(5);
EXPECT_PRED1(IsPositiveUncopyable, x);
Uncopyable y(-1);
EXPECT_NONFATAL_FAILURE(EXPECT_PRED1(IsPositiveUncopyable, y),
"IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
EXPECT_NONFATAL_FAILURE(
EXPECT_PRED1(IsPositiveUncopyable, y),
"IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
EXPECT_EQ(x, x);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y),
"Expected equality of these values:\n"
" x\n Which is: 5\n y\n Which is: -1");
}
enum NamedEnum {
kE1 = 0,
kE2 = 1
};
enum NamedEnum { kE1 = 0, kE2 = 1 };
TEST(AssertionTest, NamedEnum) {
EXPECT_EQ(kE1, kE1);
......@@ -3959,7 +3915,7 @@ TEST(AssertionTest, NamedEnum) {
enum {
kCaseA = -1,
# if GTEST_OS_LINUX
#if GTEST_OS_LINUX
// We want to test the case where the size of the anonymous enum is
// larger than sizeof(int), to make sure our implementation of the
......@@ -3972,21 +3928,21 @@ enum {
// assertions.
kCaseB = testing::internal::kMaxBiggestInt,
# else
#else
kCaseB = INT_MAX,
# endif // GTEST_OS_LINUX
#endif // GTEST_OS_LINUX
kCaseC = 42
};
TEST(AssertionTest, AnonymousEnum) {
# if GTEST_OS_LINUX
#if GTEST_OS_LINUX
EXPECT_EQ(static_cast<int>(kCaseA), static_cast<int>(kCaseB));
# endif // GTEST_OS_LINUX
#endif // GTEST_OS_LINUX
EXPECT_EQ(kCaseA, kCaseA);
EXPECT_NE(kCaseA, kCaseB);
......@@ -3994,10 +3950,8 @@ TEST(AssertionTest, AnonymousEnum) {
EXPECT_LE(kCaseA, kCaseB);
EXPECT_GT(kCaseB, kCaseA);
EXPECT_GE(kCaseA, kCaseA);
EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseB),
"(kCaseA) >= (kCaseB)");
EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseC),
"-1 vs 42");
EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseB), "(kCaseA) >= (kCaseB)");
EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseC), "-1 vs 42");
ASSERT_EQ(kCaseA, kCaseA);
ASSERT_NE(kCaseA, kCaseB);
......@@ -4006,34 +3960,25 @@ TEST(AssertionTest, AnonymousEnum) {
ASSERT_GT(kCaseB, kCaseA);
ASSERT_GE(kCaseA, kCaseA);
# ifndef __BORLANDC__
#ifndef __BORLANDC__
// ICE's in C++Builder.
EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB),
" kCaseB\n Which is: ");
EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
"\n Which is: 42");
# endif
EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB), " kCaseB\n Which is: ");
EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC), "\n Which is: 42");
#endif
EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
"\n Which is: -1");
EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC), "\n Which is: -1");
}
#endif // !GTEST_OS_MAC && !defined(__SUNPRO_CC)
#if GTEST_OS_WINDOWS
static HRESULT UnexpectedHRESULTFailure() {
return E_UNEXPECTED;
}
static HRESULT UnexpectedHRESULTFailure() { return E_UNEXPECTED; }
static HRESULT OkHRESULTSuccess() {
return S_OK;
}
static HRESULT OkHRESULTSuccess() { return S_OK; }
static HRESULT FalseHRESULTSuccess() {
return S_FALSE;
}
static HRESULT FalseHRESULTSuccess() { return S_FALSE; }
// HRESULT assertion tests test both zero and non-zero
// success codes as well as failure message for each.
......@@ -4044,8 +3989,8 @@ TEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) {
EXPECT_HRESULT_SUCCEEDED(S_FALSE);
EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),
"Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
" Actual: 0x8000FFFF");
"Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
" Actual: 0x8000FFFF");
}
TEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) {
......@@ -4053,35 +3998,35 @@ TEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) {
ASSERT_HRESULT_SUCCEEDED(S_FALSE);
EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),
"Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
" Actual: 0x8000FFFF");
"Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
" Actual: 0x8000FFFF");
}
TEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) {
EXPECT_HRESULT_FAILED(E_UNEXPECTED);
EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(OkHRESULTSuccess()),
"Expected: (OkHRESULTSuccess()) fails.\n"
" Actual: 0x0");
"Expected: (OkHRESULTSuccess()) fails.\n"
" Actual: 0x0");
EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(FalseHRESULTSuccess()),
"Expected: (FalseHRESULTSuccess()) fails.\n"
" Actual: 0x1");
"Expected: (FalseHRESULTSuccess()) fails.\n"
" Actual: 0x1");
}
TEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) {
ASSERT_HRESULT_FAILED(E_UNEXPECTED);
# ifndef __BORLANDC__
#ifndef __BORLANDC__
// ICE's in C++Builder 2007 and 2009.
EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(OkHRESULTSuccess()),
"Expected: (OkHRESULTSuccess()) fails.\n"
" Actual: 0x0");
# endif
"Expected: (OkHRESULTSuccess()) fails.\n"
" Actual: 0x0");
#endif
EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(FalseHRESULTSuccess()),
"Expected: (FalseHRESULTSuccess()) fails.\n"
" Actual: 0x1");
"Expected: (FalseHRESULTSuccess()) fails.\n"
" Actual: 0x1");
}
// Tests that streaming to the HRESULT macros works.
......@@ -4091,25 +4036,23 @@ TEST(HRESULTAssertionTest, Streaming) {
EXPECT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";
ASSERT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";
EXPECT_NONFATAL_FAILURE(
EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",
"expected failure");
EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED)
<< "expected failure",
"expected failure");
# ifndef __BORLANDC__
#ifndef __BORLANDC__
// ICE's in C++Builder 2007 and 2009.
EXPECT_FATAL_FAILURE(
ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",
"expected failure");
# endif
EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED)
<< "expected failure",
"expected failure");
#endif
EXPECT_NONFATAL_FAILURE(
EXPECT_HRESULT_FAILED(S_OK) << "expected failure",
"expected failure");
EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(S_OK) << "expected failure",
"expected failure");
EXPECT_FATAL_FAILURE(
ASSERT_HRESULT_FAILED(S_OK) << "expected failure",
"expected failure");
EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(S_OK) << "expected failure",
"expected failure");
}
#endif // GTEST_OS_WINDOWS
......@@ -4132,8 +4075,7 @@ TEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) {
else
; // NOLINT
if (AlwaysFalse())
ASSERT_LT(1, 3);
if (AlwaysFalse()) ASSERT_LT(1, 3);
if (AlwaysFalse())
; // NOLINT
......@@ -4171,24 +4113,21 @@ TEST(ExpectThrowTest, DoesNotGenerateDuplicateCatchClauseWarning) {
#pragma GCC diagnostic ignored "-Wpragmas"
#endif
TEST(AssertionSyntaxTest, ExceptionAssertionsBehavesLikeSingleStatement) {
if (AlwaysFalse())
EXPECT_THROW(ThrowNothing(), bool);
if (AlwaysFalse()) EXPECT_THROW(ThrowNothing(), bool);
if (AlwaysTrue())
EXPECT_THROW(ThrowAnInteger(), int);
else
; // NOLINT
if (AlwaysFalse())
EXPECT_NO_THROW(ThrowAnInteger());
if (AlwaysFalse()) EXPECT_NO_THROW(ThrowAnInteger());
if (AlwaysTrue())
EXPECT_NO_THROW(ThrowNothing());
else
; // NOLINT
if (AlwaysFalse())
EXPECT_ANY_THROW(ThrowNothing());
if (AlwaysFalse()) EXPECT_ANY_THROW(ThrowNothing());
if (AlwaysTrue())
EXPECT_ANY_THROW(ThrowAnInteger());
......@@ -4244,8 +4183,8 @@ TEST(AssertionSyntaxTest, WorksWithSwitch) {
}
switch (0)
case 0:
EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case";
case 0:
EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case";
// Binary assertions are implemented using a different code path
// than the Boolean assertions. Hence we test them separately.
......@@ -4256,22 +4195,20 @@ TEST(AssertionSyntaxTest, WorksWithSwitch) {
}
switch (0)
case 0:
EXPECT_NE(1, 2);
case 0:
EXPECT_NE(1, 2);
}
#if GTEST_HAS_EXCEPTIONS
void ThrowAString() {
throw "std::string";
}
void ThrowAString() { throw "std::string"; }
// Test that the exception assertion macros compile and work with const
// type qualifier.
TEST(AssertionSyntaxTest, WorksWithConst) {
ASSERT_THROW(ThrowAString(), const char*);
ASSERT_THROW(ThrowAString(), const char*);
EXPECT_THROW(ThrowAString(), const char*);
EXPECT_THROW(ThrowAString(), const char*);
}
#endif // GTEST_HAS_EXCEPTIONS
......@@ -4369,22 +4306,19 @@ TEST(AssertionWithMessageTest, ASSERT_FLOATING) {
// Tests using ASSERT_FALSE with a streamed message.
TEST(AssertionWithMessageTest, ASSERT_FALSE) {
ASSERT_FALSE(false) << "This shouldn't fail.";
EXPECT_FATAL_FAILURE({ // NOLINT
ASSERT_FALSE(true) << "Expected failure: " << 2 << " > " << 1
<< " evaluates to " << true;
}, "Expected failure");
EXPECT_FATAL_FAILURE(
{ // NOLINT
ASSERT_FALSE(true) << "Expected failure: " << 2 << " > " << 1
<< " evaluates to " << true;
},
"Expected failure");
}
// Tests using FAIL with a streamed message.
TEST(AssertionWithMessageTest, FAIL) {
EXPECT_FATAL_FAILURE(FAIL() << 0,
"0");
}
TEST(AssertionWithMessageTest, FAIL) { EXPECT_FATAL_FAILURE(FAIL() << 0, "0"); }
// Tests using SUCCEED with a streamed message.
TEST(AssertionWithMessageTest, SUCCEED) {
SUCCEED() << "Success == " << 1;
}
TEST(AssertionWithMessageTest, SUCCEED) { SUCCEED() << "Success == " << 1; }
// Tests using ASSERT_TRUE with a streamed message.
TEST(AssertionWithMessageTest, ASSERT_TRUE) {
......@@ -4401,13 +4335,16 @@ TEST(AssertionWithMessageTest, ASSERT_TRUE) {
#if GTEST_OS_WINDOWS
// Tests using wide strings in assertion messages.
TEST(AssertionWithMessageTest, WideStringMessage) {
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_TRUE(false) << L"This failure is expected.\x8119";
}, "This failure is expected.");
EXPECT_FATAL_FAILURE({ // NOLINT
ASSERT_EQ(1, 2) << "This failure is "
<< L"expected too.\x8120";
}, "This failure is expected too.");
EXPECT_NONFATAL_FAILURE(
{ // NOLINT
EXPECT_TRUE(false) << L"This failure is expected.\x8119";
},
"This failure is expected.");
EXPECT_FATAL_FAILURE(
{ // NOLINT
ASSERT_EQ(1, 2) << "This failure is " << L"expected too.\x8120";
},
"This failure is expected too.");
}
#endif // GTEST_OS_WINDOWS
......@@ -4423,8 +4360,7 @@ TEST(ExpectTest, EXPECT_TRUE) {
"Value of: 2 < 1\n"
" Actual: false\n"
"Expected: true");
EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3),
"2 > 3");
EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3), "2 > 3");
}
// Tests EXPECT_TRUE(predicate) for predicates returning AssertionResult.
......@@ -4453,8 +4389,7 @@ TEST(ExpectTest, EXPECT_FALSE) {
"Value of: 2 > 1\n"
" Actual: true\n"
"Expected: false");
EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3),
"2 < 3");
EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3), "2 < 3");
}
// Tests EXPECT_FALSE(predicate) for predicates returning AssertionResult.
......@@ -4473,19 +4408,20 @@ TEST(ExpectTest, ExpectFalseWithAssertionResult) {
#ifdef __BORLANDC__
// Restores warnings after previous "#pragma option push" suppressed them
# pragma option pop
#pragma option pop
#endif
// Tests EXPECT_EQ.
TEST(ExpectTest, EXPECT_EQ) {
EXPECT_EQ(5, 2 + 3);
// clang-format off
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3),
"Expected equality of these values:\n"
" 5\n"
" 2*3\n"
" Which is: 6");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3),
"2 - 3");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3), "2 - 3");
// clang-format on
}
// Tests using EXPECT_EQ on double values. The purpose is to make
......@@ -4496,8 +4432,7 @@ TEST(ExpectTest, EXPECT_EQ_Double) {
EXPECT_EQ(5.6, 5.6);
// A failure.
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2),
"5.1");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2), "5.1");
}
// Tests EXPECT_EQ(NULL, pointer).
......@@ -4522,8 +4457,7 @@ TEST(ExpectTest, EXPECT_EQ_0) {
EXPECT_EQ(0, n);
// A failure.
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6),
" 0\n 5.6");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6), " 0\n 5.6");
}
// Tests EXPECT_NE.
......@@ -4533,19 +4467,16 @@ TEST(ExpectTest, EXPECT_NE) {
EXPECT_NONFATAL_FAILURE(EXPECT_NE('a', 'a'),
"Expected: ('a') != ('a'), "
"actual: 'a' (97, 0x61) vs 'a' (97, 0x61)");
EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2),
"2");
EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2), "2");
char* const p0 = nullptr;
EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0),
"p0");
EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0), "p0");
// Only way to get the Nokia compiler to compile the cast
// is to have a separate void* variable first. Putting
// the two casts on the same line doesn't work, neither does
// a direct C-style to char*.
void* pv1 = (void*)0x1234; // NOLINT
char* const p1 = reinterpret_cast<char*>(pv1);
EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1),
"p1");
EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1), "p1");
}
// Tests EXPECT_LE.
......@@ -4554,8 +4485,7 @@ TEST(ExpectTest, EXPECT_LE) {
EXPECT_LE(2, 2);
EXPECT_NONFATAL_FAILURE(EXPECT_LE(2, 0),
"Expected: (2) <= (0), actual: 2 vs 0");
EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9),
"(1.1) <= (0.9)");
EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9), "(1.1) <= (0.9)");
}
// Tests EXPECT_LT.
......@@ -4563,8 +4493,7 @@ TEST(ExpectTest, EXPECT_LT) {
EXPECT_LT(2, 3);
EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 2),
"Expected: (2) < (2), actual: 2 vs 2");
EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1),
"(2) < (1)");
EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1), "(2) < (1)");
}
// Tests EXPECT_GE.
......@@ -4573,8 +4502,7 @@ TEST(ExpectTest, EXPECT_GE) {
EXPECT_GE(2, 2);
EXPECT_NONFATAL_FAILURE(EXPECT_GE(2, 3),
"Expected: (2) >= (3), actual: 2 vs 3");
EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1),
"(0.9) >= (1.1)");
EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1), "(0.9) >= (1.1)");
}
// Tests EXPECT_GT.
......@@ -4582,8 +4510,7 @@ TEST(ExpectTest, EXPECT_GT) {
EXPECT_GT(2, 1);
EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 2),
"Expected: (2) > (2), actual: 2 vs 2");
EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3),
"(2) > (3)");
EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3), "(2) > (3)");
}
#if GTEST_HAS_EXCEPTIONS
......@@ -4594,12 +4521,13 @@ TEST(ExpectTest, EXPECT_THROW) {
EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool),
"Expected: ThrowAnInteger() throws an exception of "
"type bool.\n Actual: it throws a different type.");
EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowRuntimeError("A description"),
std::logic_error),
"Expected: ThrowRuntimeError(\"A description\") "
"throws an exception of type std::logic_error.\n "
"Actual: it throws " ERROR_DESC " "
"with description \"A description\".");
EXPECT_NONFATAL_FAILURE(
EXPECT_THROW(ThrowRuntimeError("A description"), std::logic_error),
"Expected: ThrowRuntimeError(\"A description\") "
"throws an exception of type std::logic_error.\n "
"Actual: it throws " ERROR_DESC
" "
"with description \"A description\".");
EXPECT_NONFATAL_FAILURE(
EXPECT_THROW(ThrowNothing(), bool),
"Expected: ThrowNothing() throws an exception of type bool.\n"
......@@ -4615,17 +4543,17 @@ TEST(ExpectTest, EXPECT_NO_THROW) {
EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowRuntimeError("A description")),
"Expected: ThrowRuntimeError(\"A description\") "
"doesn't throw an exception.\n "
"Actual: it throws " ERROR_DESC " "
"Actual: it throws " ERROR_DESC
" "
"with description \"A description\".");
}
// Tests EXPECT_ANY_THROW.
TEST(ExpectTest, EXPECT_ANY_THROW) {
EXPECT_ANY_THROW(ThrowAnInteger());
EXPECT_NONFATAL_FAILURE(
EXPECT_ANY_THROW(ThrowNothing()),
"Expected: ThrowNothing() throws an exception.\n"
" Actual: it doesn't.");
EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()),
"Expected: ThrowNothing() throws an exception.\n"
" Actual: it doesn't.");
}
#endif // GTEST_HAS_EXCEPTIONS
......@@ -4637,7 +4565,6 @@ TEST(ExpectTest, ExpectPrecedence) {
" true && false\n Which is: false");
}
// Tests the StreamableToString() function.
// Tests using StreamableToString() on a scalar.
......@@ -4675,8 +4602,7 @@ TEST(StreamableToStringTest, NullCString) {
TEST(StreamableTest, string) {
static const std::string str(
"This failure message is a std::string, and is expected.");
EXPECT_FATAL_FAILURE(FAIL() << str,
str.c_str());
EXPECT_FATAL_FAILURE(FAIL() << str, str.c_str());
}
// Tests that we can output strings containing embedded NULs.
......@@ -4684,25 +4610,24 @@ TEST(StreamableTest, string) {
TEST(StreamableTest, stringWithEmbeddedNUL) {
static const char char_array_with_nul[] =
"Here's a NUL\0 and some more string";
static const std::string string_with_nul(char_array_with_nul,
sizeof(char_array_with_nul)
- 1); // drops the trailing NUL
static const std::string string_with_nul(
char_array_with_nul,
sizeof(char_array_with_nul) - 1); // drops the trailing NUL
EXPECT_FATAL_FAILURE(FAIL() << string_with_nul,
"Here's a NUL\\0 and some more string");
}
// Tests that we can output a NUL char.
TEST(StreamableTest, NULChar) {
EXPECT_FATAL_FAILURE({ // NOLINT
FAIL() << "A NUL" << '\0' << " and some more string";
}, "A NUL\\0 and some more string");
EXPECT_FATAL_FAILURE(
{ // NOLINT
FAIL() << "A NUL" << '\0' << " and some more string";
},
"A NUL\\0 and some more string");
}
// Tests using int as an assertion message.
TEST(StreamableTest, int) {
EXPECT_FATAL_FAILURE(FAIL() << 900913,
"900913");
}
TEST(StreamableTest, int) { EXPECT_FATAL_FAILURE(FAIL() << 900913, "900913"); }
// Tests using NULL char pointer as an assertion message.
//
......@@ -4716,10 +4641,12 @@ TEST(StreamableTest, NullCharPtr) {
// Tests that basic IO manipulators (endl, ends, and flush) can be
// streamed to testing::Message.
TEST(StreamableTest, BasicIoManip) {
EXPECT_FATAL_FAILURE({ // NOLINT
FAIL() << "Line 1." << std::endl
<< "A NUL char " << std::ends << std::flush << " in line 2.";
}, "Line 1.\nA NUL char \\0 in line 2.");
EXPECT_FATAL_FAILURE(
{ // NOLINT
FAIL() << "Line 1." << std::endl
<< "A NUL char " << std::ends << std::flush << " in line 2.";
},
"Line 1.\nA NUL char \\0 in line 2.");
}
// Tests the macros that haven't been covered so far.
......@@ -4733,8 +4660,7 @@ void AddFailureHelper(bool* aborted) {
// Tests ADD_FAILURE.
TEST(MacroTest, ADD_FAILURE) {
bool aborted = true;
EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted),
"Intentional failure.");
EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted), "Intentional failure.");
EXPECT_FALSE(aborted);
}
......@@ -4755,8 +4681,7 @@ TEST(MacroTest, ADD_FAILURE_AT) {
// Tests FAIL.
TEST(MacroTest, FAIL) {
EXPECT_FATAL_FAILURE(FAIL(),
"Failed");
EXPECT_FATAL_FAILURE(FAIL(), "Failed");
EXPECT_FATAL_FAILURE(FAIL() << "Intentional failure.",
"Intentional failure.");
}
......@@ -4789,37 +4714,34 @@ TEST(MacroTest, SUCCEED) {
// Tests using bool values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest, Bool) {
EXPECT_EQ(true, true);
EXPECT_FATAL_FAILURE({
bool false_value = false;
ASSERT_EQ(false_value, true);
}, " false_value\n Which is: false\n true");
EXPECT_EQ(true, true);
EXPECT_FATAL_FAILURE(
{
bool false_value = false;
ASSERT_EQ(false_value, true);
},
" false_value\n Which is: false\n true");
}
// Tests using int values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest, Int) {
ASSERT_EQ(32, 32);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33),
" 32\n 33");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33), " 32\n 33");
}
// Tests using time_t values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest, Time_T) {
EXPECT_EQ(static_cast<time_t>(0),
static_cast<time_t>(0));
EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<time_t>(0),
static_cast<time_t>(1234)),
"1234");
EXPECT_EQ(static_cast<time_t>(0), static_cast<time_t>(0));
EXPECT_FATAL_FAILURE(
ASSERT_EQ(static_cast<time_t>(0), static_cast<time_t>(1234)), "1234");
}
// Tests using char values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest, Char) {
ASSERT_EQ('z', 'z');
const char ch = 'b';
EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch),
" ch\n Which is: 'b'");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch),
" ch\n Which is: 'b'");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch), " ch\n Which is: 'b'");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch), " ch\n Which is: 'b'");
}
// Tests using wchar_t values in {EXPECT|ASSERT}_EQ.
......@@ -4835,8 +4757,7 @@ TEST(EqAssertionTest, WideChar) {
static wchar_t wchar;
wchar = L'b';
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar),
"wchar");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar), "wchar");
wchar = 0x8119;
EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar),
" wchar\n Which is: L'");
......@@ -4855,13 +4776,11 @@ TEST(EqAssertionTest, StdString) {
// Compares a const char* to an std::string that has different
// content
EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")),
"\"test\"");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")), "\"test\"");
// Compares an std::string to a char* that has different content.
char* const p1 = const_cast<char*>("foo");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1),
"p1");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1), "p1");
// Compares two std::strings that have different contents, one of
// which having a NUL character in the middle. This should fail.
......@@ -4882,28 +4801,31 @@ TEST(EqAssertionTest, StdWideString) {
// Compares an std::wstring to a const wchar_t* that has identical
// content.
const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' };
const wchar_t kTestX8119[] = {'T', 'e', 's', 't', 0x8119, '\0'};
EXPECT_EQ(::std::wstring(kTestX8119), kTestX8119);
// Compares an std::wstring to a const wchar_t* that has different
// content.
const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' };
EXPECT_NONFATAL_FAILURE({ // NOLINT
EXPECT_EQ(::std::wstring(kTestX8119), kTestX8120);
}, "kTestX8120");
const wchar_t kTestX8120[] = {'T', 'e', 's', 't', 0x8120, '\0'};
EXPECT_NONFATAL_FAILURE(
{ // NOLINT
EXPECT_EQ(::std::wstring(kTestX8119), kTestX8120);
},
"kTestX8120");
// Compares two std::wstrings that have different contents, one of
// which having a NUL character in the middle.
::std::wstring wstr3(wstr1);
wstr3.at(2) = L'\0';
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3),
"wstr3");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3), "wstr3");
// Compares a wchar_t* to an std::wstring that has different
// content.
EXPECT_FATAL_FAILURE({ // NOLINT
ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar"));
}, "");
EXPECT_FATAL_FAILURE(
{ // NOLINT
ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar"));
},
"");
}
#endif // GTEST_HAS_STD_WSTRING
......@@ -4921,10 +4843,8 @@ TEST(EqAssertionTest, CharPointer) {
char* const p2 = reinterpret_cast<char*>(pv2);
ASSERT_EQ(p1, p1);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
" p2\n Which is:");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
" p2\n Which is:");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), " p2\n Which is:");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), " p2\n Which is:");
EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234),
reinterpret_cast<char*>(0xABC0)),
"ABC0");
......@@ -4943,16 +4863,13 @@ TEST(EqAssertionTest, WideCharPointer) {
wchar_t* const p2 = reinterpret_cast<wchar_t*>(pv2);
EXPECT_EQ(p0, p0);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
" p2\n Which is:");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
" p2\n Which is:");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), " p2\n Which is:");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), " p2\n Which is:");
void* pv3 = (void*)0x1234; // NOLINT
void* pv4 = (void*)0xABC0; // NOLINT
const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3);
const wchar_t* p4 = reinterpret_cast<const wchar_t*>(pv4);
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4),
"p4");
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4), "p4");
}
// Tests using other types of pointers in {EXPECT|ASSERT}_EQ.
......@@ -4974,15 +4891,11 @@ class UnprintableChar {
bool operator!=(const UnprintableChar& rhs) const {
return char_ != rhs.char_;
}
bool operator<(const UnprintableChar& rhs) const {
return char_ < rhs.char_;
}
bool operator<(const UnprintableChar& rhs) const { return char_ < rhs.char_; }
bool operator<=(const UnprintableChar& rhs) const {
return char_ <= rhs.char_;
}
bool operator>(const UnprintableChar& rhs) const {
return char_ > rhs.char_;
}
bool operator>(const UnprintableChar& rhs) const { return char_ > rhs.char_; }
bool operator>=(const UnprintableChar& rhs) const {
return char_ >= rhs.char_;
}
......@@ -5044,9 +4957,7 @@ class Foo {
// Tests that the FRIEND_TEST declaration allows a TEST to access a
// class's private members. This should compile.
TEST(FRIEND_TEST_Test, TEST) {
ASSERT_EQ(1, Foo().Bar());
}
TEST(FRIEND_TEST_Test, TEST) { ASSERT_EQ(1, Foo().Bar()); }
// The fixture needed to test using FRIEND_TEST with TEST_F.
class FRIEND_TEST_Test2 : public Test {
......@@ -5056,9 +4967,7 @@ class FRIEND_TEST_Test2 : public Test {
// Tests that the FRIEND_TEST declaration allows a TEST_F to access a
// class's private members. This should compile.
TEST_F(FRIEND_TEST_Test2, TEST_F) {
ASSERT_EQ(1, foo.Bar());
}
TEST_F(FRIEND_TEST_Test2, TEST_F) { ASSERT_EQ(1, foo.Bar()); }
// Tests the life cycle of Test objects.
......@@ -5193,15 +5102,14 @@ class Base {
public:
explicit Base(int an_x) : x_(an_x) {}
int x() const { return x_; }
private:
int x_;
};
std::ostream& operator<<(std::ostream& os,
const Base& val) {
std::ostream& operator<<(std::ostream& os, const Base& val) {
return os << val.x();
}
std::ostream& operator<<(std::ostream& os,
const Base* pointer) {
std::ostream& operator<<(std::ostream& os, const Base* pointer) {
return os << "(" << pointer->x() << ")";
}
......@@ -5218,7 +5126,7 @@ TEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) {
namespace {
class MyTypeInUnnamedNameSpace : public Base {
public:
explicit MyTypeInUnnamedNameSpace(int an_x): Base(an_x) {}
explicit MyTypeInUnnamedNameSpace(int an_x) : Base(an_x) {}
};
std::ostream& operator<<(std::ostream& os,
const MyTypeInUnnamedNameSpace& val) {
......@@ -5243,14 +5151,12 @@ TEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) {
namespace namespace1 {
class MyTypeInNameSpace1 : public Base {
public:
explicit MyTypeInNameSpace1(int an_x): Base(an_x) {}
explicit MyTypeInNameSpace1(int an_x) : Base(an_x) {}
};
std::ostream& operator<<(std::ostream& os,
const MyTypeInNameSpace1& val) {
std::ostream& operator<<(std::ostream& os, const MyTypeInNameSpace1& val) {
return os << val.x();
}
std::ostream& operator<<(std::ostream& os,
const MyTypeInNameSpace1* pointer) {
std::ostream& operator<<(std::ostream& os, const MyTypeInNameSpace1* pointer) {
return os << "(" << pointer->x() << ")";
}
} // namespace namespace1
......@@ -5268,7 +5174,7 @@ TEST(MessageTest, CanStreamUserTypeInUserNameSpace) {
namespace namespace2 {
class MyTypeInNameSpace2 : public ::Base {
public:
explicit MyTypeInNameSpace2(int an_x): Base(an_x) {}
explicit MyTypeInNameSpace2(int an_x) : Base(an_x) {}
};
} // namespace namespace2
std::ostream& operator<<(std::ostream& os,
......@@ -5299,21 +5205,18 @@ TEST(MessageTest, NullPointers) {
Message* p6 = nullptr;
msg << p1 << p2 << p3 << p4 << p5 << p6;
ASSERT_STREQ("(null)(null)(null)(null)(null)(null)",
msg.GetString().c_str());
ASSERT_STREQ("(null)(null)(null)(null)(null)(null)", msg.GetString().c_str());
}
// Tests streaming wide strings to testing::Message.
TEST(MessageTest, WideStrings) {
// Streams a NULL of type const wchar_t*.
const wchar_t* const_wstr = nullptr;
EXPECT_STREQ("(null)",
(Message() << const_wstr).GetString().c_str());
EXPECT_STREQ("(null)", (Message() << const_wstr).GetString().c_str());
// Streams a NULL of type wchar_t*.
wchar_t* wstr = nullptr;
EXPECT_STREQ("(null)",
(Message() << wstr).GetString().c_str());
EXPECT_STREQ("(null)", (Message() << wstr).GetString().c_str());
// Streams a non-NULL of type const wchar_t*.
const_wstr = L"abc\x8119";
......@@ -5322,11 +5225,9 @@ TEST(MessageTest, WideStrings) {
// Streams a non-NULL of type wchar_t*.
wstr = const_cast<wchar_t*>(const_wstr);
EXPECT_STREQ("abc\xe8\x84\x99",
(Message() << wstr).GetString().c_str());
EXPECT_STREQ("abc\xe8\x84\x99", (Message() << wstr).GetString().c_str());
}
// This line tests that we can define tests in the testing namespace.
namespace testing {
......@@ -5340,14 +5241,12 @@ class TestInfoTest : public Test {
for (int i = 0; i < test_suite->total_test_count(); ++i) {
const TestInfo* const test_info = test_suite->GetTestInfo(i);
if (strcmp(test_name, test_info->name()) == 0)
return test_info;
if (strcmp(test_name, test_info->name()) == 0) return test_info;
}
return nullptr;
}
static const TestResult* GetTestResult(
const TestInfo* test_info) {
static const TestResult* GetTestResult(const TestInfo* test_info) {
return test_info->result();
}
};
......@@ -5371,26 +5270,25 @@ TEST_F(TestInfoTest, result) {
ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
}
#define VERIFY_CODE_LOCATION \
const int expected_line = __LINE__ - 1; \
#define VERIFY_CODE_LOCATION \
const int expected_line = __LINE__ - 1; \
const TestInfo* const test_info = GetUnitTestImpl()->current_test_info(); \
ASSERT_TRUE(test_info); \
EXPECT_STREQ(__FILE__, test_info->file()); \
ASSERT_TRUE(test_info); \
EXPECT_STREQ(__FILE__, test_info->file()); \
EXPECT_EQ(expected_line, test_info->line())
// clang-format off
TEST(CodeLocationForTEST, Verify) {
VERIFY_CODE_LOCATION;
}
class CodeLocationForTESTF : public Test {
};
class CodeLocationForTESTF : public Test {};
TEST_F(CodeLocationForTESTF, Verify) {
VERIFY_CODE_LOCATION;
}
class CodeLocationForTESTP : public TestWithParam<int> {
};
class CodeLocationForTESTP : public TestWithParam<int> {};
TEST_P(CodeLocationForTESTP, Verify) {
VERIFY_CODE_LOCATION;
......@@ -5399,8 +5297,7 @@ TEST_P(CodeLocationForTESTP, Verify) {
INSTANTIATE_TEST_SUITE_P(, CodeLocationForTESTP, Values(0));
template <typename T>
class CodeLocationForTYPEDTEST : public Test {
};
class CodeLocationForTYPEDTEST : public Test {};
TYPED_TEST_SUITE(CodeLocationForTYPEDTEST, int);
......@@ -5409,8 +5306,7 @@ TYPED_TEST(CodeLocationForTYPEDTEST, Verify) {
}
template <typename T>
class CodeLocationForTYPEDTESTP : public Test {
};
class CodeLocationForTYPEDTESTP : public Test {};
TYPED_TEST_SUITE_P(CodeLocationForTYPEDTESTP);
......@@ -5423,6 +5319,7 @@ REGISTER_TYPED_TEST_SUITE_P(CodeLocationForTYPEDTESTP, Verify);
INSTANTIATE_TYPED_TEST_SUITE_P(My, CodeLocationForTYPEDTESTP, int);
#undef VERIFY_CODE_LOCATION
// clang-format on
// Tests setting up and tearing down a test case.
// Legacy API is deprecated but still available
......@@ -5482,9 +5379,7 @@ const char* SetUpTestCaseTest::shared_resource_ = nullptr;
TEST_F(SetUpTestCaseTest, Test1) { EXPECT_STRNE(nullptr, shared_resource_); }
// Another test that uses the shared resource.
TEST_F(SetUpTestCaseTest, Test2) {
EXPECT_STREQ("123", shared_resource_);
}
TEST_F(SetUpTestCaseTest, Test2) { EXPECT_STREQ("123", shared_resource_); }
#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
// Tests SetupTestSuite/TearDown TestSuite
......@@ -5797,22 +5692,22 @@ class ParseFlagsTest : public Test {
// verifies that the flag values are expected and that the
// recognized flags are removed from the command line.
template <typename CharType>
static void TestParsingFlags(int argc1, const CharType** argv1,
int argc2, const CharType** argv2,
const Flags& expected, bool should_print_help) {
static void TestParsingFlags(int argc1, const CharType** argv1, int argc2,
const CharType** argv2, const Flags& expected,
bool should_print_help) {
const bool saved_help_flag = ::testing::internal::g_help_flag;
::testing::internal::g_help_flag = false;
# if GTEST_HAS_STREAM_REDIRECTION
#if GTEST_HAS_STREAM_REDIRECTION
CaptureStdout();
# endif
#endif
// Parses the command line.
internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1));
# if GTEST_HAS_STREAM_REDIRECTION
#if GTEST_HAS_STREAM_REDIRECTION
const std::string captured_stdout = GetCapturedStdout();
# endif
#endif
// Verifies the flag values.
CheckFlags(expected);
......@@ -5825,16 +5720,16 @@ class ParseFlagsTest : public Test {
// help message for the flags it recognizes.
EXPECT_EQ(should_print_help, ::testing::internal::g_help_flag);
# if GTEST_HAS_STREAM_REDIRECTION
#if GTEST_HAS_STREAM_REDIRECTION
const char* const expected_help_fragment =
"This program contains tests written using";
if (should_print_help) {
EXPECT_PRED_FORMAT2(IsSubstring, expected_help_fragment, captured_stdout);
} else {
EXPECT_PRED_FORMAT2(IsNotSubstring,
expected_help_fragment, captured_stdout);
EXPECT_PRED_FORMAT2(IsNotSubstring, expected_help_fragment,
captured_stdout);
}
# endif // GTEST_HAS_STREAM_REDIRECTION
#endif // GTEST_HAS_STREAM_REDIRECTION
::testing::internal::g_help_flag = saved_help_flag;
}
......@@ -5842,10 +5737,10 @@ class ParseFlagsTest : public Test {
// This macro wraps TestParsingFlags s.t. the user doesn't need
// to specify the array sizes.
# define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \
TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \
sizeof(argv2)/sizeof(*argv2) - 1, argv2, \
expected, should_print_help)
#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \
TestParsingFlags(sizeof(argv1) / sizeof(*argv1) - 1, argv1, \
sizeof(argv2) / sizeof(*argv2) - 1, argv2, expected, \
should_print_help)
};
// Tests parsing an empty command line.
......@@ -6070,8 +5965,8 @@ TEST_F(ParseFlagsTest, OutputXmlDirectory) {
const char* argv2[] = {"foo.exe", nullptr};
GTEST_TEST_PARSING_FLAGS_(argv, argv2,
Flags::Output("xml:directory/path/"), false);
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:directory/path/"),
false);
}
// Tests having a --gtest_brief flag
......@@ -6252,8 +6147,8 @@ TEST_F(ParseFlagsTest, StreamResultTo) {
const char* argv2[] = {"foo.exe", nullptr};
GTEST_TEST_PARSING_FLAGS_(
argv, argv2, Flags::StreamResultTo("localhost:1234"), false);
GTEST_TEST_PARSING_FLAGS_(argv, argv2,
Flags::StreamResultTo("localhost:1234"), false);
}
// Tests parsing --gtest_throw_on_failure.
......@@ -6284,23 +6179,17 @@ TEST_F(ParseFlagsTest, ThrowOnFailureTrue) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
}
# if GTEST_OS_WINDOWS
#if GTEST_OS_WINDOWS
// Tests parsing wide strings.
TEST_F(ParseFlagsTest, WideStrings) {
const wchar_t* argv[] = {
L"foo.exe",
L"--gtest_filter=Foo*",
L"--gtest_list_tests=1",
L"--gtest_break_on_failure",
L"--non_gtest_flag",
NULL
};
const wchar_t* argv[] = {L"foo.exe",
L"--gtest_filter=Foo*",
L"--gtest_list_tests=1",
L"--gtest_break_on_failure",
L"--non_gtest_flag",
NULL};
const wchar_t* argv2[] = {
L"foo.exe",
L"--non_gtest_flag",
NULL
};
const wchar_t* argv2[] = {L"foo.exe", L"--non_gtest_flag", NULL};
Flags expected_flags;
expected_flags.break_on_failure = true;
......@@ -6309,7 +6198,7 @@ TEST_F(ParseFlagsTest, WideStrings) {
GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags, false);
}
# endif // GTEST_OS_WINDOWS
#endif // GTEST_OS_WINDOWS
#if GTEST_USE_OWN_FLAGFILE_FLAG_
class FlagfileTest : public ParseFlagsTest {
......@@ -6357,8 +6246,8 @@ TEST_F(FlagfileTest, Empty) {
// Tests passing a non-empty --gtest_filter flag via --gtest_flagfile.
TEST_F(FlagfileTest, FilterNonEmpty) {
internal::FilePath flagfile_path(CreateFlagfile(
"--" GTEST_FLAG_PREFIX_ "filter=abc"));
internal::FilePath flagfile_path(
CreateFlagfile("--" GTEST_FLAG_PREFIX_ "filter=abc"));
std::string flagfile_flag =
std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str();
......@@ -6371,10 +6260,10 @@ TEST_F(FlagfileTest, FilterNonEmpty) {
// Tests passing several flags via --gtest_flagfile.
TEST_F(FlagfileTest, SeveralFlags) {
internal::FilePath flagfile_path(CreateFlagfile(
"--" GTEST_FLAG_PREFIX_ "filter=abc\n"
"--" GTEST_FLAG_PREFIX_ "break_on_failure\n"
"--" GTEST_FLAG_PREFIX_ "list_tests"));
internal::FilePath flagfile_path(
CreateFlagfile("--" GTEST_FLAG_PREFIX_ "filter=abc\n"
"--" GTEST_FLAG_PREFIX_ "break_on_failure\n"
"--" GTEST_FLAG_PREFIX_ "list_tests"));
std::string flagfile_flag =
std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str();
......@@ -6398,8 +6287,7 @@ class CurrentTestInfoTest : public Test {
// the test case is run.
static void SetUpTestSuite() {
// There should be no tests running at this point.
const TestInfo* test_info =
UnitTest::GetInstance()->current_test_info();
const TestInfo* test_info = UnitTest::GetInstance()->current_test_info();
EXPECT_TRUE(test_info == nullptr)
<< "There should be no tests running at this point.";
}
......@@ -6407,8 +6295,7 @@ class CurrentTestInfoTest : public Test {
// Tests that current_test_info() returns NULL after the last test in
// the test case has run.
static void TearDownTestSuite() {
const TestInfo* test_info =
UnitTest::GetInstance()->current_test_info();
const TestInfo* test_info = UnitTest::GetInstance()->current_test_info();
EXPECT_TRUE(test_info == nullptr)
<< "There should be no tests running at this point.";
}
......@@ -6417,8 +6304,7 @@ class CurrentTestInfoTest : public Test {
// Tests that current_test_info() returns TestInfo for currently running
// test by checking the expected test name against the actual one.
TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestSuite) {
const TestInfo* test_info =
UnitTest::GetInstance()->current_test_info();
const TestInfo* test_info = UnitTest::GetInstance()->current_test_info();
ASSERT_TRUE(nullptr != test_info)
<< "There is a test running so we should have a valid TestInfo.";
EXPECT_STREQ("CurrentTestInfoTest", test_info->test_suite_name())
......@@ -6432,8 +6318,7 @@ TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestSuite) {
// use this test to see that the TestInfo object actually changed from
// the previous invocation.
TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestSuite) {
const TestInfo* test_info =
UnitTest::GetInstance()->current_test_info();
const TestInfo* test_info = UnitTest::GetInstance()->current_test_info();
ASSERT_TRUE(nullptr != test_info)
<< "There is a test running so we should have a valid TestInfo.";
EXPECT_STREQ("CurrentTestInfoTest", test_info->test_suite_name())
......@@ -6444,7 +6329,6 @@ TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestSuite) {
} // namespace testing
// These two lines test that we can define tests in a namespace that
// has the name "testing" and is nested in another namespace.
namespace my_namespace {
......@@ -6493,13 +6377,12 @@ TEST(StreamingAssertionsTest, Unconditional) {
SUCCEED() << "expected success";
EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure",
"expected failure");
EXPECT_FATAL_FAILURE(FAIL() << "expected failure",
"expected failure");
EXPECT_FATAL_FAILURE(FAIL() << "expected failure", "expected failure");
}
#ifdef __BORLANDC__
// Silences warnings: "Condition is always true", "Unreachable code"
# pragma option push -w-ccc -w-rch
#pragma option push -w-ccc -w-rch
#endif
TEST(StreamingAssertionsTest, Truth) {
......@@ -6522,7 +6405,7 @@ TEST(StreamingAssertionsTest, Truth2) {
#ifdef __BORLANDC__
// Restores warnings after previous "#pragma option push" suppressed them
# pragma option pop
#pragma option pop
#endif
TEST(StreamingAssertionsTest, IntegerEquals) {
......@@ -6593,28 +6476,32 @@ TEST(StreamingAssertionsTest, FloatingPointEquals) {
TEST(StreamingAssertionsTest, Throw) {
EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure";
ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure";
EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) <<
"expected failure", "expected failure");
EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) <<
"expected failure", "expected failure");
EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool)
<< "expected failure",
"expected failure");
EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool)
<< "expected failure",
"expected failure");
}
TEST(StreamingAssertionsTest, NoThrow) {
EXPECT_NO_THROW(ThrowNothing()) << "unexpected failure";
ASSERT_NO_THROW(ThrowNothing()) << "unexpected failure";
EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) <<
"expected failure", "expected failure");
EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) <<
"expected failure", "expected failure");
EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger())
<< "expected failure",
"expected failure");
EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) << "expected failure",
"expected failure");
}
TEST(StreamingAssertionsTest, AnyThrow) {
EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()) <<
"expected failure", "expected failure");
EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) <<
"expected failure", "expected failure");
EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing())
<< "expected failure",
"expected failure");
EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) << "expected failure",
"expected failure");
}
#endif // GTEST_HAS_EXCEPTIONS
......@@ -6624,12 +6511,12 @@ TEST(StreamingAssertionsTest, AnyThrow) {
TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) {
GTEST_FLAG_SET(color, "yes");
SetEnv("TERM", "xterm"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "xterm"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY.
SetEnv("TERM", "dumb"); // TERM doesn't support colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "dumb"); // TERM doesn't support colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY.
}
......@@ -6649,12 +6536,12 @@ TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) {
TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) {
GTEST_FLAG_SET(color, "no");
SetEnv("TERM", "xterm"); // TERM supports colors.
EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "xterm"); // TERM supports colors.
EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY.
SetEnv("TERM", "dumb"); // TERM doesn't support colors.
EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "dumb"); // TERM doesn't support colors.
EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY.
}
......@@ -6674,7 +6561,7 @@ TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) {
TEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) {
GTEST_FLAG_SET(color, "auto");
SetEnv("TERM", "xterm"); // TERM supports colors.
SetEnv("TERM", "xterm"); // TERM supports colors.
EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
}
......@@ -6697,49 +6584,49 @@ TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) {
// On non-Windows platforms, we rely on TERM to determine if the
// terminal supports colors.
SetEnv("TERM", "dumb"); // TERM doesn't support colors.
SetEnv("TERM", "dumb"); // TERM doesn't support colors.
EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "emacs"); // TERM doesn't support colors.
SetEnv("TERM", "emacs"); // TERM doesn't support colors.
EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "vt100"); // TERM doesn't support colors.
SetEnv("TERM", "vt100"); // TERM doesn't support colors.
EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "xterm-mono"); // TERM doesn't support colors.
SetEnv("TERM", "xterm-mono"); // TERM doesn't support colors.
EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "xterm"); // TERM supports colors.
SetEnv("TERM", "xterm"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "xterm-color"); // TERM supports colors.
SetEnv("TERM", "xterm-color"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "xterm-256color"); // TERM supports colors.
SetEnv("TERM", "xterm-256color"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "screen"); // TERM supports colors.
SetEnv("TERM", "screen"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "screen-256color"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "tmux"); // TERM supports colors.
SetEnv("TERM", "tmux"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "tmux-256color"); // TERM supports colors.
SetEnv("TERM", "tmux-256color"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "rxvt-unicode"); // TERM supports colors.
SetEnv("TERM", "rxvt-unicode"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "rxvt-unicode-256color"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "linux"); // TERM supports colors.
SetEnv("TERM", "linux"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
SetEnv("TERM", "cygwin"); // TERM supports colors.
SetEnv("TERM", "cygwin"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
#endif // GTEST_OS_WINDOWS
}
......@@ -6859,12 +6746,10 @@ class TestListener : public EmptyTestEventListener {
public:
TestListener() : on_start_counter_(nullptr), is_destroyed_(nullptr) {}
TestListener(int* on_start_counter, bool* is_destroyed)
: on_start_counter_(on_start_counter),
is_destroyed_(is_destroyed) {}
: on_start_counter_(on_start_counter), is_destroyed_(is_destroyed) {}
~TestListener() override {
if (is_destroyed_)
*is_destroyed_ = true;
if (is_destroyed_) *is_destroyed_ = true;
}
protected:
......@@ -6921,8 +6806,8 @@ TEST(TestEventListenersTest, Append) {
{
TestEventListeners listeners;
listeners.Append(listener);
TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
*UnitTest::GetInstance());
TestEventListenersAccessor::GetRepeater(&listeners)
->OnTestProgramStart(*UnitTest::GetInstance());
EXPECT_EQ(1, on_start_counter);
}
EXPECT_TRUE(is_destroyed);
......@@ -6975,32 +6860,32 @@ TEST(EventListenerTest, AppendKeepsOrder) {
listeners.Append(new SequenceTestingListener(&vec, "2nd"));
listeners.Append(new SequenceTestingListener(&vec, "3rd"));
TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
*UnitTest::GetInstance());
TestEventListenersAccessor::GetRepeater(&listeners)
->OnTestProgramStart(*UnitTest::GetInstance());
ASSERT_EQ(3U, vec.size());
EXPECT_STREQ("1st.OnTestProgramStart", vec[0].c_str());
EXPECT_STREQ("2nd.OnTestProgramStart", vec[1].c_str());
EXPECT_STREQ("3rd.OnTestProgramStart", vec[2].c_str());
vec.clear();
TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramEnd(
*UnitTest::GetInstance());
TestEventListenersAccessor::GetRepeater(&listeners)
->OnTestProgramEnd(*UnitTest::GetInstance());
ASSERT_EQ(3U, vec.size());
EXPECT_STREQ("3rd.OnTestProgramEnd", vec[0].c_str());
EXPECT_STREQ("2nd.OnTestProgramEnd", vec[1].c_str());
EXPECT_STREQ("1st.OnTestProgramEnd", vec[2].c_str());
vec.clear();
TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationStart(
*UnitTest::GetInstance(), 0);
TestEventListenersAccessor::GetRepeater(&listeners)
->OnTestIterationStart(*UnitTest::GetInstance(), 0);
ASSERT_EQ(3U, vec.size());
EXPECT_STREQ("1st.OnTestIterationStart", vec[0].c_str());
EXPECT_STREQ("2nd.OnTestIterationStart", vec[1].c_str());
EXPECT_STREQ("3rd.OnTestIterationStart", vec[2].c_str());
vec.clear();
TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationEnd(
*UnitTest::GetInstance(), 0);
TestEventListenersAccessor::GetRepeater(&listeners)
->OnTestIterationEnd(*UnitTest::GetInstance(), 0);
ASSERT_EQ(3U, vec.size());
EXPECT_STREQ("3rd.OnTestIterationEnd", vec[0].c_str());
EXPECT_STREQ("2nd.OnTestIterationEnd", vec[1].c_str());
......@@ -7020,8 +6905,8 @@ TEST(TestEventListenersTest, Release) {
TestEventListeners listeners;
listeners.Append(listener);
EXPECT_EQ(listener, listeners.Release(listener));
TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
*UnitTest::GetInstance());
TestEventListenersAccessor::GetRepeater(&listeners)
->OnTestProgramStart(*UnitTest::GetInstance());
EXPECT_TRUE(listeners.Release(listener) == nullptr);
}
EXPECT_EQ(0, on_start_counter);
......@@ -7039,17 +6924,20 @@ TEST(EventListenerTest, SuppressEventForwarding) {
ASSERT_TRUE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
TestEventListenersAccessor::SuppressEventForwarding(&listeners);
ASSERT_FALSE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
*UnitTest::GetInstance());
TestEventListenersAccessor::GetRepeater(&listeners)
->OnTestProgramStart(*UnitTest::GetInstance());
EXPECT_EQ(0, on_start_counter);
}
// Tests that events generated by Google Test are not forwarded in
// death test subprocesses.
TEST(EventListenerDeathTest, EventsNotForwardedInDeathTestSubprecesses) {
EXPECT_DEATH_IF_SUPPORTED({
GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled(
*GetUnitTestImpl()->listeners())) << "expected failure";},
EXPECT_DEATH_IF_SUPPORTED(
{
GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled(
*GetUnitTestImpl()->listeners()))
<< "expected failure";
},
"expected failure");
}
......@@ -7066,8 +6954,8 @@ TEST(EventListenerTest, default_result_printer) {
EXPECT_EQ(listener, listeners.default_result_printer());
TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
*UnitTest::GetInstance());
TestEventListenersAccessor::GetRepeater(&listeners)
->OnTestProgramStart(*UnitTest::GetInstance());
EXPECT_EQ(1, on_start_counter);
......@@ -7080,8 +6968,8 @@ TEST(EventListenerTest, default_result_printer) {
// After broadcasting an event the counter is still the same, indicating
// the listener is not in the list anymore.
TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
*UnitTest::GetInstance());
TestEventListenersAccessor::GetRepeater(&listeners)
->OnTestProgramStart(*UnitTest::GetInstance());
EXPECT_EQ(1, on_start_counter);
}
......@@ -7103,8 +6991,8 @@ TEST(EventListenerTest, RemovingDefaultResultPrinterWorks) {
EXPECT_FALSE(is_destroyed);
// Broadcasting events now should not affect default_result_printer.
TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
*UnitTest::GetInstance());
TestEventListenersAccessor::GetRepeater(&listeners)
->OnTestProgramStart(*UnitTest::GetInstance());
EXPECT_EQ(0, on_start_counter);
}
// Destroying the list should not affect the listener now, too.
......@@ -7125,8 +7013,8 @@ TEST(EventListenerTest, default_xml_generator) {
EXPECT_EQ(listener, listeners.default_xml_generator());
TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
*UnitTest::GetInstance());
TestEventListenersAccessor::GetRepeater(&listeners)
->OnTestProgramStart(*UnitTest::GetInstance());
EXPECT_EQ(1, on_start_counter);
......@@ -7139,8 +7027,8 @@ TEST(EventListenerTest, default_xml_generator) {
// After broadcasting an event the counter is still the same, indicating
// the listener is not in the list anymore.
TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
*UnitTest::GetInstance());
TestEventListenersAccessor::GetRepeater(&listeners)
->OnTestProgramStart(*UnitTest::GetInstance());
EXPECT_EQ(1, on_start_counter);
}
......@@ -7162,8 +7050,8 @@ TEST(EventListenerTest, RemovingDefaultXmlGeneratorWorks) {
EXPECT_FALSE(is_destroyed);
// Broadcasting events now should not affect default_xml_generator.
TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
*UnitTest::GetInstance());
TestEventListenersAccessor::GetRepeater(&listeners)
->OnTestProgramStart(*UnitTest::GetInstance());
EXPECT_EQ(0, on_start_counter);
}
// Destroying the list should not affect the listener now, too.
......@@ -7323,7 +7211,6 @@ TEST(GTestReferenceToConstTest, Works) {
TestGTestReferenceToConst<const std::string&, const std::string&>();
}
// Tests IsContainerTest.
class NonContainer {};
......@@ -7335,10 +7222,9 @@ TEST(IsContainerTestTest, WorksForNonContainer) {
}
TEST(IsContainerTestTest, WorksForContainer) {
EXPECT_EQ(sizeof(IsContainer), sizeof(IsContainerTest<std::vector<bool>>(0)));
EXPECT_EQ(sizeof(IsContainer),
sizeof(IsContainerTest<std::vector<bool> >(0)));
EXPECT_EQ(sizeof(IsContainer),
sizeof(IsContainerTest<std::map<int, double> >(0)));
sizeof(IsContainerTest<std::map<int, double>>(0)));
}
struct ConstOnlyContainerWithPointerIterator {
......@@ -7387,8 +7273,8 @@ TEST(ArrayEqTest, WorksForDegeneratedArrays) {
TEST(ArrayEqTest, WorksForOneDimensionalArrays) {
// Note that a and b are distinct but compatible types.
const int a[] = { 0, 1 };
long b[] = { 0, 1 };
const int a[] = {0, 1};
long b[] = {0, 1};
EXPECT_TRUE(ArrayEq(a, b));
EXPECT_TRUE(ArrayEq(a, 2, b));
......@@ -7398,9 +7284,9 @@ TEST(ArrayEqTest, WorksForOneDimensionalArrays) {
}
TEST(ArrayEqTest, WorksForTwoDimensionalArrays) {
const char a[][3] = { "hi", "lo" };
const char b[][3] = { "hi", "lo" };
const char c[][3] = { "hi", "li" };
const char a[][3] = {"hi", "lo"};
const char b[][3] = {"hi", "lo"};
const char c[][3] = {"hi", "li"};
EXPECT_TRUE(ArrayEq(a, b));
EXPECT_TRUE(ArrayEq(a, 2, b));
......@@ -7418,11 +7304,11 @@ TEST(ArrayAwareFindTest, WorksForOneDimensionalArray) {
}
TEST(ArrayAwareFindTest, WorksForTwoDimensionalArray) {
int a[][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } };
const int b[2] = { 2, 3 };
int a[][2] = {{0, 1}, {2, 3}, {4, 5}};
const int b[2] = {2, 3};
EXPECT_EQ(a + 1, ArrayAwareFind(a, a + 3, b));
const int c[2] = { 6, 7 };
const int c[2] = {6, 7};
EXPECT_EQ(a + 3, ArrayAwareFind(a, a + 3, c));
}
......@@ -7448,7 +7334,7 @@ TEST(CopyArrayTest, WorksForOneDimensionalArrays) {
}
TEST(CopyArrayTest, WorksForTwoDimensionalArrays) {
const int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } };
const int a[2][3] = {{0, 1, 2}, {3, 4, 5}};
int b[2][3];
#ifndef __BORLANDC__ // C++Builder cannot compile some array size deductions.
CopyArray(a, &b);
......@@ -7463,7 +7349,7 @@ TEST(CopyArrayTest, WorksForTwoDimensionalArrays) {
// Tests NativeArray.
TEST(NativeArrayTest, ConstructorFromArrayWorks) {
const int a[3] = { 0, 1, 2 };
const int a[3] = {0, 1, 2};
NativeArray<int> na(a, 3, RelationToSourceReference());
EXPECT_EQ(3U, na.size());
EXPECT_EQ(a, na.begin());
......@@ -7493,7 +7379,7 @@ TEST(NativeArrayTest, TypeMembersAreCorrect) {
}
TEST(NativeArrayTest, MethodsWork) {
const int a[3] = { 0, 1, 2 };
const int a[3] = {0, 1, 2};
NativeArray<int> na(a, 3, RelationToSourceCopy());
ASSERT_EQ(3U, na.size());
EXPECT_EQ(3, na.end() - na.begin());
......@@ -7512,14 +7398,14 @@ TEST(NativeArrayTest, MethodsWork) {
NativeArray<int> na2(a, 3, RelationToSourceReference());
EXPECT_TRUE(na == na2);
const int b1[3] = { 0, 1, 1 };
const int b2[4] = { 0, 1, 2, 3 };
const int b1[3] = {0, 1, 1};
const int b2[4] = {0, 1, 2, 3};
EXPECT_FALSE(na == NativeArray<int>(b1, 3, RelationToSourceReference()));
EXPECT_FALSE(na == NativeArray<int>(b2, 4, RelationToSourceCopy()));
}
TEST(NativeArrayTest, WorksForTwoDimensionalArray) {
const char a[2][3] = { "hi", "lo" };
const char a[2][3] = {"hi", "lo"};
NativeArray<char[3]> na(a, 2, RelationToSourceReference());
ASSERT_EQ(2U, na.size());
EXPECT_EQ(a, na.begin());
......
googletest/test/gtest_xml_output_unittest_.cc
View file @ b007c54f
......@@ -35,18 +35,18 @@
//
// This program will be invoked from a Python unit test. Don't run it
// directly.
// clang-format off
#include "gtest/gtest.h"
using ::testing::InitGoogleTest;
using ::testing::Test;
using ::testing::TestEventListeners;
using ::testing::TestWithParam;
using ::testing::UnitTest;
using ::testing::Test;
using ::testing::Values;
class SuccessfulTest : public Test {
};
class SuccessfulTest : public Test {};
TEST_F(SuccessfulTest, Succeeds) {
SUCCEED() << "This is a success.";
......@@ -191,3 +191,5 @@ int main(int argc, char** argv) {
testing::Test::RecordProperty("ad_hoc_property", "42");
return RUN_ALL_TESTS();
}
// clang-format on
googletest/test/production.h
View file @ b007c54f
......@@ -46,6 +46,7 @@ class PrivateCode {
PrivateCode();
int x() const { return x_; }
private:
void set_x(int an_x) { x_ = an_x; }
int x_;
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment