Skip to content

Commit

Permalink
Remove STATIC_ASSERT from non-C++14 tests
Browse files Browse the repository at this point in the history
  • Loading branch information
@frederick-vs-ja
frederick-vs-ja committed Apr 14, 2024
1 parent cead952 commit 1f1854d
Show file tree
Hide file tree
Showing 147 changed files with 8,408 additions and 8,433 deletions.
28 changes: 13 additions & 15 deletions tests/std/include/range_algorithm_support.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,8 +14,6 @@

#include <is_permissive.hpp>

#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)

namespace ranges = std::ranges;

template <class>
Expand Down Expand Up @@ -47,7 +45,7 @@ struct boolish {

template <class T, std::size_t N>
struct holder {
STATIC_ASSERT(N < ~std::size_t{0} / sizeof(T));
static_assert(N < ~std::size_t{0} / sizeof(T));

alignas(T) unsigned char space[N * sizeof(T)];

Expand All @@ -69,12 +67,12 @@ namespace test {

template <class T>
void operator&(T&&) {
STATIC_ASSERT(always_false<T>);
static_assert(always_false<T>);
}

template <class T, class U>
void operator,(T&&, U&&) {
STATIC_ASSERT(always_false<T>);
static_assert(always_false<T>);
}

enum class CanDifference : bool { no, yes };
Expand Down Expand Up @@ -103,7 +101,7 @@ namespace test {

template <class T>
[[nodiscard]] constexpr bool to_bool(T const t) noexcept {
STATIC_ASSERT(std::is_enum_v<T> && std::same_as<std::underlying_type_t<T>, bool>);
static_assert(std::is_enum_v<T> && std::same_as<std::underlying_type_t<T>, bool>);
return static_cast<bool>(t);
}

Expand Down Expand Up @@ -492,29 +490,29 @@ namespace test {
}

auto operator--() & {
STATIC_ASSERT(always_false<Category>);
static_assert(always_false<Category>);
}
auto operator--(int) & {
STATIC_ASSERT(always_false<Category>);
static_assert(always_false<Category>);
}

friend void iter_swap(iterator const&, iterator const&)
requires std::is_same_v<Category, output>
{
STATIC_ASSERT(always_false<Category>);
static_assert(always_false<Category>);
}

void operator<(iterator const&) const {
STATIC_ASSERT(always_false<Category>);
static_assert(always_false<Category>);
}
void operator>(iterator const&) const {
STATIC_ASSERT(always_false<Category>);
static_assert(always_false<Category>);
}
void operator<=(iterator const&) const {
STATIC_ASSERT(always_false<Category>);
static_assert(always_false<Category>);
}
void operator>=(iterator const&) const {
STATIC_ASSERT(always_false<Category>);
static_assert(always_false<Category>);
}

// input iterator operations:
Expand Down Expand Up @@ -928,11 +926,11 @@ namespace test {
}

void operator&() const {
STATIC_ASSERT(always_false<Category>);
static_assert(always_false<Category>);
}
template <class T>
friend void operator,(range const&, T&&) {
STATIC_ASSERT(always_false<Category>);
static_assert(always_false<Category>);
}
};
} // namespace test
Expand Down
38 changes: 19 additions & 19 deletions tests/std/tests/GH_002992_unwrappable_iter_sent_pairs/test.compile.pass.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -51,27 +51,27 @@ void test_unwrappable_range() {
constexpr bool is_const_unwrappable = requires(const It& ci) { ci._Unwrapped(); };

if constexpr (is_const_unwrappable) {
STATIC_ASSERT(same_as<decltype(declval<It>()._Unwrapped()), decltype(declval<const It&>()._Unwrapped())>);
static_assert(same_as<decltype(declval<It>()._Unwrapped()), decltype(declval<const It&>()._Unwrapped())>);
}

STATIC_ASSERT(ranges::_Unwrappable_sentinel_for<Se, It>);
static_assert(ranges::_Unwrappable_sentinel_for<Se, It>);

STATIC_ASSERT(same_as<ranges::_Unwrap_iter_t<It, Se>, decltype(declval<It>()._Unwrapped())>);
static_assert(same_as<ranges::_Unwrap_iter_t<It, Se>, decltype(declval<It>()._Unwrapped())>);
if constexpr (is_const_unwrappable) {
STATIC_ASSERT(same_as<ranges::_Unwrap_iter_t<const It&, Se>, decltype(declval<It>()._Unwrapped())>);
static_assert(same_as<ranges::_Unwrap_iter_t<const It&, Se>, decltype(declval<It>()._Unwrapped())>);
}

STATIC_ASSERT(same_as<ranges::_Unwrap_sent_t<Se, It>, decltype(declval<Se>()._Unwrapped())>);
STATIC_ASSERT(same_as<ranges::_Unwrap_sent_t<const Se&, It>, decltype(declval<Se>()._Unwrapped())>);
static_assert(same_as<ranges::_Unwrap_sent_t<Se, It>, decltype(declval<Se>()._Unwrapped())>);
static_assert(same_as<ranges::_Unwrap_sent_t<const Se&, It>, decltype(declval<Se>()._Unwrapped())>);

STATIC_ASSERT(noexcept(ranges::_Unwrap_iter<Se>(declval<It>())) == noexcept(declval<It>()._Unwrapped()));
static_assert(noexcept(ranges::_Unwrap_iter<Se>(declval<It>())) == noexcept(declval<It>()._Unwrapped()));
if constexpr (is_const_unwrappable) {
STATIC_ASSERT(
static_assert(
noexcept(ranges::_Unwrap_iter<Se>(declval<const It&>())) == noexcept(declval<const It&>()._Unwrapped()));
}

STATIC_ASSERT(noexcept(ranges::_Unwrap_sent<It>(declval<Se>())) == noexcept(declval<Se>()._Unwrapped()));
STATIC_ASSERT(
static_assert(noexcept(ranges::_Unwrap_sent<It>(declval<Se>())) == noexcept(declval<Se>()._Unwrapped()));
static_assert(
noexcept(ranges::_Unwrap_sent<It>(declval<const Se&>())) == noexcept(declval<const Se&>()._Unwrapped()));

// instantiate without calling
Expand All @@ -84,18 +84,18 @@ void test_not_unwrappable_range() {
using It = ranges::iterator_t<Rng>;
using Se = ranges::sentinel_t<Rng>;

STATIC_ASSERT(!ranges::_Unwrappable_sentinel_for<Se, It>);
STATIC_ASSERT(same_as<ranges::_Unwrap_iter_t<It, Se>, It>);
STATIC_ASSERT(same_as<ranges::_Unwrap_iter_t<const It&, Se>, It>);
static_assert(!ranges::_Unwrappable_sentinel_for<Se, It>);
static_assert(same_as<ranges::_Unwrap_iter_t<It, Se>, It>);
static_assert(same_as<ranges::_Unwrap_iter_t<const It&, Se>, It>);

STATIC_ASSERT(same_as<ranges::_Unwrap_sent_t<Se, It>, Se>);
STATIC_ASSERT(same_as<ranges::_Unwrap_sent_t<const Se&, It>, Se>);
static_assert(same_as<ranges::_Unwrap_sent_t<Se, It>, Se>);
static_assert(same_as<ranges::_Unwrap_sent_t<const Se&, It>, Se>);

STATIC_ASSERT(noexcept(ranges::_Unwrap_iter<Se>(declval<It>())));
STATIC_ASSERT(noexcept(ranges::_Unwrap_iter<Se>(declval<const It&>())));
static_assert(noexcept(ranges::_Unwrap_iter<Se>(declval<It>())));
static_assert(noexcept(ranges::_Unwrap_iter<Se>(declval<const It&>())));

STATIC_ASSERT(noexcept(ranges::_Unwrap_sent<It>(declval<Se>())));
STATIC_ASSERT(noexcept(ranges::_Unwrap_sent<It>(declval<const Se&>())));
static_assert(noexcept(ranges::_Unwrap_sent<It>(declval<Se>())));
static_assert(noexcept(ranges::_Unwrap_sent<It>(declval<const Se&>())));

// instantiate without calling
void (*p)(Rng&) = test_algorithms<Rng>;
Expand Down
58 changes: 28 additions & 30 deletions tests/std/tests/P0088R3_variant/test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -79,8 +79,6 @@

#include "test_macros.h"

#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)

namespace bad_variant_access {
int run_test() {
static_assert(std::is_base_of<std::exception, std::bad_variant_access>::value,
Expand Down Expand Up @@ -7112,21 +7110,21 @@ namespace msvc {
};
struct __declspec(empty_bases) many_bases : empty<0>, empty<1>, empty<2>, empty<3> {};

STATIC_ASSERT(check_size<bool>);
STATIC_ASSERT(check_size<char>);
STATIC_ASSERT(check_size<unsigned char>);
STATIC_ASSERT(check_size<int>);
STATIC_ASSERT(check_size<unsigned int>);
STATIC_ASSERT(check_size<long>);
STATIC_ASSERT(check_size<long long>);
STATIC_ASSERT(check_size<float>);
STATIC_ASSERT(check_size<double>);
STATIC_ASSERT(check_size<void*>);
STATIC_ASSERT(check_size<empty<0>>);
STATIC_ASSERT(check_size<not_empty>);
STATIC_ASSERT(check_size<many_bases>);

STATIC_ASSERT(check_size<bool, char, short, int, long, long long, float, double, long double, void*, empty<0>,
static_assert(check_size<bool>);
static_assert(check_size<char>);
static_assert(check_size<unsigned char>);
static_assert(check_size<int>);
static_assert(check_size<unsigned int>);
static_assert(check_size<long>);
static_assert(check_size<long long>);
static_assert(check_size<float>);
static_assert(check_size<double>);
static_assert(check_size<void*>);
static_assert(check_size<empty<0>>);
static_assert(check_size<not_empty>);
static_assert(check_size<many_bases>);

static_assert(check_size<bool, char, short, int, long, long long, float, double, long double, void*, empty<0>,
empty<1>, not_empty, many_bases>);
} // namespace size

Expand Down Expand Up @@ -7527,12 +7525,12 @@ namespace msvc {
{
using V = std::variant<int>;
constexpr V v(42);
STATIC_ASSERT(std::visit<int>(obj, v) == 42);
static_assert(std::visit<int>(obj, v) == 42);
}
{
using V = std::variant<short, long, char>;
constexpr V v(42l);
STATIC_ASSERT(std::visit<long>(obj, v) == 42);
static_assert(std::visit<long>(obj, v) == 42);
}
{
using V1 = std::variant<int>;
Expand All @@ -7541,7 +7539,7 @@ namespace msvc {
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
STATIC_ASSERT(std::visit<double>(aobj, v1, v2, v3) == 3.0);
static_assert(std::visit<double>(aobj, v1, v2, v3) == 3.0);
}
{
using V1 = std::variant<int>;
Expand All @@ -7550,7 +7548,7 @@ namespace msvc {
constexpr V1 v1;
constexpr V2 v2(nullptr);
constexpr V3 v3;
STATIC_ASSERT(std::visit<long long>(aobj, v1, v2, v3) == 3LL);
static_assert(std::visit<long long>(aobj, v1, v2, v3) == 3LL);
}
{
using V = std::variant<simple_derived<0>, simple_derived<1>, simple_derived<2>>;
Expand Down Expand Up @@ -7763,7 +7761,7 @@ namespace msvc {

// Verify that `_Meta_at_<_Meta_list<>, size_t(-1)>` has no member named `type`, and that instantiating it doesn't
// consume the entire compiler heap.
STATIC_ASSERT(!has_type<std::_Meta_at_<std::_Meta_list<>, static_cast<std::size_t>(-1)>>);
static_assert(!has_type<std::_Meta_at_<std::_Meta_list<>, static_cast<std::size_t>(-1)>>);

namespace vso468746 {
// Defend against regression of VSO-468746
Expand Down Expand Up @@ -7802,9 +7800,9 @@ namespace msvc {
static constexpr V v1(&intVar);
static constexpr V v2(&doubleVar);

STATIC_ASSERT(v1.index() == 0);
static_assert(v1.index() == 0);
assert(*std::get<0>(v1) == 42);
STATIC_ASSERT(v2.index() == 1);
static_assert(v2.index() == 1);
assert(*std::get<1>(v2) == 3.14);
}
} // namespace vso492097
Expand Down Expand Up @@ -7894,9 +7892,9 @@ namespace msvc {
{
std::variant<const int> oc{};
oc.emplace<0>(0);
STATIC_ASSERT(!std::is_copy_assignable_v<decltype(oc)>);
STATIC_ASSERT(!std::is_move_assignable_v<decltype(oc)>);
STATIC_ASSERT(!std::is_swappable_v<decltype(oc)>);
static_assert(!std::is_copy_assignable_v<decltype(oc)>);
static_assert(!std::is_move_assignable_v<decltype(oc)>);
static_assert(!std::is_swappable_v<decltype(oc)>);

std::variant<volatile int> ov{};
std::variant<volatile int> ov2{};
Expand All @@ -7907,9 +7905,9 @@ namespace msvc {

std::variant<const volatile int> ocv{};
ocv.emplace<0>(0);
STATIC_ASSERT(!std::is_copy_assignable_v<decltype(ocv)>);
STATIC_ASSERT(!std::is_move_assignable_v<decltype(ocv)>);
STATIC_ASSERT(!std::is_swappable_v<decltype(ocv)>);
static_assert(!std::is_copy_assignable_v<decltype(ocv)>);
static_assert(!std::is_move_assignable_v<decltype(ocv)>);
static_assert(!std::is_swappable_v<decltype(ocv)>);
}
{
std::variant<const CvAssignable> oc{};
Expand Down
43 changes: 21 additions & 22 deletions tests/std/tests/P0220R1_any/test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2478,7 +2478,6 @@ int run_test() {
#include <cassert>

#include "test_macros.h"
#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)

namespace nonmembers::swap_ {
int run_test()
Expand Down Expand Up @@ -2713,52 +2712,52 @@ namespace msvc {
constexpr bool IsBig = !(std::_Any_is_small<T> || std::_Any_is_trivial<T>);

void run_test() {
STATIC_ASSERT(!IsBig<small>);
STATIC_ASSERT(!IsBig<void*>);
STATIC_ASSERT(IsBig<large>);
static_assert(!IsBig<small>);
static_assert(!IsBig<void*>);
static_assert(IsBig<large>);
{
// Verify that a type that meets the size requirement *exactly* and has a lesser alignment requirement
// is considered small.
using T = SizeAndAlignType<BufferSize, 1>;
STATIC_ASSERT(sizeof(T) == BufferSize);
STATIC_ASSERT(alignof(T) < BufferAlignment);
STATIC_ASSERT(!IsBig<T>);
static_assert(sizeof(T) == BufferSize);
static_assert(alignof(T) < BufferAlignment);
static_assert(!IsBig<T>);
}
{
// Verify that a type that meets the alignment requirement *exactly* and has a lesser size is considered
// small.
using T = SizeAndAlignType<BufferAlignment, BufferAlignment>;
STATIC_ASSERT(sizeof(T) <= BufferSize);
STATIC_ASSERT(alignof(T) == BufferAlignment);
STATIC_ASSERT(!IsBig<T>);
static_assert(sizeof(T) <= BufferSize);
static_assert(alignof(T) == BufferAlignment);
static_assert(!IsBig<T>);
}
{
// Verify that a type that meets the size and alignment requirements *exactly* is considered small.
using T = SizeAndAlignType<align_to<BufferAlignment>(BufferSize), BufferAlignment>;
STATIC_ASSERT(sizeof(T) <= BufferSize);
STATIC_ASSERT(alignof(T) == BufferAlignment);
STATIC_ASSERT(!IsBig<T>);
static_assert(sizeof(T) <= BufferSize);
static_assert(alignof(T) == BufferAlignment);
static_assert(!IsBig<T>);
}
{
// Verify that a type that meets the alignment requirements but is over-sized is not considered small.
using T = SizeAndAlignType<BufferSize + 1, 1>;
STATIC_ASSERT(sizeof(T) > BufferSize);
STATIC_ASSERT(alignof(T) < BufferAlignment);
STATIC_ASSERT(IsBig<T>);
static_assert(sizeof(T) > BufferSize);
static_assert(alignof(T) < BufferAlignment);
static_assert(IsBig<T>);
}
{
// Verify that a type that meets the size requirements but is over-aligned is not considered small.
using T = SizeAndAlignType<BufferAlignment * 2, BufferAlignment * 2>;
STATIC_ASSERT(alignof(T) >= BufferSize || sizeof(T) < BufferSize);
STATIC_ASSERT(alignof(T) > BufferAlignment);
STATIC_ASSERT(IsBig<T>);
static_assert(alignof(T) >= BufferSize || sizeof(T) < BufferSize);
static_assert(alignof(T) > BufferAlignment);
static_assert(IsBig<T>);
}
{
// Verify that a type that exceeds both the size and alignment requirements is not considered small.
using T = SizeAndAlignType<BufferSize + 1, BufferAlignment * 2>;
STATIC_ASSERT(sizeof(T) > BufferSize);
STATIC_ASSERT(alignof(T) > BufferAlignment);
STATIC_ASSERT(IsBig<T>);
static_assert(sizeof(T) > BufferSize);
static_assert(alignof(T) > BufferAlignment);
static_assert(IsBig<T>);
}
}
} // namespace small_type
Expand Down
Loading

0 comments on commit 1f1854d

Please sign in to comment.