Have some code:
EXPECT_NE(nullptr,ptr);
And I get the following compilation error:
'operator <<' is ambiguous
could be 'std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<<void>(std::nullptr_t)'
or 'std::basic_ostream<char,std::char_traits<char>> &testing::internal2::operator <<<char,std::char_traits<char>,T>(std::basic_ostream<char,std::char_traits<char>> &,const T &)'
Could this be a library version problem?
If you want to be more explicit, you could also use
EXPECT_TRUE(ptr != nullptr);
(that's what I normally do)
Btw. funnily enough, in my work project I still have to work with C++98 (still building for Sun and AIX, although it will soon go away) and I ended up creating my own NullPtrT class and NullPtr object in the common library, which actually works with gtest EXPECT_EQ and EXPECT_NE macros. So that I can do
EXPECT_NE(NullPtr, ptr);
I don't remember how exactly I made that work :)
operator << for NullPtr (or the PrintTo overload). –
Platinotype nullptr, BTW. –
Tavey #include "gtest.h"
using ::testing::NotNull;
ASSERT_THAT(ptr, NotNull());
This will give you some more descriptive errors and keeps you using the existing framework. Other benefits are compatibility with smart pointers and raw pointers.
Other matchers can be found on the gtest matchers documentation.
EXPECT_THAT. –
Pigmentation I've run into the same problem recently with GTest 1.8.0, but only when using Visual Studio 2019 in C++17 mode. Visual Studio 2019 works fine in C++14 mode, and neither Clang nor GCC seem to have the same problem in C++17 mode.
The issue is that with C++17 there's a new overload in the standard library for the std::ostream::operator<< that takes a nullptr_t, but GTest also provides its own, so your compiler does not know which one to use.
If you have full control over your version of GTest then https://github.com/google/googletest/pull/1620/commits/f66ab00704cd47e4e63ef6d425ca14b9192aaebb is a change for GTest-1.8.0 that resolves the issue: It's not as easy as deleting the overload, because the function in question is a template whose other instantiations are still used. Instead, the solution is to define an explicit void PrintTo(std::nullptr_t, ::std::ostream* os) function that will then automatically be used, no longer deferring to the ambiguous overloads.
When modifying GTest is not an option then the solutions mentioned in the other answers to not use EXPECT_EQ/EXPECT_NE when one parameter is a nullptr_t are your best bet.
Google Test documentation says that,
When comparing a pointer to
NULL, useEXPECT_EQ(ptr, nullptr)instead ofEXPECT_EQ(ptr, NULL)When comparing a pointer to
NULL, useEXPECT_NE(ptr, nullptr)instead ofEXPECT_NE(ptr, NULL).
Therefore, you can just use EXPECT_NE(ptr, nullptr);.
Read more: https://google.github.io/googletest/reference/assertions.html#EXPECT_NE
namespace {
template<class T>
auto not_nullptr(T*p) -> testing::AssertionResult
{
if (p)
return testing::AssertionSuccess();
else
return testing::AssertionFailure() << "pointer is null";
}
}
...
EXPECT_TRUE(not_nullptr(ptr));
reference:
© 2022 - 2024 — McMap. All rights reserved.
EXPECT_TRUE(ptr);? – Fanny>character render horribly when you put them in blockquotes. Better indent 4 spaces and render as code. I'd edit myself, but the mobile UI makes this tricky. – CryptogramEXPECT_NEand read the first paragraphs for some background – Histrionicsusing namespace std;somewhere? – UnworthyEXPECT_TRUE(ptr);works. Thank you! – Chanticleernullptr), and they interact with the old with the old features... in an unpredictable way. – Hypergolic