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

test: drop a bunch of NOLINT

Browse Source
This commit is contained in:
Michele Caini
2024-01-30 11:05:25 +01:00
parent 553accd5f0
commit 31a91c764b
4 changed files with 50 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
test/entt/meta/meta_any.cpp
View File

@@ -1,4 +1,5 @@
#include <algorithm>
#include <array>
#include <cstddef>
#include <iterator>
#include <memory>
@@ -60,10 +61,10 @@ struct fat_t: empty_t {
fat_t &operator=(const fat_t &) = default;
bool operator==(const fat_t &other) const {
return std::equal(std::begin(value), std::end(value), std::begin(other.value), std::end(other.value));
return (value == other.value);
}
double value[4]; // NOLINT
std::array<double, 4u> value{};
};
enum class enum_class : unsigned short int {

16
test/entt/meta/meta_data.cpp
View File

@@ -82,8 +82,8 @@ struct multi_setter_t {
};
struct array_t {
inline static int global[3]; // NOLINT
int local[5]; // NOLINT
inline static int global[2]; // NOLINT
int local[4]; // NOLINT
};
enum class property_t : entt::id_type {
@@ -526,8 +526,10 @@ TEST_F(MetaData, ArrayStatic) {
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 1u);
ASSERT_EQ(data.type(), entt::resolve<int[3]>()); // NOLINT
ASSERT_EQ(data.arg(0u), entt::resolve<int[3]>()); // NOLINT
// NOLINTBEGIN(*-avoid-c-arrays)
ASSERT_EQ(data.type(), entt::resolve<int[2]>());
ASSERT_EQ(data.arg(0u), entt::resolve<int[2]>());
// NOLINTEND(*-avoid-c-arrays)
ASSERT_FALSE(data.is_const());
ASSERT_TRUE(data.is_static());
ASSERT_TRUE(data.type().is_array());
@@ -542,8 +544,10 @@ TEST_F(MetaData, Array) {
ASSERT_TRUE(data);
ASSERT_EQ(data.arity(), 1u);
ASSERT_EQ(data.type(), entt::resolve<int[5]>()); // NOLINT
ASSERT_EQ(data.arg(0u), entt::resolve<int[5]>()); // NOLINT
// NOLINTBEGIN(*-avoid-c-arrays)
ASSERT_EQ(data.type(), entt::resolve<int[4]>());
ASSERT_EQ(data.arg(0u), entt::resolve<int[4]>());
// NOLINTEND(*-avoid-c-arrays)
ASSERT_FALSE(data.is_const());
ASSERT_FALSE(data.is_static());
ASSERT_TRUE(data.type().is_array());

12
test/entt/meta/meta_pointer.cpp
View File

@@ -428,11 +428,15 @@ TEST(MetaPointerLike, DereferenceProxyPointer) {
}
TEST(MetaPointerLike, DereferenceArray) {
const entt::meta_any array{std::in_place_type<int[3]>}; // NOLINT
const entt::meta_any array_of_array{std::in_place_type<int[3][3]>}; // NOLINT
// NOLINTBEGIN(*-avoid-c-arrays)
const entt::meta_any array{std::in_place_type<int[3]>};
const entt::meta_any array_of_array{std::in_place_type<int[3][3]>};
// NOLINTEND(*-avoid-c-arrays)
ASSERT_EQ(array.type(), entt::resolve<int[3]>()); // NOLINT
ASSERT_EQ(array_of_array.type(), entt::resolve<int[3][3]>()); // NOLINT
// NOLINTBEGIN(*-avoid-c-arrays)
ASSERT_EQ(array.type(), entt::resolve<int[3]>());
ASSERT_EQ(array_of_array.type(), entt::resolve<int[3][3]>());
// NOLINTEND(*-avoid-c-arrays)
ASSERT_FALSE(*array);
ASSERT_FALSE(*array_of_array);

57
test/entt/meta/meta_utility.cpp
View File

@@ -1,4 +1,5 @@
#include <array>
#include <iterator>
#include <utility>
#include <gtest/gtest.h>
#include <entt/core/type_traits.hpp>
@@ -188,15 +189,15 @@ TEST_F(MetaUtility, MetaGetter) {
}
TEST_F(MetaUtility, MetaInvokeWithCandidate) {
entt::meta_any args[2u]{clazz{}, 42}; // NOLINT
std::array args{entt::meta_any{clazz{}}, entt::meta_any{4}};
args[0u].cast<clazz &>().value = 3;
ASSERT_FALSE((entt::meta_invoke<clazz>({}, &clazz::setter, nullptr)));
ASSERT_FALSE((entt::meta_invoke<clazz>({}, &clazz::setter, std::next(args.data()))));
ASSERT_FALSE((entt::meta_invoke<clazz>({}, &clazz::getter, nullptr)));
ASSERT_TRUE((entt::meta_invoke<clazz>(args[0u], &clazz::setter, args + 1u))); // NOLINT
ASSERT_FALSE((entt::meta_invoke<clazz>(args[0u], &clazz::setter, args))); // NOLINT
ASSERT_EQ((entt::meta_invoke<clazz>(args[0u], &clazz::getter, nullptr)).cast<int>(), 42);
ASSERT_TRUE((entt::meta_invoke<clazz>(args[0u], &clazz::setter, std::next(args.data()))));
ASSERT_FALSE((entt::meta_invoke<clazz>(args[0u], &clazz::setter, args.data())));
ASSERT_EQ((entt::meta_invoke<clazz>(args[0u], &clazz::getter, nullptr)).cast<int>(), 4);
ASSERT_FALSE((entt::meta_invoke<clazz>(args[1u], &clazz::getter, nullptr)));
ASSERT_EQ((entt::meta_invoke<clazz>({}, &clazz::get_value, nullptr)).cast<int>(), 3);
@@ -206,20 +207,20 @@ TEST_F(MetaUtility, MetaInvokeWithCandidate) {
const auto setter = [](int &value) { value = 3; };
const auto getter = [](int value) { return value * 2; };
ASSERT_TRUE(entt::meta_invoke<test::empty>({}, setter, args + 1u)); // NOLINT
ASSERT_EQ(entt::meta_invoke<test::empty>({}, getter, args + 1u).cast<int>(), 6); // NOLINT
ASSERT_TRUE(entt::meta_invoke<test::empty>({}, setter, std::next(args.data())));
ASSERT_EQ(entt::meta_invoke<test::empty>({}, getter, std::next(args.data())).cast<int>(), 6);
}
TEST_F(MetaUtility, MetaInvoke) {
entt::meta_any args[2u]{clazz{}, 42}; // NOLINT
std::array args{entt::meta_any{clazz{}}, entt::meta_any{4}};
args[0u].cast<clazz &>().value = 3;
ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::setter>({}, nullptr)));
ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::setter>({}, std::next(args.data()))));
ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::getter>({}, nullptr)));
ASSERT_TRUE((entt::meta_invoke<clazz, &clazz::setter>(args[0u], args + 1u))); // NOLINT
ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::setter>(args[0u], args))); // NOLINT
ASSERT_EQ((entt::meta_invoke<clazz, &clazz::getter>(args[0u], nullptr)).cast<int>(), 42);
ASSERT_TRUE((entt::meta_invoke<clazz, &clazz::setter>(args[0u], std::next(args.data()))));
ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::setter>(args[0u], args.data())));
ASSERT_EQ((entt::meta_invoke<clazz, &clazz::getter>(args[0u], nullptr)).cast<int>(), 4);
ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::getter>(args[1u], nullptr)));
ASSERT_EQ((entt::meta_invoke<clazz, &clazz::get_value>({}, nullptr)).cast<int>(), 3);
@@ -228,42 +229,42 @@ TEST_F(MetaUtility, MetaInvoke) {
}
TEST_F(MetaUtility, MetaConstructArgsOnly) {
entt::meta_any args[2u]{clazz{}, 42}; // NOLINT
const auto any = entt::meta_construct<clazz, int>(args + 1u); // NOLINT
std::array args{entt::meta_any{clazz{}}, entt::meta_any{4}};
const auto any = entt::meta_construct<clazz, int>(std::next(args.data()));
ASSERT_TRUE(any);
ASSERT_FALSE((entt::meta_construct<clazz, int>(args))); // NOLINT
ASSERT_EQ(any.cast<const clazz &>().member, 42);
ASSERT_FALSE((entt::meta_construct<clazz, int>(args.data())));
ASSERT_EQ(any.cast<const clazz &>().member, 4);
}
TEST_F(MetaUtility, MetaConstructWithCandidate) {
entt::meta_any args[2u]{clazz{}, 42}; // NOLINT
const auto any = entt::meta_construct<clazz>(&clazz::factory, args + 1u); // NOLINT
std::array args{entt::meta_any{clazz{}}, entt::meta_any{4}};
const auto any = entt::meta_construct<clazz>(&clazz::factory, std::next(args.data()));
ASSERT_TRUE(any);
ASSERT_FALSE((entt::meta_construct<clazz>(&clazz::factory, args))); // NOLINT
ASSERT_EQ(any.cast<const clazz &>().member, 42);
ASSERT_FALSE((entt::meta_construct<clazz>(&clazz::factory, args.data())));
ASSERT_EQ(any.cast<const clazz &>().member, 4);
ASSERT_EQ(args[0u].cast<const clazz &>().member, 0);
ASSERT_TRUE((entt::meta_construct<clazz>(&clazz::static_setter, args))); // NOLINT
ASSERT_EQ(args[0u].cast<const clazz &>().member, 42);
ASSERT_TRUE((entt::meta_construct<clazz>(&clazz::static_setter, args.data())));
ASSERT_EQ(args[0u].cast<const clazz &>().member, 4);
const auto setter = [](int &value) { value = 3; };
const auto builder = [](int value) { return value * 2; };
ASSERT_TRUE(entt::meta_construct<test::empty>(setter, args + 1u)); // NOLINT
ASSERT_EQ(entt::meta_construct<test::empty>(builder, args + 1u).cast<int>(), 6); // NOLINT
ASSERT_TRUE(entt::meta_construct<test::empty>(setter, std::next(args.data())));
ASSERT_EQ(entt::meta_construct<test::empty>(builder, std::next(args.data())).cast<int>(), 6);
}
TEST_F(MetaUtility, MetaConstruct) {
std::array args{entt::meta_any{clazz{}}, entt::meta_any{2}};
const auto any = entt::meta_construct<clazz, &clazz::factory>(args.data() + 1u); // NOLINT
std::array args{entt::meta_any{clazz{}}, entt::meta_any{4}};
const auto any = entt::meta_construct<clazz, &clazz::factory>(std::next(args.data()));
ASSERT_TRUE(any);
ASSERT_FALSE((entt::meta_construct<clazz, &clazz::factory>(args.data())));
ASSERT_EQ(any.cast<const clazz &>().member, 2);
ASSERT_EQ(any.cast<const clazz &>().member, 4);
ASSERT_EQ(args[0u].cast<const clazz &>().member, 0);
ASSERT_TRUE((entt::meta_construct<clazz, &clazz::static_setter>(args.data())));
ASSERT_EQ(args[0u].cast<const clazz &>().member, 2);
ASSERT_EQ(args[0u].cast<const clazz &>().member, 4);
}