[libcxx-commits] [libcxx] 255a60c - [libc++] Make some testing utilities constexpr
Louis Dionne via libcxx-commits
libcxx-commits at lists.llvm.org
Wed Sep 2 07:05:52 PDT 2020
Author: Louis Dionne
Date: 2020-09-02T10:05:44-04:00
New Revision: 255a60cdd6fdf564bcca645b67ea2d1fb127c9ce
URL: https://github.com/llvm/llvm-project/commit/255a60cdd6fdf564bcca645b67ea2d1fb127c9ce
DIFF: https://github.com/llvm/llvm-project/commit/255a60cdd6fdf564bcca645b67ea2d1fb127c9ce.diff
LOG: [libc++] Make some testing utilities constexpr
This will be needed in order to test constexpr std::vector.
Added:
Modified:
libcxx/test/support/emplace_constructible.h
libcxx/test/support/min_allocator.h
Removed:
################################################################################
diff --git a/libcxx/test/support/emplace_constructible.h b/libcxx/test/support/emplace_constructible.h
index f0d11ba76c87..42a62fabe656 100644
--- a/libcxx/test/support/emplace_constructible.h
+++ b/libcxx/test/support/emplace_constructible.h
@@ -7,7 +7,7 @@
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;
};
@@ -15,9 +15,9 @@ 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)) {}
};
@@ -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;
@@ -47,15 +47,15 @@ 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;
@@ -63,7 +63,7 @@ struct EmplaceConstructibleMoveableAndAssignable {
return *this;
}
- EmplaceConstructibleMoveableAndAssignable& operator=(T xvalue) {
+ TEST_CONSTEXPR_CXX14 EmplaceConstructibleMoveableAndAssignable& operator=(T xvalue) {
value = std::move(xvalue);
++assigned;
return *this;
diff --git a/libcxx/test/support/min_allocator.h b/libcxx/test/support/min_allocator.h
index fd23fc4383f3..b9f6f6147609 100644
--- a/libcxx/test/support/min_allocator.h
+++ b/libcxx/test/support/min_allocator.h
@@ -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;
};
@@ -241,13 +241,13 @@ 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::ptr
diff _t
diff erence_type;
typedef T& reference;
@@ -255,53 +255,53 @@ class min_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+=(
diff erence_type n) {ptr_ += n; return *this;}
- min_pointer& operator-=(
diff erence_type n) {ptr_ -= n; return *this;}
+ TEST_CONSTEXPR_CXX14 min_pointer& operator+=(
diff erence_type n) {ptr_ += n; return *this;}
+ TEST_CONSTEXPR_CXX14 min_pointer& operator-=(
diff erence_type n) {ptr_ -= n; return *this;}
- min_pointer operator+(
diff erence_type n) const
+ TEST_CONSTEXPR_CXX14 min_pointer operator+(
diff erence_type n) const
{
min_pointer tmp(*this);
tmp += n;
return tmp;
}
- friend min_pointer operator+(
diff erence_type n, min_pointer x)
+ friend TEST_CONSTEXPR_CXX14 min_pointer operator+(
diff erence_type n, min_pointer x)
{
return x + n;
}
- min_pointer operator-(
diff erence_type n) const
+ TEST_CONSTEXPR_CXX14 min_pointer operator-(
diff erence_type n) const
{
min_pointer tmp(*this);
tmp -= n;
return tmp;
}
- friend
diff erence_type operator-(min_pointer x, min_pointer y)
+ friend TEST_CONSTEXPR_CXX14
diff erence_type operator-(min_pointer x, min_pointer y)
{
return x.ptr_ - y.ptr_;
}
- reference operator[](
diff erence_type n) const {return ptr_[n];}
+ TEST_CONSTEXPR_CXX14 reference operator[](
diff erence_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;
};
@@ -311,14 +311,14 @@ 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::ptr
diff _t
diff erence_type;
typedef const T& reference;
@@ -326,58 +326,58 @@ class min_pointer<const T, ID>
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+=(
diff erence_type n) {ptr_ += n; return *this;}
- min_pointer& operator-=(
diff erence_type n) {ptr_ -= n; return *this;}
+ TEST_CONSTEXPR_CXX14 min_pointer& operator+=(
diff erence_type n) {ptr_ += n; return *this;}
+ TEST_CONSTEXPR_CXX14 min_pointer& operator-=(
diff erence_type n) {ptr_ -= n; return *this;}
- min_pointer operator+(
diff erence_type n) const
+ TEST_CONSTEXPR_CXX14 min_pointer operator+(
diff erence_type n) const
{
min_pointer tmp(*this);
tmp += n;
return tmp;
}
- friend min_pointer operator+(
diff erence_type n, min_pointer x)
+ friend TEST_CONSTEXPR_CXX14 min_pointer operator+(
diff erence_type n, min_pointer x)
{
return x + n;
}
- min_pointer operator-(
diff erence_type n) const
+ TEST_CONSTEXPR_CXX14 min_pointer operator-(
diff erence_type n) const
{
min_pointer tmp(*this);
tmp -= n;
return tmp;
}
- friend
diff erence_type operator-(min_pointer x, min_pointer y)
+ friend TEST_CONSTEXPR_CXX14
diff erence_type operator-(min_pointer x, min_pointer y)
{
return x.ptr_ - y.ptr_;
}
- reference operator[](
diff erence_type n) const {return ptr_[n];}
+ TEST_CONSTEXPR_CXX14 reference operator[](
diff erence_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)
{
@@ -385,7 +385,7 @@ operator==(min_pointer<T, ID> x, std::nullptr_t)
}
template <class T, class ID>
-inline
+TEST_CONSTEXPR_CXX14 inline
bool
operator==(std::nullptr_t, min_pointer<T, ID> x)
{
@@ -393,7 +393,7 @@ operator==(std::nullptr_t, min_pointer<T, ID> x)
}
template <class T, class ID>
-inline
+TEST_CONSTEXPR_CXX14 inline
bool
operator!=(min_pointer<T, ID> x, std::nullptr_t)
{
@@ -401,7 +401,7 @@ operator!=(min_pointer<T, ID> x, std::nullptr_t)
}
template <class T, class ID>
-inline
+TEST_CONSTEXPR_CXX14 inline
bool
operator!=(std::nullptr_t, min_pointer<T, ID> x)
{
@@ -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::ptr
diff _t n)
+ TEST_CONSTEXPR_CXX20 pointer allocate(std::ptr
diff _t n)
{
- return pointer(static_cast<T*>(::operator new(n*sizeof(T))));
+ return pointer(std::allocator<T>().allocate(n));
}
- void deallocate(pointer p, std::ptr
diff _t)
+ TEST_CONSTEXPR_CXX20 void deallocate(pointer p, std::ptr
diff _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>
@@ -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
More information about the libcxx-commits
mailing list