"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "googletest/test/googletest-port-test.cc" between
googletest-release-1.10.0.tar.gz and googletest-release-1.11.0.tar.gz

About: GoogleTest is Google's (unit) testing and mocking framework for C++ tests.

googletest-port-test.cc  (googletest-release-1.10.0):googletest-port-test.cc  (googletest-release-1.11.0)
skipping to change at line 93 skipping to change at line 93
} }
TEST(IsXDigitTest, ReturnsFalseForWideNonAscii) { TEST(IsXDigitTest, ReturnsFalseForWideNonAscii) {
EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(0x80))); EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(0x80)));
EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x80))); EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x80)));
EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x100))); EXPECT_FALSE(IsXDigit(static_cast<wchar_t>(L'0' | 0x100)));
} }
class Base { class Base {
public: public:
// Copy constructor and assignment operator do exactly what we need, so we
// use them.
Base() : member_(0) {} Base() : member_(0) {}
explicit Base(int n) : member_(n) {} explicit Base(int n) : member_(n) {}
Base(const Base&) = default;
Base& operator=(const Base&) = default;
virtual ~Base() {} virtual ~Base() {}
int member() { return member_; } int member() { return member_; }
private: private:
int member_; int member_;
}; };
class Derived : public Base { class Derived : public Base {
public: public:
explicit Derived(int n) : Base(n) {} explicit Derived(int n) : Base(n) {}
skipping to change at line 204 skipping to change at line 204
To(bool* converted) { *converted = true; } // NOLINT To(bool* converted) { *converted = true; } // NOLINT
}; };
TEST(ImplicitCastTest, CanUseImplicitConstructor) { TEST(ImplicitCastTest, CanUseImplicitConstructor) {
bool converted = false; bool converted = false;
To to = ::testing::internal::ImplicitCast_<To>(&converted); To to = ::testing::internal::ImplicitCast_<To>(&converted);
(void)to; (void)to;
EXPECT_TRUE(converted); EXPECT_TRUE(converted);
} }
// The following code intentionally tests a suboptimal syntax.
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdangling-else"
#pragma GCC diagnostic ignored "-Wempty-body"
#pragma GCC diagnostic ignored "-Wpragmas"
#endif
TEST(GtestCheckSyntaxTest, BehavesLikeASingleStatement) { TEST(GtestCheckSyntaxTest, BehavesLikeASingleStatement) {
if (AlwaysFalse()) if (AlwaysFalse())
GTEST_CHECK_(false) << "This should never be executed; " GTEST_CHECK_(false) << "This should never be executed; "
"It's a compilation test only."; "It's a compilation test only.";
if (AlwaysTrue()) if (AlwaysTrue())
GTEST_CHECK_(true); GTEST_CHECK_(true);
else else
; // NOLINT ; // NOLINT
if (AlwaysFalse()) if (AlwaysFalse())
; // NOLINT ; // NOLINT
else else
GTEST_CHECK_(true) << ""; GTEST_CHECK_(true) << "";
} }
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
TEST(GtestCheckSyntaxTest, WorksWithSwitch) { TEST(GtestCheckSyntaxTest, WorksWithSwitch) {
switch (0) { switch (0) {
case 1: case 1:
break; break;
default: default:
GTEST_CHECK_(true); GTEST_CHECK_(true);
} }
switch (0) switch (0)
skipping to change at line 366 skipping to change at line 376
# else # else
EXPECT_TRUE(GTEST_USES_SIMPLE_RE); EXPECT_TRUE(GTEST_USES_SIMPLE_RE);
# endif # endif
#endif // !GTEST_USES_PCRE #endif // !GTEST_USES_PCRE
} }
#if GTEST_USES_POSIX_RE #if GTEST_USES_POSIX_RE
# if GTEST_HAS_TYPED_TEST
template <typename Str> template <typename Str>
class RETest : public ::testing::Test {}; class RETest : public ::testing::Test {};
// Defines StringTypes as the list of all string types that class RE // Defines StringTypes as the list of all string types that class RE
// supports. // supports.
typedef testing::Types< ::std::string, const char*> StringTypes; typedef testing::Types< ::std::string, const char*> StringTypes;
TYPED_TEST_SUITE(RETest, StringTypes); TYPED_TEST_SUITE(RETest, StringTypes);
// Tests RE's implicit constructors. // Tests RE's implicit constructors.
skipping to change at line 423 skipping to change at line 431
EXPECT_TRUE(RE::PartialMatch(TypeParam("a"), empty)); EXPECT_TRUE(RE::PartialMatch(TypeParam("a"), empty));
const RE re(TypeParam("a.*z")); const RE re(TypeParam("a.*z"));
EXPECT_TRUE(RE::PartialMatch(TypeParam("az"), re)); EXPECT_TRUE(RE::PartialMatch(TypeParam("az"), re));
EXPECT_TRUE(RE::PartialMatch(TypeParam("axyz"), re)); EXPECT_TRUE(RE::PartialMatch(TypeParam("axyz"), re));
EXPECT_TRUE(RE::PartialMatch(TypeParam("baz"), re)); EXPECT_TRUE(RE::PartialMatch(TypeParam("baz"), re));
EXPECT_TRUE(RE::PartialMatch(TypeParam("azy"), re)); EXPECT_TRUE(RE::PartialMatch(TypeParam("azy"), re));
EXPECT_FALSE(RE::PartialMatch(TypeParam("zza"), re)); EXPECT_FALSE(RE::PartialMatch(TypeParam("zza"), re));
} }
# endif // GTEST_HAS_TYPED_TEST
#elif GTEST_USES_SIMPLE_RE #elif GTEST_USES_SIMPLE_RE
TEST(IsInSetTest, NulCharIsNotInAnySet) { TEST(IsInSetTest, NulCharIsNotInAnySet) {
EXPECT_FALSE(IsInSet('\0', "")); EXPECT_FALSE(IsInSet('\0', ""));
EXPECT_FALSE(IsInSet('\0', "\0")); EXPECT_FALSE(IsInSet('\0', "\0"));
EXPECT_FALSE(IsInSet('\0', "a")); EXPECT_FALSE(IsInSet('\0', "a"));
} }
TEST(IsInSetTest, WorksForNonNulChars) { TEST(IsInSetTest, WorksForNonNulChars) {
EXPECT_FALSE(IsInSet('a', "Ab")); EXPECT_FALSE(IsInSet('a', "Ab"));
skipping to change at line 1183 skipping to change at line 1189
// to protect this access with a mutex. // to protect this access with a mutex.
DestructorCall::List()[index_]->ReportDestroyed(); DestructorCall::List()[index_]->ReportDestroyed();
} }
private: private:
static size_t GetNewIndex() { static size_t GetNewIndex() {
DestructorCall::List().push_back(new DestructorCall); DestructorCall::List().push_back(new DestructorCall);
return DestructorCall::List().size() - 1; return DestructorCall::List().size() - 1;
} }
const size_t index_; const size_t index_;
GTEST_DISALLOW_ASSIGN_(DestructorTracker);
}; };
typedef ThreadLocal<DestructorTracker>* ThreadParam; typedef ThreadLocal<DestructorTracker>* ThreadParam;
void CallThreadLocalGet(ThreadParam thread_local_param) { void CallThreadLocalGet(ThreadParam thread_local_param) {
thread_local_param->get(); thread_local_param->get();
} }
// Tests that when a ThreadLocal object dies in a thread, it destroys // Tests that when a ThreadLocal object dies in a thread, it destroys
// the managed object for that thread. // the managed object for that thread.
 End of changes. 7 change blocks. 
8 lines changed or deleted 12 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)