llvm/unittests/ADT/OptionalTest.cpp - toolchain/llvm-project - Gitiles

 //===- llvm/unittest/ADT/OptionalTest.cpp - Optional unit tests -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest-spi.h"
 #include "gtest/gtest.h"

 #include <array>


 using namespace llvm;

 static_assert(is_trivially_copyable<Optional<int>>::value,
           "trivially copyable");

 static_assert(is_trivially_copyable<Optional<std::array<int, 3>>>::value,
               "trivially copyable");

 namespace {

 struct NonDefaultConstructible {
   static unsigned CopyConstructions;
   static unsigned Destructions;
   static unsigned CopyAssignments;
   explicit NonDefaultConstructible(int) {
   }
   NonDefaultConstructible(const NonDefaultConstructible&) {
     ++CopyConstructions;
   }
   NonDefaultConstructible &operator=(const NonDefaultConstructible&) {
     ++CopyAssignments;
     return *this;
   }
   ~NonDefaultConstructible() {
     ++Destructions;
   }
   static void ResetCounts() {
     CopyConstructions = 0;
     Destructions = 0;
     CopyAssignments = 0;
   }
 };

 unsigned NonDefaultConstructible::CopyConstructions = 0;
 unsigned NonDefaultConstructible::Destructions = 0;
 unsigned NonDefaultConstructible::CopyAssignments = 0;

 static_assert(
       !is_trivially_copyable<Optional<NonDefaultConstructible>>::value,
       "not trivially copyable");

 // Test fixture
 class OptionalTest : public testing::Test {
 };

 TEST_F(OptionalTest, NonDefaultConstructibleTest) {
   Optional<NonDefaultConstructible> O;
   EXPECT_FALSE(O);
 }

 TEST_F(OptionalTest, ResetTest) {
   NonDefaultConstructible::ResetCounts();
   Optional<NonDefaultConstructible> O(NonDefaultConstructible(3));
   EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
   EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
   NonDefaultConstructible::ResetCounts();
   O.reset();
   EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
   EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
 }

 TEST_F(OptionalTest, InitializationLeakTest) {
   NonDefaultConstructible::ResetCounts();
   Optional<NonDefaultConstructible>(NonDefaultConstructible(3));
   EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
   EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
 }

 TEST_F(OptionalTest, CopyConstructionTest) {
   NonDefaultConstructible::ResetCounts();
   {
     Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
     EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
     EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
     NonDefaultConstructible::ResetCounts();
     Optional<NonDefaultConstructible> B(A);
     EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
     EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
     NonDefaultConstructible::ResetCounts();
   }
   EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
   EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
 }

 TEST_F(OptionalTest, ConstructingCopyAssignmentTest) {
   NonDefaultConstructible::ResetCounts();
   {
     Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
     Optional<NonDefaultConstructible> B;
     EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
     EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
     NonDefaultConstructible::ResetCounts();
     B = A;
     EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
     EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
     NonDefaultConstructible::ResetCounts();
   }
   EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
   EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
 }

 TEST_F(OptionalTest, CopyingCopyAssignmentTest) {
   NonDefaultConstructible::ResetCounts();
   {
     Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
     Optional<NonDefaultConstructible> B(NonDefaultConstructible(4));
     EXPECT_EQ(2u, NonDefaultConstructible::CopyConstructions);
     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
     EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
     NonDefaultConstructible::ResetCounts();
     B = A;
     EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
     EXPECT_EQ(1u, NonDefaultConstructible::CopyAssignments);
     EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
     NonDefaultConstructible::ResetCounts();
   }
   EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
   EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
 }

 TEST_F(OptionalTest, DeletingCopyAssignmentTest) {
   NonDefaultConstructible::ResetCounts();
   {
     Optional<NonDefaultConstructible> A;
     Optional<NonDefaultConstructible> B(NonDefaultConstructible(3));
     EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
     EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
     NonDefaultConstructible::ResetCounts();
     B = A;
     EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
     EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
     NonDefaultConstructible::ResetCounts();
   }
   EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
   EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
 }

 TEST_F(OptionalTest, NullCopyConstructionTest) {
   NonDefaultConstructible::ResetCounts();
   {
     Optional<NonDefaultConstructible> A;
     Optional<NonDefaultConstructible> B;
     EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
     EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
     NonDefaultConstructible::ResetCounts();
     B = A;
     EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
     EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
     EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
     NonDefaultConstructible::ResetCounts();
   }
   EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
   EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
   EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
 }

 TEST_F(OptionalTest, GetValueOr) {
   Optional<int> A;
   EXPECT_EQ(42, A.getValueOr(42));

   A = 5;
   EXPECT_EQ(5, A.getValueOr(42));
 }

 struct MultiArgConstructor {
   int x, y;
   MultiArgConstructor(int x, int y) : x(x), y(y) {}
   explicit MultiArgConstructor(int x, bool positive)
     : x(x), y(positive ? x : -x) {}

   MultiArgConstructor(const MultiArgConstructor &) = delete;
   MultiArgConstructor(MultiArgConstructor &&) = delete;
   MultiArgConstructor &operator=(const MultiArgConstructor &) = delete;
   MultiArgConstructor &operator=(MultiArgConstructor &&) = delete;

   static unsigned Destructions;
   ~MultiArgConstructor() {
     ++Destructions;
   }
   static void ResetCounts() {
     Destructions = 0;
   }
 };
 unsigned MultiArgConstructor::Destructions = 0;

 static_assert(
   !is_trivially_copyable<Optional<MultiArgConstructor>>::value,
   "not trivially copyable");

 TEST_F(OptionalTest, Emplace) {
   MultiArgConstructor::ResetCounts();
   Optional<MultiArgConstructor> A;

   A.emplace(1, 2);
   EXPECT_TRUE(A.hasValue());
   EXPECT_EQ(1, A->x);
   EXPECT_EQ(2, A->y);
   EXPECT_EQ(0u, MultiArgConstructor::Destructions);

   A.emplace(5, false);
   EXPECT_TRUE(A.hasValue());
   EXPECT_EQ(5, A->x);
   EXPECT_EQ(-5, A->y);
   EXPECT_EQ(1u, MultiArgConstructor::Destructions);
 }

 struct MoveOnly {
   static unsigned MoveConstructions;
   static unsigned Destructions;
   static unsigned MoveAssignments;
   int val;
   explicit MoveOnly(int val) : val(val) {
   }
   MoveOnly(MoveOnly&& other) {
     val = other.val;
     ++MoveConstructions;
   }
   MoveOnly &operator=(MoveOnly&& other) {
     val = other.val;
     ++MoveAssignments;
     return *this;
   }
   ~MoveOnly() {
     ++Destructions;
   }
   static void ResetCounts() {
     MoveConstructions = 0;
     Destructions = 0;
     MoveAssignments = 0;
   }
 };

 unsigned MoveOnly::MoveConstructions = 0;
 unsigned MoveOnly::Destructions = 0;
 unsigned MoveOnly::MoveAssignments = 0;

 static_assert(!is_trivially_copyable<Optional<MoveOnly>>::value,
               "not trivially copyable");

 TEST_F(OptionalTest, MoveOnlyNull) {
   MoveOnly::ResetCounts();
   Optional<MoveOnly> O;
   EXPECT_EQ(0u, MoveOnly::MoveConstructions);
   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
   EXPECT_EQ(0u, MoveOnly::Destructions);
 }

 TEST_F(OptionalTest, MoveOnlyConstruction) {
   MoveOnly::ResetCounts();
   Optional<MoveOnly> O(MoveOnly(3));
   EXPECT_TRUE((bool)O);
   EXPECT_EQ(3, O->val);
   EXPECT_EQ(1u, MoveOnly::MoveConstructions);
   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
   EXPECT_EQ(1u, MoveOnly::Destructions);
 }

 TEST_F(OptionalTest, MoveOnlyMoveConstruction) {
   Optional<MoveOnly> A(MoveOnly(3));
   MoveOnly::ResetCounts();
   Optional<MoveOnly> B(std::move(A));
   EXPECT_TRUE((bool)A);
   EXPECT_TRUE((bool)B);
   EXPECT_EQ(3, B->val);
   EXPECT_EQ(1u, MoveOnly::MoveConstructions);
   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
   EXPECT_EQ(0u, MoveOnly::Destructions);
 }

 TEST_F(OptionalTest, MoveOnlyAssignment) {
   MoveOnly::ResetCounts();
   Optional<MoveOnly> O;
   O = MoveOnly(3);
   EXPECT_TRUE((bool)O);
   EXPECT_EQ(3, O->val);
   EXPECT_EQ(1u, MoveOnly::MoveConstructions);
   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
   EXPECT_EQ(1u, MoveOnly::Destructions);
 }

 TEST_F(OptionalTest, MoveOnlyInitializingAssignment) {
   Optional<MoveOnly> A(MoveOnly(3));
   Optional<MoveOnly> B;
   MoveOnly::ResetCounts();
   B = std::move(A);
   EXPECT_TRUE((bool)A);
   EXPECT_TRUE((bool)B);
   EXPECT_EQ(3, B->val);
   EXPECT_EQ(1u, MoveOnly::MoveConstructions);
   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
   EXPECT_EQ(0u, MoveOnly::Destructions);
 }

 TEST_F(OptionalTest, MoveOnlyNullingAssignment) {
   Optional<MoveOnly> A;
   Optional<MoveOnly> B(MoveOnly(3));
   MoveOnly::ResetCounts();
   B = std::move(A);
   EXPECT_FALSE((bool)A);
   EXPECT_FALSE((bool)B);
   EXPECT_EQ(0u, MoveOnly::MoveConstructions);
   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
   EXPECT_EQ(1u, MoveOnly::Destructions);
 }

 TEST_F(OptionalTest, MoveOnlyAssigningAssignment) {
   Optional<MoveOnly> A(MoveOnly(3));
   Optional<MoveOnly> B(MoveOnly(4));
   MoveOnly::ResetCounts();
   B = std::move(A);
   EXPECT_TRUE((bool)A);
   EXPECT_TRUE((bool)B);
   EXPECT_EQ(3, B->val);
   EXPECT_EQ(0u, MoveOnly::MoveConstructions);
   EXPECT_EQ(1u, MoveOnly::MoveAssignments);
   EXPECT_EQ(0u, MoveOnly::Destructions);
 }

 struct Immovable {
   static unsigned Constructions;
   static unsigned Destructions;
   int val;
   explicit Immovable(int val) : val(val) {
     ++Constructions;
   }
   ~Immovable() {
     ++Destructions;
   }
   static void ResetCounts() {
     Constructions = 0;
     Destructions = 0;
   }
 private:
   // This should disable all move/copy operations.
   Immovable(Immovable&& other) = delete;
 };

 unsigned Immovable::Constructions = 0;
 unsigned Immovable::Destructions = 0;

 static_assert(!is_trivially_copyable<Optional<Immovable>>::value,
               "not trivially copyable");

 TEST_F(OptionalTest, ImmovableEmplace) {
   Optional<Immovable> A;
   Immovable::ResetCounts();
   A.emplace(4);
   EXPECT_TRUE((bool)A);
   EXPECT_EQ(4, A->val);
   EXPECT_EQ(1u, Immovable::Constructions);
   EXPECT_EQ(0u, Immovable::Destructions);
 }

 #if LLVM_HAS_RVALUE_REFERENCE_THIS

 TEST_F(OptionalTest, MoveGetValueOr) {
   Optional<MoveOnly> A;

   MoveOnly::ResetCounts();
   EXPECT_EQ(42, std::move(A).getValueOr(MoveOnly(42)).val);
   EXPECT_EQ(1u, MoveOnly::MoveConstructions);
   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
   EXPECT_EQ(2u, MoveOnly::Destructions);

   A = MoveOnly(5);
   MoveOnly::ResetCounts();
   EXPECT_EQ(5, std::move(A).getValueOr(MoveOnly(42)).val);
   EXPECT_EQ(1u, MoveOnly::MoveConstructions);
   EXPECT_EQ(0u, MoveOnly::MoveAssignments);
   EXPECT_EQ(2u, MoveOnly::Destructions);
 }

 #endif // LLVM_HAS_RVALUE_REFERENCE_THIS

 struct EqualTo {
   template <typename T, typename U> static bool apply(const T &X, const U &Y) {
     return X == Y;
   }
 };

 struct NotEqualTo {
   template <typename T, typename U> static bool apply(const T &X, const U &Y) {
     return X != Y;
   }
 };

 struct Less {
   template <typename T, typename U> static bool apply(const T &X, const U &Y) {
     return X < Y;
   }
 };

 struct Greater {
   template <typename T, typename U> static bool apply(const T &X, const U &Y) {
     return X > Y;
   }
 };

 struct LessEqual {
   template <typename T, typename U> static bool apply(const T &X, const U &Y) {
     return X <= Y;
   }
 };

 struct GreaterEqual {
   template <typename T, typename U> static bool apply(const T &X, const U &Y) {
     return X >= Y;
   }
 };

 template <typename OperatorT, typename T>
 void CheckRelation(const Optional<T> &Lhs, const Optional<T> &Rhs,
                    bool Expected) {
   EXPECT_EQ(Expected, OperatorT::apply(Lhs, Rhs));

   if (Lhs)
     EXPECT_EQ(Expected, OperatorT::apply(*Lhs, Rhs));
   else
     EXPECT_EQ(Expected, OperatorT::apply(None, Rhs));

   if (Rhs)
     EXPECT_EQ(Expected, OperatorT::apply(Lhs, *Rhs));
   else
     EXPECT_EQ(Expected, OperatorT::apply(Lhs, None));
 }

 struct EqualityMock {};
 const Optional<EqualityMock> NoneEq, EqualityLhs((EqualityMock())),
     EqualityRhs((EqualityMock()));
 bool IsEqual;

 bool operator==(const EqualityMock &Lhs, const EqualityMock &Rhs) {
   EXPECT_EQ(&*EqualityLhs, &Lhs);
   EXPECT_EQ(&*EqualityRhs, &Rhs);
   return IsEqual;
 }

 TEST_F(OptionalTest, OperatorEqual) {
   CheckRelation<EqualTo>(NoneEq, NoneEq, true);
   CheckRelation<EqualTo>(NoneEq, EqualityRhs, false);
   CheckRelation<EqualTo>(EqualityLhs, NoneEq, false);

   IsEqual = false;
   CheckRelation<EqualTo>(EqualityLhs, EqualityRhs, IsEqual);
   IsEqual = true;
   CheckRelation<EqualTo>(EqualityLhs, EqualityRhs, IsEqual);
 }

 TEST_F(OptionalTest, OperatorNotEqual) {
   CheckRelation<NotEqualTo>(NoneEq, NoneEq, false);
   CheckRelation<NotEqualTo>(NoneEq, EqualityRhs, true);
   CheckRelation<NotEqualTo>(EqualityLhs, NoneEq, true);

   IsEqual = false;
   CheckRelation<NotEqualTo>(EqualityLhs, EqualityRhs, !IsEqual);
   IsEqual = true;
   CheckRelation<NotEqualTo>(EqualityLhs, EqualityRhs, !IsEqual);
 }

 struct InequalityMock {};
 const Optional<InequalityMock> NoneIneq, InequalityLhs((InequalityMock())),
     InequalityRhs((InequalityMock()));
 bool IsLess;

 bool operator<(const InequalityMock &Lhs, const InequalityMock &Rhs) {
   EXPECT_EQ(&*InequalityLhs, &Lhs);
   EXPECT_EQ(&*InequalityRhs, &Rhs);
   return IsLess;
 }

 TEST_F(OptionalTest, OperatorLess) {
   CheckRelation<Less>(NoneIneq, NoneIneq, false);
   CheckRelation<Less>(NoneIneq, InequalityRhs, true);
   CheckRelation<Less>(InequalityLhs, NoneIneq, false);

   IsLess = false;
   CheckRelation<Less>(InequalityLhs, InequalityRhs, IsLess);
   IsLess = true;
   CheckRelation<Less>(InequalityLhs, InequalityRhs, IsLess);
 }

 TEST_F(OptionalTest, OperatorGreater) {
   CheckRelation<Greater>(NoneIneq, NoneIneq, false);
   CheckRelation<Greater>(NoneIneq, InequalityRhs, false);
   CheckRelation<Greater>(InequalityLhs, NoneIneq, true);

   IsLess = false;
   CheckRelation<Greater>(InequalityRhs, InequalityLhs, IsLess);
   IsLess = true;
   CheckRelation<Greater>(InequalityRhs, InequalityLhs, IsLess);
 }

 TEST_F(OptionalTest, OperatorLessEqual) {
   CheckRelation<LessEqual>(NoneIneq, NoneIneq, true);
   CheckRelation<LessEqual>(NoneIneq, InequalityRhs, true);
   CheckRelation<LessEqual>(InequalityLhs, NoneIneq, false);

   IsLess = false;
   CheckRelation<LessEqual>(InequalityRhs, InequalityLhs, !IsLess);
   IsLess = true;
   CheckRelation<LessEqual>(InequalityRhs, InequalityLhs, !IsLess);
 }

 TEST_F(OptionalTest, OperatorGreaterEqual) {
   CheckRelation<GreaterEqual>(NoneIneq, NoneIneq, true);
   CheckRelation<GreaterEqual>(NoneIneq, InequalityRhs, false);
   CheckRelation<GreaterEqual>(InequalityLhs, NoneIneq, true);

   IsLess = false;
   CheckRelation<GreaterEqual>(InequalityLhs, InequalityRhs, !IsLess);
   IsLess = true;
   CheckRelation<GreaterEqual>(InequalityLhs, InequalityRhs, !IsLess);
 }

 struct ComparableAndStreamable {
   friend bool operator==(ComparableAndStreamable,
                          ComparableAndStreamable) LLVM_ATTRIBUTE_USED {
     return true;
   }

   friend raw_ostream &operator<<(raw_ostream &OS, ComparableAndStreamable) {
     return OS << "ComparableAndStreamable";
   }

   static Optional<ComparableAndStreamable> get() {
     return ComparableAndStreamable();
   }
 };

 TEST_F(OptionalTest, StreamOperator) {
   auto to_string = [](Optional<ComparableAndStreamable> O) {
     SmallString<16> S;
     raw_svector_ostream OS(S);
     OS << O;
     return S;
   };
   EXPECT_EQ("ComparableAndStreamable",
             to_string(ComparableAndStreamable::get()));
   EXPECT_EQ("None", to_string(None));
 }

 struct Comparable {
   friend bool operator==(Comparable, Comparable) LLVM_ATTRIBUTE_USED {
     return true;
   }
   static Optional<Comparable> get() { return Comparable(); }
 };

 TEST_F(OptionalTest, UseInUnitTests) {
   // Test that we invoke the streaming operators when pretty-printing values in
   // EXPECT macros.
   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(llvm::None, ComparableAndStreamable::get()),
                           "Expected: llvm::None\n"
                           "      Which is: None\n"
                           "To be equal to: ComparableAndStreamable::get()\n"
                           "      Which is: ComparableAndStreamable");

   // Test that it is still possible to compare objects which do not have a
   // custom streaming operator.
   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(llvm::None, Comparable::get()), "object");
 }

 } // end anonymous namespace
	//===- llvm/unittest/ADT/OptionalTest.cpp - Optional unit tests -----------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "llvm/ADT/Optional.h"
	#include "llvm/ADT/SmallString.h"
	#include "llvm/Support/raw_ostream.h"
	#include "gtest/gtest-spi.h"
	#include "gtest/gtest.h"

	#include <array>


	using namespace llvm;

	static_assert(is_trivially_copyable<Optional<int>>::value,
	"trivially copyable");

	static_assert(is_trivially_copyable<Optional<std::array<int, 3>>>::value,
	"trivially copyable");

	namespace {

	struct NonDefaultConstructible {
	static unsigned CopyConstructions;
	static unsigned Destructions;
	static unsigned CopyAssignments;
	explicit NonDefaultConstructible(int) {
	}
	NonDefaultConstructible(const NonDefaultConstructible&) {
	++CopyConstructions;
	}
	NonDefaultConstructible &operator=(const NonDefaultConstructible&) {
	++CopyAssignments;
	return *this;
	}
	~NonDefaultConstructible() {
	++Destructions;
	}
	static void ResetCounts() {
	CopyConstructions = 0;
	Destructions = 0;
	CopyAssignments = 0;
	}
	};

	unsigned NonDefaultConstructible::CopyConstructions = 0;
	unsigned NonDefaultConstructible::Destructions = 0;
	unsigned NonDefaultConstructible::CopyAssignments = 0;

	static_assert(
	!is_trivially_copyable<Optional<NonDefaultConstructible>>::value,
	"not trivially copyable");

	// Test fixture
	class OptionalTest : public testing::Test {
	};

	TEST_F(OptionalTest, NonDefaultConstructibleTest) {
	Optional<NonDefaultConstructible> O;
	EXPECT_FALSE(O);
	}

	TEST_F(OptionalTest, ResetTest) {
	NonDefaultConstructible::ResetCounts();
	Optional<NonDefaultConstructible> O(NonDefaultConstructible(3));
	EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
	NonDefaultConstructible::ResetCounts();
	O.reset();
	EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
	}

	TEST_F(OptionalTest, InitializationLeakTest) {
	NonDefaultConstructible::ResetCounts();
	Optional<NonDefaultConstructible>(NonDefaultConstructible(3));
	EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
	}

	TEST_F(OptionalTest, CopyConstructionTest) {
	NonDefaultConstructible::ResetCounts();
	{
	Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
	EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
	NonDefaultConstructible::ResetCounts();
	Optional<NonDefaultConstructible> B(A);
	EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
	NonDefaultConstructible::ResetCounts();
	}
	EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
	}

	TEST_F(OptionalTest, ConstructingCopyAssignmentTest) {
	NonDefaultConstructible::ResetCounts();
	{
	Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
	Optional<NonDefaultConstructible> B;
	EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
	NonDefaultConstructible::ResetCounts();
	B = A;
	EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
	NonDefaultConstructible::ResetCounts();
	}
	EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
	}

	TEST_F(OptionalTest, CopyingCopyAssignmentTest) {
	NonDefaultConstructible::ResetCounts();
	{
	Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
	Optional<NonDefaultConstructible> B(NonDefaultConstructible(4));
	EXPECT_EQ(2u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
	NonDefaultConstructible::ResetCounts();
	B = A;
	EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(1u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
	NonDefaultConstructible::ResetCounts();
	}
	EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(2u, NonDefaultConstructible::Destructions);
	}

	TEST_F(OptionalTest, DeletingCopyAssignmentTest) {
	NonDefaultConstructible::ResetCounts();
	{
	Optional<NonDefaultConstructible> A;
	Optional<NonDefaultConstructible> B(NonDefaultConstructible(3));
	EXPECT_EQ(1u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
	NonDefaultConstructible::ResetCounts();
	B = A;
	EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(1u, NonDefaultConstructible::Destructions);
	NonDefaultConstructible::ResetCounts();
	}
	EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
	}

	TEST_F(OptionalTest, NullCopyConstructionTest) {
	NonDefaultConstructible::ResetCounts();
	{
	Optional<NonDefaultConstructible> A;
	Optional<NonDefaultConstructible> B;
	EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
	NonDefaultConstructible::ResetCounts();
	B = A;
	EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
	NonDefaultConstructible::ResetCounts();
	}
	EXPECT_EQ(0u, NonDefaultConstructible::CopyConstructions);
	EXPECT_EQ(0u, NonDefaultConstructible::CopyAssignments);
	EXPECT_EQ(0u, NonDefaultConstructible::Destructions);
	}

	TEST_F(OptionalTest, GetValueOr) {
	Optional<int> A;
	EXPECT_EQ(42, A.getValueOr(42));

	A = 5;
	EXPECT_EQ(5, A.getValueOr(42));
	}

	struct MultiArgConstructor {
	int x, y;
	MultiArgConstructor(int x, int y) : x(x), y(y) {}
	explicit MultiArgConstructor(int x, bool positive)
	: x(x), y(positive ? x : -x) {}

	MultiArgConstructor(const MultiArgConstructor &) = delete;
	MultiArgConstructor(MultiArgConstructor &&) = delete;
	MultiArgConstructor &operator=(const MultiArgConstructor &) = delete;
	MultiArgConstructor &operator=(MultiArgConstructor &&) = delete;

	static unsigned Destructions;
	~MultiArgConstructor() {
	++Destructions;
	}
	static void ResetCounts() {
	Destructions = 0;
	}
	};
	unsigned MultiArgConstructor::Destructions = 0;

	static_assert(
	!is_trivially_copyable<Optional<MultiArgConstructor>>::value,
	"not trivially copyable");

	TEST_F(OptionalTest, Emplace) {
	MultiArgConstructor::ResetCounts();
	Optional<MultiArgConstructor> A;

	A.emplace(1, 2);
	EXPECT_TRUE(A.hasValue());
	EXPECT_EQ(1, A->x);
	EXPECT_EQ(2, A->y);
	EXPECT_EQ(0u, MultiArgConstructor::Destructions);

	A.emplace(5, false);
	EXPECT_TRUE(A.hasValue());
	EXPECT_EQ(5, A->x);
	EXPECT_EQ(-5, A->y);
	EXPECT_EQ(1u, MultiArgConstructor::Destructions);
	}

	struct MoveOnly {
	static unsigned MoveConstructions;
	static unsigned Destructions;
	static unsigned MoveAssignments;
	int val;
	explicit MoveOnly(int val) : val(val) {
	}
	MoveOnly(MoveOnly&& other) {
	val = other.val;
	++MoveConstructions;
	}
	MoveOnly &operator=(MoveOnly&& other) {
	val = other.val;
	++MoveAssignments;
	return *this;
	}
	~MoveOnly() {
	++Destructions;
	}
	static void ResetCounts() {
	MoveConstructions = 0;
	Destructions = 0;
	MoveAssignments = 0;
	}
	};

	unsigned MoveOnly::MoveConstructions = 0;
	unsigned MoveOnly::Destructions = 0;
	unsigned MoveOnly::MoveAssignments = 0;

	static_assert(!is_trivially_copyable<Optional<MoveOnly>>::value,
	"not trivially copyable");

	TEST_F(OptionalTest, MoveOnlyNull) {
	MoveOnly::ResetCounts();
	Optional<MoveOnly> O;
	EXPECT_EQ(0u, MoveOnly::MoveConstructions);
	EXPECT_EQ(0u, MoveOnly::MoveAssignments);
	EXPECT_EQ(0u, MoveOnly::Destructions);
	}

	TEST_F(OptionalTest, MoveOnlyConstruction) {
	MoveOnly::ResetCounts();
	Optional<MoveOnly> O(MoveOnly(3));
	EXPECT_TRUE((bool)O);
	EXPECT_EQ(3, O->val);
	EXPECT_EQ(1u, MoveOnly::MoveConstructions);
	EXPECT_EQ(0u, MoveOnly::MoveAssignments);
	EXPECT_EQ(1u, MoveOnly::Destructions);
	}

	TEST_F(OptionalTest, MoveOnlyMoveConstruction) {
	Optional<MoveOnly> A(MoveOnly(3));
	MoveOnly::ResetCounts();
	Optional<MoveOnly> B(std::move(A));
	EXPECT_TRUE((bool)A);
	EXPECT_TRUE((bool)B);
	EXPECT_EQ(3, B->val);
	EXPECT_EQ(1u, MoveOnly::MoveConstructions);
	EXPECT_EQ(0u, MoveOnly::MoveAssignments);
	EXPECT_EQ(0u, MoveOnly::Destructions);
	}

	TEST_F(OptionalTest, MoveOnlyAssignment) {
	MoveOnly::ResetCounts();
	Optional<MoveOnly> O;
	O = MoveOnly(3);
	EXPECT_TRUE((bool)O);
	EXPECT_EQ(3, O->val);
	EXPECT_EQ(1u, MoveOnly::MoveConstructions);
	EXPECT_EQ(0u, MoveOnly::MoveAssignments);
	EXPECT_EQ(1u, MoveOnly::Destructions);
	}

	TEST_F(OptionalTest, MoveOnlyInitializingAssignment) {
	Optional<MoveOnly> A(MoveOnly(3));
	Optional<MoveOnly> B;
	MoveOnly::ResetCounts();
	B = std::move(A);
	EXPECT_TRUE((bool)A);
	EXPECT_TRUE((bool)B);
	EXPECT_EQ(3, B->val);
	EXPECT_EQ(1u, MoveOnly::MoveConstructions);
	EXPECT_EQ(0u, MoveOnly::MoveAssignments);
	EXPECT_EQ(0u, MoveOnly::Destructions);
	}

	TEST_F(OptionalTest, MoveOnlyNullingAssignment) {
	Optional<MoveOnly> A;
	Optional<MoveOnly> B(MoveOnly(3));
	MoveOnly::ResetCounts();
	B = std::move(A);
	EXPECT_FALSE((bool)A);
	EXPECT_FALSE((bool)B);
	EXPECT_EQ(0u, MoveOnly::MoveConstructions);
	EXPECT_EQ(0u, MoveOnly::MoveAssignments);
	EXPECT_EQ(1u, MoveOnly::Destructions);
	}

	TEST_F(OptionalTest, MoveOnlyAssigningAssignment) {
	Optional<MoveOnly> A(MoveOnly(3));
	Optional<MoveOnly> B(MoveOnly(4));
	MoveOnly::ResetCounts();
	B = std::move(A);
	EXPECT_TRUE((bool)A);
	EXPECT_TRUE((bool)B);
	EXPECT_EQ(3, B->val);
	EXPECT_EQ(0u, MoveOnly::MoveConstructions);
	EXPECT_EQ(1u, MoveOnly::MoveAssignments);
	EXPECT_EQ(0u, MoveOnly::Destructions);
	}

	struct Immovable {
	static unsigned Constructions;
	static unsigned Destructions;
	int val;
	explicit Immovable(int val) : val(val) {
	++Constructions;
	}
	~Immovable() {
	++Destructions;
	}
	static void ResetCounts() {
	Constructions = 0;
	Destructions = 0;
	}
	private:
	// This should disable all move/copy operations.
	Immovable(Immovable&& other) = delete;
	};

	unsigned Immovable::Constructions = 0;
	unsigned Immovable::Destructions = 0;

	static_assert(!is_trivially_copyable<Optional<Immovable>>::value,
	"not trivially copyable");

	TEST_F(OptionalTest, ImmovableEmplace) {
	Optional<Immovable> A;
	Immovable::ResetCounts();
	A.emplace(4);
	EXPECT_TRUE((bool)A);
	EXPECT_EQ(4, A->val);
	EXPECT_EQ(1u, Immovable::Constructions);
	EXPECT_EQ(0u, Immovable::Destructions);
	}

	#if LLVM_HAS_RVALUE_REFERENCE_THIS

	TEST_F(OptionalTest, MoveGetValueOr) {
	Optional<MoveOnly> A;

	MoveOnly::ResetCounts();
	EXPECT_EQ(42, std::move(A).getValueOr(MoveOnly(42)).val);
	EXPECT_EQ(1u, MoveOnly::MoveConstructions);
	EXPECT_EQ(0u, MoveOnly::MoveAssignments);
	EXPECT_EQ(2u, MoveOnly::Destructions);

	A = MoveOnly(5);
	MoveOnly::ResetCounts();
	EXPECT_EQ(5, std::move(A).getValueOr(MoveOnly(42)).val);
	EXPECT_EQ(1u, MoveOnly::MoveConstructions);
	EXPECT_EQ(0u, MoveOnly::MoveAssignments);
	EXPECT_EQ(2u, MoveOnly::Destructions);
	}

	#endif // LLVM_HAS_RVALUE_REFERENCE_THIS

	struct EqualTo {
	template <typename T, typename U> static bool apply(const T &X, const U &Y) {
	return X == Y;
	}
	};

	struct NotEqualTo {
	template <typename T, typename U> static bool apply(const T &X, const U &Y) {
	return X != Y;
	}
	};

	struct Less {
	template <typename T, typename U> static bool apply(const T &X, const U &Y) {
	return X < Y;
	}
	};

	struct Greater {
	template <typename T, typename U> static bool apply(const T &X, const U &Y) {
	return X > Y;
	}
	};

	struct LessEqual {
	template <typename T, typename U> static bool apply(const T &X, const U &Y) {
	return X <= Y;
	}
	};

	struct GreaterEqual {
	template <typename T, typename U> static bool apply(const T &X, const U &Y) {
	return X >= Y;
	}
	};

	template <typename OperatorT, typename T>
	void CheckRelation(const Optional<T> &Lhs, const Optional<T> &Rhs,
	bool Expected) {
	EXPECT_EQ(Expected, OperatorT::apply(Lhs, Rhs));

	if (Lhs)
	EXPECT_EQ(Expected, OperatorT::apply(*Lhs, Rhs));
	else
	EXPECT_EQ(Expected, OperatorT::apply(None, Rhs));

	if (Rhs)
	EXPECT_EQ(Expected, OperatorT::apply(Lhs, *Rhs));
	else
	EXPECT_EQ(Expected, OperatorT::apply(Lhs, None));
	}

	struct EqualityMock {};
	const Optional<EqualityMock> NoneEq, EqualityLhs((EqualityMock())),
	EqualityRhs((EqualityMock()));
	bool IsEqual;

	bool operator==(const EqualityMock &Lhs, const EqualityMock &Rhs) {
	EXPECT_EQ(&*EqualityLhs, &Lhs);
	EXPECT_EQ(&*EqualityRhs, &Rhs);
	return IsEqual;
	}

	TEST_F(OptionalTest, OperatorEqual) {
	CheckRelation<EqualTo>(NoneEq, NoneEq, true);
	CheckRelation<EqualTo>(NoneEq, EqualityRhs, false);
	CheckRelation<EqualTo>(EqualityLhs, NoneEq, false);

	IsEqual = false;
	CheckRelation<EqualTo>(EqualityLhs, EqualityRhs, IsEqual);
	IsEqual = true;
	CheckRelation<EqualTo>(EqualityLhs, EqualityRhs, IsEqual);
	}

	TEST_F(OptionalTest, OperatorNotEqual) {
	CheckRelation<NotEqualTo>(NoneEq, NoneEq, false);
	CheckRelation<NotEqualTo>(NoneEq, EqualityRhs, true);
	CheckRelation<NotEqualTo>(EqualityLhs, NoneEq, true);

	IsEqual = false;
	CheckRelation<NotEqualTo>(EqualityLhs, EqualityRhs, !IsEqual);
	IsEqual = true;
	CheckRelation<NotEqualTo>(EqualityLhs, EqualityRhs, !IsEqual);
	}

	struct InequalityMock {};
	const Optional<InequalityMock> NoneIneq, InequalityLhs((InequalityMock())),
	InequalityRhs((InequalityMock()));
	bool IsLess;

	bool operator<(const InequalityMock &Lhs, const InequalityMock &Rhs) {
	EXPECT_EQ(&*InequalityLhs, &Lhs);
	EXPECT_EQ(&*InequalityRhs, &Rhs);
	return IsLess;
	}

	TEST_F(OptionalTest, OperatorLess) {
	CheckRelation<Less>(NoneIneq, NoneIneq, false);
	CheckRelation<Less>(NoneIneq, InequalityRhs, true);
	CheckRelation<Less>(InequalityLhs, NoneIneq, false);

	IsLess = false;
	CheckRelation<Less>(InequalityLhs, InequalityRhs, IsLess);
	IsLess = true;
	CheckRelation<Less>(InequalityLhs, InequalityRhs, IsLess);
	}

	TEST_F(OptionalTest, OperatorGreater) {
	CheckRelation<Greater>(NoneIneq, NoneIneq, false);
	CheckRelation<Greater>(NoneIneq, InequalityRhs, false);
	CheckRelation<Greater>(InequalityLhs, NoneIneq, true);

	IsLess = false;
	CheckRelation<Greater>(InequalityRhs, InequalityLhs, IsLess);
	IsLess = true;
	CheckRelation<Greater>(InequalityRhs, InequalityLhs, IsLess);
	}

	TEST_F(OptionalTest, OperatorLessEqual) {
	CheckRelation<LessEqual>(NoneIneq, NoneIneq, true);
	CheckRelation<LessEqual>(NoneIneq, InequalityRhs, true);
	CheckRelation<LessEqual>(InequalityLhs, NoneIneq, false);

	IsLess = false;
	CheckRelation<LessEqual>(InequalityRhs, InequalityLhs, !IsLess);
	IsLess = true;
	CheckRelation<LessEqual>(InequalityRhs, InequalityLhs, !IsLess);
	}

	TEST_F(OptionalTest, OperatorGreaterEqual) {
	CheckRelation<GreaterEqual>(NoneIneq, NoneIneq, true);
	CheckRelation<GreaterEqual>(NoneIneq, InequalityRhs, false);
	CheckRelation<GreaterEqual>(InequalityLhs, NoneIneq, true);

	IsLess = false;
	CheckRelation<GreaterEqual>(InequalityLhs, InequalityRhs, !IsLess);
	IsLess = true;
	CheckRelation<GreaterEqual>(InequalityLhs, InequalityRhs, !IsLess);
	}

	struct ComparableAndStreamable {
	friend bool operator==(ComparableAndStreamable,
	ComparableAndStreamable) LLVM_ATTRIBUTE_USED {
	return true;
	}

	friend raw_ostream &operator<<(raw_ostream &OS, ComparableAndStreamable) {
	return OS << "ComparableAndStreamable";
	}

	static Optional<ComparableAndStreamable> get() {
	return ComparableAndStreamable();
	}
	};

	TEST_F(OptionalTest, StreamOperator) {
	auto to_string = [](Optional<ComparableAndStreamable> O) {
	SmallString<16> S;
	raw_svector_ostream OS(S);
	OS << O;
	return S;
	};
	EXPECT_EQ("ComparableAndStreamable",
	to_string(ComparableAndStreamable::get()));
	EXPECT_EQ("None", to_string(None));
	}

	struct Comparable {
	friend bool operator==(Comparable, Comparable) LLVM_ATTRIBUTE_USED {
	return true;
	}
	static Optional<Comparable> get() { return Comparable(); }
	};

	TEST_F(OptionalTest, UseInUnitTests) {
	// Test that we invoke the streaming operators when pretty-printing values in
	// EXPECT macros.
	EXPECT_NONFATAL_FAILURE(EXPECT_EQ(llvm::None, ComparableAndStreamable::get()),
	"Expected: llvm::None\n"
	" Which is: None\n"
	"To be equal to: ComparableAndStreamable::get()\n"
	" Which is: ComparableAndStreamable");

	// Test that it is still possible to compare objects which do not have a
	// custom streaming operator.
	EXPECT_NONFATAL_FAILURE(EXPECT_EQ(llvm::None, Comparable::get()), "object");
	}

	} // end anonymous namespace