test: drop a bunch of NOLINT

test/entt/meta/meta_any.cpp

@@ -9,6 +9,7 @@
 #include <entt/meta/meta.hpp>
 #include <entt/meta/resolve.hpp>
 #include "../common/config.h"
+#include "../common/linter.hpp"
 #include "../common/non_comparable.h"
 
 struct clazz_t {
@@ -67,12 +68,12 @@ struct fat_t: empty_t {
 
 enum class enum_class : unsigned short int {
     foo = 0u,
-    bar = 42u
+    bar = 1u
 };
 
 struct unmanageable_t {
     unmanageable_t()
-        : value{std::make_unique<int>(42)} {} // NOLINT
+        : value{std::make_unique<int>(3)} {}
 
     ~unmanageable_t() = default;
 
@@ -163,39 +164,38 @@ TEST_F(MetaAny, Empty) {
 }
 
 TEST_F(MetaAny, SBOInPlaceTypeConstruction) {
-    entt::meta_any any{std::in_place_type<int>, 42}; // NOLINT
+    entt::meta_any any{std::in_place_type<int>, 3};
 
     ASSERT_TRUE(any);
     ASSERT_FALSE(any.try_cast<std::size_t>());
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(any.cast<int>(), 3);
     ASSERT_NE(any.data(), nullptr);
-    ASSERT_EQ(any, (entt::meta_any{std::in_place_type<int>, 42}));
-    ASSERT_EQ(any, entt::meta_any{42});
-    ASSERT_NE(entt::meta_any{3}, any);
+    ASSERT_EQ(any, (entt::meta_any{std::in_place_type<int>, 3}));
+    ASSERT_EQ(any, entt::meta_any{3});
+    ASSERT_NE(entt::meta_any{1}, any);
 }
 
 TEST_F(MetaAny, SBOAsRefConstruction) {
-    int value = 3;
-    int compare = 42; // NOLINT
+    int value = 1;
+    int compare = 3;
     auto any = entt::forward_as_meta(value);
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::meta_any_policy::ref);
     ASSERT_EQ(any.type(), entt::resolve<int>());
 
     ASSERT_FALSE(any.try_cast<std::size_t>());
-    ASSERT_EQ(any.cast<int &>(), 3);
-    ASSERT_EQ(any.cast<const int &>(), 3);
-    ASSERT_EQ(any.cast<int>(), 3);
+    ASSERT_EQ(any.cast<int &>(), 1);
+    ASSERT_EQ(any.cast<const int &>(), 1);
+    ASSERT_EQ(any.cast<int>(), 1);
     ASSERT_EQ(any.data(), &value);
     ASSERT_EQ(std::as_const(any).data(), &value);
 
     ASSERT_EQ(any, entt::forward_as_meta(value));
     ASSERT_NE(any, entt::forward_as_meta(compare));
 
-    ASSERT_NE(any, entt::meta_any{42});
-    ASSERT_EQ(entt::meta_any{3}, any);
+    ASSERT_NE(any, entt::meta_any{3});
+    ASSERT_EQ(entt::meta_any{1}, any);
 
     any = entt::forward_as_meta(value);
 
@@ -207,31 +207,30 @@ TEST_F(MetaAny, SBOAsRefConstruction) {
 
     ASSERT_TRUE(other);
     ASSERT_EQ(any.type(), entt::resolve<int>());
-    ASSERT_EQ(any.cast<int>(), 3);
+    ASSERT_EQ(any.cast<int>(), 1);
     ASSERT_EQ(other.data(), any.data());
 }
 
 TEST_F(MetaAny, SBOAsConstRefConstruction) {
-    const int value = 3;
-    int compare = 42; // NOLINT
+    const int value = 1;
+    int compare = 3;
     auto any = entt::forward_as_meta(value);
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::meta_any_policy::cref);
     ASSERT_EQ(any.type(), entt::resolve<int>());
 
     ASSERT_FALSE(any.try_cast<std::size_t>());
-    ASSERT_EQ(any.cast<const int &>(), 3);
-    ASSERT_EQ(any.cast<int>(), 3);
+    ASSERT_EQ(any.cast<const int &>(), 1);
+    ASSERT_EQ(any.cast<int>(), 1);
     ASSERT_EQ(any.data(), nullptr);
     ASSERT_EQ(std::as_const(any).data(), &value);
 
     ASSERT_EQ(any, entt::forward_as_meta(value));
     ASSERT_NE(any, entt::forward_as_meta(compare));
 
-    ASSERT_NE(any, entt::meta_any{42});
-    ASSERT_EQ(entt::meta_any{3}, any);
+    ASSERT_NE(any, entt::meta_any{3});
+    ASSERT_EQ(entt::meta_any{1}, any);
 
     any = entt::forward_as_meta(std::as_const(value));
 
@@ -243,193 +242,196 @@ TEST_F(MetaAny, SBOAsConstRefConstruction) {
 
     ASSERT_TRUE(other);
     ASSERT_EQ(any.type(), entt::resolve<int>());
-    ASSERT_EQ(any.cast<int>(), 3);
+    ASSERT_EQ(any.cast<int>(), 1);
     ASSERT_EQ(other.data(), any.data());
 }
 
 ENTT_DEBUG_TEST_F(MetaAnyDeathTest, SBOAsConstRefConstruction) {
-    const int value = 3;
+    const int value = 1;
     auto any = entt::forward_as_meta(value);
 
     ASSERT_TRUE(any);
-    ASSERT_DEATH(any.cast<int &>() = 3, "");
+    ASSERT_DEATH(any.cast<int &>() = 1, "");
 }
 
 TEST_F(MetaAny, SBOCopyConstruction) {
-    const entt::meta_any any{42};
+    const entt::meta_any any{3};
     entt::meta_any other{any};
 
     ASSERT_TRUE(any);
     ASSERT_TRUE(other);
     ASSERT_FALSE(other.try_cast<std::size_t>());
-    ASSERT_EQ(other.cast<int>(), 42);
-    ASSERT_EQ(other, entt::meta_any{42});
+    ASSERT_EQ(other.cast<int>(), 3);
+    ASSERT_EQ(other, entt::meta_any{3});
     ASSERT_NE(other, entt::meta_any{0});
 }
 
 TEST_F(MetaAny, SBOCopyAssignment) {
-    const entt::meta_any any{42};
-    entt::meta_any other{3};
+    const entt::meta_any any{3};
+    entt::meta_any other{1};
 
     other = any;
 
     ASSERT_TRUE(any);
     ASSERT_TRUE(other);
     ASSERT_FALSE(other.try_cast<std::size_t>());
-    ASSERT_EQ(other.cast<int>(), 42);
-    ASSERT_EQ(other, entt::meta_any{42});
+    ASSERT_EQ(other.cast<int>(), 3);
+    ASSERT_EQ(other, entt::meta_any{3});
     ASSERT_NE(other, entt::meta_any{0});
 }
 
 TEST_F(MetaAny, SBOMoveConstruction) {
-    entt::meta_any any{42}; // NOLINT
+    entt::meta_any any{3};
     entt::meta_any other{std::move(any)};
 
-    ASSERT_FALSE(any); // NOLINT
+    test::is_initialized(any);
+
+    ASSERT_FALSE(any);
     ASSERT_TRUE(other);
     ASSERT_FALSE(other.try_cast<std::size_t>());
-    ASSERT_EQ(other.cast<int>(), 42);
-    ASSERT_EQ(other, entt::meta_any{42});
+    ASSERT_EQ(other.cast<int>(), 3);
+    ASSERT_EQ(other, entt::meta_any{3});
     ASSERT_NE(other, entt::meta_any{0});
 }
 
 TEST_F(MetaAny, SBOMoveAssignment) {
-    entt::meta_any any{42}; // NOLINT
-    entt::meta_any other{3};
+    entt::meta_any any{3};
+    entt::meta_any other{1};
 
     other = std::move(any);
+    test::is_initialized(any);
 
-    ASSERT_FALSE(any); // NOLINT
+    ASSERT_FALSE(any);
     ASSERT_TRUE(other);
     ASSERT_FALSE(other.try_cast<std::size_t>());
-    ASSERT_EQ(other.cast<int>(), 42);
-    ASSERT_EQ(other, entt::meta_any{42});
+    ASSERT_EQ(other.cast<int>(), 3);
+    ASSERT_EQ(other, entt::meta_any{3});
     ASSERT_NE(other, entt::meta_any{0});
 }
 
 TEST_F(MetaAny, SBODirectAssignment) {
     entt::meta_any any{};
-    any = 42; // NOLINT
+    any = 3;
 
     ASSERT_FALSE(any.try_cast<std::size_t>());
-    ASSERT_EQ(any.cast<int>(), 42);
-    ASSERT_EQ(any, entt::meta_any{42});
+    ASSERT_EQ(any.cast<int>(), 3);
+    ASSERT_EQ(any, entt::meta_any{3});
     ASSERT_NE(entt::meta_any{0}, any);
 }
 
 TEST_F(MetaAny, SBOAssignValue) {
-    entt::meta_any any{42}; // NOLINT
-    const entt::meta_any other{3};
+    entt::meta_any any{3};
+    const entt::meta_any other{1};
     const entt::meta_any invalid{empty_t{}};
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(any.cast<int>(), 3);
 
     ASSERT_TRUE(any.assign(other));
     ASSERT_FALSE(any.assign(invalid));
-    ASSERT_EQ(any.cast<int>(), 3);
+    ASSERT_EQ(any.cast<int>(), 1);
 }
 
 TEST_F(MetaAny, SBOConvertAssignValue) {
-    entt::meta_any any{42}; // NOLINT
-    const entt::meta_any other{3.5};
+    entt::meta_any any{3};
+    const entt::meta_any other{1.5};
     const entt::meta_any invalid{empty_t{}};
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(any.cast<int>(), 3);
 
     ASSERT_TRUE(any.assign(other));
     ASSERT_FALSE(any.assign(invalid));
-    ASSERT_EQ(any.cast<int>(), 3);
+    ASSERT_EQ(any.cast<int>(), 1);
 }
 
 TEST_F(MetaAny, SBOAsRefAssignValue) {
-    int value = 42; // NOLINT
+    int value = 3;
     entt::meta_any any{entt::forward_as_meta(value)};
-    const entt::meta_any other{3};
+    const entt::meta_any other{1};
     const entt::meta_any invalid{empty_t{}};
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(any.cast<int>(), 3);
 
     ASSERT_TRUE(any.assign(other));
     ASSERT_FALSE(any.assign(invalid));
-    ASSERT_EQ(any.cast<int>(), 3);
-    ASSERT_EQ(value, 3);
+    ASSERT_EQ(any.cast<int>(), 1);
+    ASSERT_EQ(value, 1);
 }
 
 TEST_F(MetaAny, SBOAsConstRefAssignValue) {
-    const int value = 42;
+    const int value = 3;
     entt::meta_any any{entt::forward_as_meta(value)};
-    const entt::meta_any other{3};
+    const entt::meta_any other{1};
     const entt::meta_any invalid{empty_t{}};
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(any.cast<int>(), 3);
 
     ASSERT_FALSE(any.assign(other));
     ASSERT_FALSE(any.assign(invalid));
-    ASSERT_EQ(any.cast<int>(), 42);
-    ASSERT_EQ(value, 42);
+    ASSERT_EQ(any.cast<int>(), 3);
+    ASSERT_EQ(value, 3);
 }
 
 TEST_F(MetaAny, SBOTransferValue) {
-    entt::meta_any any{42}; // NOLINT
+    entt::meta_any any{3};
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(any.cast<int>(), 3);
 
-    ASSERT_TRUE(any.assign(3));
+    ASSERT_TRUE(any.assign(1));
     ASSERT_FALSE(any.assign(empty_t{}));
-    ASSERT_EQ(any.cast<int>(), 3);
+    ASSERT_EQ(any.cast<int>(), 1);
 }
 
 TEST_F(MetaAny, SBOTransferConstValue) {
-    const int value = 3;
-    entt::meta_any any{42}; // NOLINT
+    const int value = 1;
+    entt::meta_any any{3};
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(any.cast<int>(), 3);
 
     ASSERT_TRUE(any.assign(entt::forward_as_meta(value)));
-    ASSERT_EQ(any.cast<int>(), 3);
+    ASSERT_EQ(any.cast<int>(), 1);
 }
 
 TEST_F(MetaAny, SBOConvertTransferValue) {
-    entt::meta_any any{42}; // NOLINT
+    entt::meta_any any{3};
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(any.cast<int>(), 3);
 
-    ASSERT_TRUE(any.assign(3.5));
+    ASSERT_TRUE(any.assign(1.5));
     ASSERT_FALSE(any.assign(empty_t{}));
-    ASSERT_EQ(any.cast<int>(), 3);
+    ASSERT_EQ(any.cast<int>(), 1);
 }
 
 TEST_F(MetaAny, SBOAsRefTransferValue) {
-    int value = 42; // NOLINT
+    int value = 3;
     entt::meta_any any{entt::forward_as_meta(value)};
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(any.cast<int>(), 3);
 
-    ASSERT_TRUE(any.assign(3));
+    ASSERT_TRUE(any.assign(1));
     ASSERT_FALSE(any.assign(empty_t{}));
-    ASSERT_EQ(any.cast<int>(), 3);
-    ASSERT_EQ(value, 3);
+    ASSERT_EQ(any.cast<int>(), 1);
+    ASSERT_EQ(value, 1);
 }
 
 TEST_F(MetaAny, SBOAsConstRefTransferValue) {
-    const int value = 42;
+    const int value = 3;
     entt::meta_any any{entt::forward_as_meta(value)};
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(any.cast<int>(), 3);
 
-    ASSERT_FALSE(any.assign(3));
+    ASSERT_FALSE(any.assign(1));
     ASSERT_FALSE(any.assign(empty_t{}));
-    ASSERT_EQ(any.cast<int>(), 42);
-    ASSERT_EQ(value, 42);
+    ASSERT_EQ(any.cast<int>(), 3);
+    ASSERT_EQ(value, 3);
 }
 
 TEST_F(MetaAny, NoSBOInPlaceTypeConstruction) {
@@ -450,7 +452,6 @@ TEST_F(MetaAny, NoSBOAsRefConstruction) {
     auto any = entt::forward_as_meta(instance);
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::meta_any_policy::ref);
     ASSERT_EQ(any.type(), entt::resolve<fat_t>());
 
@@ -485,7 +486,6 @@ TEST_F(MetaAny, NoSBOAsConstRefConstruction) {
     auto any = entt::forward_as_meta(instance);
 
     ASSERT_TRUE(any);
-    ASSERT_FALSE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::meta_any_policy::cref);
     ASSERT_EQ(any.type(), entt::resolve<fat_t>());
 
@@ -555,7 +555,9 @@ TEST_F(MetaAny, NoSBOMoveConstruction) {
     entt::meta_any any{instance};
     entt::meta_any other{std::move(any)};
 
-    ASSERT_FALSE(any); // NOLINT
+    test::is_initialized(any);
+
+    ASSERT_FALSE(any);
     ASSERT_TRUE(other);
     ASSERT_FALSE(other.try_cast<std::size_t>());
     ASSERT_EQ(other.cast<fat_t>(), instance);
@@ -569,8 +571,9 @@ TEST_F(MetaAny, NoSBOMoveAssignment) {
     entt::meta_any other{3};
 
     other = std::move(any);
+    test::is_initialized(any);
 
-    ASSERT_FALSE(any); // NOLINT
+    ASSERT_FALSE(any);
     ASSERT_TRUE(other);
     ASSERT_FALSE(other.try_cast<std::size_t>());
     ASSERT_EQ(other.cast<fat_t>(), instance);
@@ -723,7 +726,6 @@ TEST_F(MetaAny, VoidInPlaceTypeConstruction) {
     entt::meta_any any{std::in_place_type<void>};
 
     ASSERT_TRUE(any);
-    ASSERT_TRUE(any.owner()); // NOLINT
     ASSERT_EQ(any.policy(), entt::meta_any_policy::owner);
     ASSERT_FALSE(any.try_cast<char>());
     ASSERT_EQ(any.data(), nullptr);
@@ -760,7 +762,9 @@ TEST_F(MetaAny, VoidMoveConstruction) {
     entt::meta_any any{std::in_place_type<void>};
     const entt::meta_any other{std::move(any)};
 
-    ASSERT_FALSE(any); // NOLINT
+    test::is_initialized(any);
+
+    ASSERT_FALSE(any);
     ASSERT_TRUE(other);
     ASSERT_EQ(other.type(), entt::resolve<void>());
     ASSERT_EQ(other, entt::meta_any{std::in_place_type<void>});
@@ -771,20 +775,24 @@ TEST_F(MetaAny, VoidMoveAssignment) {
     entt::meta_any other{std::in_place_type<void>};
 
     other = std::move(any);
+    test::is_initialized(any);
 
-    ASSERT_FALSE(any); // NOLINT
+    ASSERT_FALSE(any);
     ASSERT_TRUE(other);
     ASSERT_EQ(other.type(), entt::resolve<void>());
     ASSERT_EQ(other, entt::meta_any{std::in_place_type<void>});
 }
 
 TEST_F(MetaAny, SBOMoveInvalidate) {
-    entt::meta_any any{42}; // NOLINT
+    entt::meta_any any{3};
     entt::meta_any other{std::move(any)};
     const entt::meta_any valid = std::move(other);
 
-    ASSERT_FALSE(any);   // NOLINT
-    ASSERT_FALSE(other); // NOLINT
+    test::is_initialized(any);
+    test::is_initialized(other);
+
+    ASSERT_FALSE(any);
+    ASSERT_FALSE(other);
     ASSERT_TRUE(valid);
 }
 
@@ -794,8 +802,11 @@ TEST_F(MetaAny, NoSBOMoveInvalidate) {
     entt::meta_any other{std::move(any)};
     const entt::meta_any valid = std::move(other);
 
-    ASSERT_FALSE(any);   // NOLINT
-    ASSERT_FALSE(other); // NOLINT
+    test::is_initialized(any);
+    test::is_initialized(other);
+
+    ASSERT_FALSE(any);
+    ASSERT_FALSE(other);
     ASSERT_TRUE(valid);
 }
 
@@ -804,8 +815,11 @@ TEST_F(MetaAny, VoidMoveInvalidate) {
     entt::meta_any other{std::move(any)};
     const entt::meta_any valid = std::move(other);
 
-    ASSERT_FALSE(any);   // NOLINT
-    ASSERT_FALSE(other); // NOLINT
+    test::is_initialized(any);
+    test::is_initialized(other);
+
+    ASSERT_FALSE(any);
+    ASSERT_FALSE(other);
     ASSERT_TRUE(valid);
 }
 
@@ -842,15 +856,15 @@ TEST_F(MetaAny, VoidDestruction) {
 
 TEST_F(MetaAny, Emplace) {
     entt::meta_any any{};
-    any.emplace<int>(42); // NOLINT
+    any.emplace<int>(3);
 
     ASSERT_TRUE(any);
     ASSERT_FALSE(any.try_cast<std::size_t>());
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(any.cast<int>(), 3);
     ASSERT_NE(any.data(), nullptr);
-    ASSERT_EQ(any, (entt::meta_any{std::in_place_type<int>, 42}));
-    ASSERT_EQ(any, entt::meta_any{42});
-    ASSERT_NE(entt::meta_any{3}, any);
+    ASSERT_EQ(any, (entt::meta_any{std::in_place_type<int>, 3}));
+    ASSERT_EQ(any, entt::meta_any{3});
+    ASSERT_NE(entt::meta_any{1}, any);
 }
 
 TEST_F(MetaAny, EmplaceVoid) {
@@ -864,7 +878,7 @@ TEST_F(MetaAny, EmplaceVoid) {
 }
 
 TEST_F(MetaAny, Reset) {
-    entt::meta_any any{42}; // NOLINT
+    entt::meta_any any{3};
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<int>());
@@ -877,12 +891,12 @@ TEST_F(MetaAny, Reset) {
 
 TEST_F(MetaAny, SBOSwap) {
     entt::meta_any lhs{'c'};
-    entt::meta_any rhs{42}; // NOLINT
+    entt::meta_any rhs{3};
 
     std::swap(lhs, rhs);
 
     ASSERT_FALSE(lhs.try_cast<char>());
-    ASSERT_EQ(lhs.cast<int>(), 42);
+    ASSERT_EQ(lhs.cast<int>(), 3);
     ASSERT_FALSE(rhs.try_cast<int>());
     ASSERT_EQ(rhs.cast<char>(), 'c');
 }
@@ -975,7 +989,7 @@ TEST_F(MetaAny, NoSBOWithVoidSwap) {
 }
 
 TEST_F(MetaAny, AsRef) {
-    entt::meta_any any{42}; // NOLINT
+    entt::meta_any any{3};
     auto ref = any.as_ref();
     auto cref = std::as_const(any).as_ref();
 
@@ -987,25 +1001,25 @@ TEST_F(MetaAny, AsRef) {
     ASSERT_EQ(ref.try_cast<const int>(), any.data());
     ASSERT_EQ(cref.try_cast<const int>(), any.data());
 
-    ASSERT_EQ(any.cast<int>(), 42);
-    ASSERT_EQ(ref.cast<int>(), 42);
-    ASSERT_EQ(cref.cast<int>(), 42);
+    ASSERT_EQ(any.cast<int>(), 3);
+    ASSERT_EQ(ref.cast<int>(), 3);
+    ASSERT_EQ(cref.cast<int>(), 3);
 
-    ASSERT_EQ(any.cast<const int>(), 42);
-    ASSERT_EQ(ref.cast<const int>(), 42);
-    ASSERT_EQ(cref.cast<const int>(), 42);
+    ASSERT_EQ(any.cast<const int>(), 3);
+    ASSERT_EQ(ref.cast<const int>(), 3);
+    ASSERT_EQ(cref.cast<const int>(), 3);
 
-    ASSERT_EQ(any.cast<int &>(), 42);
-    ASSERT_EQ(any.cast<const int &>(), 42);
-    ASSERT_EQ(ref.cast<int &>(), 42);
-    ASSERT_EQ(ref.cast<const int &>(), 42);
-    ASSERT_EQ(cref.cast<const int &>(), 42);
+    ASSERT_EQ(any.cast<int &>(), 3);
+    ASSERT_EQ(any.cast<const int &>(), 3);
+    ASSERT_EQ(ref.cast<int &>(), 3);
+    ASSERT_EQ(ref.cast<const int &>(), 3);
+    ASSERT_EQ(cref.cast<const int &>(), 3);
 
-    any.cast<int &>() = 3;
+    any.cast<int &>() = 1;
 
-    ASSERT_EQ(any.cast<int>(), 3);
-    ASSERT_EQ(ref.cast<int>(), 3);
-    ASSERT_EQ(cref.cast<int>(), 3);
+    ASSERT_EQ(any.cast<int>(), 1);
+    ASSERT_EQ(ref.cast<int>(), 1);
+    ASSERT_EQ(cref.cast<int>(), 1);
 
     std::swap(ref, cref);
 
@@ -1020,18 +1034,18 @@ TEST_F(MetaAny, AsRef) {
     ASSERT_EQ(ref.try_cast<const int>(), any.data());
     ASSERT_EQ(cref.try_cast<const int>(), any.data());
 
-    ASSERT_EQ(ref.cast<const int &>(), 3);
-    ASSERT_EQ(cref.cast<const int &>(), 3);
+    ASSERT_EQ(ref.cast<const int &>(), 1);
+    ASSERT_EQ(cref.cast<const int &>(), 1);
 
-    ref = 42;  // NOLINT
-    cref = 42; // NOLINT
+    ref = 3;
+    cref = 3;
 
     ASSERT_NE(ref.try_cast<int>(), nullptr);
     ASSERT_NE(cref.try_cast<int>(), nullptr);
-    ASSERT_EQ(ref.cast<int &>(), 42);
-    ASSERT_EQ(cref.cast<int &>(), 42);
-    ASSERT_EQ(ref.cast<const int &>(), 42);
-    ASSERT_EQ(cref.cast<const int &>(), 42);
+    ASSERT_EQ(ref.cast<int &>(), 3);
+    ASSERT_EQ(cref.cast<int &>(), 3);
+    ASSERT_EQ(ref.cast<const int &>(), 3);
+    ASSERT_EQ(cref.cast<const int &>(), 3);
     ASSERT_NE(ref.try_cast<int>(), any.data());
     ASSERT_NE(cref.try_cast<int>(), any.data());
 
@@ -1045,7 +1059,7 @@ TEST_F(MetaAny, AsRef) {
 }
 
 ENTT_DEBUG_TEST_F(MetaAnyDeathTest, AsRef) {
-    entt::meta_any any{42}; // NOLINT
+    entt::meta_any any{3};
     auto cref = std::as_const(any).as_ref();
 
     ASSERT_TRUE(any);
@@ -1127,7 +1141,7 @@ TEST_F(MetaAny, Cast) {
 TEST_F(MetaAny, AllowCast) {
     entt::meta_any clazz{clazz_t{}};
     entt::meta_any fat{fat_t{}};
-    entt::meta_any arithmetic{42}; // NOLINT
+    entt::meta_any arithmetic{3};
     auto as_cref = entt::forward_as_meta(arithmetic.cast<const int &>());
 
     ASSERT_TRUE(clazz);
@@ -1166,11 +1180,11 @@ TEST_F(MetaAny, AllowCast) {
 
     ASSERT_TRUE(arithmetic.allow_cast<double &>());
     ASSERT_EQ(arithmetic.type(), entt::resolve<double>());
-    ASSERT_EQ(arithmetic.cast<double &>(), 42.);
+    ASSERT_EQ(arithmetic.cast<double &>(), 3.);
 
     ASSERT_TRUE(arithmetic.allow_cast<const float &>());
     ASSERT_EQ(arithmetic.type(), entt::resolve<float>());
-    ASSERT_EQ(arithmetic.cast<float &>(), 42.f);
+    ASSERT_EQ(arithmetic.cast<float &>(), 3.f);
 
     ASSERT_TRUE(as_cref.allow_cast<int>());
     ASSERT_FALSE(as_cref.allow_cast<int &>());
@@ -1185,7 +1199,7 @@ TEST_F(MetaAny, AllowCast) {
 TEST_F(MetaAny, OpaqueAllowCast) {
     entt::meta_any clazz{clazz_t{}};
     entt::meta_any fat{fat_t{}};
-    entt::meta_any arithmetic{42}; // NOLINT
+    entt::meta_any arithmetic{3};
     auto as_cref = entt::forward_as_meta(arithmetic.cast<const int &>());
 
     ASSERT_TRUE(clazz);
@@ -1216,11 +1230,11 @@ TEST_F(MetaAny, OpaqueAllowCast) {
 
     ASSERT_TRUE(arithmetic.allow_cast(entt::resolve<double>()));
     ASSERT_EQ(arithmetic.type(), entt::resolve<double>());
-    ASSERT_EQ(arithmetic.cast<double &>(), 42.);
+    ASSERT_EQ(arithmetic.cast<double &>(), 3.);
 
     ASSERT_TRUE(arithmetic.allow_cast(entt::resolve<float>()));
     ASSERT_EQ(arithmetic.type(), entt::resolve<float>());
-    ASSERT_EQ(arithmetic.cast<float &>(), 42.f);
+    ASSERT_EQ(arithmetic.cast<float &>(), 3.f);
 
     ASSERT_TRUE(as_cref.allow_cast(entt::resolve<int>()));
     ASSERT_EQ(as_cref.type(), entt::resolve<int>());
@@ -1235,7 +1249,7 @@ TEST_F(MetaAny, OpaqueAllowCast) {
 
 TEST_F(MetaAny, Convert) {
     entt::meta_any any{clazz_t{}};
-    any.cast<clazz_t &>().value = 42; // NOLINT
+    any.cast<clazz_t &>().value = 3;
     auto as_int = std::as_const(any).allow_cast<int>();
 
     ASSERT_TRUE(any);
@@ -1244,15 +1258,15 @@ TEST_F(MetaAny, Convert) {
     ASSERT_EQ(any.type(), entt::resolve<clazz_t>());
     ASSERT_TRUE(any.allow_cast<int>());
     ASSERT_EQ(any.type(), entt::resolve<int>());
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(any.cast<int>(), 3);
 
     ASSERT_TRUE(as_int);
     ASSERT_EQ(as_int.type(), entt::resolve<int>());
-    ASSERT_EQ(as_int.cast<int>(), 42);
+    ASSERT_EQ(as_int.cast<int>(), 3);
 
     ASSERT_TRUE(as_int.allow_cast<char>());
     ASSERT_EQ(as_int.type(), entt::resolve<char>());
-    ASSERT_EQ(as_int.cast<char>(), char{42});
+    ASSERT_EQ(as_int.cast<char>(), char{3});
 }
 
 TEST_F(MetaAny, ArithmeticConversion) {
@@ -1296,7 +1310,7 @@ TEST_F(MetaAny, EnumConversion) {
 
     ASSERT_TRUE(any.allow_cast(entt::resolve<int>()));
     ASSERT_EQ(any.type(), entt::resolve<int>());
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(any.cast<int>(), 1);
 
     ASSERT_TRUE(any.allow_cast<enum_class>());
     ASSERT_EQ(any.type(), entt::resolve<enum_class>());
@@ -1338,13 +1352,13 @@ TEST_F(MetaAny, Invoke) {
     auto any = entt::forward_as_meta(instance);
 
     ASSERT_TRUE(any.invoke("func"_hs));
-    ASSERT_TRUE(any.invoke("member"_hs, 42));
-    ASSERT_FALSE(std::as_const(any).invoke("member"_hs, 42));
-    ASSERT_FALSE(std::as_const(any).as_ref().invoke("member"_hs, 42));
-    ASSERT_FALSE(any.invoke("non_existent"_hs, 42));
+    ASSERT_TRUE(any.invoke("member"_hs, 3));
+    ASSERT_FALSE(std::as_const(any).invoke("member"_hs, 3));
+    ASSERT_FALSE(std::as_const(any).as_ref().invoke("member"_hs, 3));
+    ASSERT_FALSE(any.invoke("non_existent"_hs, 3));
 
     ASSERT_EQ(clazz_t::c, 'd');
-    ASSERT_EQ(instance.value, 42);
+    ASSERT_EQ(instance.value, 3);
 }
 
 TEST_F(MetaAny, SetGet) {
@@ -1353,7 +1367,7 @@ TEST_F(MetaAny, SetGet) {
     clazz_t instance;
     auto any = entt::forward_as_meta(instance);
 
-    ASSERT_TRUE(any.set("value"_hs, 42));
+    ASSERT_TRUE(any.set("value"_hs, 3));
 
     const auto value = std::as_const(any).get("value"_hs);
 
@@ -1361,15 +1375,15 @@ TEST_F(MetaAny, SetGet) {
     ASSERT_EQ(value, any.get("value"_hs));
     ASSERT_EQ(value, std::as_const(any).as_ref().get("value"_hs));
     ASSERT_NE(value.try_cast<int>(), nullptr);
-    ASSERT_EQ(value.cast<int>(), 42);
-    ASSERT_EQ(instance.value, 42);
+    ASSERT_EQ(value.cast<int>(), 3);
+    ASSERT_EQ(instance.value, 3);
 
-    ASSERT_FALSE(any.set("non_existent"_hs, 42));
+    ASSERT_FALSE(any.set("non_existent"_hs, 3));
     ASSERT_FALSE(any.get("non_existent"_hs));
 }
 
 TEST_F(MetaAny, ForwardAsMeta) {
-    int value = 42; // NOLINT
+    int value = 3;
     auto ref = entt::forward_as_meta(value);
     auto cref = entt::forward_as_meta(std::as_const(value));
     auto any = entt::forward_as_meta(static_cast<int &&>(value));
@@ -1382,9 +1396,9 @@ TEST_F(MetaAny, ForwardAsMeta) {
     ASSERT_NE(ref.try_cast<int>(), nullptr);
     ASSERT_EQ(cref.try_cast<int>(), nullptr);
 
-    ASSERT_EQ(any.cast<const int &>(), 42);
-    ASSERT_EQ(ref.cast<const int &>(), 42);
-    ASSERT_EQ(cref.cast<const int &>(), 42);
+    ASSERT_EQ(any.cast<const int &>(), 3);
+    ASSERT_EQ(ref.cast<const int &>(), 3);
+    ASSERT_EQ(cref.cast<const int &>(), 3);
 
     ASSERT_NE(any.data(), &value);
     ASSERT_EQ(ref.data(), &value);

test/entt/meta/meta_base.cpp

@@ -62,7 +62,7 @@ struct MetaBase: ::testing::Test {
 
 TEST_F(MetaBase, Functionalities) {
     auto any = entt::resolve<derived_t>().construct();
-    any.cast<derived_t &>().value_1 = 42; // NOLINT
+    any.cast<derived_t &>().value_1 = 2;
     auto as_derived = any.as_ref();
 
     ASSERT_TRUE(any.allow_cast<base_1_t &>());
@@ -90,27 +90,27 @@ TEST_F(MetaBase, SetGetWithMutatingThis) {
     ASSERT_EQ(static_cast<const void *>(static_cast<const base_2_t *>(&instance)), static_cast<const void *>(static_cast<const base_3_t *>(&instance)));
     ASSERT_EQ(static_cast<const void *>(&instance), static_cast<const void *>(static_cast<const base_1_t *>(&instance)));
 
-    ASSERT_TRUE(any.set("value"_hs, 42));
+    ASSERT_TRUE(any.set("value"_hs, 0));
     ASSERT_TRUE(any.set("value_1"_hs, 1));
     ASSERT_TRUE(any.set("value_2"_hs, 2));
     ASSERT_TRUE(any.set("value_3"_hs, 3));
 
-    ASSERT_FALSE(as_cref.set("value"_hs, 0));
-    ASSERT_FALSE(as_cref.set("value_1"_hs, 0));
-    ASSERT_FALSE(as_cref.set("value_2"_hs, 0));
-    ASSERT_FALSE(as_cref.set("value_3"_hs, 0));
+    ASSERT_FALSE(as_cref.set("value"_hs, 4));
+    ASSERT_FALSE(as_cref.set("value_1"_hs, 4));
+    ASSERT_FALSE(as_cref.set("value_2"_hs, 4));
+    ASSERT_FALSE(as_cref.set("value_3"_hs, 4));
 
-    ASSERT_EQ(any.get("value"_hs).cast<int>(), 42);
+    ASSERT_EQ(any.get("value"_hs).cast<int>(), 0);
     ASSERT_EQ(any.get("value_1"_hs).cast<const int>(), 1);
     ASSERT_EQ(any.get("value_2"_hs).cast<int>(), 2);
     ASSERT_EQ(any.get("value_3"_hs).cast<const int>(), 3);
 
-    ASSERT_EQ(as_cref.get("value"_hs).cast<const int>(), 42);
+    ASSERT_EQ(as_cref.get("value"_hs).cast<const int>(), 0);
     ASSERT_EQ(as_cref.get("value_1"_hs).cast<int>(), 1);
     ASSERT_EQ(as_cref.get("value_2"_hs).cast<const int>(), 2);
     ASSERT_EQ(as_cref.get("value_3"_hs).cast<int>(), 3);
 
-    ASSERT_EQ(instance.value, 42);
+    ASSERT_EQ(instance.value, 0);
     ASSERT_EQ(instance.value_1, 1);
     ASSERT_EQ(instance.value_2, 2);
     ASSERT_EQ(instance.value_3, 3);
@@ -120,41 +120,41 @@ TEST_F(MetaBase, ConvWithMutatingThis) {
     entt::meta_any any{derived_t{}};
     auto &&ref = any.cast<derived_t &>();
     auto as_cref = std::as_const(any).as_ref();
-    ref.value_2 = 42; // NOLINT
+    ref.value_2 = 2;
 
     auto conv = std::as_const(any).allow_cast<int>();
     auto from_cref = std::as_const(as_cref).allow_cast<int>();
 
     ASSERT_TRUE(conv);
     ASSERT_TRUE(from_cref);
-    ASSERT_EQ(conv.cast<int>(), 42);
-    ASSERT_EQ(from_cref.cast<int>(), 42);
+    ASSERT_EQ(conv.cast<int>(), 2);
+    ASSERT_EQ(from_cref.cast<int>(), 2);
 
     ASSERT_TRUE(as_cref.allow_cast<int>());
     ASSERT_TRUE(any.allow_cast<int>());
 
-    ASSERT_EQ(as_cref.cast<int>(), 42);
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(as_cref.cast<int>(), 2);
+    ASSERT_EQ(any.cast<int>(), 2);
 }
 
 TEST_F(MetaBase, OpaqueConvWithMutatingThis) {
     entt::meta_any any{derived_t{}};
     auto as_cref = std::as_const(any).as_ref();
-    any.cast<derived_t &>().value_2 = 42; // NOLINT
+    any.cast<derived_t &>().value_2 = 2;
 
     auto conv = std::as_const(any).allow_cast(entt::resolve<int>());
     auto from_cref = std::as_const(as_cref).allow_cast(entt::resolve<int>());
 
     ASSERT_TRUE(conv);
     ASSERT_TRUE(from_cref);
-    ASSERT_EQ(conv.cast<int>(), 42);
-    ASSERT_EQ(from_cref.cast<int>(), 42);
+    ASSERT_EQ(conv.cast<int>(), 2);
+    ASSERT_EQ(from_cref.cast<int>(), 2);
 
     ASSERT_TRUE(as_cref.allow_cast(entt::resolve<int>()));
     ASSERT_TRUE(any.allow_cast(entt::resolve<int>()));
 
-    ASSERT_EQ(as_cref.cast<int>(), 42);
-    ASSERT_EQ(any.cast<int>(), 42);
+    ASSERT_EQ(as_cref.cast<int>(), 2);
+    ASSERT_EQ(any.cast<int>(), 2);
 }
 
 TEST_F(MetaBase, AssignWithMutatingThis) {
@@ -164,10 +164,10 @@ TEST_F(MetaBase, AssignWithMutatingThis) {
     entt::meta_any src{derived_t{}};
 
     dst.cast<base_2_t &>().value_2 = 0;
-    src.cast<derived_t &>().value_2 = 42; // NOLINT
+    src.cast<derived_t &>().value_2 = 1;
 
     ASSERT_TRUE(dst.assign(src));
-    ASSERT_EQ(dst.get("value_2"_hs).cast<int>(), 42);
+    ASSERT_EQ(dst.get("value_2"_hs).cast<int>(), 1);
 }
 
 TEST_F(MetaBase, TransferWithMutatingThis) {
@@ -177,10 +177,10 @@ TEST_F(MetaBase, TransferWithMutatingThis) {
     entt::meta_any src{derived_t{}};
 
     dst.cast<base_2_t &>().value_2 = 0;
-    src.cast<derived_t &>().value_2 = 42; // NOLINT
+    src.cast<derived_t &>().value_2 = 1;
 
     ASSERT_TRUE(dst.assign(std::move(src)));
-    ASSERT_EQ(dst.get("value_2"_hs).cast<int>(), 42);
+    ASSERT_EQ(dst.get("value_2"_hs).cast<int>(), 1);
 }
 
 TEST_F(MetaBase, ReRegistration) {

test/entt/meta/meta_container.cpp

@@ -17,8 +17,8 @@
 #include "../common/non_default_constructible.h"
 
 TEST(MetaContainer, Invalid) {
-    ASSERT_FALSE(entt::meta_any{42}.as_sequence_container());
-    ASSERT_FALSE(entt::meta_any{42}.as_associative_container());
+    ASSERT_FALSE(entt::meta_any{0}.as_sequence_container());
+    ASSERT_FALSE(entt::meta_any{0}.as_associative_container());
 
     ASSERT_FALSE((entt::meta_any{std::map<int, char>{}}.as_sequence_container()));
     ASSERT_FALSE(entt::meta_any{std::vector<int>{}}.as_associative_container());
@@ -96,10 +96,10 @@ TEST(SequenceContainer, StdVector) {
     ASSERT_EQ(view.begin()->cast<int>(), 0);
     ASSERT_EQ((++view.begin())->cast<int>(), 1);
 
-    ret = view.insert(cview.end(), 42); // NOLINT
+    ret = view.insert(cview.end(), 64);
 
     ASSERT_TRUE(ret);
-    ASSERT_EQ(*ret, 42);
+    ASSERT_EQ(*ret, 64);
 
     it = view.begin();
     ret = view.erase(it);
@@ -115,7 +115,7 @@ TEST(SequenceContainer, StdVector) {
     ASSERT_EQ(ret->cast<int>(), 2);
 
     ASSERT_TRUE(view.clear());
-    ASSERT_TRUE(view.reserve(42u));
+    ASSERT_TRUE(view.reserve(8u));
     ASSERT_EQ(view.size(), 0u);
 }
 
@@ -164,7 +164,7 @@ TEST(SequenceContainer, StdVectorBool) {
     ASSERT_EQ(ret->cast<proxy_type>(), false);
 
     ASSERT_TRUE(view.clear());
-    ASSERT_TRUE(view.reserve(42u));
+    ASSERT_TRUE(view.reserve(8u));
     ASSERT_EQ(cview.size(), 0u);
 }
 
@@ -206,7 +206,7 @@ TEST(SequenceContainer, StdArray) {
     ASSERT_EQ(it->cast<int>(), 2);
 
     ASSERT_FALSE(view.clear());
-    ASSERT_FALSE(view.reserve(42u));
+    ASSERT_FALSE(view.reserve(8u));
     ASSERT_EQ(view.size(), 3u);
 }
 
@@ -242,10 +242,10 @@ TEST(SequenceContainer, StdList) {
     ASSERT_EQ(view.begin()->cast<int>(), 0);
     ASSERT_EQ((++view.begin())->cast<int>(), 1);
 
-    ret = view.insert(cview.end(), 42); // NOLINT
+    ret = view.insert(cview.end(), 64);
 
     ASSERT_TRUE(ret);
-    ASSERT_EQ(*ret, 42);
+    ASSERT_EQ(*ret, 64);
 
     it = view.begin();
     ret = view.erase(it);
@@ -261,7 +261,7 @@ TEST(SequenceContainer, StdList) {
     ASSERT_EQ(ret->cast<int>(), 2);
 
     ASSERT_TRUE(view.clear());
-    ASSERT_FALSE(view.reserve(42u));
+    ASSERT_FALSE(view.reserve(8u));
     ASSERT_EQ(view.size(), 0u);
 }
 
@@ -297,10 +297,10 @@ TEST(SequenceContainer, StdDeque) {
     ASSERT_EQ(view.begin()->cast<int>(), 0);
     ASSERT_EQ((++view.begin())->cast<int>(), 1);
 
-    ret = view.insert(cview.end(), 42); // NOLINT
+    ret = view.insert(cview.end(), 64);
 
     ASSERT_TRUE(ret);
-    ASSERT_EQ(*ret, 42);
+    ASSERT_EQ(*ret, 64);
 
     it = view.begin();
     ret = view.erase(it);
@@ -316,7 +316,7 @@ TEST(SequenceContainer, StdDeque) {
     ASSERT_EQ(ret->cast<int>(), 2);
 
     ASSERT_TRUE(view.clear());
-    ASSERT_FALSE(view.reserve(42u));
+    ASSERT_FALSE(view.reserve(8u));
     ASSERT_EQ(view.size(), 0u);
 }
 
@@ -342,18 +342,18 @@ TEST(SequenceContainer, Constness) {
     ASSERT_EQ(view.size(), 0u);
     ASSERT_EQ(view.begin(), view.end());
 
-    vec.push_back(42); // NOLINT
+    vec.push_back(64);
 
     ASSERT_EQ(view.size(), 1u);
     ASSERT_NE(view.begin(), view.end());
-    ASSERT_EQ(view[0].cast<const int &>(), 42);
+    ASSERT_EQ(view[0].cast<const int &>(), 64);
 
     auto it = view.begin();
     auto ret = view.insert(it, 0);
 
     ASSERT_FALSE(ret);
     ASSERT_EQ(view.size(), 1u);
-    ASSERT_EQ(it->cast<int>(), 42);
+    ASSERT_EQ(it->cast<int>(), 64);
     ASSERT_EQ(++it, view.end());
 
     it = view.begin();
@@ -363,7 +363,7 @@ TEST(SequenceContainer, Constness) {
     ASSERT_EQ(view.size(), 1u);
 
     ASSERT_FALSE(view.clear());
-    ASSERT_FALSE(view.reserve(42u));
+    ASSERT_FALSE(view.reserve(8u));
     ASSERT_EQ(view.size(), 1u);
 }
 
@@ -377,37 +377,37 @@ ENTT_DEBUG_TEST(SequenceContainerDeathTest, Constness) {
 }
 
 TEST(SequenceContainer, FromConstAny) {
-    const std::vector<int> vec{42};
+    const std::vector<int> vec{64};
     const entt::meta_any any{vec};
     auto view = any.as_sequence_container();
 
     ASSERT_TRUE(view);
     ASSERT_EQ(view.value_type(), entt::resolve<int>());
-    ASSERT_EQ(view[0].cast<const int &>(), 42);
+    ASSERT_EQ(view[0].cast<const int &>(), 64);
 }
 
 TEST(SequenceContainer, FromConstAnyRef) {
-    std::vector<int> vec{42}; // NOLINT
+    std::vector<int> vec{64};
     const entt::meta_any any = entt::forward_as_meta(vec);
     auto view = any.as_sequence_container();
 
     ASSERT_TRUE(view);
     ASSERT_EQ(view.value_type(), entt::resolve<int>());
-    ASSERT_EQ(view[0].cast<const int &>(), 42);
+    ASSERT_EQ(view[0].cast<const int &>(), 64);
 }
 
 TEST(SequenceContainer, FromConstAnyConstRef) {
-    std::vector<int> vec{42}; // NOLINT
+    std::vector<int> vec{64};
     const entt::meta_any any = entt::forward_as_meta(std::as_const(vec));
     auto view = any.as_sequence_container();
 
     ASSERT_TRUE(view);
     ASSERT_EQ(view.value_type(), entt::resolve<int>());
-    ASSERT_EQ(view[0].cast<const int &>(), 42);
+    ASSERT_EQ(view[0].cast<const int &>(), 64);
 }
 
 ENTT_DEBUG_TEST(SequenceContainerDeathTest, FromConstAny) {
-    const std::vector<int> vec{42};
+    const std::vector<int> vec{64};
     const entt::meta_any any{vec};
     auto view = any.as_sequence_container();
 
@@ -416,7 +416,7 @@ ENTT_DEBUG_TEST(SequenceContainerDeathTest, FromConstAny) {
 }
 
 ENTT_DEBUG_TEST(SequenceContainerDeathTest, FromConstAnyRef) {
-    std::vector<int> vec{42}; // NOLINT
+    std::vector<int> vec{64};
     const entt::meta_any any = entt::forward_as_meta(vec);
     auto view = any.as_sequence_container();
 
@@ -425,7 +425,7 @@ ENTT_DEBUG_TEST(SequenceContainerDeathTest, FromConstAnyRef) {
 }
 
 ENTT_DEBUG_TEST(SequenceContainerDeathTest, FromConstAnyConstRef) {
-    std::vector<int> vec{42}; // NOLINT
+    std::vector<int> vec{64};
     const entt::meta_any any = entt::forward_as_meta(std::as_const(vec));
     auto view = any.as_sequence_container();
 
@@ -511,7 +511,7 @@ TEST(AssociativeContainer, StdMap) {
 
     ASSERT_EQ(view.erase(1.), 1u);
     ASSERT_TRUE(view.clear());
-    ASSERT_FALSE(view.reserve(42u));
+    ASSERT_FALSE(view.reserve(8u));
     ASSERT_EQ(view.size(), 0u);
 }
 
@@ -554,7 +554,7 @@ TEST(AssociativeContainer, StdSet) {
 
     ASSERT_EQ(view.erase(1.), 1u);
     ASSERT_TRUE(view.clear());
-    ASSERT_FALSE(view.reserve(42u));
+    ASSERT_FALSE(view.reserve(8u));
     ASSERT_EQ(view.size(), 0u);
 }
 
@@ -568,7 +568,6 @@ TEST(AssociativeContainer, DenseMap) {
     map.emplace(4, '3');
 
     ASSERT_TRUE(view);
-    ASSERT_FALSE(view.key_only()); // NOLINT
     ASSERT_EQ(view.key_type(), entt::resolve<int>());
     ASSERT_EQ(view.mapped_type(), entt::resolve<char>());
     ASSERT_EQ(view.value_type(), (entt::resolve<std::pair<const int, char>>()));
@@ -602,7 +601,7 @@ TEST(AssociativeContainer, DenseMap) {
 
     ASSERT_EQ(view.erase(1.), 1u);
     ASSERT_TRUE(view.clear());
-    ASSERT_TRUE(view.reserve(42u));
+    ASSERT_TRUE(view.reserve(8u));
     ASSERT_EQ(view.size(), 0u);
 }
 
@@ -616,7 +615,6 @@ TEST(AssociativeContainer, DenseSet) {
     set.emplace(4);
 
     ASSERT_TRUE(view);
-    ASSERT_TRUE(view.key_only()); // NOLINT
     ASSERT_EQ(view.key_type(), entt::resolve<int>());
     ASSERT_EQ(view.mapped_type(), entt::meta_type{});
     ASSERT_EQ(view.value_type(), entt::resolve<int>());
@@ -649,7 +647,7 @@ TEST(AssociativeContainer, DenseSet) {
 
     ASSERT_EQ(view.erase(1.), 1u);
     ASSERT_TRUE(view.clear());
-    ASSERT_TRUE(view.reserve(42u));
+    ASSERT_TRUE(view.reserve(8u));
     ASSERT_EQ(view.size(), 0u);
 }
 
@@ -659,7 +657,6 @@ TEST(KeyValueAssociativeContainer, Constness) {
     auto view = any.as_associative_container();
 
     ASSERT_TRUE(view);
-    ASSERT_FALSE(view.key_only()); // NOLINT
     ASSERT_EQ(view.key_type(), entt::resolve<int>());
     ASSERT_EQ(view.mapped_type(), entt::resolve<char>());
     ASSERT_EQ(view.value_type(), (entt::resolve<std::pair<const int, char>>()));
@@ -683,7 +680,7 @@ TEST(KeyValueAssociativeContainer, Constness) {
     ASSERT_NE(view.find(2), view.end());
 
     ASSERT_FALSE(view.clear());
-    ASSERT_FALSE(view.reserve(42u));
+    ASSERT_FALSE(view.reserve(8u));
     ASSERT_EQ(view.size(), 1u);
 }
 
@@ -702,7 +699,6 @@ TEST(KeyOnlyAssociativeContainer, Constness) {
     auto view = any.as_associative_container();
 
     ASSERT_TRUE(view);
-    ASSERT_TRUE(view.key_only()); // NOLINT
     ASSERT_EQ(view.key_type(), entt::resolve<int>());
     ASSERT_EQ(view.mapped_type(), entt::meta_type{});
     ASSERT_EQ(view.value_type(), (entt::resolve<int>()));
@@ -730,7 +726,7 @@ TEST(KeyOnlyAssociativeContainer, Constness) {
     ASSERT_NE(view.find(2), view.end());
 
     ASSERT_FALSE(view.clear());
-    ASSERT_FALSE(view.reserve(42u));
+    ASSERT_FALSE(view.reserve(8u));
     ASSERT_EQ(view.size(), 1u);
 }
 

test/entt/meta/meta_context.cpp

@@ -197,7 +197,7 @@ TEST_F(MetaContext, MetaType) {
     ASSERT_EQ(global.id(), "foo"_hs);
     ASSERT_EQ(local.id(), "bar"_hs);
 
-    clazz instance{'c', 99}; // NOLINT
+    clazz instance{'c', 8};
     const argument value{2};
 
     ASSERT_NE(instance.value, value.get());
@@ -243,7 +243,7 @@ TEST_F(MetaContext, MetaData) {
     ASSERT_EQ(global.data("rw"_hs).arg(0u).data("marker"_hs).get({}).cast<int>(), global_marker);
     ASSERT_EQ(local.data("rw"_hs).arg(0u).data("marker"_hs).get({}).cast<int>(), local_marker);
 
-    clazz instance{'c', 99}; // NOLINT
+    clazz instance{'c', 8};
     const argument value{2};
 
     ASSERT_NE(instance.value, value.get());
@@ -278,7 +278,7 @@ TEST_F(MetaContext, MetaFunc) {
     ASSERT_EQ(global.func("func"_hs).ret().data("marker"_hs).get({}).cast<int>(), global_marker);
     ASSERT_EQ(local.func("func"_hs).ret().data("marker"_hs).get({}).cast<int>(), local_marker);
 
-    clazz instance{'c', 99}; // NOLINT
+    clazz instance{'c', 8};
     const argument value{2};
 
     ASSERT_NE(instance.value, value.get());
@@ -393,7 +393,7 @@ TEST_F(MetaContext, MetaTemplate) {
 TEST_F(MetaContext, MetaPointer) {
     using namespace entt::literals;
 
-    int value = 42; // NOLINT
+    int value = 2;
 
     const entt::meta_any global{&value};
     const entt::meta_any local{ctx(), &value};
@@ -459,9 +459,9 @@ TEST_F(MetaContext, MetaSequenceContainer) {
 TEST_F(MetaContext, MetaAny) {
     using namespace entt::literals;
 
-    const entt::meta_any global{42};
-    const entt::meta_any ctx_value{ctx(), 42};
-    const entt::meta_any in_place{ctx(), std::in_place_type<int>, 42};
+    const entt::meta_any global{2};
+    const entt::meta_any ctx_value{ctx(), 2};
+    const entt::meta_any in_place{ctx(), std::in_place_type<int>, 2};
     entt::meta_any two_step_local{entt::meta_ctx_arg, ctx()};
 
     ASSERT_TRUE(global);
@@ -469,7 +469,7 @@ TEST_F(MetaContext, MetaAny) {
     ASSERT_TRUE(in_place);
     ASSERT_FALSE(two_step_local);
 
-    two_step_local = 42; // NOLINT
+    two_step_local = 2;
 
     ASSERT_TRUE(two_step_local);
 
@@ -482,7 +482,7 @@ TEST_F(MetaContext, MetaAny) {
 TEST_F(MetaContext, MetaHandle) {
     using namespace entt::literals;
 
-    int value = 42; // NOLINT
+    int value = 2;
 
     entt::meta_handle global{value};
     entt::meta_handle ctx_value{ctx(), value};
@@ -504,8 +504,8 @@ TEST_F(MetaContext, MetaHandle) {
 TEST_F(MetaContext, ForwardAsMeta) {
     using namespace entt::literals;
 
-    const auto global = entt::forward_as_meta(42);
-    const auto local = entt::forward_as_meta(ctx(), 42);
+    const auto global = entt::forward_as_meta(2);
+    const auto local = entt::forward_as_meta(ctx(), 2);
 
     ASSERT_TRUE(global);
     ASSERT_TRUE(local);

test/entt/meta/meta_conv.cpp

@@ -44,7 +44,7 @@ struct MetaConv: ::testing::Test {
 
 TEST_F(MetaConv, Functionalities) {
     auto any = entt::resolve<clazz_t>().construct();
-    any.cast<clazz_t &>().value = 42; // NOLINT
+    any.cast<clazz_t &>().value = 2;
 
     const auto as_int = std::as_const(any).allow_cast<int>();
     const auto as_bool = std::as_const(any).allow_cast<bool>();

test/entt/meta/meta_ctor.cpp

@@ -43,7 +43,7 @@ struct clazz_t {
 };
 
 double double_factory() {
-    return 42.;
+    return 1.;
 }
 
 struct MetaCtor: ::testing::Test {
@@ -74,26 +74,26 @@ struct MetaCtor: ::testing::Test {
 };
 
 TEST_F(MetaCtor, Functionalities) {
-    auto any = entt::resolve<clazz_t>().construct(42, 'c'); // NOLINT
+    auto any = entt::resolve<clazz_t>().construct(1, 'c');
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().i, 1);
     ASSERT_EQ(any.cast<clazz_t>().c, 'c');
 }
 
 TEST_F(MetaCtor, Func) {
-    auto any = entt::resolve<clazz_t>().construct(42); // NOLINT
+    auto any = entt::resolve<clazz_t>().construct(1);
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().i, 1);
     ASSERT_EQ(any.cast<clazz_t>().c, 'c');
 }
 
 TEST_F(MetaCtor, MetaAnyArgs) {
-    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{42}, entt::meta_any{'c'}); // NOLINT
+    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{1}, entt::meta_any{'c'});
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().i, 1);
     ASSERT_EQ(any.cast<clazz_t>().c, 'c');
 }
 
@@ -102,10 +102,10 @@ TEST_F(MetaCtor, InvalidArgs) {
 }
 
 TEST_F(MetaCtor, CastAndConvert) {
-    auto any = entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{42, 'd'}); // NOLINT
+    auto any = entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{1, 'd'});
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().i, 1);
     ASSERT_EQ(any.cast<clazz_t>().c, 'c');
 }
 
@@ -118,31 +118,31 @@ TEST_F(MetaCtor, ArithmeticConversion) {
 }
 
 TEST_F(MetaCtor, ConstNonConstRefArgs) {
-    int ivalue = 42; // NOLINT
+    int ivalue = 1;
     const char cvalue = 'c';
     auto any = entt::resolve<clazz_t>().construct(entt::forward_as_meta(ivalue), entt::forward_as_meta(cvalue));
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().i, 1);
     ASSERT_EQ(any.cast<clazz_t>().c, 'c');
 }
 
 TEST_F(MetaCtor, WrongConstness) {
-    int value = 42; // NOLINT
+    int value = 1;
     auto any = entt::resolve<clazz_t>().construct(derived_t{}, entt::forward_as_meta(value));
     auto other = entt::resolve<clazz_t>().construct(derived_t{}, entt::forward_as_meta(std::as_const(value)));
 
     ASSERT_TRUE(any);
     ASSERT_FALSE(other);
-    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().i, 1);
     ASSERT_EQ(any.cast<clazz_t>().c, 'c');
 }
 
 TEST_F(MetaCtor, FuncMetaAnyArgs) {
-    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{42}); // NOLINT
+    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{1});
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().i, 1);
     ASSERT_EQ(any.cast<clazz_t>().c, 'c');
 }
 
@@ -163,14 +163,14 @@ TEST_F(MetaCtor, FuncArithmeticConversion) {
 }
 
 TEST_F(MetaCtor, FuncConstNonConstRefArgs) {
-    int ivalue = 42; // NOLINT
+    int ivalue = 1;
     auto any = entt::resolve<clazz_t>().construct(entt::forward_as_meta(ivalue));
     auto other = entt::resolve<clazz_t>().construct(entt::forward_as_meta(std::as_const(ivalue)));
 
     ASSERT_TRUE(any);
     ASSERT_TRUE(other);
-    ASSERT_EQ(any.cast<clazz_t>().i, 42);
-    ASSERT_EQ(other.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().i, 1);
+    ASSERT_EQ(other.cast<clazz_t>().i, 1);
 }
 
 TEST_F(MetaCtor, ExternalMemberFunction) {
@@ -193,7 +193,7 @@ TEST_F(MetaCtor, OverrideImplicitlyGeneratedDefaultConstructor) {
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<double>());
-    ASSERT_EQ(any.cast<double>(), 42.);
+    ASSERT_EQ(any.cast<double>(), 1.);
 }
 
 TEST_F(MetaCtor, NonDefaultConstructibleType) {

test/entt/meta/meta_data.cpp

@@ -168,8 +168,8 @@ TEST_F(MetaData, Functionalities) {
     ASSERT_FALSE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
-    ASSERT_TRUE(data.set(instance, 42));
-    ASSERT_EQ(data.get(instance).cast<int>(), 42);
+    ASSERT_TRUE(data.set(instance, 1));
+    ASSERT_EQ(data.get(instance).cast<int>(), 1);
 
     for(auto curr: data.prop()) {
         ASSERT_EQ(curr.first, 3u);
@@ -198,7 +198,7 @@ TEST_F(MetaData, Const) {
     ASSERT_TRUE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 1);
-    ASSERT_FALSE(data.set(instance, 42));
+    ASSERT_FALSE(data.set(instance, 1));
     ASSERT_EQ(data.get(instance).cast<int>(), 1);
 
     for(auto curr: data.prop()) {
@@ -227,8 +227,8 @@ TEST_F(MetaData, Static) {
     ASSERT_FALSE(data.is_const());
     ASSERT_TRUE(data.is_static());
     ASSERT_EQ(data.get({}).cast<int>(), 2);
-    ASSERT_TRUE(data.set({}, 42));
-    ASSERT_EQ(data.get({}).cast<int>(), 42);
+    ASSERT_TRUE(data.set({}, 1));
+    ASSERT_EQ(data.get({}).cast<int>(), 1);
 
     for(auto curr: data.prop()) {
         ASSERT_EQ(curr.first, static_cast<entt::id_type>(property_t::random));
@@ -256,7 +256,7 @@ TEST_F(MetaData, ConstStatic) {
     ASSERT_TRUE(data.is_const());
     ASSERT_TRUE(data.is_static());
     ASSERT_EQ(data.get({}).cast<int>(), 3);
-    ASSERT_FALSE(data.set({}, 42));
+    ASSERT_FALSE(data.set({}, 1));
     ASSERT_EQ(data.get({}).cast<int>(), 3);
 
     for(auto curr: data.prop()) {
@@ -277,12 +277,12 @@ TEST_F(MetaData, GetMetaAnyArg) {
     using namespace entt::literals;
 
     entt::meta_any any{clazz_t{}};
-    any.cast<clazz_t &>().i = 99; // NOLINT
+    any.cast<clazz_t &>().i = 3;
     const auto value = entt::resolve<clazz_t>().data("i"_hs).get(any);
 
     ASSERT_TRUE(value);
     ASSERT_TRUE(static_cast<bool>(value.cast<int>()));
-    ASSERT_EQ(value.cast<int>(), 99);
+    ASSERT_EQ(value.cast<int>(), 3);
 }
 
 TEST_F(MetaData, GetInvalidArg) {
@@ -296,11 +296,11 @@ TEST_F(MetaData, SetMetaAnyArg) {
     using namespace entt::literals;
 
     entt::meta_any any{clazz_t{}};
-    const entt::meta_any value{42};
+    const entt::meta_any value{1};
 
     ASSERT_EQ(any.cast<clazz_t>().i, 0);
     ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, value));
-    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().i, 1);
 }
 
 TEST_F(MetaData, SetInvalidArg) {
@@ -323,22 +323,22 @@ TEST_F(MetaData, SetConvert) {
     using namespace entt::literals;
 
     clazz_t instance{};
-    instance.h = 42; // NOLINT
+    instance.h = 1;
 
     ASSERT_EQ(instance.i, 0);
     ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(instance, instance));
-    ASSERT_EQ(instance.i, 42);
+    ASSERT_EQ(instance.i, 1);
 }
 
 TEST_F(MetaData, SetByRef) {
     using namespace entt::literals;
 
     entt::meta_any any{clazz_t{}};
-    int value{42}; // NOLINT
+    int value{1};
 
     ASSERT_EQ(any.cast<clazz_t>().i, 0);
     ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, entt::forward_as_meta(value)));
-    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().i, 1);
 
     value = 3;
     auto wrapper = entt::forward_as_meta(value);
@@ -351,11 +351,11 @@ TEST_F(MetaData, SetByConstRef) {
     using namespace entt::literals;
 
     entt::meta_any any{clazz_t{}};
-    int value{42}; // NOLINT
+    int value{1};
 
     ASSERT_EQ(any.cast<clazz_t>().i, 0);
     ASSERT_TRUE(entt::resolve<clazz_t>().data("i"_hs).set(any, entt::forward_as_meta(std::as_const(value))));
-    ASSERT_EQ(any.cast<clazz_t>().i, 42);
+    ASSERT_EQ(any.cast<clazz_t>().i, 1);
 
     value = 3;
     auto wrapper = entt::forward_as_meta(std::as_const(value));
@@ -377,8 +377,8 @@ TEST_F(MetaData, SetterGetterAsFreeFunctions) {
     ASSERT_FALSE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
-    ASSERT_TRUE(data.set(instance, 42));
-    ASSERT_EQ(data.get(instance).cast<int>(), 42);
+    ASSERT_TRUE(data.set(instance, 1));
+    ASSERT_EQ(data.get(instance).cast<int>(), 1);
 }
 
 TEST_F(MetaData, SetterGetterAsMemberFunctions) {
@@ -394,8 +394,8 @@ TEST_F(MetaData, SetterGetterAsMemberFunctions) {
     ASSERT_FALSE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
-    ASSERT_TRUE(data.set(instance, 42.));
-    ASSERT_EQ(data.get(instance).cast<int>(), 42);
+    ASSERT_TRUE(data.set(instance, 1.));
+    ASSERT_EQ(data.get(instance).cast<int>(), 1);
     ASSERT_TRUE(data.set(instance, 3));
     ASSERT_EQ(data.get(instance).cast<int>(), 3);
 }
@@ -413,8 +413,8 @@ TEST_F(MetaData, SetterGetterWithRefAsMemberFunctions) {
     ASSERT_FALSE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
-    ASSERT_TRUE(data.set(instance, 42));
-    ASSERT_EQ(data.get(instance).cast<int>(), 42);
+    ASSERT_TRUE(data.set(instance, 1));
+    ASSERT_EQ(data.get(instance).cast<int>(), 1);
 }
 
 TEST_F(MetaData, SetterGetterMixed) {
@@ -430,8 +430,8 @@ TEST_F(MetaData, SetterGetterMixed) {
     ASSERT_FALSE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
-    ASSERT_TRUE(data.set(instance, 42));
-    ASSERT_EQ(data.get(instance).cast<int>(), 42);
+    ASSERT_TRUE(data.set(instance, 1));
+    ASSERT_EQ(data.get(instance).cast<int>(), 1);
 }
 
 TEST_F(MetaData, SetterGetterReadOnly) {
@@ -447,7 +447,7 @@ TEST_F(MetaData, SetterGetterReadOnly) {
     ASSERT_TRUE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
-    ASSERT_FALSE(data.set(instance, 42));
+    ASSERT_FALSE(data.set(instance, 1));
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
 }
 
@@ -464,7 +464,7 @@ TEST_F(MetaData, SetterGetterReadOnlyDataMember) {
     ASSERT_TRUE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
-    ASSERT_FALSE(data.set(instance, 42));
+    ASSERT_FALSE(data.set(instance, 1));
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
 }
 
@@ -483,13 +483,13 @@ TEST_F(MetaData, MultiSetter) {
     ASSERT_FALSE(data.is_const());
     ASSERT_FALSE(data.is_static());
     ASSERT_EQ(data.get(instance).cast<int>(), 0);
-    ASSERT_TRUE(data.set(instance, 42));
-    ASSERT_EQ(data.get(instance).cast<int>(), 42);
-    ASSERT_TRUE(data.set(instance, 3.));
+    ASSERT_TRUE(data.set(instance, 1));
+    ASSERT_EQ(data.get(instance).cast<int>(), 1);
+    ASSERT_TRUE(data.set(instance, 2.));
+    ASSERT_EQ(data.get(instance).cast<int>(), 2);
+    ASSERT_FALSE(data.set(instance, std::string{"3"}));
+    ASSERT_TRUE(data.set(instance, std::string{"3"}.c_str()));
     ASSERT_EQ(data.get(instance).cast<int>(), 3);
-    ASSERT_FALSE(data.set(instance, std::string{"99"}));
-    ASSERT_TRUE(data.set(instance, std::string{"99"}.c_str()));
-    ASSERT_EQ(data.get(instance).cast<int>(), 99);
 }
 
 TEST_F(MetaData, ConstInstance) {
@@ -560,8 +560,8 @@ TEST_F(MetaData, AsVoid) {
     ASSERT_EQ(data.arity(), 1u);
     ASSERT_EQ(data.type(), entt::resolve<int>());
     ASSERT_EQ(data.arg(0u), entt::resolve<int>());
-    ASSERT_TRUE(data.set(instance, 42));
-    ASSERT_EQ(instance.i, 42);
+    ASSERT_TRUE(data.set(instance, 1));
+    ASSERT_EQ(instance.i, 1);
     ASSERT_EQ(data.get(instance), entt::meta_any{std::in_place_type<void>});
 }
 
@@ -617,9 +617,9 @@ TEST_F(MetaData, SetGetBaseData) {
     ASSERT_TRUE(type.data("value"_hs));
 
     ASSERT_EQ(instance.value, 3);
-    ASSERT_TRUE(type.data("value"_hs).set(instance, 42));
-    ASSERT_EQ(type.data("value"_hs).get(instance).cast<int>(), 42);
-    ASSERT_EQ(instance.value, 42);
+    ASSERT_TRUE(type.data("value"_hs).set(instance, 1));
+    ASSERT_EQ(type.data("value"_hs).get(instance).cast<int>(), 1);
+    ASSERT_EQ(instance.value, 1);
 }
 
 TEST_F(MetaData, SetGetFromBase) {
@@ -631,9 +631,9 @@ TEST_F(MetaData, SetGetFromBase) {
     ASSERT_TRUE(type.data("value_from_base"_hs));
 
     ASSERT_EQ(instance.value, 3);
-    ASSERT_TRUE(type.data("value_from_base"_hs).set(instance, 42));
-    ASSERT_EQ(type.data("value_from_base"_hs).get(instance).cast<int>(), 42);
-    ASSERT_EQ(instance.value, 42);
+    ASSERT_TRUE(type.data("value_from_base"_hs).set(instance, 1));
+    ASSERT_EQ(type.data("value_from_base"_hs).get(instance).cast<int>(), 1);
+    ASSERT_EQ(instance.value, 1);
 }
 
 TEST_F(MetaData, ReRegistration) {

test/entt/meta/meta_func.cpp

@@ -259,11 +259,11 @@ TEST_F(MetaFunc, RetVoid) {
     ASSERT_EQ(func.arg(0u), entt::resolve<int>());
     ASSERT_FALSE(func.arg(1u));
 
-    auto any = func.invoke(instance, 5); // NOLINT
+    auto any = func.invoke(instance, 4);
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<void>());
-    ASSERT_EQ(func_t::value, 25);
+    ASSERT_EQ(func_t::value, 16);
 
     for(auto curr: func.prop()) {
         ASSERT_EQ(curr.first, "true"_hs);
@@ -328,11 +328,11 @@ TEST_F(MetaFunc, StaticRetVoid) {
     ASSERT_EQ(func.arg(0u), entt::resolve<int>());
     ASSERT_FALSE(func.arg(1u));
 
-    auto any = func.invoke({}, 42); // NOLINT
+    auto any = func.invoke({}, 3);
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<void>());
-    ASSERT_EQ(func_t::value, 42);
+    ASSERT_EQ(func_t::value, 3);
 
     for(auto curr: func.prop()) {
         ASSERT_EQ(curr.first, "true"_hs);
@@ -353,7 +353,7 @@ TEST_F(MetaFunc, StaticAsMember) {
 
     base_t instance{};
     auto func = entt::resolve<base_t>().func("fake_member"_hs);
-    auto any = func.invoke(instance, 42); // NOLINT
+    auto any = func.invoke(instance, 3);
 
     ASSERT_TRUE(func);
     ASSERT_EQ(func.arity(), 1u);
@@ -365,12 +365,12 @@ TEST_F(MetaFunc, StaticAsMember) {
 
     ASSERT_EQ(func.prop().cbegin(), func.prop().cend());
 
-    ASSERT_FALSE(func.invoke({}, 42));
-    ASSERT_FALSE(func.invoke(std::as_const(instance), 42));
+    ASSERT_FALSE(func.invoke({}, 3));
+    ASSERT_FALSE(func.invoke(std::as_const(instance), 3));
 
     ASSERT_TRUE(any);
     ASSERT_EQ(any.type(), entt::resolve<void>());
-    ASSERT_EQ(instance.value, 42);
+    ASSERT_EQ(instance.value, 3);
 }
 
 TEST_F(MetaFunc, StaticAsConstMember) {
@@ -499,7 +499,7 @@ TEST_F(MetaFunc, ConstInstance) {
     func_t instance{};
     auto any = entt::resolve<func_t>().func("f1"_hs).invoke(std::as_const(instance), 2);
 
-    ASSERT_FALSE(entt::resolve<func_t>().func("g"_hs).invoke(std::as_const(instance), 42));
+    ASSERT_FALSE(entt::resolve<func_t>().func("g"_hs).invoke(std::as_const(instance), 1));
     ASSERT_TRUE(any);
     ASSERT_EQ(any.cast<int>(), 4);
 }
@@ -510,9 +510,9 @@ TEST_F(MetaFunc, AsVoid) {
     auto func = entt::resolve<func_t>().func("v"_hs);
     func_t instance{};
 
-    ASSERT_EQ(func.invoke(instance, 42), entt::meta_any{std::in_place_type<void>});
+    ASSERT_EQ(func.invoke(instance, 1), entt::meta_any{std::in_place_type<void>});
     ASSERT_EQ(func.ret(), entt::resolve<void>());
-    ASSERT_EQ(instance.value, 42);
+    ASSERT_EQ(instance.value, 1);
 }
 
 TEST_F(MetaFunc, AsRef) {
@@ -555,9 +555,9 @@ TEST_F(MetaFunc, InvokeBaseFunction) {
     ASSERT_TRUE(type.func("setter"_hs));
     ASSERT_EQ(instance.value, 3);
 
-    type.func("setter"_hs).invoke(instance, 42); // NOLINT
+    type.func("setter"_hs).invoke(instance, 1);
 
-    ASSERT_EQ(instance.value, 42);
+    ASSERT_EQ(instance.value, 1);
 }
 
 TEST_F(MetaFunc, InvokeFromBase) {
@@ -571,19 +571,19 @@ TEST_F(MetaFunc, InvokeFromBase) {
     ASSERT_TRUE(setter_from_base);
     ASSERT_EQ(instance.value, 3);
 
-    setter_from_base.invoke(instance, 42); // NOLINT
+    setter_from_base.invoke(instance, 1);
 
-    ASSERT_EQ(instance.value, 42);
+    ASSERT_EQ(instance.value, 1);
 
     auto getter_from_base = type.func("getter_from_base"_hs);
 
     ASSERT_TRUE(getter_from_base);
-    ASSERT_EQ(getter_from_base.invoke(instance).cast<int>(), 42);
+    ASSERT_EQ(getter_from_base.invoke(instance).cast<int>(), 1);
 
     auto static_setter_from_base = type.func("static_setter_from_base"_hs);
 
     ASSERT_TRUE(static_setter_from_base);
-    ASSERT_EQ(instance.value, 42);
+    ASSERT_EQ(instance.value, 1);
 
     static_setter_from_base.invoke(instance, 3);
 

test/entt/meta/meta_pointer.cpp

@@ -79,7 +79,7 @@ Type &dereference_meta_pointer_like(const adl_wrapped_shared_ptr<Type> &ptr) {
 }
 
 int test_function() {
-    return 42; // NOLINT
+    return 3;
 }
 
 TEST(MetaPointerLike, DereferenceOperatorInvalidType) {
@@ -96,7 +96,7 @@ TEST(MetaPointerLike, DereferenceOperatorInvalidType) {
 }
 
 TEST(MetaPointerLike, DereferenceOperatorConstType) {
-    const int value = 42;
+    const int value = 3;
     const entt::meta_any any{&value};
 
     ASSERT_TRUE(any.type().is_pointer());
@@ -112,11 +112,11 @@ TEST(MetaPointerLike, DereferenceOperatorConstType) {
 
     ASSERT_EQ(deref.try_cast<int>(), nullptr);
     ASSERT_EQ(deref.try_cast<const int>(), &value);
-    ASSERT_EQ(deref.cast<const int &>(), 42);
+    ASSERT_EQ(deref.cast<const int &>(), 3);
 }
 
 ENTT_DEBUG_TEST(MetaPointerLikeDeathTest, DereferenceOperatorConstType) {
-    const int value = 42;
+    const int value = 3;
     const entt::meta_any any{&value};
     auto deref = *any;
 
@@ -125,7 +125,7 @@ ENTT_DEBUG_TEST(MetaPointerLikeDeathTest, DereferenceOperatorConstType) {
 }
 
 TEST(MetaPointerLike, DereferenceOperatorConstAnyNonConstType) {
-    int value = 42; // NOLINT
+    int value = 3;
     const entt::meta_any any{&value};
     auto deref = *any;
 
@@ -136,12 +136,12 @@ TEST(MetaPointerLike, DereferenceOperatorConstAnyNonConstType) {
 
     ASSERT_NE(deref.try_cast<int>(), nullptr);
     ASSERT_NE(deref.try_cast<const int>(), nullptr);
-    ASSERT_EQ(deref.cast<int &>(), 42);
-    ASSERT_EQ(deref.cast<const int &>(), 42);
+    ASSERT_EQ(deref.cast<int &>(), 3);
+    ASSERT_EQ(deref.cast<const int &>(), 3);
 }
 
 TEST(MetaPointerLike, DereferenceOperatorConstAnyConstType) {
-    const int value = 42;
+    const int value = 3;
     const entt::meta_any any{&value};
     auto deref = *any;
 
@@ -152,11 +152,11 @@ TEST(MetaPointerLike, DereferenceOperatorConstAnyConstType) {
 
     ASSERT_EQ(deref.try_cast<int>(), nullptr);
     ASSERT_NE(deref.try_cast<const int>(), nullptr);
-    ASSERT_EQ(deref.cast<const int &>(), 42);
+    ASSERT_EQ(deref.cast<const int &>(), 3);
 }
 
 ENTT_DEBUG_TEST(MetaPointerLikeDeathTest, DereferenceOperatorConstAnyConstType) {
-    const int value = 42;
+    const int value = 3;
     const entt::meta_any any{&value};
     auto deref = *any;
 
@@ -179,10 +179,10 @@ TEST(MetaPointerLike, DereferenceOperatorRawPointer) {
     ASSERT_FALSE(deref.type().is_pointer_like());
     ASSERT_EQ(deref.type(), entt::resolve<int>());
 
-    deref.cast<int &>() = 42; // NOLINT
+    deref.cast<int &>() = 3;
 
-    ASSERT_EQ(*any.cast<int *>(), 42);
-    ASSERT_EQ(value, 42);
+    ASSERT_EQ(*any.cast<int *>(), 3);
+    ASSERT_EQ(value, 3);
 }
 
 TEST(MetaPointerLike, DereferenceOperatorSmartPointer) {
@@ -200,10 +200,10 @@ TEST(MetaPointerLike, DereferenceOperatorSmartPointer) {
     ASSERT_FALSE(deref.type().is_pointer_like());
     ASSERT_EQ(deref.type(), entt::resolve<int>());
 
-    deref.cast<int &>() = 42; // NOLINT
+    deref.cast<int &>() = 3;
 
-    ASSERT_EQ(*any.cast<std::shared_ptr<int>>(), 42);
-    ASSERT_EQ(*value, 42);
+    ASSERT_EQ(*any.cast<std::shared_ptr<int>>(), 3);
+    ASSERT_EQ(*value, 3);
 }
 
 TEST(MetaPointerLike, PointerToConstMoveOnlyType) {
@@ -235,14 +235,14 @@ TEST(MetaPointerLike, AsRef) {
     ASSERT_FALSE(deref.type().is_pointer_like());
     ASSERT_EQ(deref.type(), entt::resolve<int>());
 
-    deref.cast<int &>() = 42; // NOLINT
+    deref.cast<int &>() = 3;
 
-    ASSERT_EQ(*any.cast<int *>(), 42);
-    ASSERT_EQ(value, 42);
+    ASSERT_EQ(*any.cast<int *>(), 3);
+    ASSERT_EQ(value, 3);
 }
 
 TEST(MetaPointerLike, AsConstRef) {
-    int value = 42; // NOLINT
+    int value = 3;
     int *const ptr = &value;
     entt::meta_any any{entt::forward_as_meta(ptr)};
 
@@ -257,14 +257,14 @@ TEST(MetaPointerLike, AsConstRef) {
     ASSERT_FALSE(deref.type().is_pointer_like());
     ASSERT_EQ(deref.type(), entt::resolve<int>());
 
-    deref.cast<int &>() = 42; // NOLINT
+    deref.cast<int &>() = 3;
 
-    ASSERT_EQ(*any.cast<int *>(), 42);
-    ASSERT_EQ(value, 42);
+    ASSERT_EQ(*any.cast<int *>(), 3);
+    ASSERT_EQ(value, 3);
 }
 
 TEST(MetaPointerLike, DereferenceOverloadAdl) {
-    const entt::meta_any any{adl_wrapped_shared_ptr<int>{42}};
+    const entt::meta_any any{adl_wrapped_shared_ptr<int>{3}};
 
     ASSERT_FALSE(any.type().is_pointer());
     ASSERT_TRUE(any.type().is_pointer_like());
@@ -276,12 +276,12 @@ TEST(MetaPointerLike, DereferenceOverloadAdl) {
     ASSERT_FALSE(deref.type().is_pointer_like());
     ASSERT_EQ(deref.type(), entt::resolve<int>());
 
-    ASSERT_EQ(deref.cast<int &>(), 42);
-    ASSERT_EQ(deref.cast<const int &>(), 42);
+    ASSERT_EQ(deref.cast<int &>(), 3);
+    ASSERT_EQ(deref.cast<const int &>(), 3);
 }
 
 TEST(MetaPointerLike, DereferenceOverloadSpec) {
-    const entt::meta_any any{spec_wrapped_shared_ptr<int>{42}};
+    const entt::meta_any any{spec_wrapped_shared_ptr<int>{3}};
 
     ASSERT_FALSE(any.type().is_pointer());
     ASSERT_TRUE(any.type().is_pointer_like());
@@ -293,12 +293,12 @@ TEST(MetaPointerLike, DereferenceOverloadSpec) {
     ASSERT_FALSE(deref.type().is_pointer_like());
     ASSERT_EQ(deref.type(), entt::resolve<int>());
 
-    ASSERT_EQ(deref.cast<int &>(), 42);
-    ASSERT_EQ(deref.cast<const int &>(), 42);
+    ASSERT_EQ(deref.cast<int &>(), 3);
+    ASSERT_EQ(deref.cast<const int &>(), 3);
 }
 
 TEST(MetaPointerLike, DereferencePointerToConstOverloadAdl) {
-    const entt::meta_any any{adl_wrapped_shared_ptr<const int>{42}};
+    const entt::meta_any any{adl_wrapped_shared_ptr<const int>{3}};
 
     ASSERT_FALSE(any.type().is_pointer());
     ASSERT_TRUE(any.type().is_pointer_like());
@@ -309,11 +309,11 @@ TEST(MetaPointerLike, DereferencePointerToConstOverloadAdl) {
     ASSERT_FALSE(deref.type().is_pointer());
     ASSERT_FALSE(deref.type().is_pointer_like());
     ASSERT_EQ(deref.type(), entt::resolve<int>());
-    ASSERT_EQ(deref.cast<const int &>(), 42);
+    ASSERT_EQ(deref.cast<const int &>(), 3);
 }
 
 TEST(MetaPointerLike, DereferencePointerToConstOverloadSpec) {
-    const entt::meta_any any{spec_wrapped_shared_ptr<const int>{42}};
+    const entt::meta_any any{spec_wrapped_shared_ptr<const int>{3}};
 
     ASSERT_FALSE(any.type().is_pointer());
     ASSERT_TRUE(any.type().is_pointer_like());
@@ -324,25 +324,25 @@ TEST(MetaPointerLike, DereferencePointerToConstOverloadSpec) {
     ASSERT_FALSE(deref.type().is_pointer());
     ASSERT_FALSE(deref.type().is_pointer_like());
     ASSERT_EQ(deref.type(), entt::resolve<int>());
-    ASSERT_EQ(deref.cast<const int &>(), 42);
+    ASSERT_EQ(deref.cast<const int &>(), 3);
 }
 
 ENTT_DEBUG_TEST(MetaPointerLikeDeathTest, DereferencePointerToConstOverloadAdl) {
-    const entt::meta_any any{adl_wrapped_shared_ptr<const int>{42}};
+    const entt::meta_any any{adl_wrapped_shared_ptr<const int>{3}};
 
     auto deref = *any;
 
     ASSERT_TRUE(deref);
-    ASSERT_DEATH(deref.cast<int &>() = 42, "");
+    ASSERT_DEATH(deref.cast<int &>() = 3, "");
 }
 
 ENTT_DEBUG_TEST(MetaPointerLikeDeathTest, DereferencePointerToConstOverloadSpec) {
-    const entt::meta_any any{spec_wrapped_shared_ptr<const int>{42}};
+    const entt::meta_any any{spec_wrapped_shared_ptr<const int>{3}};
 
     auto deref = *any;
 
     ASSERT_TRUE(deref);
-    ASSERT_DEATH(deref.cast<int &>() = 42, "");
+    ASSERT_DEATH(deref.cast<int &>() = 3, "");
 }
 
 TEST(MetaPointerLike, DereferencePointerToVoid) {
@@ -397,11 +397,11 @@ TEST(MetaPointerLike, DereferencePointerToFunction) {
     ASSERT_TRUE(any.type().is_pointer());
     ASSERT_TRUE((*std::as_const(any)).type().is_pointer_like());
     ASSERT_NE((**any).try_cast<int (*)()>(), nullptr);
-    ASSERT_EQ((***std::as_const(any)).cast<int (*)()>()(), 42);
+    ASSERT_EQ((***std::as_const(any)).cast<int (*)()>()(), 3);
 }
 
 TEST(MetaPointerLike, DereferenceSelfPointer) {
-    self_ptr obj{42}; // NOLINT
+    self_ptr obj{3};
     const entt::meta_any any{entt::forward_as_meta(obj)};
     entt::meta_any deref = *any;
 
@@ -422,9 +422,9 @@ TEST(MetaPointerLike, DereferenceProxyPointer) {
     ASSERT_EQ(*deref.cast<const proxy_ptr &>().value, value);
     ASSERT_TRUE(deref.try_cast<proxy_ptr>());
 
-    *deref.cast<proxy_ptr &>().value = 42; // NOLINT
+    *deref.cast<proxy_ptr &>().value = 3;
 
-    ASSERT_EQ(value, 42);
+    ASSERT_EQ(value, 3);
 }
 
 TEST(MetaPointerLike, DereferenceArray) {

test/entt/meta/meta_prop.cpp

@@ -19,7 +19,7 @@ struct MetaProp: ::testing::Test {
 
         entt::meta<base_1_t>()
             .type("base_1"_hs)
-            .prop("int"_hs, 42); // NOLINT
+            .prop("int"_hs, 2);
 
         entt::meta<base_2_t>()
             .type("base_2"_hs)
@@ -29,7 +29,7 @@ struct MetaProp: ::testing::Test {
         entt::meta<base_3_t>()
             .type("base_3"_hs)
             .prop("key_only"_hs)
-            .prop("key"_hs, 42); // NOLINT
+            .prop("key"_hs, 2);
 
         entt::meta<derived_t>()
             .type("derived"_hs)
@@ -64,8 +64,8 @@ TEST_F(MetaProp, Functionalities) {
     ASSERT_NE(value.try_cast<const int>(), nullptr);
     ASSERT_NE(cvalue.try_cast<const int>(), nullptr);
 
-    ASSERT_EQ(value, 42);
-    ASSERT_EQ(cvalue, 42);
+    ASSERT_EQ(value, 2);
+    ASSERT_EQ(cvalue, 2);
 }
 
 TEST_F(MetaProp, FromBase) {
@@ -83,9 +83,9 @@ TEST_F(MetaProp, FromBase) {
     ASSERT_TRUE(key_value);
 
     ASSERT_FALSE(prop_bool.value().cast<bool>());
-    ASSERT_EQ(prop_int.value().cast<int>(), 42);
+    ASSERT_EQ(prop_int.value().cast<int>(), 2);
     ASSERT_FALSE(key_only.value());
-    ASSERT_EQ(key_value.value().cast<int>(), 42);
+    ASSERT_EQ(key_value.value().cast<int>(), 2);
 }
 
 TEST_F(MetaProp, DeducedArrayType) {
@@ -111,7 +111,7 @@ TEST_F(MetaProp, ReRegistration) {
     ASSERT_EQ(node.details->prop.size(), 1u);
 
     ASSERT_TRUE(type.prop("int"_hs));
-    ASSERT_EQ(type.prop("int"_hs).value().cast<int>(), 42);
+    ASSERT_EQ(type.prop("int"_hs).value().cast<int>(), 2);
 
     entt::meta<base_1_t>().prop("int"_hs, 0);
     entt::meta<base_1_t>().prop("double"_hs, 3.);

test/entt/meta/meta_range.cpp

@@ -12,7 +12,7 @@ struct MetaRange: ::testing::Test {
     void SetUp() override {
         using namespace entt::literals;
 
-        entt::meta<int>().type("int"_hs).data<42>("answer"_hs); // NOLINT
+        entt::meta<int>().type("int"_hs).data<2>("answer"_hs);
     }
 
     void TearDown() override {
@@ -91,6 +91,6 @@ TEST_F(MetaRange, DirectValue) {
 
     for(auto &&[id, data]: range) {
         ASSERT_EQ(id, "answer"_hs);
-        ASSERT_EQ(data.get({}).cast<int>(), 42);
+        ASSERT_EQ(data.get({}).cast<int>(), 2);
     }
 }

test/entt/meta/meta_type.cpp

@@ -172,7 +172,7 @@ struct MetaType: ::testing::Test {
 
         entt::meta<clazz_t>()
             .type("clazz"_hs)
-            .prop(static_cast<entt::id_type>(property_t::value), 42) // NOLINT
+            .prop(static_cast<entt::id_type>(property_t::value), 3)
             .ctor<const base_t &, int>()
             .data<&clazz_t::value>("value"_hs)
             .func<&clazz_t::member>("member"_hs)
@@ -222,7 +222,7 @@ TEST_F(MetaType, Functionalities) {
 
     for(auto &&curr: type.prop()) {
         ASSERT_EQ(curr.first, static_cast<entt::id_type>(property_t::value));
-        ASSERT_EQ(curr.second.value(), 42);
+        ASSERT_EQ(curr.second.value(), 3);
     }
 
     ASSERT_FALSE(type.prop(static_cast<entt::id_type>(property_t::key_only)));
@@ -231,7 +231,7 @@ TEST_F(MetaType, Functionalities) {
     auto prop = type.prop(static_cast<entt::id_type>(property_t::value));
 
     ASSERT_TRUE(prop);
-    ASSERT_EQ(prop.value(), 42);
+    ASSERT_EQ(prop.value(), 3);
 }
 
 TEST_F(MetaType, SizeOf) {
@@ -342,8 +342,8 @@ TEST_F(MetaType, Ctor) {
     base_t &base = derived;
     auto type = entt::resolve<clazz_t>();
 
-    ASSERT_TRUE((type.construct(entt::forward_as_meta(derived), 42)));
-    ASSERT_TRUE((type.construct(entt::forward_as_meta(base), 42)));
+    ASSERT_TRUE((type.construct(entt::forward_as_meta(derived), 3)));
+    ASSERT_TRUE((type.construct(entt::forward_as_meta(base), 3)));
 
     // use the implicitly generated default constructor
     auto any = type.construct();
@@ -413,7 +413,7 @@ TEST_F(MetaType, InvokeFromBase) {
     auto type = entt::resolve<concrete_t>();
     concrete_t instance{};
 
-    ASSERT_TRUE(type.invoke("base_only"_hs, instance, 42));
+    ASSERT_TRUE(type.invoke("base_only"_hs, instance, 3));
     ASSERT_FALSE(type.invoke("ylno_esab"_hs, {}, 'c'));
 }
 
@@ -475,10 +475,10 @@ TEST_F(MetaType, OverloadedFunc) {
 }
 
 TEST_F(MetaType, Construct) {
-    auto any = entt::resolve<clazz_t>().construct(base_t{}, 42); // NOLINT
+    auto any = entt::resolve<clazz_t>().construct(base_t{}, 2);
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().value, 42);
+    ASSERT_EQ(any.cast<clazz_t>().value, 2);
 }
 
 TEST_F(MetaType, ConstructNoArgs) {
@@ -489,10 +489,10 @@ TEST_F(MetaType, ConstructNoArgs) {
 }
 
 TEST_F(MetaType, ConstructMetaAnyArgs) {
-    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{base_t{}}, entt::meta_any{42}); // NOLINT
+    auto any = entt::resolve<clazz_t>().construct(entt::meta_any{base_t{}}, entt::meta_any{3});
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().value, 42);
+    ASSERT_EQ(any.cast<clazz_t>().value, 3);
 }
 
 TEST_F(MetaType, ConstructInvalidArgs) {
@@ -504,10 +504,10 @@ TEST_F(MetaType, LessArgs) {
 }
 
 TEST_F(MetaType, ConstructCastAndConvert) {
-    auto any = entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{derived_t{}, 42}); // NOLINT
+    auto any = entt::resolve<clazz_t>().construct(derived_t{}, clazz_t{derived_t{}, 3});
 
     ASSERT_TRUE(any);
-    ASSERT_EQ(any.cast<clazz_t>().value, 42);
+    ASSERT_EQ(any.cast<clazz_t>().value, 3);
 }
 
 TEST_F(MetaType, ConstructArithmeticConversion) {
@@ -610,10 +610,10 @@ TEST_F(MetaType, AbstractClass) {
     ASSERT_EQ(instance.base_t::value, 'c');
     ASSERT_EQ(instance.value, 3);
 
-    type.func("func"_hs).invoke(instance, 42); // NOLINT
+    type.func("func"_hs).invoke(instance, 2);
 
     ASSERT_EQ(instance.base_t::value, 'c');
-    ASSERT_EQ(instance.value, 42);
+    ASSERT_EQ(instance.value, 2);
 }
 
 TEST_F(MetaType, EnumAndNamedConstants) {
@@ -662,12 +662,12 @@ TEST_F(MetaType, Variables) {
     double d = 3.;
 
     p_data.set(prop, property_t::random);
-    d_data.set(d, 42.);
+    d_data.set(d, 3.);
 
     ASSERT_EQ(p_data.get(prop).cast<property_t>(), property_t::random);
-    ASSERT_EQ(d_data.get(d).cast<double>(), 42.);
+    ASSERT_EQ(d_data.get(d).cast<double>(), 3.);
     ASSERT_EQ(prop, property_t::random);
-    ASSERT_EQ(d, 42.);
+    ASSERT_EQ(d, 3.);
 }
 
 TEST_F(MetaType, PropertiesAndCornerCases) {
@@ -727,7 +727,7 @@ TEST_F(MetaType, ResetAndReRegistrationAfterReset) {
     ASSERT_FALSE(entt::resolve<clazz_t>().func("member"_hs));
 
     entt::meta<double>().type("double"_hs);
-    entt::meta_any any{42.};
+    entt::meta_any any{3.};
 
     ASSERT_TRUE(any);
     ASSERT_TRUE(any.allow_cast<int>());
@@ -739,7 +739,7 @@ TEST_F(MetaType, ResetAndReRegistrationAfterReset) {
     entt::meta<property_t>()
         .type("property"_hs)
         .data<property_t::random>("rand"_hs)
-        .prop(static_cast<entt::id_type>(property_t::value), 42) // NOLINT
+        .prop(static_cast<entt::id_type>(property_t::value), 3)
         .prop(static_cast<entt::id_type>(property_t::random), 3);
 
     ASSERT_TRUE(entt::resolve<property_t>().data("rand"_hs).prop(static_cast<entt::id_type>(property_t::value)));

test/entt/meta/meta_utility.cpp

@@ -1,3 +1,4 @@
+#include <array>
 #include <utility>
 #include <gtest/gtest.h>
 #include <entt/core/type_traits.hpp>
@@ -55,7 +56,7 @@ struct MetaUtility: ::testing::Test {
 using MetaUtilityDeathTest = MetaUtility;
 
 TEST_F(MetaUtility, MetaDispatch) {
-    int value = 42; // NOLINT
+    int value = 2;
 
     auto as_void = entt::meta_dispatch<entt::as_void_t>(value);
     auto as_ref = entt::meta_dispatch<entt::as_ref_t>(value);
@@ -72,13 +73,13 @@ TEST_F(MetaUtility, MetaDispatch) {
     ASSERT_EQ(as_cref.try_cast<int>(), nullptr);
     ASSERT_NE(as_cref.try_cast<const int>(), nullptr);
 
-    ASSERT_EQ(as_is.cast<int>(), 42);
-    ASSERT_EQ(as_ref.cast<int>(), 42);
-    ASSERT_EQ(as_cref.cast<int>(), 42);
+    ASSERT_EQ(as_is.cast<int>(), 2);
+    ASSERT_EQ(as_ref.cast<int>(), 2);
+    ASSERT_EQ(as_cref.cast<int>(), 2);
 }
 
 TEST_F(MetaUtility, MetaDispatchMetaAny) {
-    entt::meta_any any{42}; // NOLINT
+    entt::meta_any any{2};
 
     auto from_any = entt::meta_dispatch(any);
     auto from_const_any = entt::meta_dispatch(std::as_const(any));
@@ -89,12 +90,12 @@ TEST_F(MetaUtility, MetaDispatchMetaAny) {
     ASSERT_NE(from_any.try_cast<int>(), nullptr);
     ASSERT_NE(from_const_any.try_cast<int>(), nullptr);
 
-    ASSERT_EQ(from_any.cast<int>(), 42);
-    ASSERT_EQ(from_const_any.cast<int>(), 42);
+    ASSERT_EQ(from_any.cast<int>(), 2);
+    ASSERT_EQ(from_const_any.cast<int>(), 2);
 }
 
 TEST_F(MetaUtility, MetaDispatchMetaAnyAsRef) {
-    entt::meta_any any{42}; // NOLINT
+    entt::meta_any any{2};
 
     auto from_any = entt::meta_dispatch(any.as_ref());
     auto from_const_any = entt::meta_dispatch(std::as_const(any).as_ref());
@@ -106,8 +107,8 @@ TEST_F(MetaUtility, MetaDispatchMetaAnyAsRef) {
     ASSERT_EQ(from_const_any.try_cast<int>(), nullptr);
     ASSERT_NE(from_const_any.try_cast<const int>(), nullptr);
 
-    ASSERT_EQ(from_any.cast<int>(), 42);
-    ASSERT_EQ(from_const_any.cast<int>(), 42);
+    ASSERT_EQ(from_any.cast<int>(), 2);
+    ASSERT_EQ(from_const_any.cast<int>(), 2);
 }
 
 TEST_F(MetaUtility, MetaArg) {
@@ -188,7 +189,7 @@ TEST_F(MetaUtility, MetaGetter) {
 
 TEST_F(MetaUtility, MetaInvokeWithCandidate) {
     entt::meta_any args[2u]{clazz{}, 42}; // NOLINT
-    args[0u].cast<clazz &>().value = 99;  // NOLINT
+    args[0u].cast<clazz &>().value = 3;
 
     ASSERT_FALSE((entt::meta_invoke<clazz>({}, &clazz::setter, nullptr)));
     ASSERT_FALSE((entt::meta_invoke<clazz>({}, &clazz::getter, nullptr)));
@@ -198,7 +199,7 @@ TEST_F(MetaUtility, MetaInvokeWithCandidate) {
     ASSERT_EQ((entt::meta_invoke<clazz>(args[0u], &clazz::getter, nullptr)).cast<int>(), 42);
     ASSERT_FALSE((entt::meta_invoke<clazz>(args[1u], &clazz::getter, nullptr)));
 
-    ASSERT_EQ((entt::meta_invoke<clazz>({}, &clazz::get_value, nullptr)).cast<int>(), 99);
+    ASSERT_EQ((entt::meta_invoke<clazz>({}, &clazz::get_value, nullptr)).cast<int>(), 3);
     ASSERT_TRUE((entt::meta_invoke<clazz>({}, &clazz::reset_value, nullptr)));
     ASSERT_EQ(args[0u].cast<clazz &>().value, 0);
 
@@ -211,7 +212,7 @@ TEST_F(MetaUtility, MetaInvokeWithCandidate) {
 
 TEST_F(MetaUtility, MetaInvoke) {
     entt::meta_any args[2u]{clazz{}, 42}; // NOLINT
-    args[0u].cast<clazz &>().value = 99;  // NOLINT
+    args[0u].cast<clazz &>().value = 3;
 
     ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::setter>({}, nullptr)));
     ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::getter>({}, nullptr)));
@@ -221,7 +222,7 @@ TEST_F(MetaUtility, MetaInvoke) {
     ASSERT_EQ((entt::meta_invoke<clazz, &clazz::getter>(args[0u], nullptr)).cast<int>(), 42);
     ASSERT_FALSE((entt::meta_invoke<clazz, &clazz::getter>(args[1u], nullptr)));
 
-    ASSERT_EQ((entt::meta_invoke<clazz, &clazz::get_value>({}, nullptr)).cast<int>(), 99);
+    ASSERT_EQ((entt::meta_invoke<clazz, &clazz::get_value>({}, nullptr)).cast<int>(), 3);
     ASSERT_TRUE((entt::meta_invoke<clazz, &clazz::reset_value>({}, nullptr)));
     ASSERT_EQ(args[0u].cast<clazz &>().value, 0);
 }
@@ -255,14 +256,14 @@ TEST_F(MetaUtility, MetaConstructWithCandidate) {
 }
 
 TEST_F(MetaUtility, MetaConstruct) {
-    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{2}};
+    const auto any = entt::meta_construct<clazz, &clazz::factory>(args.data() + 1u); // NOLINT
 
     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, 2);
 
     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, 2);
 }