blob: f56dc6d7aceed760863b1d96a27b0de161fcea62 [file] [log] [blame]
/*
* Copyright 2015 The WebRTC Project Authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
// TODO(bugs.webrtc.org/8821): Delete this file when absl unittests run on
// webrtc bots.
#include <memory>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#include "api/optional.h"
#include "rtc_base/gunit.h"
namespace rtc {
namespace {
struct MyUnprintableType {
int value;
};
struct MyPrintableType {
int value;
};
struct MyOstreamPrintableType {
int value;
};
void PrintTo(const MyPrintableType& mpt, std::ostream* os) {
*os << "The value is " << mpt.value;
}
std::ostream& operator<<(std::ostream& os, const MyPrintableType& mpt) {
os << mpt.value;
return os;
}
std::ostream& operator<<(std::ostream& os, const MyOstreamPrintableType& mpt) {
os << mpt.value;
return os;
}
// Class whose instances logs various method calls (constructor, destructor,
// etc.). Each instance has a unique ID (a simple global sequence number) and
// an origin ID. When a copy is made, the new object gets a fresh ID but copies
// the origin ID from the original. When a new Logger is created from scratch,
// it gets a fresh ID, and the origin ID is the same as the ID (default
// constructor) or given as an argument (explicit constructor).
class Logger {
public:
Logger() : id_(g_next_id++), origin_(id_) { Log("default constructor"); }
explicit Logger(int origin) : id_(g_next_id++), origin_(origin) {
Log("explicit constructor");
}
Logger(int origin, const Logger& pass_by_ref, Logger pass_by_value)
: id_(g_next_id++), origin_(origin) {
Log("multi parameter constructor");
}
Logger(const Logger& other) : id_(g_next_id++), origin_(other.origin_) {
LogFrom("copy constructor", other);
}
Logger(Logger&& other) : id_(g_next_id++), origin_(other.origin_) {
LogFrom("move constructor", other);
}
~Logger() { Log("destructor"); }
Logger& operator=(const Logger& other) {
origin_ = other.origin_;
LogFrom("operator= copy", other);
return *this;
}
Logger& operator=(Logger&& other) {
origin_ = other.origin_;
LogFrom("operator= move", other);
return *this;
}
friend void swap(Logger& a, Logger& b) {
using std::swap;
swap(a.origin_, b.origin_);
Log2("swap", a, b);
}
friend bool operator==(const Logger& a, const Logger& b) {
Log2("operator==", a, b);
return a.origin_ == b.origin_;
}
friend bool operator!=(const Logger& a, const Logger& b) {
Log2("operator!=", a, b);
return a.origin_ != b.origin_;
}
void Foo() { Log("Foo()"); }
void Foo() const { Log("Foo() const"); }
static std::unique_ptr<std::vector<std::string>> Setup() {
std::unique_ptr<std::vector<std::string>> s(new std::vector<std::string>);
g_log = s.get();
g_next_id = 0;
return s;
}
private:
int id_;
int origin_;
static std::vector<std::string>* g_log;
static int g_next_id;
void Log(const char* msg) const {
std::ostringstream oss;
oss << id_ << ':' << origin_ << ". " << msg;
g_log->push_back(oss.str());
}
void LogFrom(const char* msg, const Logger& other) const {
std::ostringstream oss;
oss << id_ << ':' << origin_ << ". " << msg << " (from " << other.id_ << ':'
<< other.origin_ << ")";
g_log->push_back(oss.str());
}
static void Log2(const char* msg, const Logger& a, const Logger& b) {
std::ostringstream oss;
oss << msg << ' ' << a.id_ << ':' << a.origin_ << ", " << b.id_ << ':'
<< b.origin_;
g_log->push_back(oss.str());
}
};
std::vector<std::string>* Logger::g_log = nullptr;
int Logger::g_next_id = 0;
// Append all the other args to the vector pointed to by the first arg.
template <typename T>
void VectorAppend(std::vector<T>* v) {}
template <typename T, typename... Ts>
void VectorAppend(std::vector<T>* v, const T& e, Ts... es) {
v->push_back(e);
VectorAppend(v, es...);
}
// Create a vector of strings. Because we're not allowed to use
// std::initializer_list.
template <typename... Ts>
std::vector<std::string> V(Ts... es) {
std::vector<std::string> strings;
VectorAppend(&strings, static_cast<std::string>(es)...);
return strings;
}
} // namespace
TEST(OptionalTest, TestConstructDefault) {
auto log = Logger::Setup();
{
Optional<Logger> x;
EXPECT_FALSE(x);
EXPECT_FALSE(x.has_value());
}
EXPECT_EQ(V(), *log);
}
TEST(OptionalTest, TestConstructNullopt) {
auto log = Logger::Setup();
{
Optional<Logger> x(nullopt);
EXPECT_FALSE(x);
EXPECT_FALSE(x.has_value());
}
EXPECT_EQ(V(), *log);
}
TEST(OptionalTest, TestConstructCopyEmpty) {
auto log = Logger::Setup();
{
Optional<Logger> x;
EXPECT_FALSE(x);
EXPECT_FALSE(x.has_value());
auto y = x;
EXPECT_FALSE(y);
EXPECT_FALSE(y.has_value());
}
EXPECT_EQ(V(), *log);
}
TEST(OptionalTest, TestConstructCopyFull) {
auto log = Logger::Setup();
{
Logger a;
Optional<Logger> x(a);
EXPECT_TRUE(x);
EXPECT_TRUE(x.has_value());
log->push_back("---");
auto y = x;
EXPECT_TRUE(y);
EXPECT_TRUE(y.has_value());
log->push_back("---");
}
EXPECT_EQ(V("0:0. default constructor", "1:0. copy constructor (from 0:0)",
"---", "2:0. copy constructor (from 1:0)", "---",
"2:0. destructor", "1:0. destructor", "0:0. destructor"),
*log);
}
TEST(OptionalTest, TestConstructMoveEmpty) {
auto log = Logger::Setup();
{
Optional<Logger> x;
EXPECT_FALSE(x);
EXPECT_FALSE(x.has_value());
auto y = std::move(x);
EXPECT_FALSE(y);
EXPECT_FALSE(y.has_value());
}
EXPECT_EQ(V(), *log);
}
TEST(OptionalTest, TestConstructMoveFull) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(17));
EXPECT_TRUE(x);
EXPECT_TRUE(x.has_value());
log->push_back("---");
auto y = std::move(x);
EXPECT_TRUE(x);
EXPECT_TRUE(x.has_value());
EXPECT_TRUE(y);
EXPECT_TRUE(y.has_value());
log->push_back("---");
}
EXPECT_EQ(
V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
"0:17. destructor", "---", "2:17. move constructor (from 1:17)", "---",
"2:17. destructor", "1:17. destructor"),
*log);
}
TEST(OptionalTest, TestCopyAssignToEmptyFromEmpty) {
auto log = Logger::Setup();
{
Optional<Logger> x, y;
x = y;
}
EXPECT_EQ(V(), *log);
}
TEST(OptionalTest, TestCopyAssignToFullFromEmpty) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(17));
Optional<Logger> y;
log->push_back("---");
x = y;
log->push_back("---");
}
EXPECT_EQ(
V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
"0:17. destructor", "---", "1:17. destructor", "---"),
*log);
}
TEST(OptionalTest, TestCopyAssignToFullFromNullopt) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(17));
log->push_back("---");
x = nullopt;
log->push_back("---");
EXPECT_FALSE(x);
}
EXPECT_EQ(
V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
"0:17. destructor", "---", "1:17. destructor", "---"),
*log);
}
TEST(OptionalTest, TestCopyAssignToFullFromEmptyBraces) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(17));
log->push_back("---");
x = {};
log->push_back("---");
EXPECT_FALSE(x);
}
EXPECT_EQ(
V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
"0:17. destructor", "---", "1:17. destructor", "---"),
*log);
}
TEST(OptionalTest, TestCopyAssignToEmptyFromFull) {
auto log = Logger::Setup();
{
Optional<Logger> x;
Optional<Logger> y(Logger(17));
log->push_back("---");
x = y;
log->push_back("---");
}
EXPECT_EQ(
V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
"0:17. destructor", "---", "2:17. copy constructor (from 1:17)", "---",
"1:17. destructor", "2:17. destructor"),
*log);
}
TEST(OptionalTest, TestCopyAssignToFullFromFull) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(17));
Optional<Logger> y(Logger(42));
log->push_back("---");
x = y;
log->push_back("---");
}
EXPECT_EQ(
V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
"0:17. destructor", "2:42. explicit constructor",
"3:42. move constructor (from 2:42)", "2:42. destructor", "---",
"1:42. operator= copy (from 3:42)", "---", "3:42. destructor",
"1:42. destructor"),
*log);
}
TEST(OptionalTest, TestCopyAssignToEmptyFromT) {
auto log = Logger::Setup();
{
Optional<Logger> x;
Logger y(17);
log->push_back("---");
x = Optional<Logger>(y);
log->push_back("---");
}
EXPECT_EQ(V("0:17. explicit constructor", "---",
"1:17. copy constructor (from 0:17)",
"2:17. move constructor (from 1:17)", "1:17. destructor", "---",
"0:17. destructor", "2:17. destructor"),
*log);
}
TEST(OptionalTest, TestCopyAssignToFullFromT) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(17));
Logger y(42);
log->push_back("---");
x = Optional<Logger>(y);
log->push_back("---");
}
EXPECT_EQ(
V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
"0:17. destructor", "2:42. explicit constructor", "---",
"3:42. copy constructor (from 2:42)",
"1:42. operator= move (from 3:42)", "3:42. destructor", "---",
"2:42. destructor", "1:42. destructor"),
*log);
}
TEST(OptionalTest, TestMoveAssignToEmptyFromEmpty) {
auto log = Logger::Setup();
{
Optional<Logger> x, y;
x = std::move(y);
}
EXPECT_EQ(V(), *log);
}
TEST(OptionalTest, TestMoveAssignToFullFromEmpty) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(17));
Optional<Logger> y;
log->push_back("---");
x = std::move(y);
log->push_back("---");
}
EXPECT_EQ(
V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
"0:17. destructor", "---", "1:17. destructor", "---"),
*log);
}
TEST(OptionalTest, TestMoveAssignToEmptyFromFull) {
auto log = Logger::Setup();
{
Optional<Logger> x;
Optional<Logger> y(Logger(17));
log->push_back("---");
x = std::move(y);
log->push_back("---");
}
EXPECT_EQ(
V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
"0:17. destructor", "---", "2:17. move constructor (from 1:17)", "---",
"1:17. destructor", "2:17. destructor"),
*log);
}
TEST(OptionalTest, TestMoveAssignToFullFromFull) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(17));
Optional<Logger> y(Logger(42));
log->push_back("---");
x = std::move(y);
log->push_back("---");
}
EXPECT_EQ(
V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
"0:17. destructor", "2:42. explicit constructor",
"3:42. move constructor (from 2:42)", "2:42. destructor", "---",
"1:42. operator= move (from 3:42)", "---", "3:42. destructor",
"1:42. destructor"),
*log);
}
TEST(OptionalTest, TestMoveAssignToEmptyFromT) {
auto log = Logger::Setup();
{
Optional<Logger> x;
Logger y(17);
log->push_back("---");
x = Optional<Logger>(std::move(y));
log->push_back("---");
}
EXPECT_EQ(V("0:17. explicit constructor", "---",
"1:17. move constructor (from 0:17)",
"2:17. move constructor (from 1:17)", "1:17. destructor", "---",
"0:17. destructor", "2:17. destructor"),
*log);
}
TEST(OptionalTest, TestMoveAssignToFullFromT) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(17));
Logger y(42);
log->push_back("---");
x = Optional<Logger>(std::move(y));
log->push_back("---");
}
EXPECT_EQ(
V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
"0:17. destructor", "2:42. explicit constructor", "---",
"3:42. move constructor (from 2:42)",
"1:42. operator= move (from 3:42)", "3:42. destructor", "---",
"2:42. destructor", "1:42. destructor"),
*log);
}
TEST(OptionalTest, TestResetEmpty) {
auto log = Logger::Setup();
{
Optional<Logger> x;
x.reset();
}
EXPECT_EQ(V(), *log);
}
TEST(OptionalTest, TestResetFull) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(17));
log->push_back("---");
x.reset();
log->push_back("---");
}
EXPECT_EQ(
V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
"0:17. destructor", "---", "1:17. destructor", "---"),
*log);
}
TEST(OptionalTest, TestEmplaceEmptyWithExplicit) {
auto log = Logger::Setup();
{
Optional<Logger> x;
log->push_back("---");
x.emplace(42);
log->push_back("---");
}
// clang-format off
EXPECT_EQ(V("---",
"0:42. explicit constructor",
"---",
"0:42. destructor"),
*log);
// clang-format on
}
TEST(OptionalTest, TestEmplaceEmptyWithMultipleParameters) {
auto log = Logger::Setup();
{
Optional<Logger> x;
Logger ref(21);
Logger value(35);
log->push_back("---");
x.emplace(42, ref, std::move(value));
log->push_back("---");
}
// clang-format off
EXPECT_EQ(V("0:21. explicit constructor",
"1:35. explicit constructor",
"---",
"2:35. move constructor (from 1:35)",
"3:42. multi parameter constructor",
"2:35. destructor",
"---",
"1:35. destructor",
"0:21. destructor",
"3:42. destructor"),
*log);
// clang-format on
}
TEST(OptionalTest, TestEmplaceEmptyWithCopy) {
auto log = Logger::Setup();
{
Optional<Logger> x;
Logger y(42);
log->push_back("---");
x.emplace(y);
log->push_back("---");
}
// clang-format off
EXPECT_EQ(V("0:42. explicit constructor",
"---",
"1:42. copy constructor (from 0:42)",
"---",
"0:42. destructor",
"1:42. destructor"),
*log);
// clang-format on
}
TEST(OptionalTest, TestEmplaceEmptyWithMove) {
auto log = Logger::Setup();
{
Optional<Logger> x;
Logger y(42);
log->push_back("---");
x.emplace(std::move(y));
log->push_back("---");
}
// clang-format off
EXPECT_EQ(V("0:42. explicit constructor",
"---",
"1:42. move constructor (from 0:42)",
"---",
"0:42. destructor",
"1:42. destructor"),
*log);
// clang-format on
}
TEST(OptionalTest, TestEmplaceFullWithExplicit) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(17));
log->push_back("---");
x.emplace(42);
log->push_back("---");
}
// clang-format off
EXPECT_EQ(
V("0:17. explicit constructor",
"1:17. move constructor (from 0:17)",
"0:17. destructor",
"---",
"1:17. destructor",
"2:42. explicit constructor",
"---",
"2:42. destructor"),
*log);
// clang-format on
}
TEST(OptionalTest, TestEmplaceFullWithMultipleParameters) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(17));
Logger ref(21);
Logger value(35);
log->push_back("---");
x.emplace(42, ref, std::move(value));
log->push_back("---");
}
// clang-format off
EXPECT_EQ(V("0:17. explicit constructor",
"1:17. move constructor (from 0:17)",
"0:17. destructor",
"2:21. explicit constructor",
"3:35. explicit constructor",
"---",
"1:17. destructor",
"4:35. move constructor (from 3:35)",
"5:42. multi parameter constructor",
"4:35. destructor",
"---",
"3:35. destructor",
"2:21. destructor",
"5:42. destructor"),
*log);
// clang-format on
}
TEST(OptionalTest, TestEmplaceFullWithCopy) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(17));
Logger y(42);
log->push_back("---");
x.emplace(y);
log->push_back("---");
}
// clang-format off
EXPECT_EQ(V("0:17. explicit constructor",
"1:17. move constructor (from 0:17)",
"0:17. destructor",
"2:42. explicit constructor",
"---",
"1:17. destructor",
"3:42. copy constructor (from 2:42)",
"---",
"2:42. destructor",
"3:42. destructor"),
*log);
// clang-format on
}
TEST(OptionalTest, TestEmplaceFullWithMove) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(17));
Logger y(42);
log->push_back("---");
x.emplace(std::move(y));
log->push_back("---");
}
// clang-format off
EXPECT_EQ(V("0:17. explicit constructor",
"1:17. move constructor (from 0:17)",
"0:17. destructor",
"2:42. explicit constructor",
"---",
"1:17. destructor",
"3:42. move constructor (from 2:42)",
"---",
"2:42. destructor",
"3:42. destructor"),
*log);
// clang-format on
}
TEST(OptionalTest, TestDereference) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(42));
const auto& y = x;
log->push_back("---");
x->Foo();
y->Foo();
std::move(x)->Foo();
std::move(y)->Foo();
log->push_back("---");
(*x).Foo();
(*y).Foo();
(*std::move(x)).Foo();
(*std::move(y)).Foo();
log->push_back("---");
x.value().Foo();
y.value().Foo();
std::move(x).value().Foo();
std::move(y).value().Foo();
log->push_back("---");
}
// clang-format off
EXPECT_EQ(V("0:42. explicit constructor",
"1:42. move constructor (from 0:42)",
"0:42. destructor",
"---",
"1:42. Foo()",
"1:42. Foo() const",
"1:42. Foo()",
"1:42. Foo() const",
"---",
"1:42. Foo()",
"1:42. Foo() const",
"1:42. Foo()",
"1:42. Foo() const",
"---",
"1:42. Foo()",
"1:42. Foo() const",
"1:42. Foo()",
"1:42. Foo() const",
"---",
"1:42. destructor"),
*log);
// clang-format on
}
TEST(OptionalTest, TestDereferenceWithDefault) {
auto log = Logger::Setup();
const Logger a(17), b(42);
Optional<Logger> x(a);
Optional<Logger> y;
EXPECT_EQ(a, x.value_or(Logger(42)));
EXPECT_EQ(b, y.value_or(Logger(42)));
EXPECT_EQ(a, Optional<Logger>(Logger(17)).value_or(b));
EXPECT_EQ(b, Optional<Logger>().value_or(b));
// Can't expect exact list of constructors and destructors because it is
// compiler-dependent. i.e. msvc produce different output than clang. Calls
// above are subject to copy elision that allow to change behavior.
}
TEST(OptionalTest, TestEquality) {
auto log = Logger::Setup();
{
Logger a(17), b(42);
Optional<Logger> ma1(a), ma2(a), mb(b), me1, me2;
log->push_back("---");
EXPECT_EQ(ma1, ma1);
EXPECT_EQ(ma1, ma2);
EXPECT_NE(ma1, mb);
EXPECT_NE(ma1, me1);
EXPECT_EQ(me1, me1);
EXPECT_EQ(me1, me2);
log->push_back("---");
}
EXPECT_EQ(
V("0:17. explicit constructor", "1:42. explicit constructor",
"2:17. copy constructor (from 0:17)",
"3:17. copy constructor (from 0:17)",
"4:42. copy constructor (from 1:42)", "---", "operator== 2:17, 2:17",
"operator== 2:17, 3:17", "operator!= 2:17, 4:42", "---",
"4:42. destructor", "3:17. destructor", "2:17. destructor",
"1:42. destructor", "0:17. destructor"),
*log);
}
TEST(OptionalTest, TestEqualityWithNullopt) {
auto log = Logger::Setup();
{
Logger a(17);
Optional<Logger> ma(a), me;
// Using operator== and operator!= explicitly instead of EXPECT_EQ/EXPECT_NE
// macros because those operators are under test.
log->push_back("---");
EXPECT_FALSE(ma == nullopt);
EXPECT_FALSE(nullopt == ma);
EXPECT_TRUE(me == nullopt);
EXPECT_TRUE(nullopt == me);
EXPECT_TRUE(ma != nullopt);
EXPECT_TRUE(nullopt != ma);
EXPECT_FALSE(me != nullopt);
EXPECT_FALSE(nullopt != me);
log->push_back("---");
}
// clang-format off
EXPECT_EQ(V("0:17. explicit constructor",
"1:17. copy constructor (from 0:17)",
"---",
// No operators should be called when comparing to empty.
"---",
"1:17. destructor",
"0:17. destructor"),
*log);
// clang-format on
}
TEST(OptionalTest, TestEqualityWithObject) {
auto log = Logger::Setup();
{
Logger a(17), b(42);
Optional<Logger> ma(a), me;
// Using operator== and operator!= explicitly instead of EXPECT_EQ/EXPECT_NE
// macros because those operators are under test.
log->push_back("---");
EXPECT_TRUE(ma == a);
EXPECT_TRUE(a == ma);
EXPECT_FALSE(ma == b);
EXPECT_FALSE(b == ma);
EXPECT_FALSE(me == a);
EXPECT_FALSE(a == me);
EXPECT_FALSE(ma != a);
EXPECT_FALSE(a != ma);
EXPECT_TRUE(ma != b);
EXPECT_TRUE(b != ma);
EXPECT_TRUE(me != a);
EXPECT_TRUE(a != me);
log->push_back("---");
}
// clang-format off
EXPECT_EQ(V("0:17. explicit constructor",
"1:42. explicit constructor",
"2:17. copy constructor (from 0:17)",
"---",
"operator== 2:17, 0:17",
"operator== 0:17, 2:17",
"operator== 2:17, 1:42",
"operator== 1:42, 2:17",
// No operator should be called when comparing to empty.
"operator!= 2:17, 0:17",
"operator!= 0:17, 2:17",
"operator!= 2:17, 1:42",
"operator!= 1:42, 2:17",
// No operator should be called when comparing to empty.
"---",
"2:17. destructor",
"1:42. destructor",
"0:17. destructor"),
*log);
// clang-format on
}
TEST(OptionalTest, TestSwap) {
auto log = Logger::Setup();
{
Logger a(17), b(42);
Optional<Logger> x1(a), x2(b), y1(a), y2, z1, z2;
log->push_back("---");
swap(x1, x2); // Swap full <-> full.
swap(y1, y2); // Swap full <-> empty.
swap(z1, z2); // Swap empty <-> empty.
log->push_back("---");
}
EXPECT_EQ(V("0:17. explicit constructor", "1:42. explicit constructor",
"2:17. copy constructor (from 0:17)",
"3:42. copy constructor (from 1:42)",
"4:17. copy constructor (from 0:17)", "---", "swap 2:42, 3:17",
"5:17. move constructor (from 4:17)", "4:17. destructor", "---",
"5:17. destructor", "3:17. destructor", "2:42. destructor",
"1:42. destructor", "0:17. destructor"),
*log);
}
TEST(OptionalTest, TestMoveValue) {
auto log = Logger::Setup();
{
Optional<Logger> x(Logger(42));
log->push_back("---");
Logger moved = std::move(x.value());
log->push_back("---");
}
EXPECT_EQ(
V("0:42. explicit constructor", "1:42. move constructor (from 0:42)",
"0:42. destructor", "---", "2:42. move constructor (from 1:42)", "---",
"2:42. destructor", "1:42. destructor"),
*log);
}
// Nice printing available only when GTEST aware ABSL is present
#ifdef GTEST_HAS_ABSL
#define MaybeTestPrintTo TestPrintTo
#define MaybeTestUnprintablePrintTo TestUnprintablePrintTo
#else
#define MaybeTestPrintTo DISABLED_TestPrintTo
#define MaybeTestUnprintablePrintTo DISABLED_TestUnprintablePrintTo
#endif
TEST(OptionalTest, MaybeTestPrintTo) {
constexpr char kEmptyOptionalMessage[] = "(nullopt)";
const Optional<MyUnprintableType> empty_unprintable;
const Optional<MyPrintableType> empty_printable;
const Optional<MyOstreamPrintableType> empty_ostream_printable;
EXPECT_EQ(kEmptyOptionalMessage, ::testing::PrintToString(empty_unprintable));
EXPECT_EQ(kEmptyOptionalMessage, ::testing::PrintToString(empty_printable));
EXPECT_EQ(kEmptyOptionalMessage,
::testing::PrintToString(empty_ostream_printable));
EXPECT_NE("(1)", ::testing::PrintToString(Optional<MyUnprintableType>({1})));
EXPECT_NE("(1)", ::testing::PrintToString(Optional<MyPrintableType>({1})));
EXPECT_EQ("(The value is 1)",
::testing::PrintToString(Optional<MyPrintableType>({1})));
EXPECT_EQ("(1)",
::testing::PrintToString(Optional<MyOstreamPrintableType>({1})));
}
TEST(OptionalTest, MaybeTestUnprintablePrintTo) {
struct UnprintableType {
uint8_t value[5];
};
Optional<UnprintableType> opt({0xa1, 0xb2, 0xc3, 0xd4, 0xe5});
EXPECT_EQ("(5-byte object <A1-B2 C3-D4 E5>)", ::testing::PrintToString(opt));
}
void UnusedFunctionWorkaround() {
// These are here to ensure we don't get warnings about ostream and PrintTo
// for MyPrintableType never getting called.
const MyPrintableType dont_warn{17};
const MyOstreamPrintableType dont_warn2{18};
std::stringstream sstr;
sstr << dont_warn;
PrintTo(dont_warn, &sstr);
sstr << dont_warn2;
}
} // namespace rtc