Skip to content

Commit 0aafc46

Browse files
lukevalentylukevalenty
authored
Merge pull request #229 from elbeno/use-static-require
2 parents 8224f84 + c8e86c6 commit 0aafc46

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

41 files changed

+1354
-1275
lines changed

‎test/atomic.cpp

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -10,15 +10,15 @@ TEMPLATE_TEST_CASE("atomic size and alignment is the same as the data",
1010
"[atomic]", bool, char, signed char, unsigned char,
1111
short int, unsigned short int, int, unsigned int, long int,
1212
unsigned long int) {
13-
static_assert(sizeof(stdx::atomic<TestType>) == sizeof(TestType));
14-
static_assert(alignof(stdx::atomic<TestType>) == alignof(TestType));
13+
STATIC_REQUIRE(sizeof(stdx::atomic<TestType>) == sizeof(TestType));
14+
STATIC_REQUIRE(alignof(stdx::atomic<TestType>) == alignof(TestType));
1515
}
1616

1717
TEMPLATE_TEST_CASE("atomic is default constructible when data is", "[atomic]",
1818
bool, char, signed char, unsigned char, short int,
1919
unsigned short int, int, unsigned int, long int,
2020
unsigned long int) {
21-
static_assert(std::is_default_constructible_v<stdx::atomic<TestType>>);
21+
STATIC_REQUIRE(std::is_default_constructible_v<stdx::atomic<TestType>>);
2222
}
2323

2424
namespace {
@@ -29,22 +29,22 @@ struct non_dc {
2929

3030
#if __cplusplus >= 202002L
3131
TEST_CASE("atomic is not default constructible when data is not", "[atomic]") {
32-
static_assert(not std::is_default_constructible_v<stdx::atomic<non_dc>>);
32+
STATIC_REQUIRE(not std::is_default_constructible_v<stdx::atomic<non_dc>>);
3333
}
3434
#endif
3535

3636
TEST_CASE("atomic is not copyable or movable", "[atomic]") {
37-
static_assert(not std::is_copy_constructible_v<stdx::atomic<int>>);
38-
static_assert(not std::is_move_constructible_v<stdx::atomic<int>>);
39-
static_assert(not std::is_copy_assignable_v<stdx::atomic<int>>);
40-
static_assert(not std::is_move_assignable_v<stdx::atomic<int>>);
37+
STATIC_REQUIRE(not std::is_copy_constructible_v<stdx::atomic<int>>);
38+
STATIC_REQUIRE(not std::is_move_constructible_v<stdx::atomic<int>>);
39+
STATIC_REQUIRE(not std::is_copy_assignable_v<stdx::atomic<int>>);
40+
STATIC_REQUIRE(not std::is_move_assignable_v<stdx::atomic<int>>);
4141
}
4242

4343
TEMPLATE_TEST_CASE("atomic supports value initialization", "[atomic]", bool,
4444
char, signed char, unsigned char, short int,
4545
unsigned short int, int, unsigned int, long int,
4646
unsigned long int) {
47-
static_assert(std::is_constructible_v<stdx::atomic<TestType>, TestType>);
47+
STATIC_REQUIRE(std::is_constructible_v<stdx::atomic<TestType>, TestType>);
4848
[[maybe_unused]] auto x = stdx::atomic<TestType>{TestType{}};
4949
}
5050

‎test/atomic_bitset.cpp

Lines changed: 26 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -9,34 +9,34 @@
99

1010
TEST_CASE("atomic_bitset with explicit storage element type",
1111
"[atomic_bitset]") {
12-
static_assert(sizeof(stdx::atomic_bitset<1, std::uint8_t>) ==
13-
sizeof(std::uint8_t));
14-
static_assert(sizeof(stdx::atomic_bitset<8, std::uint8_t>) ==
15-
sizeof(std::uint8_t));
16-
static_assert(sizeof(stdx::atomic_bitset<1, std::uint16_t>) ==
17-
sizeof(std::uint16_t));
18-
static_assert(sizeof(stdx::atomic_bitset<16, std::uint16_t>) ==
19-
sizeof(std::uint16_t));
20-
static_assert(sizeof(stdx::atomic_bitset<1, std::uint32_t>) ==
21-
sizeof(std::uint32_t));
22-
static_assert(sizeof(stdx::atomic_bitset<32, std::uint32_t>) ==
23-
sizeof(std::uint32_t));
24-
static_assert(sizeof(stdx::atomic_bitset<1, std::uint64_t>) ==
25-
sizeof(std::uint64_t));
26-
static_assert(sizeof(stdx::atomic_bitset<64, std::uint64_t>) ==
27-
sizeof(std::uint64_t));
12+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<1, std::uint8_t>) ==
13+
sizeof(std::uint8_t));
14+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<8, std::uint8_t>) ==
15+
sizeof(std::uint8_t));
16+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<1, std::uint16_t>) ==
17+
sizeof(std::uint16_t));
18+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<16, std::uint16_t>) ==
19+
sizeof(std::uint16_t));
20+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<1, std::uint32_t>) ==
21+
sizeof(std::uint32_t));
22+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<32, std::uint32_t>) ==
23+
sizeof(std::uint32_t));
24+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<1, std::uint64_t>) ==
25+
sizeof(std::uint64_t));
26+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<64, std::uint64_t>) ==
27+
sizeof(std::uint64_t));
2828
}
2929

3030
TEST_CASE("atomic_bitset with implicit storage element type",
3131
"[atomic_bitset]") {
32-
static_assert(sizeof(stdx::atomic_bitset<1>) == sizeof(std::uint8_t));
33-
static_assert(sizeof(stdx::atomic_bitset<8>) == sizeof(std::uint8_t));
34-
static_assert(sizeof(stdx::atomic_bitset<9>) == sizeof(std::uint16_t));
35-
static_assert(sizeof(stdx::atomic_bitset<16>) == sizeof(std::uint16_t));
36-
static_assert(sizeof(stdx::atomic_bitset<17>) == sizeof(std::uint32_t));
37-
static_assert(sizeof(stdx::atomic_bitset<32>) == sizeof(std::uint32_t));
38-
static_assert(sizeof(stdx::atomic_bitset<33>) == sizeof(std::uint64_t));
39-
static_assert(sizeof(stdx::atomic_bitset<64>) == sizeof(std::uint64_t));
32+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<1>) == sizeof(std::uint8_t));
33+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<8>) == sizeof(std::uint8_t));
34+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<9>) == sizeof(std::uint16_t));
35+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<16>) == sizeof(std::uint16_t));
36+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<17>) == sizeof(std::uint32_t));
37+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<32>) == sizeof(std::uint32_t));
38+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<33>) == sizeof(std::uint64_t));
39+
STATIC_REQUIRE(sizeof(stdx::atomic_bitset<64>) == sizeof(std::uint64_t));
4040
}
4141

4242
TEMPLATE_TEST_CASE("index operation", "[atomic_bitset]", std::uint8_t,
@@ -162,7 +162,7 @@ TEST_CASE("to_natural returns smallest_uint", "[atomic_bitset]") {
162162
auto bs = stdx::atomic_bitset<4>{stdx::all_bits};
163163
auto value = bs.to_natural();
164164
CHECK(value == 0b1111);
165-
static_assert(std::is_same_v<decltype(value), std::uint8_t>);
165+
STATIC_REQUIRE(std::is_same_v<decltype(value), std::uint8_t>);
166166
}
167167

168168
TEMPLATE_TEST_CASE("construct with a string_view", "[atomic_bitset]",
@@ -301,7 +301,7 @@ enum struct Bits : std::uint8_t { ZERO, ONE, TWO, THREE, MAX };
301301

302302
TEST_CASE("use atomic_bitset with enum struct (construct)", "[atomic_bitset]") {
303303
constexpr auto bs = stdx::atomic_bitset<Bits::MAX>{};
304-
static_assert(bs.size() == stdx::to_underlying(Bits::MAX));
304+
STATIC_REQUIRE(bs.size() == stdx::to_underlying(Bits::MAX));
305305
}
306306

307307
TEST_CASE("use atomic_bitset with enum struct (to)", "[atomic_bitset]") {

‎test/atomic_bitset_override.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -8,13 +8,13 @@
88
TEST_CASE("atomic_bitset works with overridden type",
99
"[atomic_bitset_override]") {
1010
auto bs = stdx::atomic_bitset<4>{};
11-
static_assert(sizeof(decltype(bs)) == sizeof(std::uint32_t));
12-
static_assert(alignof(decltype(bs)) == alignof(std::uint32_t));
11+
STATIC_REQUIRE(sizeof(decltype(bs)) == sizeof(std::uint32_t));
12+
STATIC_REQUIRE(alignof(decltype(bs)) == alignof(std::uint32_t));
1313
}
1414

1515
TEST_CASE("to_natural returns smallest_uint", "[atomic_bitset_override]") {
1616
auto bs = stdx::atomic_bitset<4>{stdx::all_bits};
1717
auto value = bs.to_natural();
1818
CHECK(value == 0b1111);
19-
static_assert(std::is_same_v<decltype(value), std::uint8_t>);
19+
STATIC_REQUIRE(std::is_same_v<decltype(value), std::uint8_t>);
2020
}

‎test/atomic_override.cpp

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -8,14 +8,14 @@
88
TEST_CASE("atomic with overridden type is correctly sized/aligned",
99
"[atomic_override]") {
1010
auto bs = stdx::atomic<bool>{};
11-
static_assert(sizeof(decltype(bs)) == sizeof(std::uint32_t));
12-
static_assert(alignof(decltype(bs)) == alignof(std::uint32_t));
11+
STATIC_REQUIRE(sizeof(decltype(bs)) == sizeof(std::uint32_t));
12+
STATIC_REQUIRE(alignof(decltype(bs)) == alignof(std::uint32_t));
1313
}
1414

1515
TEST_CASE("atomic with overridden type presents interface of original type",
1616
"[atomic_override]") {
1717
auto bs = stdx::atomic<bool>{};
18-
static_assert(std::is_same_v<decltype(bs.load()), bool>);
18+
STATIC_REQUIRE(std::is_same_v<decltype(bs.load()), bool>);
1919
}
2020

2121
TEST_CASE("atomic works with overridden type", "[atomic_override]") {
@@ -28,7 +28,7 @@ TEST_CASE("atomic works with overridden type", "[atomic_override]") {
2828
TEST_CASE("atomic config works with partial specialization",
2929
"[atomic_override]") {
3030
using elem_t = ::atomic::atomic_type_t<int *>;
31-
static_assert(std::is_same_v<elem_t, uintptr_t>);
31+
STATIC_REQUIRE(std::is_same_v<elem_t, uintptr_t>);
3232
}
3333

3434
#if __cplusplus >= 202002L
@@ -38,7 +38,7 @@ enum E : std::uint8_t {};
3838

3939
TEST_CASE("atomic config works with enum", "[atomic_override]") {
4040
auto bs = stdx::atomic<E>{};
41-
static_assert(sizeof(decltype(bs)) == sizeof(std::uint32_t));
42-
static_assert(alignof(decltype(bs)) == alignof(std::uint32_t));
41+
STATIC_REQUIRE(sizeof(decltype(bs)) == sizeof(std::uint32_t));
42+
STATIC_REQUIRE(alignof(decltype(bs)) == alignof(std::uint32_t));
4343
}
4444
#endif

‎test/bind.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88

99
TEST_CASE("bind_front basic operation", "[bind]") {
1010
constexpr auto f = stdx::bind_front([](int x, int y) { return x - y; }, 42);
11-
static_assert(f(17) == 25);
11+
STATIC_REQUIRE(f(17) == 25);
1212
}
1313

1414
TEST_CASE("bind_front with rvalue", "[bind]") {
@@ -35,7 +35,7 @@ TEST_CASE("bind_front with lambda template argument", "[bind]") {
3535

3636
TEST_CASE("bind_back basic operation", "[bind]") {
3737
constexpr auto f = stdx::bind_back([](int x, int y) { return x - y; }, 17);
38-
static_assert(f(42) == 25);
38+
STATIC_REQUIRE(f(42) == 25);
3939
}
4040

4141
TEST_CASE("bind_back with rvalue", "[bind]") {

0 commit comments

Comments
 (0)