Scarfski/entt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test: full review of entt::any tests

Browse Source
This commit is contained in:
Michele Caini
2024-02-02 11:20:49 +01:00
parent a69e0eb661
commit df6da5c208
1 changed files with 131 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

257
test/entt/core/any.cpp
View File

@@ -1,4 +1,5 @@
#include <algorithm>
#include <array>
#include <cstdint>
#include <cstring>
#include <iterator>
@@ -16,50 +17,37 @@
#include "../common/non_comparable.h"
#include "../common/non_movable.h"
struct empty {
empty() = default;
template<std::size_t Len>
struct tracker {
tracker(int &cnt)
: counter{&cnt} {}
empty(const empty &) = default;
empty &operator=(const empty &) = delete;
tracker(const tracker &) = default;
tracker &operator=(const tracker &) = delete;
~empty() {
++counter;
~tracker() {
++(*counter);
}
inline static int counter = 0; // NOLINT
private:
std::array<std::byte, Len> buffer{};
int *counter{};
};
struct fat {
fat(double v1, double v2, double v3, double v4)
: value{v1, v2, v3, v4} {}
fat(const fat &) = default;
fat &operator=(const fat &) = default;
~fat() {
++counter;
}
[[nodiscard]] bool operator==(const fat &other) const {
return std::equal(std::begin(value), std::end(value), std::begin(other.value), std::end(other.value));
return (value == other.value);
}
inline static int counter{0}; // NOLINT
double value[4]; // NOLINT
std::array<double, 4u> value{};
};
struct alignas(64u) over_aligned {};
struct Any: ::testing::Test {
void SetUp() override {
fat::counter = 0;
empty::counter = 0;
}
};
using AnyDeathTest = Any;
TEST_F(Any, SBO) {
TEST(Any, SBO) {
entt::any any{'c'};
ASSERT_TRUE(any);
@@ -69,7 +57,7 @@ TEST_F(Any, SBO) {
ASSERT_EQ(entt::any_cast<char>(any), 'c');
}
TEST_F(Any, NoSBO) {
TEST(Any, NoSBO) {
const fat instance{.1, .2, .3, .4};
entt::any any{instance};
@@ -80,7 +68,7 @@ TEST_F(Any, NoSBO) {
ASSERT_EQ(entt::any_cast<fat>(any), instance);
}
TEST_F(Any, Empty) {
TEST(Any, Empty) {
entt::any any{};
ASSERT_FALSE(any);
@@ -90,7 +78,7 @@ TEST_F(Any, Empty) {
ASSERT_EQ(any.data(), nullptr);
}
TEST_F(Any, SBOInPlaceTypeConstruction) {
TEST(Any, SBOInPlaceTypeConstruction) {
entt::any any{std::in_place_type<int>, 2};
ASSERT_TRUE(any);
@@ -108,7 +96,7 @@ TEST_F(Any, SBOInPlaceTypeConstruction) {
ASSERT_EQ(other.data(), any.data());
}
TEST_F(Any, SBOAsRefConstruction) {
TEST(Any, SBOAsRefConstruction) {
int value = 2;
entt::any any{entt::forward_as_any(value)};
@@ -144,7 +132,7 @@ TEST_F(Any, SBOAsRefConstruction) {
ASSERT_EQ(other.data(), any.data());
}
TEST_F(Any, SBOAsConstRefConstruction) {
TEST(Any, SBOAsConstRefConstruction) {
const int value = 2;
entt::any any{entt::forward_as_any(value)};
@@ -180,7 +168,7 @@ TEST_F(Any, SBOAsConstRefConstruction) {
ASSERT_EQ(other.data(), any.data());
}
TEST_F(Any, SBOCopyConstruction) {
TEST(Any, SBOCopyConstruction) {
const entt::any any{2};
entt::any other{any};
@@ -192,7 +180,7 @@ TEST_F(Any, SBOCopyConstruction) {
ASSERT_EQ(entt::any_cast<int>(other), 2);
}
TEST_F(Any, SBOCopyAssignment) {
TEST(Any, SBOCopyAssignment) {
const entt::any any{2};
entt::any other{3};
@@ -206,7 +194,7 @@ TEST_F(Any, SBOCopyAssignment) {
ASSERT_EQ(entt::any_cast<int>(other), 2);
}
TEST_F(Any, SBOMoveConstruction) {
TEST(Any, SBOMoveConstruction) {
entt::any any{2};
entt::any other{std::move(any)};
@@ -220,7 +208,7 @@ TEST_F(Any, SBOMoveConstruction) {
ASSERT_EQ(entt::any_cast<int>(other), 2);
}
TEST_F(Any, SBOMoveAssignment) {
TEST(Any, SBOMoveAssignment) {
entt::any any{2};
entt::any other{3};
@@ -235,7 +223,7 @@ TEST_F(Any, SBOMoveAssignment) {
ASSERT_EQ(entt::any_cast<int>(other), 2);
}
TEST_F(Any, SBODirectAssignment) {
TEST(Any, SBODirectAssignment) {
entt::any any{};
any = 2;
@@ -246,7 +234,7 @@ TEST_F(Any, SBODirectAssignment) {
ASSERT_EQ(entt::any_cast<int>(any), 2);
}
TEST_F(Any, SBOAssignValue) {
TEST(Any, SBOAssignValue) {
entt::any any{2};
const entt::any other{3};
const entt::any invalid{'c'};
@@ -259,7 +247,7 @@ TEST_F(Any, SBOAssignValue) {
ASSERT_EQ(entt::any_cast<int>(any), 3);
}
TEST_F(Any, SBOAsRefAssignValue) {
TEST(Any, SBOAsRefAssignValue) {
int value = 2;
entt::any any{entt::forward_as_any(value)};
const entt::any other{3};
@@ -274,7 +262,7 @@ TEST_F(Any, SBOAsRefAssignValue) {
ASSERT_EQ(value, 3);
}
TEST_F(Any, SBOAsConstRefAssignValue) {
TEST(Any, SBOAsConstRefAssignValue) {
const int value = 2;
entt::any any{entt::forward_as_any(value)};
const entt::any other{3};
@@ -289,7 +277,7 @@ TEST_F(Any, SBOAsConstRefAssignValue) {
ASSERT_EQ(value, 2);
}
TEST_F(Any, SBOTransferValue) {
TEST(Any, SBOTransferValue) {
entt::any any{2};
ASSERT_TRUE(any);
@@ -300,7 +288,7 @@ TEST_F(Any, SBOTransferValue) {
ASSERT_EQ(entt::any_cast<int>(any), 3);
}
TEST_F(Any, SBOTransferConstValue) {
TEST(Any, SBOTransferConstValue) {
const int value = 3;
entt::any any{2};
@@ -311,7 +299,7 @@ TEST_F(Any, SBOTransferConstValue) {
ASSERT_EQ(entt::any_cast<int>(any), 3);
}
TEST_F(Any, SBOAsRefTransferValue) {
TEST(Any, SBOAsRefTransferValue) {
int value = 2;
entt::any any{entt::forward_as_any(value)};
@@ -324,7 +312,7 @@ TEST_F(Any, SBOAsRefTransferValue) {
ASSERT_EQ(value, 3);
}
TEST_F(Any, SBOAsConstRefTransferValue) {
TEST(Any, SBOAsConstRefTransferValue) {
const int value = 2;
entt::any any{entt::forward_as_any(value)};
@@ -337,7 +325,7 @@ TEST_F(Any, SBOAsConstRefTransferValue) {
ASSERT_EQ(value, 2);
}
TEST_F(Any, NoSBOInPlaceTypeConstruction) {
TEST(Any, NoSBOInPlaceTypeConstruction) {
const fat instance{.1, .2, .3, .4};
entt::any any{std::in_place_type<fat>, instance};
@@ -356,7 +344,7 @@ TEST_F(Any, NoSBOInPlaceTypeConstruction) {
ASSERT_EQ(other.data(), any.data());
}
TEST_F(Any, NoSBOAsRefConstruction) {
TEST(Any, NoSBOAsRefConstruction) {
fat instance{.1, .2, .3, .4};
entt::any any{entt::forward_as_any(instance)};
@@ -393,7 +381,7 @@ TEST_F(Any, NoSBOAsRefConstruction) {
ASSERT_EQ(other.data(), any.data());
}
TEST_F(Any, NoSBOAsConstRefConstruction) {
TEST(Any, NoSBOAsConstRefConstruction) {
const fat instance{.1, .2, .3, .4};
entt::any any{entt::forward_as_any(instance)};
@@ -429,7 +417,7 @@ TEST_F(Any, NoSBOAsConstRefConstruction) {
ASSERT_EQ(other.data(), any.data());
}
TEST_F(Any, NoSBOCopyConstruction) {
TEST(Any, NoSBOCopyConstruction) {
const fat instance{.1, .2, .3, .4};
const entt::any any{instance};
entt::any other{any};
@@ -442,7 +430,7 @@ TEST_F(Any, NoSBOCopyConstruction) {
ASSERT_EQ(entt::any_cast<fat>(other), instance);
}
TEST_F(Any, NoSBOCopyAssignment) {
TEST(Any, NoSBOCopyAssignment) {
const fat instance{.1, .2, .3, .4};
const entt::any any{instance};
entt::any other{3};
@@ -457,7 +445,7 @@ TEST_F(Any, NoSBOCopyAssignment) {
ASSERT_EQ(entt::any_cast<fat>(other), instance);
}
TEST_F(Any, NoSBOMoveConstruction) {
TEST(Any, NoSBOMoveConstruction) {
const fat instance{.1, .2, .3, .4};
entt::any any{instance};
entt::any other{std::move(any)};
@@ -472,7 +460,7 @@ TEST_F(Any, NoSBOMoveConstruction) {
ASSERT_EQ(entt::any_cast<fat>(other), instance);
}
TEST_F(Any, NoSBOMoveAssignment) {
TEST(Any, NoSBOMoveAssignment) {
const fat instance{.1, .2, .3, .4};
entt::any any{instance};
entt::any other{3};
@@ -488,7 +476,7 @@ TEST_F(Any, NoSBOMoveAssignment) {
ASSERT_EQ(entt::any_cast<fat>(other), instance);
}
TEST_F(Any, NoSBODirectAssignment) {
TEST(Any, NoSBODirectAssignment) {
const fat instance{.1, .2, .3, .4};
entt::any any{};
any = instance;
@@ -500,7 +488,7 @@ TEST_F(Any, NoSBODirectAssignment) {
ASSERT_EQ(entt::any_cast<fat>(any), instance);
}
TEST_F(Any, NoSBOAssignValue) {
TEST(Any, NoSBOAssignValue) {
entt::any any{fat{.1, .2, .3, .4}};
const entt::any other{fat{.0, .1, .2, .3}};
const entt::any invalid{'c'};
@@ -516,7 +504,7 @@ TEST_F(Any, NoSBOAssignValue) {
ASSERT_EQ(addr, std::as_const(any).data());
}
TEST_F(Any, NoSBOAsRefAssignValue) {
TEST(Any, NoSBOAsRefAssignValue) {
fat instance{.1, .2, .3, .4};
entt::any any{entt::forward_as_any(instance)};
const entt::any other{fat{.0, .1, .2, .3}};
@@ -531,7 +519,7 @@ TEST_F(Any, NoSBOAsRefAssignValue) {
ASSERT_EQ(instance, (fat{.0, .1, .2, .3}));
}
TEST_F(Any, NoSBOAsConstRefAssignValue) {
TEST(Any, NoSBOAsConstRefAssignValue) {
const fat instance{.1, .2, .3, .4};
entt::any any{entt::forward_as_any(instance)};
const entt::any other{fat{.0, .1, .2, .3}};
@@ -546,7 +534,7 @@ TEST_F(Any, NoSBOAsConstRefAssignValue) {
ASSERT_EQ(instance, (fat{.1, .2, .3, .4}));
}
TEST_F(Any, NoSBOTransferValue) {
TEST(Any, NoSBOTransferValue) {
entt::any any{fat{.1, .2, .3, .4}};
const void *addr = std::as_const(any).data();
@@ -560,7 +548,7 @@ TEST_F(Any, NoSBOTransferValue) {
ASSERT_EQ(addr, std::as_const(any).data());
}
TEST_F(Any, NoSBOTransferConstValue) {
TEST(Any, NoSBOTransferConstValue) {
const fat instance{.0, .1, .2, .3};
entt::any any{fat{.1, .2, .3, .4}};
@@ -574,7 +562,7 @@ TEST_F(Any, NoSBOTransferConstValue) {
ASSERT_EQ(addr, std::as_const(any).data());
}
TEST_F(Any, NoSBOAsRefTransferValue) {
TEST(Any, NoSBOAsRefTransferValue) {
fat instance{.1, .2, .3, .4};
entt::any any{entt::forward_as_any(instance)};
@@ -590,7 +578,7 @@ TEST_F(Any, NoSBOAsRefTransferValue) {
ASSERT_EQ(addr, std::as_const(any).data());
}
TEST_F(Any, NoSBOAsConstRefTransferValue) {
TEST(Any, NoSBOAsConstRefTransferValue) {
const fat instance{.1, .2, .3, .4};
entt::any any{entt::forward_as_any(instance)};
@@ -606,7 +594,7 @@ TEST_F(Any, NoSBOAsConstRefTransferValue) {
ASSERT_EQ(addr, std::as_const(any).data());
}
TEST_F(Any, VoidInPlaceTypeConstruction) {
TEST(Any, VoidInPlaceTypeConstruction) {
entt::any any{std::in_place_type<void>};
ASSERT_FALSE(any);
@@ -615,7 +603,7 @@ TEST_F(Any, VoidInPlaceTypeConstruction) {
ASSERT_EQ(entt::any_cast<int>(&any), nullptr);
}
TEST_F(Any, VoidCopyConstruction) {
TEST(Any, VoidCopyConstruction) {
entt::any any{std::in_place_type<void>};
entt::any other{any};
@@ -627,7 +615,7 @@ TEST_F(Any, VoidCopyConstruction) {
ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
}
TEST_F(Any, VoidCopyAssignment) {
TEST(Any, VoidCopyAssignment) {
entt::any any{std::in_place_type<void>};
entt::any other{2};
@@ -641,7 +629,7 @@ TEST_F(Any, VoidCopyAssignment) {
ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
}
TEST_F(Any, VoidMoveConstruction) {
TEST(Any, VoidMoveConstruction) {
entt::any any{std::in_place_type<void>};
entt::any other{std::move(any)};
@@ -654,7 +642,7 @@ TEST_F(Any, VoidMoveConstruction) {
ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
}
TEST_F(Any, VoidMoveAssignment) {
TEST(Any, VoidMoveAssignment) {
entt::any any{std::in_place_type<void>};
entt::any other{2};
@@ -668,7 +656,7 @@ TEST_F(Any, VoidMoveAssignment) {
ASSERT_EQ(entt::any_cast<double>(&other), nullptr);
}
TEST_F(Any, SBOMoveValidButUnspecifiedState) {
TEST(Any, SBOMoveValidButUnspecifiedState) {
entt::any any{2};
entt::any other{std::move(any)};
const entt::any valid = std::move(other);
@@ -681,7 +669,7 @@ TEST_F(Any, SBOMoveValidButUnspecifiedState) {
ASSERT_TRUE(valid);
}
TEST_F(Any, NoSBOMoveValidButUnspecifiedState) {
TEST(Any, NoSBOMoveValidButUnspecifiedState) {
const fat instance{.1, .2, .3, .4};
entt::any any{instance};
entt::any other{std::move(any)};
@@ -695,7 +683,7 @@ TEST_F(Any, NoSBOMoveValidButUnspecifiedState) {
ASSERT_TRUE(valid);
}
TEST_F(Any, VoidMoveValidButUnspecifiedState) {
TEST(Any, VoidMoveValidButUnspecifiedState) {
entt::any any{std::in_place_type<void>};
entt::any other{std::move(any)};
const entt::any valid = std::move(other);
@@ -708,36 +696,44 @@ TEST_F(Any, VoidMoveValidButUnspecifiedState) {
ASSERT_FALSE(valid);
}
TEST_F(Any, SBODestruction) {
TEST(Any, SBODestruction) {
using tracker_type = tracker<0u>;
int counter{};
{
entt::any any{std::in_place_type<empty>};
any.emplace<empty>();
any = empty{};
entt::any any{std::in_place_type<tracker_type>, counter};
any.emplace<tracker_type>(counter);
any = tracker_type{counter};
entt::any other{std::move(any)};
any = std::move(other);
}
ASSERT_EQ(empty::counter, 6);
ASSERT_EQ(counter, 6);
}
TEST_F(Any, NoSBODestruction) {
TEST(Any, NoSBODestruction) {
using tracker_type = tracker<entt::any::length>;
int counter{};
{
entt::any any{std::in_place_type<fat>, 1., 2., 3., 4.};
any.emplace<fat>(1., 2., 3., 4.);
any = fat{1., 2., 3., 4.};
entt::any any{std::in_place_type<tracker_type>, counter};
any.emplace<tracker_type>(counter);
any = tracker_type{counter};
entt::any other{std::move(any)};
any = std::move(other);
}
ASSERT_EQ(fat::counter, 4);
ASSERT_EQ(counter, 4);
}
TEST_F(Any, VoidDestruction) {
TEST(Any, VoidDestruction) {
// just let asan tell us if everything is ok here
[[maybe_unused]] const entt::any any{std::in_place_type<void>};
}
TEST_F(Any, Emplace) {
TEST(Any, Emplace) {
entt::any any{};
any.emplace<int>(2);
@@ -748,7 +744,7 @@ TEST_F(Any, Emplace) {
ASSERT_EQ(entt::any_cast<int>(any), 2);
}
TEST_F(Any, EmplaceVoid) {
TEST(Any, EmplaceVoid) {
entt::any any{};
any.emplace<void>();
@@ -757,7 +753,7 @@ TEST_F(Any, EmplaceVoid) {
ASSERT_EQ(any.type(), entt::type_id<void>());
}
TEST_F(Any, Reset) {
TEST(Any, Reset) {
entt::any any{2};
ASSERT_TRUE(any);
@@ -784,7 +780,7 @@ TEST_F(Any, Reset) {
ASSERT_EQ(any.type(), entt::type_id<void>());
}
TEST_F(Any, SBOSwap) {
TEST(Any, SBOSwap) {
entt::any lhs{'c'};
entt::any rhs{2};
@@ -801,7 +797,7 @@ TEST_F(Any, SBOSwap) {
ASSERT_EQ(entt::any_cast<char>(rhs), 'c');
}
TEST_F(Any, NoSBOSwap) {
TEST(Any, NoSBOSwap) {
entt::any lhs{fat{.1, .2, .3, .4}};
entt::any rhs{fat{.4, .3, .2, .1}};
@@ -814,7 +810,7 @@ TEST_F(Any, NoSBOSwap) {
ASSERT_EQ(entt::any_cast<fat>(rhs), (fat{.1, .2, .3, .4}));
}
TEST_F(Any, VoidSwap) {
TEST(Any, VoidSwap) {
entt::any lhs{std::in_place_type<void>};
entt::any rhs{std::in_place_type<void>};
const auto *pre = lhs.data();
@@ -827,7 +823,7 @@ TEST_F(Any, VoidSwap) {
ASSERT_EQ(pre, lhs.data());
}
TEST_F(Any, SBOWithNoSBOSwap) {
TEST(Any, SBOWithNoSBOSwap) {
entt::any lhs{fat{.1, .2, .3, .4}};
entt::any rhs{'c'};
@@ -844,7 +840,7 @@ TEST_F(Any, SBOWithNoSBOSwap) {
ASSERT_EQ(entt::any_cast<fat>(rhs), (fat{.1, .2, .3, .4}));
}
TEST_F(Any, SBOWithRefSwap) {
TEST(Any, SBOWithRefSwap) {
int value = 3;
entt::any lhs{entt::forward_as_any(value)};
entt::any rhs{'c'};
@@ -863,7 +859,7 @@ TEST_F(Any, SBOWithRefSwap) {
ASSERT_EQ(rhs.data(), &value);
}
TEST_F(Any, SBOWithConstRefSwap) {
TEST(Any, SBOWithConstRefSwap) {
const int value = 3;
entt::any lhs{entt::forward_as_any(value)};
entt::any rhs{'c'};
@@ -883,7 +879,7 @@ TEST_F(Any, SBOWithConstRefSwap) {
ASSERT_EQ(std::as_const(rhs).data(), &value);
}
TEST_F(Any, SBOWithEmptySwap) {
TEST(Any, SBOWithEmptySwap) {
entt::any lhs{'c'};
entt::any rhs{};
@@ -906,7 +902,7 @@ TEST_F(Any, SBOWithEmptySwap) {
ASSERT_EQ(entt::any_cast<char>(lhs), 'c');
}
TEST_F(Any, SBOWithVoidSwap) {
TEST(Any, SBOWithVoidSwap) {
entt::any lhs{'c'};
entt::any rhs{std::in_place_type<void>};
@@ -929,7 +925,7 @@ TEST_F(Any, SBOWithVoidSwap) {
ASSERT_EQ(entt::any_cast<char>(lhs), 'c');
}
TEST_F(Any, NoSBOWithRefSwap) {
TEST(Any, NoSBOWithRefSwap) {
int value = 3;
entt::any lhs{entt::forward_as_any(value)};
entt::any rhs{fat{.1, .2, .3, .4}};
@@ -948,7 +944,7 @@ TEST_F(Any, NoSBOWithRefSwap) {
ASSERT_EQ(rhs.data(), &value);
}
TEST_F(Any, NoSBOWithConstRefSwap) {
TEST(Any, NoSBOWithConstRefSwap) {
const int value = 3;
entt::any lhs{entt::forward_as_any(value)};
entt::any rhs{fat{.1, .2, .3, .4}};
@@ -968,7 +964,7 @@ TEST_F(Any, NoSBOWithConstRefSwap) {
ASSERT_EQ(std::as_const(rhs).data(), &value);
}
TEST_F(Any, NoSBOWithEmptySwap) {
TEST(Any, NoSBOWithEmptySwap) {
entt::any lhs{fat{.1, .2, .3, .4}};
entt::any rhs{};
@@ -991,7 +987,7 @@ TEST_F(Any, NoSBOWithEmptySwap) {
ASSERT_EQ(entt::any_cast<fat>(lhs), (fat{.1, .2, .3, .4}));
}
TEST_F(Any, NoSBOWithVoidSwap) {
TEST(Any, NoSBOWithVoidSwap) {
entt::any lhs{fat{.1, .2, .3, .4}};
entt::any rhs{std::in_place_type<void>};
@@ -1014,7 +1010,7 @@ TEST_F(Any, NoSBOWithVoidSwap) {
ASSERT_EQ(entt::any_cast<fat>(lhs), (fat{.1, .2, .3, .4}));
}
TEST_F(Any, AsRef) {
TEST(Any, AsRef) {
entt::any any{2};
auto ref = any.as_ref();
auto cref = std::as_const(any).as_ref();
@@ -1092,7 +1088,7 @@ TEST_F(Any, AsRef) {
ASSERT_NE(entt::any_cast<int>(&cref), any.data());
}
TEST_F(Any, Comparable) {
TEST(Any, Comparable) {
const entt::any any{'c'};
const entt::any other{'a'};
@@ -1106,7 +1102,7 @@ TEST_F(Any, Comparable) {
ASSERT_TRUE(entt::any{} != any);
}
TEST_F(Any, NoSBOComparable) {
TEST(Any, NoSBOComparable) {
const entt::any any{fat{.1, .2, .3, .4}};
const entt::any other{fat{.0, .1, .2, .3}};
@@ -1120,7 +1116,7 @@ TEST_F(Any, NoSBOComparable) {
ASSERT_TRUE(entt::any{} != any);
}
TEST_F(Any, RefComparable) {
TEST(Any, RefComparable) {
int value = 2;
const entt::any any{entt::forward_as_any(value)};
const entt::any other{3};
@@ -1135,7 +1131,7 @@ TEST_F(Any, RefComparable) {
ASSERT_TRUE(entt::any{} != any);
}
TEST_F(Any, ConstRefComparable) {
TEST(Any, ConstRefComparable) {
int value = 2;
const entt::any any{3};
const entt::any other{entt::make_any<const int &>(value)};
@@ -1150,7 +1146,7 @@ TEST_F(Any, ConstRefComparable) {
ASSERT_TRUE(entt::any{} != any);
}
TEST_F(Any, UnrelatedComparable) {
TEST(Any, UnrelatedComparable) {
const entt::any any{'c'};
const entt::any other{2};
@@ -1164,7 +1160,7 @@ TEST_F(Any, UnrelatedComparable) {
ASSERT_TRUE(entt::any{} != any);
}
TEST_F(Any, NonComparable) {
TEST(Any, NonComparable) {
const test::non_comparable instance{};
auto any = entt::forward_as_any(instance);
@@ -1177,7 +1173,7 @@ TEST_F(Any, NonComparable) {
ASSERT_TRUE(entt::any{} != any);
}
TEST_F(Any, AssociativeContainerOfNonComparable) {
TEST(Any, AssociativeContainerOfNonComparable) {
const std::unordered_map<int, test::non_comparable> instance{};
auto any = entt::forward_as_any(instance);
@@ -1190,7 +1186,7 @@ TEST_F(Any, AssociativeContainerOfNonComparable) {
ASSERT_TRUE(entt::any{} != any);
}
TEST_F(Any, SequenceContainerOfNonComparable) {
TEST(Any, SequenceContainerOfNonComparable) {
const std::vector<test::non_comparable> instance{};
auto any = entt::forward_as_any(instance);
@@ -1203,7 +1199,7 @@ TEST_F(Any, SequenceContainerOfNonComparable) {
ASSERT_TRUE(entt::any{} != any);
}
TEST_F(Any, CompareVoid) {
TEST(Any, CompareVoid) {
const entt::any any{std::in_place_type<void>};
ASSERT_EQ(any, any);
@@ -1218,7 +1214,7 @@ TEST_F(Any, CompareVoid) {
ASSERT_FALSE(entt::any{} != any);
}
TEST_F(Any, AnyCast) {
TEST(Any, AnyCast) {
entt::any any{2};
const auto &cany = any;
@@ -1238,7 +1234,7 @@ TEST_F(Any, AnyCast) {
ASSERT_EQ(entt::any_cast<int>(entt::any{2}), 2);
}
ENTT_DEBUG_TEST_F(AnyDeathTest, AnyCast) {
ENTT_DEBUG_TEST(AnyDeathTest, AnyCast) {
entt::any any{2};
const auto &cany = any;
@@ -1253,7 +1249,7 @@ ENTT_DEBUG_TEST_F(AnyDeathTest, AnyCast) {
ASSERT_DEATH([[maybe_unused]] auto elem = entt::any_cast<double>(entt::any{2}), "");
}
TEST_F(Any, MakeAny) {
TEST(Any, MakeAny) {
int value = 2;
auto any = entt::make_any<int>(value);
auto ext = entt::make_any<int, sizeof(int), alignof(int)>(value);
@@ -1280,7 +1276,7 @@ TEST_F(Any, MakeAny) {
ASSERT_EQ(ref.data(), &value);
}
TEST_F(Any, ForwardAsAny) {
TEST(Any, ForwardAsAny) {
int value = 2;
auto ref = entt::forward_as_any(value);
auto cref = entt::forward_as_any(std::as_const(value));
@@ -1306,7 +1302,7 @@ TEST_F(Any, ForwardAsAny) {
ASSERT_EQ(ref.data(), &value);
}
TEST_F(Any, NonCopyableType) {
TEST(Any, NonCopyableType) {
const std::unique_ptr<int> value{};
entt::any any{std::in_place_type<std::unique_ptr<int>>};
entt::any other = entt::forward_as_any(value);
@@ -1338,7 +1334,7 @@ TEST_F(Any, NonCopyableType) {
ASSERT_EQ(copy.policy(), entt::any_policy::owner);
}
TEST_F(Any, NonCopyableValueType) {
TEST(Any, NonCopyableValueType) {
std::vector<entt::any> vec{};
vec.emplace_back(std::in_place_type<std::unique_ptr<int>>);
vec.shrink_to_fit();
@@ -1355,7 +1351,7 @@ TEST_F(Any, NonCopyableValueType) {
ASSERT_TRUE(vec[1u]);
}
TEST_F(Any, NonMovableType) {
TEST(Any, NonMovableType) {
entt::any any{std::in_place_type<test::non_movable>};
entt::any other{std::in_place_type<test::non_movable>};
@@ -1386,24 +1382,29 @@ TEST_F(Any, NonMovableType) {
ASSERT_EQ(copy.policy(), entt::any_policy::owner);
}
TEST_F(Any, Array) {
entt::any any{std::in_place_type<int[1]>}; // NOLINT
TEST(Any, Array) {
// NOLINTNEXTLINE(*-avoid-c-arrays)
entt::any any{std::in_place_type<int[1]>};
const entt::any copy{any};
ASSERT_TRUE(any);
ASSERT_FALSE(copy);
ASSERT_EQ(any.type(), entt::type_id<int[1]>()); // NOLINT
ASSERT_NE(entt::any_cast<int[1]>(&any), nullptr); // NOLINT
ASSERT_EQ(entt::any_cast<int[2]>(&any), nullptr); // NOLINT
// NOLINTBEGIN(*-avoid-c-arrays)
ASSERT_EQ(any.type(), entt::type_id<int[1]>());
ASSERT_NE(entt::any_cast<int[1]>(&any), nullptr);
ASSERT_EQ(entt::any_cast<int[2]>(&any), nullptr);
// NOLINTEND(*-avoid-c-arrays)
ASSERT_EQ(entt::any_cast<int *>(&any), nullptr);
entt::any_cast<int(&)[1]>(any)[0] = 2; // NOLINT
// NOLINTNEXTLINE(*-avoid-c-arrays)
entt::any_cast<int(&)[1]>(any)[0] = 2;
ASSERT_EQ(entt::any_cast<const int(&)[1]>(std::as_const(any))[0], 2); // NOLINT
// NOLINTNEXTLINE(*-avoid-c-arrays)
ASSERT_EQ(entt::any_cast<const int(&)[1]>(std::as_const(any))[0], 2);
}
TEST_F(Any, CopyMoveReference) {
TEST(Any, CopyMoveReference) {
int value = 3;
auto any = entt::forward_as_any(value);
entt::any move = std::move(any);
@@ -1433,7 +1434,7 @@ TEST_F(Any, CopyMoveReference) {
ASSERT_EQ(entt::any_cast<int &>(copy), 3);
}
TEST_F(Any, CopyMoveConstReference) {
TEST(Any, CopyMoveConstReference) {
int value = 3;
auto any = entt::forward_as_any(std::as_const(value));
entt::any move = std::move(any);
@@ -1463,7 +1464,7 @@ TEST_F(Any, CopyMoveConstReference) {
ASSERT_EQ(entt::any_cast<const int &>(copy), 3);
}
TEST_F(Any, SBOVsZeroedSBOSize) {
TEST(Any, SBOVsZeroedSBOSize) {
entt::any sbo{2};
const auto *broken = sbo.data();
entt::any other = std::move(sbo);
@@ -1477,9 +1478,11 @@ TEST_F(Any, SBOVsZeroedSBOSize) {
ASSERT_EQ(valid, same.data());
}
TEST_F(Any, SboAlignment) {
TEST(Any, SboAlignment) {
constexpr auto alignment = alignof(over_aligned);
entt::basic_any<alignment, alignment> sbo[2] = {over_aligned{}, over_aligned{}}; // NOLINT
using any_type = entt::basic_any<alignment, alignment>;
std::array<any_type, 2u> sbo = {over_aligned{}, over_aligned{}};
const auto *data = sbo[0].data();
// NOLINTBEGIN(*-reinterpret-cast)
@@ -1497,9 +1500,11 @@ TEST_F(Any, SboAlignment) {
ASSERT_NE(data, sbo[1].data());
}
TEST_F(Any, NoSboAlignment) {
TEST(Any, NoSboAlignment) {
constexpr auto alignment = alignof(over_aligned);
entt::basic_any<alignment> nosbo[2] = {over_aligned{}, over_aligned{}}; // NOLINT
using any_type = entt::basic_any<alignment>;
std::array<any_type, 2u> nosbo = {over_aligned{}, over_aligned{}};
const auto *data = nosbo[0].data();
// NOLINTBEGIN(*-reinterpret-cast)
@@ -1517,12 +1522,12 @@ TEST_F(Any, NoSboAlignment) {
ASSERT_EQ(data, nosbo[1].data());
}
TEST_F(Any, AggregatesMustWork) {
TEST(Any, AggregatesMustWork) {
// the goal of this test is to enforce the requirements for aggregate types
entt::any{std::in_place_type<test::aggregate>, 2}.emplace<test::aggregate>(2);
}
TEST_F(Any, DeducedArrayType) {
TEST(Any, DeducedArrayType) {
entt::any any{"array of char"};
ASSERT_TRUE(any);