// Copyright 2017 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "absl/types/optional.h"
// This test is a no-op when absl::optional is an alias for std::optional.
#if !defined(ABSL_USES_STD_OPTIONAL)
#include <string>
#include <type_traits>
#include <utility>
#include "gtest/gtest.h"
#include "absl/base/config.h"
#include "absl/base/internal/raw_logging.h"
#include "absl/meta/type_traits.h"
#include "absl/strings/string_view.h"
struct Hashable {};
namespace std {
template <>
struct hash<Hashable> {
size_t operator()(const Hashable&) { return 0; }
};
} // namespace std
struct NonHashable {};
namespace {
std::string TypeQuals(std::string&) { return "&"; }
std::string TypeQuals(std::string&&) { return "&&"; }
std::string TypeQuals(const std::string&) { return "c&"; }
std::string TypeQuals(const std::string&&) { return "c&&"; }
struct StructorListener {
int construct0 = 0;
int construct1 = 0;
int construct2 = 0;
int listinit = 0;
int copy = 0;
int move = 0;
int copy_assign = 0;
int move_assign = 0;
int destruct = 0;
int volatile_copy = 0;
int volatile_move = 0;
int volatile_copy_assign = 0;
int volatile_move_assign = 0;
};
// Suppress MSVC warnings.
// 4521: multiple copy constructors specified
// 4522: multiple assignment operators specified
// We wrote multiple of them to test that the correct overloads are selected.
#ifdef _MSC_VER
#pragma warning( push )
#pragma warning( disable : 4521)
#pragma warning( disable : 4522)
#endif
struct Listenable {
static StructorListener* listener;
Listenable() { ++listener->construct0; }
explicit Listenable(int /*unused*/) { ++listener->construct1; }
Listenable(int /*unused*/, int /*unused*/) { ++listener->construct2; }
Listenable(std::initializer_list<int> /*unused*/) { ++listener->listinit; }
Listenable(const Listenable& /*unused*/) { ++listener->copy; }
Listenable(const volatile Listenable& /*unused*/) {
++listener->volatile_copy;
}
Listenable(volatile Listenable&& /*unused*/) { ++listener->volatile_move; }
Listenable(Listenable&& /*unused*/) { ++listener->move; }
Listenable& operator=(const Listenable& /*unused*/) {
++listener->copy_assign;
return *this;
}
Listenable& operator=(Listenable&& /*unused*/) {
++listener->move_assign;
return *this;
}
// use void return type instead of volatile T& to work around GCC warning
// when the assignment's returned reference is ignored.
void operator=(const volatile Listenable& /*unused*/) volatile {
++listener->volatile_copy_assign;
}
void operator=(volatile Listenable&& /*unused*/) volatile {
++listener->volatile_move_assign;
}
~Listenable() { ++listener->destruct; }
};
#ifdef _MSC_VER
#pragma warning( pop )
#endif
StructorListener* Listenable::listener = nullptr;
// ABSL_HAVE_NO_CONSTEXPR_INITIALIZER_LIST is defined to 1 when the standard
// library implementation doesn't marked initializer_list's default constructor
// constexpr. The C++11 standard doesn't specify constexpr on it, but C++14
// added it. However, libstdc++ 4.7 marked it constexpr.
#if defined(_LIBCPP_VERSION) && \
(_LIBCPP_STD_VER <= 11 || defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR))
#define ABSL_HAVE_NO_CONSTEXPR_INITIALIZER_LIST 1
#endif
struct ConstexprType {
enum CtorTypes {
kCtorDefault,
kCtorInt,
kCtorInitializerList,
kCtorConstChar
};
constexpr ConstexprType() : x(kCtorDefault) {}
constexpr explicit ConstexprType(int i) : x(kCtorInt) {}
#ifndef ABSL_HAVE_NO_CONSTEXPR_INITIALIZER_LIST
constexpr ConstexprType(std::initializer_list<int> il)
: x(kCtorInitializerList) {}
#endif
constexpr ConstexprType(const char*) // NOLINT(runtime/explicit)
: x(kCtorConstChar) {}
int x;
};
struct Copyable {
Copyable() {}
Copyable(const Copyable&) {}
Copyable& operator=(const Copyable&) { return *this; }
};
struct MoveableThrow {
MoveableThrow() {}
MoveableThrow(MoveableThrow&&) {}
MoveableThrow& operator=(MoveableThrow&&) { return *this; }
};
struct MoveableNoThrow {
MoveableNoThrow() {}
MoveableNoThrow(MoveableNoThrow&&) noexcept {}
MoveableNoThrow& operator=(MoveableNoThrow&&) noexcept { return *this; }
};
struct NonMovable {
NonMovable() {}
NonMovable(const NonMovable&) = delete;
NonMovable& operator=(const NonMovable&) = delete;
NonMovable(NonMovable&&) = delete;
NonMovable& operator=(NonMovable&&) = delete;
};
struct NoDefault {
NoDefault() = delete;
NoDefault(const NoDefault&) {}
NoDefault& operator=(const NoDefault&) { return *this; }
};
struct ConvertsFromInPlaceT {
ConvertsFromInPlaceT(absl::in_place_t) {} // NOLINT
};
TEST(optionalTest, DefaultConstructor) {
absl::optional<int> empty;
EXPECT_FALSE(empty);
constexpr absl::optional<int> cempty;
static_assert(!cempty.has_value(), "");
EXPECT_TRUE(
std::is_nothrow_default_constructible<absl::optional<int>>::value);
}
TEST(optionalTest, nulloptConstructor) {
absl::optional<int> empty(absl::nullopt);
EXPECT_FALSE(empty);
constexpr absl::optional<int> cempty{absl::nullopt};
static_assert(!cempty.has_value(), "");
EXPECT_TRUE((std::is_nothrow_constructible<absl::optional<int>,
absl::nullopt_t>::value));
}
TEST(optionalTest, CopyConstructor) {
{
absl::optional<int> empty, opt42 = 42;
absl::optional<int> empty_copy(empty);
EXPECT_FALSE(empty_copy);
absl::optional<int> opt42_copy(opt42);
EXPECT_TRUE(opt42_copy);
EXPECT_EQ(42, *opt42_copy);
}
{
absl::optional<const int> empty, opt42 = 42;
absl::optional<const int> empty_copy(empty);
EXPECT_FALSE(empty_copy);
absl::optional<const int> opt42_copy(opt42);
EXPECT_TRUE(opt42_copy);
EXPECT_EQ(42, *opt42_copy);
}
{
absl::optional<volatile int> empty, opt42 = 42;
absl::optional<volatile int> empty_copy(empty);
EXPECT_FALSE(empty_copy);
absl::optional<volatile int> opt42_copy(opt42);
EXPECT_TRUE(opt42_copy);
EXPECT_EQ(42, *opt42_copy);
}
// test copyablility
EXPECT_TRUE(std::is_copy_constructible<absl::optional<int>>::value);
EXPECT_TRUE(std::is_copy_constructible<absl::optional<Copyable>>::value);
EXPECT_FALSE(
std::is_copy_constructible<absl::optional<MoveableThrow>>::value);
EXPECT_FALSE(
std::is_copy_constructible<absl::optional<MoveableNoThrow>>::value);
EXPECT_FALSE(std::is_copy_constructible<absl::optional<NonMovable>>::value);
EXPECT_FALSE(
absl::is_trivially_copy_constructible<absl::optional<Copyable>>::value);
#if defined(ABSL_USES_STD_OPTIONAL) && defined(__GLIBCXX__)
// libstdc++ std::optional implementation (as of 7.2) has a bug: when T is
// trivially copyable, optional<T> is not trivially copyable (due to one of
// its base class is unconditionally nontrivial).
#define ABSL_GLIBCXX_OPTIONAL_TRIVIALITY_BUG 1
#endif
#ifndef ABSL_GLIBCXX_OPTIONAL_TRIVIALITY_BUG
EXPECT_TRUE(
absl::is_trivially_copy_constructible<absl::optional<int>>::value);
EXPECT_TRUE(
absl::is_trivially_copy_constructible<absl::optional<const int>>::value);
#ifndef _MSC_VER
// See defect report "Trivial copy/move constructor for class with volatile
// member" at
// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#2094
// A class with non-static data member of volatile-qualified type should still
// have a trivial copy constructor if the data member is trivial.
// Also a cv-qualified scalar type should be trivially copyable.
EXPECT_TRUE(absl::is_trivially_copy_constructible<
absl::optional<volatile int>>::value);
#endif // _MSC_VER
#endif // ABSL_GLIBCXX_OPTIONAL_TRIVIALITY_BUG
// constexpr copy constructor for trivially copyable types
{
constexpr absl::optional<int> o1;
constexpr absl::optional<int> o2 = o1;
static_assert(!o2, "");
}
{
constexpr absl::optional<int> o1 = 42;
constexpr absl::optional<int> o2 = o1;
static_assert(o2, "");
static_assert(*o2 == 42, "");
}
{
struct TrivialCopyable {
constexpr TrivialCopyable() : x(0) {}
constexpr explicit TrivialCopyable(int i) : x(i) {}
int x;
};
constexpr absl::optional<TrivialCopyable> o1(42);
constexpr absl::optional<TrivialCopyable> o2 = o1;
static_assert(o2, "");
static_assert((*o2).x == 42, "");
#ifndef ABSL_GLIBCXX_OPTIONAL_TRIVIALITY_BUG
EXPECT_TRUE(absl::is_trivially_copy_constructible<
absl::optional<TrivialCopyable>>::value);
EXPECT_TRUE(absl::is_trivially_copy_constructible<
absl::optional<const TrivialCopyable>>::value);
#endif
// When testing with VS 2017 15.3, there seems to be a bug in MSVC
// std::optional when T is volatile-qualified. So skipping this test.
// Bug report:
// https://connect.microsoft.com/VisualStudio/feedback/details/3142534
#if defined(ABSL_USES_STD_OPTIONAL) && defined(_MSC_VER) && _MSC_VER >= 1911
#define ABSL_MSVC_OPTIONAL_VOLATILE_COPY_BUG 1
#endif
#ifndef ABSL_MSVC_OPTIONAL_VOLATILE_COPY_BUG
EXPECT_FALSE(std::is_copy_constructible<
absl::optional<volatile TrivialCopyable>>::value);
#endif
}
}
TEST(optionalTest, MoveConstructor) {
absl::optional<int> empty, opt42 = 42;
absl::optional<int> empty_move(std::move(empty));
EXPECT_FALSE(empty_move);
absl::optional<int> opt42_move(std::move(opt42));
EXPECT_TRUE(opt42_move);
EXPECT_EQ(42, opt42_move);
// test movability
EXPECT_TRUE(std::is_move_constructible<absl::optional<int>>::value);
EXPECT_TRUE(std::is_move_constructible<absl::optional<Copyable>>::value);
EXPECT_TRUE(std::is_move_constructible<absl::optional<MoveableThrow>>::value);
EXPECT_TRUE(
std::is_move_constructible<absl::optional<MoveableNoThrow>>::value);
EXPECT_FALSE(std::is_move_constructible<absl::optional<NonMovable>>::value);
// test noexcept
EXPECT_TRUE(std::is_nothrow_move_constructible<absl::optional<int>>::value);
#ifndef ABSL_USES_STD_OPTIONAL
EXPECT_EQ(
absl::default_allocator_is_nothrow::value,
std::is_nothrow_move_constructible<absl::optional<MoveableThrow>>::value);
#endif
EXPECT_TRUE(std::is_nothrow_move_constructible<
absl::optional<MoveableNoThrow>>::value);
}
TEST(optionalTest, Destructor) {
struct Trivial {};
struct NonTrivial {
NonTrivial(const NonTrivial&) {}
NonTrivial& operator=(const NonTrivial&) { return *this; }
~NonTrivial() {}
};
EXPECT_TRUE(std::is_trivially_destructible<absl::optional<int>>::value);
EXPECT_TRUE(std::is_trivially_destructible<absl::optional<Trivial>>::value);
EXPECT_FALSE(
std::is_trivially_destructible<absl::optional<NonTrivial>>::value);
}
TEST(optionalTest, InPlaceConstructor) {
constexpr absl::optional<ConstexprType> opt0{absl::in_place_t()};
static_assert(opt0, "");
static_assert((*opt0).x == ConstexprType::kCtorDefault, "");
constexpr absl::optional<ConstexprType> opt1{absl::in_place_t(), 1};
static_assert(opt1, "");
static_assert((*opt1).x == ConstexprType::kCtorInt, "");
#ifndef ABSL_HAVE_NO_CONSTEXPR_INITIALIZER_LIST
constexpr absl::optional<ConstexprType> opt2{absl::in_place_t(), {1, 2}};
static_assert(opt2, "");
static_assert((*opt2).x == ConstexprType::kCtorInitializerList, "");
#endif
EXPECT_FALSE((std::is_constructible<absl::optional<ConvertsFromInPlaceT>,
absl::in_place_t>::value));
EXPECT_FALSE((std::is_constructible<absl::optional<ConvertsFromInPlaceT>,
const absl::in_place_t&>::value));
EXPECT_TRUE(
(std::is_constructible<absl::optional<ConvertsFromInPlaceT>,
absl::in_place_t, absl::in_place_t>::value));
EXPECT_FALSE((std::is_constructible<absl::optional<NoDefault>,
absl::in_place_t>::value));
EXPECT_FALSE((std::is_constructible<absl::optional<NoDefault>,
absl::in_place_t&&>::value));
}
// template<U=T> optional(U&&);
TEST(optionalTest, ValueConstructor) {
constexpr absl::optional<int> opt0(0);
static_assert(opt0, "");
static_assert(*opt0 == 0, "");
EXPECT_TRUE((std::is_convertible<int, absl::optional<int>>::value));
// Copy initialization ( = "abc") won't work due to optional(optional&&)
// is not constexpr. Use list initialization instead. This invokes
// absl::optional<ConstexprType>::absl::optional<U>(U&&), with U = const char
// (&) [4], which direct-initializes the ConstexprType value held by the
// optional via ConstexprType::ConstexprType(const char*).
constexpr absl::optional<ConstexprType> opt1 = {"abc"};
static_assert(opt1, "");
static_assert(ConstexprType::kCtorConstChar == (*opt1).x, "");
EXPECT_TRUE(
(std::is_convertible<const char*, absl::optional<ConstexprType>>::value));
// direct initialization
constexpr absl::optional<ConstexprType> opt2{2};
static_assert(opt2, "");
static_assert(ConstexprType::kCtorInt == (*opt2).x, "");
EXPECT_FALSE(
(std::is_convertible<int, absl::optional<ConstexprType>>::value));
// this invokes absl::optional<int>::optional(int&&)
// NOTE: this has different behavior than assignment, e.g.
// "opt3 = {};" clears the optional rather than setting the value to 0
// According to C++17 standard N4659 [over.ics.list] 16.3.3.1.5, (9.2)- "if
// the initializer list has no elements, the implicit conversion is the
// identity conversion", so `optional(int&&)` should be a better match than
// `optional(optional&&)` which is a user-defined conversion.
// Note: GCC 7 has a bug with this overload selection when compiled with
// `-std=c++17`.
#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ == 7 && \
__cplusplus == 201703L
#define ABSL_GCC7_OVER_ICS_LIST_BUG 1
#endif
#ifndef ABSL_GCC7_OVER_ICS_LIST_BUG
constexpr absl::optional<int> opt3({});
static_assert(opt3, "");
static_assert(*opt3 == 0, "");
#endif
// this invokes the move constructor with a default constructed optional
// because non-template function is a better match than template function.
absl::optional<ConstexprType> opt4({});
EXPECT_FALSE(opt4);
}
struct Implicit {};
struct Explicit {};
struct Convert {
Convert(const Implicit&) // NOLINT(runtime/explicit)
: implicit(true), move(false) {}
Convert(Implicit&&) // NOLINT(runtime/explicit)
: implicit(true), move(true) {}
explicit Convert(const Explicit&) : implicit(false), move(false) {}
explicit Convert(Explicit&&) : implicit(false), move(true) {}
bool implicit;
bool move;
};
struct ConvertFromOptional {
ConvertFromOptional(const Implicit&) // NOLINT(runtime/explicit)
: implicit(true), move(false), from_optional(false) {}
ConvertFromOptional(Implicit&&) // NOLINT(runtime/explicit)
: implicit(true), move(true), from_optional(false) {}
ConvertFromOptional(
const absl::optional<Implicit>&) // NOLINT(runtime/explicit)
: implicit(true), move(false), from_optional(true) {}
ConvertFromOptional(absl::optional<Implicit>&&) // NOLINT(runtime/explicit)
: implicit(true), move(true), from_optional(true) {}
explicit ConvertFromOptional(const Explicit&)
: implicit(false), move(false), from_optional(false) {}
explicit ConvertFromOptional(Explicit&&)
: implicit(false), move(true), from_optional(false) {}
explicit ConvertFromOptional(const absl::optional<Explicit>&)
: implicit(false), move(false), from_optional(true) {}
explicit ConvertFromOptional(absl::optional<Explicit>&&)
: implicit(false), move(true), from_optional(true) {}
bool implicit;
bool move;
bool from_optional;
};
TEST(optionalTest, ConvertingConstructor) {
absl::optional<Implicit> i_empty;
absl::optional<Implicit> i(absl::in_place);
absl::optional<Explicit> e_empty;
absl::optional<Explicit> e(absl::in_place);
{
// implicitly constructing absl::optional<Convert> from
// absl::optional<Implicit>
absl::optional<Convert> empty = i_empty;
EXPECT_FALSE(empty);
absl::optional<Convert> opt_copy = i;
EXPECT_TRUE(opt_copy);
EXPECT_TRUE(opt_copy->implicit);
EXPECT_FALSE(opt_copy->move);
absl::optional<Convert> opt_move = absl::optional<Implicit>(absl::in_place);
EXPECT_TRUE(opt_move);
EXPECT_TRUE(opt_move->implicit);
EXPECT_TRUE(opt_move->move);
}
{
// explicitly constructing absl::optional<Convert> from
// absl::optional<Explicit>
absl::optional<Convert> empty(e_empty);
EXPECT_FALSE(empty);
absl::optional<Convert> opt_copy(e);
EXPECT_TRUE(opt_copy);
EXPECT_FALSE(opt_copy->implicit);
EXPECT_FALSE(opt_copy->move);
EXPECT_FALSE((std::is_convertible<const absl::optional<Explicit>&,
absl::optional<Convert>>::value));
absl::optional<Convert> opt_move{absl::optional<Explicit>(absl::in_place)};
EXPECT_TRUE(opt_move);
EXPECT_FALSE(opt_move->implicit);
EXPECT_TRUE(opt_move->move);
EXPECT_FALSE((std::is_convertible<absl::optional<Explicit>&&,
absl::optional<Convert>>::value));
}
{
// implicitly constructing absl::optional<ConvertFromOptional> from
// absl::optional<Implicit> via
// ConvertFromOptional(absl::optional<Implicit>&&) check that
// ConvertFromOptional(Implicit&&) is NOT called
static_assert(
std::is_convertible<absl::optional<Implicit>,
absl::optional<ConvertFromOptional>>::value,
"");
absl::optional<ConvertFromOptional> opt0 = i_empty;
EXPECT_TRUE(opt0);
EXPECT_TRUE(opt0->implicit);
EXPECT_FALSE(opt0->move);
EXPECT_TRUE(opt0->from_optional);
absl::optional<ConvertFromOptional> opt1 = absl::optional<Implicit>();
EXPECT_TRUE(opt1);
EXPECT_TRUE(opt1->implicit);
EXPECT_TRUE(opt1->move);
EXPECT_TRUE(opt1->from_optional);
}
{
// implicitly constructing absl::optional<ConvertFromOptional> from
// absl::optional<Explicit> via
// ConvertFromOptional(absl::optional<Explicit>&&) check that
// ConvertFromOptional(Explicit&&) is NOT called
absl::optional<ConvertFromOptional> opt0(e_empty);
EXPECT_TRUE(opt0);
EXPECT_FALSE(opt0->implicit);
EXPECT_FALSE(opt0->move);
EXPECT_TRUE(opt0->from_optional);
EXPECT_FALSE(
(std::is_convertible<const absl::optional<Explicit>&,
absl::optional<ConvertFromOptional>>::value));
absl::optional<ConvertFromOptional> opt1{absl::optional<Explicit>()};
EXPECT_TRUE(opt1);
EXPECT_FALSE(opt1->implicit);
EXPECT_TRUE(opt1->move);
EXPECT_TRUE(opt1->from_optional);
EXPECT_FALSE(
(std::is_convertible<absl::optional<Explicit>&&,
absl::optional<ConvertFromOptional>>::value));
}
}
TEST(optionalTest, StructorBasic) {
StructorListener listener;
Listenable::listener = &listener;
{
absl::optional<Listenable> empty;
EXPECT_FALSE(empty);
absl::optional<Listenable> opt0(absl::in_place);
EXPECT_TRUE(opt0);
absl::optional<Listenable> opt1(absl::in_place, 1);
EXPECT_TRUE(opt1);
absl::optional<Listenable> opt2(absl::in_place, 1, 2);
EXPECT_TRUE(opt2);
}
EXPECT_EQ(1, listener.construct0);
EXPECT_EQ(1, listener.construct1);
EXPECT_EQ(1, listener.construct2);
EXPECT_EQ(3, listener.destruct);
}
TEST(optionalTest, CopyMoveStructor) {
StructorListener listener;
Listenable::listener = &listener;
absl::optional<Listenable> original(absl::in_place);
EXPECT_EQ(1, listener.construct0);
EXPECT_EQ(0, listener.copy);
EXPECT_EQ(0, listener.move);
absl::optional<Listenable> copy(original);
EXPECT_EQ(1, listener.construct0);
EXPECT_EQ(1, listener.copy);
EXPECT_EQ(0, listener.move);
absl::optional<Listenable> move(std::move(original));
EXPECT_EQ(1, listener.construct0);
EXPECT_EQ(1, listener.copy);
EXPECT_EQ(1, listener.move);
}
TEST(optionalTest, ListInit) {
StructorListener listener;
Listenable::listener = &listener;
absl::optional<Listenable> listinit1(absl::in_place, {1});
absl::optional<Listenable> listinit2(absl::in_place, {1, 2});
EXPECT_EQ(2, listener.listinit);
}
TEST(optionalTest, AssignFromNullopt) {
absl::optional<int> opt(1);
opt = absl::nullopt;
EXPECT_FALSE(opt);
StructorListener listener;
Listenable::listener = &listener;
absl::optional<Listenable> opt1(absl::in_place);
opt1 = absl::nullopt;
EXPECT_FALSE(opt1);
EXPECT_EQ(1, listener.construct0);
EXPECT_EQ(1, listener.destruct);
EXPECT_TRUE((
std::is_nothrow_assignable<absl::optional<int>, absl::nullopt_t>::value));
EXPECT_TRUE((std::is_nothrow_assignable<absl::optional<Listenable>,
absl::nullopt_t>::value));
}
TEST(optionalTest, CopyAssignment) {
const absl::optional<int> empty, opt1 = 1, opt2 = 2;
absl::optional<int> empty_to_opt1, opt1_to_opt2, opt2_to_empty;
EXPECT_FALSE(empty_to_opt1);
empty_to_opt1 = empty;
EXPECT_FALSE(empty_to_opt1);
empty_to_opt1 = opt1;
EXPECT_TRUE(empty_to_opt1);
EXPECT_EQ(1, empty_to_opt1.value());
EXPECT_FALSE(opt1_to_opt2);
opt1_to_opt2 = opt1;
EXPECT_TRUE(opt1_to_opt2);
EXPECT_EQ(1, opt1_to_opt2.value());
opt1_to_opt2 = opt2;
EXPECT_TRUE(opt1_to_opt2);
EXPECT_EQ(2, opt1_to_opt2.value());
EXPECT_FALSE(opt2_to_empty);
opt2_to_empty = opt2;
EXPECT_TRUE(opt2_to_empty);
EXPECT_EQ(2, opt2_to_empty.value());
opt2_to_empty = empty;
EXPECT_FALSE(opt2_to_empty);
EXPECT_FALSE(absl::is_copy_assignable<absl::optional<const int>>::value);
EXPECT_TRUE(absl::is_copy_assignable<absl::optional<Copyable>>::value);
EXPECT_FALSE(absl::is_copy_assignable<absl::optional<MoveableThrow>>::value);
EXPECT_FALSE(
absl::is_copy_assignable<absl::optional<MoveableNoThrow>>::value);
EXPECT_FALSE(absl::is_copy_assignable<absl::optional<NonMovable>>::value);
EXPECT_TRUE(absl::is_trivially_copy_assignable<int>::value);
EXPECT_TRUE(absl::is_trivially_copy_assignable<volatile int>::value);
struct Trivial {
int i;
};
struct NonTrivial {
NonTrivial& operator=(const NonTrivial&) { return *this; }
int i;
};
EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial>::value);
EXPECT_FALSE(absl::is_copy_assignable<const Trivial>::value);
EXPECT_FALSE(absl::is_copy_assignable<volatile Trivial>::value);
EXPECT_TRUE(absl::is_copy_assignable<NonTrivial>::value);
EXPECT_FALSE(absl::is_trivially_copy_assignable<NonTrivial>::value);
// std::optional doesn't support volatile nontrivial types.
#ifndef ABSL_USES_STD_OPTIONAL
{
StructorListener listener;
Listenable::listener = &listener;
absl::optional<volatile Listenable> empty, set(absl::in_place);
EXPECT_EQ(1, listener.construct0);
absl::optional<volatile Listenable> empty_to_empty, empty_to_set,
set_to_empty(absl::in_place), set_to_set(absl::in_place);
EXPECT_EQ(3, listener.construct0);
empty_to_empty = empty; // no effect
empty_to_set = set; // copy construct
set_to_empty = empty; // destruct
set_to_set = set; // copy assign
EXPECT_EQ(1, listener.volatile_copy);
EXPECT_EQ(0, listener.volatile_move);
EXPECT_EQ(1, listener.destruct);
EXPECT_EQ(1, listener.volatile_copy_assign);
}
#endif // ABSL_USES_STD_OPTIONAL
}
TEST(optionalTest, MoveAssignment) {
{
StructorListener listener;
Listenable::listener = &listener;
absl::optional<Listenable> empty1, empty2, set1(absl::in_place),
set2(absl::in_place);
EXPECT_EQ(2, listener.construct0);
absl::optional<Listenable> empty_to_empty, empty_to_set,
set_to_empty(absl::in_place), set_to_set(absl::in_place);
EXPECT_EQ(4, listener.construct0);
empty_to_empty = std::move(empty1);
empty_to_set = std::move(set1);
set_to_empty = std::move(empty2);
set_to_set = std::move(set2);
EXPECT_EQ(0, listener.copy);
EXPECT_EQ(1, listener.move);
EXPECT_EQ(1, listener.destruct);
EXPECT_EQ(1, listener.move_assign);
}
// std::optional doesn't support volatile nontrivial types.
#ifndef ABSL_USES_STD_OPTIONAL
{
StructorListener listener;
Listenable::listener = &listener;
absl::optional<volatile Listenable> empty1, empty2, set1(absl::in_place),
set2(absl::in_place);
EXPECT_EQ(2, listener.construct0);
absl::optional<volatile Listenable> empty_to_empty, empty_to_set,
set_to_empty(absl::in_place), set_to_set(absl::in_place);
EXPECT_EQ(4, listener.construct0);
empty_to_empty = std::move(empty1); // no effect
empty_to_set = std::move(set1); // move construct
set_to_empty = std::move(empty2); // destruct
set_to_set = std::move(set2); // move assign
EXPECT_EQ(0, listener.volatile_copy);
EXPECT_EQ(1, listener.volatile_move);
EXPECT_EQ(1, listener.destruct);
EXPECT_EQ(1, listener.volatile_move_assign);
}
#endif // ABSL_USES_STD_OPTIONAL
EXPECT_FALSE(absl::is_move_assignable<absl::optional<const int>>::value);
EXPECT_TRUE(absl::is_move_assignable<absl::optional<Copyable>>::value);
EXPECT_TRUE(absl::is_move_assignable<absl::optional<MoveableThrow>>::value);
EXPECT_TRUE(absl::is_move_assignable<absl::optional<MoveableNoThrow>>::value);
EXPECT_FALSE(absl::is_move_assignable<absl::optional<NonMovable>>::value);
EXPECT_FALSE(
std::is_nothrow_move_assignable<absl::optional<MoveableThrow>>::value);
EXPECT_TRUE(
std::is_nothrow_move_assignable<absl::optional<MoveableNoThrow>>::value);
}
struct NoConvertToOptional {
// disable implicit conversion from const NoConvertToOptional&
// to absl::optional<NoConvertToOptional>.
NoConvertToOptional(const NoConvertToOptional&) = delete;
};
struct CopyConvert {
CopyConvert(const NoConvertToOptional&);
CopyConvert& operator=(const CopyConvert&) = delete;
CopyConvert& operator=(const NoConvertToOptional&);
};
struct CopyConvertFromOptional {
CopyConvertFromOptional(const NoConvertToOptional&);
CopyConvertFromOptional(const absl::optional<NoConvertToOptional>&);
CopyConvertFromOptional& operator=(const CopyConvertFromOptional&) = delete;
CopyConvertFromOptional& operator=(const NoConvertToOptional&);
CopyConvertFromOptional& operator=(
const absl::optional<NoConvertToOptional>&);
};
struct MoveConvert {
MoveConvert(NoConvertToOptional&&);
MoveConvert& operator=(const MoveConvert&) = delete;
MoveConvert& operator=(NoConvertToOptional&&);
};
struct MoveConvertFromOptional {
MoveConvertFromOptional(NoConvertToOptional&&);
MoveConvertFromOptional(absl::optional<NoConvertToOptional>&&);
MoveConvertFromOptional& operator=(const MoveConvertFromOptional&) = delete;
MoveConvertFromOptional& operator=(NoConvertToOptional&&);
MoveConvertFromOptional& operator=(absl::optional<NoConvertToOptional>&&);
};
// template <typename U = T> absl::optional<T>& operator=(U&& v);
TEST(optionalTest, ValueAssignment) {
absl::optional<int> opt;
EXPECT_FALSE(opt);
opt = 42;
EXPECT_TRUE(opt);
EXPECT_EQ(42, opt.value());
opt = absl::nullopt;
EXPECT_FALSE(opt);
opt = 42;
EXPECT_TRUE(opt);
EXPECT_EQ(42, opt.value());
opt = 43;
EXPECT_TRUE(opt);
EXPECT_EQ(43, opt.value());
opt = {}; // this should clear optional
EXPECT_FALSE(opt);
opt = {44};
EXPECT_TRUE(opt);
EXPECT_EQ(44, opt.value());
// U = const NoConvertToOptional&
EXPECT_TRUE((std::is_assignable<absl::optional<CopyConvert>&,
const NoConvertToOptional&>::value));
// U = const absl::optional<NoConvertToOptional>&
EXPECT_TRUE((std::is_assignable<absl::optional<CopyConvertFromOptional>&,
const NoConvertToOptional&>::value));
// U = const NoConvertToOptional& triggers SFINAE because
// std::is_constructible_v<MoveConvert, const NoConvertToOptional&> is false
EXPECT_FALSE((std::is_assignable<absl::optional<MoveConvert>&,
const NoConvertToOptional&>::value));
// U = NoConvertToOptional
EXPECT_TRUE((std::is_assignable<absl::optional<MoveConvert>&,
NoConvertToOptional&&>::value));
// U = const NoConvertToOptional& triggers SFINAE because
// std::is_constructible_v<MoveConvertFromOptional, const
// NoConvertToOptional&> is false
EXPECT_FALSE((std::is_assignable<absl::optional<MoveConvertFromOptional>&,
const NoConvertToOptional&>::value));
// U = NoConvertToOptional
EXPECT_TRUE((std::is_assignable<absl::optional<MoveConvertFromOptional>&,
NoConvertToOptional&&>::value));
// U = const absl::optional<NoConvertToOptional>&
EXPECT_TRUE(
(std::is_assignable<absl::optional<CopyConvertFromOptional>&,
const absl::optional<NoConvertToOptional>&>::value));
// U = absl::optional<NoConvertToOptional>
EXPECT_TRUE(
(std::is_assignable<absl::optional<MoveConvertFromOptional>&,
absl::optional<NoConvertToOptional>&&>::value));
}
// template <typename U> absl::optional<T>& operator=(const absl::optional<U>&
// rhs); template <typename U> absl::optional<T>& operator=(absl::optional<U>&&
// rhs);
TEST(optionalTest, ConvertingAssignment) {
absl::optional<int> opt_i;
absl::optional<char> opt_c('c');
opt_i = opt_c;
EXPECT_TRUE(opt_i);
EXPECT_EQ(*opt_c, *opt_i);
opt_i = absl::optional<char>();
EXPECT_FALSE(opt_i);
opt_i = absl::optional<char>('d');
EXPECT_TRUE(opt_i);
EXPECT_EQ('d', *opt_i);
absl::optional<std::string> opt_str;
absl::optional<const char*> opt_cstr("abc");
opt_str = opt_cstr;
EXPECT_TRUE(opt_str);
EXPECT_EQ(std::string("abc"), *opt_str);
opt_str = absl::optional<const char*>();
EXPECT_FALSE(opt_str);
opt_str = absl::optional<const char*>("def");
EXPECT_TRUE(opt_str);
EXPECT_EQ(std::string("def"), *opt_str);
// operator=(const absl::optional<U>&) with U = NoConvertToOptional
EXPECT_TRUE(
(std::is_assignable<absl::optional<CopyConvert>,
const absl::optional<NoConvertToOptional>&>::value));
// operator=(const absl::optional<U>&) with U = NoConvertToOptional
// triggers SFINAE because
// std::is_constructible_v<MoveConvert, const NoConvertToOptional&> is false
EXPECT_FALSE(
(std::is_assignable<absl::optional<MoveConvert>&,
const absl::optional<NoConvertToOptional>&>::value));
// operator=(absl::optional<U>&&) with U = NoConvertToOptional
EXPECT_TRUE(
(std::is_assignable<absl::optional<MoveConvert>&,
absl::optional<NoConvertToOptional>&&>::value));
// operator=(const absl::optional<U>&) with U = NoConvertToOptional triggers
// SFINAE because std::is_constructible_v<MoveConvertFromOptional, const
// NoConvertToOptional&> is false. operator=(U&&) with U = const
// absl::optional<NoConverToOptional>& triggers SFINAE because
// std::is_constructible<MoveConvertFromOptional,
// absl::optional<NoConvertToOptional>&&> is true.
EXPECT_FALSE(
(std::is_assignable<absl::optional<MoveConvertFromOptional>&,
const absl::optional<NoConvertToOptional>&>::value));
}
TEST(optionalTest, ResetAndHasValue) {
StructorListener listener;
Listenable::listener = &listener;
absl::optional<Listenable> opt;
EXPECT_FALSE(opt);
EXPECT_FALSE(opt.has_value());
opt.emplace();
EXPECT_TRUE(opt);
EXPECT_TRUE(opt.has_value());
opt.reset();
EXPECT_FALSE(opt);
EXPECT_FALSE(opt.has_value());
EXPECT_EQ(1, listener.destruct);
opt.reset();
EXPECT_FALSE(opt);
EXPECT_FALSE(opt.has_value());
constexpr absl::optional<int> empty;
static_assert(!empty.has_value(), "");
constexpr absl::optional<int> nonempty(1);
static_assert(nonempty.has_value(), "");
}
TEST(optionalTest, Emplace) {
StructorListener listener;
Listenable::listener = &listener;
absl::optional<Listenable> opt;
EXPECT_FALSE(opt);
opt.emplace(1);
EXPECT_TRUE(opt);
opt.emplace(1, 2);
EXPECT_EQ(1, listener.construct1);
EXPECT_EQ(1, listener.construct2);
EXPECT_EQ(1, listener.destruct);
absl::optional<std::string> o;
EXPECT_TRUE((std::is_same<std::string&, decltype(o.emplace("abc"))>::value));
std::string& ref = o.emplace("abc");
EXPECT_EQ(&ref, &o.value());
}
TEST(optionalTest, ListEmplace) {
StructorListener listener;
Listenable::listener = &listener;
absl::optional<Listenable> opt;
EXPECT_FALSE(opt);
opt.emplace({1});
EXPECT_TRUE(opt);
opt.emplace({1, 2});
EXPECT_EQ(2, listener.listinit);
EXPECT_EQ(1, listener.destruct);
absl::optional<Listenable> o;
EXPECT_TRUE((std::is_same<Listenable&, decltype(o.emplace({1}))>::value));
Listenable& ref = o.emplace({1});
EXPECT_EQ(&ref, &o.value());
}
TEST(optionalTest, Swap) {
absl::optional<int> opt_empty, opt1 = 1, opt2 = 2;
EXPECT_FALSE(opt_empty);
EXPECT_TRUE(opt1);
EXPECT_EQ(1, opt1.value());
EXPECT_TRUE(opt2);
EXPECT_EQ(2, opt2.value());
swap(opt_empty, opt1);
EXPECT_FALSE(opt1);
EXPECT_TRUE(opt_empty);
EXPECT_EQ(1, opt_empty.value());
EXPECT_TRUE(opt2);
EXPECT_EQ(2, opt2.value());
swap(opt_empty, opt1);
EXPECT_FALSE(opt_empty);
EXPECT_TRUE(opt1);
EXPECT_EQ(1, opt1.value());
EXPECT_TRUE(opt2);
EXPECT_EQ(2, opt2.value());
swap(opt1, opt2);
EXPECT_FALSE(opt_empty);
EXPECT_TRUE(opt1);
EXPECT_EQ(2, opt1.value());
EXPECT_TRUE(opt2);
EXPECT_EQ(1, opt2.value());
EXPECT_TRUE(noexcept(opt1.swap(opt2)));
EXPECT_TRUE(noexcept(swap(opt1, opt2)));
}
template <int v>
struct DeletedOpAddr {
int value = v;
constexpr DeletedOpAddr() = default;
constexpr const DeletedOpAddr<v>* operator&() const = delete; // NOLINT
DeletedOpAddr<v>* operator&() = delete; // NOLINT
};
// The static_assert featuring a constexpr call to operator->() is commented out
// to document the fact that the current implementation of absl::optional<T>
// expects such usecases to be malformed and not compile.
TEST(optionalTest, OperatorAddr) {
constexpr int v = -1;
{ // constexpr
constexpr absl::optional<DeletedOpAddr<v>> opt(absl::in_place_t{});
static_assert(opt.has_value(), "");
// static_assert(opt->value == v, "");
static_assert((*opt).value == v, "");
}
{ // non-constexpr
const absl::optional<DeletedOpAddr<v>> opt(absl::in_place_t{});
EXPECT_TRUE(opt.has_value());
EXPECT_TRUE(opt->value == v);
EXPECT_TRUE((*opt).value == v);
}
}
TEST(optionalTest, PointerStuff) {
absl::optional<std::string> opt(absl::in_place, "foo");
EXPECT_EQ("foo", *opt);
const auto& opt_const = opt;
EXPECT_EQ("foo", *opt_const);
EXPECT_EQ(opt->size(), 3);
EXPECT_EQ(opt_const->size(), 3);
constexpr absl::optional<ConstexprType> opt1(1);
static_assert((*opt1).x == ConstexprType::kCtorInt, "");
}
// gcc has a bug pre 4.9.1 where it doesn't do correct overload resolution
// when overloads are const-qualified and *this is an raluve.
// Skip that test to make the build green again when using the old compiler.
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59296 is fixed in 4.9.1.
#if defined(__GNUC__) && !defined(__clang__)
#define GCC_VERSION (__GNUC__ * 10000 \
+ __GNUC_MINOR__ * 100 \
+ __GNUC_PATCHLEVEL__)
#if GCC_VERSION < 40901
#define ABSL_SKIP_OVERLOAD_TEST_DUE_TO_GCC_BUG
#endif
#endif
// MSVC has a bug with "cv-qualifiers in class construction", fixed in 2017. See
// https://docs.microsoft.com/en-us/cpp/cpp-conformance-improvements-2017#bug-fixes
// The compiler some incorrectly ingores the cv-qualifier when generating a
// class object via a constructor call. For example:
//
// class optional {
// constexpr T&& value() &&;
// constexpr const T&& value() const &&;
// }
//
// using COI = const absl::optional<int>;
// static_assert(2 == COI(2).value(), ""); // const &&
//
// This should invoke the "const &&" overload but since it ignores the const
// qualifier it finds the "&&" overload the best candidate.
#if defined(_MSC_VER) && _MSC_VER < 1910
#define ABSL_SKIP_OVERLOAD_TEST_DUE_TO_MSVC_BUG
#endif
TEST(optionalTest, Value) {
using O = absl::optional<std::string>;
using CO = const absl::optional<std::string>;
using OC = absl::optional<const std::string>;
O lvalue(absl::in_place, "lvalue");
CO clvalue(absl::in_place, "clvalue");
OC lvalue_c(absl::in_place, "lvalue_c");
EXPECT_EQ("lvalue", lvalue.value());
EXPECT_EQ("clvalue", clvalue.value());
EXPECT_EQ("lvalue_c", lvalue_c.value());
EXPECT_EQ("xvalue", O(absl::in_place, "xvalue").value());
EXPECT_EQ("xvalue_c", OC(absl::in_place, "xvalue_c").value());
#ifndef ABSL_SKIP_OVERLOAD_TEST_DUE_TO_GCC_BUG
EXPECT_EQ("cxvalue", CO(absl::in_place, "cxvalue").value());
#endif
EXPECT_EQ("&", TypeQuals(lvalue.value()));
EXPECT_EQ("c&", TypeQuals(clvalue.value()));
EXPECT_EQ("c&", TypeQuals(lvalue_c.value()));
EXPECT_EQ("&&", TypeQuals(O(absl::in_place, "xvalue").value()));
#if !defined(ABSL_SKIP_OVERLOAD_TEST_DUE_TO_MSVC_BUG) && \
!defined(ABSL_SKIP_OVERLOAD_TEST_DUE_TO_GCC_BUG)
EXPECT_EQ("c&&", TypeQuals(CO(absl::in_place, "cxvalue").value()));
#endif
EXPECT_EQ("c&&", TypeQuals(OC(absl::in_place, "xvalue_c").value()));
// test on volatile type
using OV = absl::optional<volatile int>;
OV lvalue_v(absl::in_place, 42);
EXPECT_EQ(42, lvalue_v.value());
EXPECT_EQ(42, OV(42).value());
EXPECT_TRUE((std::is_same<volatile int&, decltype(lvalue_v.value())>::value));
EXPECT_TRUE((std::is_same<volatile int&&, decltype(OV(42).value())>::value));
// test exception throw on value()
absl::optional<int> empty;
#ifdef ABSL_HAVE_EXCEPTIONS
EXPECT_THROW((void)empty.value(), absl::bad_optional_access);
#else
EXPECT_DEATH_IF_SUPPORTED((void)empty.value(), "Bad optional access");
#endif
// test constexpr value()
constexpr absl::optional<int> o1(1);
static_assert(1 == o1.value(), ""); // const &
#if !defined(_MSC_VER) && !defined(ABSL_SKIP_OVERLOAD_TEST_DUE_TO_GCC_BUG)
using COI = const absl::optional<int>;
static_assert(2 == COI(2).value(), ""); // const &&
#endif
}
TEST(optionalTest, DerefOperator) {
using O = absl::optional<std::string>;
using CO = const absl::optional<std::string>;
using OC = absl::optional<const std::string>;
O lvalue(absl::in_place, "lvalue");
CO clvalue(absl::in_place, "clvalue");
OC lvalue_c(absl::in_place, "lvalue_c");
EXPECT_EQ("lvalue", *lvalue);
EXPECT_EQ("clvalue", *clvalue);
EXPECT_EQ("lvalue_c", *lvalue_c);
EXPECT_EQ("xvalue", *O(absl::in_place, "xvalue"));
EXPECT_EQ("xvalue_c", *OC(absl::in_place, "xvalue_c"));
#ifndef ABSL_SKIP_OVERLOAD_TEST_DUE_TO_GCC_BUG
EXPECT_EQ("cxvalue", *CO(absl::in_place, "cxvalue"));
#endif
EXPECT_EQ("&", TypeQuals(*lvalue));
EXPECT_EQ("c&", TypeQuals(*clvalue));
EXPECT_EQ("&&", TypeQuals(*O(absl::in_place, "xvalue")));
#if !defined(ABSL_SKIP_OVERLOAD_TEST_DUE_TO_MSVC_BUG) && \
!defined(ABSL_SKIP_OVERLOAD_TEST_DUE_TO_GCC_BUG)
EXPECT_EQ("c&&", TypeQuals(*CO(absl::in_place, "cxvalue")));
#endif
EXPECT_EQ("c&&", TypeQuals(*OC(absl::in_place, "xvalue_c")));
// test on volatile type
using OV = absl::optional<volatile int>;
OV lvalue_v(absl::in_place, 42);
EXPECT_EQ(42, *lvalue_v);
EXPECT_EQ(42, *OV(42));
EXPECT_TRUE((std::is_same<volatile int&, decltype(*lvalue_v)>::value));
EXPECT_TRUE((std::is_same<volatile int&&, decltype(*OV(42))>::value));
constexpr absl::optional<int> opt1(1);
static_assert(*opt1 == 1, "");
#if !defined(_MSC_VER) && !defined(ABSL_SKIP_OVERLOAD_TEST_DUE_TO_GCC_BUG)
using COI = const absl::optional<int>;
static_assert(*COI(2) == 2, "");
#endif
}
TEST(optionalTest, ValueOr) {
absl::optional<double> opt_empty, opt_set = 1.2;
EXPECT_EQ(42.0, opt_empty.value_or(42));
EXPECT_EQ(1.2, opt_set.value_or(42));
EXPECT_EQ(42.0, absl::optional<double>().value_or(42));
EXPECT_EQ(1.2, absl::optional<double>(1.2).value_or(42));
constexpr absl::optional<double> copt_empty, copt_set = {1.2};
static_assert(42.0 == copt_empty.value_or(42), "");
static_assert(1.2 == copt_set.value_or(42), "");
#ifndef ABSL_SKIP_OVERLOAD_TEST_DUE_TO_MSVC_BUG
using COD = const absl::optional<double>;
static_assert(42.0 == COD().value_or(42), "");
static_assert(1.2 == COD(1.2).value_or(42), "");
#endif
}
// make_optional cannot be constexpr until C++17
TEST(optionalTest, make_optional) {
auto opt_int = absl::make_optional(42);
EXPECT_TRUE((std::is_same<decltype(opt_int), absl::optional<int>>::value));
EXPECT_EQ(42, opt_int);
StructorListener listener;
Listenable::listener = &listener;
absl::optional<Listenable> opt0 = absl::make_optional<Listenable>();
EXPECT_EQ(1, listener.construct0);
absl::optional<Listenable> opt1 = absl::make_optional<Listenable>(1);
EXPECT_EQ(1, listener.construct1);
absl::optional<Listenable> opt2 = absl::make_optional<Listenable>(1, 2);
EXPECT_EQ(1, listener.construct2);
absl::optional<Listenable> opt3 = absl::make_optional<Listenable>({1});
absl::optional<Listenable> opt4 = absl::make_optional<Listenable>({1, 2});
EXPECT_EQ(2, listener.listinit);
// Constexpr tests on trivially copyable types
// optional<T> has trivial copy/move ctors when T is trivially copyable.
// For nontrivial types with constexpr constructors, we need copy elision in
// C++17 for make_optional to be constexpr.
{
constexpr absl::optional<int> c_opt = absl::make_optional(42);
static_assert(c_opt.value() == 42, "");
}
{
struct TrivialCopyable {
constexpr TrivialCopyable() : x(0) {}
constexpr explicit TrivialCopyable(int i) : x(i) {}
int x;
};
constexpr TrivialCopyable v;
constexpr absl::optional<TrivialCopyable> c_opt0 = absl::make_optional(v);
static_assert((*c_opt0).x == 0, "");
constexpr absl::optional<TrivialCopyable> c_opt1 =
absl::make_optional<TrivialCopyable>();
static_assert((*c_opt1).x == 0, "");
constexpr absl::optional<TrivialCopyable> c_opt2 =
absl::make_optional<TrivialCopyable>(42);
static_assert((*c_opt2).x == 42, "");
}
}
template <typename T, typename U>
void optionalTest_Comparisons_EXPECT_LESS(T x, U y) {
EXPECT_FALSE(x == y);
EXPECT_TRUE(x != y);
EXPECT_TRUE(x < y);
EXPECT_FALSE(x > y);
EXPECT_TRUE(x <= y);
EXPECT_FALSE(x >= y);
}
template <typename T, typename U>
void optionalTest_Comparisons_EXPECT_SAME(T x, U y) {
EXPECT_TRUE(x == y);
EXPECT_FALSE(x != y);
EXPECT_FALSE(x < y);
EXPECT_FALSE(x > y);
EXPECT_TRUE(x <= y);
EXPECT_TRUE(x >= y);
}
template <typename T, typename U>
void optionalTest_Comparisons_EXPECT_GREATER(T x, U y) {
EXPECT_FALSE(x == y);
EXPECT_TRUE(x != y);
EXPECT_FALSE(x < y);
EXPECT_TRUE(x > y);
EXPECT_FALSE(x <= y);
EXPECT_TRUE(x >= y);
}
template <typename T, typename U, typename V>
void TestComparisons() {
absl::optional<T> ae, a2{2}, a4{4};
absl::optional<U> be, b2{2}, b4{4};
V v3 = 3;
// LHS: absl::nullopt, ae, a2, v3, a4
// RHS: absl::nullopt, be, b2, v3, b4
// optionalTest_Comparisons_EXPECT_NOT_TO_WORK(absl::nullopt,absl::nullopt);
optionalTest_Comparisons_EXPECT_SAME(absl::nullopt, be);
optionalTest_Comparisons_EXPECT_LESS(absl::nullopt, b2);
// optionalTest_Comparisons_EXPECT_NOT_TO_WORK(absl::nullopt,v3);
optionalTest_Comparisons_EXPECT_LESS(absl::nullopt, b4);
optionalTest_Comparisons_EXPECT_SAME(ae, absl::nullopt);
optionalTest_Comparisons_EXPECT_SAME(ae, be);
optionalTest_Comparisons_EXPECT_LESS(ae, b2);
optionalTest_Comparisons_EXPECT_LESS(ae, v3);
optionalTest_Comparisons_EXPECT_LESS(ae, b4);
optionalTest_Comparisons_EXPECT_GREATER(a2, absl::nullopt);
optionalTest_Comparisons_EXPECT_GREATER(a2, be);
optionalTest_Comparisons_EXPECT_SAME(a2, b2);
optionalTest_Comparisons_EXPECT_LESS(a2, v3);
optionalTest_Comparisons_EXPECT_LESS(a2, b4);
// optionalTest_Comparisons_EXPECT_NOT_TO_WORK(v3,absl::nullopt);
optionalTest_Comparisons_EXPECT_GREATER(v3, be);
optionalTest_Comparisons_EXPECT_GREATER(v3, b2);
optionalTest_Comparisons_EXPECT_SAME(v3, v3);
optionalTest_Comparisons_EXPECT_LESS(v3, b4);
optionalTest_Comparisons_EXPECT_GREATER(a4, absl::nullopt);
optionalTest_Comparisons_EXPECT_GREATER(a4, be);
optionalTest_Comparisons_EXPECT_GREATER(a4, b2);
optionalTest_Comparisons_EXPECT_GREATER(a4, v3);
optionalTest_Comparisons_EXPECT_SAME(a4, b4);
}
struct Int1 {
Int1() = default;
Int1(int i) : i(i) {} // NOLINT(runtime/explicit)
int i;
};
struct Int2 {
Int2() = default;
Int2(int i) : i(i) {} // NOLINT(runtime/explicit)
int i;
};
// comparison between Int1 and Int2
constexpr bool operator==(const Int1& lhs, const Int2& rhs) {
return lhs.i == rhs.i;
}
constexpr bool operator!=(const Int1& lhs, const Int2& rhs) {
return !(lhs == rhs);
}
constexpr bool operator<(const Int1& lhs, const Int2& rhs) {
return lhs.i < rhs.i;
}
constexpr bool operator<=(const Int1& lhs, const Int2& rhs) {
return lhs < rhs || lhs == rhs;
}
constexpr bool operator>(const Int1& lhs, const Int2& rhs) {
return !(lhs <= rhs);
}
constexpr bool operator>=(const Int1& lhs, const Int2& rhs) {
return !(lhs < rhs);
}
TEST(optionalTest, Comparisons) {
TestComparisons<int, int, int>();
TestComparisons<const int, int, int>();
TestComparisons<Int1, int, int>();
TestComparisons<int, Int2, int>();
TestComparisons<Int1, Int2, int>();
// compare absl::optional<std::string> with const char*
absl::optional<std::string> opt_str = "abc";
const char* cstr = "abc";
EXPECT_TRUE(opt_str == cstr);
// compare absl::optional<std::string> with absl::optional<const char*>
absl::optional<const char*> opt_cstr = cstr;
EXPECT_TRUE(opt_str == opt_cstr);
// compare absl::optional<std::string> with absl::optional<absl::string_view>
absl::optional<absl::string_view> e1;
absl::optional<std::string> e2;
EXPECT_TRUE(e1 == e2);
}
TEST(optionalTest, SwapRegression) {
StructorListener listener;
Listenable::listener = &listener;
{
absl::optional<Listenable> a;
absl::optional<Listenable> b(absl::in_place);
a.swap(b);
}
EXPECT_EQ(1, listener.construct0);
EXPECT_EQ(1, listener.move);
EXPECT_EQ(2, listener.destruct);
{
absl::optional<Listenable> a(absl::in_place);
absl::optional<Listenable> b;
a.swap(b);
}
EXPECT_EQ(2, listener.construct0);
EXPECT_EQ(2, listener.move);
EXPECT_EQ(4, listener.destruct);
}
TEST(optionalTest, BigStringLeakCheck) {
constexpr size_t n = 1 << 16;
using OS = absl::optional<std::string>;
OS a;
OS b = absl::nullopt;
OS c = std::string(n, 'c');
std::string sd(n, 'd');
OS d = sd;
OS e(absl::in_place, n, 'e');
OS f;
f.emplace(n, 'f');
OS ca(a);
OS cb(b);
OS cc(c);
OS cd(d);
OS ce(e);
OS oa;
OS ob = absl::nullopt;
OS oc = std::string(n, 'c');
std::string sod(n, 'd');
OS od = sod;
OS oe(absl::in_place, n, 'e');
OS of;
of.emplace(n, 'f');
OS ma(std::move(oa));
OS mb(std::move(ob));
OS mc(std::move(oc));
OS md(std::move(od));
OS me(std::move(oe));
OS mf(std::move(of));
OS aa1;
OS ab1 = absl::nullopt;
OS ac1 = std::string(n, 'c');
std::string sad1(n, 'd');
OS ad1 = sad1;
OS ae1(absl::in_place, n, 'e');
OS af1;
af1.emplace(n, 'f');
OS aa2;
OS ab2 = absl::nullopt;
OS ac2 = std::string(n, 'c');
std::string sad2(n, 'd');
OS ad2 = sad2;
OS ae2(absl::in_place, n, 'e');
OS af2;
af2.emplace(n, 'f');
aa1 = af2;
ab1 = ae2;
ac1 = ad2;
ad1 = ac2;
ae1 = ab2;
af1 = aa2;
OS aa3;
OS ab3 = absl::nullopt;
OS ac3 = std::string(n, 'c');
std::string sad3(n, 'd');
OS ad3 = sad3;
OS ae3(absl::in_place, n, 'e');
OS af3;
af3.emplace(n, 'f');
aa3 = absl::nullopt;
ab3 = absl::nullopt;
ac3 = absl::nullopt;
ad3 = absl::nullopt;
ae3 = absl::nullopt;
af3 = absl::nullopt;
OS aa4;
OS ab4 = absl::nullopt;
OS ac4 = std::string(n, 'c');
std::string sad4(n, 'd');
OS ad4 = sad4;
OS ae4(absl::in_place, n, 'e');
OS af4;
af4.emplace(n, 'f');
aa4 = OS(absl::in_place, n, 'a');
ab4 = OS(absl::in_place, n, 'b');
ac4 = OS(absl::in_place, n, 'c');
ad4 = OS(absl::in_place, n, 'd');
ae4 = OS(absl::in_place, n, 'e');
af4 = OS(absl::in_place, n, 'f');
OS aa5;
OS ab5 = absl::nullopt;
OS ac5 = std::string(n, 'c');
std::string sad5(n, 'd');
OS ad5 = sad5;
OS ae5(absl::in_place, n, 'e');
OS af5;
af5.emplace(n, 'f');
std::string saa5(n, 'a');
std::string sab5(n, 'a');
std::string sac5(n, 'a');
std::string sad52(n, 'a');
std::string sae5(n, 'a');
std::string saf5(n, 'a');
aa5 = saa5;
ab5 = sab5;
ac5 = sac5;
ad5 = sad52;
ae5 = sae5;
af5 = saf5;
OS aa6;
OS ab6 = absl::nullopt;
OS ac6 = std::string(n, 'c');
std::string sad6(n, 'd');
OS ad6 = sad6;
OS ae6(absl::in_place, n, 'e');
OS af6;
af6.emplace(n, 'f');
aa6 = std::string(n, 'a');
ab6 = std::string(n, 'b');
ac6 = std::string(n, 'c');
ad6 = std::string(n, 'd');
ae6 = std::string(n, 'e');
af6 = std::string(n, 'f');
OS aa7;
OS ab7 = absl::nullopt;
OS ac7 = std::string(n, 'c');
std::string sad7(n, 'd');
OS ad7 = sad7;
OS ae7(absl::in_place, n, 'e');
OS af7;
af7.emplace(n, 'f');
aa7.emplace(n, 'A');
ab7.emplace(n, 'B');
ac7.emplace(n, 'C');
ad7.emplace(n, 'D');
ae7.emplace(n, 'E');
af7.emplace(n, 'F');
}
TEST(optionalTest, MoveAssignRegression) {
StructorListener listener;
Listenable::listener = &listener;
{
absl::optional<Listenable> a;
Listenable b;
a = std::move(b);
}
EXPECT_EQ(1, listener.construct0);
EXPECT_EQ(1, listener.move);
EXPECT_EQ(2, listener.destruct);
}
TEST(optionalTest, ValueType) {
EXPECT_TRUE((std::is_same<absl::optional<int>::value_type, int>::value));
EXPECT_TRUE((std::is_same<absl::optional<std::string>::value_type,
std::string>::value));
EXPECT_FALSE(
(std::is_same<absl::optional<int>::value_type, absl::nullopt_t>::value));
}
template <typename T>
struct is_hash_enabled_for {
template <typename U, typename = decltype(std::hash<U>()(std::declval<U>()))>
static std::true_type test(int);
template <typename U>
static std::false_type test(...);
static constexpr bool value = decltype(test<T>(0))::value;
};
TEST(optionalTest, Hash) {
std::hash<absl::optional<int>> hash;
std::set<size_t> hashcodes;
hashcodes.insert(hash(absl::nullopt));
for (int i = 0; i < 100; ++i) {
hashcodes.insert(hash(i));
}
EXPECT_GT(hashcodes.size(), 90);
static_assert(is_hash_enabled_for<absl::optional<int>>::value, "");
static_assert(is_hash_enabled_for<absl::optional<Hashable>>::value, "");
static_assert(
absl::type_traits_internal::IsHashable<absl::optional<int>>::value, "");
static_assert(
absl::type_traits_internal::IsHashable<absl::optional<Hashable>>::value,
"");
absl::type_traits_internal::AssertHashEnabled<absl::optional<int>>();
absl::type_traits_internal::AssertHashEnabled<absl::optional<Hashable>>();
#if ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
static_assert(!is_hash_enabled_for<absl::optional<NonHashable>>::value, "");
static_assert(!absl::type_traits_internal::IsHashable<
absl::optional<NonHashable>>::value,
"");
#endif
// libstdc++ std::optional is missing remove_const_t, i.e. it's using
// std::hash<T> rather than std::hash<std::remove_const_t<T>>.
// Reference: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82262
#ifndef __GLIBCXX__
static_assert(is_hash_enabled_for<absl::optional<const int>>::value, "");
static_assert(is_hash_enabled_for<absl::optional<const Hashable>>::value, "");
std::hash<absl::optional<const int>> c_hash;
for (int i = 0; i < 100; ++i) {
EXPECT_EQ(hash(i), c_hash(i));
}
#endif
}
struct MoveMeNoThrow {
MoveMeNoThrow() : x(0) {}
[[noreturn]] MoveMeNoThrow(const MoveMeNoThrow& other) : x(other.x) {
ABSL_RAW_LOG(FATAL, "Should not be called.");
abort();
}
MoveMeNoThrow(MoveMeNoThrow&& other) noexcept : x(other.x) {}
int x;
};
struct MoveMeThrow {
MoveMeThrow() : x(0) {}
MoveMeThrow(const MoveMeThrow& other) : x(other.x) {}
MoveMeThrow(MoveMeThrow&& other) : x(other.x) {}
int x;
};
TEST(optionalTest, NoExcept) {
static_assert(
std::is_nothrow_move_constructible<absl::optional<MoveMeNoThrow>>::value,
"");
#ifndef ABSL_USES_STD_OPTIONAL
static_assert(absl::default_allocator_is_nothrow::value ==
std::is_nothrow_move_constructible<
absl::optional<MoveMeThrow>>::value,
"");
#endif
std::vector<absl::optional<MoveMeNoThrow>> v;
for (int i = 0; i < 10; ++i) v.emplace_back();
}
struct AnyLike {
AnyLike(AnyLike&&) = default;
AnyLike(const AnyLike&) = default;
template <typename ValueType,
typename T = typename std::decay<ValueType>::type,
typename std::enable_if<
!absl::disjunction<
std::is_same<AnyLike, T>,
absl::negation<std::is_copy_constructible<T>>>::value,
int>::type = 0>
AnyLike(ValueType&&) {} // NOLINT(runtime/explicit)
AnyLike& operator=(AnyLike&&) = default;
AnyLike& operator=(const AnyLike&) = default;
template <typename ValueType,
typename T = typename std::decay<ValueType>::type>
typename std::enable_if<
absl::conjunction<absl::negation<std::is_same<AnyLike, T>>,
std::is_copy_constructible<T>>::value,
AnyLike&>::type
operator=(ValueType&& /* rhs */) {
return *this;
}
};
TEST(optionalTest, ConstructionConstraints) {
EXPECT_TRUE((std::is_constructible<AnyLike, absl::optional<AnyLike>>::value));
EXPECT_TRUE(
(std::is_constructible<AnyLike, const absl::optional<AnyLike>&>::value));
EXPECT_TRUE((std::is_constructible<absl::optional<AnyLike>, AnyLike>::value));
EXPECT_TRUE(
(std::is_constructible<absl::optional<AnyLike>, const AnyLike&>::value));
EXPECT_TRUE((std::is_convertible<absl::optional<AnyLike>, AnyLike>::value));
EXPECT_TRUE(
(std::is_convertible<const absl::optional<AnyLike>&, AnyLike>::value));
EXPECT_TRUE((std::is_convertible<AnyLike, absl::optional<AnyLike>>::value));
EXPECT_TRUE(
(std::is_convertible<const AnyLike&, absl::optional<AnyLike>>::value));
EXPECT_TRUE(std::is_move_constructible<absl::optional<AnyLike>>::value);
EXPECT_TRUE(std::is_copy_constructible<absl::optional<AnyLike>>::value);
}
TEST(optionalTest, AssignmentConstraints) {
EXPECT_TRUE((std::is_assignable<AnyLike&, absl::optional<AnyLike>>::value));
EXPECT_TRUE(
(std::is_assignable<AnyLike&, const absl::optional<AnyLike>&>::value));
EXPECT_TRUE((std::is_assignable<absl::optional<AnyLike>&, AnyLike>::value));
EXPECT_TRUE(
(std::is_assignable<absl::optional<AnyLike>&, const AnyLike&>::value));
EXPECT_TRUE(std::is_move_assignable<absl::optional<AnyLike>>::value);
EXPECT_TRUE(absl::is_copy_assignable<absl::optional<AnyLike>>::value);
}
#if !defined(__EMSCRIPTEN__)
struct NestedClassBug {
struct Inner {
bool dummy = false;
};
absl::optional<Inner> value;
};
TEST(optionalTest, InPlaceTSFINAEBug) {
NestedClassBug b;
((void)b);
using Inner = NestedClassBug::Inner;
EXPECT_TRUE((std::is_default_constructible<Inner>::value));
EXPECT_TRUE((std::is_constructible<Inner>::value));
EXPECT_TRUE(
(std::is_constructible<absl::optional<Inner>, absl::in_place_t>::value));
absl::optional<Inner> o(absl::in_place);
EXPECT_TRUE(o.has_value());
o.emplace();
EXPECT_TRUE(o.has_value());
}
#endif // !defined(__EMSCRIPTEN__)
} // namespace
#endif // #if !defined(ABSL_USES_STD_OPTIONAL)
