struct ValueIterator {
typedef std::input_iterator_tag iterator_category;
typedef std::size_t value_type;
- typedef ptrdiff_t difference_type;
+ typedef std::ptrdiff_t difference_type;
typedef std::size_t reference;
typedef std::size_t* pointer;
#endif
test<char>();
- test<ptrdiff_t>();
+ test<std::ptrdiff_t>();
test<std::size_t>();
return 0;
struct Data {
std::array<int, N1> input1;
std::array<int, N2> input2;
- ptrdiff_t expected;
+ std::ptrdiff_t expected;
};
template <class Iter1, class Sent1, class Iter2, class Sent2, int N1, int N2>
static_assert(std::is_same_v<std::atomic<intptr_t>, ::atomic_intptr_t>);
static_assert(std::is_same_v<std::atomic<uintptr_t>, ::atomic_uintptr_t>);
static_assert(std::is_same_v<std::atomic<std::size_t>, ::atomic_size_t>);
- static_assert(std::is_same_v<std::atomic<ptrdiff_t>, ::atomic_ptrdiff_t>);
+ static_assert(std::is_same_v<std::atomic<std::ptrdiff_t>, ::atomic_ptrdiff_t>);
static_assert(std::is_same_v<std::atomic<intmax_t>, ::atomic_intmax_t>);
static_assert(std::is_same_v<std::atomic<uintmax_t>, ::atomic_uintmax_t>);
A a; (void)a;
#if TEST_STD_VER >= 17
static_assert((std::is_same_v<typename A::value_type, decltype(a.load())>), "");
- static_assert((std::is_same_v<typename A::difference_type, ptrdiff_t>), "");
+ static_assert((std::is_same_v<typename A::difference_type, std::ptrdiff_t>), "");
#endif
}
};
test<intptr_t> ();
test<uintptr_t> ();
test<std::size_t> ();
- test<ptrdiff_t> ();
+ test<std::ptrdiff_t> ();
test<intmax_t> ();
test<uintmax_t> ();
#include "test_macros.h"
#include "min_allocator.h"
-typedef ptrdiff_t T;
+typedef std::ptrdiff_t T;
const T t1[] = {0, 1, 2, 3, 4, 5, 6, 7};
const T t2[] = {10, 11, 12, 13, 14, 15};
-const ptrdiff_t size_t1 = std::end(t1) - std::begin(t1);
-const ptrdiff_t size_t2 = std::end(t2) - std::begin(t2);
+const std::ptrdiff_t size_t1 = std::end(t1) - std::begin(t1);
+const std::ptrdiff_t size_t2 = std::end(t2) - std::begin(t2);
template <class C>
void
-testd(const C& c, ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)
+testd(const C& c, std::ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)
{
typename C::const_iterator i = c.begin();
- ptrdiff_t n1 = 0;
+ std::ptrdiff_t n1 = 0;
for (; n1 < p; ++n1, ++i)
assert(*i == t1[n1]);
- for (ptrdiff_t n2 = f; n2 < l-1; ++n2, ++i)
+ for (std::ptrdiff_t n2 = f; n2 < l-1; ++n2, ++i)
assert(*i == t2[n2]);
for (; n1 < size_t1; ++n1, ++i)
assert(*i == t1[n1]);
template <class C>
void
-tests(const C& c, ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)
+tests(const C& c, std::ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)
{
typename C::const_iterator i = c.begin();
- ptrdiff_t n = 0;
- ptrdiff_t d = l > f+1 ? l-1-f : 0;
+ std::ptrdiff_t n = 0;
+ std::ptrdiff_t d = l > f+1 ? l-1-f : 0;
if (d == 0 || p == f)
{
for (n = 0; n < size_t1; ++n, ++i)
{
// splicing different containers
typedef std::forward_list<T> C;
- for (ptrdiff_t f = 0; f <= size_t2+1; ++f)
+ for (std::ptrdiff_t f = 0; f <= size_t2+1; ++f)
{
- for (ptrdiff_t l = f; l <= size_t2+1; ++l)
+ for (std::ptrdiff_t l = f; l <= size_t2+1; ++l)
{
- for (ptrdiff_t p = 0; p <= size_t1; ++p)
+ for (std::ptrdiff_t p = 0; p <= size_t1; ++p)
{
C c1(std::begin(t1), std::end(t1));
C c2(std::begin(t2), std::end(t2));
}
// splicing within same container
- for (ptrdiff_t f = 0; f <= size_t1+1; ++f)
+ for (std::ptrdiff_t f = 0; f <= size_t1+1; ++f)
{
- for (ptrdiff_t l = f; l <= size_t1; ++l)
+ for (std::ptrdiff_t l = f; l <= size_t1; ++l)
{
- for (ptrdiff_t p = 0; p <= f; ++p)
+ for (std::ptrdiff_t p = 0; p <= f; ++p)
{
C c1(std::begin(t1), std::end(t1));
std::next(c1.cbefore_begin(), f), std::next(c1.cbefore_begin(), l));
tests(c1, p, f, l);
}
- for (ptrdiff_t p = l; p <= size_t1; ++p)
+ for (std::ptrdiff_t p = l; p <= size_t1; ++p)
{
C c1(std::begin(t1), std::end(t1));
{
// splicing different containers
typedef std::forward_list<T, min_allocator<T>> C;
- for (ptrdiff_t f = 0; f <= size_t2+1; ++f)
+ for (std::ptrdiff_t f = 0; f <= size_t2+1; ++f)
{
- for (ptrdiff_t l = f; l <= size_t2+1; ++l)
+ for (std::ptrdiff_t l = f; l <= size_t2+1; ++l)
{
- for (ptrdiff_t p = 0; p <= size_t1; ++p)
+ for (std::ptrdiff_t p = 0; p <= size_t1; ++p)
{
C c1(std::begin(t1), std::end(t1));
C c2(std::begin(t2), std::end(t2));
}
// splicing within same container
- for (ptrdiff_t f = 0; f <= size_t1+1; ++f)
+ for (std::ptrdiff_t f = 0; f <= size_t1+1; ++f)
{
- for (ptrdiff_t l = f; l <= size_t1; ++l)
+ for (std::ptrdiff_t l = f; l <= size_t1; ++l)
{
- for (ptrdiff_t p = 0; p <= f; ++p)
+ for (std::ptrdiff_t p = 0; p <= f; ++p)
{
C c1(std::begin(t1), std::end(t1));
std::next(c1.cbefore_begin(), f), std::next(c1.cbefore_begin(), l));
tests(c1, p, f, l);
}
- for (ptrdiff_t p = l; p <= size_t1; ++p)
+ for (std::ptrdiff_t p = l; p <= size_t1; ++p)
{
C c1(std::begin(t1), std::end(t1));
test_const_container ( sv );
static constexpr int arrA [] { 1, 2, 3 };
- ASSERT_SAME_TYPE(ptrdiff_t, decltype(std::ssize(arrA)));
+ ASSERT_SAME_TYPE(std::ptrdiff_t, decltype(std::ssize(arrA)));
static_assert( std::is_signed_v<decltype(std::ssize(arrA))>, "");
test_const_array ( arrA );
struct MaybeNoexceptMove {
int x;
using value_type = int;
- using difference_type = ptrdiff_t;
+ using difference_type = std::ptrdiff_t;
constexpr friend value_type&& iter_move(MaybeNoexceptMove) noexcept(IsNoexcept) {
return std::move(global);
template <bool IsNoexcept>
struct MaybeNoexceptSwap {
using value_type = int;
- using difference_type = ptrdiff_t;
+ using difference_type = std::ptrdiff_t;
constexpr friend void iter_swap(MaybeNoexceptSwap, MaybeNoexceptSwap) noexcept(IsNoexcept) {
}
struct IterBase {
using iterator_category = std::bidirectional_iterator_tag;
using value_type = int;
- using difference_type = ptrdiff_t;
+ using difference_type = std::ptrdiff_t;
using pointer = int*;
using reference = int&;
{
struct ThrowingCopyNoexceptDecrement {
using value_type = int;
- using difference_type = ptrdiff_t;
+ using difference_type = std::ptrdiff_t;
ThrowingCopyNoexceptDecrement();
ThrowingCopyNoexceptDecrement(const ThrowingCopyNoexceptDecrement&);
{
struct NoexceptCopyThrowingDecrement {
using value_type = int;
- using difference_type = ptrdiff_t;
+ using difference_type = std::ptrdiff_t;
NoexceptCopyThrowingDecrement();
NoexceptCopyThrowingDecrement(const NoexceptCopyThrowingDecrement&) noexcept;
{
struct NoexceptCopyAndDecrement {
using value_type = int;
- using difference_type = ptrdiff_t;
+ using difference_type = std::ptrdiff_t;
NoexceptCopyAndDecrement();
NoexceptCopyAndDecrement(const NoexceptCopyAndDecrement&) noexcept;
{
struct ThrowingCopyNoexceptDecrement {
using value_type = int;
- using difference_type = ptrdiff_t;
+ using difference_type = std::ptrdiff_t;
ThrowingCopyNoexceptDecrement();
ThrowingCopyNoexceptDecrement(const ThrowingCopyNoexceptDecrement&);
{
struct NoexceptCopyThrowingDecrement {
using value_type = int;
- using difference_type = ptrdiff_t;
+ using difference_type = std::ptrdiff_t;
NoexceptCopyThrowingDecrement();
NoexceptCopyThrowingDecrement(const NoexceptCopyThrowingDecrement&) noexcept;
{
struct NoexceptCopyAndDecrement {
using value_type = int;
- using difference_type = ptrdiff_t;
+ using difference_type = std::ptrdiff_t;
NoexceptCopyAndDecrement();
NoexceptCopyAndDecrement(const NoexceptCopyAndDecrement&) noexcept;
static_assert(alignof(std::max_align_t) >= alignof(void*), "");
#if TEST_STD_VER > 14
static_assert(alignof(std::max_align_t) <= __STDCPP_DEFAULT_NEW_ALIGNMENT__,
- "max_align_t alignment should be no larger than operator new's alignment");
+ "std::max_align_t alignment should be no larger than operator new's alignment");
#endif
static_assert(!std::is_invocable_v<L, std::int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>);
- static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+ static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, std::int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>);
- static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+ static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, std::int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>);
- static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+ static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, std::int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>);
- static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+ static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, std::int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>);
- static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+ static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, std::int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>);
- static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+ static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, std::int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>);
- static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+ static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, std::int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>);
- static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+ static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, std::int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>);
- static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+ static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, std::int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>);
- static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+ static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, std::int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>);
- static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+ static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>);
#endif
// int_test<char>();
- signed_test<ptrdiff_t>();
+ signed_test<std::ptrdiff_t>();
unsigned_test<std::size_t>();
return 0;
// This gets converted to ptrdiff_t because it's wider.
ShortUnsignedReturnType c;
assert(std::ranges::ssize(c) == 42);
- ASSERT_SAME_TYPE(decltype(std::ranges::ssize(c)), ptrdiff_t);
+ ASSERT_SAME_TYPE(decltype(std::ranges::ssize(c)), std::ptrdiff_t);
return true;
}
struct AlmostInputIterator {
using value_type = char;
- using difference_type = ptrdiff_t;
+ using difference_type = std::ptrdiff_t;
using iterator_concept = int;
constexpr const char& operator*() const;
template <bool IsNoexcept = false>
struct MaybeNoexceptIterator {
using value_type = int;
- using difference_type = ptrdiff_t;
+ using difference_type = std::ptrdiff_t;
value_type* ptr_ = nullptr;
int* iter_move_invocations_ = nullptr;
template <bool IsNoexcept = false>
struct MaybeNoexceptIterator {
using value_type = int;
- using difference_type = ptrdiff_t;
+ using difference_type = std::ptrdiff_t;
value_type* ptr_ = nullptr;
int* iter_swap_invocations_ = nullptr;
static_assert((std::is_same<typename S::traits_type, Traits>::value), "");
static_assert((std::is_same<typename S::value_type, typename Traits::char_type>::value), "");
static_assert((std::is_same<typename S::size_type, std::size_t>::value), "");
- static_assert((std::is_same<typename S::difference_type, ptrdiff_t>::value), "");
+ static_assert((std::is_same<typename S::difference_type, std::ptrdiff_t>::value), "");
static_assert((std::is_same<typename S::reference, typename S::value_type&>::value), "");
static_assert((std::is_same<typename S::const_reference, const typename S::value_type&>::value), "");
static_assert((std::is_same<typename S::pointer, typename S::value_type*>::value), "");
static_assert(std::counting_semaphore<>::max() >= 1, "");
static_assert(std::counting_semaphore<1>::max() >= 1, "");
static_assert(std::counting_semaphore<std::numeric_limits<int>::max()>::max() >= std::numeric_limits<int>::max(), "");
- static_assert(std::counting_semaphore<std::numeric_limits<ptrdiff_t>::max()>::max() == std::numeric_limits<ptrdiff_t>::max(), "");
+ static_assert(std::counting_semaphore<std::numeric_limits<std::ptrdiff_t>::max()>::max() == std::numeric_limits<ptrdiff_t>::max(), "");
return 0;
}
std::size_t n = expected.size();
std::basic_string<CharT> out(n, CharT(' '));
std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...);
- assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+ assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
assert(result.out == out.end());
assert(out == expected);
}
std::basic_string<CharT> out(n, CharT(' '));
std::format_to_n_result result =
std::format_to_n(out.begin(), n, std::locale(), fmt, std::forward<Args>(args)...);
- assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+ assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
assert(result.out == out.end());
assert(out == expected);
}
#endif // TEST_HAS_NO_LOCALIZATION
{
- ptrdiff_t n = 0;
+ std::ptrdiff_t n = 0;
std::basic_string<CharT> out;
std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...);
- assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+ assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
assert(result.out == out.end());
assert(out.empty());
}
{
- ptrdiff_t n = expected.size() / 2;
+ std::ptrdiff_t n = expected.size() / 2;
std::basic_string<CharT> out(n, CharT(' '));
std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...);
- assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+ assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
assert(result.out == out.end());
assert(out == expected.substr(0, n));
}
std::size_t n = expected.size();
std::basic_string<CharT> out(n, CharT(' '));
std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...);
- assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+ assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
assert(result.out == out.end());
assert(out == expected);
}
std::basic_string<CharT> out(n, CharT(' '));
std::format_to_n_result result =
std::format_to_n(out.begin(), n, std::locale(), fmt, std::forward<Args>(args)...);
- assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+ assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
assert(result.out == out.end());
assert(out == expected);
}
#endif // TEST_HAS_NO_LOCALIZATION
{
- ptrdiff_t n = 0;
+ std::ptrdiff_t n = 0;
std::basic_string<CharT> out;
std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...);
- assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+ assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
assert(result.out == out.end());
assert(out.empty());
}
{
- ptrdiff_t n = expected.size() / 2;
+ std::ptrdiff_t n = expected.size() / 2;
std::basic_string<CharT> out(n, CharT(' '));
std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...);
- assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+ assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
assert(result.out == out.end());
assert(out == expected.substr(0, n));
}
struct iterator {
using iterator_concept = std::input_iterator_tag;
using value_type = recursive_range;
- using difference_type = ptrdiff_t;
+ using difference_type = std::ptrdiff_t;
using reference = recursive_range;
reference operator*() const;
class SizedSentinel {
public:
constexpr bool operator==(int*) const;
- friend constexpr ptrdiff_t operator-(const SizedSentinel&, int*);
- friend constexpr ptrdiff_t operator-(int*, const SizedSentinel&);
+ friend constexpr std::ptrdiff_t operator-(const SizedSentinel&, int*);
+ friend constexpr std::ptrdiff_t operator-(int*, const SizedSentinel&);
};
static_assert(std::sized_sentinel_for<SizedSentinel, Iterator>);
auto ptr = static_cast<char*>(allocation);
std::fill(ptr, ptr + 13, '0');
assert(last_size == 13);
- assert(last_alignment == alignof(max_align_t));
+ assert(last_alignment == alignof(std::max_align_t));
allocator.deallocate_bytes(allocation, 13);
assert(last_size == 13);
- assert(last_alignment == alignof(max_align_t));
+ assert(last_alignment == alignof(std::max_align_t));
}
{
void* allocation = allocator.allocate_bytes(13, 64);
template <typename T>
struct ThrowingIterator {
typedef std::bidirectional_iterator_tag iterator_category;
- typedef ptrdiff_t difference_type;
+ typedef std::ptrdiff_t difference_type;
typedef const T value_type;
typedef const T * pointer;
typedef const T & reference;
template <typename T>
struct NonThrowingIterator {
typedef std::bidirectional_iterator_tag iterator_category;
- typedef ptrdiff_t difference_type;
+ typedef std::ptrdiff_t difference_type;
typedef const T value_type;
typedef const T * pointer;
typedef const T & reference;
public:
using value_type = int;
using reference = int&;
- using difference_type = ptrdiff_t;
+ using difference_type = std::ptrdiff_t;
private:
value_type* ptr_ = nullptr;