|
-
- #include <utl/concepts/concepts.h>
- #include <utl/meta/meta.h>
- #include <gtest/gtest.h>
-
-
- namespace test_concepts {
- using namespace utl;
-
-
-
- struct Empty { };
- struct HaveOnlyCopy {
- HaveOnlyCopy(const HaveOnlyCopy&) = default;
- HaveOnlyCopy(HaveOnlyCopy&&) = delete;
- HaveOnlyCopy& operator= (const HaveOnlyCopy&) = default;
- HaveOnlyCopy& operator= (HaveOnlyCopy&&) = delete;
- };
- struct HaveOnlyMove {
- HaveOnlyMove(const HaveOnlyMove&) = delete;
- HaveOnlyMove(HaveOnlyMove&&) = default;
- HaveOnlyMove& operator= (const HaveOnlyMove&) = delete;
- HaveOnlyMove& operator= (HaveOnlyMove&&) = default;
- };
- struct HaveCopyAndMove {
- HaveCopyAndMove(const HaveCopyAndMove&) = default;
- HaveCopyAndMove(HaveCopyAndMove&&) = default;
- HaveCopyAndMove& operator= (const HaveCopyAndMove&) = default;
- HaveCopyAndMove& operator= (HaveCopyAndMove&&) = default;
- };
- class HavePerfectForwarding {
- public: template<class T> HavePerfectForwarding(T&&) { }
- };
- class Base { };
- class Derived1 : public Base { };
- class Derived2 : public Derived1 { };
- class HaveOperatorBase {
- public: operator Base() { return base; }
- Base base;
- };
-
-
- struct A {
- int a_;
- public:
- A(int a =0) : a_{a} { };
- A(const A&) = default;
- A(A&&) = default;
- };
- bool operator== (const A& l, const A& r) { return l.a_ == r.a_; }
- bool operator!= (const A& l, const A& r) { return l.a_ != r.a_; }
-
- struct B {
- int b_;
- public:
- B(int b =0) : b_{b} { };
- B(const B&) = default;
- B(B&&) = default;
- B& operator= (const B&) = default;
- B& operator= (B&&) = default;
- };
- bool operator== (const B& l, const B& r) { return l.b_ == r.b_; }
- bool operator!= (const B& l, const B& r) { return l.b_ != r.b_; }
- bool operator< (const B& l, const B& r) { return l.b_ < r.b_; }
- bool operator<= (const B& l, const B& r) { return l.b_ <= r.b_; }
- bool operator> (const B& l, const B& r) { return l.b_ > r.b_; }
- bool operator>= (const B& l, const B& r) { return l.b_ >= r.b_; }
-
-
- TEST(TConcepts, Same) {
-
- EXPECT_EQ (true, (Same<int, int>));
- EXPECT_EQ (false, (Same<int, long>));
- EXPECT_EQ (true, (Same<int*, int*>));
- EXPECT_EQ (true, (Same<double&, double&>));
- EXPECT_EQ (false, (Same<int, Empty>));
- EXPECT_EQ (false, (Same<Base, Derived1>));
- }
-
- TEST(TConcepts, DerivedFrom) {
-
- EXPECT_EQ (true, (DerivedFrom<Derived1, Base>));
- EXPECT_EQ (true, (DerivedFrom<Derived2, Derived1>));
- EXPECT_EQ (true, (DerivedFrom<Derived2, Base>));
- EXPECT_EQ (false, (DerivedFrom<Base, Derived1>));
- EXPECT_EQ (false, (DerivedFrom<Base, int>));
- EXPECT_EQ (false, (DerivedFrom<void, int>));
- }
-
- TEST(TConcepts, ConvertibleTo) {
-
- EXPECT_EQ (true, (ConvertibleTo<void, void>));
- EXPECT_EQ (false, (ConvertibleTo<Base, void>));
- EXPECT_EQ (false, (ConvertibleTo<Base*, Derived1*>));
- EXPECT_EQ (true, (ConvertibleTo<Derived1*, Base*>));
- EXPECT_EQ (true, (ConvertibleTo<HaveOperatorBase, Base>));
- EXPECT_EQ (true, (ConvertibleTo<Base, HavePerfectForwarding>));
- }
-
- TEST(TConcepts, CommonReference) {
-
- EXPECT_EQ (true, (CommonReference<Derived1, Base>));
- EXPECT_EQ (true, (CommonReference<Derived1&, Base>));
- EXPECT_EQ (true, (CommonReference<const Empty&&, const Empty&>));
- EXPECT_EQ (false, (CommonReference<Empty&, const volatile Empty&>));
-
-
-
-
- EXPECT_EQ (true, (Common<int, int>));
- EXPECT_EQ (true, (Common<Base, Derived1>));
- EXPECT_EQ (true, (Common<Derived1, Derived2>));
- EXPECT_EQ (true, (Common<Base, HaveOperatorBase>));
- EXPECT_EQ (true, (Common<Base, HavePerfectForwarding>));
- }
-
- TEST(TConcepts, Integral) {
-
- EXPECT_EQ (false, (Integral<void>));
- EXPECT_EQ (true, (Integral<int>));
- EXPECT_EQ (true, (Integral<bool>));
- EXPECT_EQ (false, (Integral<int*>));
- EXPECT_EQ (false, (Integral<Base>));
- EXPECT_EQ (true, (Integral<meta::int_<42>::value_type>));
- EXPECT_EQ (false, (Integral<meta::int_<42>::type>));
-
-
- EXPECT_EQ (false, (SignedIntegral<void>));
- EXPECT_EQ (true, (SignedIntegral<int>));
- EXPECT_EQ (false, (SignedIntegral<int*>));
- EXPECT_EQ (false, (SignedIntegral<unsigned long>));
- EXPECT_EQ (false, (SignedIntegral<double>));
- EXPECT_EQ (false, (SignedIntegral<Base>));
- EXPECT_EQ (true, (SignedIntegral<meta::int16_<42>::value_type>));
-
-
- EXPECT_EQ (false, (UnsignedIntegral<void>));
- EXPECT_EQ (true, (UnsignedIntegral<unsigned int>));
- EXPECT_EQ (false, (UnsignedIntegral<long>));
- EXPECT_EQ (false, (UnsignedIntegral<double>));
- EXPECT_EQ (false, (UnsignedIntegral<Base>));
- EXPECT_EQ (true, (UnsignedIntegral<meta::uint16_<42>::value_type>));
- }
-
- TEST(TConcepts, Assignable) {
-
- EXPECT_EQ (false, (MoveAssignable<void>));
- EXPECT_EQ (true, (MoveAssignable<void*>));
- EXPECT_EQ (true, (MoveAssignable<int>));
- EXPECT_EQ (true, (MoveAssignable<int*>));
- EXPECT_EQ (false, (MoveAssignable<HaveOnlyCopy>));
- EXPECT_EQ (true, (MoveAssignable<HaveOnlyMove>));
- EXPECT_EQ (true, (MoveAssignable<HaveCopyAndMove>));
- EXPECT_EQ (true, (MoveAssignable<Empty>));
- EXPECT_EQ (true, (MoveAssignable<HavePerfectForwarding>));
-
-
- EXPECT_EQ (false, (CopyAssignable<void>));
- EXPECT_EQ (true, (CopyAssignable<void*>));
- EXPECT_EQ (true, (CopyAssignable<int>));
- EXPECT_EQ (true, (CopyAssignable<int*>));
- EXPECT_EQ (true, (CopyAssignable<HaveOnlyCopy>));
- EXPECT_EQ (false, (CopyAssignable<HaveOnlyMove>));
- EXPECT_EQ (true, (CopyAssignable<HaveCopyAndMove>));
- EXPECT_EQ (true, (CopyAssignable<Empty>));
- EXPECT_EQ (true, (CopyAssignable<HavePerfectForwarding>));
-
-
- EXPECT_EQ (false, (Assignable<void, void>));
- EXPECT_EQ (false, (Assignable<int&, void>));
- EXPECT_EQ (true, (Assignable<int&, int>));
- EXPECT_EQ (false, (Assignable<int, int>));
- EXPECT_EQ (false, (Assignable<int*, int*>));
- EXPECT_EQ (true, (Assignable<Base&, Derived1>));
- EXPECT_EQ (false, (Assignable<Derived1&, Base>));
- EXPECT_EQ (true, (Assignable<HaveOnlyMove&, HaveOnlyMove&&>));
- EXPECT_EQ (true , (Assignable<HaveOnlyMove&, HaveOnlyMove>));
- EXPECT_EQ (true, (Assignable<Empty&, Empty>));
- }
-
- TEST(TConcepts, Swappable) {
-
- EXPECT_EQ (false, (Swappable<void>));
- EXPECT_EQ (true, (Swappable<void*>));
- EXPECT_EQ (true, (Swappable<int>));
- EXPECT_EQ (true, (Swappable<Base>));
- EXPECT_EQ (true, (SwappableWith<int, int>));
- EXPECT_EQ (false, (SwappableWith<int, Base>));
- EXPECT_EQ (false, (SwappableWith<Base, Derived1>));
-
-
- EXPECT_EQ (false, (Destructible<void>));
- EXPECT_EQ (true, (Destructible<void*>));
- EXPECT_EQ (true, (Destructible<int>));
- EXPECT_EQ (true, (Destructible<int&>));
- EXPECT_EQ (true, (Destructible<Base>));
- EXPECT_EQ (true, (Destructible<HavePerfectForwarding>));
- }
-
- TEST(TConcepts, Constructible) {
-
- EXPECT_EQ (false, (Constructible<void>));
- EXPECT_EQ (true, (Constructible<void*>));
- EXPECT_EQ (true, (Constructible<Base>));
- EXPECT_EQ (false, (Constructible<HaveOnlyMove>));
- EXPECT_EQ (true, (Constructible<HavePerfectForwarding, int>));
-
-
- EXPECT_EQ (false, (DefaultConstructible<void>));
- EXPECT_EQ (true, (DefaultConstructible<void*>));
- EXPECT_EQ (false, (DefaultConstructible<int&>));
- EXPECT_EQ (true, (DefaultConstructible<Base>));
- EXPECT_EQ (true, (DefaultConstructible<Derived1>));
- EXPECT_EQ (false, (DefaultConstructible<HaveOnlyCopy>));
- EXPECT_EQ (false, (DefaultConstructible<HaveOnlyMove>));
- EXPECT_EQ (false, (DefaultConstructible<HavePerfectForwarding>));
-
-
- EXPECT_EQ (false, (MoveConstructible<void>));
- EXPECT_EQ (true, (MoveConstructible<void*>));
- EXPECT_EQ (true, (MoveConstructible<Base>));
- EXPECT_EQ (true, (MoveConstructible<Derived1>));
- EXPECT_EQ (true, (MoveConstructible<HaveOnlyMove>));
- EXPECT_EQ (false, (MoveConstructible<HaveOnlyCopy>));
- EXPECT_EQ (true, (MoveConstructible<HaveCopyAndMove>));
- EXPECT_EQ (true , (MoveConstructible<HavePerfectForwarding>));
-
-
- EXPECT_EQ (false, (CopyConstructible<void>));
- EXPECT_EQ (true, (CopyConstructible<void*>));
- EXPECT_EQ (true, (CopyConstructible<Base>));
- EXPECT_EQ (true, (CopyConstructible<Derived1>));
- EXPECT_EQ (false, (CopyConstructible<HaveOnlyMove>));
- EXPECT_EQ (false, (CopyConstructible<HaveOnlyCopy>));
- EXPECT_EQ (true, (CopyConstructible<HaveCopyAndMove>));
- EXPECT_EQ (true , (CopyConstructible<HavePerfectForwarding>));
- }
-
- TEST(TConcepts, MovableCopyable) {
-
- EXPECT_EQ (false, (Movable<void>));
- EXPECT_EQ (true, (Movable<int>));
- EXPECT_EQ (true, (Movable<Base>));
- EXPECT_EQ (true, (Movable<Derived1>));
- EXPECT_EQ (true, (Movable<HaveOnlyMove>));
- EXPECT_EQ (false, (Movable<HaveOnlyCopy>));
- EXPECT_EQ (true, (Movable<HaveCopyAndMove>));
- EXPECT_EQ (true , (Movable<HavePerfectForwarding>));
-
-
- EXPECT_EQ (false, (Copyable<void>));
- EXPECT_EQ (true, (Copyable<int>));
- EXPECT_EQ (true, (Copyable<Base>));
- EXPECT_EQ (true, (Copyable<Derived1>));
- EXPECT_EQ (false, (Copyable<HaveOnlyMove>));
- EXPECT_EQ (false, (Copyable<HaveOnlyCopy>));
- EXPECT_EQ (true, (Copyable<HaveCopyAndMove>));
- EXPECT_EQ (true , (Copyable<HavePerfectForwarding>));
- }
-
- TEST(TConcepts, Boolean) {
-
- EXPECT_EQ (false, (Boolean<void>));
- EXPECT_EQ (true, (Boolean<bool>));
- EXPECT_EQ (true, (Boolean<int>));
- EXPECT_EQ (true, (Boolean<double>));
- EXPECT_EQ (true, (Boolean<std::true_type>));
- EXPECT_EQ (true, (Boolean<meta::true_>));
- EXPECT_EQ (false, (Boolean<Empty>));
- }
-
- TEST(TConcepts, Comparable) {
-
- EXPECT_EQ (false, (EqualityComparable<void>));
- EXPECT_EQ (true, (EqualityComparable<bool>));
- EXPECT_EQ (true, (EqualityComparable<int>));
- EXPECT_EQ (false, (EqualityComparable<Empty>));
- EXPECT_EQ (true, (EqualityComparable<A>));
-
-
- EXPECT_EQ (false, (EqualityComparableWith<void, bool>));
- EXPECT_EQ (false, (EqualityComparableWith<void, void>));
- EXPECT_EQ (true, (EqualityComparableWith<bool, bool>));
- EXPECT_EQ (true, (EqualityComparableWith<int, int>));
- EXPECT_EQ (true, (EqualityComparableWith<int, bool>));
- EXPECT_EQ (false, (EqualityComparableWith<Empty, Empty>));
- EXPECT_EQ (false, (EqualityComparableWith<int, Empty>));
- EXPECT_EQ (true, (EqualityComparableWith<A, A>));
- EXPECT_EQ (false, (EqualityComparableWith<A, B>));
-
-
- EXPECT_EQ (false, (StrictTotallyOrdered<void>));
- EXPECT_EQ (true, (StrictTotallyOrdered<bool>));
- EXPECT_EQ (true, (StrictTotallyOrdered<int>));
- EXPECT_EQ (true, (StrictTotallyOrdered<double>));
- EXPECT_EQ (false, (StrictTotallyOrdered<Empty>));
- EXPECT_EQ (false, (StrictTotallyOrdered<A>));
- EXPECT_EQ (true, (StrictTotallyOrdered<B>));
-
-
- EXPECT_EQ (false, (StrictTotallyOrderedWith<void, void>));
- EXPECT_EQ (false, (StrictTotallyOrderedWith<int, void>));
- EXPECT_EQ (true, (StrictTotallyOrderedWith<bool, bool>));
- EXPECT_EQ (true, (StrictTotallyOrderedWith<int, double>));
- EXPECT_EQ (false, (StrictTotallyOrderedWith<int, Empty>));
- EXPECT_EQ (false, (StrictTotallyOrderedWith<Base, Derived1>));
- EXPECT_EQ (false, (StrictTotallyOrderedWith<A, A>));
- EXPECT_EQ (true, (StrictTotallyOrderedWith<B, B>));
- EXPECT_EQ (false, (StrictTotallyOrderedWith<A, B>));
- }
-
- TEST(TConcepts, Types) {
-
- EXPECT_EQ (false, (Semiregular<void>));
- EXPECT_EQ (true, (Semiregular<int>));
- EXPECT_EQ (true, (Semiregular<Empty>));
- EXPECT_EQ (false, (Semiregular<HaveOnlyMove>));
- EXPECT_EQ (false, (Semiregular<HaveOnlyCopy>));
- EXPECT_EQ (false, (Semiregular<HaveCopyAndMove>));
- EXPECT_EQ (false, (Semiregular<A>));
- EXPECT_EQ (true, (Semiregular<B>));
-
-
- EXPECT_EQ (false, (Regular<void>));
- EXPECT_EQ (true, (Regular<int>));
- EXPECT_EQ (true, (Regular<int*>));
- EXPECT_EQ (false, (Regular<Empty>));
- EXPECT_EQ (false, (Regular<HaveOnlyMove>));
- EXPECT_EQ (false, (Regular<HaveOnlyCopy>));
- EXPECT_EQ (false, (Regular<HaveCopyAndMove>));
- EXPECT_EQ (false, (Regular<A>));
- EXPECT_EQ (true, (Regular<B>));
-
-
- EXPECT_EQ (false, (Scalar<void>));
- EXPECT_EQ (true, (Scalar<int>));
- EXPECT_EQ (true, (Scalar<long*>));
- EXPECT_EQ (false, (Scalar<A>));
- EXPECT_EQ (false, (Scalar<B>));
-
-
- EXPECT_EQ (false, (Arithmetic<void>));
- EXPECT_EQ (true, (Arithmetic<int>));
- EXPECT_EQ (false, (Arithmetic<long*>));
- EXPECT_EQ (false, (Arithmetic<A>));
- EXPECT_EQ (false, (Arithmetic<B>));
-
-
- EXPECT_EQ (false, (FloatingPoint<void>));
- EXPECT_EQ (true, (FloatingPoint<float>));
- EXPECT_EQ (true, (FloatingPoint<double>));
- EXPECT_EQ (false, (FloatingPoint<int>));
- EXPECT_EQ (false, (FloatingPoint<float*>));
- EXPECT_EQ (false, (FloatingPoint<A>));
- EXPECT_EQ (false, (FloatingPoint<B>));
- }
-
- struct Inv {
- void operator() (int) { };
- void operator() () { };
- };
- struct Pred {
- bool operator () (int) { return true; }
- bool operator () (int, int) { return true; }
- };
- TEST(TConcepts, Callable) {
- EXPECT_EQ (true, (Invocable<Inv, int>));
- EXPECT_EQ (true, (Invocable<Inv>));
- EXPECT_EQ (true, (Invocable<Inv, double>));
- EXPECT_EQ (false, (Invocable<Inv, Empty>));
-
- EXPECT_EQ (true, (RegularInvocable<Inv, int>));
-
- EXPECT_EQ (false, (Predicate<Inv, int>));
- EXPECT_EQ (true, (Predicate<Pred, int>));
- EXPECT_EQ (false, (Predicate<Pred, Empty>));
-
- EXPECT_EQ (true, (Relation<Pred, int, int>));
- EXPECT_EQ (true, (Relation<Pred, int, double>));
- EXPECT_EQ (false, (Relation<Pred, Empty, int>));
-
- EXPECT_EQ (true, (StrictWeakOrder<Pred, int, int>));
- EXPECT_EQ (false, (StrictWeakOrder<Pred, int, Empty>));
- }
-
- struct Incr {
- Incr& operator++() { return *this; }
- Incr operator++(int) { return *this; }
- };
- int type_printer (int* i) { return *i; }
- TEST(TConcepts, Iterators) {
-
-
-
-
- EXPECT_EQ (true, (WeaklyIncrementable<int>));
- EXPECT_EQ (false, (WeaklyIncrementable<void>));
- EXPECT_EQ (false, (WeaklyIncrementable<meta::nil_>));
- EXPECT_EQ (true, (WeaklyIncrementable<Incr>));
- EXPECT_EQ (false, (WeaklyIncrementable<Incr&>));
- }
- }
-
|