| 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617 | // 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////      http://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.// Unit tests for the variant template. The 'is' and 'IsEmpty' methods// of variant are not explicitly tested because they are used repeatedly// in building other tests. All other public variant methods should have// explicit tests.#include "absl/types/variant.h"#include <algorithm>#include <cstddef>#include <functional>#include <initializer_list>#include <memory>#include <ostream>#include <queue>#include <type_traits>#include <unordered_set>#include <utility>#include <vector>#include "gmock/gmock.h"#include "gtest/gtest.h"#include "absl/base/config.h"#include "absl/base/port.h"#include "absl/memory/memory.h"#include "absl/meta/type_traits.h"#include "absl/strings/string_view.h"#ifdef ABSL_HAVE_EXCEPTIONS#define ABSL_VARIANT_TEST_EXPECT_FAIL(expr, exception_t, text) \  EXPECT_THROW(expr, exception_t)#else#define ABSL_VARIANT_TEST_EXPECT_FAIL(expr, exception_t, text) \  EXPECT_DEATH(expr, text)#endif  // ABSL_HAVE_EXCEPTIONS#define ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(...)                 \  ABSL_VARIANT_TEST_EXPECT_FAIL((void)(__VA_ARGS__), absl::bad_variant_access, \                                "Bad variant access")struct Hashable {};namespace std {template <>struct hash<Hashable> {  size_t operator()(const Hashable&);};}  // namespace stdstruct NonHashable {};namespace absl {namespace {using ::testing::DoubleEq;using ::testing::Pointee;using ::testing::VariantWith;struct MoveCanThrow {  MoveCanThrow() : v(0) {}  MoveCanThrow(int v) : v(v) {}  // NOLINT(runtime/explicit)  MoveCanThrow(const MoveCanThrow& other) : v(other.v) {}  MoveCanThrow& operator=(const MoveCanThrow& /*other*/) { return *this; }  int v;};bool operator==(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v == rhs.v; }bool operator!=(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v != rhs.v; }bool operator<(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v < rhs.v; }bool operator<=(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v <= rhs.v; }bool operator>=(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v >= rhs.v; }bool operator>(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v > rhs.v; }// This helper class allows us to determine if it was swapped with std::swap()// or with its friend swap() function.struct SpecialSwap {  explicit SpecialSwap(int i) : i(i) {}  friend void swap(SpecialSwap& a, SpecialSwap& b) {    a.special_swap = b.special_swap = true;    std::swap(a.i, b.i);  }  bool operator==(SpecialSwap other) const { return i == other.i; }  int i;  bool special_swap = false;};struct MoveOnlyWithListConstructor {  MoveOnlyWithListConstructor() = default;  explicit MoveOnlyWithListConstructor(std::initializer_list<int> /*ilist*/,                                       int value)      : value(value) {}  MoveOnlyWithListConstructor(MoveOnlyWithListConstructor&&) = default;  MoveOnlyWithListConstructor& operator=(MoveOnlyWithListConstructor&&) =      default;  int value = 0;};#ifdef ABSL_HAVE_EXCEPTIONSstruct ConversionException {};template <class T>struct ExceptionOnConversion {  operator T() const {  // NOLINT(runtime/explicit)    throw ConversionException();  }};// Forces a variant into the valueless by exception state.template <class H, class... T>void ToValuelessByException(absl::variant<H, T...>& v) {  // NOLINT  try {    v.template emplace<0>(ExceptionOnConversion<H>());  } catch (ConversionException& /*e*/) {    // This space intentionally left blank.  }}#endif  // ABSL_HAVE_EXCEPTIONS// An indexed sequence of distinct structures holding a single// value of type Ttemplate<typename T, size_t N>struct ValueHolder {  explicit ValueHolder(const T& x) : value(x) {}  typedef T value_type;  value_type value;  static const size_t kIndex = N;};template<typename T, size_t N>const size_t ValueHolder<T, N>::kIndex;// The following three functions make ValueHolder compatible with// EXPECT_EQ and EXPECT_NEtemplate<typename T, size_t N>inline bool operator==(const ValueHolder<T, N>& left,                       const ValueHolder<T, N>& right) {  return left.value == right.value;}template<typename T, size_t N>inline bool operator!=(const ValueHolder<T, N>& left,                       const ValueHolder<T, N>& right) {  return left.value != right.value;}template<typename T, size_t N>inline std::ostream& operator<<(    std::ostream& stream, const ValueHolder<T, N>& object) {  return stream << object.value;}// Makes a variant holding twelve uniquely typed T wrappers.template<typename T>struct VariantFactory {  typedef variant<ValueHolder<T, 1>, ValueHolder<T, 2>, ValueHolder<T, 3>,                  ValueHolder<T, 4>>      Type;};// A typelist in 1:1 with VariantFactory, to use type driven unit tests.typedef ::testing::Types<ValueHolder<size_t, 1>, ValueHolder<size_t, 2>,                         ValueHolder<size_t, 3>,                         ValueHolder<size_t, 4>> VariantTypes;// Increments the provided counter pointer in the destructorstruct IncrementInDtor {  explicit IncrementInDtor(int* counter) : counter(counter) {}  ~IncrementInDtor() { *counter += 1; }  int* counter;};struct IncrementInDtorCopyCanThrow {  explicit IncrementInDtorCopyCanThrow(int* counter) : counter(counter) {}  IncrementInDtorCopyCanThrow(IncrementInDtorCopyCanThrow&& other) noexcept =      default;  IncrementInDtorCopyCanThrow(const IncrementInDtorCopyCanThrow& other)      : counter(other.counter) {}  IncrementInDtorCopyCanThrow& operator=(      IncrementInDtorCopyCanThrow&&) noexcept = default;  IncrementInDtorCopyCanThrow& operator=(      IncrementInDtorCopyCanThrow const& other) {    counter = other.counter;    return *this;  }  ~IncrementInDtorCopyCanThrow() { *counter += 1; }  int* counter;};// This is defined so operator== for ValueHolder<IncrementInDtor> will// return true if two IncrementInDtor objects increment the same// counterinline bool operator==(const IncrementInDtor& left,                       const IncrementInDtor& right) {  return left.counter == right.counter;}// This is defined so EXPECT_EQ can work with IncrementInDtorinline std::ostream& operator<<(    std::ostream& stream, const IncrementInDtor& object) {  return stream << object.counter;}// A class that can be copied, but not assigned.class CopyNoAssign { public:  explicit CopyNoAssign(int value) : foo(value) {}  CopyNoAssign(const CopyNoAssign& other) : foo(other.foo) {}  int foo; private:  const CopyNoAssign& operator=(const CopyNoAssign&);};// A class that can neither be copied nor assigned. We provide// overloads for the constructor with up to four parameters so we can// test the overloads of variant::emplace.class NonCopyable { public:  NonCopyable()      : value(0) {}  explicit NonCopyable(int value1)      : value(value1) {}  NonCopyable(int value1, int value2)      : value(value1 + value2) {}  NonCopyable(int value1, int value2, int value3)      : value(value1 + value2 + value3) {}  NonCopyable(int value1, int value2, int value3, int value4)      : value(value1 + value2 + value3 + value4) {}  NonCopyable(const NonCopyable&) = delete;  NonCopyable& operator=(const NonCopyable&) = delete;  int value;};// A typed test and typed test case over the VariantTypes typelist,// from which we derive a number of tests that will execute for one of// each type.template <typename T>class VariantTypesTest : public ::testing::Test {};TYPED_TEST_CASE(VariantTypesTest, VariantTypes);////////////////////// [variant.ctor] //////////////////////struct NonNoexceptDefaultConstructible {  NonNoexceptDefaultConstructible() {}  int value = 5;};struct NonDefaultConstructible {  NonDefaultConstructible() = delete;};TEST(VariantTest, TestDefaultConstructor) {  {    using X = variant<int>;    constexpr variant<int> x{};    ASSERT_FALSE(x.valueless_by_exception());    ASSERT_EQ(0, x.index());    EXPECT_EQ(0, absl::get<0>(x));    EXPECT_TRUE(std::is_nothrow_default_constructible<X>::value);  }  {    using X = variant<NonNoexceptDefaultConstructible>;    X x{};    ASSERT_FALSE(x.valueless_by_exception());    ASSERT_EQ(0, x.index());    EXPECT_EQ(5, absl::get<0>(x).value);    EXPECT_FALSE(std::is_nothrow_default_constructible<X>::value);  }  {    using X = variant<int, NonNoexceptDefaultConstructible>;    X x{};    ASSERT_FALSE(x.valueless_by_exception());    ASSERT_EQ(0, x.index());    EXPECT_EQ(0, absl::get<0>(x));    EXPECT_TRUE(std::is_nothrow_default_constructible<X>::value);  }  {    using X = variant<NonNoexceptDefaultConstructible, int>;    X x{};    ASSERT_FALSE(x.valueless_by_exception());    ASSERT_EQ(0, x.index());    EXPECT_EQ(5, absl::get<0>(x).value);    EXPECT_FALSE(std::is_nothrow_default_constructible<X>::value);  }  EXPECT_FALSE(      std::is_default_constructible<variant<NonDefaultConstructible>>::value);  EXPECT_FALSE((std::is_default_constructible<                variant<NonDefaultConstructible, int>>::value));  EXPECT_TRUE((std::is_default_constructible<               variant<int, NonDefaultConstructible>>::value));}// Test that for each slot, copy constructing a variant with that type// produces a sensible object that correctly reports its type, and// that copies the provided value.TYPED_TEST(VariantTypesTest, TestCopyCtor) {  typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;  using value_type1 = absl::variant_alternative_t<0, Variant>;  using value_type2 = absl::variant_alternative_t<1, Variant>;  using value_type3 = absl::variant_alternative_t<2, Variant>;  using value_type4 = absl::variant_alternative_t<3, Variant>;  const TypeParam value(TypeParam::kIndex);  Variant original(value);  Variant copied(original);  EXPECT_TRUE(absl::holds_alternative<value_type1>(copied) ||              TypeParam::kIndex != 1);  EXPECT_TRUE(absl::holds_alternative<value_type2>(copied) ||              TypeParam::kIndex != 2);  EXPECT_TRUE(absl::holds_alternative<value_type3>(copied) ||              TypeParam::kIndex != 3);  EXPECT_TRUE(absl::holds_alternative<value_type4>(copied) ||              TypeParam::kIndex != 4);  EXPECT_TRUE((absl::get_if<value_type1>(&original) ==               absl::get_if<value_type1>(&copied)) ||              TypeParam::kIndex == 1);  EXPECT_TRUE((absl::get_if<value_type2>(&original) ==               absl::get_if<value_type2>(&copied)) ||              TypeParam::kIndex == 2);  EXPECT_TRUE((absl::get_if<value_type3>(&original) ==               absl::get_if<value_type3>(&copied)) ||              TypeParam::kIndex == 3);  EXPECT_TRUE((absl::get_if<value_type4>(&original) ==               absl::get_if<value_type4>(&copied)) ||              TypeParam::kIndex == 4);  EXPECT_TRUE((absl::get_if<value_type1>(&original) ==               absl::get_if<value_type1>(&copied)) ||              TypeParam::kIndex == 1);  EXPECT_TRUE((absl::get_if<value_type2>(&original) ==               absl::get_if<value_type2>(&copied)) ||              TypeParam::kIndex == 2);  EXPECT_TRUE((absl::get_if<value_type3>(&original) ==               absl::get_if<value_type3>(&copied)) ||              TypeParam::kIndex == 3);  EXPECT_TRUE((absl::get_if<value_type4>(&original) ==               absl::get_if<value_type4>(&copied)) ||              TypeParam::kIndex == 4);  const TypeParam* ovalptr = absl::get_if<TypeParam>(&original);  const TypeParam* cvalptr = absl::get_if<TypeParam>(&copied);  ASSERT_TRUE(ovalptr != nullptr);  ASSERT_TRUE(cvalptr != nullptr);  EXPECT_EQ(*ovalptr, *cvalptr);  TypeParam* mutable_ovalptr = absl::get_if<TypeParam>(&original);  TypeParam* mutable_cvalptr = absl::get_if<TypeParam>(&copied);  ASSERT_TRUE(mutable_ovalptr != nullptr);  ASSERT_TRUE(mutable_cvalptr != nullptr);  EXPECT_EQ(*mutable_ovalptr, *mutable_cvalptr);}template <class>struct MoveOnly {  MoveOnly() = default;  explicit MoveOnly(int value) : value(value) {}  MoveOnly(MoveOnly&&) = default;  MoveOnly& operator=(MoveOnly&&) = default;  int value = 5;};TEST(VariantTest, TestMoveConstruct) {  using V = variant<MoveOnly<class A>, MoveOnly<class B>, MoveOnly<class C>>;  V v(in_place_index_t<1>{}, 10);  V v2 = absl::move(v);  EXPECT_EQ(10, absl::get<1>(v2).value);}// Used internally to emulate missing triviality traits for tests.template <class T>union SingleUnion {  T member;};// NOTE: These don't work with types that can't be union members.//       They are just for testing.template <class T>struct is_trivially_move_constructible    : std::is_move_constructible<SingleUnion<T>>::type {};template <class T>struct is_trivially_move_assignable    : absl::is_move_assignable<SingleUnion<T>>::type {};TEST(VariantTest, NothrowMoveConstructible) {  // Verify that variant is nothrow move constructible iff its template  // arguments are.  using U = std::unique_ptr<int>;  struct E {    E(E&&) {}  };  static_assert(std::is_nothrow_move_constructible<variant<U>>::value, "");  static_assert(std::is_nothrow_move_constructible<variant<U, int>>::value, "");  static_assert(!std::is_nothrow_move_constructible<variant<U, E>>::value, "");}// Test that for each slot, constructing a variant with that type// produces a sensible object that correctly reports its type, and// that copies the provided value.TYPED_TEST(VariantTypesTest, TestValueCtor) {  typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;  using value_type1 = absl::variant_alternative_t<0, Variant>;  using value_type2 = absl::variant_alternative_t<1, Variant>;  using value_type3 = absl::variant_alternative_t<2, Variant>;  using value_type4 = absl::variant_alternative_t<3, Variant>;  const TypeParam value(TypeParam::kIndex);  Variant v(value);  EXPECT_TRUE(absl::holds_alternative<value_type1>(v) ||              TypeParam::kIndex != 1);  EXPECT_TRUE(absl::holds_alternative<value_type2>(v) ||              TypeParam::kIndex != 2);  EXPECT_TRUE(absl::holds_alternative<value_type3>(v) ||              TypeParam::kIndex != 3);  EXPECT_TRUE(absl::holds_alternative<value_type4>(v) ||              TypeParam::kIndex != 4);  EXPECT_TRUE(nullptr != absl::get_if<value_type1>(&v) ||              TypeParam::kIndex != 1);  EXPECT_TRUE(nullptr != absl::get_if<value_type2>(&v) ||              TypeParam::kIndex != 2);  EXPECT_TRUE(nullptr != absl::get_if<value_type3>(&v) ||              TypeParam::kIndex != 3);  EXPECT_TRUE(nullptr != absl::get_if<value_type4>(&v) ||              TypeParam::kIndex != 4);  EXPECT_TRUE(nullptr != absl::get_if<value_type1>(&v) ||              TypeParam::kIndex != 1);  EXPECT_TRUE(nullptr != absl::get_if<value_type2>(&v) ||              TypeParam::kIndex != 2);  EXPECT_TRUE(nullptr != absl::get_if<value_type3>(&v) ||              TypeParam::kIndex != 3);  EXPECT_TRUE(nullptr != absl::get_if<value_type4>(&v) ||              TypeParam::kIndex != 4);  const TypeParam* valptr = absl::get_if<TypeParam>(&v);  ASSERT_TRUE(nullptr != valptr);  EXPECT_EQ(value.value, valptr->value);  const TypeParam* mutable_valptr = absl::get_if<TypeParam>(&v);  ASSERT_TRUE(nullptr != mutable_valptr);  EXPECT_EQ(value.value, mutable_valptr->value);}TEST(VariantTest, InPlaceType) {  using Var = variant<int, std::string, NonCopyable, std::vector<int>>;  Var v1(in_place_type_t<int>(), 7);  ASSERT_TRUE(absl::holds_alternative<int>(v1));  EXPECT_EQ(7, absl::get<int>(v1));  Var v2(in_place_type_t<std::string>(), "ABC");  ASSERT_TRUE(absl::holds_alternative<std::string>(v2));  EXPECT_EQ("ABC", absl::get<std::string>(v2));  Var v3(in_place_type_t<std::string>(), "ABC", 2);  ASSERT_TRUE(absl::holds_alternative<std::string>(v3));  EXPECT_EQ("AB", absl::get<std::string>(v3));  Var v4(in_place_type_t<NonCopyable>{});  ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v4));  Var v5(in_place_type_t<std::vector<int>>(), {1, 2, 3});  ASSERT_TRUE(absl::holds_alternative<std::vector<int>>(v5));  EXPECT_THAT(absl::get<std::vector<int>>(v5), ::testing::ElementsAre(1, 2, 3));}TEST(VariantTest, InPlaceTypeInitializerList) {  using Var = variant<int, std::string, NonCopyable, MoveOnlyWithListConstructor>;  Var v1(in_place_type_t<MoveOnlyWithListConstructor>(), {1, 2, 3, 4, 5}, 6);  ASSERT_TRUE(absl::holds_alternative<MoveOnlyWithListConstructor>(v1));  EXPECT_EQ(6, absl::get<MoveOnlyWithListConstructor>(v1).value);}TEST(VariantTest, InPlaceIndex) {  using Var = variant<int, std::string, NonCopyable, std::vector<int>>;  Var v1(in_place_index_t<0>(), 7);  ASSERT_TRUE(absl::holds_alternative<int>(v1));  EXPECT_EQ(7, absl::get<int>(v1));  Var v2(in_place_index_t<1>(), "ABC");  ASSERT_TRUE(absl::holds_alternative<std::string>(v2));  EXPECT_EQ("ABC", absl::get<std::string>(v2));  Var v3(in_place_index_t<1>(), "ABC", 2);  ASSERT_TRUE(absl::holds_alternative<std::string>(v3));  EXPECT_EQ("AB", absl::get<std::string>(v3));  Var v4(in_place_index_t<2>{});  EXPECT_TRUE(absl::holds_alternative<NonCopyable>(v4));  // Verify that a variant with only non-copyables can still be constructed.  EXPECT_TRUE(absl::holds_alternative<NonCopyable>(      variant<NonCopyable>(in_place_index_t<0>{})));  Var v5(in_place_index_t<3>(), {1, 2, 3});  ASSERT_TRUE(absl::holds_alternative<std::vector<int>>(v5));  EXPECT_THAT(absl::get<std::vector<int>>(v5), ::testing::ElementsAre(1, 2, 3));}TEST(VariantTest, InPlaceIndexInitializerList) {  using Var = variant<int, std::string, NonCopyable, MoveOnlyWithListConstructor>;  Var v1(in_place_index_t<3>(), {1, 2, 3, 4, 5}, 6);  ASSERT_TRUE(absl::holds_alternative<MoveOnlyWithListConstructor>(v1));  EXPECT_EQ(6, absl::get<MoveOnlyWithListConstructor>(v1).value);}////////////////////// [variant.dtor] //////////////////////// Make sure that the destructor destroys the contained valueTEST(VariantTest, TestDtor) {  typedef VariantFactory<IncrementInDtor>::Type Variant;  using value_type1 = absl::variant_alternative_t<0, Variant>;  using value_type2 = absl::variant_alternative_t<1, Variant>;  using value_type3 = absl::variant_alternative_t<2, Variant>;  using value_type4 = absl::variant_alternative_t<3, Variant>;  int counter = 0;  IncrementInDtor counter_adjuster(&counter);  EXPECT_EQ(0, counter);  value_type1 value1(counter_adjuster);  { Variant object(value1); }  EXPECT_EQ(1, counter);  value_type2 value2(counter_adjuster);  { Variant object(value2); }  EXPECT_EQ(2, counter);  value_type3 value3(counter_adjuster);  { Variant object(value3); }  EXPECT_EQ(3, counter);  value_type4 value4(counter_adjuster);  { Variant object(value4); }  EXPECT_EQ(4, counter);}#ifdef ABSL_HAVE_EXCEPTIONS// See comment in absl/base/config.h#if defined(ABSL_INTERNAL_MSVC_2017_DBG_MODE)TEST(VariantTest, DISABLED_TestDtorValuelessByException)#else// Test destruction when in the valueless_by_exception state.TEST(VariantTest, TestDtorValuelessByException)#endif{  int counter = 0;  IncrementInDtor counter_adjuster(&counter);  {    using Variant = VariantFactory<IncrementInDtor>::Type;    Variant v(in_place_index_t<0>(), counter_adjuster);    EXPECT_EQ(0, counter);    ToValuelessByException(v);    ASSERT_TRUE(v.valueless_by_exception());    EXPECT_EQ(1, counter);  }  EXPECT_EQ(1, counter);}#endif  // ABSL_HAVE_EXCEPTIONS//////////////////////// [variant.assign] ////////////////////////// Test that self-assignment doesn't destroy the current valueTEST(VariantTest, TestSelfAssignment) {  typedef VariantFactory<IncrementInDtor>::Type Variant;  int counter = 0;  IncrementInDtor counter_adjuster(&counter);  absl::variant_alternative_t<0, Variant> value(counter_adjuster);  Variant object(value);  object.operator=(object);  EXPECT_EQ(0, counter);  // A std::string long enough that it's likely to defeat any inline representation  // optimization.  const std::string long_str(128, 'a');  std::string foo = long_str;  foo = *&foo;  EXPECT_EQ(long_str, foo);  variant<int, std::string> so = long_str;  ASSERT_EQ(1, so.index());  EXPECT_EQ(long_str, absl::get<1>(so));  so = *&so;  ASSERT_EQ(1, so.index());  EXPECT_EQ(long_str, absl::get<1>(so));}// Test that assigning a variant<..., T, ...> to a variant<..., T, ...> produces// a variant<..., T, ...> with the correct value.TYPED_TEST(VariantTypesTest, TestAssignmentCopiesValueSameTypes) {  typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;  const TypeParam value(TypeParam::kIndex);  const Variant source(value);  Variant target(TypeParam(value.value + 1));  ASSERT_TRUE(absl::holds_alternative<TypeParam>(source));  ASSERT_TRUE(absl::holds_alternative<TypeParam>(target));  ASSERT_NE(absl::get<TypeParam>(source), absl::get<TypeParam>(target));  target = source;  ASSERT_TRUE(absl::holds_alternative<TypeParam>(source));  ASSERT_TRUE(absl::holds_alternative<TypeParam>(target));  EXPECT_EQ(absl::get<TypeParam>(source), absl::get<TypeParam>(target));}// Test that assisnging a variant<..., T, ...> to a variant<1, ...>// produces a variant<..., T, ...> with the correct value.TYPED_TEST(VariantTypesTest, TestAssignmentCopiesValuesVaryingSourceType) {  typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;  using value_type1 = absl::variant_alternative_t<0, Variant>;  const TypeParam value(TypeParam::kIndex);  const Variant source(value);  ASSERT_TRUE(absl::holds_alternative<TypeParam>(source));  Variant target(value_type1(1));  ASSERT_TRUE(absl::holds_alternative<value_type1>(target));  target = source;  EXPECT_TRUE(absl::holds_alternative<TypeParam>(source));  EXPECT_TRUE(absl::holds_alternative<TypeParam>(target));  EXPECT_EQ(absl::get<TypeParam>(source), absl::get<TypeParam>(target));}// Test that assigning a variant<1, ...> to a variant<..., T, ...>// produces a variant<1, ...> with the correct value.TYPED_TEST(VariantTypesTest, TestAssignmentCopiesValuesVaryingTargetType) {  typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;  using value_type1 = absl::variant_alternative_t<0, Variant>;  const Variant source(value_type1(1));  ASSERT_TRUE(absl::holds_alternative<value_type1>(source));  const TypeParam value(TypeParam::kIndex);  Variant target(value);  ASSERT_TRUE(absl::holds_alternative<TypeParam>(target));  target = source;  EXPECT_TRUE(absl::holds_alternative<value_type1>(target));  EXPECT_TRUE(absl::holds_alternative<value_type1>(source));  EXPECT_EQ(absl::get<value_type1>(source), absl::get<value_type1>(target));}// Test that operator=<T> works, that assigning a new value destroys// the old and that assigning the new value again does not redestroy// the oldTEST(VariantTest, TestAssign) {  typedef VariantFactory<IncrementInDtor>::Type Variant;  using value_type1 = absl::variant_alternative_t<0, Variant>;  using value_type2 = absl::variant_alternative_t<1, Variant>;  using value_type3 = absl::variant_alternative_t<2, Variant>;  using value_type4 = absl::variant_alternative_t<3, Variant>;  const int kSize = 4;  int counter[kSize];  std::unique_ptr<IncrementInDtor> counter_adjustor[kSize];  for (int i = 0; i != kSize; i++) {    counter[i] = 0;    counter_adjustor[i] = absl::make_unique<IncrementInDtor>(&counter[i]);  }  value_type1 v1(*counter_adjustor[0]);  value_type2 v2(*counter_adjustor[1]);  value_type3 v3(*counter_adjustor[2]);  value_type4 v4(*counter_adjustor[3]);  // Test that reassignment causes destruction of old value  {    Variant object(v1);    object = v2;    object = v3;    object = v4;    object = v1;  }  EXPECT_EQ(2, counter[0]);  EXPECT_EQ(1, counter[1]);  EXPECT_EQ(1, counter[2]);  EXPECT_EQ(1, counter[3]);  std::fill(std::begin(counter), std::end(counter), 0);  // Test that self-assignment does not cause destruction of old value  {    Variant object(v1);    object.operator=(object);    EXPECT_EQ(0, counter[0]);  }  {    Variant object(v2);    object.operator=(object);    EXPECT_EQ(0, counter[1]);  }  {    Variant object(v3);    object.operator=(object);    EXPECT_EQ(0, counter[2]);  }  {    Variant object(v4);    object.operator=(object);    EXPECT_EQ(0, counter[3]);  }  EXPECT_EQ(1, counter[0]);  EXPECT_EQ(1, counter[1]);  EXPECT_EQ(1, counter[2]);  EXPECT_EQ(1, counter[3]);}// This tests that we perform a backup if the copy-assign can throw but the move// cannot throw.TEST(VariantTest, TestBackupAssign) {  typedef VariantFactory<IncrementInDtorCopyCanThrow>::Type Variant;  using value_type1 = absl::variant_alternative_t<0, Variant>;  using value_type2 = absl::variant_alternative_t<1, Variant>;  using value_type3 = absl::variant_alternative_t<2, Variant>;  using value_type4 = absl::variant_alternative_t<3, Variant>;  const int kSize = 4;  int counter[kSize];  std::unique_ptr<IncrementInDtorCopyCanThrow> counter_adjustor[kSize];  for (int i = 0; i != kSize; i++) {    counter[i] = 0;    counter_adjustor[i].reset(new IncrementInDtorCopyCanThrow(&counter[i]));  }  value_type1 v1(*counter_adjustor[0]);  value_type2 v2(*counter_adjustor[1]);  value_type3 v3(*counter_adjustor[2]);  value_type4 v4(*counter_adjustor[3]);  // Test that reassignment causes destruction of old value  {    Variant object(v1);    object = v2;    object = v3;    object = v4;    object = v1;  }  // libstdc++ doesn't pass this test#if !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__))  EXPECT_EQ(3, counter[0]);  EXPECT_EQ(2, counter[1]);  EXPECT_EQ(2, counter[2]);  EXPECT_EQ(2, counter[3]);#endif  std::fill(std::begin(counter), std::end(counter), 0);  // Test that self-assignment does not cause destruction of old value  {    Variant object(v1);    object.operator=(object);    EXPECT_EQ(0, counter[0]);  }  {    Variant object(v2);    object.operator=(object);    EXPECT_EQ(0, counter[1]);  }  {    Variant object(v3);    object.operator=(object);    EXPECT_EQ(0, counter[2]);  }  {    Variant object(v4);    object.operator=(object);    EXPECT_EQ(0, counter[3]);  }  EXPECT_EQ(1, counter[0]);  EXPECT_EQ(1, counter[1]);  EXPECT_EQ(1, counter[2]);  EXPECT_EQ(1, counter[3]);}///////////////////// [variant.mod] /////////////////////TEST(VariantTest, TestEmplaceBasic) {  using Variant = variant<int, char>;  Variant v(absl::in_place_index_t<0>{}, 0);  {    char& emplace_result = v.emplace<char>();    ASSERT_TRUE(absl::holds_alternative<char>(v));    EXPECT_EQ(absl::get<char>(v), 0);    EXPECT_EQ(&emplace_result, &absl::get<char>(v));  }  // Make sure that another emplace does zero-initialization  absl::get<char>(v) = 'a';  v.emplace<char>('b');  ASSERT_TRUE(absl::holds_alternative<char>(v));  EXPECT_EQ(absl::get<char>(v), 'b');  {    int& emplace_result = v.emplace<int>();    EXPECT_TRUE(absl::holds_alternative<int>(v));    EXPECT_EQ(absl::get<int>(v), 0);    EXPECT_EQ(&emplace_result, &absl::get<int>(v));  }}TEST(VariantTest, TestEmplaceInitializerList) {  using Var = variant<int, std::string, NonCopyable, MoveOnlyWithListConstructor>;  Var v1(absl::in_place_index_t<0>{}, 555);  MoveOnlyWithListConstructor& emplace_result =      v1.emplace<MoveOnlyWithListConstructor>({1, 2, 3, 4, 5}, 6);  ASSERT_TRUE(absl::holds_alternative<MoveOnlyWithListConstructor>(v1));  EXPECT_EQ(6, absl::get<MoveOnlyWithListConstructor>(v1).value);  EXPECT_EQ(&emplace_result, &absl::get<MoveOnlyWithListConstructor>(v1));}TEST(VariantTest, TestEmplaceIndex) {  using Variant = variant<int, char>;  Variant v(absl::in_place_index_t<0>{}, 555);  {    char& emplace_result = v.emplace<1>();    ASSERT_TRUE(absl::holds_alternative<char>(v));    EXPECT_EQ(absl::get<char>(v), 0);    EXPECT_EQ(&emplace_result, &absl::get<char>(v));  }  // Make sure that another emplace does zero-initialization  absl::get<char>(v) = 'a';  v.emplace<1>('b');  ASSERT_TRUE(absl::holds_alternative<char>(v));  EXPECT_EQ(absl::get<char>(v), 'b');  {    int& emplace_result = v.emplace<0>();    EXPECT_TRUE(absl::holds_alternative<int>(v));    EXPECT_EQ(absl::get<int>(v), 0);    EXPECT_EQ(&emplace_result, &absl::get<int>(v));  }}TEST(VariantTest, TestEmplaceIndexInitializerList) {  using Var = variant<int, std::string, NonCopyable, MoveOnlyWithListConstructor>;  Var v1(absl::in_place_index_t<0>{}, 555);  MoveOnlyWithListConstructor& emplace_result =      v1.emplace<3>({1, 2, 3, 4, 5}, 6);  ASSERT_TRUE(absl::holds_alternative<MoveOnlyWithListConstructor>(v1));  EXPECT_EQ(6, absl::get<MoveOnlyWithListConstructor>(v1).value);  EXPECT_EQ(&emplace_result, &absl::get<MoveOnlyWithListConstructor>(v1));}//////////////////////// [variant.status] ////////////////////////TEST(VariantTest, Index) {  using Var = variant<int, std::string, double>;  Var v = 1;  EXPECT_EQ(0, v.index());  v = "str";  EXPECT_EQ(1, v.index());  v = 0.;  EXPECT_EQ(2, v.index());  Var v2 = v;  EXPECT_EQ(2, v2.index());  v2.emplace<int>(3);  EXPECT_EQ(0, v2.index());}TEST(VariantTest, NotValuelessByException) {  using Var = variant<int, std::string, double>;  Var v = 1;  EXPECT_FALSE(v.valueless_by_exception());  v = "str";  EXPECT_FALSE(v.valueless_by_exception());  v = 0.;  EXPECT_FALSE(v.valueless_by_exception());  Var v2 = v;  EXPECT_FALSE(v.valueless_by_exception());  v2.emplace<int>(3);  EXPECT_FALSE(v.valueless_by_exception());}#ifdef ABSL_HAVE_EXCEPTIONSTEST(VariantTest, IndexValuelessByException) {  using Var = variant<MoveCanThrow, std::string, double>;  Var v(absl::in_place_index_t<0>{});  EXPECT_EQ(0, v.index());  ToValuelessByException(v);  EXPECT_EQ(absl::variant_npos, v.index());  v = "str";  EXPECT_EQ(1, v.index());}TEST(VariantTest, ValuelessByException) {  using Var = variant<MoveCanThrow, std::string, double>;  Var v(absl::in_place_index_t<0>{});  EXPECT_FALSE(v.valueless_by_exception());  ToValuelessByException(v);  EXPECT_TRUE(v.valueless_by_exception());  v = "str";  EXPECT_FALSE(v.valueless_by_exception());}#endif  // ABSL_HAVE_EXCEPTIONS////////////////////// [variant.swap] //////////////////////TEST(VariantTest, MemberSwap) {  SpecialSwap v1(3);  SpecialSwap v2(7);  variant<SpecialSwap> a = v1, b = v2;  EXPECT_THAT(a, VariantWith<SpecialSwap>(v1));  EXPECT_THAT(b, VariantWith<SpecialSwap>(v2));  a.swap(b);  EXPECT_THAT(a, VariantWith<SpecialSwap>(v2));  EXPECT_THAT(b, VariantWith<SpecialSwap>(v1));  EXPECT_TRUE(absl::get<SpecialSwap>(a).special_swap);  using V = variant<MoveCanThrow, std::string, int>;  int i = 33;  std::string s = "abc";  V valueless(in_place_index_t<0>{});  ToValuelessByException(valueless);  {    // lhs and rhs holds different alternative    V lhs(i), rhs(s);    lhs.swap(rhs);    EXPECT_THAT(lhs, VariantWith<std::string>(s));    EXPECT_THAT(rhs, VariantWith<int>(i));  }  {    // lhs is valueless    V lhs(valueless), rhs(i);    lhs.swap(rhs);    EXPECT_THAT(lhs, VariantWith<int>(i));    EXPECT_TRUE(rhs.valueless_by_exception());  }  {    // rhs is valueless    V lhs(s), rhs(valueless);    lhs.swap(rhs);    EXPECT_THAT(rhs, VariantWith<std::string>(s));    EXPECT_TRUE(lhs.valueless_by_exception());  }  {    // both are valueless    V lhs(valueless), rhs(valueless);    lhs.swap(rhs);    EXPECT_TRUE(lhs.valueless_by_exception());    EXPECT_TRUE(rhs.valueless_by_exception());  }}//////////////////////// [variant.helper] ////////////////////////TEST(VariantTest, VariantSize) {  {    using Size1Variant = absl::variant<int>;    EXPECT_EQ(1, absl::variant_size<Size1Variant>::value);    EXPECT_EQ(1, absl::variant_size<const Size1Variant>::value);    EXPECT_EQ(1, absl::variant_size<volatile Size1Variant>::value);    EXPECT_EQ(1, absl::variant_size<const volatile Size1Variant>::value);  }  {    using Size3Variant = absl::variant<int, float, int>;    EXPECT_EQ(3, absl::variant_size<Size3Variant>::value);    EXPECT_EQ(3, absl::variant_size<const Size3Variant>::value);    EXPECT_EQ(3, absl::variant_size<volatile Size3Variant>::value);    EXPECT_EQ(3, absl::variant_size<const volatile Size3Variant>::value);  }}TEST(VariantTest, VariantAlternative) {  {    using V = absl::variant<float, int, const char*>;    EXPECT_TRUE(        (std::is_same<float, absl::variant_alternative_t<0, V>>::value));    EXPECT_TRUE((std::is_same<const float,                              absl::variant_alternative_t<0, const V>>::value));    EXPECT_TRUE(        (std::is_same<volatile float,                      absl::variant_alternative_t<0, volatile V>>::value));    EXPECT_TRUE((        std::is_same<const volatile float,                     absl::variant_alternative_t<0, const volatile V>>::value));    EXPECT_TRUE((std::is_same<int, absl::variant_alternative_t<1, V>>::value));    EXPECT_TRUE((std::is_same<const int,                              absl::variant_alternative_t<1, const V>>::value));    EXPECT_TRUE(        (std::is_same<volatile int,                      absl::variant_alternative_t<1, volatile V>>::value));    EXPECT_TRUE((        std::is_same<const volatile int,                     absl::variant_alternative_t<1, const volatile V>>::value));    EXPECT_TRUE(        (std::is_same<const char*, absl::variant_alternative_t<2, V>>::value));    EXPECT_TRUE((std::is_same<const char* const,                              absl::variant_alternative_t<2, const V>>::value));    EXPECT_TRUE(        (std::is_same<const char* volatile,                      absl::variant_alternative_t<2, volatile V>>::value));    EXPECT_TRUE((        std::is_same<const char* const volatile,                     absl::variant_alternative_t<2, const volatile V>>::value));  }  {    using V = absl::variant<float, volatile int, const char*>;    EXPECT_TRUE(        (std::is_same<float, absl::variant_alternative_t<0, V>>::value));    EXPECT_TRUE((std::is_same<const float,                              absl::variant_alternative_t<0, const V>>::value));    EXPECT_TRUE(        (std::is_same<volatile float,                      absl::variant_alternative_t<0, volatile V>>::value));    EXPECT_TRUE((        std::is_same<const volatile float,                     absl::variant_alternative_t<0, const volatile V>>::value));    EXPECT_TRUE(        (std::is_same<volatile int, absl::variant_alternative_t<1, V>>::value));    EXPECT_TRUE((std::is_same<const volatile int,                              absl::variant_alternative_t<1, const V>>::value));    EXPECT_TRUE(        (std::is_same<volatile int,                      absl::variant_alternative_t<1, volatile V>>::value));    EXPECT_TRUE((        std::is_same<const volatile int,                     absl::variant_alternative_t<1, const volatile V>>::value));    EXPECT_TRUE(        (std::is_same<const char*, absl::variant_alternative_t<2, V>>::value));    EXPECT_TRUE((std::is_same<const char* const,                              absl::variant_alternative_t<2, const V>>::value));    EXPECT_TRUE(        (std::is_same<const char* volatile,                      absl::variant_alternative_t<2, volatile V>>::value));    EXPECT_TRUE((        std::is_same<const char* const volatile,                     absl::variant_alternative_t<2, const volatile V>>::value));  }}///////////////////// [variant.get] /////////////////////TEST(VariantTest, HoldsAlternative) {  using Var = variant<int, std::string, double>;  Var v = 1;  EXPECT_TRUE(absl::holds_alternative<int>(v));  EXPECT_FALSE(absl::holds_alternative<std::string>(v));  EXPECT_FALSE(absl::holds_alternative<double>(v));  v = "str";  EXPECT_FALSE(absl::holds_alternative<int>(v));  EXPECT_TRUE(absl::holds_alternative<std::string>(v));  EXPECT_FALSE(absl::holds_alternative<double>(v));  v = 0.;  EXPECT_FALSE(absl::holds_alternative<int>(v));  EXPECT_FALSE(absl::holds_alternative<std::string>(v));  EXPECT_TRUE(absl::holds_alternative<double>(v));  Var v2 = v;  EXPECT_FALSE(absl::holds_alternative<int>(v2));  EXPECT_FALSE(absl::holds_alternative<std::string>(v2));  EXPECT_TRUE(absl::holds_alternative<double>(v2));  v2.emplace<int>(3);  EXPECT_TRUE(absl::holds_alternative<int>(v2));  EXPECT_FALSE(absl::holds_alternative<std::string>(v2));  EXPECT_FALSE(absl::holds_alternative<double>(v2));}TEST(VariantTest, GetIndex) {  using Var = variant<int, std::string, double, int>;  {    Var v(absl::in_place_index_t<0>{}, 0);    using LValueGetType = decltype(absl::get<0>(v));    using RValueGetType = decltype(absl::get<0>(absl::move(v)));    EXPECT_TRUE((std::is_same<LValueGetType, int&>::value));    EXPECT_TRUE((std::is_same<RValueGetType, int&&>::value));    EXPECT_EQ(absl::get<0>(v), 0);    EXPECT_EQ(absl::get<0>(absl::move(v)), 0);    const Var& const_v = v;    using ConstLValueGetType = decltype(absl::get<0>(const_v));    using ConstRValueGetType = decltype(absl::get<0>(absl::move(const_v)));    EXPECT_TRUE((std::is_same<ConstLValueGetType, const int&>::value));    EXPECT_TRUE((std::is_same<ConstRValueGetType, const int&&>::value));    EXPECT_EQ(absl::get<0>(const_v), 0);    EXPECT_EQ(absl::get<0>(absl::move(const_v)), 0);  }  {    Var v = std::string("Hello");    using LValueGetType = decltype(absl::get<1>(v));    using RValueGetType = decltype(absl::get<1>(absl::move(v)));    EXPECT_TRUE((std::is_same<LValueGetType, std::string&>::value));    EXPECT_TRUE((std::is_same<RValueGetType, std::string&&>::value));    EXPECT_EQ(absl::get<1>(v), "Hello");    EXPECT_EQ(absl::get<1>(absl::move(v)), "Hello");    const Var& const_v = v;    using ConstLValueGetType = decltype(absl::get<1>(const_v));    using ConstRValueGetType = decltype(absl::get<1>(absl::move(const_v)));    EXPECT_TRUE((std::is_same<ConstLValueGetType, const std::string&>::value));    EXPECT_TRUE((std::is_same<ConstRValueGetType, const std::string&&>::value));    EXPECT_EQ(absl::get<1>(const_v), "Hello");    EXPECT_EQ(absl::get<1>(absl::move(const_v)), "Hello");  }  {    Var v = 2.0;    using LValueGetType = decltype(absl::get<2>(v));    using RValueGetType = decltype(absl::get<2>(absl::move(v)));    EXPECT_TRUE((std::is_same<LValueGetType, double&>::value));    EXPECT_TRUE((std::is_same<RValueGetType, double&&>::value));    EXPECT_EQ(absl::get<2>(v), 2.);    EXPECT_EQ(absl::get<2>(absl::move(v)), 2.);    const Var& const_v = v;    using ConstLValueGetType = decltype(absl::get<2>(const_v));    using ConstRValueGetType = decltype(absl::get<2>(absl::move(const_v)));    EXPECT_TRUE((std::is_same<ConstLValueGetType, const double&>::value));    EXPECT_TRUE((std::is_same<ConstRValueGetType, const double&&>::value));    EXPECT_EQ(absl::get<2>(const_v), 2.);    EXPECT_EQ(absl::get<2>(absl::move(const_v)), 2.);  }  {    Var v(absl::in_place_index_t<0>{}, 0);    v.emplace<3>(1);    using LValueGetType = decltype(absl::get<3>(v));    using RValueGetType = decltype(absl::get<3>(absl::move(v)));    EXPECT_TRUE((std::is_same<LValueGetType, int&>::value));    EXPECT_TRUE((std::is_same<RValueGetType, int&&>::value));    EXPECT_EQ(absl::get<3>(v), 1);    EXPECT_EQ(absl::get<3>(absl::move(v)), 1);    const Var& const_v = v;    using ConstLValueGetType = decltype(absl::get<3>(const_v));    using ConstRValueGetType = decltype(absl::get<3>(absl::move(const_v)));    EXPECT_TRUE((std::is_same<ConstLValueGetType, const int&>::value));    EXPECT_TRUE((std::is_same<ConstRValueGetType, const int&&>::value));    EXPECT_EQ(absl::get<3>(const_v), 1);    EXPECT_EQ(absl::get<3>(absl::move(const_v)), 1);  // NOLINT  }}TEST(VariantTest, BadGetIndex) {  using Var = variant<int, std::string, double>;  {    Var v = 1;    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<1>(v));    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<1>(std::move(v)));    const Var& const_v = v;    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<1>(const_v));    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(        absl::get<1>(std::move(const_v)));  // NOLINT  }  {    Var v = std::string("Hello");    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<0>(v));    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<0>(std::move(v)));    const Var& const_v = v;    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<0>(const_v));    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(        absl::get<0>(std::move(const_v)));  // NOLINT  }}TEST(VariantTest, GetType) {  using Var = variant<int, std::string, double>;  {    Var v = 1;    using LValueGetType = decltype(absl::get<int>(v));    using RValueGetType = decltype(absl::get<int>(absl::move(v)));    EXPECT_TRUE((std::is_same<LValueGetType, int&>::value));    EXPECT_TRUE((std::is_same<RValueGetType, int&&>::value));    EXPECT_EQ(absl::get<int>(v), 1);    EXPECT_EQ(absl::get<int>(absl::move(v)), 1);    const Var& const_v = v;    using ConstLValueGetType = decltype(absl::get<int>(const_v));    using ConstRValueGetType = decltype(absl::get<int>(absl::move(const_v)));    EXPECT_TRUE((std::is_same<ConstLValueGetType, const int&>::value));    EXPECT_TRUE((std::is_same<ConstRValueGetType, const int&&>::value));    EXPECT_EQ(absl::get<int>(const_v), 1);    EXPECT_EQ(absl::get<int>(absl::move(const_v)), 1);  }  {    Var v = std::string("Hello");    using LValueGetType = decltype(absl::get<1>(v));    using RValueGetType = decltype(absl::get<1>(absl::move(v)));    EXPECT_TRUE((std::is_same<LValueGetType, std::string&>::value));    EXPECT_TRUE((std::is_same<RValueGetType, std::string&&>::value));    EXPECT_EQ(absl::get<std::string>(v), "Hello");    EXPECT_EQ(absl::get<std::string>(absl::move(v)), "Hello");    const Var& const_v = v;    using ConstLValueGetType = decltype(absl::get<1>(const_v));    using ConstRValueGetType = decltype(absl::get<1>(absl::move(const_v)));    EXPECT_TRUE((std::is_same<ConstLValueGetType, const std::string&>::value));    EXPECT_TRUE((std::is_same<ConstRValueGetType, const std::string&&>::value));    EXPECT_EQ(absl::get<std::string>(const_v), "Hello");    EXPECT_EQ(absl::get<std::string>(absl::move(const_v)), "Hello");  }  {    Var v = 2.0;    using LValueGetType = decltype(absl::get<2>(v));    using RValueGetType = decltype(absl::get<2>(absl::move(v)));    EXPECT_TRUE((std::is_same<LValueGetType, double&>::value));    EXPECT_TRUE((std::is_same<RValueGetType, double&&>::value));    EXPECT_EQ(absl::get<double>(v), 2.);    EXPECT_EQ(absl::get<double>(absl::move(v)), 2.);    const Var& const_v = v;    using ConstLValueGetType = decltype(absl::get<2>(const_v));    using ConstRValueGetType = decltype(absl::get<2>(absl::move(const_v)));    EXPECT_TRUE((std::is_same<ConstLValueGetType, const double&>::value));    EXPECT_TRUE((std::is_same<ConstRValueGetType, const double&&>::value));    EXPECT_EQ(absl::get<double>(const_v), 2.);    EXPECT_EQ(absl::get<double>(absl::move(const_v)), 2.);  }}TEST(VariantTest, BadGetType) {  using Var = variant<int, std::string, double>;  {    Var v = 1;    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<std::string>(v));    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(        absl::get<std::string>(std::move(v)));    const Var& const_v = v;    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<std::string>(const_v));    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(        absl::get<std::string>(std::move(const_v)));  // NOLINT  }  {    Var v = std::string("Hello");    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<int>(v));    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<int>(std::move(v)));    const Var& const_v = v;    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<int>(const_v));    ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(        absl::get<int>(std::move(const_v)));  // NOLINT  }}TEST(VariantTest, GetIfIndex) {  using Var = variant<int, std::string, double, int>;  {    Var v(absl::in_place_index_t<0>{}, 0);    EXPECT_TRUE(noexcept(absl::get_if<0>(&v)));    {      auto* elem = absl::get_if<0>(&v);      EXPECT_TRUE((std::is_same<decltype(elem), int*>::value));      ASSERT_NE(elem, nullptr);      EXPECT_EQ(*elem, 0);      {        auto* bad_elem = absl::get_if<1>(&v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), std::string*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<2>(&v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), double*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<3>(&v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));        EXPECT_EQ(bad_elem, nullptr);      }    }    const Var& const_v = v;    EXPECT_TRUE(noexcept(absl::get_if<0>(&const_v)));    {      auto* elem = absl::get_if<0>(&const_v);      EXPECT_TRUE((std::is_same<decltype(elem), const int*>::value));      ASSERT_NE(elem, nullptr);      EXPECT_EQ(*elem, 0);      {        auto* bad_elem = absl::get_if<1>(&const_v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), const std::string*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<2>(&const_v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), const double*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<3>(&const_v);        EXPECT_EQ(bad_elem, nullptr);        EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));      }    }  }  {    Var v = std::string("Hello");    EXPECT_TRUE(noexcept(absl::get_if<1>(&v)));    {      auto* elem = absl::get_if<1>(&v);      EXPECT_TRUE((std::is_same<decltype(elem), std::string*>::value));      ASSERT_NE(elem, nullptr);      EXPECT_EQ(*elem, "Hello");      {        auto* bad_elem = absl::get_if<0>(&v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<2>(&v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), double*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<3>(&v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));        EXPECT_EQ(bad_elem, nullptr);      }    }    const Var& const_v = v;    EXPECT_TRUE(noexcept(absl::get_if<1>(&const_v)));    {      auto* elem = absl::get_if<1>(&const_v);      EXPECT_TRUE((std::is_same<decltype(elem), const std::string*>::value));      ASSERT_NE(elem, nullptr);      EXPECT_EQ(*elem, "Hello");      {        auto* bad_elem = absl::get_if<0>(&const_v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<2>(&const_v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), const double*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<3>(&const_v);        EXPECT_EQ(bad_elem, nullptr);        EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));      }    }  }  {    Var v = 2.0;    EXPECT_TRUE(noexcept(absl::get_if<2>(&v)));    {      auto* elem = absl::get_if<2>(&v);      EXPECT_TRUE((std::is_same<decltype(elem), double*>::value));      ASSERT_NE(elem, nullptr);      EXPECT_EQ(*elem, 2.0);      {        auto* bad_elem = absl::get_if<0>(&v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<1>(&v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), std::string*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<3>(&v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));        EXPECT_EQ(bad_elem, nullptr);      }    }    const Var& const_v = v;    EXPECT_TRUE(noexcept(absl::get_if<2>(&const_v)));    {      auto* elem = absl::get_if<2>(&const_v);      EXPECT_TRUE((std::is_same<decltype(elem), const double*>::value));      ASSERT_NE(elem, nullptr);      EXPECT_EQ(*elem, 2.0);      {        auto* bad_elem = absl::get_if<0>(&const_v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<1>(&const_v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), const std::string*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<3>(&const_v);        EXPECT_EQ(bad_elem, nullptr);        EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));      }    }  }  {    Var v(absl::in_place_index_t<0>{}, 0);    v.emplace<3>(1);    EXPECT_TRUE(noexcept(absl::get_if<3>(&v)));    {      auto* elem = absl::get_if<3>(&v);      EXPECT_TRUE((std::is_same<decltype(elem), int*>::value));      ASSERT_NE(elem, nullptr);      EXPECT_EQ(*elem, 1);      {        auto* bad_elem = absl::get_if<0>(&v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<1>(&v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), std::string*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<2>(&v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), double*>::value));        EXPECT_EQ(bad_elem, nullptr);      }    }    const Var& const_v = v;    EXPECT_TRUE(noexcept(absl::get_if<3>(&const_v)));    {      auto* elem = absl::get_if<3>(&const_v);      EXPECT_TRUE((std::is_same<decltype(elem), const int*>::value));      ASSERT_NE(elem, nullptr);      EXPECT_EQ(*elem, 1);      {        auto* bad_elem = absl::get_if<0>(&const_v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<1>(&const_v);        EXPECT_TRUE((std::is_same<decltype(bad_elem), const std::string*>::value));        EXPECT_EQ(bad_elem, nullptr);      }      {        auto* bad_elem = absl::get_if<2>(&const_v);        EXPECT_EQ(bad_elem, nullptr);        EXPECT_TRUE((std::is_same<decltype(bad_elem), const double*>::value));      }    }  }}//////////////////////// [variant.relops] ////////////////////////TEST(VariantTest, OperatorEquals) {  variant<int, std::string> a(1), b(1);  EXPECT_TRUE(a == b);  EXPECT_TRUE(b == a);  EXPECT_FALSE(a != b);  EXPECT_FALSE(b != a);  b = "str";  EXPECT_FALSE(a == b);  EXPECT_FALSE(b == a);  EXPECT_TRUE(a != b);  EXPECT_TRUE(b != a);  b = 0;  EXPECT_FALSE(a == b);  EXPECT_FALSE(b == a);  EXPECT_TRUE(a != b);  EXPECT_TRUE(b != a);  a = b = "foo";  EXPECT_TRUE(a == b);  EXPECT_TRUE(b == a);  EXPECT_FALSE(a != b);  EXPECT_FALSE(b != a);  a = "bar";  EXPECT_FALSE(a == b);  EXPECT_FALSE(b == a);  EXPECT_TRUE(a != b);  EXPECT_TRUE(b != a);}TEST(VariantTest, OperatorRelational) {  variant<int, std::string> a(1), b(1);  EXPECT_FALSE(a < b);  EXPECT_FALSE(b < a);  EXPECT_FALSE(a > b);  EXPECT_FALSE(b > a);  EXPECT_TRUE(a <= b);  EXPECT_TRUE(b <= a);  EXPECT_TRUE(a >= b);  EXPECT_TRUE(b >= a);  b = "str";  EXPECT_TRUE(a < b);  EXPECT_FALSE(b < a);  EXPECT_FALSE(a > b);  EXPECT_TRUE(b > a);  EXPECT_TRUE(a <= b);  EXPECT_FALSE(b <= a);  EXPECT_FALSE(a >= b);  EXPECT_TRUE(b >= a);  b = 0;  EXPECT_FALSE(a < b);  EXPECT_TRUE(b < a);  EXPECT_TRUE(a > b);  EXPECT_FALSE(b > a);  EXPECT_FALSE(a <= b);  EXPECT_TRUE(b <= a);  EXPECT_TRUE(a >= b);  EXPECT_FALSE(b >= a);  a = b = "foo";  EXPECT_FALSE(a < b);  EXPECT_FALSE(b < a);  EXPECT_FALSE(a > b);  EXPECT_FALSE(b > a);  EXPECT_TRUE(a <= b);  EXPECT_TRUE(b <= a);  EXPECT_TRUE(a >= b);  EXPECT_TRUE(b >= a);  a = "bar";  EXPECT_TRUE(a < b);  EXPECT_FALSE(b < a);  EXPECT_FALSE(a > b);  EXPECT_TRUE(b > a);  EXPECT_TRUE(a <= b);  EXPECT_FALSE(b <= a);  EXPECT_FALSE(a >= b);  EXPECT_TRUE(b >= a);}#ifdef ABSL_HAVE_EXCEPTIONSTEST(VariantTest, ValuelessOperatorEquals) {  variant<MoveCanThrow, std::string> int_v(1), string_v("Hello"),      valueless(absl::in_place_index_t<0>{}),      other_valueless(absl::in_place_index_t<0>{});  ToValuelessByException(valueless);  ToValuelessByException(other_valueless);  EXPECT_TRUE(valueless == other_valueless);  EXPECT_TRUE(other_valueless == valueless);  EXPECT_FALSE(valueless == int_v);  EXPECT_FALSE(valueless == string_v);  EXPECT_FALSE(int_v == valueless);  EXPECT_FALSE(string_v == valueless);  EXPECT_FALSE(valueless != other_valueless);  EXPECT_FALSE(other_valueless != valueless);  EXPECT_TRUE(valueless != int_v);  EXPECT_TRUE(valueless != string_v);  EXPECT_TRUE(int_v != valueless);  EXPECT_TRUE(string_v != valueless);}TEST(VariantTest, ValuelessOperatorRelational) {  variant<MoveCanThrow, std::string> int_v(1), string_v("Hello"),      valueless(absl::in_place_index_t<0>{}),      other_valueless(absl::in_place_index_t<0>{});  ToValuelessByException(valueless);  ToValuelessByException(other_valueless);  EXPECT_FALSE(valueless < other_valueless);  EXPECT_FALSE(other_valueless < valueless);  EXPECT_TRUE(valueless < int_v);  EXPECT_TRUE(valueless < string_v);  EXPECT_FALSE(int_v < valueless);  EXPECT_FALSE(string_v < valueless);  EXPECT_TRUE(valueless <= other_valueless);  EXPECT_TRUE(other_valueless <= valueless);  EXPECT_TRUE(valueless <= int_v);  EXPECT_TRUE(valueless <= string_v);  EXPECT_FALSE(int_v <= valueless);  EXPECT_FALSE(string_v <= valueless);  EXPECT_TRUE(valueless >= other_valueless);  EXPECT_TRUE(other_valueless >= valueless);  EXPECT_FALSE(valueless >= int_v);  EXPECT_FALSE(valueless >= string_v);  EXPECT_TRUE(int_v >= valueless);  EXPECT_TRUE(string_v >= valueless);  EXPECT_FALSE(valueless > other_valueless);  EXPECT_FALSE(other_valueless > valueless);  EXPECT_FALSE(valueless > int_v);  EXPECT_FALSE(valueless > string_v);  EXPECT_TRUE(int_v > valueless);  EXPECT_TRUE(string_v > valueless);}#endif/////////////////////// [variant.visit] ///////////////////////template <typename T>struct ConvertTo {  template <typename U>  T operator()(const U& u) const {    return u;  }};TEST(VariantTest, VisitSimple) {  variant<std::string, const char*> v = "A";  std::string str = absl::visit(ConvertTo<std::string>{}, v);  EXPECT_EQ("A", str);  v = std::string("B");  absl::string_view piece = absl::visit(ConvertTo<absl::string_view>{}, v);  EXPECT_EQ("B", piece);  struct StrLen {    int operator()(const std::string& s) const { return s.size(); }    int operator()(const char* s) const { return strlen(s); }  };  v = "SomeStr";  EXPECT_EQ(7, absl::visit(StrLen{}, v));  v = std::string("VeryLargeThisTime");  EXPECT_EQ(17, absl::visit(StrLen{}, v));}TEST(VariantTest, VisitRValue) {  variant<std::string> v = std::string("X");  struct Visitor {    bool operator()(const std::string&) const { return false; }    bool operator()(std::string&&) const { return true; }  // NOLINT    int operator()(const std::string&, const std::string&) const { return 0; }    int operator()(const std::string&, std::string&&) const { return 1; }  // NOLINT    int operator()(std::string&&, const std::string&) const { return 2; }  // NOLINT    int operator()(std::string&&, std::string&&) const { return 3; }       // NOLINT  };  EXPECT_FALSE(absl::visit(Visitor{}, v));  EXPECT_TRUE(absl::visit(Visitor{}, absl::move(v)));  // Also test the variadic overload.  EXPECT_EQ(0, absl::visit(Visitor{}, v, v));  EXPECT_EQ(1, absl::visit(Visitor{}, v, absl::move(v)));  EXPECT_EQ(2, absl::visit(Visitor{}, absl::move(v), v));  EXPECT_EQ(3, absl::visit(Visitor{}, absl::move(v), absl::move(v)));}TEST(VariantTest, VisitRValueVisitor) {  variant<std::string> v = std::string("X");  struct Visitor {    bool operator()(const std::string&) const& { return false; }    bool operator()(const std::string&) && { return true; }  };  Visitor visitor;  EXPECT_FALSE(absl::visit(visitor, v));  EXPECT_TRUE(absl::visit(Visitor{}, v));}TEST(VariantTest, VisitResultTypeDifferent) {  variant<std::string> v = std::string("X");  struct LValue_LValue {};  struct RValue_LValue {};  struct LValue_RValue {};  struct RValue_RValue {};  struct Visitor {    LValue_LValue operator()(const std::string&) const& { return {}; }    RValue_LValue operator()(std::string&&) const& { return {}; }  // NOLINT    LValue_RValue operator()(const std::string&) && { return {}; }    RValue_RValue operator()(std::string&&) && { return {}; }  // NOLINT  } visitor;  EXPECT_TRUE(      (std::is_same<LValue_LValue, decltype(absl::visit(visitor, v))>::value));  EXPECT_TRUE(      (std::is_same<RValue_LValue,                    decltype(absl::visit(visitor, absl::move(v)))>::value));  EXPECT_TRUE((      std::is_same<LValue_RValue, decltype(absl::visit(Visitor{}, v))>::value));  EXPECT_TRUE(      (std::is_same<RValue_RValue,                    decltype(absl::visit(Visitor{}, absl::move(v)))>::value));}TEST(VariantTest, VisitVariadic) {  using A = variant<int, std::string>;  using B = variant<std::unique_ptr<int>, absl::string_view>;  struct Visitor {    std::pair<int, int> operator()(int a, std::unique_ptr<int> b) const {      return {a, *b};    }    std::pair<int, int> operator()(absl::string_view a,                                   std::unique_ptr<int> b) const {      return {static_cast<int>(a.size()), static_cast<int>(*b)};    }    std::pair<int, int> operator()(int a, absl::string_view b) const {      return {a, static_cast<int>(b.size())};    }    std::pair<int, int> operator()(absl::string_view a,                                   absl::string_view b) const {      return {static_cast<int>(a.size()), static_cast<int>(b.size())};    }  };  EXPECT_THAT(absl::visit(Visitor(), A(1), B(std::unique_ptr<int>(new int(7)))),              ::testing::Pair(1, 7));  EXPECT_THAT(absl::visit(Visitor(), A(1), B(absl::string_view("ABC"))),              ::testing::Pair(1, 3));  EXPECT_THAT(absl::visit(Visitor(), A(std::string("BBBBB")),                          B(std::unique_ptr<int>(new int(7)))),              ::testing::Pair(5, 7));  EXPECT_THAT(      absl::visit(Visitor(), A(std::string("BBBBB")), B(absl::string_view("ABC"))),      ::testing::Pair(5, 3));}TEST(VariantTest, VisitNoArgs) {  EXPECT_EQ(5, absl::visit([] { return 5; }));}struct ConstFunctor {  int operator()(int a, int b) const { return a - b; }};struct MutableFunctor {  int operator()(int a, int b) { return a - b; }};struct Class {  int Method(int a, int b) { return a - b; }  int ConstMethod(int a, int b) const { return a - b; }  int member;};TEST(VariantTest, VisitReferenceWrapper) {  ConstFunctor cf;  MutableFunctor mf;  absl::variant<int> three = 3;  absl::variant<int> two = 2;  EXPECT_EQ(1, absl::visit(std::cref(cf), three, two));  EXPECT_EQ(1, absl::visit(std::ref(cf), three, two));  EXPECT_EQ(1, absl::visit(std::ref(mf), three, two));}// libstdc++ std::variant doesn't support the INVOKE semantics.#if !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__))TEST(VariantTest, VisitMemberFunction) {  absl::variant<std::unique_ptr<Class>> p(absl::make_unique<Class>());  absl::variant<std::unique_ptr<const Class>> cp(      absl::make_unique<const Class>());  absl::variant<int> three = 3;  absl::variant<int> two = 2;  EXPECT_EQ(1, absl::visit(&Class::Method, p, three, two));  EXPECT_EQ(1, absl::visit(&Class::ConstMethod, p, three, two));  EXPECT_EQ(1, absl::visit(&Class::ConstMethod, cp, three, two));}TEST(VariantTest, VisitDataMember) {  absl::variant<std::unique_ptr<Class>> p(absl::make_unique<Class>(Class{42}));  absl::variant<std::unique_ptr<const Class>> cp(      absl::make_unique<const Class>(Class{42}));  EXPECT_EQ(42, absl::visit(&Class::member, p));  absl::visit(&Class::member, p) = 5;  EXPECT_EQ(5, absl::visit(&Class::member, p));  EXPECT_EQ(42, absl::visit(&Class::member, cp));}#endif  // !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__))/////////////////////////// [variant.monostate] ///////////////////////////TEST(VariantTest, MonostateBasic) {  absl::monostate mono;  (void)mono;  // TODO(mattcalabrese) Expose move triviality metafunctions in absl.  EXPECT_TRUE(absl::is_trivially_default_constructible<absl::monostate>::value);  EXPECT_TRUE(is_trivially_move_constructible<absl::monostate>::value);  EXPECT_TRUE(absl::is_trivially_copy_constructible<absl::monostate>::value);  EXPECT_TRUE(is_trivially_move_assignable<absl::monostate>::value);  EXPECT_TRUE(absl::is_trivially_copy_assignable<absl::monostate>::value);  EXPECT_TRUE(absl::is_trivially_destructible<absl::monostate>::value);}TEST(VariantTest, VariantMonostateDefaultConstruction) {  absl::variant<absl::monostate, NonDefaultConstructible> var;  EXPECT_EQ(var.index(), 0);}////////////////////////////////// [variant.monostate.relops] //////////////////////////////////TEST(VariantTest, MonostateComparisons) {  absl::monostate lhs, rhs;  EXPECT_EQ(lhs, lhs);  EXPECT_EQ(lhs, rhs);  EXPECT_FALSE(lhs != lhs);  EXPECT_FALSE(lhs != rhs);  EXPECT_FALSE(lhs < lhs);  EXPECT_FALSE(lhs < rhs);  EXPECT_FALSE(lhs > lhs);  EXPECT_FALSE(lhs > rhs);  EXPECT_LE(lhs, lhs);  EXPECT_LE(lhs, rhs);  EXPECT_GE(lhs, lhs);  EXPECT_GE(lhs, rhs);  EXPECT_TRUE(noexcept(std::declval<absl::monostate>() ==                       std::declval<absl::monostate>()));  EXPECT_TRUE(noexcept(std::declval<absl::monostate>() !=                       std::declval<absl::monostate>()));  EXPECT_TRUE(noexcept(std::declval<absl::monostate>() <                       std::declval<absl::monostate>()));  EXPECT_TRUE(noexcept(std::declval<absl::monostate>() >                       std::declval<absl::monostate>()));  EXPECT_TRUE(noexcept(std::declval<absl::monostate>() <=                       std::declval<absl::monostate>()));  EXPECT_TRUE(noexcept(std::declval<absl::monostate>() >=                       std::declval<absl::monostate>()));}///////////////////////// [variant.specalg] /////////////////////////TEST(VariantTest, NonmemberSwap) {  using std::swap;  SpecialSwap v1(3);  SpecialSwap v2(7);  variant<SpecialSwap> a = v1, b = v2;  EXPECT_THAT(a, VariantWith<SpecialSwap>(v1));  EXPECT_THAT(b, VariantWith<SpecialSwap>(v2));  std::swap(a, b);  EXPECT_THAT(a, VariantWith<SpecialSwap>(v2));  EXPECT_THAT(b, VariantWith<SpecialSwap>(v1));#ifndef ABSL_HAVE_STD_VARIANT  EXPECT_FALSE(absl::get<SpecialSwap>(a).special_swap);#endif  swap(a, b);  EXPECT_THAT(a, VariantWith<SpecialSwap>(v1));  EXPECT_THAT(b, VariantWith<SpecialSwap>(v2));  EXPECT_TRUE(absl::get<SpecialSwap>(b).special_swap);}//////////////////////////// [variant.bad.access] ////////////////////////////TEST(VariantTest, BadAccess) {  EXPECT_TRUE(noexcept(absl::bad_variant_access()));  absl::bad_variant_access exception_obj;  std::exception* base = &exception_obj;  (void)base;}////////////////////// [variant.hash] //////////////////////TEST(VariantTest, MonostateHash) {  absl::monostate mono, other_mono;  std::hash<absl::monostate> const hasher{};  static_assert(std::is_same<decltype(hasher(mono)), std::size_t>::value, "");  EXPECT_EQ(hasher(mono), hasher(other_mono));}TEST(VariantTest, Hash) {  static_assert(type_traits_internal::IsHashEnabled<variant<int>>::value, "");  static_assert(type_traits_internal::IsHashEnabled<variant<Hashable>>::value,                "");  static_assert(      type_traits_internal::IsHashEnabled<variant<int, Hashable>>::value, "");#if defined(_MSC_VER) ||                                   \    (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 4000 && \     _LIBCPP_STD_VER > 11) ||                              \    defined(__APPLE__)  // For MSVC and libc++ (< 4.0 and c++14), std::hash primary template has a  // static_assert to catch any user-defined type T that doesn't provide a hash  // specialization. So instantiating std::hash<variant<T>> will result  // in a hard error which is not SFINAE friendly.#define ABSL_STD_HASH_NOT_SFINAE_FRIENDLY 1#endif#ifndef ABSL_STD_HASH_NOT_SFINAE_FRIENDLY  static_assert(      !type_traits_internal::IsHashEnabled<variant<NonHashable>>::value, "");  static_assert(!type_traits_internal::IsHashEnabled<                    variant<Hashable, NonHashable>>::value,                "");#endif// MSVC std::hash<std::variant> does not use the index, thus produce the same// result on the same value as different alternative.#if !(defined(_MSC_VER) && defined(ABSL_HAVE_STD_VARIANT))  {    // same value as different alternative    variant<int, int> v0(in_place_index_t<0>{}, 42);    variant<int, int> v1(in_place_index_t<1>{}, 42);    std::hash<variant<int, int>> hash;    EXPECT_NE(hash(v0), hash(v1));  }#endif  // !(defined(_MSC_VER) && defined(ABSL_HAVE_STD_VARIANT))  {    std::hash<variant<int>> hash;    std::set<size_t> hashcodes;    for (int i = 0; i < 100; ++i) {      hashcodes.insert(hash(i));    }    EXPECT_GT(hashcodes.size(), 90);    // test const-qualified    static_assert(        type_traits_internal::IsHashEnabled<variant<const int>>::value, "");    static_assert(        type_traits_internal::IsHashEnabled<variant<const Hashable>>::value,        "");    std::hash<absl::variant<const int>> c_hash;    for (int i = 0; i < 100; ++i) {      EXPECT_EQ(hash(i), c_hash(i));    }  }}////////////////////////////////////////// Miscellaneous and deprecated tests //////////////////////////////////////////// Test that a set requiring a basic type conversion works correctly.TEST(VariantTest, TestConvertingSet) {  typedef variant<double> Variant;  Variant v(1.0);  const int two = 2;  v = two;  EXPECT_TRUE(absl::holds_alternative<double>(v));  ASSERT_TRUE(nullptr != absl::get_if<double>(&v));  EXPECT_DOUBLE_EQ(2, absl::get<double>(v));}// Test that a vector of variants behaves reasonably.TEST(VariantTest, Container) {  typedef variant<int, float> Variant;  // Creation of vector should work  std::vector<Variant> vec;  vec.push_back(Variant(10));  vec.push_back(Variant(20.0f));  // Vector resizing should work if we supply a value for new slots  vec.resize(10, Variant(0));}// Test that a variant with a non-copyable type can be constructed and// manipulated to some degree.TEST(VariantTest, TestVariantWithNonCopyableType) {  typedef variant<int, NonCopyable> Variant;  const int kValue = 1;  Variant v(kValue);  ASSERT_TRUE(absl::holds_alternative<int>(v));  EXPECT_EQ(kValue, absl::get<int>(v));}// Test that a variant with a non-copyable type can be transformed to// the non-copyable type with a call to `emplace` for different numbers// of arguments. We do not need to test this for each of T1 ... T8// because `emplace` does not overload on T1 ... to T8, so if this// works for any one of T1 ... T8, then it works for all of them. We// do need to test that it works with varying numbers of parameters// though.TEST(VariantTest, TestEmplace) {  typedef variant<int, NonCopyable> Variant;  const int kValue = 1;  Variant v(kValue);  ASSERT_TRUE(absl::holds_alternative<int>(v));  EXPECT_EQ(kValue, absl::get<int>(v));  // emplace with zero arguments, then back to 'int'  v.emplace<NonCopyable>();  ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));  EXPECT_EQ(0, absl::get<NonCopyable>(v).value);  v = kValue;  ASSERT_TRUE(absl::holds_alternative<int>(v));  // emplace with one argument:  v.emplace<NonCopyable>(1);  ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));  EXPECT_EQ(1, absl::get<NonCopyable>(v).value);  v = kValue;  ASSERT_TRUE(absl::holds_alternative<int>(v));  // emplace with two arguments:  v.emplace<NonCopyable>(1, 2);  ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));  EXPECT_EQ(3, absl::get<NonCopyable>(v).value);  v = kValue;  ASSERT_TRUE(absl::holds_alternative<int>(v));  // emplace with three arguments  v.emplace<NonCopyable>(1, 2, 3);  ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));  EXPECT_EQ(6, absl::get<NonCopyable>(v).value);  v = kValue;  ASSERT_TRUE(absl::holds_alternative<int>(v));  // emplace with four arguments  v.emplace<NonCopyable>(1, 2, 3, 4);  ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));  EXPECT_EQ(10, absl::get<NonCopyable>(v).value);  v = kValue;  ASSERT_TRUE(absl::holds_alternative<int>(v));}TEST(VariantTest, TestEmplaceDestroysCurrentValue) {  typedef variant<int, IncrementInDtor, NonCopyable> Variant;  int counter = 0;  Variant v(0);  ASSERT_TRUE(absl::holds_alternative<int>(v));  v.emplace<IncrementInDtor>(&counter);  ASSERT_TRUE(absl::holds_alternative<IncrementInDtor>(v));  ASSERT_EQ(0, counter);  v.emplace<NonCopyable>();  ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));  EXPECT_EQ(1, counter);}TEST(VariantTest, TestMoveSemantics) {  typedef variant<std::unique_ptr<int>, std::unique_ptr<std::string>> Variant;  // Construct a variant by moving from an element value.  Variant v(absl::WrapUnique(new int(10)));  EXPECT_TRUE(absl::holds_alternative<std::unique_ptr<int>>(v));  // Construct a variant by moving from another variant.  Variant v2(absl::move(v));  ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<int>>(v2));  ASSERT_NE(nullptr, absl::get<std::unique_ptr<int>>(v2));  EXPECT_EQ(10, *absl::get<std::unique_ptr<int>>(v2));  // Moving from a variant object leaves it holding moved-from value of the  // same element type.  EXPECT_TRUE(absl::holds_alternative<std::unique_ptr<int>>(v));  ASSERT_NE(nullptr, absl::get_if<std::unique_ptr<int>>(&v));  EXPECT_EQ(nullptr, absl::get<std::unique_ptr<int>>(v));  // Assign a variant from an element value by move.  v = absl::make_unique<std::string>("foo");  ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<std::string>>(v));  EXPECT_EQ("foo", *absl::get<std::unique_ptr<std::string>>(v));  // Move-assign a variant.  v2 = absl::move(v);  ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<std::string>>(v2));  EXPECT_EQ("foo", *absl::get<std::unique_ptr<std::string>>(v2));  EXPECT_TRUE(absl::holds_alternative<std::unique_ptr<std::string>>(v));}variant<int, std::string> PassThrough(const variant<int, std::string>& arg) {  return arg;}TEST(VariantTest, TestImplicitConversion) {  EXPECT_TRUE(absl::holds_alternative<int>(PassThrough(0)));  // We still need the explicit cast for std::string, because C++ won't apply  // two user-defined implicit conversions in a row.  EXPECT_TRUE(absl::holds_alternative<std::string>(PassThrough(std::string("foo"))));}struct Convertible2;struct Convertible1 {  Convertible1() {}  Convertible1(const Convertible1&) {}  Convertible1& operator=(const Convertible1&) { return *this; }  // implicit conversion from Convertible2  Convertible1(const Convertible2&) {}  // NOLINT(runtime/explicit)};struct Convertible2 {  Convertible2() {}  Convertible2(const Convertible2&) {}  Convertible2& operator=(const Convertible2&) { return *this; }  // implicit conversion from Convertible1  Convertible2(const Convertible1&) {}  // NOLINT(runtime/explicit)};TEST(VariantTest, TestRvalueConversion) {  variant<double, std::string> var(      ConvertVariantTo<variant<double, std::string>>(variant<std::string, int>(0)));  ASSERT_TRUE(absl::holds_alternative<double>(var));  EXPECT_EQ(0.0, absl::get<double>(var));  var = ConvertVariantTo<variant<double, std::string>>(      variant<const char*, float>("foo"));  ASSERT_TRUE(absl::holds_alternative<std::string>(var));  EXPECT_EQ("foo", absl::get<std::string>(var));  variant<double> singleton(      ConvertVariantTo<variant<double>>(variant<int, float>(42)));  ASSERT_TRUE(absl::holds_alternative<double>(singleton));  EXPECT_EQ(42.0, absl::get<double>(singleton));  singleton = ConvertVariantTo<variant<double>>(variant<int, float>(3.14f));  ASSERT_TRUE(absl::holds_alternative<double>(singleton));  EXPECT_FLOAT_EQ(3.14f, static_cast<float>(absl::get<double>(singleton)));  singleton = ConvertVariantTo<variant<double>>(variant<int>(0));  ASSERT_TRUE(absl::holds_alternative<double>(singleton));  EXPECT_EQ(0.0, absl::get<double>(singleton));  variant<int32_t, uint32_t> variant2(      ConvertVariantTo<variant<int32_t, uint32_t>>(variant<int32_t>(42)));  ASSERT_TRUE(absl::holds_alternative<int32_t>(variant2));  EXPECT_EQ(42, absl::get<int32_t>(variant2));  variant2 = ConvertVariantTo<variant<int32_t, uint32_t>>(variant<uint32_t>(42));  ASSERT_TRUE(absl::holds_alternative<uint32_t>(variant2));  EXPECT_EQ(42, absl::get<uint32_t>(variant2));  variant<Convertible1, Convertible2> variant3(      ConvertVariantTo<variant<Convertible1, Convertible2>>(          (variant<Convertible2, Convertible1>(Convertible1()))));  ASSERT_TRUE(absl::holds_alternative<Convertible1>(variant3));  variant3 = ConvertVariantTo<variant<Convertible1, Convertible2>>(      variant<Convertible2, Convertible1>(Convertible2()));  ASSERT_TRUE(absl::holds_alternative<Convertible2>(variant3));}TEST(VariantTest, TestLvalueConversion) {  variant<std::string, int> source1 = 0;  variant<double, std::string> destination(      ConvertVariantTo<variant<double, std::string>>(source1));  ASSERT_TRUE(absl::holds_alternative<double>(destination));  EXPECT_EQ(0.0, absl::get<double>(destination));  variant<const char*, float> source2 = "foo";  destination = ConvertVariantTo<variant<double, std::string>>(source2);  ASSERT_TRUE(absl::holds_alternative<std::string>(destination));  EXPECT_EQ("foo", absl::get<std::string>(destination));  variant<int, float> source3(42);  variant<double> singleton(ConvertVariantTo<variant<double>>(source3));  ASSERT_TRUE(absl::holds_alternative<double>(singleton));  EXPECT_EQ(42.0, absl::get<double>(singleton));  source3 = 3.14f;  singleton = ConvertVariantTo<variant<double>>(source3);  ASSERT_TRUE(absl::holds_alternative<double>(singleton));  EXPECT_FLOAT_EQ(3.14f, static_cast<float>(absl::get<double>(singleton)));  variant<int> source4(0);  singleton = ConvertVariantTo<variant<double>>(source4);  ASSERT_TRUE(absl::holds_alternative<double>(singleton));  EXPECT_EQ(0.0, absl::get<double>(singleton));  variant<int32_t> source5(42);  variant<int32_t, uint32_t> variant2(      ConvertVariantTo<variant<int32_t, uint32_t>>(source5));  ASSERT_TRUE(absl::holds_alternative<int32_t>(variant2));  EXPECT_EQ(42, absl::get<int32_t>(variant2));  variant<uint32_t> source6(42);  variant2 = ConvertVariantTo<variant<int32_t, uint32_t>>(source6);  ASSERT_TRUE(absl::holds_alternative<uint32_t>(variant2));  EXPECT_EQ(42, absl::get<uint32_t>(variant2));  variant<Convertible2, Convertible1> source7((Convertible1()));  variant<Convertible1, Convertible2> variant3(      ConvertVariantTo<variant<Convertible1, Convertible2>>(source7));  ASSERT_TRUE(absl::holds_alternative<Convertible1>(variant3));  source7 = Convertible2();  variant3 = ConvertVariantTo<variant<Convertible1, Convertible2>>(source7);  ASSERT_TRUE(absl::holds_alternative<Convertible2>(variant3));}TEST(VariantTest, TestMoveConversion) {  using Variant =      variant<std::unique_ptr<const int>, std::unique_ptr<const std::string>>;  using OtherVariant = variant<std::unique_ptr<int>, std::unique_ptr<std::string>>;  Variant var(      ConvertVariantTo<Variant>(OtherVariant{absl::make_unique<int>(0)}));  ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<const int>>(var));  ASSERT_NE(absl::get<std::unique_ptr<const int>>(var), nullptr);  EXPECT_EQ(0, *absl::get<std::unique_ptr<const int>>(var));  var =      ConvertVariantTo<Variant>(OtherVariant(absl::make_unique<std::string>("foo")));  ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<const std::string>>(var));  EXPECT_EQ("foo", *absl::get<std::unique_ptr<const std::string>>(var));}TEST(VariantTest, DoesNotMoveFromLvalues) {  // We use shared_ptr here because it's both copyable and movable, and  // a moved-from shared_ptr is guaranteed to be null, so we can detect  // whether moving or copying has occurred.  using Variant =      variant<std::shared_ptr<const int>, std::shared_ptr<const std::string>>;  using OtherVariant = variant<std::shared_ptr<int>, std::shared_ptr<std::string>>;  Variant v1(std::make_shared<const int>(0));  // Test copy constructor  Variant v2(v1);  EXPECT_EQ(absl::get<std::shared_ptr<const int>>(v1),            absl::get<std::shared_ptr<const int>>(v2));  // Test copy-assignment operator  v1 = std::make_shared<const std::string>("foo");  v2 = v1;  EXPECT_EQ(absl::get<std::shared_ptr<const std::string>>(v1),            absl::get<std::shared_ptr<const std::string>>(v2));  // Test converting copy constructor  OtherVariant other(std::make_shared<int>(0));  Variant v3(ConvertVariantTo<Variant>(other));  EXPECT_EQ(absl::get<std::shared_ptr<int>>(other),            absl::get<std::shared_ptr<const int>>(v3));  other = std::make_shared<std::string>("foo");  v3 = ConvertVariantTo<Variant>(other);  EXPECT_EQ(absl::get<std::shared_ptr<std::string>>(other),            absl::get<std::shared_ptr<const std::string>>(v3));}TEST(VariantTest, TestRvalueConversionViaConvertVariantTo) {  variant<double, std::string> var(      ConvertVariantTo<variant<double, std::string>>(variant<std::string, int>(3)));  EXPECT_THAT(absl::get_if<double>(&var), Pointee(3.0));  var = ConvertVariantTo<variant<double, std::string>>(      variant<const char*, float>("foo"));  EXPECT_THAT(absl::get_if<std::string>(&var), Pointee(std::string("foo")));  variant<double> singleton(      ConvertVariantTo<variant<double>>(variant<int, float>(42)));  EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(42.0));  singleton = ConvertVariantTo<variant<double>>(variant<int, float>(3.14f));  EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(DoubleEq(3.14f)));  singleton = ConvertVariantTo<variant<double>>(variant<int>(3));  EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(3.0));  variant<int32_t, uint32_t> variant2(      ConvertVariantTo<variant<int32_t, uint32_t>>(variant<int32_t>(42)));  EXPECT_THAT(absl::get_if<int32_t>(&variant2), Pointee(42));  variant2 = ConvertVariantTo<variant<int32_t, uint32_t>>(variant<uint32_t>(42));  EXPECT_THAT(absl::get_if<uint32_t>(&variant2), Pointee(42));  variant<Convertible1, Convertible2> variant3(      ConvertVariantTo<variant<Convertible1, Convertible2>>(          (variant<Convertible2, Convertible1>(Convertible1()))));  ASSERT_TRUE(absl::holds_alternative<Convertible1>(variant3));  variant3 = ConvertVariantTo<variant<Convertible1, Convertible2>>(      variant<Convertible2, Convertible1>(Convertible2()));  ASSERT_TRUE(absl::holds_alternative<Convertible2>(variant3));}TEST(VariantTest, TestLvalueConversionViaConvertVariantTo) {  variant<std::string, int> source1 = 3;  variant<double, std::string> destination(      ConvertVariantTo<variant<double, std::string>>(source1));  EXPECT_THAT(absl::get_if<double>(&destination), Pointee(3.0));  variant<const char*, float> source2 = "foo";  destination = ConvertVariantTo<variant<double, std::string>>(source2);  EXPECT_THAT(absl::get_if<std::string>(&destination), Pointee(std::string("foo")));  variant<int, float> source3(42);  variant<double> singleton(ConvertVariantTo<variant<double>>(source3));  EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(42.0));  source3 = 3.14f;  singleton = ConvertVariantTo<variant<double>>(source3);  EXPECT_FLOAT_EQ(3.14f, static_cast<float>(absl::get<double>(singleton)));  EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(DoubleEq(3.14f)));  variant<int> source4(3);  singleton = ConvertVariantTo<variant<double>>(source4);  EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(3.0));  variant<int32_t> source5(42);  variant<int32_t, uint32_t> variant2(      ConvertVariantTo<variant<int32_t, uint32_t>>(source5));  EXPECT_THAT(absl::get_if<int32_t>(&variant2), Pointee(42));  variant<uint32_t> source6(42);  variant2 = ConvertVariantTo<variant<int32_t, uint32_t>>(source6);  EXPECT_THAT(absl::get_if<uint32_t>(&variant2), Pointee(42));  variant<Convertible2, Convertible1> source7((Convertible1()));  variant<Convertible1, Convertible2> variant3(      ConvertVariantTo<variant<Convertible1, Convertible2>>(source7));  ASSERT_TRUE(absl::holds_alternative<Convertible1>(variant3));  source7 = Convertible2();  variant3 = ConvertVariantTo<variant<Convertible1, Convertible2>>(source7);  ASSERT_TRUE(absl::holds_alternative<Convertible2>(variant3));}TEST(VariantTest, TestMoveConversionViaConvertVariantTo) {  using Variant =      variant<std::unique_ptr<const int>, std::unique_ptr<const std::string>>;  using OtherVariant = variant<std::unique_ptr<int>, std::unique_ptr<std::string>>;  Variant var(      ConvertVariantTo<Variant>(OtherVariant{absl::make_unique<int>(3)}));  EXPECT_THAT(absl::get_if<std::unique_ptr<const int>>(&var),              Pointee(Pointee(3)));  var =      ConvertVariantTo<Variant>(OtherVariant(absl::make_unique<std::string>("foo")));  EXPECT_THAT(absl::get_if<std::unique_ptr<const std::string>>(&var),              Pointee(Pointee(std::string("foo"))));}// If all alternatives are trivially copy/move constructible, variant should// also be trivially copy/move constructible. This is not required by the// standard and we know that libstdc++ variant doesn't have this feature.// For more details see the paper:// http://open-std.org/JTC1/SC22/WG21/docs/papers/2017/p0602r0.html#if !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__))#define ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY 1#endifTEST(VariantTest, TestCopyAndMoveTypeTraits) {  EXPECT_TRUE(std::is_copy_constructible<variant<std::string>>::value);  EXPECT_TRUE(absl::is_copy_assignable<variant<std::string>>::value);  EXPECT_TRUE(std::is_move_constructible<variant<std::string>>::value);  EXPECT_TRUE(absl::is_move_assignable<variant<std::string>>::value);  EXPECT_TRUE(std::is_move_constructible<variant<std::unique_ptr<int>>>::value);  EXPECT_TRUE(absl::is_move_assignable<variant<std::unique_ptr<int>>>::value);  EXPECT_FALSE(      std::is_copy_constructible<variant<std::unique_ptr<int>>>::value);  EXPECT_FALSE(absl::is_copy_assignable<variant<std::unique_ptr<int>>>::value);  EXPECT_FALSE(      absl::is_trivially_copy_constructible<variant<std::string>>::value);  EXPECT_FALSE(absl::is_trivially_copy_assignable<variant<std::string>>::value);#if ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY  EXPECT_TRUE(absl::is_trivially_copy_constructible<variant<int>>::value);  EXPECT_TRUE(absl::is_trivially_copy_assignable<variant<int>>::value);  EXPECT_TRUE(is_trivially_move_constructible<variant<int>>::value);  EXPECT_TRUE(is_trivially_move_assignable<variant<int>>::value);#endif  // ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY}TEST(VariantTest, TestVectorOfMoveonlyVariant) {  // Verify that variant<MoveonlyType> works correctly as a std::vector element.  std::vector<variant<std::unique_ptr<int>, std::string>> vec;  vec.push_back(absl::make_unique<int>(42));  vec.emplace_back("Hello");  vec.reserve(3);  auto another_vec = absl::move(vec);  // As a sanity check, verify vector contents.  ASSERT_EQ(2, another_vec.size());  EXPECT_EQ(42, *absl::get<std::unique_ptr<int>>(another_vec[0]));  EXPECT_EQ("Hello", absl::get<std::string>(another_vec[1]));}TEST(VariantTest, NestedVariant) {#if ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY  static_assert(absl::is_trivially_copy_constructible<variant<int>>(), "");  static_assert(absl::is_trivially_copy_assignable<variant<int>>(), "");  static_assert(is_trivially_move_constructible<variant<int>>(), "");  static_assert(is_trivially_move_assignable<variant<int>>(), "");  static_assert(absl::is_trivially_copy_constructible<variant<variant<int>>>(),                "");  static_assert(absl::is_trivially_copy_assignable<variant<variant<int>>>(),                "");  static_assert(is_trivially_move_constructible<variant<variant<int>>>(), "");  static_assert(is_trivially_move_assignable<variant<variant<int>>>(), "");#endif  // ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY  variant<int> x(42);  variant<variant<int>> y(x);  variant<variant<int>> z(y);  EXPECT_TRUE(absl::holds_alternative<variant<int>>(z));  EXPECT_EQ(x, absl::get<variant<int>>(z));}struct TriviallyDestructible {  TriviallyDestructible(TriviallyDestructible&&) {}  TriviallyDestructible(const TriviallyDestructible&) {}  TriviallyDestructible& operator=(TriviallyDestructible&&) { return *this; }  TriviallyDestructible& operator=(const TriviallyDestructible&) {    return *this;  }};struct TriviallyMovable {  TriviallyMovable(TriviallyMovable&&) = default;  TriviallyMovable(TriviallyMovable const&) {}  TriviallyMovable& operator=(const TriviallyMovable&) { return *this; }};struct TriviallyCopyable {  TriviallyCopyable(const TriviallyCopyable&) = default;  TriviallyCopyable& operator=(const TriviallyCopyable&) { return *this; }};struct TriviallyMoveAssignable {  TriviallyMoveAssignable(TriviallyMoveAssignable&&) = default;  TriviallyMoveAssignable(const TriviallyMoveAssignable&) {}  TriviallyMoveAssignable& operator=(TriviallyMoveAssignable&&) = default;  TriviallyMoveAssignable& operator=(const TriviallyMoveAssignable&) {    return *this;  }};struct TriviallyCopyAssignable {};#if ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITYTEST(VariantTest, TestTriviality) {  {    using TrivDestVar = absl::variant<TriviallyDestructible>;    EXPECT_FALSE(is_trivially_move_constructible<TrivDestVar>::value);    EXPECT_FALSE(absl::is_trivially_copy_constructible<TrivDestVar>::value);    EXPECT_FALSE(is_trivially_move_assignable<TrivDestVar>::value);    EXPECT_FALSE(absl::is_trivially_copy_assignable<TrivDestVar>::value);    EXPECT_TRUE(absl::is_trivially_destructible<TrivDestVar>::value);  }  {    using TrivMoveVar = absl::variant<TriviallyMovable>;    EXPECT_TRUE(is_trivially_move_constructible<TrivMoveVar>::value);    EXPECT_FALSE(absl::is_trivially_copy_constructible<TrivMoveVar>::value);    EXPECT_FALSE(is_trivially_move_assignable<TrivMoveVar>::value);    EXPECT_FALSE(absl::is_trivially_copy_assignable<TrivMoveVar>::value);    EXPECT_TRUE(absl::is_trivially_destructible<TrivMoveVar>::value);  }  {    using TrivCopyVar = absl::variant<TriviallyCopyable>;    EXPECT_TRUE(is_trivially_move_constructible<TrivCopyVar>::value);    EXPECT_TRUE(absl::is_trivially_copy_constructible<TrivCopyVar>::value);    EXPECT_FALSE(is_trivially_move_assignable<TrivCopyVar>::value);    EXPECT_FALSE(absl::is_trivially_copy_assignable<TrivCopyVar>::value);    EXPECT_TRUE(absl::is_trivially_destructible<TrivCopyVar>::value);  }  {    using TrivMoveAssignVar = absl::variant<TriviallyMoveAssignable>;    EXPECT_TRUE(is_trivially_move_constructible<TrivMoveAssignVar>::value);    EXPECT_FALSE(        absl::is_trivially_copy_constructible<TrivMoveAssignVar>::value);    EXPECT_TRUE(is_trivially_move_assignable<TrivMoveAssignVar>::value);    EXPECT_FALSE(absl::is_trivially_copy_assignable<TrivMoveAssignVar>::value);    EXPECT_TRUE(absl::is_trivially_destructible<TrivMoveAssignVar>::value);  }  {    using TrivCopyAssignVar = absl::variant<TriviallyCopyAssignable>;    EXPECT_TRUE(is_trivially_move_constructible<TrivCopyAssignVar>::value);    EXPECT_TRUE(        absl::is_trivially_copy_constructible<TrivCopyAssignVar>::value);    EXPECT_TRUE(is_trivially_move_assignable<TrivCopyAssignVar>::value);    EXPECT_TRUE(absl::is_trivially_copy_assignable<TrivCopyAssignVar>::value);    EXPECT_TRUE(absl::is_trivially_destructible<TrivCopyAssignVar>::value);  }}#endif  // ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY// To verify that absl::variant correctly use the nontrivial move ctor of its// member rather than use the trivial copy constructor.TEST(VariantTest, MoveCtorBug) {  // To simulate std::tuple in libstdc++.  struct TrivialCopyNontrivialMove {    TrivialCopyNontrivialMove() = default;    TrivialCopyNontrivialMove(const TrivialCopyNontrivialMove&) = default;    TrivialCopyNontrivialMove(TrivialCopyNontrivialMove&&) { called = true; }    bool called = false;  };  {    using V = absl::variant<TrivialCopyNontrivialMove, int>;    V v1(absl::in_place_index_t<0>{});    // this should invoke the move ctor, rather than the trivial copy ctor.    V v2(std::move(v1));    EXPECT_TRUE(absl::get<0>(v2).called);  }  {    // this case failed to compile before our fix due to a GCC bug.    using V = absl::variant<int, TrivialCopyNontrivialMove>;    V v1(absl::in_place_index_t<1>{});    // this should invoke the move ctor, rather than the trivial copy ctor.    V v2(std::move(v1));    EXPECT_TRUE(absl::get<1>(v2).called);  }}}  // namespace}  // namespace absl
 |