eson/googletest
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Apply clang-tidy modernize-use-nullptr to googletest.

Browse Source 
Now that googletest has moved to C++11, it should no longer
use NULL or 0 for the null pointer. This patch converts all
such usages to nullptr using clang-tidy.

This prevents LLVM from issuing -Wzero-as-null-pointer-constant
warnings.

PiperOrigin-RevId: 215814400
This commit is contained in:
Abseil Team 2018-10-04 18:28:05 -04:00 committed by Gennadiy Civil
parent f13bbe2992
commit 4bb49ed640
58 changed files with 705 additions and 1107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
googlemock/include/gmock/gmock-actions.h
View File

@ -137,7 +137,7 @@ template <typename T>
class BuiltInDefaultValue<T*> { class BuiltInDefaultValue<T*> {
public: public:
static bool Exists() { return true; } static bool Exists() { return true; }
static T* Get() { return NULL; } static T* Get() { return nullptr; }
}; };
// The following specializations define the default values for // The following specializations define the default values for
@ -220,11 +220,11 @@ class DefaultValue {
// Unsets the default value for type T. // Unsets the default value for type T.
static void Clear() { static void Clear() {
delete producer_; delete producer_;
producer_ = NULL; producer_ = nullptr;
} }
// Returns true iff the user has set the default value for type T. // Returns true iff the user has set the default value for type T.
static bool IsSet() { return producer_ != NULL; } static bool IsSet() { return producer_ != nullptr; }
// Returns true if T has a default return value set by the user or there // Returns true if T has a default return value set by the user or there
// exists a built-in default value. // exists a built-in default value.
@ -236,8 +236,8 @@ class DefaultValue {
// otherwise returns the built-in default value. Requires that Exists() // otherwise returns the built-in default value. Requires that Exists()
// is true, which ensures that the return value is well-defined. // is true, which ensures that the return value is well-defined.
static T Get() { static T Get() {
return producer_ == NULL ? return producer_ == nullptr ? internal::BuiltInDefaultValue<T>::Get()
internal::BuiltInDefaultValue<T>::Get() : producer_->Produce(); : producer_->Produce();
} }
private: private:
@ -282,12 +282,10 @@ class DefaultValue<T&> {
} }
// Unsets the default value for type T&. // Unsets the default value for type T&.
static void Clear() { static void Clear() { address_ = nullptr; }
address_ = NULL;
}
// Returns true iff the user has set the default value for type T&. // Returns true iff the user has set the default value for type T&.
static bool IsSet() { return address_ != NULL; } static bool IsSet() { return address_ != nullptr; }
// Returns true if T has a default return value set by the user or there // Returns true if T has a default return value set by the user or there
// exists a built-in default value. // exists a built-in default value.
@ -299,8 +297,8 @@ class DefaultValue<T&> {
// otherwise returns the built-in default value if there is one; // otherwise returns the built-in default value if there is one;
// otherwise aborts the process. // otherwise aborts the process.
static T& Get() { static T& Get() {
return address_ == NULL ? return address_ == nullptr ? internal::BuiltInDefaultValue<T&>::Get()
internal::BuiltInDefaultValue<T&>::Get() : *address_; : *address_;
} }
private: private:
@ -318,11 +316,11 @@ class DefaultValue<void> {
// Points to the user-set default value for type T. // Points to the user-set default value for type T.
template <typename T> template <typename T>
typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = NULL; typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = nullptr;
// Points to the user-set default value for type T&. // Points to the user-set default value for type T&.
template <typename T> template <typename T>
T* DefaultValue<T&>::address_ = NULL; T* DefaultValue<T&>::address_ = nullptr;
// Implement this interface to define an action for function type F. // Implement this interface to define an action for function type F.
template <typename F> template <typename F>
@ -1108,8 +1106,9 @@ Action<To>::Action(const Action<From>& from)
#if GTEST_LANG_CXX11 #if GTEST_LANG_CXX11
fun_(from.fun_), fun_(from.fun_),
#endif #endif
impl_(from.impl_ == NULL ? NULL impl_(from.impl_ == nullptr
: new internal::ActionAdaptor<To, From>(from)) { ? nullptr
: new internal::ActionAdaptor<To, From>(from)) {
} }
// Creates an action that returns 'value'. 'value' is passed by value // Creates an action that returns 'value'. 'value' is passed by value

48
googlemock/include/gmock/gmock-matchers.h
View File

@ -94,8 +94,7 @@ class MatchResultListener {
// is NULL. // is NULL.
template <typename T> template <typename T>
MatchResultListener& operator<<(const T& x) { MatchResultListener& operator<<(const T& x) {
if (stream_ != NULL) if (stream_ != nullptr) *stream_ << x;
*stream_ << x;
return *this; return *this;
} }
@ -106,7 +105,7 @@ class MatchResultListener {
// the match result. A matcher's MatchAndExplain() method can use // the match result. A matcher's MatchAndExplain() method can use
// this information to avoid generating the explanation when no one // this information to avoid generating the explanation when no one
// intends to hear it. // intends to hear it.
bool IsInterested() const { return stream_ != NULL; } bool IsInterested() const { return stream_ != nullptr; }
private: private:
::std::ostream* const stream_; ::std::ostream* const stream_;
@ -261,7 +260,7 @@ struct AnyGe {
// A match result listener that ignores the explanation. // A match result listener that ignores the explanation.
class DummyMatchResultListener : public MatchResultListener { class DummyMatchResultListener : public MatchResultListener {
public: public:
DummyMatchResultListener() : MatchResultListener(NULL) {} DummyMatchResultListener() : MatchResultListener(nullptr) {}
private: private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener); GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
@ -333,7 +332,7 @@ class MatcherBase {
const MatcherInterface<U>* impl, const MatcherInterface<U>* impl,
typename internal::EnableIf< typename internal::EnableIf<
!internal::IsSame<U, GTEST_REFERENCE_TO_CONST_(U)>::value>::type* = !internal::IsSame<U, GTEST_REFERENCE_TO_CONST_(U)>::value>::type* =
NULL) nullptr)
: impl_(new internal::MatcherInterfaceAdapter<U>(impl)) {} : impl_(new internal::MatcherInterfaceAdapter<U>(impl)) {}
virtual ~MatcherBase() {} virtual ~MatcherBase() {}
@ -375,9 +374,11 @@ class Matcher : public internal::MatcherBase<T> {
: internal::MatcherBase<T>(impl) {} : internal::MatcherBase<T>(impl) {}
template <typename U> template <typename U>
explicit Matcher(const MatcherInterface<U>* impl, explicit Matcher(
typename internal::EnableIf<!internal::IsSame< const MatcherInterface<U>* impl,
U, GTEST_REFERENCE_TO_CONST_(U)>::value>::type* = NULL) typename internal::EnableIf<
!internal::IsSame<U, GTEST_REFERENCE_TO_CONST_(U)>::value>::type* =
nullptr)
: internal::MatcherBase<T>(impl) {} : internal::MatcherBase<T>(impl) {}
// Implicit constructor here allows people to write // Implicit constructor here allows people to write
@ -850,7 +851,7 @@ namespace internal {
// If the explanation is not empty, prints it to the ostream. // If the explanation is not empty, prints it to the ostream.
inline void PrintIfNotEmpty(const std::string& explanation, inline void PrintIfNotEmpty(const std::string& explanation,
::std::ostream* os) { ::std::ostream* os) {
if (explanation != "" && os != NULL) { if (explanation != "" && os != nullptr) {
*os << ", " << explanation; *os << ", " << explanation;
} }
} }
@ -1321,7 +1322,7 @@ class StrEqualityMatcher {
// wchar_t* // wchar_t*
template <typename CharType> template <typename CharType>
bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
if (s == NULL) { if (s == nullptr) {
return !expect_eq_; return !expect_eq_;
} }
return MatchAndExplain(StringType(s), listener); return MatchAndExplain(StringType(s), listener);
@ -1391,7 +1392,7 @@ class HasSubstrMatcher {
// wchar_t* // wchar_t*
template <typename CharType> template <typename CharType>
bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
return s != NULL && MatchAndExplain(StringType(s), listener); return s != nullptr && MatchAndExplain(StringType(s), listener);
} }
// Matches anything that can convert to StringType. // Matches anything that can convert to StringType.
@ -1448,7 +1449,7 @@ class StartsWithMatcher {
// wchar_t* // wchar_t*
template <typename CharType> template <typename CharType>
bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
return s != NULL && MatchAndExplain(StringType(s), listener); return s != nullptr && MatchAndExplain(StringType(s), listener);
} }
// Matches anything that can convert to StringType. // Matches anything that can convert to StringType.
@ -1504,7 +1505,7 @@ class EndsWithMatcher {
// wchar_t* // wchar_t*
template <typename CharType> template <typename CharType>
bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
return s != NULL && MatchAndExplain(StringType(s), listener); return s != nullptr && MatchAndExplain(StringType(s), listener);
} }
// Matches anything that can convert to StringType. // Matches anything that can convert to StringType.
@ -1557,7 +1558,7 @@ class MatchesRegexMatcher {
// wchar_t* // wchar_t*
template <typename CharType> template <typename CharType>
bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
return s != NULL && MatchAndExplain(std::string(s), listener); return s != nullptr && MatchAndExplain(std::string(s), listener);
} }
// Matches anything that can convert to std::string. // Matches anything that can convert to std::string.
@ -2347,8 +2348,7 @@ class PointeeMatcher {
virtual bool MatchAndExplain(Pointer pointer, virtual bool MatchAndExplain(Pointer pointer,
MatchResultListener* listener) const { MatchResultListener* listener) const {
if (GetRawPointer(pointer) == NULL) if (GetRawPointer(pointer) == nullptr) return false;
return false;
*listener << "which points to "; *listener << "which points to ";
return MatchPrintAndExplain(*pointer, matcher_, listener); return MatchPrintAndExplain(*pointer, matcher_, listener);
@ -2431,7 +2431,7 @@ class WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> {
bool MatchAndExplain(From& from, MatchResultListener* listener) const { bool MatchAndExplain(From& from, MatchResultListener* listener) const {
// We don't want an std::bad_cast here, so do the cast with pointers. // We don't want an std::bad_cast here, so do the cast with pointers.
To* to = dynamic_cast<To*>(&from); To* to = dynamic_cast<To*>(&from);
if (to == NULL) { if (to == nullptr) {
*listener << "which cannot be dynamic_cast to " << this->GetToName(); *listener << "which cannot be dynamic_cast to " << this->GetToName();
return false; return false;
} }
@ -2485,8 +2485,7 @@ class FieldMatcher {
bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p, bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
MatchResultListener* listener) const { MatchResultListener* listener) const {
if (p == NULL) if (p == nullptr) return false;
return false;
*listener << "which points to an object "; *listener << "which points to an object ";
// Since *p has a field, it must be a class/struct/union type and // Since *p has a field, it must be a class/struct/union type and
@ -2570,8 +2569,7 @@ class PropertyMatcher {
bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p, bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
MatchResultListener* listener) const { MatchResultListener* listener) const {
if (p == NULL) if (p == nullptr) return false;
return false;
*listener << "which points to an object "; *listener << "which points to an object ";
// Since *p has a property method, it must be a class/struct/union // Since *p has a property method, it must be a class/struct/union
@ -2615,7 +2613,7 @@ struct CallableTraits<ResType(*)(ArgType)> {
typedef ResType(*StorageType)(ArgType); typedef ResType(*StorageType)(ArgType);
static void CheckIsValid(ResType(*f)(ArgType)) { static void CheckIsValid(ResType(*f)(ArgType)) {
GTEST_CHECK_(f != NULL) GTEST_CHECK_(f != nullptr)
<< "NULL function pointer is passed into ResultOf()."; << "NULL function pointer is passed into ResultOf().";
} }
template <typename T> template <typename T>
@ -2857,7 +2855,7 @@ class ContainerEqMatcher {
return true; return true;
::std::ostream* const os = listener->stream(); ::std::ostream* const os = listener->stream();
if (os != NULL) { if (os != nullptr) {
// Something is different. Check for extra values first. // Something is different. Check for extra values first.
bool printed_header = false; bool printed_header = false;
for (typename LhsStlContainer::const_iterator it = for (typename LhsStlContainer::const_iterator it =
@ -4136,11 +4134,11 @@ class AnyCastMatcher {
::testing::MatchResultListener* listener) const { ::testing::MatchResultListener* listener) const {
if (!listener->IsInterested()) { if (!listener->IsInterested()) {
const T* ptr = any_cast<T>(&value); const T* ptr = any_cast<T>(&value);
return ptr != NULL && matcher_.Matches(*ptr); return ptr != nullptr && matcher_.Matches(*ptr);
} }
const T* elem = any_cast<T>(&value); const T* elem = any_cast<T>(&value);
if (elem == NULL) { if (elem == nullptr) {
*listener << "whose value is not of type '" << GetTypeName() << "'"; *listener << "whose value is not of type '" << GetTypeName() << "'";
return false; return false;
} }

20
googlemock/include/gmock/gmock-spec-builders.h
View File

@ -1213,7 +1213,7 @@ class TypedExpectation : public ExpectationBase {
// FIXME: allow the user to control whether // FIXME: allow the user to control whether
// unexpected calls should fail immediately or continue using a // unexpected calls should fail immediately or continue using a
// flag --gmock_unexpected_calls_are_fatal. // flag --gmock_unexpected_calls_are_fatal.
return NULL; return nullptr;
} }
IncrementCallCount(); IncrementCallCount();
@ -1498,7 +1498,7 @@ class FunctionMockerBase : public UntypedFunctionMockerBase {
return spec; return spec;
} }
return NULL; return nullptr;
} }
// Performs the default action of this mock function on the given // Performs the default action of this mock function on the given
@ -1513,7 +1513,7 @@ class FunctionMockerBase : public UntypedFunctionMockerBase {
const std::string& call_description) const { const std::string& call_description) const {
const OnCallSpec<F>* const spec = const OnCallSpec<F>* const spec =
this->FindOnCallSpec(args); this->FindOnCallSpec(args);
if (spec != NULL) { if (spec != nullptr) {
return spec->GetAction().Perform(internal::move(args)); return spec->GetAction().Perform(internal::move(args));
} }
const std::string message = const std::string message =
@ -1630,7 +1630,7 @@ class FunctionMockerBase : public UntypedFunctionMockerBase {
// Adds this expectation into the implicit sequence if there is one. // Adds this expectation into the implicit sequence if there is one.
Sequence* const implicit_sequence = g_gmock_implicit_sequence.get(); Sequence* const implicit_sequence = g_gmock_implicit_sequence.get();
if (implicit_sequence != NULL) { if (implicit_sequence != nullptr) {
implicit_sequence->AddExpectation(Expectation(untyped_expectation)); implicit_sequence->AddExpectation(Expectation(untyped_expectation));
} }
@ -1649,7 +1649,7 @@ class FunctionMockerBase : public UntypedFunctionMockerBase {
::std::ostream* os) const { ::std::ostream* os) const {
const OnCallSpec<F>* const spec = FindOnCallSpec(args); const OnCallSpec<F>* const spec = FindOnCallSpec(args);
if (spec == NULL) { if (spec == nullptr) {
*os << (internal::type_equals<Result, void>::value ? *os << (internal::type_equals<Result, void>::value ?
"returning directly.\n" : "returning directly.\n" :
"returning default value.\n"); "returning default value.\n");
@ -1699,9 +1699,9 @@ class FunctionMockerBase : public UntypedFunctionMockerBase {
*static_cast<const ArgumentTuple*>(untyped_args); *static_cast<const ArgumentTuple*>(untyped_args);
MutexLock l(&g_gmock_mutex); MutexLock l(&g_gmock_mutex);
TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args); TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args);
if (exp == NULL) { // A match wasn't found. if (exp == nullptr) { // A match wasn't found.
this->FormatUnexpectedCallMessageLocked(args, what, why); this->FormatUnexpectedCallMessageLocked(args, what, why);
return NULL; return nullptr;
} }
// This line must be done before calling GetActionForArguments(), // This line must be done before calling GetActionForArguments(),
@ -1709,8 +1709,8 @@ class FunctionMockerBase : public UntypedFunctionMockerBase {
// its saturation status. // its saturation status.
*is_excessive = exp->IsSaturated(); *is_excessive = exp->IsSaturated();
const Action<F>* action = exp->GetActionForArguments(this, args, what, why); const Action<F>* action = exp->GetActionForArguments(this, args, what, why);
if (action != NULL && action->IsDoDefault()) if (action != nullptr && action->IsDoDefault())
action = NULL; // Normalize "do default" to NULL. action = nullptr; // Normalize "do default" to NULL.
*untyped_action = action; *untyped_action = action;
return exp; return exp;
} }
@ -1740,7 +1740,7 @@ class FunctionMockerBase : public UntypedFunctionMockerBase {
return exp; return exp;
} }
} }
return NULL; return nullptr;
} }
// Returns a message that the arguments don't match any expectation. // Returns a message that the arguments don't match any expectation.

41
googlemock/src/gmock-spec-builders.cc
View File

@ -296,12 +296,12 @@ void ReportUninterestingCall(CallReaction reaction, const std::string& msg) {
stack_frames_to_skip); stack_frames_to_skip);
break; break;
default: // FAIL default: // FAIL
Expect(false, NULL, -1, msg); Expect(false, nullptr, -1, msg);
} }
} }
UntypedFunctionMockerBase::UntypedFunctionMockerBase() UntypedFunctionMockerBase::UntypedFunctionMockerBase()
: mock_obj_(NULL), name_("") {} : mock_obj_(nullptr), name_("") {}
UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {} UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {}
@ -340,7 +340,7 @@ const void* UntypedFunctionMockerBase::MockObject() const
// We protect mock_obj_ under g_gmock_mutex in case this mock // We protect mock_obj_ under g_gmock_mutex in case this mock
// function is called from two threads concurrently. // function is called from two threads concurrently.
MutexLock l(&g_gmock_mutex); MutexLock l(&g_gmock_mutex);
Assert(mock_obj_ != NULL, __FILE__, __LINE__, Assert(mock_obj_ != nullptr, __FILE__, __LINE__,
"MockObject() must not be called before RegisterOwner() or " "MockObject() must not be called before RegisterOwner() or "
"SetOwnerAndName() has been called."); "SetOwnerAndName() has been called.");
mock_obj = mock_obj_; mock_obj = mock_obj_;
@ -357,7 +357,7 @@ const char* UntypedFunctionMockerBase::Name() const
// We protect name_ under g_gmock_mutex in case this mock // We protect name_ under g_gmock_mutex in case this mock
// function is called from two threads concurrently. // function is called from two threads concurrently.
MutexLock l(&g_gmock_mutex); MutexLock l(&g_gmock_mutex);
Assert(name_ != NULL, __FILE__, __LINE__, Assert(name_ != nullptr, __FILE__, __LINE__,
"Name() must not be called before SetOwnerAndName() has " "Name() must not be called before SetOwnerAndName() has "
"been called."); "been called.");
name = name_; name = name_;
@ -414,8 +414,7 @@ UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
this->UntypedPerformDefaultAction(untyped_args, ss.str()); this->UntypedPerformDefaultAction(untyped_args, ss.str());
// Prints the function result. // Prints the function result.
if (result != NULL) if (result != nullptr) result->PrintAsActionResult(&ss);
result->PrintAsActionResult(&ss);
ReportUninterestingCall(reaction, ss.str()); ReportUninterestingCall(reaction, ss.str());
return result; return result;
@ -425,7 +424,7 @@ UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
::std::stringstream ss; ::std::stringstream ss;
::std::stringstream why; ::std::stringstream why;
::std::stringstream loc; ::std::stringstream loc;
const void* untyped_action = NULL; const void* untyped_action = nullptr;
// The UntypedFindMatchingExpectation() function acquires and // The UntypedFindMatchingExpectation() function acquires and
// releases g_gmock_mutex. // releases g_gmock_mutex.
@ -433,7 +432,7 @@ UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
this->UntypedFindMatchingExpectation( this->UntypedFindMatchingExpectation(
untyped_args, &untyped_action, &is_excessive, untyped_args, &untyped_action, &is_excessive,
&ss, &why); &ss, &why);
const bool found = untyped_expectation != NULL; const bool found = untyped_expectation != nullptr;
// True iff we need to print the call's arguments and return value. // True iff we need to print the call's arguments and return value.
// This definition must be kept in sync with the uses of Expect() // This definition must be kept in sync with the uses of Expect()
@ -442,10 +441,9 @@ UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
!found || is_excessive || LogIsVisible(kInfo); !found || is_excessive || LogIsVisible(kInfo);
if (!need_to_report_call) { if (!need_to_report_call) {
// Perform the action without printing the call information. // Perform the action without printing the call information.
return return untyped_action == nullptr
untyped_action == NULL ? ? this->UntypedPerformDefaultAction(untyped_args, "")
this->UntypedPerformDefaultAction(untyped_args, "") : : this->UntypedPerformAction(untyped_action, untyped_args);
this->UntypedPerformAction(untyped_action, untyped_args);
} }
ss << " Function call: " << Name(); ss << " Function call: " << Name();
@ -458,16 +456,15 @@ UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
} }
UntypedActionResultHolderBase* const result = UntypedActionResultHolderBase* const result =
untyped_action == NULL ? untyped_action == nullptr
this->UntypedPerformDefaultAction(untyped_args, ss.str()) : ? this->UntypedPerformDefaultAction(untyped_args, ss.str())
this->UntypedPerformAction(untyped_action, untyped_args); : this->UntypedPerformAction(untyped_action, untyped_args);
if (result != NULL) if (result != nullptr) result->PrintAsActionResult(&ss);
result->PrintAsActionResult(&ss);
ss << "\n" << why.str(); ss << "\n" << why.str();
if (!found) { if (!found) {
// No expectation matches this call - reports a failure. // No expectation matches this call - reports a failure.
Expect(false, NULL, -1, ss.str()); Expect(false, nullptr, -1, ss.str());
} else if (is_excessive) { } else if (is_excessive) {
// We had an upper-bound violation and the failure message is in ss. // We had an upper-bound violation and the failure message is in ss.
Expect(false, untyped_expectation->file(), Expect(false, untyped_expectation->file(),
@ -568,7 +565,7 @@ typedef std::set<internal::UntypedFunctionMockerBase*> FunctionMockers;
// expectations. // expectations.
struct MockObjectState { struct MockObjectState {
MockObjectState() MockObjectState()
: first_used_file(NULL), first_used_line(-1), leakable(false) {} : first_used_file(nullptr), first_used_line(-1), leakable(false) {}
// Where in the source file an ON_CALL or EXPECT_CALL is first // Where in the source file an ON_CALL or EXPECT_CALL is first
// invoked on this mock object. // invoked on this mock object.
@ -776,12 +773,12 @@ void Mock::RegisterUseByOnCallOrExpectCall(const void* mock_obj,
GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
internal::MutexLock l(&internal::g_gmock_mutex); internal::MutexLock l(&internal::g_gmock_mutex);
MockObjectState& state = g_mock_object_registry.states()[mock_obj]; MockObjectState& state = g_mock_object_registry.states()[mock_obj];
if (state.first_used_file == NULL) { if (state.first_used_file == nullptr) {
state.first_used_file = file; state.first_used_file = file;
state.first_used_line = line; state.first_used_line = line;
const TestInfo* const test_info = const TestInfo* const test_info =
UnitTest::GetInstance()->current_test_info(); UnitTest::GetInstance()->current_test_info();
if (test_info != NULL) { if (test_info != nullptr) {
// FIXME: record the test case name when the // FIXME: record the test case name when the
// ON_CALL or EXPECT_CALL is invoked from SetUpTestCase() or // ON_CALL or EXPECT_CALL is invoked from SetUpTestCase() or
// TearDownTestCase(). // TearDownTestCase().
@ -846,7 +843,7 @@ Expectation::~Expectation() {}
// Adds an expectation to a sequence. // Adds an expectation to a sequence.
void Sequence::AddExpectation(const Expectation& expectation) const { void Sequence::AddExpectation(const Expectation& expectation) const {
if (*last_expectation_ != expectation) { if (*last_expectation_ != expectation) {
if (last_expectation_->expectation_base() != NULL) { if (last_expectation_->expectation_base() != nullptr) {
expectation.expectation_base()->immediate_prerequisites_ expectation.expectation_base()->immediate_prerequisites_
+= *last_expectation_; += *last_expectation_;
} }

12
googlemock/src/gmock.cc
View File

@ -65,12 +65,12 @@ static const char* ParseGoogleMockFlagValue(const char* str,
const char* flag, const char* flag,
bool def_optional) { bool def_optional) {
// str and flag must not be NULL. // str and flag must not be NULL.
if (str == NULL || flag == NULL) return NULL; if (str == nullptr || flag == nullptr) return nullptr;
// The flag must start with "--gmock_". // The flag must start with "--gmock_".
const std::string flag_str = std::string("--gmock_") + flag; const std::string flag_str = std::string("--gmock_") + flag;
const size_t flag_len = flag_str.length(); const size_t flag_len = flag_str.length();
if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL; if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
// Skips the flag name. // Skips the flag name.
const char* flag_end = str + flag_len; const char* flag_end = str + flag_len;
@ -83,7 +83,7 @@ static const char* ParseGoogleMockFlagValue(const char* str,
// If def_optional is true and there are more characters after the // If def_optional is true and there are more characters after the
// flag name, or if def_optional is false, there must be a '=' after // flag name, or if def_optional is false, there must be a '=' after
// the flag name. // the flag name.
if (flag_end[0] != '=') return NULL; if (flag_end[0] != '=') return nullptr;
// Returns the string after "=". // Returns the string after "=".
return flag_end + 1; return flag_end + 1;
@ -100,7 +100,7 @@ static bool ParseGoogleMockBoolFlag(const char* str, const char* flag,
const char* const value_str = ParseGoogleMockFlagValue(str, flag, true); const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
// Aborts if the parsing failed. // Aborts if the parsing failed.
if (value_str == NULL) return false; if (value_str == nullptr) return false;
// Converts the string value to a bool. // Converts the string value to a bool.
*value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
@ -119,7 +119,7 @@ static bool ParseGoogleMockStringFlag(const char* str, const char* flag,
const char* const value_str = ParseGoogleMockFlagValue(str, flag, false); const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);
// Aborts if the parsing failed. // Aborts if the parsing failed.
if (value_str == NULL) return false; if (value_str == nullptr) return false;
// Sets *value to the value of the flag. // Sets *value to the value of the flag.
*value = value_str; *value = value_str;
@ -132,7 +132,7 @@ static bool ParseGoogleMockIntFlag(const char* str, const char* flag,
const char* const value_str = ParseGoogleMockFlagValue(str, flag, true); const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
// Aborts if the parsing failed. // Aborts if the parsing failed.
if (value_str == NULL) return false; if (value_str == nullptr) return false;
// Sets *value to the value of the flag. // Sets *value to the value of the flag.
return ParseInt32(Message() << "The value of flag --" << flag, return ParseInt32(Message() << "The value of flag --" << flag,

28
googlemock/test/gmock-actions_test.cc
View File

@ -89,9 +89,9 @@ using testing::SetErrnoAndReturn;
// Tests that BuiltInDefaultValue<T*>::Get() returns NULL. // Tests that BuiltInDefaultValue<T*>::Get() returns NULL.
TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) { TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) {
EXPECT_TRUE(BuiltInDefaultValue<int*>::Get() == NULL); EXPECT_TRUE(BuiltInDefaultValue<int*>::Get() == nullptr);
EXPECT_TRUE(BuiltInDefaultValue<const char*>::Get() == NULL); EXPECT_TRUE(BuiltInDefaultValue<const char*>::Get() == nullptr);
EXPECT_TRUE(BuiltInDefaultValue<void*>::Get() == NULL); EXPECT_TRUE(BuiltInDefaultValue<void*>::Get() == nullptr);
} }
// Tests that BuiltInDefaultValue<T*>::Exists() return true. // Tests that BuiltInDefaultValue<T*>::Exists() return true.
@ -196,7 +196,7 @@ TEST(BuiltInDefaultValueTest, ExistsForString) {
TEST(BuiltInDefaultValueTest, WorksForConstTypes) { TEST(BuiltInDefaultValueTest, WorksForConstTypes) {
EXPECT_EQ("", BuiltInDefaultValue<const std::string>::Get()); EXPECT_EQ("", BuiltInDefaultValue<const std::string>::Get());
EXPECT_EQ(0, BuiltInDefaultValue<const int>::Get()); EXPECT_EQ(0, BuiltInDefaultValue<const int>::Get());
EXPECT_TRUE(BuiltInDefaultValue<char* const>::Get() == NULL); EXPECT_TRUE(BuiltInDefaultValue<char* const>::Get() == nullptr);
EXPECT_FALSE(BuiltInDefaultValue<const bool>::Get()); EXPECT_FALSE(BuiltInDefaultValue<const bool>::Get());
} }
@ -306,7 +306,7 @@ TEST(DefaultValueDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
#if GTEST_HAS_STD_UNIQUE_PTR_ #if GTEST_HAS_STD_UNIQUE_PTR_
TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) { TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {
EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists()); EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == NULL); EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == nullptr);
DefaultValue<std::unique_ptr<int>>::SetFactory([] { DefaultValue<std::unique_ptr<int>>::SetFactory([] {
return std::unique_ptr<int>(new int(42)); return std::unique_ptr<int>(new int(42));
}); });
@ -519,7 +519,7 @@ TEST(MakePolymorphicActionTest, WorksWhenPerformHasOneTemplateParameter) {
EXPECT_EQ(0, a1.Perform(make_tuple())); EXPECT_EQ(0, a1.Perform(make_tuple()));
Action<void*()> a2 = ReturnZeroFromNullaryFunction(); Action<void*()> a2 = ReturnZeroFromNullaryFunction();
EXPECT_TRUE(a2.Perform(make_tuple()) == NULL); EXPECT_TRUE(a2.Perform(make_tuple()) == nullptr);
} }
// Tests that Return() works as an action for void-returning // Tests that Return() works as an action for void-returning
@ -636,10 +636,10 @@ TEST(ReturnTest, CanConvertArgumentUsingNonConstTypeCastOperator) {
// Tests that ReturnNull() returns NULL in a pointer-returning function. // Tests that ReturnNull() returns NULL in a pointer-returning function.
TEST(ReturnNullTest, WorksInPointerReturningFunction) { TEST(ReturnNullTest, WorksInPointerReturningFunction) {
const Action<int*()> a1 = ReturnNull(); const Action<int*()> a1 = ReturnNull();
EXPECT_TRUE(a1.Perform(make_tuple()) == NULL); EXPECT_TRUE(a1.Perform(make_tuple()) == nullptr);
const Action<const char*(bool)> a2 = ReturnNull(); // NOLINT const Action<const char*(bool)> a2 = ReturnNull(); // NOLINT
EXPECT_TRUE(a2.Perform(make_tuple(true)) == NULL); EXPECT_TRUE(a2.Perform(make_tuple(true)) == nullptr);
} }
#if GTEST_HAS_STD_UNIQUE_PTR_ #if GTEST_HAS_STD_UNIQUE_PTR_
@ -819,10 +819,10 @@ TEST(SetArgPointeeTest, AcceptsStringLiteral) {
typedef void MyFunction(std::string*, const char**); typedef void MyFunction(std::string*, const char**);
Action<MyFunction> a = SetArgPointee<0>("hi"); Action<MyFunction> a = SetArgPointee<0>("hi");
std::string str; std::string str;
const char* ptr = NULL; const char* ptr = nullptr;
a.Perform(make_tuple(&str, &ptr)); a.Perform(make_tuple(&str, &ptr));
EXPECT_EQ("hi", str); EXPECT_EQ("hi", str);
EXPECT_TRUE(ptr == NULL); EXPECT_TRUE(ptr == nullptr);
a = SetArgPointee<1>("world"); a = SetArgPointee<1>("world");
str = ""; str = "";
@ -834,7 +834,7 @@ TEST(SetArgPointeeTest, AcceptsStringLiteral) {
TEST(SetArgPointeeTest, AcceptsWideStringLiteral) { TEST(SetArgPointeeTest, AcceptsWideStringLiteral) {
typedef void MyFunction(const wchar_t**); typedef void MyFunction(const wchar_t**);
Action<MyFunction> a = SetArgPointee<0>(L"world"); Action<MyFunction> a = SetArgPointee<0>(L"world");
const wchar_t* ptr = NULL; const wchar_t* ptr = nullptr;
a.Perform(make_tuple(&ptr)); a.Perform(make_tuple(&ptr));
EXPECT_STREQ(L"world", ptr); EXPECT_STREQ(L"world", ptr);
@ -856,10 +856,10 @@ TEST(SetArgPointeeTest, AcceptsCharPointer) {
const char* const hi = "hi"; const char* const hi = "hi";
Action<MyFunction> a = SetArgPointee<1>(hi); Action<MyFunction> a = SetArgPointee<1>(hi);
std::string str; std::string str;
const char* ptr = NULL; const char* ptr = nullptr;
a.Perform(make_tuple(true, &str, &ptr)); a.Perform(make_tuple(true, &str, &ptr));
EXPECT_EQ("hi", str); EXPECT_EQ("hi", str);
EXPECT_TRUE(ptr == NULL); EXPECT_TRUE(ptr == nullptr);
char world_array[] = "world"; char world_array[] = "world";
char* const world = world_array; char* const world = world_array;
@ -874,7 +874,7 @@ TEST(SetArgPointeeTest, AcceptsWideCharPointer) {
typedef void MyFunction(bool, const wchar_t**); typedef void MyFunction(bool, const wchar_t**);
const wchar_t* const hi = L"hi"; const wchar_t* const hi = L"hi";
Action<MyFunction> a = SetArgPointee<1>(hi); Action<MyFunction> a = SetArgPointee<1>(hi);
const wchar_t* ptr = NULL; const wchar_t* ptr = nullptr;
a.Perform(make_tuple(true, &ptr)); a.Perform(make_tuple(true, &ptr));
EXPECT_EQ(hi, ptr); EXPECT_EQ(hi, ptr);

2
googlemock/test/gmock-generated-function-mockers_test.cc
View File

@ -228,7 +228,7 @@ TEST_F(FunctionMockerTest, MocksDecimalFunction) {
Lt(100), 5U, NULL, "hi")) Lt(100), 5U, NULL, "hi"))
.WillOnce(Return(5)); .WillOnce(Return(5));
EXPECT_EQ(5, foo_->Decimal(true, 'a', 0, 0, 1, 0, 0, 5, NULL, "hi")); EXPECT_EQ(5, foo_->Decimal(true, 'a', 0, 0, 1, 0, 0, 5, nullptr, "hi"));
} }
// Tests mocking a function that takes a non-const reference. // Tests mocking a function that takes a non-const reference.

4
googlemock/test/gmock-generated-matchers_test.cc
View File

@ -697,7 +697,7 @@ TEST(ElementsAreArrayTest, CanBeCreatedWithIteratorRange) {
// Pointers are iterators, too. // Pointers are iterators, too.
EXPECT_THAT(test_vector, ElementsAreArray(a, a + GTEST_ARRAY_SIZE_(a))); EXPECT_THAT(test_vector, ElementsAreArray(a, a + GTEST_ARRAY_SIZE_(a)));
// The empty range of NULL pointers should also be okay. // The empty range of NULL pointers should also be okay.
int* const null_int = NULL; int* const null_int = nullptr;
EXPECT_THAT(test_vector, Not(ElementsAreArray(null_int, null_int))); EXPECT_THAT(test_vector, Not(ElementsAreArray(null_int, null_int)));
EXPECT_THAT((vector<int>()), ElementsAreArray(null_int, null_int)); EXPECT_THAT((vector<int>()), ElementsAreArray(null_int, null_int));
} }
@ -770,7 +770,7 @@ MATCHER_P2(EqSumOf, x, y, std::string(negation ? "doesn't equal" : "equals") +
} else { } else {
// Verifies that we can stream to the underlying stream of // Verifies that we can stream to the underlying stream of
// result_listener. // result_listener.
if (result_listener->stream() != NULL) { if (result_listener->stream() != nullptr) {
*result_listener->stream() << "diff == " << (x + y - arg); *result_listener->stream() << "diff == " << (x + y - arg);
} }
return false; return false;

6
googlemock/test/gmock-internal-utils_test.cc
View File

@ -158,9 +158,9 @@ TEST(GetRawPointerTest, WorksForSmartPointers) {
} }
TEST(GetRawPointerTest, WorksForRawPointers) { TEST(GetRawPointerTest, WorksForRawPointers) {
int* p = NULL; int* p = nullptr;
// Don't use EXPECT_EQ as no NULL-testing magic on Symbian. // Don't use EXPECT_EQ as no NULL-testing magic on Symbian.
EXPECT_TRUE(NULL == GetRawPointer(p)); EXPECT_TRUE(nullptr == GetRawPointer(p));
int n = 1; int n = 1;
EXPECT_EQ(&n, GetRawPointer(&n)); EXPECT_EQ(&n, GetRawPointer(&n));
} }
@ -492,7 +492,7 @@ TEST(LogTest, NoSkippingStackFrameInOptMode) {
AllOf(Ge(expected_skip_count), Le(expected_skip_count + 10))); AllOf(Ge(expected_skip_count), Le(expected_skip_count + 10)));
// Restores the default OS stack trace getter. // Restores the default OS stack trace getter.
GetUnitTestImpl()->set_os_stack_trace_getter(NULL); GetUnitTestImpl()->set_os_stack_trace_getter(nullptr);
} }
// Tests that all logs are printed when the value of the // Tests that all logs are printed when the value of the

124
googlemock/test/gmock-matchers_test.cc
View File

@ -238,8 +238,8 @@ TEST(MatchResultListenerTest, StreamingWorks) {
} }
TEST(MatchResultListenerTest, CanAccessUnderlyingStream) { TEST(MatchResultListenerTest, CanAccessUnderlyingStream) {
EXPECT_TRUE(DummyMatchResultListener().stream() == NULL); EXPECT_TRUE(DummyMatchResultListener().stream() == nullptr);
EXPECT_TRUE(StreamMatchResultListener(NULL).stream() == NULL); EXPECT_TRUE(StreamMatchResultListener(nullptr).stream() == nullptr);
EXPECT_EQ(&std::cout, StreamMatchResultListener(&std::cout).stream()); EXPECT_EQ(&std::cout, StreamMatchResultListener(&std::cout).stream());
} }
@ -249,7 +249,7 @@ TEST(MatchResultListenerTest, IsInterestedWorks) {
EXPECT_TRUE(StreamMatchResultListener(&std::cout).IsInterested()); EXPECT_TRUE(StreamMatchResultListener(&std::cout).IsInterested());
EXPECT_FALSE(DummyMatchResultListener().IsInterested()); EXPECT_FALSE(DummyMatchResultListener().IsInterested());
EXPECT_FALSE(StreamMatchResultListener(NULL).IsInterested()); EXPECT_FALSE(StreamMatchResultListener(nullptr).IsInterested());
} }
// Makes sure that the MatcherInterface<T> interface doesn't // Makes sure that the MatcherInterface<T> interface doesn't
@ -283,7 +283,7 @@ class NewEvenMatcherImpl : public MatcherInterface<int> {
const bool match = x % 2 == 0; const bool match = x % 2 == 0;
// Verifies that we can stream to a listener directly. // Verifies that we can stream to a listener directly.
*listener << "value % " << 2; *listener << "value % " << 2;
if (listener->stream() != NULL) { if (listener->stream() != nullptr) {
// Verifies that we can stream to a listener's underlying stream // Verifies that we can stream to a listener's underlying stream
// too. // too.
*listener->stream() << " == " << (x % 2); *listener->stream() << " == " << (x % 2);
@ -327,7 +327,7 @@ TEST(MatcherTest, CanBeImplicitlyConstructedFromValue) {
// Tests that NULL can be used in place of Eq(NULL). // Tests that NULL can be used in place of Eq(NULL).
TEST(MatcherTest, CanBeImplicitlyConstructedFromNULL) { TEST(MatcherTest, CanBeImplicitlyConstructedFromNULL) {
Matcher<int*> m1 = NULL; Matcher<int*> m1 = NULL;
EXPECT_TRUE(m1.Matches(NULL)); EXPECT_TRUE(m1.Matches(nullptr));
int n = 0; int n = 0;
EXPECT_FALSE(m1.Matches(&n)); EXPECT_FALSE(m1.Matches(&n));
} }
@ -512,7 +512,7 @@ TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromStringView) {
// MatcherInterface* without requiring the user to explicitly // MatcherInterface* without requiring the user to explicitly
// write the type. // write the type.
TEST(MakeMatcherTest, ConstructsMatcherFromMatcherInterface) { TEST(MakeMatcherTest, ConstructsMatcherFromMatcherInterface) {
const MatcherInterface<int>* dummy_impl = NULL; const MatcherInterface<int>* dummy_impl = nullptr;
Matcher<int> m = MakeMatcher(dummy_impl); Matcher<int> m = MakeMatcher(dummy_impl);
} }
@ -571,7 +571,7 @@ class PolymorphicIsEvenImpl {
bool MatchAndExplain(const T& x, MatchResultListener* listener) const { bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
// Verifies that we can stream to the listener directly. // Verifies that we can stream to the listener directly.
*listener << "% " << 2; *listener << "% " << 2;
if (listener->stream() != NULL) { if (listener->stream() != nullptr) {
// Verifies that we can stream to the listener's underlying stream // Verifies that we can stream to the listener's underlying stream
// too. // too.
*listener->stream() << " == " << (x % 2); *listener->stream() << " == " << (x % 2);
@ -1154,13 +1154,13 @@ TEST(NeTest, CanDescribeSelf) {
// Tests that IsNull() matches any NULL pointer of any type. // Tests that IsNull() matches any NULL pointer of any type.
TEST(IsNullTest, MatchesNullPointer) { TEST(IsNullTest, MatchesNullPointer) {
Matcher<int*> m1 = IsNull(); Matcher<int*> m1 = IsNull();
int* p1 = NULL; int* p1 = nullptr;
int n = 0; int n = 0;
EXPECT_TRUE(m1.Matches(p1)); EXPECT_TRUE(m1.Matches(p1));
EXPECT_FALSE(m1.Matches(&n)); EXPECT_FALSE(m1.Matches(&n));
Matcher<const char*> m2 = IsNull(); Matcher<const char*> m2 = IsNull();
const char* p2 = NULL; const char* p2 = nullptr;
EXPECT_TRUE(m2.Matches(p2)); EXPECT_TRUE(m2.Matches(p2));
EXPECT_FALSE(m2.Matches("hi")); EXPECT_FALSE(m2.Matches("hi"));
@ -1174,7 +1174,7 @@ TEST(IsNullTest, MatchesNullPointer) {
// gmock_matchers_test::IsNullTest_MatchesNullPointer_Test::TestBody()') // gmock_matchers_test::IsNullTest_MatchesNullPointer_Test::TestBody()')
// gmock-matchers.h: (instantiating: 'testing::PolymorphicMatc // gmock-matchers.h: (instantiating: 'testing::PolymorphicMatc
Matcher<void*> m3 = IsNull(); Matcher<void*> m3 = IsNull();
void* p3 = NULL; void* p3 = nullptr;
EXPECT_TRUE(m3.Matches(p3)); EXPECT_TRUE(m3.Matches(p3));
EXPECT_FALSE(m3.Matches(reinterpret_cast<void*>(0xbeef))); EXPECT_FALSE(m3.Matches(reinterpret_cast<void*>(0xbeef)));
#endif #endif
@ -1217,13 +1217,13 @@ TEST(IsNullTest, CanDescribeSelf) {
// Tests that NotNull() matches any non-NULL pointer of any type. // Tests that NotNull() matches any non-NULL pointer of any type.
TEST(NotNullTest, MatchesNonNullPointer) { TEST(NotNullTest, MatchesNonNullPointer) {
Matcher<int*> m1 = NotNull(); Matcher<int*> m1 = NotNull();
int* p1 = NULL; int* p1 = nullptr;
int n = 0; int n = 0;
EXPECT_FALSE(m1.Matches(p1)); EXPECT_FALSE(m1.Matches(p1));
EXPECT_TRUE(m1.Matches(&n)); EXPECT_TRUE(m1.Matches(&n));
Matcher<const char*> m2 = NotNull(); Matcher<const char*> m2 = NotNull();
const char* p2 = NULL; const char* p2 = nullptr;
EXPECT_FALSE(m2.Matches(p2)); EXPECT_FALSE(m2.Matches(p2));
EXPECT_TRUE(m2.Matches("hi")); EXPECT_TRUE(m2.Matches("hi"));
} }
@ -1324,7 +1324,7 @@ TEST(StrEqTest, MatchesEqualString) {
Matcher<const char*> m = StrEq(std::string("Hello")); Matcher<const char*> m = StrEq(std::string("Hello"));
EXPECT_TRUE(m.Matches("Hello")); EXPECT_TRUE(m.Matches("Hello"));
EXPECT_FALSE(m.Matches("hello")); EXPECT_FALSE(m.Matches("hello"));
EXPECT_FALSE(m.Matches(NULL)); EXPECT_FALSE(m.Matches(nullptr));
Matcher<const std::string&> m2 = StrEq("Hello"); Matcher<const std::string&> m2 = StrEq("Hello");
EXPECT_TRUE(m2.Matches("Hello")); EXPECT_TRUE(m2.Matches("Hello"));
@ -1360,7 +1360,7 @@ TEST(StrEqTest, CanDescribeSelf) {
TEST(StrNeTest, MatchesUnequalString) { TEST(StrNeTest, MatchesUnequalString) {
Matcher<const char*> m = StrNe("Hello"); Matcher<const char*> m = StrNe("Hello");
EXPECT_TRUE(m.Matches("")); EXPECT_TRUE(m.Matches(""));
EXPECT_TRUE(m.Matches(NULL)); EXPECT_TRUE(m.Matches(nullptr));
EXPECT_FALSE(m.Matches("Hello")); EXPECT_FALSE(m.Matches("Hello"));
Matcher<std::string> m2 = StrNe(std::string("Hello")); Matcher<std::string> m2 = StrNe(std::string("Hello"));
@ -1385,7 +1385,7 @@ TEST(StrCaseEqTest, MatchesEqualStringIgnoringCase) {
EXPECT_TRUE(m.Matches("Hello")); EXPECT_TRUE(m.Matches("Hello"));
EXPECT_TRUE(m.Matches("hello")); EXPECT_TRUE(m.Matches("hello"));
EXPECT_FALSE(m.Matches("Hi")); EXPECT_FALSE(m.Matches("Hi"));
EXPECT_FALSE(m.Matches(NULL)); EXPECT_FALSE(m.Matches(nullptr));
Matcher<const std::string&> m2 = StrCaseEq("Hello"); Matcher<const std::string&> m2 = StrCaseEq("Hello");
EXPECT_TRUE(m2.Matches("hello")); EXPECT_TRUE(m2.Matches("hello"));
@ -1433,7 +1433,7 @@ TEST(StrCaseEqTest, CanDescribeSelf) {
TEST(StrCaseNeTest, MatchesUnequalStringIgnoringCase) { TEST(StrCaseNeTest, MatchesUnequalStringIgnoringCase) {
Matcher<const char*> m = StrCaseNe("Hello"); Matcher<const char*> m = StrCaseNe("Hello");
EXPECT_TRUE(m.Matches("Hi")); EXPECT_TRUE(m.Matches("Hi"));
EXPECT_TRUE(m.Matches(NULL)); EXPECT_TRUE(m.Matches(nullptr));
EXPECT_FALSE(m.Matches("Hello")); EXPECT_FALSE(m.Matches("Hello"));
EXPECT_FALSE(m.Matches("hello")); EXPECT_FALSE(m.Matches("hello"));
@ -1475,17 +1475,17 @@ TEST(HasSubstrTest, WorksForCStrings) {
const Matcher<char*> m1 = HasSubstr("foo"); const Matcher<char*> m1 = HasSubstr("foo");
EXPECT_TRUE(m1.Matches(const_cast<char*>("I love food."))); EXPECT_TRUE(m1.Matches(const_cast<char*>("I love food.")));
EXPECT_FALSE(m1.Matches(const_cast<char*>("tofo"))); EXPECT_FALSE(m1.Matches(const_cast<char*>("tofo")));
EXPECT_FALSE(m1.Matches(NULL)); EXPECT_FALSE(m1.Matches(nullptr));
const Matcher<const char*> m2 = HasSubstr("foo"); const Matcher<const char*> m2 = HasSubstr("foo");
EXPECT_TRUE(m2.Matches("I love food.")); EXPECT_TRUE(m2.Matches("I love food."));
EXPECT_FALSE(m2.Matches("tofo")); EXPECT_FALSE(m2.Matches("tofo"));
EXPECT_FALSE(m2.Matches(NULL)); EXPECT_FALSE(m2.Matches(nullptr));
const Matcher<const char*> m_empty = HasSubstr(""); const Matcher<const char*> m_empty = HasSubstr("");
EXPECT_TRUE(m_empty.Matches("not empty")); EXPECT_TRUE(m_empty.Matches("not empty"));
EXPECT_TRUE(m_empty.Matches("")); EXPECT_TRUE(m_empty.Matches(""));
EXPECT_FALSE(m_empty.Matches(NULL)); EXPECT_FALSE(m_empty.Matches(nullptr));
} }
#if GTEST_HAS_ABSL #if GTEST_HAS_ABSL
@ -1720,7 +1720,7 @@ TEST(StartsWithTest, MatchesStringWithGivenPrefix) {
const Matcher<const char*> m1 = StartsWith(std::string("")); const Matcher<const char*> m1 = StartsWith(std::string(""));
EXPECT_TRUE(m1.Matches("Hi")); EXPECT_TRUE(m1.Matches("Hi"));
EXPECT_TRUE(m1.Matches("")); EXPECT_TRUE(m1.Matches(""));
EXPECT_FALSE(m1.Matches(NULL)); EXPECT_FALSE(m1.Matches(nullptr));
const Matcher<const std::string&> m2 = StartsWith("Hi"); const Matcher<const std::string&> m2 = StartsWith("Hi");
EXPECT_TRUE(m2.Matches("Hi")); EXPECT_TRUE(m2.Matches("Hi"));
@ -1748,7 +1748,7 @@ TEST(EndsWithTest, MatchesStringWithGivenSuffix) {
const Matcher<const char*> m1 = EndsWith(""); const Matcher<const char*> m1 = EndsWith("");
EXPECT_TRUE(m1.Matches("Hi")); EXPECT_TRUE(m1.Matches("Hi"));
EXPECT_TRUE(m1.Matches("")); EXPECT_TRUE(m1.Matches(""));
EXPECT_FALSE(m1.Matches(NULL)); EXPECT_FALSE(m1.Matches(nullptr));
const Matcher<const std::string&> m2 = EndsWith(std::string("Hi")); const Matcher<const std::string&> m2 = EndsWith(std::string("Hi"));
EXPECT_TRUE(m2.Matches("Hi")); EXPECT_TRUE(m2.Matches("Hi"));
@ -1786,7 +1786,7 @@ TEST(MatchesRegexTest, MatchesStringMatchingGivenRegex) {
const Matcher<const char*> m1 = MatchesRegex("a.*z"); const Matcher<const char*> m1 = MatchesRegex("a.*z");
EXPECT_TRUE(m1.Matches("az")); EXPECT_TRUE(m1.Matches("az"));
EXPECT_TRUE(m1.Matches("abcz")); EXPECT_TRUE(m1.Matches("abcz"));
EXPECT_FALSE(m1.Matches(NULL)); EXPECT_FALSE(m1.Matches(nullptr));
const Matcher<const std::string&> m2 = MatchesRegex(new RE("a.*z")); const Matcher<const std::string&> m2 = MatchesRegex(new RE("a.*z"));
EXPECT_TRUE(m2.Matches("azbz")); EXPECT_TRUE(m2.Matches("azbz"));
@ -1824,7 +1824,7 @@ TEST(ContainsRegexTest, MatchesStringContainingGivenRegex) {
const Matcher<const char*> m1 = ContainsRegex(std::string("a.*z")); const Matcher<const char*> m1 = ContainsRegex(std::string("a.*z"));
EXPECT_TRUE(m1.Matches("az")); EXPECT_TRUE(m1.Matches("az"));
EXPECT_TRUE(m1.Matches("0abcz1")); EXPECT_TRUE(m1.Matches("0abcz1"));
EXPECT_FALSE(m1.Matches(NULL)); EXPECT_FALSE(m1.Matches(nullptr));
const Matcher<const std::string&> m2 = ContainsRegex(new RE("a.*z")); const Matcher<const std::string&> m2 = ContainsRegex(new RE("a.*z"));
EXPECT_TRUE(m2.Matches("azbz")); EXPECT_TRUE(m2.Matches("azbz"));
@ -1862,7 +1862,7 @@ TEST(StdWideStrEqTest, MatchesEqual) {
Matcher<const wchar_t*> m = StrEq(::std::wstring(L"Hello")); Matcher<const wchar_t*> m = StrEq(::std::wstring(L"Hello"));
EXPECT_TRUE(m.Matches(L"Hello")); EXPECT_TRUE(m.Matches(L"Hello"));
EXPECT_FALSE(m.Matches(L"hello")); EXPECT_FALSE(m.Matches(L"hello"));
EXPECT_FALSE(m.Matches(NULL)); EXPECT_FALSE(m.Matches(nullptr));
Matcher<const ::std::wstring&> m2 = StrEq(L"Hello"); Matcher<const ::std::wstring&> m2 = StrEq(L"Hello");
EXPECT_TRUE(m2.Matches(L"Hello")); EXPECT_TRUE(m2.Matches(L"Hello"));
@ -1902,7 +1902,7 @@ TEST(StdWideStrEqTest, CanDescribeSelf) {
TEST(StdWideStrNeTest, MatchesUnequalString) { TEST(StdWideStrNeTest, MatchesUnequalString) {
Matcher<const wchar_t*> m = StrNe(L"Hello"); Matcher<const wchar_t*> m = StrNe(L"Hello");
EXPECT_TRUE(m.Matches(L"")); EXPECT_TRUE(m.Matches(L""));
EXPECT_TRUE(m.Matches(NULL)); EXPECT_TRUE(m.Matches(nullptr));
EXPECT_FALSE(m.Matches(L"Hello")); EXPECT_FALSE(m.Matches(L"Hello"));
Matcher< ::std::wstring> m2 = StrNe(::std::wstring(L"Hello")); Matcher< ::std::wstring> m2 = StrNe(::std::wstring(L"Hello"));
@ -1920,7 +1920,7 @@ TEST(StdWideStrCaseEqTest, MatchesEqualStringIgnoringCase) {
EXPECT_TRUE(m.Matches(L"Hello")); EXPECT_TRUE(m.Matches(L"Hello"));
EXPECT_TRUE(m.Matches(L"hello")); EXPECT_TRUE(m.Matches(L"hello"));
EXPECT_FALSE(m.Matches(L"Hi")); EXPECT_FALSE(m.Matches(L"Hi"));
EXPECT_FALSE(m.Matches(NULL)); EXPECT_FALSE(m.Matches(nullptr));
Matcher<const ::std::wstring&> m2 = StrCaseEq(L"Hello"); Matcher<const ::std::wstring&> m2 = StrCaseEq(L"Hello");
EXPECT_TRUE(m2.Matches(L"hello")); EXPECT_TRUE(m2.Matches(L"hello"));
@ -1960,7 +1960,7 @@ TEST(StdWideStrCaseEqTest, CanDescribeSelf) {
TEST(StdWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) { TEST(StdWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) {
Matcher<const wchar_t*> m = StrCaseNe(L"Hello"); Matcher<const wchar_t*> m = StrCaseNe(L"Hello");
EXPECT_TRUE(m.Matches(L"Hi")); EXPECT_TRUE(m.Matches(L"Hi"));
EXPECT_TRUE(m.Matches(NULL)); EXPECT_TRUE(m.Matches(nullptr));
EXPECT_FALSE(m.Matches(L"Hello")); EXPECT_FALSE(m.Matches(L"Hello"));
EXPECT_FALSE(m.Matches(L"hello")); EXPECT_FALSE(m.Matches(L"hello"));
@ -1990,12 +1990,12 @@ TEST(StdWideHasSubstrTest, WorksForCStrings) {
const Matcher<wchar_t*> m1 = HasSubstr(L"foo"); const Matcher<wchar_t*> m1 = HasSubstr(L"foo");
EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food."))); EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food.")));
EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo"))); EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo")));
EXPECT_FALSE(m1.Matches(NULL)); EXPECT_FALSE(m1.Matches(nullptr));
const Matcher<const wchar_t*> m2 = HasSubstr(L"foo"); const Matcher<const wchar_t*> m2 = HasSubstr(L"foo");
EXPECT_TRUE(m2.Matches(L"I love food.")); EXPECT_TRUE(m2.Matches(L"I love food."));
EXPECT_FALSE(m2.Matches(L"tofo")); EXPECT_FALSE(m2.Matches(L"tofo"));
EXPECT_FALSE(m2.Matches(NULL)); EXPECT_FALSE(m2.Matches(nullptr));
} }
// Tests that HasSubstr(s) describes itself properly. // Tests that HasSubstr(s) describes itself properly.
@ -2010,7 +2010,7 @@ TEST(StdWideStartsWithTest, MatchesStringWithGivenPrefix) {
const Matcher<const wchar_t*> m1 = StartsWith(::std::wstring(L"")); const Matcher<const wchar_t*> m1 = StartsWith(::std::wstring(L""));
EXPECT_TRUE(m1.Matches(L"Hi")); EXPECT_TRUE(m1.Matches(L"Hi"));
EXPECT_TRUE(m1.Matches(L"")); EXPECT_TRUE(m1.Matches(L""));
EXPECT_FALSE(m1.Matches(NULL)); EXPECT_FALSE(m1.Matches(nullptr));
const Matcher<const ::std::wstring&> m2 = StartsWith(L"Hi"); const Matcher<const ::std::wstring&> m2 = StartsWith(L"Hi");
EXPECT_TRUE(m2.Matches(L"Hi")); EXPECT_TRUE(m2.Matches(L"Hi"));
@ -2031,7 +2031,7 @@ TEST(StdWideEndsWithTest, MatchesStringWithGivenSuffix) {
const Matcher<const wchar_t*> m1 = EndsWith(L""); const Matcher<const wchar_t*> m1 = EndsWith(L"");
EXPECT_TRUE(m1.Matches(L"Hi")); EXPECT_TRUE(m1.Matches(L"Hi"));
EXPECT_TRUE(m1.Matches(L"")); EXPECT_TRUE(m1.Matches(L""));
EXPECT_FALSE(m1.Matches(NULL)); EXPECT_FALSE(m1.Matches(nullptr));
const Matcher<const ::std::wstring&> m2 = EndsWith(::std::wstring(L"Hi")); const Matcher<const ::std::wstring&> m2 = EndsWith(::std::wstring(L"Hi"));
EXPECT_TRUE(m2.Matches(L"Hi")); EXPECT_TRUE(m2.Matches(L"Hi"));
@ -2053,7 +2053,7 @@ TEST(GlobalWideStrEqTest, MatchesEqual) {
Matcher<const wchar_t*> m = StrEq(::wstring(L"Hello")); Matcher<const wchar_t*> m = StrEq(::wstring(L"Hello"));
EXPECT_TRUE(m.Matches(L"Hello")); EXPECT_TRUE(m.Matches(L"Hello"));
EXPECT_FALSE(m.Matches(L"hello")); EXPECT_FALSE(m.Matches(L"hello"));
EXPECT_FALSE(m.Matches(NULL)); EXPECT_FALSE(m.Matches(nullptr));
Matcher<const ::wstring&> m2 = StrEq(L"Hello"); Matcher<const ::wstring&> m2 = StrEq(L"Hello");
EXPECT_TRUE(m2.Matches(L"Hello")); EXPECT_TRUE(m2.Matches(L"Hello"));
@ -2093,7 +2093,7 @@ TEST(GlobalWideStrEqTest, CanDescribeSelf) {
TEST(GlobalWideStrNeTest, MatchesUnequalString) { TEST(GlobalWideStrNeTest, MatchesUnequalString) {
Matcher<const wchar_t*> m = StrNe(L"Hello"); Matcher<const wchar_t*> m = StrNe(L"Hello");
EXPECT_TRUE(m.Matches(L"")); EXPECT_TRUE(m.Matches(L""));
EXPECT_TRUE(m.Matches(NULL)); EXPECT_TRUE(m.Matches(nullptr));
EXPECT_FALSE(m.Matches(L"Hello")); EXPECT_FALSE(m.Matches(L"Hello"));
Matcher< ::wstring> m2 = StrNe(::wstring(L"Hello")); Matcher< ::wstring> m2 = StrNe(::wstring(L"Hello"));
@ -2111,7 +2111,7 @@ TEST(GlobalWideStrCaseEqTest, MatchesEqualStringIgnoringCase) {
EXPECT_TRUE(m.Matches(L"Hello")); EXPECT_TRUE(m.Matches(L"Hello"));
EXPECT_TRUE(m.Matches(L"hello")); EXPECT_TRUE(m.Matches(L"hello"));
EXPECT_FALSE(m.Matches(L"Hi")); EXPECT_FALSE(m.Matches(L"Hi"));
EXPECT_FALSE(m.Matches(NULL)); EXPECT_FALSE(m.Matches(nullptr));
Matcher<const ::wstring&> m2 = StrCaseEq(L"Hello"); Matcher<const ::wstring&> m2 = StrCaseEq(L"Hello");
EXPECT_TRUE(m2.Matches(L"hello")); EXPECT_TRUE(m2.Matches(L"hello"));
@ -2151,7 +2151,7 @@ TEST(GlobalWideStrCaseEqTest, CanDescribeSelf) {
TEST(GlobalWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) { TEST(GlobalWideStrCaseNeTest, MatchesUnequalStringIgnoringCase) {
Matcher<const wchar_t*> m = StrCaseNe(L"Hello"); Matcher<const wchar_t*> m = StrCaseNe(L"Hello");
EXPECT_TRUE(m.Matches(L"Hi")); EXPECT_TRUE(m.Matches(L"Hi"));
EXPECT_TRUE(m.Matches(NULL)); EXPECT_TRUE(m.Matches(nullptr));
EXPECT_FALSE(m.Matches(L"Hello")); EXPECT_FALSE(m.Matches(L"Hello"));
EXPECT_FALSE(m.Matches(L"hello")); EXPECT_FALSE(m.Matches(L"hello"));
@ -2181,12 +2181,12 @@ TEST(GlobalWideHasSubstrTest, WorksForCStrings) {
const Matcher<wchar_t*> m1 = HasSubstr(L"foo"); const Matcher<wchar_t*> m1 = HasSubstr(L"foo");
EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food."))); EXPECT_TRUE(m1.Matches(const_cast<wchar_t*>(L"I love food.")));
EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo"))); EXPECT_FALSE(m1.Matches(const_cast<wchar_t*>(L"tofo")));
EXPECT_FALSE(m1.Matches(NULL)); EXPECT_FALSE(m1.Matches(nullptr));
const Matcher<const wchar_t*> m2 = HasSubstr(L"foo"); const Matcher<const wchar_t*> m2 = HasSubstr(L"foo");
EXPECT_TRUE(m2.Matches(L"I love food.")); EXPECT_TRUE(m2.Matches(L"I love food."));
EXPECT_FALSE(m2.Matches(L"tofo")); EXPECT_FALSE(m2.Matches(L"tofo"));
EXPECT_FALSE(m2.Matches(NULL)); EXPECT_FALSE(m2.Matches(nullptr));
} }
// Tests that HasSubstr(s) describes itself properly. // Tests that HasSubstr(s) describes itself properly.
@ -2201,7 +2201,7 @@ TEST(GlobalWideStartsWithTest, MatchesStringWithGivenPrefix) {
const Matcher<const wchar_t*> m1 = StartsWith(::wstring(L"")); const Matcher<const wchar_t*> m1 = StartsWith(::wstring(L""));
EXPECT_TRUE(m1.Matches(L"Hi")); EXPECT_TRUE(m1.Matches(L"Hi"));
EXPECT_TRUE(m1.Matches(L"")); EXPECT_TRUE(m1.Matches(L""));
EXPECT_FALSE(m1.Matches(NULL)); EXPECT_FALSE(m1.Matches(nullptr));
const Matcher<const ::wstring&> m2 = StartsWith(L"Hi"); const Matcher<const ::wstring&> m2 = StartsWith(L"Hi");
EXPECT_TRUE(m2.Matches(L"Hi")); EXPECT_TRUE(m2.Matches(L"Hi"));
@ -2222,7 +2222,7 @@ TEST(GlobalWideEndsWithTest, MatchesStringWithGivenSuffix) {
const Matcher<const wchar_t*> m1 = EndsWith(L""); const Matcher<const wchar_t*> m1 = EndsWith(L"");
EXPECT_TRUE(m1.Matches(L"Hi")); EXPECT_TRUE(m1.Matches(L"Hi"));
EXPECT_TRUE(m1.Matches(L"")); EXPECT_TRUE(m1.Matches(L""));
EXPECT_FALSE(m1.Matches(NULL)); EXPECT_FALSE(m1.Matches(nullptr));
const Matcher<const ::wstring&> m2 = EndsWith(::wstring(L"Hi")); const Matcher<const ::wstring&> m2 = EndsWith(::wstring(L"Hi"));
EXPECT_TRUE(m2.Matches(L"Hi")); EXPECT_TRUE(m2.Matches(L"Hi"));
@ -3701,7 +3701,7 @@ TEST(PointeeTest, RawPointer) {
EXPECT_TRUE(m.Matches(&n)); EXPECT_TRUE(m.Matches(&n));
n = -1; n = -1;
EXPECT_FALSE(m.Matches(&n)); EXPECT_FALSE(m.Matches(&n));
EXPECT_FALSE(m.Matches(NULL)); EXPECT_FALSE(m.Matches(nullptr));
} }
TEST(PointeeTest, RawPointerToConst) { TEST(PointeeTest, RawPointerToConst) {
@ -3711,7 +3711,7 @@ TEST(PointeeTest, RawPointerToConst) {
EXPECT_TRUE(m.Matches(&x)); EXPECT_TRUE(m.Matches(&x));
x = -1; x = -1;
EXPECT_FALSE(m.Matches(&x)); EXPECT_FALSE(m.Matches(&x));
EXPECT_FALSE(m.Matches(NULL)); EXPECT_FALSE(m.Matches(nullptr));
} }
TEST(PointeeTest, ReferenceToConstRawPointer) { TEST(PointeeTest, ReferenceToConstRawPointer) {
@ -3721,7 +3721,7 @@ TEST(PointeeTest, ReferenceToConstRawPointer) {
EXPECT_TRUE(m.Matches(&n)); EXPECT_TRUE(m.Matches(&n));
n = -1; n = -1;
EXPECT_FALSE(m.Matches(&n)); EXPECT_FALSE(m.Matches(&n));
EXPECT_FALSE(m.Matches(NULL)); EXPECT_FALSE(m.Matches(nullptr));
} }
TEST(PointeeTest, ReferenceToNonConstRawPointer) { TEST(PointeeTest, ReferenceToNonConstRawPointer) {
@ -3732,7 +3732,7 @@ TEST(PointeeTest, ReferenceToNonConstRawPointer) {
EXPECT_TRUE(m.Matches(p)); EXPECT_TRUE(m.Matches(p));
x = -1; x = -1;
EXPECT_FALSE(m.Matches(p)); EXPECT_FALSE(m.Matches(p));
p = NULL; p = nullptr;
EXPECT_FALSE(m.Matches(p)); EXPECT_FALSE(m.Matches(p));
} }
@ -3771,7 +3771,7 @@ TEST(WhenDynamicCastToTest, WrongTypes) {
TEST(WhenDynamicCastToTest, AlreadyNull) { TEST(WhenDynamicCastToTest, AlreadyNull) {
// Already NULL. // Already NULL.
Base* as_base_ptr = NULL; Base* as_base_ptr = nullptr;
EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull())); EXPECT_THAT(as_base_ptr, WhenDynamicCastTo<Derived*>(IsNull()));
} }
@ -3807,7 +3807,7 @@ TEST(WhenDynamicCastToTest, Describe) {
TEST(WhenDynamicCastToTest, Explain) { TEST(WhenDynamicCastToTest, Explain) {
Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_)); Matcher<Base*> matcher = WhenDynamicCastTo<Derived*>(Pointee(_));
Base* null = NULL; Base* null = nullptr;
EXPECT_THAT(Explain(matcher, null), HasSubstr("NULL")); EXPECT_THAT(Explain(matcher, null), HasSubstr("NULL"));
Derived derived; Derived derived;
EXPECT_TRUE(matcher.Matches(&derived)); EXPECT_TRUE(matcher.Matches(&derived));
@ -3868,7 +3868,7 @@ TEST(PointeeTest, WorksWithConstPropagatingPointers) {
TEST(PointeeTest, NeverMatchesNull) { TEST(PointeeTest, NeverMatchesNull) {
const Matcher<const char*> m = Pointee(_); const Matcher<const char*> m = Pointee(_);
EXPECT_FALSE(m.Matches(NULL)); EXPECT_FALSE(m.Matches(nullptr));
} }
// Tests that we can write Pointee(value) instead of Pointee(Eq(value)). // Tests that we can write Pointee(value) instead of Pointee(Eq(value)).
@ -3879,7 +3879,7 @@ TEST(PointeeTest, MatchesAgainstAValue) {
EXPECT_TRUE(m.Matches(&n)); EXPECT_TRUE(m.Matches(&n));
n = -1; n = -1;
EXPECT_FALSE(m.Matches(&n)); EXPECT_FALSE(m.Matches(&n));
EXPECT_FALSE(m.Matches(NULL)); EXPECT_FALSE(m.Matches(nullptr));
} }
TEST(PointeeTest, CanDescribeSelf) { TEST(PointeeTest, CanDescribeSelf) {
@ -3892,7 +3892,7 @@ TEST(PointeeTest, CanDescribeSelf) {
TEST(PointeeTest, CanExplainMatchResult) { TEST(PointeeTest, CanExplainMatchResult) {
const Matcher<const std::string*> m = Pointee(StartsWith("Hi")); const Matcher<const std::string*> m = Pointee(StartsWith("Hi"));
EXPECT_EQ("", Explain(m, static_cast<const std::string*>(NULL))); EXPECT_EQ("", Explain(m, static_cast<const std::string*>(nullptr)));
const Matcher<long*> m2 = Pointee(GreaterThan(1)); // NOLINT const Matcher<long*> m2 = Pointee(GreaterThan(1)); // NOLINT
long n = 3; // NOLINT long n = 3; // NOLINT
@ -3929,7 +3929,7 @@ MATCHER_P(UncopyableIs, inner_matcher, "") {
// A user-defined struct for testing Field(). // A user-defined struct for testing Field().
struct AStruct { struct AStruct {
AStruct() : x(0), y(1.0), z(5), p(NULL) {} AStruct() : x(0), y(1.0), z(5), p(nullptr) {}
AStruct(const AStruct& rhs) AStruct(const AStruct& rhs)
: x(rhs.x), y(rhs.y), z(rhs.z.value()), p(rhs.p) {} : x(rhs.x), y(rhs.y), z(rhs.z.value()), p(rhs.p) {}
@ -3990,7 +3990,7 @@ TEST(FieldTest, WorksForUncopyableField) {
// Tests that Field(&Foo::field, ...) works when field is a pointer. // Tests that Field(&Foo::field, ...) works when field is a pointer.
TEST(FieldTest, WorksForPointerField) { TEST(FieldTest, WorksForPointerField) {
// Matching against NULL. // Matching against NULL.
Matcher<AStruct> m = Field(&AStruct::p, static_cast<const char*>(NULL)); Matcher<AStruct> m = Field(&AStruct::p, static_cast<const char*>(nullptr));
AStruct a; AStruct a;
EXPECT_TRUE(m.Matches(a)); EXPECT_TRUE(m.Matches(a));
a.p = "hi"; a.p = "hi";
@ -4116,7 +4116,7 @@ TEST(FieldForPointerTest, WorksForReferenceToConstPointer) {
// Tests that Field() does not match the NULL pointer. // Tests that Field() does not match the NULL pointer.
TEST(FieldForPointerTest, DoesNotMatchNull) { TEST(FieldForPointerTest, DoesNotMatchNull) {
Matcher<const AStruct*> m = Field(&AStruct::x, _); Matcher<const AStruct*> m = Field(&AStruct::x, _);
EXPECT_FALSE(m.Matches(NULL)); EXPECT_FALSE(m.Matches(nullptr));
} }
// Tests that Field(&Foo::field, ...) works when the argument's type // Tests that Field(&Foo::field, ...) works when the argument's type
@ -4154,7 +4154,7 @@ TEST(FieldForPointerTest, CanExplainMatchResult) {
AStruct a; AStruct a;
a.x = 1; a.x = 1;
EXPECT_EQ("", Explain(m, static_cast<const AStruct*>(NULL))); EXPECT_EQ("", Explain(m, static_cast<const AStruct*>(nullptr)));
EXPECT_EQ("which points to an object whose given field is 1" + OfType("int"), EXPECT_EQ("which points to an object whose given field is 1" + OfType("int"),
Explain(m, &a)); Explain(m, &a));
@ -4168,7 +4168,7 @@ TEST(FieldForPointerTest, CanExplainMatchResultWithFieldName) {
AStruct a; AStruct a;
a.x = 1; a.x = 1;
EXPECT_EQ("", Explain(m, static_cast<const AStruct*>(NULL))); EXPECT_EQ("", Explain(m, static_cast<const AStruct*>(nullptr)));
EXPECT_EQ( EXPECT_EQ(
"which points to an object whose field `field_name` is 1" + OfType("int"), "which points to an object whose field `field_name` is 1" + OfType("int"),
Explain(m, &a)); Explain(m, &a));
@ -4413,7 +4413,7 @@ TEST(PropertyForPointerTest, WorksForReferenceToConstPointer) {
// Tests that Property() does not match the NULL pointer. // Tests that Property() does not match the NULL pointer.
TEST(PropertyForPointerTest, WorksForReferenceToNonConstProperty) { TEST(PropertyForPointerTest, WorksForReferenceToNonConstProperty) {
Matcher<const AClass*> m = Property(&AClass::x, _); Matcher<const AClass*> m = Property(&AClass::x, _);
EXPECT_FALSE(m.Matches(NULL)); EXPECT_FALSE(m.Matches(nullptr));
} }
// Tests that Property(&Foo::property, ...) works when the argument's // Tests that Property(&Foo::property, ...) works when the argument's
@ -4454,7 +4454,7 @@ TEST(PropertyForPointerTest, CanExplainMatchResult) {
AClass a; AClass a;
a.set_n(1); a.set_n(1);
EXPECT_EQ("", Explain(m, static_cast<const AClass*>(NULL))); EXPECT_EQ("", Explain(m, static_cast<const AClass*>(nullptr)));
EXPECT_EQ( EXPECT_EQ(
"which points to an object whose given property is 1" + OfType("int"), "which points to an object whose given property is 1" + OfType("int"),
Explain(m, &a)); Explain(m, &a));
@ -4470,7 +4470,7 @@ TEST(PropertyForPointerTest, CanExplainMatchResultWithPropertyName) {
AClass a; AClass a;
a.set_n(1); a.set_n(1);
EXPECT_EQ("", Explain(m, static_cast<const AClass*>(NULL))); EXPECT_EQ("", Explain(m, static_cast<const AClass*>(nullptr)));
EXPECT_EQ("which points to an object whose property `fancy_name` is 1" + EXPECT_EQ("which points to an object whose property `fancy_name` is 1" +
OfType("int"), OfType("int"),
Explain(m, &a)); Explain(m, &a));
@ -4581,7 +4581,7 @@ TEST(ResultOfTest, WorksForCompatibleMatcherTypes) {
// a NULL function pointer. // a NULL function pointer.
TEST(ResultOfDeathTest, DiesOnNullFunctionPointers) { TEST(ResultOfDeathTest, DiesOnNullFunctionPointers) {
EXPECT_DEATH_IF_SUPPORTED( EXPECT_DEATH_IF_SUPPORTED(
ResultOf(static_cast<std::string (*)(int dummy)>(NULL), ResultOf(static_cast<std::string (*)(int dummy)>(nullptr),
Eq(std::string("foo"))), Eq(std::string("foo"))),
"NULL function pointer is passed into ResultOf\\(\\)\\."); "NULL function pointer is passed into ResultOf\\(\\)\\.");
} }
@ -6181,7 +6181,7 @@ TEST_P(BipartiteRandomTest, LargerNets) {
testing::internal::Int32 seed = GTEST_FLAG(random_seed); testing::internal::Int32 seed = GTEST_FLAG(random_seed);
if (seed == 0) { if (seed == 0) {
seed = static_cast<testing::internal::Int32>(time(NULL)); seed = static_cast<testing::internal::Int32>(time(nullptr));
} }
for (; iters > 0; --iters, ++seed) { for (; iters > 0; --iters, ++seed) {
@ -6684,7 +6684,7 @@ class SampleVariantIntString {
template <typename T> template <typename T>
friend const T& get(const SampleVariantIntString& value) { friend const T& get(const SampleVariantIntString& value) {
return value.get_impl(static_cast<T*>(NULL)); return value.get_impl(static_cast<T*>(nullptr));
} }
private: private:
@ -6743,7 +6743,7 @@ class SampleAnyType {
template <typename T> template <typename T>
friend const T* any_cast(const SampleAnyType* any) { friend const T* any_cast(const SampleAnyType* any) {
return any->get_impl(static_cast<T*>(NULL)); return any->get_impl(static_cast<T*>(nullptr));
} }
private: private:
@ -6751,9 +6751,9 @@ class SampleAnyType {
int i_; int i_;
std::string s_; std::string s_;
const int* get_impl(int*) const { return index_ == 0 ? &i_ : NULL; } const int* get_impl(int*) const { return index_ == 0 ? &i_ : nullptr; }
const std::string* get_impl(std::string*) const { const std::string* get_impl(std::string*) const {
return index_ == 1 ? &s_ : NULL; return index_ == 1 ? &s_ : nullptr;
} }
}; };

3
googlemock/test/gmock-more-actions_test.cc
View File

@ -333,7 +333,8 @@ TEST(InvokeTest, FunctionWithUnusedParameters) {
Action<int(int, int, bool, int*)> a2 = Action<int(int, int, bool, int*)> a2 =
Invoke(SumOfFirst2); Invoke(SumOfFirst2);
EXPECT_EQ(23, a2.Perform(make_tuple(20, 3, true, static_cast<int*>(NULL)))); EXPECT_EQ(23,
a2.Perform(make_tuple(20, 3, true, static_cast<int*>(nullptr))));
} }
// Tests using Invoke() with methods with parameters declared as Unused. // Tests using Invoke() with methods with parameters declared as Unused.

6
googlemock/test/gmock-spec-builders_test.cc
View File

@ -2041,7 +2041,7 @@ TEST(FunctionCallMessageTest,
GMOCK_FLAG(verbose) = kWarningVerbosity; GMOCK_FLAG(verbose) = kWarningVerbosity;
NaggyMock<MockC> c; NaggyMock<MockC> c;
CaptureStdout(); CaptureStdout();
c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable()); c.VoidMethod(false, 5, "Hi", nullptr, Printable(), Unprintable());
const std::string output = GetCapturedStdout(); const std::string output = GetCapturedStdout();
EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output); EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output);
EXPECT_PRED_FORMAT2(IsNotSubstring, "Stack trace:", output); EXPECT_PRED_FORMAT2(IsNotSubstring, "Stack trace:", output);
@ -2055,7 +2055,7 @@ TEST(FunctionCallMessageTest,
GMOCK_FLAG(verbose) = kInfoVerbosity; GMOCK_FLAG(verbose) = kInfoVerbosity;
NaggyMock<MockC> c; NaggyMock<MockC> c;
CaptureStdout(); CaptureStdout();
c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable()); c.VoidMethod(false, 5, "Hi", nullptr, Printable(), Unprintable());
const std::string output = GetCapturedStdout(); const std::string output = GetCapturedStdout();
EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output); EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", output);
EXPECT_PRED_FORMAT2(IsSubstring, "Stack trace:", output); EXPECT_PRED_FORMAT2(IsSubstring, "Stack trace:", output);
@ -2098,7 +2098,7 @@ TEST(FunctionCallMessageTest,
// A void mock function. // A void mock function.
NaggyMock<MockC> c; NaggyMock<MockC> c;
CaptureStdout(); CaptureStdout();
c.VoidMethod(false, 5, "Hi", NULL, Printable(), Unprintable()); c.VoidMethod(false, 5, "Hi", nullptr, Printable(), Unprintable());
const std::string output2 = GetCapturedStdout(); const std::string output2 = GetCapturedStdout();
EXPECT_THAT(output2.c_str(), EXPECT_THAT(output2.c_str(),
ContainsRegex( ContainsRegex(

38
googlemock/test/gmock_link_test.h
View File

@ -248,7 +248,7 @@ TEST(LinkTest, TestReturnVoid) {
Mock mock; Mock mock;
EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return()); EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
mock.VoidFromString(NULL); mock.VoidFromString(nullptr);
} }
// Tests the linkage of the Return action. // Tests the linkage of the Return action.
@ -257,7 +257,7 @@ TEST(LinkTest, TestReturn) {
char ch = 'x'; char ch = 'x';
EXPECT_CALL(mock, StringFromString(_)).WillOnce(Return(&ch)); EXPECT_CALL(mock, StringFromString(_)).WillOnce(Return(&ch));
mock.StringFromString(NULL); mock.StringFromString(nullptr);
} }
// Tests the linkage of the ReturnNull action. // Tests the linkage of the ReturnNull action.
@ -265,7 +265,7 @@ TEST(LinkTest, TestReturnNull) {
Mock mock; Mock mock;
EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return()); EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Return());
mock.VoidFromString(NULL); mock.VoidFromString(nullptr);
} }
// Tests the linkage of the ReturnRef action. // Tests the linkage of the ReturnRef action.
@ -274,7 +274,7 @@ TEST(LinkTest, TestReturnRef) {
int n = 42; int n = 42;
EXPECT_CALL(mock, IntRefFromString(_)).WillOnce(ReturnRef(n)); EXPECT_CALL(mock, IntRefFromString(_)).WillOnce(ReturnRef(n));
mock.IntRefFromString(NULL); mock.IntRefFromString(nullptr);
} }
// Tests the linkage of the Assign action. // Tests the linkage of the Assign action.
@ -283,7 +283,7 @@ TEST(LinkTest, TestAssign) {
char ch = 'x'; char ch = 'x';
EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Assign(&ch, 'y')); EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Assign(&ch, 'y'));
mock.VoidFromString(NULL); mock.VoidFromString(nullptr);
} }
// Tests the linkage of the SetArgPointee action. // Tests the linkage of the SetArgPointee action.
@ -314,7 +314,7 @@ TEST(LinkTest, TestSetErrnoAndReturn) {
int saved_errno = errno; int saved_errno = errno;
EXPECT_CALL(mock, IntFromString(_)).WillOnce(SetErrnoAndReturn(1, -1)); EXPECT_CALL(mock, IntFromString(_)).WillOnce(SetErrnoAndReturn(1, -1));
mock.IntFromString(NULL); mock.IntFromString(nullptr);
errno = saved_errno; errno = saved_errno;
} }
@ -328,8 +328,8 @@ TEST(LinkTest, TestInvoke) {
EXPECT_CALL(mock, VoidFromString(_)) EXPECT_CALL(mock, VoidFromString(_))
.WillOnce(Invoke(&InvokeHelper::StaticVoidFromString)) .WillOnce(Invoke(&InvokeHelper::StaticVoidFromString))
.WillOnce(Invoke(&test_invoke_helper, &InvokeHelper::VoidFromString)); .WillOnce(Invoke(&test_invoke_helper, &InvokeHelper::VoidFromString));
mock.VoidFromString(NULL); mock.VoidFromString(nullptr);
mock.VoidFromString(NULL); mock.VoidFromString(nullptr);
} }
// Tests the linkage of the InvokeWithoutArgs action. // Tests the linkage of the InvokeWithoutArgs action.
@ -341,8 +341,8 @@ TEST(LinkTest, TestInvokeWithoutArgs) {
.WillOnce(InvokeWithoutArgs(&InvokeHelper::StaticVoidFromVoid)) .WillOnce(InvokeWithoutArgs(&InvokeHelper::StaticVoidFromVoid))
.WillOnce(InvokeWithoutArgs(&test_invoke_helper, .WillOnce(InvokeWithoutArgs(&test_invoke_helper,
&InvokeHelper::VoidFromVoid)); &InvokeHelper::VoidFromVoid));
mock.VoidFromString(NULL); mock.VoidFromString(nullptr);
mock.VoidFromString(NULL); mock.VoidFromString(nullptr);
} }
// Tests the linkage of the InvokeArgument action. // Tests the linkage of the InvokeArgument action.
@ -360,7 +360,7 @@ TEST(LinkTest, TestWithArg) {
EXPECT_CALL(mock, VoidFromString(_)) EXPECT_CALL(mock, VoidFromString(_))
.WillOnce(WithArg<0>(Invoke(&InvokeHelper::StaticVoidFromString))); .WillOnce(WithArg<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
mock.VoidFromString(NULL); mock.VoidFromString(nullptr);
} }
// Tests the linkage of the WithArgs action. // Tests the linkage of the WithArgs action.
@ -369,7 +369,7 @@ TEST(LinkTest, TestWithArgs) {
EXPECT_CALL(mock, VoidFromString(_)) EXPECT_CALL(mock, VoidFromString(_))
.WillOnce(WithArgs<0>(Invoke(&InvokeHelper::StaticVoidFromString))); .WillOnce(WithArgs<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
mock.VoidFromString(NULL); mock.VoidFromString(nullptr);
} }
// Tests the linkage of the WithoutArgs action. // Tests the linkage of the WithoutArgs action.
@ -377,7 +377,7 @@ TEST(LinkTest, TestWithoutArgs) {
Mock mock; Mock mock;
EXPECT_CALL(mock, VoidFromString(_)).WillOnce(WithoutArgs(Return())); EXPECT_CALL(mock, VoidFromString(_)).WillOnce(WithoutArgs(Return()));
mock.VoidFromString(NULL); mock.VoidFromString(nullptr);
} }
// Tests the linkage of the DoAll action. // Tests the linkage of the DoAll action.
@ -405,7 +405,7 @@ TEST(LinkTest, TestIgnoreResult) {
Mock mock; Mock mock;
EXPECT_CALL(mock, VoidFromString(_)).WillOnce(IgnoreResult(Return(42))); EXPECT_CALL(mock, VoidFromString(_)).WillOnce(IgnoreResult(Return(42)));
mock.VoidFromString(NULL); mock.VoidFromString(nullptr);
} }
#if GTEST_HAS_EXCEPTIONS #if GTEST_HAS_EXCEPTIONS
@ -437,7 +437,7 @@ TEST(LinkTest, TestActionMacro) {
Mock mock; Mock mock;
EXPECT_CALL(mock, IntFromString(_)).WillOnce(Return1()); EXPECT_CALL(mock, IntFromString(_)).WillOnce(Return1());
mock.IntFromString(NULL); mock.IntFromString(nullptr);
} }
// Tests the linkage of actions created using ACTION_P macro. // Tests the linkage of actions created using ACTION_P macro.
@ -449,7 +449,7 @@ TEST(LinkTest, TestActionPMacro) {
Mock mock; Mock mock;
EXPECT_CALL(mock, IntFromString(_)).WillOnce(ReturnArgument(42)); EXPECT_CALL(mock, IntFromString(_)).WillOnce(ReturnArgument(42));
mock.IntFromString(NULL); mock.IntFromString(nullptr);
} }
// Tests the linkage of actions created using ACTION_P2 macro. // Tests the linkage of actions created using ACTION_P2 macro.
@ -646,7 +646,7 @@ TEST(LinkTest, TestMatcherProperty) {
// Tests the linkage of the ResultOf matcher. // Tests the linkage of the ResultOf matcher.
TEST(LinkTest, TestMatcherResultOf) { TEST(LinkTest, TestMatcherResultOf) {
Matcher<char*> m = ResultOf(&InvokeHelper::StaticIntFromString, Eq(1)); Matcher<char*> m = ResultOf(&InvokeHelper::StaticIntFromString, Eq(1));
EXPECT_TRUE(m.Matches(NULL)); EXPECT_TRUE(m.Matches(nullptr));
} }
// Tests the linkage of the ResultOf matcher. // Tests the linkage of the ResultOf matcher.
@ -660,7 +660,7 @@ TEST(LinkTest, TestMatcherPointee) {
// Tests the linkage of the Truly matcher. // Tests the linkage of the Truly matcher.
TEST(LinkTest, TestMatcherTruly) { TEST(LinkTest, TestMatcherTruly) {
Matcher<const char*> m = Truly(&InvokeHelper::StaticBoolFromString); Matcher<const char*> m = Truly(&InvokeHelper::StaticBoolFromString);
EXPECT_TRUE(m.Matches(NULL)); EXPECT_TRUE(m.Matches(nullptr));
} }
// Tests the linkage of the AllOf matcher. // Tests the linkage of the AllOf matcher.
@ -684,7 +684,7 @@ TEST(LinkTest, TestMatcherNot) {
// Tests the linkage of the MatcherCast<T>() function. // Tests the linkage of the MatcherCast<T>() function.
TEST(LinkTest, TestMatcherCast) { TEST(LinkTest, TestMatcherCast) {
Matcher<const char*> m = MatcherCast<const char*>(_); Matcher<const char*> m = MatcherCast<const char*>(_);
EXPECT_TRUE(m.Matches(NULL)); EXPECT_TRUE(m.Matches(nullptr));
} }
#endif // GMOCK_TEST_GMOCK_LINK_TEST_H_ #endif // GMOCK_TEST_GMOCK_LINK_TEST_H_

8
googlemock/test/gmock_stress_test.cc
View File

@ -210,7 +210,7 @@ void TestConcurrentCallsOnSameObject(Dummy /* dummy */) {
int count1 = 0; int count1 = 0;
const Helper1Param param = { &foo, &count1 }; const Helper1Param param = { &foo, &count1 };
ThreadWithParam<Helper1Param>* const t = ThreadWithParam<Helper1Param>* const t =
new ThreadWithParam<Helper1Param>(Helper1, param, NULL); new ThreadWithParam<Helper1Param>(Helper1, param, nullptr);
int count2 = 0; int count2 = 0;
const Helper1Param param2 = { &foo, &count2 }; const Helper1Param param2 = { &foo, &count2 };
@ -264,7 +264,7 @@ void TestPartiallyOrderedExpectationsWithThreads(Dummy /* dummy */) {
foo.Bar(1); foo.Bar(1);
ThreadWithParam<MockFoo*>* const t = ThreadWithParam<MockFoo*>* const t =
new ThreadWithParam<MockFoo*>(Helper2, &foo, NULL); new ThreadWithParam<MockFoo*>(Helper2, &foo, nullptr);
Helper2(&foo); Helper2(&foo);
JoinAndDelete(t); JoinAndDelete(t);
@ -288,8 +288,8 @@ TEST(StressTest, CanUseGMockWithThreads) {
ThreadWithParam<Dummy>* threads[kTestThreads] = {}; ThreadWithParam<Dummy>* threads[kTestThreads] = {};
for (int i = 0; i < kTestThreads; i++) { for (int i = 0; i < kTestThreads; i++) {
// Creates a thread to run the test function. // Creates a thread to run the test function.
threads[i] = threads[i] = new ThreadWithParam<Dummy>(test_routines[i % kRoutines],
new ThreadWithParam<Dummy>(test_routines[i % kRoutines], Dummy(), NULL); Dummy(), nullptr);
GTEST_LOG_(INFO) << "Thread #" << i << " running . . ."; GTEST_LOG_(INFO) << "Thread #" << i << " running . . .";
} }

136
googlemock/test/gmock_test.cc
View File

@ -64,59 +64,35 @@ void TestInitGoogleMock(const Char* (&argv)[M], const Char* (&new_argv)[N],
} }
TEST(InitGoogleMockTest, ParsesInvalidCommandLine) { TEST(InitGoogleMockTest, ParsesInvalidCommandLine) {
const char* argv[] = { const char* argv[] = {nullptr};
NULL
};
const char* new_argv[] = { const char* new_argv[] = {nullptr};
NULL
};
TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose)); TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
} }
TEST(InitGoogleMockTest, ParsesEmptyCommandLine) { TEST(InitGoogleMockTest, ParsesEmptyCommandLine) {
const char* argv[] = { const char* argv[] = {"foo.exe", nullptr};
"foo.exe",
NULL
};
const char* new_argv[] = { const char* new_argv[] = {"foo.exe", nullptr};
"foo.exe",
NULL
};
TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose)); TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
} }
TEST(InitGoogleMockTest, ParsesSingleFlag) { TEST(InitGoogleMockTest, ParsesSingleFlag) {
const char* argv[] = { const char* argv[] = {"foo.exe", "--gmock_verbose=info", nullptr};
"foo.exe",
"--gmock_verbose=info",
NULL
};
const char* new_argv[] = { const char* new_argv[] = {"foo.exe", nullptr};
"foo.exe",
NULL
};
TestInitGoogleMock(argv, new_argv, "info"); TestInitGoogleMock(argv, new_argv, "info");
} }
TEST(InitGoogleMockTest, ParsesMultipleFlags) { TEST(InitGoogleMockTest, ParsesMultipleFlags) {
int old_default_behavior = GMOCK_FLAG(default_mock_behavior); int old_default_behavior = GMOCK_FLAG(default_mock_behavior);
const wchar_t* argv[] = { const wchar_t* argv[] = {L"foo.exe", L"--gmock_verbose=info",
L"foo.exe", L"--gmock_default_mock_behavior=2", nullptr};
L"--gmock_verbose=info",
L"--gmock_default_mock_behavior=2",
NULL
};
const wchar_t* new_argv[] = { const wchar_t* new_argv[] = {L"foo.exe", nullptr};
L"foo.exe",
NULL
};
TestInitGoogleMock(argv, new_argv, "info"); TestInitGoogleMock(argv, new_argv, "info");
EXPECT_EQ(2, GMOCK_FLAG(default_mock_behavior)); EXPECT_EQ(2, GMOCK_FLAG(default_mock_behavior));
@ -125,92 +101,52 @@ TEST(InitGoogleMockTest, ParsesMultipleFlags) {
} }
TEST(InitGoogleMockTest, ParsesUnrecognizedFlag) { TEST(InitGoogleMockTest, ParsesUnrecognizedFlag) {
const char* argv[] = { const char* argv[] = {"foo.exe", "--non_gmock_flag=blah", nullptr};
"foo.exe",
"--non_gmock_flag=blah",
NULL
};
const char* new_argv[] = { const char* new_argv[] = {"foo.exe", "--non_gmock_flag=blah", nullptr};
"foo.exe",
"--non_gmock_flag=blah",
NULL
};
TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose)); TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
} }
TEST(InitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) { TEST(InitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
const char* argv[] = { const char* argv[] = {"foo.exe", "--non_gmock_flag=blah",
"foo.exe", "--gmock_verbose=error", nullptr};
"--non_gmock_flag=blah",
"--gmock_verbose=error",
NULL
};
const char* new_argv[] = { const char* new_argv[] = {"foo.exe", "--non_gmock_flag=blah", nullptr};
"foo.exe",
"--non_gmock_flag=blah",
NULL
};
TestInitGoogleMock(argv, new_argv, "error"); TestInitGoogleMock(argv, new_argv, "error");
} }
TEST(WideInitGoogleMockTest, ParsesInvalidCommandLine) { TEST(WideInitGoogleMockTest, ParsesInvalidCommandLine) {
const wchar_t* argv[] = { const wchar_t* argv[] = {nullptr};
NULL
};
const wchar_t* new_argv[] = { const wchar_t* new_argv[] = {nullptr};
NULL
};
TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose)); TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
} }
TEST(WideInitGoogleMockTest, ParsesEmptyCommandLine) { TEST(WideInitGoogleMockTest, ParsesEmptyCommandLine) {
const wchar_t* argv[] = { const wchar_t* argv[] = {L"foo.exe", nullptr};
L"foo.exe",
NULL
};
const wchar_t* new_argv[] = { const wchar_t* new_argv[] = {L"foo.exe", nullptr};
L"foo.exe",
NULL
};
TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose)); TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
} }
TEST(WideInitGoogleMockTest, ParsesSingleFlag) { TEST(WideInitGoogleMockTest, ParsesSingleFlag) {
const wchar_t* argv[] = { const wchar_t* argv[] = {L"foo.exe", L"--gmock_verbose=info", nullptr};
L"foo.exe",
L"--gmock_verbose=info",
NULL
};
const wchar_t* new_argv[] = { const wchar_t* new_argv[] = {L"foo.exe", nullptr};
L"foo.exe",
NULL
};
TestInitGoogleMock(argv, new_argv, "info"); TestInitGoogleMock(argv, new_argv, "info");
} }
TEST(WideInitGoogleMockTest, ParsesMultipleFlags) { TEST(WideInitGoogleMockTest, ParsesMultipleFlags) {
int old_default_behavior = GMOCK_FLAG(default_mock_behavior); int old_default_behavior = GMOCK_FLAG(default_mock_behavior);
const wchar_t* argv[] = { const wchar_t* argv[] = {L"foo.exe", L"--gmock_verbose=info",
L"foo.exe", L"--gmock_default_mock_behavior=2", nullptr};
L"--gmock_verbose=info",
L"--gmock_default_mock_behavior=2",
NULL
};
const wchar_t* new_argv[] = { const wchar_t* new_argv[] = {L"foo.exe", nullptr};
L"foo.exe",
NULL
};
TestInitGoogleMock(argv, new_argv, "info"); TestInitGoogleMock(argv, new_argv, "info");
EXPECT_EQ(2, GMOCK_FLAG(default_mock_behavior)); EXPECT_EQ(2, GMOCK_FLAG(default_mock_behavior));
@ -219,34 +155,18 @@ TEST(WideInitGoogleMockTest, ParsesMultipleFlags) {
} }
TEST(WideInitGoogleMockTest, ParsesUnrecognizedFlag) { TEST(WideInitGoogleMockTest, ParsesUnrecognizedFlag) {
const wchar_t* argv[] = { const wchar_t* argv[] = {L"foo.exe", L"--non_gmock_flag=blah", nullptr};
L"foo.exe",
L"--non_gmock_flag=blah",
NULL
};
const wchar_t* new_argv[] = { const wchar_t* new_argv[] = {L"foo.exe", L"--non_gmock_flag=blah", nullptr};
L"foo.exe",
L"--non_gmock_flag=blah",
NULL
};
TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose)); TestInitGoogleMock(argv, new_argv, GMOCK_FLAG(verbose));
} }
TEST(WideInitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) { TEST(WideInitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
const wchar_t* argv[] = { const wchar_t* argv[] = {L"foo.exe", L"--non_gmock_flag=blah",
L"foo.exe", L"--gmock_verbose=error", nullptr};
L"--non_gmock_flag=blah",
L"--gmock_verbose=error",
NULL
};
const wchar_t* new_argv[] = { const wchar_t* new_argv[] = {L"foo.exe", L"--non_gmock_flag=blah", nullptr};
L"foo.exe",
L"--non_gmock_flag=blah",
NULL
};
TestInitGoogleMock(argv, new_argv, "error"); TestInitGoogleMock(argv, new_argv, "error");
} }

2
googletest/include/gtest/gtest-message.h
View File

@ -151,7 +151,7 @@ class GTEST_API_ Message {
// as "(null)". // as "(null)".
template <typename T> template <typename T>
inline Message& operator <<(T* const& pointer) { // NOLINT inline Message& operator <<(T* const& pointer) { // NOLINT
if (pointer == NULL) { if (pointer == nullptr) {
*ss_ << "(null)"; *ss_ << "(null)";
} else { } else {
*ss_ << pointer; *ss_ << pointer;

8
googletest/include/gtest/gtest-printers.h
View File

@ -449,7 +449,7 @@ void DefaultPrintTo(WrapPrinterType<kPrintContainer> /* dummy */,
template <typename T> template <typename T>
void DefaultPrintTo(WrapPrinterType<kPrintPointer> /* dummy */, void DefaultPrintTo(WrapPrinterType<kPrintPointer> /* dummy */,
T* p, ::std::ostream* os) { T* p, ::std::ostream* os) {
if (p == NULL) { if (p == nullptr) {
*os << "NULL"; *os << "NULL";
} else { } else {
// T is not a function type. We just call << to print p, // T is not a function type. We just call << to print p,
@ -461,7 +461,7 @@ void DefaultPrintTo(WrapPrinterType<kPrintPointer> /* dummy */,
template <typename T> template <typename T>
void DefaultPrintTo(WrapPrinterType<kPrintFunctionPointer> /* dummy */, void DefaultPrintTo(WrapPrinterType<kPrintFunctionPointer> /* dummy */,
T* p, ::std::ostream* os) { T* p, ::std::ostream* os) {
if (p == NULL) { if (p == nullptr) {
*os << "NULL"; *os << "NULL";
} else { } else {
// T is a function type, so '*os << p' doesn't do what we want // T is a function type, so '*os << p' doesn't do what we want
@ -914,7 +914,7 @@ template <>
class UniversalTersePrinter<const char*> { class UniversalTersePrinter<const char*> {
public: public:
static void Print(const char* str, ::std::ostream* os) { static void Print(const char* str, ::std::ostream* os) {
if (str == NULL) { if (str == nullptr) {
*os << "NULL"; *os << "NULL";
} else { } else {
UniversalPrint(std::string(str), os); UniversalPrint(std::string(str), os);
@ -934,7 +934,7 @@ template <>
class UniversalTersePrinter<const wchar_t*> { class UniversalTersePrinter<const wchar_t*> {
public: public:
static void Print(const wchar_t* str, ::std::ostream* os) { static void Print(const wchar_t* str, ::std::ostream* os) {
if (str == NULL) { if (str == nullptr) {
*os << "NULL"; *os << "NULL";
} else { } else {
UniversalPrint(::std::wstring(str), os); UniversalPrint(::std::wstring(str), os);

11
googletest/include/gtest/gtest-test-part.h
View File

@ -60,16 +60,13 @@ class GTEST_API_ TestPartResult {
// C'tor. TestPartResult does NOT have a default constructor. // C'tor. TestPartResult does NOT have a default constructor.
// Always use this constructor (with parameters) to create a // Always use this constructor (with parameters) to create a
// TestPartResult object. // TestPartResult object.
TestPartResult(Type a_type, TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
const char* a_file_name,
int a_line_number,
const char* a_message) const char* a_message)
: type_(a_type), : type_(a_type),
file_name_(a_file_name == NULL ? "" : a_file_name), file_name_(a_file_name == nullptr ? "" : a_file_name),
line_number_(a_line_number), line_number_(a_line_number),
summary_(ExtractSummary(a_message)), summary_(ExtractSummary(a_message)),
message_(a_message) { message_(a_message) {}
}
// Gets the outcome of the test part. // Gets the outcome of the test part.
Type type() const { return type_; } Type type() const { return type_; }
@ -77,7 +74,7 @@ class GTEST_API_ TestPartResult {
// Gets the name of the source file where the test part took place, or // Gets the name of the source file where the test part took place, or
// NULL if it's unknown. // NULL if it's unknown.
const char* file_name() const { const char* file_name() const {
return file_name_.empty() ? NULL : file_name_.c_str(); return file_name_.empty() ? nullptr : file_name_.c_str();
} }
// Gets the line in the source file where the test part took place, // Gets the line in the source file where the test part took place,

41
googletest/include/gtest/gtest.h
View File

@ -300,7 +300,8 @@ class GTEST_API_ AssertionResult {
const T& success, const T& success,
typename internal::EnableIf< typename internal::EnableIf<
!internal::ImplicitlyConvertible<T, AssertionResult>::value>::type* !internal::ImplicitlyConvertible<T, AssertionResult>::value>::type*
/*enabler*/ = NULL) /*enabler*/
= nullptr)
: success_(success) {} : success_(success) {}
#if defined(_MSC_VER) && _MSC_VER < 1910 #if defined(_MSC_VER) && _MSC_VER < 1910
@ -324,7 +325,7 @@ class GTEST_API_ AssertionResult {
// assertion's expectation). When nothing has been streamed into the // assertion's expectation). When nothing has been streamed into the
// object, returns an empty string. // object, returns an empty string.
const char* message() const { const char* message() const {
return message_.get() != NULL ? message_->c_str() : ""; return message_.get() != nullptr ? message_->c_str() : "";
} }
// FIXME: Remove this after making sure no clients use it. // FIXME: Remove this after making sure no clients use it.
// Deprecated; please use message() instead. // Deprecated; please use message() instead.
@ -347,8 +348,7 @@ class GTEST_API_ AssertionResult {
private: private:
// Appends the contents of message to message_. // Appends the contents of message to message_.
void AppendMessage(const Message& a_message) { void AppendMessage(const Message& a_message) {
if (message_.get() == NULL) if (message_.get() == nullptr) message_.reset(new ::std::string);
message_.reset(new ::std::string);
message_->append(a_message.GetString().c_str()); message_->append(a_message.GetString().c_str());
} }
@ -512,7 +512,7 @@ class GTEST_API_ Test {
// If you see an error about overriding the following function or // If you see an error about overriding the following function or
// about it being private, you have mis-spelled SetUp() as Setup(). // about it being private, you have mis-spelled SetUp() as Setup().
struct Setup_should_be_spelled_SetUp {}; struct Setup_should_be_spelled_SetUp {};
virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; } virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
// We disallow copying Tests. // We disallow copying Tests.
GTEST_DISALLOW_COPY_AND_ASSIGN_(Test); GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
@ -700,17 +700,15 @@ class GTEST_API_ TestInfo {
// Returns the name of the parameter type, or NULL if this is not a typed // Returns the name of the parameter type, or NULL if this is not a typed
// or a type-parameterized test. // or a type-parameterized test.
const char* type_param() const { const char* type_param() const {
if (type_param_.get() != NULL) if (type_param_.get() != nullptr) return type_param_->c_str();
return type_param_->c_str(); return nullptr;
return NULL;
} }
// Returns the text representation of the value parameter, or NULL if this // Returns the text representation of the value parameter, or NULL if this
// is not a value-parameterized test. // is not a value-parameterized test.
const char* value_param() const { const char* value_param() const {
if (value_param_.get() != NULL) if (value_param_.get() != nullptr) return value_param_->c_str();
return value_param_->c_str(); return nullptr;
return NULL;
} }
// Returns the file name where this test is defined. // Returns the file name where this test is defined.
@ -849,9 +847,8 @@ class GTEST_API_ TestCase {
// Returns the name of the parameter type, or NULL if this is not a // Returns the name of the parameter type, or NULL if this is not a
// type-parameterized test case. // type-parameterized test case.
const char* type_param() const { const char* type_param() const {
if (type_param_.get() != NULL) if (type_param_.get() != nullptr) return type_param_->c_str();
return type_param_->c_str(); return nullptr;
return NULL;
} }
// Returns true if any test in this test case should run. // Returns true if any test in this test case should run.
@ -1038,7 +1035,7 @@ class Environment {
// If you see an error about overriding the following function or // If you see an error about overriding the following function or
// about it being private, you have mis-spelled SetUp() as Setup(). // about it being private, you have mis-spelled SetUp() as Setup().
struct Setup_should_be_spelled_SetUp {}; struct Setup_should_be_spelled_SetUp {};
virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; } virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
}; };
#if GTEST_HAS_EXCEPTIONS #if GTEST_HAS_EXCEPTIONS
@ -1514,16 +1511,14 @@ class EqHelper<true> {
// EXPECT_EQ(false, a_bool). // EXPECT_EQ(false, a_bool).
template <typename T1, typename T2> template <typename T1, typename T2>
static AssertionResult Compare( static AssertionResult Compare(
const char* lhs_expression, const char* lhs_expression, const char* rhs_expression, const T1& lhs,
const char* rhs_expression,
const T1& lhs,
const T2& rhs, const T2& rhs,
// The following line prevents this overload from being considered if T2 // The following line prevents this overload from being considered if T2
// is not a pointer type. We need this because ASSERT_EQ(NULL, my_ptr) // is not a pointer type. We need this because ASSERT_EQ(NULL, my_ptr)
// expands to Compare("", "", NULL, my_ptr), which requires a conversion // expands to Compare("", "", NULL, my_ptr), which requires a conversion
// to match the Secret* in the other overload, which would otherwise make // to match the Secret* in the other overload, which would otherwise make
// this template match better. // this template match better.
typename EnableIf<!is_pointer<T2>::value>::type* = 0) { typename EnableIf<!is_pointer<T2>::value>::type* = nullptr) {
return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs); return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
} }
@ -1542,8 +1537,8 @@ class EqHelper<true> {
Secret* /* lhs (NULL) */, Secret* /* lhs (NULL) */,
T* rhs) { T* rhs) {
// We already know that 'lhs' is a null pointer. // We already know that 'lhs' is a null pointer.
return CmpHelperEQ(lhs_expression, rhs_expression, return CmpHelperEQ(lhs_expression, rhs_expression, static_cast<T*>(nullptr),
static_cast<T*>(NULL), rhs); rhs);
} }
}; };
@ -1817,7 +1812,7 @@ class WithParamInterface {
// The current parameter value. Is also available in the test fixture's // The current parameter value. Is also available in the test fixture's
// constructor. // constructor.
static const ParamType& GetParam() { static const ParamType& GetParam() {
GTEST_CHECK_(parameter_ != NULL) GTEST_CHECK_(parameter_ != nullptr)
<< "GetParam() can only be called inside a value-parameterized test " << "GetParam() can only be called inside a value-parameterized test "
<< "-- did you intend to write TEST_P instead of TEST_F?"; << "-- did you intend to write TEST_P instead of TEST_F?";
return *parameter_; return *parameter_;
@ -1838,7 +1833,7 @@ class WithParamInterface {
}; };
template <typename T> template <typename T>
const T* WithParamInterface<T>::parameter_ = NULL; const T* WithParamInterface<T>::parameter_ = nullptr;
// Most value-parameterized classes can ignore the existence of // Most value-parameterized classes can ignore the existence of
// WithParamInterface, and can just inherit from ::testing::TestWithParam. // WithParamInterface, and can just inherit from ::testing::TestWithParam.

10
googletest/include/gtest/internal/gtest-internal.h
View File

@ -587,8 +587,8 @@ GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
// returns NULL if no comma is found in 'str'. // returns NULL if no comma is found in 'str'.
inline const char* SkipComma(const char* str) { inline const char* SkipComma(const char* str) {
const char* comma = strchr(str, ','); const char* comma = strchr(str, ',');
if (comma == NULL) { if (comma == nullptr) {
return NULL; return nullptr;
} }
while (IsSpace(*(++comma))) {} while (IsSpace(*(++comma))) {}
return comma; return comma;
@ -598,7 +598,7 @@ inline const char* SkipComma(const char* str) {
// the entire string if it contains no comma. // the entire string if it contains no comma.
inline std::string GetPrefixUntilComma(const char* str) { inline std::string GetPrefixUntilComma(const char* str) {
const char* comma = strchr(str, ','); const char* comma = strchr(str, ',');
return comma == NULL ? str : std::string(str, comma); return comma == nullptr ? str : std::string(str, comma);
} }
// Splits a given string on a given delimiter, populating a given // Splits a given string on a given delimiter, populating a given
@ -667,7 +667,7 @@ class TypeParameterizedTest {
.c_str(), .c_str(),
StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(), StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
GetTypeName<Type>().c_str(), GetTypeName<Type>().c_str(),
NULL, // No value parameter. nullptr, // No value parameter.
code_location, GetTypeId<FixtureClass>(), TestClass::SetUpTestCase, code_location, GetTypeId<FixtureClass>(), TestClass::SetUpTestCase,
TestClass::TearDownTestCase, new TestFactoryImpl<TestClass>); TestClass::TearDownTestCase, new TestFactoryImpl<TestClass>);
@ -980,7 +980,7 @@ struct IsHashTable {
static char test(...); static char test(...);
public: public:
static const bool value = sizeof(test<T>(0, 0)) == sizeof(int); static const bool value = sizeof(test<T>(nullptr, nullptr)) == sizeof(int);
}; };
template <typename T> template <typename T>

4
googletest/include/gtest/internal/gtest-linked_ptr.h
View File

@ -149,7 +149,7 @@ class linked_ptr {
// Take over ownership of a raw pointer. This should happen as soon as // Take over ownership of a raw pointer. This should happen as soon as
// possible after the object is created. // possible after the object is created.
explicit linked_ptr(T* ptr = NULL) { capture(ptr); } explicit linked_ptr(T* ptr = nullptr) { capture(ptr); }
~linked_ptr() { depart(); } ~linked_ptr() { depart(); }
// Copy an existing linked_ptr<>, adding ourselves to the list of references. // Copy an existing linked_ptr<>, adding ourselves to the list of references.
@ -175,7 +175,7 @@ class linked_ptr {
} }
// Smart pointer members. // Smart pointer members.
void reset(T* ptr = NULL) { void reset(T* ptr = nullptr) {
depart(); depart();
capture(ptr); capture(ptr);
} }

18
googletest/include/gtest/internal/gtest-param-util.h
View File

@ -327,8 +327,7 @@ class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
// detect that fact. The client code, on the other hand, is // detect that fact. The client code, on the other hand, is
// responsible for not calling Current() on an out-of-range iterator. // responsible for not calling Current() on an out-of-range iterator.
virtual const T* Current() const { virtual const T* Current() const {
if (value_.get() == NULL) if (value_.get() == nullptr) value_.reset(new T(*iterator_));
value_.reset(new T(*iterator_));
return value_.get(); return value_.get();
} }
virtual bool Equals(const ParamIteratorInterface<T>& other) const { virtual bool Equals(const ParamIteratorInterface<T>& other) const {
@ -579,13 +578,10 @@ class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
test_name_stream << test_info->test_base_name << "/" << param_name; test_name_stream << test_info->test_base_name << "/" << param_name;
MakeAndRegisterTestInfo( MakeAndRegisterTestInfo(
test_case_name.c_str(), test_case_name.c_str(), test_name_stream.GetString().c_str(),
test_name_stream.GetString().c_str(), nullptr, // No type parameter.
NULL, // No type parameter. PrintToString(*param_it).c_str(), code_location_,
PrintToString(*param_it).c_str(), GetTestCaseTypeId(), TestCase::SetUpTestCase,
code_location_,
GetTestCaseTypeId(),
TestCase::SetUpTestCase,
TestCase::TearDownTestCase, TestCase::TearDownTestCase,
test_info->test_meta_factory->CreateTestFactory(*param_it)); test_info->test_meta_factory->CreateTestFactory(*param_it));
} // for param_it } // for param_it
@ -676,7 +672,7 @@ class ParameterizedTestCaseRegistry {
ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder( ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
const char* test_case_name, const char* test_case_name,
CodeLocation code_location) { CodeLocation code_location) {
ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL; ParameterizedTestCaseInfo<TestCase>* typed_test_info = nullptr;
for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
it != test_case_infos_.end(); ++it) { it != test_case_infos_.end(); ++it) {
if ((*it)->GetTestCaseName() == test_case_name) { if ((*it)->GetTestCaseName() == test_case_name) {
@ -696,7 +692,7 @@ class ParameterizedTestCaseRegistry {
break; break;
} }
} }
if (typed_test_info == NULL) { if (typed_test_info == nullptr) {
typed_test_info = new ParameterizedTestCaseInfo<TestCase>( typed_test_info = new ParameterizedTestCaseInfo<TestCase>(
test_case_name, code_location); test_case_name, code_location);
test_case_infos_.push_back(typed_test_info); test_case_infos_.push_back(typed_test_info);

27
googletest/include/gtest/internal/gtest-port.h
View File

@ -1197,7 +1197,7 @@ class scoped_ptr {
public: public:
typedef T element_type; typedef T element_type;
explicit scoped_ptr(T* p = NULL) : ptr_(p) {} explicit scoped_ptr(T* p = nullptr) : ptr_(p) {}
~scoped_ptr() { reset(); } ~scoped_ptr() { reset(); }
T& operator*() const { return *ptr_; } T& operator*() const { return *ptr_; }
@ -1206,11 +1206,11 @@ class scoped_ptr {
T* release() { T* release() {
T* const ptr = ptr_; T* const ptr = ptr_;
ptr_ = NULL; ptr_ = nullptr;
return ptr; return ptr;
} }
void reset(T* p = NULL) { void reset(T* p = nullptr) {
if (p != ptr_) { if (p != ptr_) {
if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type. if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type.
delete ptr_; delete ptr_;
@ -1360,7 +1360,7 @@ class GTEST_API_ GTestLog {
__FILE__, __LINE__).GetStream() __FILE__, __LINE__).GetStream()
inline void LogToStderr() {} inline void LogToStderr() {}
inline void FlushInfoLog() { fflush(NULL); } inline void FlushInfoLog() { fflush(nullptr); }
#endif // !defined(GTEST_LOG_) #endif // !defined(GTEST_LOG_)
@ -1511,7 +1511,7 @@ inline To DownCast_(From* f) { // so we only accept pointers
#if GTEST_HAS_RTTI #if GTEST_HAS_RTTI
// RTTI: debug mode only! // RTTI: debug mode only!
GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL); GTEST_CHECK_(f == nullptr || dynamic_cast<To>(f) != NULL);
#endif #endif
return static_cast<To>(f); return static_cast<To>(f);
} }
@ -1583,7 +1583,7 @@ inline void SleepMilliseconds(int n) {
0, // 0 seconds. 0, // 0 seconds.
n * 1000L * 1000L, // And n ms. n * 1000L * 1000L, // And n ms.
}; };
nanosleep(&time, NULL); nanosleep(&time, nullptr);
} }
# endif // GTEST_HAS_PTHREAD # endif // GTEST_HAS_PTHREAD
@ -1601,7 +1601,7 @@ inline void SleepMilliseconds(int n) {
class Notification { class Notification {
public: public:
Notification() : notified_(false) { Notification() : notified_(false) {
GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
} }
~Notification() { ~Notification() {
pthread_mutex_destroy(&mutex_); pthread_mutex_destroy(&mutex_);
@ -1710,7 +1710,7 @@ class ThreadWithParamBase {
// pass into pthread_create(). // pass into pthread_create().
extern "C" inline void* ThreadFuncWithCLinkage(void* thread) { extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
static_cast<ThreadWithParamBase*>(thread)->Run(); static_cast<ThreadWithParamBase*>(thread)->Run();
return NULL; return nullptr;
} }
// Helper class for testing Google Test's multi-threading constructs. // Helper class for testing Google Test's multi-threading constructs.
@ -1739,20 +1739,19 @@ class ThreadWithParam : public ThreadWithParamBase {
// The thread can be created only after all fields except thread_ // The thread can be created only after all fields except thread_
// have been initialized. // have been initialized.
GTEST_CHECK_POSIX_SUCCESS_( GTEST_CHECK_POSIX_SUCCESS_(
pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base)); pthread_create(&thread_, nullptr, &ThreadFuncWithCLinkage, base));
} }
~ThreadWithParam() { Join(); } ~ThreadWithParam() { Join(); }
void Join() { void Join() {
if (!finished_) { if (!finished_) {
GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0)); GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, nullptr));
finished_ = true; finished_ = true;
} }
} }
virtual void Run() { virtual void Run() {
if (thread_can_start_ != NULL) if (thread_can_start_ != nullptr) thread_can_start_->WaitForNotification();
thread_can_start_->WaitForNotification();
func_(param_); func_(param_);
} }
@ -2115,7 +2114,7 @@ class MutexBase {
class Mutex : public MutexBase { class Mutex : public MutexBase {
public: public:
Mutex() { Mutex() {
GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
has_owner_ = false; has_owner_ = false;
} }
~Mutex() { ~Mutex() {
@ -2213,7 +2212,7 @@ class GTEST_API_ ThreadLocal {
T* GetOrCreateValue() const { T* GetOrCreateValue() const {
ThreadLocalValueHolderBase* const holder = ThreadLocalValueHolderBase* const holder =
static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_)); static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
if (holder != NULL) { if (holder != nullptr) {
return CheckedDowncastToActualType<ValueHolder>(holder)->pointer(); return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
} }

2
googletest/include/gtest/internal/gtest-type-util.h
View File

@ -89,7 +89,7 @@ std::string GetTypeName() {
# if GTEST_HAS_CXXABI_H_ # if GTEST_HAS_CXXABI_H_
using abi::__cxa_demangle; using abi::__cxa_demangle;
# endif // GTEST_HAS_CXXABI_H_ # endif // GTEST_HAS_CXXABI_H_
char* const readable_name = __cxa_demangle(name, 0, 0, &status); char* const readable_name = __cxa_demangle(name, nullptr, nullptr, &status);
const std::string name_str(status == 0 ? readable_name : name); const std::string name_str(status == 0 ? readable_name : name);
free(readable_name); free(readable_name);
return CanonicalizeForStdLibVersioning(name_str); return CanonicalizeForStdLibVersioning(name_str);

2
googletest/samples/sample10_unittest.cc
View File

@ -100,7 +100,7 @@ TEST(ListenersTest, DoesNotLeak) {
// specified. // specified.
TEST(ListenersTest, LeaksWater) { TEST(ListenersTest, LeaksWater) {
Water* water = new Water; Water* water = new Water;
EXPECT_TRUE(water != NULL); EXPECT_TRUE(water != nullptr);
} }
} // namespace } // namespace

2
googletest/samples/sample2.cc
View File

@ -35,7 +35,7 @@
// Clones a 0-terminated C string, allocating memory using new. // Clones a 0-terminated C string, allocating memory using new.
const char* MyString::CloneCString(const char* a_c_string) { const char* MyString::CloneCString(const char* a_c_string) {
if (a_c_string == NULL) return NULL; if (a_c_string == nullptr) return nullptr;
const size_t len = strlen(a_c_string); const size_t len = strlen(a_c_string);
char* const clone = new char[ len + 1 ]; char* const clone = new char[ len + 1 ];

10
googletest/samples/sample2.h
View File

@ -50,15 +50,15 @@ class MyString {
// C'tors // C'tors
// The default c'tor constructs a NULL string. // The default c'tor constructs a NULL string.
MyString() : c_string_(NULL) {} MyString() : c_string_(nullptr) {}
// Constructs a MyString by cloning a 0-terminated C string. // Constructs a MyString by cloning a 0-terminated C string.
explicit MyString(const char* a_c_string) : c_string_(NULL) { explicit MyString(const char* a_c_string) : c_string_(nullptr) {
Set(a_c_string); Set(a_c_string);
} }
// Copy c'tor // Copy c'tor
MyString(const MyString& string) : c_string_(NULL) { MyString(const MyString& string) : c_string_(nullptr) {
Set(string.c_string_); Set(string.c_string_);
} }
@ -71,9 +71,7 @@ class MyString {
// Gets the 0-terminated C string this MyString object represents. // Gets the 0-terminated C string this MyString object represents.
const char* c_string() const { return c_string_; } const char* c_string() const { return c_string_; }
size_t Length() const { size_t Length() const { return c_string_ == nullptr ? 0 : strlen(c_string_); }
return c_string_ == NULL ? 0 : strlen(c_string_);
}
// Sets the 0-terminated C string this MyString object represents. // Sets the 0-terminated C string this MyString object represents.
void Set(const char* c_string); void Set(const char* c_string);

6
googletest/samples/sample2_unittest.cc
View File

@ -66,7 +66,7 @@ TEST(MyString, DefaultConstructor) {
// we have to live with this fact. // we have to live with this fact.
// //
// </TechnicalDetails> // </TechnicalDetails>
EXPECT_STREQ(NULL, s.c_string()); EXPECT_STREQ(nullptr, s.c_string());
EXPECT_EQ(0u, s.Length()); EXPECT_EQ(0u, s.Length());
} }
@ -101,7 +101,7 @@ TEST(MyString, Set) {
EXPECT_EQ(0, strcmp(s.c_string(), kHelloString)); EXPECT_EQ(0, strcmp(s.c_string(), kHelloString));
// Can we set the MyString to NULL? // Can we set the MyString to NULL?
s.Set(NULL); s.Set(nullptr);
EXPECT_STREQ(NULL, s.c_string()); EXPECT_STREQ(nullptr, s.c_string());
} }
} // namespace } // namespace

16
googletest/samples/sample3-inl.h
View File

@ -58,7 +58,8 @@ class QueueNode {
private: private:
// Creates a node with a given element value. The next pointer is // Creates a node with a given element value. The next pointer is
// set to NULL. // set to NULL.
explicit QueueNode(const E& an_element) : element_(an_element), next_(NULL) {} explicit QueueNode(const E& an_element)
: element_(an_element), next_(nullptr) {}
// We disable the default assignment operator and copy c'tor. // We disable the default assignment operator and copy c'tor.
const QueueNode& operator = (const QueueNode&); const QueueNode& operator = (const QueueNode&);
@ -72,7 +73,7 @@ template <typename E> // E is the element type.
class Queue { class Queue {
public: public:
// Creates an empty queue. // Creates an empty queue.
Queue() : head_(NULL), last_(NULL), size_(0) {} Queue() : head_(nullptr), last_(nullptr), size_(0) {}
// D'tor. Clears the queue. // D'tor. Clears the queue.
~Queue() { Clear(); } ~Queue() { Clear(); }
@ -86,12 +87,12 @@ class Queue {
for (; ;) { for (; ;) {
delete node; delete node;
node = next; node = next;
if (node == NULL) break; if (node == nullptr) break;
next = node->next(); next = node->next();
} }
// 2. Resets the member variables. // 2. Resets the member variables.
head_ = last_ = NULL; head_ = last_ = nullptr;
size_ = 0; size_ = 0;
} }
} }
@ -128,14 +129,14 @@ class Queue {
// the queue is empty. // the queue is empty.
E* Dequeue() { E* Dequeue() {
if (size_ == 0) { if (size_ == 0) {
return NULL; return nullptr;
} }
const QueueNode<E>* const old_head = head_; const QueueNode<E>* const old_head = head_;
head_ = head_->next_; head_ = head_->next_;
size_--; size_--;
if (size_ == 0) { if (size_ == 0) {
last_ = NULL; last_ = nullptr;
} }
E* element = new E(old_head->element()); E* element = new E(old_head->element());
@ -150,7 +151,8 @@ class Queue {
template <typename F> template <typename F>
Queue* Map(F function) const { Queue* Map(F function) const {
Queue* new_queue = new Queue(); Queue* new_queue = new Queue();
for (const QueueNode<E>* node = head_; node != NULL; node = node->next_) { for (const QueueNode<E>* node = head_; node != nullptr;
node = node->next_) {
new_queue->Enqueue(function(node->element())); new_queue->Enqueue(function(node->element()));
} }

10
googletest/samples/sample3_unittest.cc
View File

@ -99,8 +99,8 @@ class QueueTestSmpl3 : public testing::Test {
ASSERT_EQ(q->Size(), new_q->Size()); ASSERT_EQ(q->Size(), new_q->Size());
// Verifies the relationship between the elements of the two queues. // Verifies the relationship between the elements of the two queues.
for ( const QueueNode<int> * n1 = q->Head(), * n2 = new_q->Head(); for (const QueueNode<int>*n1 = q->Head(), *n2 = new_q->Head();
n1 != NULL; n1 = n1->next(), n2 = n2->next() ) { n1 != nullptr; n1 = n1->next(), n2 = n2->next()) {
EXPECT_EQ(2 * n1->element(), n2->element()); EXPECT_EQ(2 * n1->element(), n2->element());
} }
@ -125,16 +125,16 @@ TEST_F(QueueTestSmpl3, DefaultConstructor) {
// Tests Dequeue(). // Tests Dequeue().
TEST_F(QueueTestSmpl3, Dequeue) { TEST_F(QueueTestSmpl3, Dequeue) {
int * n = q0_.Dequeue(); int * n = q0_.Dequeue();
EXPECT_TRUE(n == NULL); EXPECT_TRUE(n == nullptr);
n = q1_.Dequeue(); n = q1_.Dequeue();
ASSERT_TRUE(n != NULL); ASSERT_TRUE(n != nullptr);
EXPECT_EQ(1, *n); EXPECT_EQ(1, *n);
EXPECT_EQ(0u, q1_.Size()); EXPECT_EQ(0u, q1_.Size());
delete n; delete n;
n = q2_.Dequeue(); n = q2_.Dequeue();
ASSERT_TRUE(n != NULL); ASSERT_TRUE(n != nullptr);
EXPECT_EQ(2, *n); EXPECT_EQ(2, *n);
EXPECT_EQ(1u, q2_.Size()); EXPECT_EQ(1u, q2_.Size());
delete n; delete n;

12
googletest/samples/sample5_unittest.cc
View File

@ -63,15 +63,13 @@ class QuickTest : public testing::Test {
protected: protected:
// Remember that SetUp() is run immediately before a test starts. // Remember that SetUp() is run immediately before a test starts.
// This is a good place to record the start time. // This is a good place to record the start time.
virtual void SetUp() { virtual void SetUp() { start_time_ = time(nullptr); }
start_time_ = time(NULL);
}
// TearDown() is invoked immediately after a test finishes. Here we // TearDown() is invoked immediately after a test finishes. Here we
// check if the test was too slow. // check if the test was too slow.
virtual void TearDown() { virtual void TearDown() {
// Gets the time when the test finishes // Gets the time when the test finishes
const time_t end_time = time(NULL); const time_t end_time = time(nullptr);
// Asserts that the test took no more than ~5 seconds. Did you // Asserts that the test took no more than ~5 seconds. Did you
// know that you can use assertions in SetUp() and TearDown() as // know that you can use assertions in SetUp() and TearDown() as
@ -176,16 +174,16 @@ TEST_F(QueueTest, DefaultConstructor) {
// Tests Dequeue(). // Tests Dequeue().
TEST_F(QueueTest, Dequeue) { TEST_F(QueueTest, Dequeue) {
int* n = q0_.Dequeue(); int* n = q0_.Dequeue();
EXPECT_TRUE(n == NULL); EXPECT_TRUE(n == nullptr);
n = q1_.Dequeue(); n = q1_.Dequeue();
EXPECT_TRUE(n != NULL); EXPECT_TRUE(n != nullptr);
EXPECT_EQ(1, *n); EXPECT_EQ(1, *n);
EXPECT_EQ(0u, q1_.Size()); EXPECT_EQ(0u, q1_.Size());
delete n; delete n;
n = q2_.Dequeue(); n = q2_.Dequeue();
EXPECT_TRUE(n != NULL); EXPECT_TRUE(n != nullptr);
EXPECT_EQ(2, *n); EXPECT_EQ(2, *n);
EXPECT_EQ(1u, q2_.Size()); EXPECT_EQ(1u, q2_.Size());
delete n; delete n;

2
googletest/samples/sample7_unittest.cc
View File

@ -69,7 +69,7 @@ class PrimeTableTestSmpl7 : public TestWithParam<CreatePrimeTableFunc*> {
virtual void SetUp() { table_ = (*GetParam())(); } virtual void SetUp() { table_ = (*GetParam())(); }
virtual void TearDown() { virtual void TearDown() {
delete table_; delete table_;
table_ = NULL; table_ = nullptr;
} }
protected: protected:

11
googletest/samples/sample8_unittest.cc
View File

@ -50,8 +50,9 @@ class HybridPrimeTable : public PrimeTable {
public: public:
HybridPrimeTable(bool force_on_the_fly, int max_precalculated) HybridPrimeTable(bool force_on_the_fly, int max_precalculated)
: on_the_fly_impl_(new OnTheFlyPrimeTable), : on_the_fly_impl_(new OnTheFlyPrimeTable),
precalc_impl_(force_on_the_fly ? NULL : precalc_impl_(force_on_the_fly
new PreCalculatedPrimeTable(max_precalculated)), ? nullptr
: new PreCalculatedPrimeTable(max_precalculated)),
max_precalculated_(max_precalculated) {} max_precalculated_(max_precalculated) {}
virtual ~HybridPrimeTable() { virtual ~HybridPrimeTable() {
delete on_the_fly_impl_; delete on_the_fly_impl_;
@ -59,7 +60,7 @@ class HybridPrimeTable : public PrimeTable {
} }
virtual bool IsPrime(int n) const { virtual bool IsPrime(int n) const {
if (precalc_impl_ != NULL && n < max_precalculated_) if (precalc_impl_ != nullptr && n < max_precalculated_)
return precalc_impl_->IsPrime(n); return precalc_impl_->IsPrime(n);
else else
return on_the_fly_impl_->IsPrime(n); return on_the_fly_impl_->IsPrime(n);
@ -67,7 +68,7 @@ class HybridPrimeTable : public PrimeTable {
virtual int GetNextPrime(int p) const { virtual int GetNextPrime(int p) const {
int next_prime = -1; int next_prime = -1;
if (precalc_impl_ != NULL && p < max_precalculated_) if (precalc_impl_ != nullptr && p < max_precalculated_)
next_prime = precalc_impl_->GetNextPrime(p); next_prime = precalc_impl_->GetNextPrime(p);
return next_prime != -1 ? next_prime : on_the_fly_impl_->GetNextPrime(p); return next_prime != -1 ? next_prime : on_the_fly_impl_->GetNextPrime(p);
@ -106,7 +107,7 @@ class PrimeTableTest : public TestWithParam< ::testing::tuple<bool, int> > {
} }
virtual void TearDown() { virtual void TearDown() {
delete table_; delete table_;
table_ = NULL; table_ = nullptr;
} }
HybridPrimeTable* table_; HybridPrimeTable* table_;
}; };

20
googletest/src/gtest-death-test.cc
View File

@ -281,7 +281,7 @@ static void DeathTestAbort(const std::string& message) {
// the heap for any additional non-minuscule memory requirements. // the heap for any additional non-minuscule memory requirements.
const InternalRunDeathTestFlag* const flag = const InternalRunDeathTestFlag* const flag =
GetUnitTestImpl()->internal_run_death_test_flag(); GetUnitTestImpl()->internal_run_death_test_flag();
if (flag != NULL) { if (flag != nullptr) {
FILE* parent = posix::FDOpen(flag->write_fd(), "w"); FILE* parent = posix::FDOpen(flag->write_fd(), "w");
fputc(kDeathTestInternalError, parent); fputc(kDeathTestInternalError, parent);
fprintf(parent, "%s", message.c_str()); fprintf(parent, "%s", message.c_str());
@ -361,7 +361,7 @@ static void FailFromInternalError(int fd) {
// for the current test. // for the current test.
DeathTest::DeathTest() { DeathTest::DeathTest() {
TestInfo* const info = GetUnitTestImpl()->current_test_info(); TestInfo* const info = GetUnitTestImpl()->current_test_info();
if (info == NULL) { if (info == nullptr) {
DeathTestAbort("Cannot run a death test outside of a TEST or " DeathTestAbort("Cannot run a death test outside of a TEST or "
"TEST_F construct"); "TEST_F construct");
} }
@ -1115,9 +1115,7 @@ class ExecDeathTest : public ForkingDeathTest {
// Utility class for accumulating command-line arguments. // Utility class for accumulating command-line arguments.
class Arguments { class Arguments {
public: public:
Arguments() { Arguments() { args_.push_back(nullptr); }
args_.push_back(NULL);
}
~Arguments() { ~Arguments() {
for (std::vector<char*>::iterator i = args_.begin(); i != args_.end(); for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
@ -1288,7 +1286,7 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
static const bool stack_grows_down = StackGrowsDown(); static const bool stack_grows_down = StackGrowsDown();
const size_t stack_size = getpagesize(); const size_t stack_size = getpagesize();
// MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead. // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead.
void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE, void* const stack = mmap(nullptr, stack_size, PROT_READ | PROT_WRITE,
MAP_ANON | MAP_PRIVATE, -1, 0); MAP_ANON | MAP_PRIVATE, -1, 0);
GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED); GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
@ -1320,7 +1318,7 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
# endif // GTEST_OS_QNX # endif // GTEST_OS_QNX
# if GTEST_OS_LINUX # if GTEST_OS_LINUX
GTEST_DEATH_TEST_CHECK_SYSCALL_( GTEST_DEATH_TEST_CHECK_SYSCALL_(
sigaction(SIGPROF, &saved_sigprof_action, NULL)); sigaction(SIGPROF, &saved_sigprof_action, nullptr));
# endif // GTEST_OS_LINUX # endif // GTEST_OS_LINUX
GTEST_DEATH_TEST_CHECK_(child_pid != -1); GTEST_DEATH_TEST_CHECK_(child_pid != -1);
@ -1338,7 +1336,7 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
const TestInfo* const info = impl->current_test_info(); const TestInfo* const info = impl->current_test_info();
const int death_test_index = info->result()->death_test_count(); const int death_test_index = info->result()->death_test_count();
if (flag != NULL) { if (flag != nullptr) {
set_write_fd(flag->write_fd()); set_write_fd(flag->write_fd());
return EXECUTE_TEST; return EXECUTE_TEST;
} }
@ -1393,7 +1391,7 @@ bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex,
const int death_test_index = impl->current_test_info() const int death_test_index = impl->current_test_info()
->increment_death_test_count(); ->increment_death_test_count();
if (flag != NULL) { if (flag != nullptr) {
if (death_test_index > flag->index()) { if (death_test_index > flag->index()) {
DeathTest::set_last_death_test_message( DeathTest::set_last_death_test_message(
"Death test count (" + StreamableToString(death_test_index) "Death test count (" + StreamableToString(death_test_index)
@ -1404,7 +1402,7 @@ bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex,
if (!(flag->file() == file && flag->line() == line && if (!(flag->file() == file && flag->line() == line &&
flag->index() == death_test_index)) { flag->index() == death_test_index)) {
*test = NULL; *test = nullptr;
return true; return true;
} }
} }
@ -1515,7 +1513,7 @@ static int GetStatusFileDescriptor(unsigned int parent_process_id,
// initialized from the GTEST_FLAG(internal_run_death_test) flag if // initialized from the GTEST_FLAG(internal_run_death_test) flag if
// the flag is specified; otherwise returns NULL. // the flag is specified; otherwise returns NULL.
InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() { InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
if (GTEST_FLAG(internal_run_death_test) == "") return NULL; if (GTEST_FLAG(internal_run_death_test) == "") return nullptr;
// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
// can use it here. // can use it here.

4
googletest/src/gtest-filepath.cc
View File

@ -111,7 +111,7 @@ FilePath FilePath::GetCurrentDir() {
// however, so fallback only when failure is detected. // however, so fallback only when failure is detected.
return FilePath(result == NULL ? kCurrentDirectoryString : cwd); return FilePath(result == NULL ? kCurrentDirectoryString : cwd);
# endif // GTEST_OS_NACL # endif // GTEST_OS_NACL
return FilePath(result == NULL ? "" : cwd); return FilePath(result == nullptr ? "" : cwd);
#endif // GTEST_OS_WINDOWS_MOBILE #endif // GTEST_OS_WINDOWS_MOBILE
} }
@ -352,7 +352,7 @@ FilePath FilePath::RemoveTrailingPathSeparator() const {
// redundancies that might be in a pathname involving "." or "..". // redundancies that might be in a pathname involving "." or "..".
// FIXME: handle Windows network shares (e.g. \\server\share). // FIXME: handle Windows network shares (e.g. \\server\share).
void FilePath::Normalize() { void FilePath::Normalize() {
if (pathname_.c_str() == NULL) { if (pathname_.c_str() == nullptr) {
pathname_ = ""; pathname_ = "";
return; return;
} }

7
googletest/src/gtest-internal-inl.h
View File

@ -585,14 +585,14 @@ class GTEST_API_ UnitTestImpl {
// total_test_case_count() - 1. If i is not in that range, returns NULL. // total_test_case_count() - 1. If i is not in that range, returns NULL.
const TestCase* GetTestCase(int i) const { const TestCase* GetTestCase(int i) const {
const int index = GetElementOr(test_case_indices_, i, -1); const int index = GetElementOr(test_case_indices_, i, -1);
return index < 0 ? NULL : test_cases_[i]; return index < 0 ? nullptr : test_cases_[i];
} }
// Gets the i-th test case among all the test cases. i can range from 0 to // Gets the i-th test case among all the test cases. i can range from 0 to
// total_test_case_count() - 1. If i is not in that range, returns NULL. // total_test_case_count() - 1. If i is not in that range, returns NULL.
TestCase* GetMutableTestCase(int i) { TestCase* GetMutableTestCase(int i) {
const int index = GetElementOr(test_case_indices_, i, -1); const int index = GetElementOr(test_case_indices_, i, -1);
return index < 0 ? NULL : test_cases_[index]; return index < 0 ? nullptr : test_cases_[index];
} }
// Provides access to the event listener list. // Provides access to the event listener list.
@ -1158,8 +1158,7 @@ class StreamingListener : public EmptyTestEventListener {
void OnTestPartResult(const TestPartResult& test_part_result) { void OnTestPartResult(const TestPartResult& test_part_result) {
const char* file_name = test_part_result.file_name(); const char* file_name = test_part_result.file_name();
if (file_name == NULL) if (file_name == nullptr) file_name = "";
file_name = "";
SendLn("event=TestPartResult&file=" + UrlEncode(file_name) + SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
"&line=" + StreamableToString(test_part_result.line_number()) + "&line=" + StreamableToString(test_part_result.line_number()) +
"&message=" + UrlEncode(test_part_result.message())); "&message=" + UrlEncode(test_part_result.message()));

27
googletest/src/gtest-port.cc
View File

@ -935,7 +935,7 @@ const char kUnknownFile[] = "unknown file";
// Formats a source file path and a line number as they would appear // Formats a source file path and a line number as they would appear
// in an error message from the compiler used to compile this code. // in an error message from the compiler used to compile this code.
GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) { GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
const std::string file_name(file == NULL ? kUnknownFile : file); const std::string file_name(file == nullptr ? kUnknownFile : file);
if (line < 0) { if (line < 0) {
return file_name + ":"; return file_name + ":";
@ -954,7 +954,7 @@ GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
// to the file location it produces, unlike FormatFileLocation(). // to the file location it produces, unlike FormatFileLocation().
GTEST_API_ ::std::string FormatCompilerIndependentFileLocation( GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
const char* file, int line) { const char* file, int line) {
const std::string file_name(file == NULL ? kUnknownFile : file); const std::string file_name(file == nullptr ? kUnknownFile : file);
if (line < 0) if (line < 0)
return file_name; return file_name;
@ -1034,7 +1034,7 @@ class CapturedStream {
const int captured_fd = mkstemp(name_template); const int captured_fd = mkstemp(name_template);
filename_ = name_template; filename_ = name_template;
# endif // GTEST_OS_WINDOWS # endif // GTEST_OS_WINDOWS
fflush(NULL); fflush(nullptr);
dup2(captured_fd, fd_); dup2(captured_fd, fd_);
close(captured_fd); close(captured_fd);
} }
@ -1046,7 +1046,7 @@ class CapturedStream {
std::string GetCapturedString() { std::string GetCapturedString() {
if (uncaptured_fd_ != -1) { if (uncaptured_fd_ != -1) {
// Restores the original stream. // Restores the original stream.
fflush(NULL); fflush(nullptr);
dup2(uncaptured_fd_, fd_); dup2(uncaptured_fd_, fd_);
close(uncaptured_fd_); close(uncaptured_fd_);
uncaptured_fd_ = -1; uncaptured_fd_ = -1;
@ -1069,13 +1069,13 @@ class CapturedStream {
GTEST_DISABLE_MSC_DEPRECATED_POP_() GTEST_DISABLE_MSC_DEPRECATED_POP_()
static CapturedStream* g_captured_stderr = NULL; static CapturedStream* g_captured_stderr = nullptr;
static CapturedStream* g_captured_stdout = NULL; static CapturedStream* g_captured_stdout = nullptr;
// Starts capturing an output stream (stdout/stderr). // Starts capturing an output stream (stdout/stderr).
static void CaptureStream(int fd, const char* stream_name, static void CaptureStream(int fd, const char* stream_name,
CapturedStream** stream) { CapturedStream** stream) {
if (*stream != NULL) { if (*stream != nullptr) {
GTEST_LOG_(FATAL) << "Only one " << stream_name GTEST_LOG_(FATAL) << "Only one " << stream_name
<< " capturer can exist at a time."; << " capturer can exist at a time.";
} }
@ -1087,7 +1087,7 @@ static std::string GetCapturedStream(CapturedStream** captured_stream) {
const std::string content = (*captured_stream)->GetCapturedString(); const std::string content = (*captured_stream)->GetCapturedString();
delete *captured_stream; delete *captured_stream;
*captured_stream = NULL; *captured_stream = nullptr;
return content; return content;
} }
@ -1146,10 +1146,11 @@ std::string ReadEntireFile(FILE* file) {
} }
#if GTEST_HAS_DEATH_TEST #if GTEST_HAS_DEATH_TEST
static const std::vector<std::string>* g_injected_test_argvs = NULL; // Owned. static const std::vector<std::string>* g_injected_test_argvs =
nullptr; // Owned.
std::vector<std::string> GetInjectableArgvs() { std::vector<std::string> GetInjectableArgvs() {
if (g_injected_test_argvs != NULL) { if (g_injected_test_argvs != nullptr) {
return *g_injected_test_argvs; return *g_injected_test_argvs;
} }
return GetArgvs(); return GetArgvs();
@ -1174,7 +1175,7 @@ void SetInjectableArgvs(const std::vector< ::string>& new_argvs) {
void ClearInjectableArgvs() { void ClearInjectableArgvs() {
delete g_injected_test_argvs; delete g_injected_test_argvs;
g_injected_test_argvs = NULL; g_injected_test_argvs = nullptr;
} }
#endif // GTEST_HAS_DEATH_TEST #endif // GTEST_HAS_DEATH_TEST
@ -1207,7 +1208,7 @@ static std::string FlagToEnvVar(const char* flag) {
// unchanged and returns false. // unchanged and returns false.
bool ParseInt32(const Message& src_text, const char* str, Int32* value) { bool ParseInt32(const Message& src_text, const char* str, Int32* value) {
// Parses the environment variable as a decimal integer. // Parses the environment variable as a decimal integer.
char* end = NULL; char* end = nullptr;
const long long_value = strtol(str, &end, 10); // NOLINT const long long_value = strtol(str, &end, 10); // NOLINT
// Has strtol() consumed all characters in the string? // Has strtol() consumed all characters in the string?
@ -1296,7 +1297,7 @@ Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
std::string OutputFlagAlsoCheckEnvVar(){ std::string OutputFlagAlsoCheckEnvVar(){
std::string default_value_for_output_flag = ""; std::string default_value_for_output_flag = "";
const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE"); const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
if (NULL != xml_output_file_env) { if (nullptr != xml_output_file_env) {
default_value_for_output_flag = std::string("xml:") + xml_output_file_env; default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
} }
return default_value_for_output_flag; return default_value_for_output_flag;

4
googletest/src/gtest-printers.cc
View File

@ -327,7 +327,7 @@ void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) {
// Prints the given C string to the ostream. // Prints the given C string to the ostream.
void PrintTo(const char* s, ostream* os) { void PrintTo(const char* s, ostream* os) {
if (s == NULL) { if (s == nullptr) {
*os << "NULL"; *os << "NULL";
} else { } else {
*os << ImplicitCast_<const void*>(s) << " pointing to "; *os << ImplicitCast_<const void*>(s) << " pointing to ";
@ -344,7 +344,7 @@ void PrintTo(const char* s, ostream* os) {
#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
// Prints the given wide C string to the ostream. // Prints the given wide C string to the ostream.
void PrintTo(const wchar_t* s, ostream* os) { void PrintTo(const wchar_t* s, ostream* os) {
if (s == NULL) { if (s == nullptr) {
*os << "NULL"; *os << "NULL";
} else { } else {
*os << ImplicitCast_<const void*>(s) << " pointing to "; *os << ImplicitCast_<const void*>(s) << " pointing to ";

3
googletest/src/gtest-test-part.cc
View File

@ -41,8 +41,7 @@ using internal::GetUnitTestImpl;
// in it. // in it.
std::string TestPartResult::ExtractSummary(const char* message) { std::string TestPartResult::ExtractSummary(const char* message) {
const char* const stack_trace = strstr(message, internal::kStackTraceMarker); const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
return stack_trace == NULL ? message : return stack_trace == nullptr ? message : std::string(message, stack_trace);
std::string(message, stack_trace);
} }
// Prints a TestPartResult object. // Prints a TestPartResult object.

2
googletest/src/gtest-typed-test.cc
View File

@ -48,7 +48,7 @@ static const char* SkipSpaces(const char* str) {
static std::vector<std::string> SplitIntoTestNames(const char* src) { static std::vector<std::string> SplitIntoTestNames(const char* src) {
std::vector<std::string> name_vec; std::vector<std::string> name_vec;
src = SkipSpaces(src); src = SkipSpaces(src);
for (; src != NULL; src = SkipComma(src)) { for (; src != nullptr; src = SkipComma(src)) {
name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src))); name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src)));
} }
return name_vec; return name_vec;

203
googletest/src/gtest.cc
View File

@ -196,14 +196,14 @@ bool g_help_flag = false;
// Utilty function to Open File for Writing // Utilty function to Open File for Writing
static FILE* OpenFileForWriting(const std::string& output_file) { static FILE* OpenFileForWriting(const std::string& output_file) {
FILE* fileout = NULL; FILE* fileout = nullptr;
FilePath output_file_path(output_file); FilePath output_file_path(output_file);
FilePath output_dir(output_file_path.RemoveFileName()); FilePath output_dir(output_file_path.RemoveFileName());
if (output_dir.CreateDirectoriesRecursively()) { if (output_dir.CreateDirectoriesRecursively()) {
fileout = posix::FOpen(output_file.c_str(), "w"); fileout = posix::FOpen(output_file.c_str(), "w");
} }
if (fileout == NULL) { if (fileout == nullptr) {
GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\""; GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";
} }
return fileout; return fileout;
@ -216,7 +216,7 @@ static FILE* OpenFileForWriting(const std::string& output_file) {
static const char* GetDefaultFilter() { static const char* GetDefaultFilter() {
const char* const testbridge_test_only = const char* const testbridge_test_only =
internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY"); internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
if (testbridge_test_only != NULL) { if (testbridge_test_only != nullptr) {
return testbridge_test_only; return testbridge_test_only;
} }
return kUniversalFilter; return kUniversalFilter;
@ -460,9 +460,9 @@ FilePath GetCurrentExecutableName() {
std::string UnitTestOptions::GetOutputFormat() { std::string UnitTestOptions::GetOutputFormat() {
const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
const char* const colon = strchr(gtest_output_flag, ':'); const char* const colon = strchr(gtest_output_flag, ':');
return (colon == NULL) ? return (colon == nullptr)
std::string(gtest_output_flag) : ? std::string(gtest_output_flag)
std::string(gtest_output_flag, colon - gtest_output_flag); : std::string(gtest_output_flag, colon - gtest_output_flag);
} }
// Returns the name of the requested output file, or the default if none // Returns the name of the requested output file, or the default if none
@ -475,7 +475,7 @@ std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
format = std::string(kDefaultOutputFormat); format = std::string(kDefaultOutputFormat);
const char* const colon = strchr(gtest_output_flag, ':'); const char* const colon = strchr(gtest_output_flag, ':');
if (colon == NULL) if (colon == nullptr)
return internal::FilePath::MakeFileName( return internal::FilePath::MakeFileName(
internal::FilePath( internal::FilePath(
UnitTest::GetInstance()->original_working_dir()), UnitTest::GetInstance()->original_working_dir()),
@ -535,7 +535,7 @@ bool UnitTestOptions::MatchesFilter(
cur_pattern = strchr(cur_pattern, ':'); cur_pattern = strchr(cur_pattern, ':');
// Returns if no more pattern can be found. // Returns if no more pattern can be found.
if (cur_pattern == NULL) { if (cur_pattern == nullptr) {
return false; return false;
} }
@ -556,7 +556,7 @@ bool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name,
const char* const dash = strchr(p, '-'); const char* const dash = strchr(p, '-');
std::string positive; std::string positive;
std::string negative; std::string negative;
if (dash == NULL) { if (dash == nullptr) {
positive = GTEST_FLAG(filter).c_str(); // Whole string is a positive filter positive = GTEST_FLAG(filter).c_str(); // Whole string is a positive filter
negative = ""; negative = "";
} else { } else {
@ -701,7 +701,7 @@ static AssertionResult HasOneFailure(const char* /* results_expr */,
<< r; << r;
} }
if (strstr(r.message(), substr.c_str()) == NULL) { if (strstr(r.message(), substr.c_str()) == nullptr) {
return AssertionFailure() << "Expected: " << expected << " containing \"" return AssertionFailure() << "Expected: " << expected << " containing \""
<< substr << "\"\n" << substr << "\"\n"
<< " Actual:\n" << " Actual:\n"
@ -888,7 +888,7 @@ TimeInMillis GetTimeInMillis() {
return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm; return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm;
#elif GTEST_HAS_GETTIMEOFDAY_ #elif GTEST_HAS_GETTIMEOFDAY_
struct timeval now; struct timeval now;
gettimeofday(&now, NULL); gettimeofday(&now, nullptr);
return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000; return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000;
#else #else
# error "Don't know how to get the current time on your system." # error "Don't know how to get the current time on your system."
@ -941,9 +941,9 @@ const char* String::Utf16ToAnsi(LPCWSTR utf16_str) {
// C string is considered different to any non-NULL C string, // C string is considered different to any non-NULL C string,
// including the empty string. // including the empty string.
bool String::CStringEquals(const char * lhs, const char * rhs) { bool String::CStringEquals(const char * lhs, const char * rhs) {
if ( lhs == NULL ) return rhs == NULL; if (lhs == nullptr) return rhs == nullptr;
if ( rhs == NULL ) return false; if (rhs == nullptr) return false;
return strcmp(lhs, rhs) == 0; return strcmp(lhs, rhs) == 0;
} }
@ -1035,10 +1035,9 @@ std::string Message::GetString() const {
// Used in EXPECT_TRUE/FALSE(assertion_result). // Used in EXPECT_TRUE/FALSE(assertion_result).
AssertionResult::AssertionResult(const AssertionResult& other) AssertionResult::AssertionResult(const AssertionResult& other)
: success_(other.success_), : success_(other.success_),
message_(other.message_.get() != NULL ? message_(other.message_.get() != nullptr
new ::std::string(*other.message_) : ? new ::std::string(*other.message_)
static_cast< ::std::string*>(NULL)) { : static_cast< ::std::string*>(nullptr)) {}
}
// Swaps two AssertionResults. // Swaps two AssertionResults.
void AssertionResult::swap(AssertionResult& other) { void AssertionResult::swap(AssertionResult& other) {
@ -1050,8 +1049,7 @@ void AssertionResult::swap(AssertionResult& other) {
// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
AssertionResult AssertionResult::operator!() const { AssertionResult AssertionResult::operator!() const {
AssertionResult negation(!success_); AssertionResult negation(!success_);
if (message_.get() != NULL) if (message_.get() != nullptr) negation << *message_;
negation << *message_;
return negation; return negation;
} }
@ -1605,17 +1603,15 @@ namespace {
// only. // only.
bool IsSubstringPred(const char* needle, const char* haystack) { bool IsSubstringPred(const char* needle, const char* haystack) {
if (needle == NULL || haystack == NULL) if (needle == nullptr || haystack == nullptr) return needle == haystack;
return needle == haystack;
return strstr(haystack, needle) != NULL; return strstr(haystack, needle) != nullptr;
} }
bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) { bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
if (needle == NULL || haystack == NULL) if (needle == nullptr || haystack == nullptr) return needle == haystack;
return needle == haystack;
return wcsstr(haystack, needle) != NULL; return wcsstr(haystack, needle) != nullptr;
} }
// StringType here can be either ::std::string or ::std::wstring. // StringType here can be either ::std::string or ::std::wstring.
@ -1896,7 +1892,7 @@ std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
// Converts a wide C string to an std::string using the UTF-8 encoding. // Converts a wide C string to an std::string using the UTF-8 encoding.
// NULL will be converted to "(null)". // NULL will be converted to "(null)".
std::string String::ShowWideCString(const wchar_t * wide_c_str) { std::string String::ShowWideCString(const wchar_t * wide_c_str) {
if (wide_c_str == NULL) return "(null)"; if (wide_c_str == nullptr) return "(null)";
return internal::WideStringToUtf8(wide_c_str, -1); return internal::WideStringToUtf8(wide_c_str, -1);
} }
@ -1908,9 +1904,9 @@ std::string String::ShowWideCString(const wchar_t * wide_c_str) {
// C string is considered different to any non-NULL C string, // C string is considered different to any non-NULL C string,
// including the empty string. // including the empty string.
bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) { bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
if (lhs == NULL) return rhs == NULL; if (lhs == nullptr) return rhs == nullptr;
if (rhs == NULL) return false; if (rhs == nullptr) return false;
return wcscmp(lhs, rhs) == 0; return wcscmp(lhs, rhs) == 0;
} }
@ -1953,10 +1949,8 @@ AssertionResult CmpHelperSTRNE(const char* s1_expression,
// NULL C string is considered different to any non-NULL C string, // NULL C string is considered different to any non-NULL C string,
// including the empty string. // including the empty string.
bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) { bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
if (lhs == NULL) if (lhs == nullptr) return rhs == nullptr;
return rhs == NULL; if (rhs == nullptr) return false;
if (rhs == NULL)
return false;
return posix::StrCaseCmp(lhs, rhs) == 0; return posix::StrCaseCmp(lhs, rhs) == 0;
} }
@ -1974,9 +1968,9 @@ bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
// current locale. // current locale.
bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs, bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
const wchar_t* rhs) { const wchar_t* rhs) {
if (lhs == NULL) return rhs == NULL; if (lhs == nullptr) return rhs == nullptr;
if (rhs == NULL) return false; if (rhs == nullptr) return false;
#if GTEST_OS_WINDOWS #if GTEST_OS_WINDOWS
return _wcsicmp(lhs, rhs) == 0; return _wcsicmp(lhs, rhs) == 0;
@ -2309,10 +2303,10 @@ void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
// AddTestPartResult. // AddTestPartResult.
UnitTest::GetInstance()->AddTestPartResult( UnitTest::GetInstance()->AddTestPartResult(
result_type, result_type,
NULL, // No info about the source file where the exception occurred. nullptr, // No info about the source file where the exception occurred.
-1, // We have no info on which line caused the exception. -1, // We have no info on which line caused the exception.
message, message,
""); // No stack trace, either. ""); // No stack trace, either.
} }
} // namespace internal } // namespace internal
@ -2562,16 +2556,15 @@ bool Test::IsSkipped() {
// Constructs a TestInfo object. It assumes ownership of the test factory // Constructs a TestInfo object. It assumes ownership of the test factory
// object. // object.
TestInfo::TestInfo(const std::string& a_test_case_name, TestInfo::TestInfo(const std::string& a_test_case_name,
const std::string& a_name, const std::string& a_name, const char* a_type_param,
const char* a_type_param,
const char* a_value_param, const char* a_value_param,
internal::CodeLocation a_code_location, internal::CodeLocation a_code_location,
internal::TypeId fixture_class_id, internal::TypeId fixture_class_id,
internal::TestFactoryBase* factory) internal::TestFactoryBase* factory)
: test_case_name_(a_test_case_name), : test_case_name_(a_test_case_name),
name_(a_name), name_(a_name),
type_param_(a_type_param ? new std::string(a_type_param) : NULL), type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
value_param_(a_value_param ? new std::string(a_value_param) : NULL), value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
location_(a_code_location), location_(a_code_location),
fixture_class_id_(fixture_class_id), fixture_class_id_(fixture_class_id),
should_run_(false), should_run_(false),
@ -2725,7 +2718,7 @@ void TestInfo::Run() {
// Tells UnitTest to stop associating assertion results to this // Tells UnitTest to stop associating assertion results to this
// test. // test.
impl->set_current_test_info(NULL); impl->set_current_test_info(nullptr);
} }
// class TestCase // class TestCase
@ -2783,12 +2776,11 @@ TestCase::TestCase(const char* a_name, const char* a_type_param,
Test::SetUpTestCaseFunc set_up_tc, Test::SetUpTestCaseFunc set_up_tc,
Test::TearDownTestCaseFunc tear_down_tc) Test::TearDownTestCaseFunc tear_down_tc)
: name_(a_name), : name_(a_name),
type_param_(a_type_param ? new std::string(a_type_param) : NULL), type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
set_up_tc_(set_up_tc), set_up_tc_(set_up_tc),
tear_down_tc_(tear_down_tc), tear_down_tc_(tear_down_tc),
should_run_(false), should_run_(false),
elapsed_time_(0) { elapsed_time_(0) {}
}
// Destructor of TestCase. // Destructor of TestCase.
TestCase::~TestCase() { TestCase::~TestCase() {
@ -2800,14 +2792,14 @@ TestCase::~TestCase() {
// total_test_count() - 1. If i is not in that range, returns NULL. // total_test_count() - 1. If i is not in that range, returns NULL.
const TestInfo* TestCase::GetTestInfo(int i) const { const TestInfo* TestCase::GetTestInfo(int i) const {
const int index = GetElementOr(test_indices_, i, -1); const int index = GetElementOr(test_indices_, i, -1);
return index < 0 ? NULL : test_info_list_[index]; return index < 0 ? nullptr : test_info_list_[index];
} }
// Returns the i-th test among all the tests. i can range from 0 to // Returns the i-th test among all the tests. i can range from 0 to
// total_test_count() - 1. If i is not in that range, returns NULL. // total_test_count() - 1. If i is not in that range, returns NULL.
TestInfo* TestCase::GetMutableTestInfo(int i) { TestInfo* TestCase::GetMutableTestInfo(int i) {
const int index = GetElementOr(test_indices_, i, -1); const int index = GetElementOr(test_indices_, i, -1);
return index < 0 ? NULL : test_info_list_[index]; return index < 0 ? nullptr : test_info_list_[index];
} }
// Adds a test to this test case. Will delete the test upon // Adds a test to this test case. Will delete the test upon
@ -2842,7 +2834,7 @@ void TestCase::Run() {
this, &TestCase::RunTearDownTestCase, "TearDownTestCase()"); this, &TestCase::RunTearDownTestCase, "TearDownTestCase()");
repeater->OnTestCaseEnd(*this); repeater->OnTestCaseEnd(*this);
impl->set_current_test_case(NULL); impl->set_current_test_case(nullptr);
} }
// Clears the results of all tests in this test case. // Clears the results of all tests in this test case.
@ -3001,7 +2993,8 @@ static const char* GetAnsiColorCode(GTestColor color) {
case COLOR_RED: return "1"; case COLOR_RED: return "1";
case COLOR_GREEN: return "2"; case COLOR_GREEN: return "2";
case COLOR_YELLOW: return "3"; case COLOR_YELLOW: return "3";
default: return NULL; default:
return nullptr;
}; };
} }
@ -3106,14 +3099,13 @@ static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
const char* const type_param = test_info.type_param(); const char* const type_param = test_info.type_param();
const char* const value_param = test_info.value_param(); const char* const value_param = test_info.value_param();
if (type_param != NULL || value_param != NULL) { if (type_param != nullptr || value_param != nullptr) {
printf(", where "); printf(", where ");
if (type_param != NULL) { if (type_param != nullptr) {
printf("%s = %s", kTypeParamLabel, type_param); printf("%s = %s", kTypeParamLabel, type_param);
if (value_param != NULL) if (value_param != nullptr) printf(" and ");
printf(" and ");
} }
if (value_param != NULL) { if (value_param != nullptr) {
printf("%s = %s", kValueParamLabel, value_param); printf("%s = %s", kValueParamLabel, value_param);
} }
} }
@ -3197,7 +3189,7 @@ void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(COLOR_GREEN, "[----------] "); ColoredPrintf(COLOR_GREEN, "[----------] ");
printf("%s from %s", counts.c_str(), test_case.name()); printf("%s from %s", counts.c_str(), test_case.name());
if (test_case.type_param() == NULL) { if (test_case.type_param() == nullptr) {
printf("\n"); printf("\n");
} else { } else {
printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param()); printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
@ -3421,7 +3413,7 @@ TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
} }
} }
return NULL; return nullptr;
} }
// Since most methods are very similar, use macros to reduce boilerplate. // Since most methods are very similar, use macros to reduce boilerplate.
@ -3695,7 +3687,7 @@ static bool PortableLocaltime(time_t seconds, struct tm* out) {
*out = *tm_ptr; *out = *tm_ptr;
return true; return true;
#else #else
return localtime_r(&seconds, out) != NULL; return localtime_r(&seconds, out) != nullptr;
#endif #endif
} }
@ -3721,7 +3713,7 @@ void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
*stream << "<![CDATA["; *stream << "<![CDATA[";
for (;;) { for (;;) {
const char* const next_segment = strstr(segment, "]]>"); const char* const next_segment = strstr(segment, "]]>");
if (next_segment != NULL) { if (next_segment != nullptr) {
stream->write( stream->write(
segment, static_cast<std::streamsize>(next_segment - segment)); segment, static_cast<std::streamsize>(next_segment - segment));
*stream << "]]>]]&gt;<![CDATA["; *stream << "]]>]]&gt;<![CDATA[";
@ -3765,11 +3757,11 @@ void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
*stream << " <testcase"; *stream << " <testcase";
OutputXmlAttribute(stream, kTestcase, "name", test_info.name()); OutputXmlAttribute(stream, kTestcase, "name", test_info.name());
if (test_info.value_param() != NULL) { if (test_info.value_param() != nullptr) {
OutputXmlAttribute(stream, kTestcase, "value_param", OutputXmlAttribute(stream, kTestcase, "value_param",
test_info.value_param()); test_info.value_param());
} }
if (test_info.type_param() != NULL) { if (test_info.type_param() != nullptr) {
OutputXmlAttribute(stream, kTestcase, "type_param", test_info.type_param()); OutputXmlAttribute(stream, kTestcase, "type_param", test_info.type_param());
} }
if (GTEST_FLAG(list_tests)) { if (GTEST_FLAG(list_tests)) {
@ -4130,11 +4122,11 @@ void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
*stream << Indent(8) << "{\n"; *stream << Indent(8) << "{\n";
OutputJsonKey(stream, kTestcase, "name", test_info.name(), kIndent); OutputJsonKey(stream, kTestcase, "name", test_info.name(), kIndent);
if (test_info.value_param() != NULL) { if (test_info.value_param() != nullptr) {
OutputJsonKey(stream, kTestcase, "value_param", OutputJsonKey(stream, kTestcase, "value_param",
test_info.value_param(), kIndent); test_info.value_param(), kIndent);
} }
if (test_info.type_param() != NULL) { if (test_info.type_param() != nullptr) {
OutputJsonKey(stream, kTestcase, "type_param", test_info.type_param(), OutputJsonKey(stream, kTestcase, "type_param", test_info.type_param(),
kIndent); kIndent);
} }
@ -4335,7 +4327,7 @@ void StreamingListener::SocketWriter::MakeConnection() {
memset(&hints, 0, sizeof(hints)); memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses. hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses.
hints.ai_socktype = SOCK_STREAM; hints.ai_socktype = SOCK_STREAM;
addrinfo* servinfo = NULL; addrinfo* servinfo = nullptr;
// Use the getaddrinfo() to get a linked list of IP addresses for // Use the getaddrinfo() to get a linked list of IP addresses for
// the given host name. // the given host name.
@ -4347,7 +4339,7 @@ void StreamingListener::SocketWriter::MakeConnection() {
} }
// Loop through all the results and connect to the first we can. // Loop through all the results and connect to the first we can.
for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != NULL; for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr;
cur_addr = cur_addr->ai_next) { cur_addr = cur_addr->ai_next) {
sockfd_ = socket( sockfd_ = socket(
cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol); cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
@ -4479,9 +4471,8 @@ class ScopedPrematureExitFile {
TestEventListeners::TestEventListeners() TestEventListeners::TestEventListeners()
: repeater_(new internal::TestEventRepeater()), : repeater_(new internal::TestEventRepeater()),
default_result_printer_(NULL), default_result_printer_(nullptr),
default_xml_generator_(NULL) { default_xml_generator_(nullptr) {}
}
TestEventListeners::~TestEventListeners() { delete repeater_; } TestEventListeners::~TestEventListeners() { delete repeater_; }
@ -4498,9 +4489,9 @@ void TestEventListeners::Append(TestEventListener* listener) {
// NULL if the listener is not found in the list. // NULL if the listener is not found in the list.
TestEventListener* TestEventListeners::Release(TestEventListener* listener) { TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
if (listener == default_result_printer_) if (listener == default_result_printer_)
default_result_printer_ = NULL; default_result_printer_ = nullptr;
else if (listener == default_xml_generator_) else if (listener == default_xml_generator_)
default_xml_generator_ = NULL; default_xml_generator_ = nullptr;
return repeater_->Release(listener); return repeater_->Release(listener);
} }
@ -4519,8 +4510,7 @@ void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
// list. // list.
delete Release(default_result_printer_); delete Release(default_result_printer_);
default_result_printer_ = listener; default_result_printer_ = listener;
if (listener != NULL) if (listener != nullptr) Append(listener);
Append(listener);
} }
} }
@ -4535,8 +4525,7 @@ void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
// list. // list.
delete Release(default_xml_generator_); delete Release(default_xml_generator_);
default_xml_generator_ = listener; default_xml_generator_ = listener;
if (listener != NULL) if (listener != nullptr) Append(listener);
Append(listener);
} }
} }
@ -4688,8 +4677,8 @@ TestEventListeners& UnitTest::listeners() {
// We don't protect this under mutex_, as we only support calling it // We don't protect this under mutex_, as we only support calling it
// from the main thread. // from the main thread.
Environment* UnitTest::AddEnvironment(Environment* env) { Environment* UnitTest::AddEnvironment(Environment* env) {
if (env == NULL) { if (env == nullptr) {
return NULL; return nullptr;
} }
impl_->environments().push_back(env); impl_->environments().push_back(env);
@ -4721,7 +4710,7 @@ void UnitTest::AddTestPartResult(
} }
} }
if (os_stack_trace.c_str() != NULL && !os_stack_trace.empty()) { if (os_stack_trace.c_str() != nullptr && !os_stack_trace.empty()) {
msg << internal::kStackTraceMarker << os_stack_trace; msg << internal::kStackTraceMarker << os_stack_trace;
} }
@ -4809,8 +4798,9 @@ int UnitTest::Run() {
// that understands the premature-exit-file protocol to report the // that understands the premature-exit-file protocol to report the
// test as having failed. // test as having failed.
const internal::ScopedPrematureExitFile premature_exit_file( const internal::ScopedPrematureExitFile premature_exit_file(
in_death_test_child_process ? in_death_test_child_process
NULL : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE")); ? nullptr
: internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
// Captures the value of GTEST_FLAG(catch_exceptions). This value will be // Captures the value of GTEST_FLAG(catch_exceptions). This value will be
// used for the duration of the program. // used for the duration of the program.
@ -4924,23 +4914,22 @@ namespace internal {
UnitTestImpl::UnitTestImpl(UnitTest* parent) UnitTestImpl::UnitTestImpl(UnitTest* parent)
: parent_(parent), : parent_(parent),
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */) GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
default_global_test_part_result_reporter_(this), default_global_test_part_result_reporter_(this),
default_per_thread_test_part_result_reporter_(this), default_per_thread_test_part_result_reporter_(this),
GTEST_DISABLE_MSC_WARNINGS_POP_() GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_repoter_(
global_test_part_result_repoter_(
&default_global_test_part_result_reporter_), &default_global_test_part_result_reporter_),
per_thread_test_part_result_reporter_( per_thread_test_part_result_reporter_(
&default_per_thread_test_part_result_reporter_), &default_per_thread_test_part_result_reporter_),
parameterized_test_registry_(), parameterized_test_registry_(),
parameterized_tests_registered_(false), parameterized_tests_registered_(false),
last_death_test_case_(-1), last_death_test_case_(-1),
current_test_case_(NULL), current_test_case_(nullptr),
current_test_info_(NULL), current_test_info_(nullptr),
ad_hoc_test_result_(), ad_hoc_test_result_(),
os_stack_trace_getter_(NULL), os_stack_trace_getter_(nullptr),
post_flag_parse_init_performed_(false), post_flag_parse_init_performed_(false),
random_seed_(0), // Will be overridden by the flag before first use. random_seed_(0), // Will be overridden by the flag before first use.
random_(0), // Will be reseeded before first use. random_(0), // Will be reseeded before first use.
start_timestamp_(0), start_timestamp_(0),
elapsed_time_(0), elapsed_time_(0),
#if GTEST_HAS_DEATH_TEST #if GTEST_HAS_DEATH_TEST
@ -4970,10 +4959,10 @@ void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
std::string xml_element; std::string xml_element;
TestResult* test_result; // TestResult appropriate for property recording. TestResult* test_result; // TestResult appropriate for property recording.
if (current_test_info_ != NULL) { if (current_test_info_ != nullptr) {
xml_element = "testcase"; xml_element = "testcase";
test_result = &(current_test_info_->result_); test_result = &(current_test_info_->result_);
} else if (current_test_case_ != NULL) { } else if (current_test_case_ != nullptr) {
xml_element = "testsuite"; xml_element = "testsuite";
test_result = &(current_test_case_->ad_hoc_test_result_); test_result = &(current_test_case_->ad_hoc_test_result_);
} else { } else {
@ -4987,7 +4976,7 @@ void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
// Disables event forwarding if the control is currently in a death test // Disables event forwarding if the control is currently in a death test
// subprocess. Must not be called before InitGoogleTest. // subprocess. Must not be called before InitGoogleTest.
void UnitTestImpl::SuppressTestEventsIfInSubprocess() { void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
if (internal_run_death_test_flag_.get() != NULL) if (internal_run_death_test_flag_.get() != nullptr)
listeners()->SuppressEventForwarding(); listeners()->SuppressEventForwarding();
} }
#endif // GTEST_HAS_DEATH_TEST #endif // GTEST_HAS_DEATH_TEST
@ -5085,7 +5074,8 @@ class TestCaseNameIs {
// Returns true iff the name of test_case matches name_. // Returns true iff the name of test_case matches name_.
bool operator()(const TestCase* test_case) const { bool operator()(const TestCase* test_case) const {
return test_case != NULL && strcmp(test_case->name(), name_.c_str()) == 0; return test_case != nullptr &&
strcmp(test_case->name(), name_.c_str()) == 0;
} }
private: private:
@ -5175,7 +5165,8 @@ bool UnitTestImpl::RunAllTests() {
bool in_subprocess_for_death_test = false; bool in_subprocess_for_death_test = false;
#if GTEST_HAS_DEATH_TEST #if GTEST_HAS_DEATH_TEST
in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != NULL); in_subprocess_for_death_test =
(internal_run_death_test_flag_.get() != nullptr);
# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_) # if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
if (in_subprocess_for_death_test) { if (in_subprocess_for_death_test) {
GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_(); GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
@ -5306,9 +5297,9 @@ bool UnitTestImpl::RunAllTests() {
// be created, prints an error and exits. // be created, prints an error and exits.
void WriteToShardStatusFileIfNeeded() { void WriteToShardStatusFileIfNeeded() {
const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile); const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
if (test_shard_file != NULL) { if (test_shard_file != nullptr) {
FILE* const file = posix::FOpen(test_shard_file, "w"); FILE* const file = posix::FOpen(test_shard_file, "w");
if (file == NULL) { if (file == nullptr) {
ColoredPrintf(COLOR_RED, ColoredPrintf(COLOR_RED,
"Could not write to the test shard status file \"%s\" " "Could not write to the test shard status file \"%s\" "
"specified by the %s environment variable.\n", "specified by the %s environment variable.\n",
@ -5373,7 +5364,7 @@ bool ShouldShard(const char* total_shards_env,
// and aborts. // and aborts.
Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) { Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
const char* str_val = posix::GetEnv(var); const char* str_val = posix::GetEnv(var);
if (str_val == NULL) { if (str_val == nullptr) {
return default_val; return default_val;
} }
@ -5459,7 +5450,7 @@ int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
// max_length characters, only prints the first max_length characters // max_length characters, only prints the first max_length characters
// and "...". // and "...".
static void PrintOnOneLine(const char* str, int max_length) { static void PrintOnOneLine(const char* str, int max_length) {
if (str != NULL) { if (str != nullptr) {
for (int i = 0; *str != '\0'; ++str) { for (int i = 0; *str != '\0'; ++str) {
if (i >= max_length) { if (i >= max_length) {
printf("..."); printf("...");
@ -5492,7 +5483,7 @@ void UnitTestImpl::ListTestsMatchingFilter() {
if (!printed_test_case_name) { if (!printed_test_case_name) {
printed_test_case_name = true; printed_test_case_name = true;
printf("%s.", test_case->name()); printf("%s.", test_case->name());
if (test_case->type_param() != NULL) { if (test_case->type_param() != nullptr) {
printf(" # %s = ", kTypeParamLabel); printf(" # %s = ", kTypeParamLabel);
// We print the type parameter on a single line to make // We print the type parameter on a single line to make
// the output easy to parse by a program. // the output easy to parse by a program.
@ -5501,7 +5492,7 @@ void UnitTestImpl::ListTestsMatchingFilter() {
printf("\n"); printf("\n");
} }
printf(" %s", test_info->name()); printf(" %s", test_info->name());
if (test_info->value_param() != NULL) { if (test_info->value_param() != nullptr) {
printf(" # %s = ", kValueParamLabel); printf(" # %s = ", kValueParamLabel);
// We print the value parameter on a single line to make the // We print the value parameter on a single line to make the
// output easy to parse by a program. // output easy to parse by a program.
@ -5548,7 +5539,7 @@ void UnitTestImpl::set_os_stack_trace_getter(
// otherwise, creates an OsStackTraceGetter, makes it the current // otherwise, creates an OsStackTraceGetter, makes it the current
// getter, and returns it. // getter, and returns it.
OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() { OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
if (os_stack_trace_getter_ == NULL) { if (os_stack_trace_getter_ == nullptr) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_ #ifdef GTEST_OS_STACK_TRACE_GETTER_
os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_; os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else #else
@ -5561,10 +5552,10 @@ OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
// Returns the most specific TestResult currently running. // Returns the most specific TestResult currently running.
TestResult* UnitTestImpl::current_test_result() { TestResult* UnitTestImpl::current_test_result() {
if (current_test_info_ != NULL) { if (current_test_info_ != nullptr) {
return &current_test_info_->result_; return &current_test_info_->result_;
} }
if (current_test_case_ != NULL) { if (current_test_case_ != nullptr) {
return &current_test_case_->ad_hoc_test_result_; return &current_test_case_->ad_hoc_test_result_;
} }
return &ad_hoc_test_result_; return &ad_hoc_test_result_;
@ -5651,12 +5642,12 @@ bool SkipPrefix(const char* prefix, const char** pstr) {
static const char* ParseFlagValue(const char* str, const char* flag, static const char* ParseFlagValue(const char* str, const char* flag,
bool def_optional) { bool def_optional) {
// str and flag must not be NULL. // str and flag must not be NULL.
if (str == NULL || flag == NULL) return NULL; if (str == nullptr || flag == nullptr) return nullptr;
// The flag must start with "--" followed by GTEST_FLAG_PREFIX_. // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag; const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
const size_t flag_len = flag_str.length(); const size_t flag_len = flag_str.length();
if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL; if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
// Skips the flag name. // Skips the flag name.
const char* flag_end = str + flag_len; const char* flag_end = str + flag_len;
@ -5669,7 +5660,7 @@ static const char* ParseFlagValue(const char* str, const char* flag,
// If def_optional is true and there are more characters after the // If def_optional is true and there are more characters after the
// flag name, or if def_optional is false, there must be a '=' after // flag name, or if def_optional is false, there must be a '=' after
// the flag name. // the flag name.
if (flag_end[0] != '=') return NULL; if (flag_end[0] != '=') return nullptr;
// Returns the string after "=". // Returns the string after "=".
return flag_end + 1; return flag_end + 1;
@ -5690,7 +5681,7 @@ static bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
const char* const value_str = ParseFlagValue(str, flag, true); const char* const value_str = ParseFlagValue(str, flag, true);
// Aborts if the parsing failed. // Aborts if the parsing failed.
if (value_str == NULL) return false; if (value_str == nullptr) return false;
// Converts the string value to a bool. // Converts the string value to a bool.
*value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
@ -5707,7 +5698,7 @@ bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
const char* const value_str = ParseFlagValue(str, flag, false); const char* const value_str = ParseFlagValue(str, flag, false);
// Aborts if the parsing failed. // Aborts if the parsing failed.
if (value_str == NULL) return false; if (value_str == nullptr) return false;
// Sets *value to the value of the flag. // Sets *value to the value of the flag.
return ParseInt32(Message() << "The value of flag --" << flag, return ParseInt32(Message() << "The value of flag --" << flag,
@ -5725,7 +5716,7 @@ static bool ParseStringFlag(const char* str, const char* flag, String* value) {
const char* const value_str = ParseFlagValue(str, flag, false); const char* const value_str = ParseFlagValue(str, flag, false);
// Aborts if the parsing failed. // Aborts if the parsing failed.
if (value_str == NULL) return false; if (value_str == nullptr) return false;
// Sets *value to the value of the flag. // Sets *value to the value of the flag.
*value = value_str; *value = value_str;
@ -5767,7 +5758,7 @@ static void PrintColorEncoded(const char* str) {
// next segment. // next segment.
for (;;) { for (;;) {
const char* p = strchr(str, '@'); const char* p = strchr(str, '@');
if (p == NULL) { if (p == nullptr) {
ColoredPrintf(color, "%s", str); ColoredPrintf(color, "%s", str);
return; return;
} }

2
googletest/test/googletest-catch-exceptions-test_.cc
View File

@ -277,7 +277,7 @@ TEST(CxxExceptionTest, ThrowsNonStdCxxException) {
// ones. // ones.
void TerminateHandler() { void TerminateHandler() {
fprintf(stderr, "%s\n", "Unhandled C++ exception terminating the program."); fprintf(stderr, "%s\n", "Unhandled C++ exception terminating the program.");
fflush(NULL); fflush(nullptr);
exit(3); exit(3);
} }

21
googletest/test/googletest-death-test-test.cc
View File

@ -370,13 +370,13 @@ void SetSigprofActionAndTimer() {
timer.it_interval.tv_sec = 0; timer.it_interval.tv_sec = 0;
timer.it_interval.tv_usec = 1; timer.it_interval.tv_usec = 1;
timer.it_value = timer.it_interval; timer.it_value = timer.it_interval;
ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL)); ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, nullptr));
struct sigaction signal_action; struct sigaction signal_action;
memset(&signal_action, 0, sizeof(signal_action)); memset(&signal_action, 0, sizeof(signal_action));
sigemptyset(&signal_action.sa_mask); sigemptyset(&signal_action.sa_mask);
signal_action.sa_sigaction = SigprofAction; signal_action.sa_sigaction = SigprofAction;
signal_action.sa_flags = SA_RESTART | SA_SIGINFO; signal_action.sa_flags = SA_RESTART | SA_SIGINFO;
ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, NULL)); ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, nullptr));
} }
// Disables ITIMER_PROF timer and ignores SIGPROF signal. // Disables ITIMER_PROF timer and ignores SIGPROF signal.
@ -385,7 +385,7 @@ void DisableSigprofActionAndTimer(struct sigaction* old_signal_action) {
timer.it_interval.tv_sec = 0; timer.it_interval.tv_sec = 0;
timer.it_interval.tv_usec = 0; timer.it_interval.tv_usec = 0;
timer.it_value = timer.it_interval; timer.it_value = timer.it_interval;
ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL)); ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, nullptr));
struct sigaction signal_action; struct sigaction signal_action;
memset(&signal_action, 0, sizeof(signal_action)); memset(&signal_action, 0, sizeof(signal_action));
sigemptyset(&signal_action.sa_mask); sigemptyset(&signal_action.sa_mask);
@ -466,7 +466,7 @@ TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {
if (!testing::GTEST_FLAG(death_test_use_fork)) { if (!testing::GTEST_FLAG(death_test_use_fork)) {
testing::GTEST_FLAG(death_test_style) = "threadsafe"; testing::GTEST_FLAG(death_test_style) = "threadsafe";
pthread_flag = false; pthread_flag = false;
ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, NULL, NULL)); ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, nullptr, nullptr));
ASSERT_DEATH(_exit(1), ""); ASSERT_DEATH(_exit(1), "");
ASSERT_FALSE(pthread_flag); ASSERT_FALSE(pthread_flag);
} }
@ -1001,7 +1001,7 @@ bool MockDeathTestFactory::Create(const char* /*statement*/,
if (create_) { if (create_) {
*test = new MockDeathTest(this, role_, status_, passed_); *test = new MockDeathTest(this, role_, status_, passed_);
} else { } else {
*test = NULL; *test = nullptr;
} }
return true; return true;
} }
@ -1021,9 +1021,9 @@ class MacroLogicDeathTest : public testing::Test {
static void TearDownTestCase() { static void TearDownTestCase() {
delete replacer_; delete replacer_;
replacer_ = NULL; replacer_ = nullptr;
delete factory_; delete factory_;
factory_ = NULL; factory_ = nullptr;
} }
// Runs a death test that breaks the rules by returning. Such a death // Runs a death test that breaks the rules by returning. Such a death
@ -1037,10 +1037,9 @@ class MacroLogicDeathTest : public testing::Test {
} }
}; };
testing::internal::ReplaceDeathTestFactory* MacroLogicDeathTest::replacer_ testing::internal::ReplaceDeathTestFactory* MacroLogicDeathTest::replacer_ =
= NULL; nullptr;
MockDeathTestFactory* MacroLogicDeathTest::factory_ = NULL; MockDeathTestFactory* MacroLogicDeathTest::factory_ = nullptr;
// Test that nothing happens when the factory doesn't return a DeathTest: // Test that nothing happens when the factory doesn't return a DeathTest:
TEST_F(MacroLogicDeathTest, NothingHappens) { TEST_F(MacroLogicDeathTest, NothingHappens) {

20
googletest/test/googletest-linked-ptr-test.cc
View File

@ -38,7 +38,7 @@ using testing::Message;
using testing::internal::linked_ptr; using testing::internal::linked_ptr;
int num; int num;
Message* history = NULL; Message* history = nullptr;
// Class which tracks allocation/deallocation // Class which tracks allocation/deallocation
class A { class A {
@ -67,7 +67,7 @@ class LinkedPtrTest : public testing::Test {
virtual ~LinkedPtrTest() { virtual ~LinkedPtrTest() {
delete history; delete history;
history = NULL; history = nullptr;
} }
}; };
@ -77,18 +77,18 @@ TEST_F(LinkedPtrTest, GeneralTest) {
// Use explicit function call notation here to suppress self-assign warning. // Use explicit function call notation here to suppress self-assign warning.
a0.operator=(a0); a0.operator=(a0);
a1 = a2; a1 = a2;
ASSERT_EQ(a0.get(), static_cast<A*>(NULL)); ASSERT_EQ(a0.get(), static_cast<A*>(nullptr));
ASSERT_EQ(a1.get(), static_cast<A*>(NULL)); ASSERT_EQ(a1.get(), static_cast<A*>(nullptr));
ASSERT_EQ(a2.get(), static_cast<A*>(NULL)); ASSERT_EQ(a2.get(), static_cast<A*>(nullptr));
ASSERT_TRUE(a0 == NULL); ASSERT_TRUE(a0 == nullptr);
ASSERT_TRUE(a1 == NULL); ASSERT_TRUE(a1 == nullptr);
ASSERT_TRUE(a2 == NULL); ASSERT_TRUE(a2 == nullptr);
{ {
linked_ptr<A> a3(new A); linked_ptr<A> a3(new A);
a0 = a3; a0 = a3;
ASSERT_TRUE(a0 == a3); ASSERT_TRUE(a0 == a3);
ASSERT_TRUE(a0 != NULL); ASSERT_TRUE(a0 != nullptr);
ASSERT_TRUE(a0.get() == a3); ASSERT_TRUE(a0.get() == a3);
ASSERT_TRUE(a0 == a3.get()); ASSERT_TRUE(a0 == a3.get());
linked_ptr<A> a4(a0); linked_ptr<A> a4(a0);
@ -101,7 +101,7 @@ TEST_F(LinkedPtrTest, GeneralTest) {
linked_ptr<A> a6(b0); linked_ptr<A> a6(b0);
ASSERT_TRUE(b0 == a6); ASSERT_TRUE(b0 == a6);
ASSERT_TRUE(a6 == b0); ASSERT_TRUE(a6 == b0);
ASSERT_TRUE(b0 != NULL); ASSERT_TRUE(b0 != nullptr);
a5 = b0; a5 = b0;
a5 = b0; a5 = b0;
a3->Use(); a3->Use();

2
googletest/test/googletest-listener-test.cc
View File

@ -47,7 +47,7 @@ using ::testing::TestPartResult;
using ::testing::UnitTest; using ::testing::UnitTest;
// Used by tests to register their events. // Used by tests to register their events.
std::vector<std::string>* g_events = NULL; std::vector<std::string>* g_events = nullptr;
namespace testing { namespace testing {
namespace internal { namespace internal {

4
googletest/test/googletest-message-test.cc
View File

@ -85,7 +85,7 @@ TEST(MessageTest, StreamsPointer) {
// Tests streaming a NULL non-char pointer. // Tests streaming a NULL non-char pointer.
TEST(MessageTest, StreamsNullPointer) { TEST(MessageTest, StreamsNullPointer) {
int* p = NULL; int* p = nullptr;
EXPECT_EQ("(null)", (Message() << p).GetString()); EXPECT_EQ("(null)", (Message() << p).GetString());
} }
@ -96,7 +96,7 @@ TEST(MessageTest, StreamsCString) {
// Tests streaming a NULL C string. // Tests streaming a NULL C string.
TEST(MessageTest, StreamsNullCString) { TEST(MessageTest, StreamsNullCString) {
char* p = NULL; char* p = nullptr;
EXPECT_EQ("(null)", (Message() << p).GetString()); EXPECT_EQ("(null)", (Message() << p).GetString());
} }

11
googletest/test/googletest-output-test_.cc
View File

@ -174,7 +174,7 @@ TEST(SCOPED_TRACETest, AcceptedValues) {
SCOPED_TRACE("literal string"); SCOPED_TRACE("literal string");
SCOPED_TRACE(std::string("std::string")); SCOPED_TRACE(std::string("std::string"));
SCOPED_TRACE(1337); // streamable type SCOPED_TRACE(1337); // streamable type
const char* null_value = NULL; const char* null_value = nullptr;
SCOPED_TRACE(null_value); SCOPED_TRACE(null_value);
ADD_FAILURE() << "Just checking that all these values work fine."; ADD_FAILURE() << "Just checking that all these values work fine.";
@ -306,9 +306,8 @@ TEST(SCOPED_TRACETest, WorksConcurrently) {
printf("(expecting 6 failures)\n"); printf("(expecting 6 failures)\n");
CheckPoints check_points; CheckPoints check_points;
ThreadWithParam<CheckPoints*> thread(&ThreadWithScopedTrace, ThreadWithParam<CheckPoints*> thread(&ThreadWithScopedTrace, &check_points,
&check_points, nullptr);
NULL);
check_points.n1.WaitForNotification(); check_points.n1.WaitForNotification();
{ {
@ -511,7 +510,7 @@ class DeathTestAndMultiThreadsTest : public testing::Test {
// Starts a thread and waits for it to begin. // Starts a thread and waits for it to begin.
virtual void SetUp() { virtual void SetUp() {
thread_.reset(new ThreadWithParam<SpawnThreadNotifications*>( thread_.reset(new ThreadWithParam<SpawnThreadNotifications*>(
&ThreadRoutine, &notifications_, NULL)); &ThreadRoutine, &notifications_, nullptr));
notifications_.spawn_thread_started.WaitForNotification(); notifications_.spawn_thread_started.WaitForNotification();
} }
// Tells the thread to finish, and reaps it. // Tells the thread to finish, and reaps it.
@ -966,7 +965,7 @@ TEST_F(ExpectFailureTest, ExpectNonFatalFailure) {
class ExpectFailureWithThreadsTest : public ExpectFailureTest { class ExpectFailureWithThreadsTest : public ExpectFailureTest {
protected: protected:
static void AddFailureInOtherThread(FailureMode failure) { static void AddFailureInOtherThread(FailureMode failure) {
ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL); ThreadWithParam<FailureMode> thread(&AddFailure, failure, nullptr);
thread.Join(); thread.Join();
} }
}; };

26
googletest/test/googletest-port-test.cc
View File

@ -262,9 +262,9 @@ TEST(FormatFileLocationTest, FormatsFileLocation) {
} }
TEST(FormatFileLocationTest, FormatsUnknownFile) { TEST(FormatFileLocationTest, FormatsUnknownFile) {
EXPECT_PRED_FORMAT2( EXPECT_PRED_FORMAT2(IsSubstring, "unknown file",
IsSubstring, "unknown file", FormatFileLocation(NULL, 42)); FormatFileLocation(nullptr, 42));
EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation(NULL, 42)); EXPECT_PRED_FORMAT2(IsSubstring, "42", FormatFileLocation(nullptr, 42));
} }
TEST(FormatFileLocationTest, FormatsUknownLine) { TEST(FormatFileLocationTest, FormatsUknownLine) {
@ -272,7 +272,7 @@ TEST(FormatFileLocationTest, FormatsUknownLine) {
} }
TEST(FormatFileLocationTest, FormatsUknownFileAndLine) { TEST(FormatFileLocationTest, FormatsUknownFileAndLine) {
EXPECT_EQ("unknown file:", FormatFileLocation(NULL, -1)); EXPECT_EQ("unknown file:", FormatFileLocation(nullptr, -1));
} }
// Verifies behavior of FormatCompilerIndependentFileLocation. // Verifies behavior of FormatCompilerIndependentFileLocation.
@ -282,7 +282,7 @@ TEST(FormatCompilerIndependentFileLocationTest, FormatsFileLocation) {
TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFile) { TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFile) {
EXPECT_EQ("unknown file:42", EXPECT_EQ("unknown file:42",
FormatCompilerIndependentFileLocation(NULL, 42)); FormatCompilerIndependentFileLocation(nullptr, 42));
} }
TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownLine) { TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownLine) {
@ -290,7 +290,7 @@ TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownLine) {
} }
TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine) { TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine) {
EXPECT_EQ("unknown file", FormatCompilerIndependentFileLocation(NULL, -1)); EXPECT_EQ("unknown file", FormatCompilerIndependentFileLocation(nullptr, -1));
} }
#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_QNX || GTEST_OS_FUCHSIA #if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_QNX || GTEST_OS_FUCHSIA
@ -298,7 +298,7 @@ void* ThreadFunc(void* data) {
internal::Mutex* mutex = static_cast<internal::Mutex*>(data); internal::Mutex* mutex = static_cast<internal::Mutex*>(data);
mutex->Lock(); mutex->Lock();
mutex->Unlock(); mutex->Unlock();
return NULL; return nullptr;
} }
TEST(GetThreadCountTest, ReturnsCorrectValue) { TEST(GetThreadCountTest, ReturnsCorrectValue) {
@ -965,7 +965,7 @@ TEST(ThreadLocalTest, DefaultConstructorInitializesToDefaultValues) {
EXPECT_EQ(0, t1.get()); EXPECT_EQ(0, t1.get());
ThreadLocal<void*> t2; ThreadLocal<void*> t2;
EXPECT_TRUE(t2.get() == NULL); EXPECT_TRUE(t2.get() == nullptr);
} }
TEST(ThreadLocalTest, SingleParamConstructorInitializesToParam) { TEST(ThreadLocalTest, SingleParamConstructorInitializesToParam) {
@ -1015,7 +1015,7 @@ void AddTwo(int* param) { *param += 2; }
TEST(ThreadWithParamTest, ConstructorExecutesThreadFunc) { TEST(ThreadWithParamTest, ConstructorExecutesThreadFunc) {
int i = 40; int i = 40;
ThreadWithParam<int*> thread(&AddTwo, &i, NULL); ThreadWithParam<int*> thread(&AddTwo, &i, nullptr);
thread.Join(); thread.Join();
EXPECT_EQ(42, i); EXPECT_EQ(42, i);
} }
@ -1055,7 +1055,7 @@ class AtomicCounterWithMutex {
// functionality as we are testing them here. // functionality as we are testing them here.
pthread_mutex_t memory_barrier_mutex; pthread_mutex_t memory_barrier_mutex;
GTEST_CHECK_POSIX_SUCCESS_( GTEST_CHECK_POSIX_SUCCESS_(
pthread_mutex_init(&memory_barrier_mutex, NULL)); pthread_mutex_init(&memory_barrier_mutex, nullptr));
GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&memory_barrier_mutex)); GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&memory_barrier_mutex));
SleepMilliseconds(random_.Generate(30)); SleepMilliseconds(random_.Generate(30));
@ -1118,7 +1118,7 @@ TEST(MutexTest, OnlyOneThreadCanLockAtATime) {
template <typename T> template <typename T>
void RunFromThread(void (func)(T), T param) { void RunFromThread(void (func)(T), T param) {
ThreadWithParam<T> thread(func, param, NULL); ThreadWithParam<T> thread(func, param, nullptr);
thread.Join(); thread.Join();
} }
@ -1250,8 +1250,8 @@ TEST(ThreadLocalTest, DestroysManagedObjectAtThreadExit) {
ASSERT_EQ(0U, DestructorCall::List().size()); ASSERT_EQ(0U, DestructorCall::List().size());
// This creates another DestructorTracker object in the new thread. // This creates another DestructorTracker object in the new thread.
ThreadWithParam<ThreadParam> thread( ThreadWithParam<ThreadParam> thread(&CallThreadLocalGet,
&CallThreadLocalGet, &thread_local_tracker, NULL); &thread_local_tracker, nullptr);
thread.Join(); thread.Join();
// The thread has exited, and we should have a DestroyedTracker // The thread has exited, and we should have a DestroyedTracker

28
googletest/test/googletest-printers-test.cc
View File

@ -405,7 +405,7 @@ TEST(PrintCStringTest, NonConst) {
// NULL C string. // NULL C string.
TEST(PrintCStringTest, Null) { TEST(PrintCStringTest, Null) {
const char* p = NULL; const char* p = nullptr;
EXPECT_EQ("NULL", Print(p)); EXPECT_EQ("NULL", Print(p));
} }
@ -440,7 +440,7 @@ TEST(PrintWideCStringTest, NonConst) {
// NULL wide C string. // NULL wide C string.
TEST(PrintWideCStringTest, Null) { TEST(PrintWideCStringTest, Null) {
const wchar_t* p = NULL; const wchar_t* p = nullptr;
EXPECT_EQ("NULL", Print(p)); EXPECT_EQ("NULL", Print(p));
} }
@ -460,7 +460,7 @@ TEST(PrintWideCStringTest, EscapesProperly) {
TEST(PrintCharPointerTest, SignedChar) { TEST(PrintCharPointerTest, SignedChar) {
signed char* p = reinterpret_cast<signed char*>(0x1234); signed char* p = reinterpret_cast<signed char*>(0x1234);
EXPECT_EQ(PrintPointer(p), Print(p)); EXPECT_EQ(PrintPointer(p), Print(p));
p = NULL; p = nullptr;
EXPECT_EQ("NULL", Print(p)); EXPECT_EQ("NULL", Print(p));
} }
@ -468,7 +468,7 @@ TEST(PrintCharPointerTest, SignedChar) {
TEST(PrintCharPointerTest, ConstSignedChar) { TEST(PrintCharPointerTest, ConstSignedChar) {
signed char* p = reinterpret_cast<signed char*>(0x1234); signed char* p = reinterpret_cast<signed char*>(0x1234);
EXPECT_EQ(PrintPointer(p), Print(p)); EXPECT_EQ(PrintPointer(p), Print(p));
p = NULL; p = nullptr;
EXPECT_EQ("NULL", Print(p)); EXPECT_EQ("NULL", Print(p));
} }
@ -476,7 +476,7 @@ TEST(PrintCharPointerTest, ConstSignedChar) {
TEST(PrintCharPointerTest, UnsignedChar) { TEST(PrintCharPointerTest, UnsignedChar) {
unsigned char* p = reinterpret_cast<unsigned char*>(0x1234); unsigned char* p = reinterpret_cast<unsigned char*>(0x1234);
EXPECT_EQ(PrintPointer(p), Print(p)); EXPECT_EQ(PrintPointer(p), Print(p));
p = NULL; p = nullptr;
EXPECT_EQ("NULL", Print(p)); EXPECT_EQ("NULL", Print(p));
} }
@ -484,7 +484,7 @@ TEST(PrintCharPointerTest, UnsignedChar) {
TEST(PrintCharPointerTest, ConstUnsignedChar) { TEST(PrintCharPointerTest, ConstUnsignedChar) {
const unsigned char* p = reinterpret_cast<const unsigned char*>(0x1234); const unsigned char* p = reinterpret_cast<const unsigned char*>(0x1234);
EXPECT_EQ(PrintPointer(p), Print(p)); EXPECT_EQ(PrintPointer(p), Print(p));
p = NULL; p = nullptr;
EXPECT_EQ("NULL", Print(p)); EXPECT_EQ("NULL", Print(p));
} }
@ -494,7 +494,7 @@ TEST(PrintCharPointerTest, ConstUnsignedChar) {
TEST(PrintPointerToBuiltInTypeTest, Bool) { TEST(PrintPointerToBuiltInTypeTest, Bool) {
bool* p = reinterpret_cast<bool*>(0xABCD); bool* p = reinterpret_cast<bool*>(0xABCD);
EXPECT_EQ(PrintPointer(p), Print(p)); EXPECT_EQ(PrintPointer(p), Print(p));
p = NULL; p = nullptr;
EXPECT_EQ("NULL", Print(p)); EXPECT_EQ("NULL", Print(p));
} }
@ -502,7 +502,7 @@ TEST(PrintPointerToBuiltInTypeTest, Bool) {
TEST(PrintPointerToBuiltInTypeTest, Void) { TEST(PrintPointerToBuiltInTypeTest, Void) {
void* p = reinterpret_cast<void*>(0xABCD); void* p = reinterpret_cast<void*>(0xABCD);
EXPECT_EQ(PrintPointer(p), Print(p)); EXPECT_EQ(PrintPointer(p), Print(p));
p = NULL; p = nullptr;
EXPECT_EQ("NULL", Print(p)); EXPECT_EQ("NULL", Print(p));
} }
@ -510,7 +510,7 @@ TEST(PrintPointerToBuiltInTypeTest, Void) {
TEST(PrintPointerToBuiltInTypeTest, ConstVoid) { TEST(PrintPointerToBuiltInTypeTest, ConstVoid) {
const void* p = reinterpret_cast<const void*>(0xABCD); const void* p = reinterpret_cast<const void*>(0xABCD);
EXPECT_EQ(PrintPointer(p), Print(p)); EXPECT_EQ(PrintPointer(p), Print(p));
p = NULL; p = nullptr;
EXPECT_EQ("NULL", Print(p)); EXPECT_EQ("NULL", Print(p));
} }
@ -518,7 +518,7 @@ TEST(PrintPointerToBuiltInTypeTest, ConstVoid) {
TEST(PrintPointerToPointerTest, IntPointerPointer) { TEST(PrintPointerToPointerTest, IntPointerPointer) {
int** p = reinterpret_cast<int**>(0xABCD); int** p = reinterpret_cast<int**>(0xABCD);
EXPECT_EQ(PrintPointer(p), Print(p)); EXPECT_EQ(PrintPointer(p), Print(p));
p = NULL; p = nullptr;
EXPECT_EQ("NULL", Print(p)); EXPECT_EQ("NULL", Print(p));
} }
@ -1398,7 +1398,7 @@ TEST(FormatForComparisonFailureMessageTest, WorksForWCharPointerVsStdWString) {
// char array vs pointer // char array vs pointer
TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsPointer) { TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsPointer) {
char str[] = "hi \"world\""; char str[] = "hi \"world\"";
char* p = NULL; char* p = nullptr;
EXPECT_EQ(PrintPointer(str), EXPECT_EQ(PrintPointer(str),
FormatForComparisonFailureMessage(str, p).c_str()); FormatForComparisonFailureMessage(str, p).c_str());
} }
@ -1413,7 +1413,7 @@ TEST(FormatForComparisonFailureMessageTest, WorksForCharArrayVsCharArray) {
// wchar_t array vs pointer // wchar_t array vs pointer
TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsPointer) { TEST(FormatForComparisonFailureMessageTest, WorksForWCharArrayVsPointer) {
wchar_t str[] = L"hi \"world\""; wchar_t str[] = L"hi \"world\"";
wchar_t* p = NULL; wchar_t* p = nullptr;
EXPECT_EQ(PrintPointer(str), EXPECT_EQ(PrintPointer(str),
FormatForComparisonFailureMessage(str, p).c_str()); FormatForComparisonFailureMessage(str, p).c_str());
} }
@ -1614,7 +1614,7 @@ TEST(UniversalTersePrintTest, WorksForCString) {
UniversalTersePrint(s2, &ss2); UniversalTersePrint(s2, &ss2);
EXPECT_EQ("\"abc\"", ss2.str()); EXPECT_EQ("\"abc\"", ss2.str());
const char* s3 = NULL; const char* s3 = nullptr;
::std::stringstream ss3; ::std::stringstream ss3;
UniversalTersePrint(s3, &ss3); UniversalTersePrint(s3, &ss3);
EXPECT_EQ("NULL", ss3.str()); EXPECT_EQ("NULL", ss3.str());
@ -1644,7 +1644,7 @@ TEST(UniversalPrintTest, WorksForCString) {
UniversalPrint(s2, &ss2); UniversalPrint(s2, &ss2);
EXPECT_EQ(PrintPointer(s2) + " pointing to \"abc\"", std::string(ss2.str())); EXPECT_EQ(PrintPointer(s2) + " pointing to \"abc\"", std::string(ss2.str()));
const char* s3 = NULL; const char* s3 = nullptr;
::std::stringstream ss3; ::std::stringstream ss3;
UniversalPrint(s3, &ss3); UniversalPrint(s3, &ss3);
EXPECT_EQ("NULL", ss3.str()); EXPECT_EQ("NULL", ss3.str());

2
googletest/test/googletest-throw-on-failure-test_.cc
View File

@ -45,7 +45,7 @@
// ones. // ones.
void TerminateHandler() { void TerminateHandler() {
fprintf(stderr, "%s\n", "Unhandled C++ exception terminating the program."); fprintf(stderr, "%s\n", "Unhandled C++ exception terminating the program.");
fflush(NULL); fflush(nullptr);
exit(1); exit(1);
} }

2
googletest/test/googletest-tuple-test.cc
View File

@ -158,7 +158,7 @@ TEST(TupleConstructorTest, DefaultConstructorDefaultInitializesEachField) {
b3 = a3; b3 = a3;
EXPECT_EQ(0.0, get<0>(b3)); EXPECT_EQ(0.0, get<0>(b3));
EXPECT_EQ('\0', get<1>(b3)); EXPECT_EQ('\0', get<1>(b3));
EXPECT_TRUE(get<2>(b3) == NULL); EXPECT_TRUE(get<2>(b3) == nullptr);
tuple<int, int, int, int, int, int, int, int, int, int> a10, b10; tuple<int, int, int, int, int, int, int, int, int, int> a10, b10;
b10 = a10; b10 = a10;

8
googletest/test/gtest-typed-test_test.cc
View File

@ -55,7 +55,7 @@ class CommonTest : public Test {
static void TearDownTestCase() { static void TearDownTestCase() {
delete shared_; delete shared_;
shared_ = NULL; shared_ = nullptr;
} }
// This 'protected:' is optional. There's no harm in making all // This 'protected:' is optional. There's no harm in making all
@ -85,7 +85,7 @@ class CommonTest : public Test {
}; };
template <typename T> template <typename T>
T* CommonTest<T>::shared_ = NULL; T* CommonTest<T>::shared_ = nullptr;
// This #ifdef block tests typed tests. // This #ifdef block tests typed tests.
#if GTEST_HAS_TYPED_TEST #if GTEST_HAS_TYPED_TEST
@ -121,7 +121,7 @@ TYPED_TEST(CommonTest, ValuesAreCorrect) {
TYPED_TEST(CommonTest, ValuesAreStillCorrect) { TYPED_TEST(CommonTest, ValuesAreStillCorrect) {
// Static members of the fixture class template can also be visited // Static members of the fixture class template can also be visited
// via 'this'. // via 'this'.
ASSERT_TRUE(this->shared_ != NULL); ASSERT_TRUE(this->shared_ != nullptr);
EXPECT_EQ(5, *this->shared_); EXPECT_EQ(5, *this->shared_);
// TypeParam can be used to refer to the type parameter. // TypeParam can be used to refer to the type parameter.
@ -292,7 +292,7 @@ TYPED_TEST_P(DerivedTest, ValuesAreCorrect) {
TYPED_TEST_P(DerivedTest, ValuesAreStillCorrect) { TYPED_TEST_P(DerivedTest, ValuesAreStillCorrect) {
// Static members of the fixture class template can also be visited // Static members of the fixture class template can also be visited
// via 'this'. // via 'this'.
ASSERT_TRUE(this->shared_ != NULL); ASSERT_TRUE(this->shared_ != nullptr);
EXPECT_EQ(5, *this->shared_); EXPECT_EQ(5, *this->shared_);
EXPECT_EQ(2, this->value_); EXPECT_EQ(2, this->value_);
} }

12
googletest/test/gtest-unittest-api_test.cc
View File

@ -76,7 +76,7 @@ class UnitTestHelper {
if (0 == strcmp(test_case->name(), name)) if (0 == strcmp(test_case->name(), name))
return test_case; return test_case;
} }
return NULL; return nullptr;
} }
// Returns the array of pointers to all tests in a particular test case // Returns the array of pointers to all tests in a particular test case
@ -137,7 +137,7 @@ TEST(ApiTest, UnitTestImmutableAccessorsWork) {
} }
AssertionResult IsNull(const char* str) { AssertionResult IsNull(const char* str) {
if (str != NULL) { if (str != nullptr) {
return testing::AssertionFailure() << "argument is " << str; return testing::AssertionFailure() << "argument is " << str;
} }
return AssertionSuccess(); return AssertionSuccess();
@ -145,7 +145,7 @@ AssertionResult IsNull(const char* str) {
TEST(ApiTest, TestCaseImmutableAccessorsWork) { TEST(ApiTest, TestCaseImmutableAccessorsWork) {
const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest"); const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
ASSERT_TRUE(test_case != NULL); ASSERT_TRUE(test_case != nullptr);
EXPECT_STREQ("ApiTest", test_case->name()); EXPECT_STREQ("ApiTest", test_case->name());
EXPECT_TRUE(IsNull(test_case->type_param())); EXPECT_TRUE(IsNull(test_case->type_param()));
@ -181,11 +181,11 @@ TEST(ApiTest, TestCaseImmutableAccessorsWork) {
EXPECT_TRUE(tests[3]->should_run()); EXPECT_TRUE(tests[3]->should_run());
delete[] tests; delete[] tests;
tests = NULL; tests = nullptr;
#if GTEST_HAS_TYPED_TEST #if GTEST_HAS_TYPED_TEST
test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0"); test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
ASSERT_TRUE(test_case != NULL); ASSERT_TRUE(test_case != nullptr);
EXPECT_STREQ("TestCaseWithCommentTest/0", test_case->name()); EXPECT_STREQ("TestCaseWithCommentTest/0", test_case->name());
EXPECT_STREQ(GetTypeName<int>().c_str(), test_case->type_param()); EXPECT_STREQ(GetTypeName<int>().c_str(), test_case->type_param());
@ -208,7 +208,7 @@ TEST(ApiTest, TestCaseImmutableAccessorsWork) {
TEST(ApiTest, TestCaseDisabledAccessorsWork) { TEST(ApiTest, TestCaseDisabledAccessorsWork) {
const TestCase* test_case = UnitTestHelper::FindTestCase("DISABLED_Test"); const TestCase* test_case = UnitTestHelper::FindTestCase("DISABLED_Test");
ASSERT_TRUE(test_case != NULL); ASSERT_TRUE(test_case != nullptr);
EXPECT_STREQ("DISABLED_Test", test_case->name()); EXPECT_STREQ("DISABLED_Test", test_case->name());
EXPECT_TRUE(IsNull(test_case->type_param())); EXPECT_TRUE(IsNull(test_case->type_param()));

3
googletest/test/gtest_assert_by_exception_test.cc
View File

@ -80,8 +80,7 @@ TEST(Test, Test) {
try { try {
AssertFalse(); AssertFalse();
} catch(const testing::AssertionException& e) { } catch(const testing::AssertionException& e) {
if (strstr(e.what(), "Expected failure") != NULL) if (strstr(e.what(), "Expected failure") != nullptr) throw;
throw;
printf("%s", printf("%s",
"A failed assertion did throw an exception of the right type, " "A failed assertion did throw an exception of the right type, "

4
googletest/test/gtest_premature_exit_test.cc
View File

@ -56,7 +56,7 @@ class PrematureExitTest : public Test {
premature_exit_file_path_ = GetEnv("TEST_PREMATURE_EXIT_FILE"); premature_exit_file_path_ = GetEnv("TEST_PREMATURE_EXIT_FILE");
// Normalize NULL to "" for ease of handling. // Normalize NULL to "" for ease of handling.
if (premature_exit_file_path_ == NULL) { if (premature_exit_file_path_ == nullptr) {
premature_exit_file_path_ = ""; premature_exit_file_path_ = "";
} }
} }
@ -113,7 +113,7 @@ int main(int argc, char **argv) {
// Test that the premature-exit file is deleted upon return from // Test that the premature-exit file is deleted upon return from
// RUN_ALL_TESTS(). // RUN_ALL_TESTS().
const char* const filepath = GetEnv("TEST_PREMATURE_EXIT_FILE"); const char* const filepath = GetEnv("TEST_PREMATURE_EXIT_FILE");
if (filepath != NULL && *filepath != '\0') { if (filepath != nullptr && *filepath != '\0') {
if (PrematureExitTest::FileExists(filepath)) { if (PrematureExitTest::FileExists(filepath)) {
printf( printf(
"File %s shouldn't exist after the test program finishes, but does.", "File %s shouldn't exist after the test program finishes, but does.",

2
googletest/test/gtest_stress_test.cc
View File

@ -163,7 +163,7 @@ void FailingThread(bool is_fatal) {
} }
void GenerateFatalFailureInAnotherThread(bool is_fatal) { void GenerateFatalFailureInAnotherThread(bool is_fatal) {
ThreadWithParam<bool> thread(&FailingThread, is_fatal, NULL); ThreadWithParam<bool> thread(&FailingThread, is_fatal, nullptr);
thread.Join(); thread.Join();
} }

3
googletest/test/gtest_throw_on_failure_ex_test.cc
View File

@ -63,8 +63,7 @@ void TestFailureThrowsRuntimeError() {
try { try {
EXPECT_EQ(2, 3) << "Expected failure"; EXPECT_EQ(2, 3) << "Expected failure";
} catch(const std::runtime_error& e) { } catch(const std::runtime_error& e) {
if (strstr(e.what(), "Expected failure") != NULL) if (strstr(e.what(), "Expected failure") != nullptr) return;
return;
printf("%s", printf("%s",
"A failed assertion did throw an exception of the right type, " "A failed assertion did throw an exception of the right type, "

693
googletest/test/gtest_unittest.cc
View File

File diff suppressed because it is too large Load Diff