423 lines
17 KiB
C++
423 lines
17 KiB
C++
/*!
|
|
* \file Tmeta.cpp
|
|
*
|
|
* Copyright (C) 2018 Christos Choutouridis
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as
|
|
* published by the Free Software Foundation, either version 3
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
#include <utl/concepts/concepts.h>
|
|
#include <utl/meta/meta.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
|
|
namespace test_concepts {
|
|
using namespace utl;
|
|
|
|
/*
|
|
* Fixture like types
|
|
*/
|
|
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) {
|
|
// 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) {
|
|
// 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) {
|
|
// 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) {
|
|
// 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&>));
|
|
//FIXME: CommonReference needs SFINAE friendly implementation
|
|
//EXPECT_EQ (false, (CommonReference<Empty&&, const volatile Empty&>)); <- yields compiler error
|
|
|
|
// Common
|
|
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) {
|
|
// 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>));
|
|
|
|
// SignedIntegral
|
|
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>));
|
|
|
|
// UnsignedIntegral
|
|
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) {
|
|
// MoveAssignable
|
|
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>));
|
|
|
|
// CopyAssignable
|
|
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>));
|
|
|
|
// Assignable
|
|
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) {
|
|
// Swappable, SwappableWith
|
|
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>));
|
|
|
|
// Destructible
|
|
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) {
|
|
// 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>));
|
|
|
|
// DefaultConstructible
|
|
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>));
|
|
|
|
// MoveConstructible
|
|
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>));
|
|
|
|
// CopyConstructible
|
|
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) {
|
|
// Movable
|
|
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>));
|
|
|
|
// Copyable
|
|
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) {
|
|
// 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) {
|
|
// EqualityComparable
|
|
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>));
|
|
|
|
// EqualityComparableWith
|
|
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>));
|
|
|
|
// StrictTotallyOrdered
|
|
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>));
|
|
|
|
// StrictTotallyOrderedWith
|
|
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) {
|
|
// Semiregular
|
|
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>));
|
|
|
|
// Regular
|
|
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>));
|
|
|
|
// Scalar
|
|
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>));
|
|
|
|
// Arithmetic
|
|
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>));
|
|
|
|
// FloatingPoint
|
|
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) {
|
|
|
|
// type_printer(detail::try_ppI<Incr&>{});
|
|
// type_printer(detail::try_Ipp<Incr&>{});
|
|
// type_printer(meta::detected_t<detail::try_ppI, int>{});
|
|
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&>));
|
|
}
|
|
}
|
|
|