Skip to content

Commit

Permalink
[libc++] Make some testing utilities constexpr
Browse files Browse the repository at this point in the history 
This will be needed in order to test constexpr std::vector.
  • Loading branch information
@ldionne
ldionne committed Sep 2, 2020
1 parent 1b88bbf commit 255a60c
Show file tree
Hide file tree
Showing 2 changed files with 83 additions and 83 deletions.
20 changes: 10 additions & 10 deletions libcxx/test/support/emplace_constructible.h
View file
Expand Up @@ -7,17 +7,17 @@
template <class T>
struct EmplaceConstructible {
T value;
explicit EmplaceConstructible(T xvalue) : value(xvalue) {}
TEST_CONSTEXPR_CXX14 explicit EmplaceConstructible(T xvalue) : value(xvalue) {}
EmplaceConstructible(EmplaceConstructible const&) = delete;
};

template <class T>
struct EmplaceConstructibleAndMoveInsertable {
int copied = 0;
T value;
explicit EmplaceConstructibleAndMoveInsertable(T xvalue) : value(xvalue) {}
TEST_CONSTEXPR_CXX14 explicit EmplaceConstructibleAndMoveInsertable(T xvalue) : value(xvalue) {}

EmplaceConstructibleAndMoveInsertable(
TEST_CONSTEXPR_CXX14 EmplaceConstructibleAndMoveInsertable(
EmplaceConstructibleAndMoveInsertable&& Other)
: copied(Other.copied + 1), value(std::move(Other.value)) {}
};
Expand All @@ -27,13 +27,13 @@ struct EmplaceConstructibleAndMoveable {
int copied = 0;
int assigned = 0;
T value;
explicit EmplaceConstructibleAndMoveable(T xvalue) noexcept : value(xvalue) {}
TEST_CONSTEXPR_CXX14 explicit EmplaceConstructibleAndMoveable(T xvalue) noexcept : value(xvalue) {}

EmplaceConstructibleAndMoveable(EmplaceConstructibleAndMoveable&& Other)
TEST_CONSTEXPR_CXX14 EmplaceConstructibleAndMoveable(EmplaceConstructibleAndMoveable&& Other)
noexcept : copied(Other.copied + 1),
value(std::move(Other.value)) {}

EmplaceConstructibleAndMoveable&
TEST_CONSTEXPR_CXX14 EmplaceConstructibleAndMoveable&
operator=(EmplaceConstructibleAndMoveable&& Other) noexcept {
copied = Other.copied;
assigned = Other.assigned + 1;
Expand All @@ -47,23 +47,23 @@ struct EmplaceConstructibleMoveableAndAssignable {
int copied = 0;
int assigned = 0;
T value;
explicit EmplaceConstructibleMoveableAndAssignable(T xvalue) noexcept
TEST_CONSTEXPR_CXX14 explicit EmplaceConstructibleMoveableAndAssignable(T xvalue) noexcept
: value(xvalue) {}

EmplaceConstructibleMoveableAndAssignable(
TEST_CONSTEXPR_CXX14 EmplaceConstructibleMoveableAndAssignable(
EmplaceConstructibleMoveableAndAssignable&& Other) noexcept
: copied(Other.copied + 1),
value(std::move(Other.value)) {}

EmplaceConstructibleMoveableAndAssignable&
TEST_CONSTEXPR_CXX14 EmplaceConstructibleMoveableAndAssignable&
operator=(EmplaceConstructibleMoveableAndAssignable&& Other) noexcept {
copied = Other.copied;
assigned = Other.assigned + 1;
value = std::move(Other.value);
return *this;
}

EmplaceConstructibleMoveableAndAssignable& operator=(T xvalue) {
TEST_CONSTEXPR_CXX14 EmplaceConstructibleMoveableAndAssignable& operator=(T xvalue) {
value = std::move(xvalue);
++assigned;
return *this;
Expand Down
146 changes: 73 additions & 73 deletions libcxx/test/support/min_allocator.h
View file
Expand Up @@ -220,19 +220,19 @@ class min_pointer<void, ID>
void* ptr_;
public:
min_pointer() TEST_NOEXCEPT = default;
min_pointer(std::nullptr_t) TEST_NOEXCEPT : ptr_(nullptr) {}
TEST_CONSTEXPR_CXX14 min_pointer(std::nullptr_t) TEST_NOEXCEPT : ptr_(nullptr) {}
template <class T,
class = typename std::enable_if
<
!std::is_const<T>::value
>::type
>
min_pointer(min_pointer<T, ID> p) TEST_NOEXCEPT : ptr_(p.ptr_) {}
TEST_CONSTEXPR_CXX14 min_pointer(min_pointer<T, ID> p) TEST_NOEXCEPT : ptr_(p.ptr_) {}

explicit operator bool() const {return ptr_ != nullptr;}
TEST_CONSTEXPR_CXX14 explicit operator bool() const {return ptr_ != nullptr;}

friend bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;}
friend bool operator!=(min_pointer x, min_pointer y) {return !(x == y);}
TEST_CONSTEXPR_CXX14 friend bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;}
TEST_CONSTEXPR_CXX14 friend bool operator!=(min_pointer x, min_pointer y) {return !(x == y);}
template <class U, class XID> friend class min_pointer;
};

Expand All @@ -241,67 +241,67 @@ class min_pointer
{
T* ptr_;

explicit min_pointer(T* p) TEST_NOEXCEPT : ptr_(p) {}
TEST_CONSTEXPR_CXX14 explicit min_pointer(T* p) TEST_NOEXCEPT : ptr_(p) {}
public:
min_pointer() TEST_NOEXCEPT = default;
min_pointer(std::nullptr_t) TEST_NOEXCEPT : ptr_(nullptr) {}
explicit min_pointer(min_pointer<void, ID> p) TEST_NOEXCEPT : ptr_(static_cast<T*>(p.ptr_)) {}
TEST_CONSTEXPR_CXX14 min_pointer(std::nullptr_t) TEST_NOEXCEPT : ptr_(nullptr) {}
TEST_CONSTEXPR_CXX14 explicit min_pointer(min_pointer<void, ID> p) TEST_NOEXCEPT : ptr_(static_cast<T*>(p.ptr_)) {}

explicit operator bool() const {return ptr_ != nullptr;}
TEST_CONSTEXPR_CXX14 explicit operator bool() const {return ptr_ != nullptr;}

typedef std::ptrdiff_t difference_type;
typedef T& reference;
typedef T* pointer;
typedef T value_type;
typedef std::random_access_iterator_tag iterator_category;

reference operator*() const {return *ptr_;}
pointer operator->() const {return ptr_;}
TEST_CONSTEXPR_CXX14 reference operator*() const {return *ptr_;}
TEST_CONSTEXPR_CXX14 pointer operator->() const {return ptr_;}

min_pointer& operator++() {++ptr_; return *this;}
min_pointer operator++(int) {min_pointer tmp(*this); ++ptr_; return tmp;}
TEST_CONSTEXPR_CXX14 min_pointer& operator++() {++ptr_; return *this;}
TEST_CONSTEXPR_CXX14 min_pointer operator++(int) {min_pointer tmp(*this); ++ptr_; return tmp;}

min_pointer& operator--() {--ptr_; return *this;}
min_pointer operator--(int) {min_pointer tmp(*this); --ptr_; return tmp;}
TEST_CONSTEXPR_CXX14 min_pointer& operator--() {--ptr_; return *this;}
TEST_CONSTEXPR_CXX14 min_pointer operator--(int) {min_pointer tmp(*this); --ptr_; return tmp;}

min_pointer& operator+=(difference_type n) {ptr_ += n; return *this;}
min_pointer& operator-=(difference_type n) {ptr_ -= n; return *this;}
TEST_CONSTEXPR_CXX14 min_pointer& operator+=(difference_type n) {ptr_ += n; return *this;}
TEST_CONSTEXPR_CXX14 min_pointer& operator-=(difference_type n) {ptr_ -= n; return *this;}

min_pointer operator+(difference_type n) const
TEST_CONSTEXPR_CXX14 min_pointer operator+(difference_type n) const
{
min_pointer tmp(*this);
tmp += n;
return tmp;
}

friend min_pointer operator+(difference_type n, min_pointer x)
friend TEST_CONSTEXPR_CXX14 min_pointer operator+(difference_type n, min_pointer x)
{
return x + n;
}

min_pointer operator-(difference_type n) const
TEST_CONSTEXPR_CXX14 min_pointer operator-(difference_type n) const
{
min_pointer tmp(*this);
tmp -= n;
return tmp;
}

friend difference_type operator-(min_pointer x, min_pointer y)
friend TEST_CONSTEXPR_CXX14 difference_type operator-(min_pointer x, min_pointer y)
{
return x.ptr_ - y.ptr_;
}

reference operator[](difference_type n) const {return ptr_[n];}
TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const {return ptr_[n];}

friend bool operator< (min_pointer x, min_pointer y) {return x.ptr_ < y.ptr_;}
friend bool operator> (min_pointer x, min_pointer y) {return y < x;}
friend bool operator<=(min_pointer x, min_pointer y) {return !(y < x);}
friend bool operator>=(min_pointer x, min_pointer y) {return !(x < y);}
friend TEST_CONSTEXPR_CXX14 bool operator< (min_pointer x, min_pointer y) {return x.ptr_ < y.ptr_;}
friend TEST_CONSTEXPR_CXX14 bool operator> (min_pointer x, min_pointer y) {return y < x;}
friend TEST_CONSTEXPR_CXX14 bool operator<=(min_pointer x, min_pointer y) {return !(y < x);}
friend TEST_CONSTEXPR_CXX14 bool operator>=(min_pointer x, min_pointer y) {return !(x < y);}

static min_pointer pointer_to(T& t) {return min_pointer(std::addressof(t));}
static TEST_CONSTEXPR_CXX14 min_pointer pointer_to(T& t) {return min_pointer(std::addressof(t));}

friend bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;}
friend bool operator!=(min_pointer x, min_pointer y) {return !(x == y);}
friend TEST_CONSTEXPR_CXX14 bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;}
friend TEST_CONSTEXPR_CXX14 bool operator!=(min_pointer x, min_pointer y) {return !(x == y);}
template <class U, class XID> friend class min_pointer;
template <class U> friend class min_allocator;
};
Expand All @@ -311,97 +311,97 @@ class min_pointer<const T, ID>
{
const T* ptr_;

explicit min_pointer(const T* p) : ptr_(p) {}
TEST_CONSTEXPR_CXX14 explicit min_pointer(const T* p) : ptr_(p) {}
public:
min_pointer() TEST_NOEXCEPT = default;
min_pointer(std::nullptr_t) : ptr_(nullptr) {}
min_pointer(min_pointer<T, ID> p) : ptr_(p.ptr_) {}
explicit min_pointer(min_pointer<const void, ID> p) : ptr_(static_cast<const T*>(p.ptr_)) {}
TEST_CONSTEXPR_CXX14 min_pointer(std::nullptr_t) : ptr_(nullptr) {}
TEST_CONSTEXPR_CXX14 min_pointer(min_pointer<T, ID> p) : ptr_(p.ptr_) {}
TEST_CONSTEXPR_CXX14 explicit min_pointer(min_pointer<const void, ID> p) : ptr_(static_cast<const T*>(p.ptr_)) {}

explicit operator bool() const {return ptr_ != nullptr;}
TEST_CONSTEXPR_CXX14 explicit operator bool() const {return ptr_ != nullptr;}

typedef std::ptrdiff_t difference_type;
typedef const T& reference;
typedef const T* pointer;
typedef const T value_type;
typedef std::random_access_iterator_tag iterator_category;

reference operator*() const {return *ptr_;}
pointer operator->() const {return ptr_;}
TEST_CONSTEXPR_CXX14 reference operator*() const {return *ptr_;}
TEST_CONSTEXPR_CXX14 pointer operator->() const {return ptr_;}

min_pointer& operator++() {++ptr_; return *this;}
min_pointer operator++(int) {min_pointer tmp(*this); ++ptr_; return tmp;}
TEST_CONSTEXPR_CXX14 min_pointer& operator++() {++ptr_; return *this;}
TEST_CONSTEXPR_CXX14 min_pointer operator++(int) {min_pointer tmp(*this); ++ptr_; return tmp;}

min_pointer& operator--() {--ptr_; return *this;}
min_pointer operator--(int) {min_pointer tmp(*this); --ptr_; return tmp;}
TEST_CONSTEXPR_CXX14 min_pointer& operator--() {--ptr_; return *this;}
TEST_CONSTEXPR_CXX14 min_pointer operator--(int) {min_pointer tmp(*this); --ptr_; return tmp;}

min_pointer& operator+=(difference_type n) {ptr_ += n; return *this;}
min_pointer& operator-=(difference_type n) {ptr_ -= n; return *this;}
TEST_CONSTEXPR_CXX14 min_pointer& operator+=(difference_type n) {ptr_ += n; return *this;}
TEST_CONSTEXPR_CXX14 min_pointer& operator-=(difference_type n) {ptr_ -= n; return *this;}

min_pointer operator+(difference_type n) const
TEST_CONSTEXPR_CXX14 min_pointer operator+(difference_type n) const
{
min_pointer tmp(*this);
tmp += n;
return tmp;
}

friend min_pointer operator+(difference_type n, min_pointer x)
friend TEST_CONSTEXPR_CXX14 min_pointer operator+(difference_type n, min_pointer x)
{
return x + n;
}

min_pointer operator-(difference_type n) const
TEST_CONSTEXPR_CXX14 min_pointer operator-(difference_type n) const
{
min_pointer tmp(*this);
tmp -= n;
return tmp;
}

friend difference_type operator-(min_pointer x, min_pointer y)
friend TEST_CONSTEXPR_CXX14 difference_type operator-(min_pointer x, min_pointer y)
{
return x.ptr_ - y.ptr_;
}

reference operator[](difference_type n) const {return ptr_[n];}
TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const {return ptr_[n];}

friend bool operator< (min_pointer x, min_pointer y) {return x.ptr_ < y.ptr_;}
friend bool operator> (min_pointer x, min_pointer y) {return y < x;}
friend bool operator<=(min_pointer x, min_pointer y) {return !(y < x);}
friend bool operator>=(min_pointer x, min_pointer y) {return !(x < y);}
friend TEST_CONSTEXPR_CXX14 bool operator< (min_pointer x, min_pointer y) {return x.ptr_ < y.ptr_;}
friend TEST_CONSTEXPR_CXX14 bool operator> (min_pointer x, min_pointer y) {return y < x;}
friend TEST_CONSTEXPR_CXX14 bool operator<=(min_pointer x, min_pointer y) {return !(y < x);}
friend TEST_CONSTEXPR_CXX14 bool operator>=(min_pointer x, min_pointer y) {return !(x < y);}

static min_pointer pointer_to(const T& t) {return min_pointer(std::addressof(t));}
static TEST_CONSTEXPR_CXX14 min_pointer pointer_to(const T& t) {return min_pointer(std::addressof(t));}

friend bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;}
friend bool operator!=(min_pointer x, min_pointer y) {return !(x == y);}
friend TEST_CONSTEXPR_CXX14 bool operator==(min_pointer x, min_pointer y) {return x.ptr_ == y.ptr_;}
friend TEST_CONSTEXPR_CXX14 bool operator!=(min_pointer x, min_pointer y) {return !(x == y);}
template <class U, class XID> friend class min_pointer;
};

template <class T, class ID>
inline
TEST_CONSTEXPR_CXX14 inline
bool
operator==(min_pointer<T, ID> x, std::nullptr_t)
{
return !static_cast<bool>(x);
}

template <class T, class ID>
inline
TEST_CONSTEXPR_CXX14 inline
bool
operator==(std::nullptr_t, min_pointer<T, ID> x)
{
return !static_cast<bool>(x);
}

template <class T, class ID>
inline
TEST_CONSTEXPR_CXX14 inline
bool
operator!=(min_pointer<T, ID> x, std::nullptr_t)
{
return static_cast<bool>(x);
}

template <class T, class ID>
inline
TEST_CONSTEXPR_CXX14 inline
bool
operator!=(std::nullptr_t, min_pointer<T, ID> x)
{
Expand All @@ -417,20 +417,20 @@ class min_allocator

min_allocator() = default;
template <class U>
min_allocator(min_allocator<U>) {}
TEST_CONSTEXPR_CXX20 min_allocator(min_allocator<U>) {}

pointer allocate(std::ptrdiff_t n)
TEST_CONSTEXPR_CXX20 pointer allocate(std::ptrdiff_t n)
{
return pointer(static_cast<T*>(::operator new(n*sizeof(T))));
return pointer(std::allocator<T>().allocate(n));
}

void deallocate(pointer p, std::ptrdiff_t)
TEST_CONSTEXPR_CXX20 void deallocate(pointer p, std::ptrdiff_t n)
{
return ::operator delete(p.ptr_);
std::allocator<T>().deallocate(p.ptr_, n);
}

friend bool operator==(min_allocator, min_allocator) {return true;}
friend bool operator!=(min_allocator x, min_allocator y) {return !(x == y);}
TEST_CONSTEXPR_CXX20 friend bool operator==(min_allocator, min_allocator) {return true;}
TEST_CONSTEXPR_CXX20 friend bool operator!=(min_allocator x, min_allocator y) {return !(x == y);}
};

template <class T>
Expand All @@ -439,23 +439,23 @@ class explicit_allocator
public:
typedef T value_type;

explicit_allocator() TEST_NOEXCEPT {}
TEST_CONSTEXPR_CXX20 explicit_allocator() TEST_NOEXCEPT {}

template <class U>
explicit explicit_allocator(explicit_allocator<U>) TEST_NOEXCEPT {}
TEST_CONSTEXPR_CXX20 explicit explicit_allocator(explicit_allocator<U>) TEST_NOEXCEPT {}

T* allocate(std::size_t n)
TEST_CONSTEXPR_CXX20 T* allocate(std::size_t n)
{
return static_cast<T*>(::operator new(n*sizeof(T)));
return static_cast<T*>(std::allocator<T>().allocate(n));
}

void deallocate(T* p, std::size_t)
TEST_CONSTEXPR_CXX20 void deallocate(T* p, std::size_t n)
{
return ::operator delete(static_cast<void*>(p));
std::allocator<T>().deallocate(p, n);
}

friend bool operator==(explicit_allocator, explicit_allocator) {return true;}
friend bool operator!=(explicit_allocator x, explicit_allocator y) {return !(x == y);}
TEST_CONSTEXPR_CXX20 friend bool operator==(explicit_allocator, explicit_allocator) {return true;}
TEST_CONSTEXPR_CXX20 friend bool operator!=(explicit_allocator x, explicit_allocator y) {return !(x == y);}
};

#endif // MIN_ALLOCATOR_H

0 comments on commit 255a60c

Please sign in to comment.