test: fix typo from last PR and make test local paths local

test/CMakeLists.txt

@@ -44,7 +44,7 @@ else()
     set_target_properties(gmock_main PROPERTIES CXX_CLANG_TIDY "")
 endif()
 
-include_directories($<TARGET_PROPERTY:EnTT,INTERFACE_INCLUDE_DIRECTORIES> ${CMAKE_CURRENT_SOURCE_DIR})
+include_directories($<TARGET_PROPERTY:EnTT,INTERFACE_INCLUDE_DIRECTORIES>)
 add_compile_options($<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_OPTIONS>)
 
 function(SETUP_TARGET TARGET_NAME)

test/entt/container/dense_map.cpp

@@ -9,15 +9,15 @@
 #include <utility>
 #include <vector>
 #include <gtest/gtest.h>
-#include "common/config.h"
-#include "common/linter.hpp"
-#include "common/throwing_allocator.hpp"
-#include "common/tracked_memory_resource.hpp"
-#include "common/transparent_equal_to.h"
 #include <entt/container/dense_map.hpp>
 #include <entt/core/iterator.hpp>
 #include <entt/core/memory.hpp>
 #include <entt/core/utility.hpp>
+#include "../../common/config.h"
+#include "../../common/linter.hpp"
+#include "../../common/throwing_allocator.hpp"
+#include "../../common/tracked_memory_resource.hpp"
+#include "../../common/transparent_equal_to.h"
 
 TEST(DenseMap, Functionalities) {
     entt::dense_map<int, int, entt::identity, test::transparent_equal_to> map;

test/entt/container/dense_set.cpp

@@ -9,13 +9,13 @@
 #include <utility>
 #include <vector>
 #include <gtest/gtest.h>
-#include "common/linter.hpp"
-#include "common/throwing_allocator.hpp"
-#include "common/tracked_memory_resource.hpp"
-#include "common/transparent_equal_to.h"
 #include <entt/container/dense_set.hpp>
 #include <entt/core/memory.hpp>
 #include <entt/core/utility.hpp>
+#include "../../common/linter.hpp"
+#include "../../common/throwing_allocator.hpp"
+#include "../../common/tracked_memory_resource.hpp"
+#include "../../common/transparent_equal_to.h"
 
 TEST(DenseSet, Functionalities) {
     entt::dense_set<int, entt::identity, test::transparent_equal_to> set;

test/entt/core/algorithm.cpp

@@ -1,8 +1,8 @@
 #include <array>
 #include <vector>
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
 #include <entt/core/algorithm.hpp>
+#include "../../common/boxed_type.h"
 
 TEST(Algorithm, StdSort) {
     // well, I'm pretty sure it works, it's std::sort!!

test/entt/core/any.cpp

@@ -7,13 +7,13 @@
 #include <utility>
 #include <vector>
 #include <gtest/gtest.h>
-#include "common/aggregate.h"
-#include "common/config.h"
-#include "common/linter.hpp"
-#include "common/non_comparable.h"
-#include "common/non_movable.h"
 #include <entt/core/any.hpp>
 #include <entt/core/type_info.hpp>
+#include "../../common/aggregate.h"
+#include "../../common/config.h"
+#include "../../common/linter.hpp"
+#include "../../common/non_comparable.h"
+#include "../../common/non_movable.h"
 
 template<std::size_t Len>
 struct tracker {

test/entt/core/compressed_pair.cpp

@@ -5,9 +5,9 @@
 #include <utility>
 #include <vector>
 #include <gtest/gtest.h>
-#include "common/empty.h"
-#include "common/non_default_constructible.h"
 #include <entt/core/compressed_pair.hpp>
+#include "../../common/empty.h"
+#include "../../common/non_default_constructible.h"
 
 TEST(CompressedPair, Size) {
     struct local {

test/entt/core/ident.cpp

@@ -1,8 +1,8 @@
 #include <type_traits>
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
-#include "common/empty.h"
 #include <entt/core/ident.hpp>
+#include "../../common/boxed_type.h"
+#include "../../common/empty.h"
 
 TEST(Ident, Uniqueness) {
     using id = entt::ident<test::empty, test::boxed_int>;

test/entt/core/iterator.cpp

@@ -2,8 +2,8 @@
 #include <utility>
 #include <vector>
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
 #include <entt/core/iterator.hpp>
+#include "../../common/boxed_type.h"
 
 TEST(InputIteratorPointer, Functionalities) {
     entt::input_iterator_pointer ptr{test::boxed_int{0}};

test/entt/core/memory.cpp

@@ -8,12 +8,12 @@
 #include <utility>
 #include <vector>
 #include <gtest/gtest.h>
-#include "common/basic_test_allocator.hpp"
-#include "common/config.h"
-#include "common/throwing_allocator.hpp"
-#include "common/throwing_type.hpp"
-#include "common/tracked_memory_resource.hpp"
 #include <entt/core/memory.hpp>
+#include "../../common/basic_test_allocator.hpp"
+#include "../../common/config.h"
+#include "../../common/throwing_allocator.hpp"
+#include "../../common/throwing_type.hpp"
+#include "../../common/tracked_memory_resource.hpp"
 
 TEST(ToAddress, Functionalities) {
     const std::shared_ptr<int> shared = std::make_shared<int>();

test/entt/core/type_traits.cpp

@@ -6,9 +6,9 @@
 #include <utility>
 #include <vector>
 #include <gtest/gtest.h>
-#include "common/non_comparable.h"
 #include <entt/core/hashed_string.hpp>
 #include <entt/core/type_traits.hpp>
+#include "../../common/non_comparable.h"
 
 struct nlohmann_json_like final {
     using value_type = nlohmann_json_like;

test/entt/entity/component.cpp

@@ -1,9 +1,9 @@
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
-#include "common/empty.h"
-#include "common/non_movable.h"
 #include <entt/config/config.h>
 #include <entt/entity/component.hpp>
+#include "../../common/boxed_type.h"
+#include "../../common/empty.h"
+#include "../../common/non_movable.h"
 
 struct self_contained {
     static constexpr auto in_place_delete = true;

test/entt/entity/entity.cpp

@@ -1,9 +1,9 @@
 #include <cstddef>
 #include <cstdint>
 #include <gtest/gtest.h>
-#include "common/entity.h"
 #include <entt/config/config.h>
 #include <entt/entity/entity.hpp>
+#include "../../common/entity.h"
 
 struct entity_traits {
     using value_type = test::entity;

test/entt/entity/group.cpp

@@ -5,11 +5,11 @@
 #include <tuple>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
-#include "common/config.h"
-#include "common/empty.h"
 #include <entt/entity/group.hpp>
 #include <entt/entity/registry.hpp>
+#include "../../common/boxed_type.h"
+#include "../../common/config.h"
+#include "../../common/empty.h"
 
 TEST(NonOwningGroup, Functionalities) {
     entt::registry registry;

test/entt/entity/helper.cpp

@@ -1,10 +1,10 @@
 #include <gtest/gtest.h>
-#include "common/pointer_stable.h"
 #include <entt/core/hashed_string.hpp>
 #include <entt/entity/component.hpp>
 #include <entt/entity/entity.hpp>
 #include <entt/entity/helper.hpp>
 #include <entt/entity/registry.hpp>
+#include "../../common/pointer_stable.h"
 
 struct clazz {
     void func(entt::registry &, entt::entity curr) {

test/entt/entity/registry.cpp

@@ -9,18 +9,18 @@
 #include <utility>
 #include <vector>
 #include <gtest/gtest.h>
-#include "common/aggregate.h"
-#include "common/config.h"
-#include "common/empty.h"
-#include "common/entity.h"
-#include "common/non_default_constructible.h"
-#include "common/pointer_stable.h"
 #include <entt/config/config.h>
 #include <entt/core/hashed_string.hpp>
 #include <entt/core/type_info.hpp>
 #include <entt/entity/entity.hpp>
 #include <entt/entity/registry.hpp>
 #include <entt/entity/view.hpp>
+#include "../../common/aggregate.h"
+#include "../../common/config.h"
+#include "../../common/empty.h"
+#include "../../common/entity.h"
+#include "../../common/non_default_constructible.h"
+#include "../../common/pointer_stable.h"
 
 struct no_eto_type {
     static constexpr std::size_t page_size = 1024u;

test/entt/entity/runtime_view.cpp

@@ -2,11 +2,11 @@
 #include <memory>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/linter.hpp"
-#include "common/pointer_stable.h"
 #include <entt/entity/entity.hpp>
 #include <entt/entity/registry.hpp>
 #include <entt/entity/runtime_view.hpp>
+#include "../../common/linter.hpp"
+#include "../../common/pointer_stable.h"
 
 template<typename Type>
 struct RuntimeView: testing::Test {

test/entt/entity/sigh_mixin.cpp

@@ -4,12 +4,6 @@
 #include <type_traits>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/entity.h"
-#include "common/linter.hpp"
-#include "common/non_default_constructible.h"
-#include "common/pointer_stable.h"
-#include "common/throwing_allocator.hpp"
-#include "common/throwing_type.hpp"
 #include <entt/core/any.hpp>
 #include <entt/core/type_info.hpp>
 #include <entt/entity/component.hpp>
@@ -17,6 +11,12 @@
 #include <entt/entity/mixin.hpp>
 #include <entt/entity/registry.hpp>
 #include <entt/entity/storage.hpp>
+#include "../../common/entity.h"
+#include "../../common/linter.hpp"
+#include "../../common/non_default_constructible.h"
+#include "../../common/pointer_stable.h"
+#include "../../common/throwing_allocator.hpp"
+#include "../../common/throwing_type.hpp"
 
 template<typename Registry>
 void listener(std::size_t &counter, Registry &, typename Registry::entity_type) {

test/entt/entity/snapshot.cpp

@@ -4,14 +4,14 @@
 #include <utility>
 #include <vector>
 #include <gtest/gtest.h>
-#include "common/config.h"
-#include "common/empty.h"
 #include <entt/core/any.hpp>
 #include <entt/core/hashed_string.hpp>
 #include <entt/entity/entity.hpp>
 #include <entt/entity/registry.hpp>
 #include <entt/entity/snapshot.hpp>
 #include <entt/signal/sigh.hpp>
+#include "../../common/config.h"
+#include "../../common/empty.h"
 
 struct shadow {
     entt::entity target{entt::null};

test/entt/entity/sparse_set.cpp

@@ -6,15 +6,15 @@
 #include <memory>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/config.h"
-#include "common/entity.h"
-#include "common/linter.hpp"
-#include "common/throwing_allocator.hpp"
 #include <entt/config/config.h>
 #include <entt/core/any.hpp>
 #include <entt/core/type_info.hpp>
 #include <entt/entity/entity.hpp>
 #include <entt/entity/sparse_set.hpp>
+#include "../../common/config.h"
+#include "../../common/entity.h"
+#include "../../common/linter.hpp"
+#include "../../common/throwing_allocator.hpp"
 
 struct entity_traits {
     using value_type = test::entity;

test/entt/entity/storage.cpp

@@ -7,18 +7,18 @@
 #include <unordered_set>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/aggregate.h"
-#include "common/config.h"
-#include "common/linter.hpp"
-#include "common/pointer_stable.h"
-#include "common/throwing_allocator.hpp"
-#include "common/throwing_type.hpp"
-#include "common/tracked_memory_resource.hpp"
 #include <entt/core/iterator.hpp>
 #include <entt/core/type_info.hpp>
 #include <entt/entity/component.hpp>
 #include <entt/entity/entity.hpp>
 #include <entt/entity/storage.hpp>
+#include "../../common/aggregate.h"
+#include "../../common/config.h"
+#include "../../common/linter.hpp"
+#include "../../common/pointer_stable.h"
+#include "../../common/throwing_allocator.hpp"
+#include "../../common/throwing_type.hpp"
+#include "../../common/tracked_memory_resource.hpp"
 
 struct update_from_destructor {
     update_from_destructor(entt::storage<update_from_destructor> &ref, entt::entity other)

test/entt/entity/storage_entity.cpp

@@ -7,12 +7,12 @@
 #include <type_traits>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/config.h"
-#include "common/linter.hpp"
 #include <entt/core/iterator.hpp>
 #include <entt/core/type_info.hpp>
 #include <entt/entity/entity.hpp>
 #include <entt/entity/storage.hpp>
+#include "../../common/config.h"
+#include "../../common/linter.hpp"
 
 TEST(StorageEntity, Constructors) {
     entt::storage<entt::entity> pool;

test/entt/entity/storage_no_instance.cpp

@@ -6,13 +6,13 @@
 #include <type_traits>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/config.h"
-#include "common/empty.h"
-#include "common/linter.hpp"
 #include <entt/core/iterator.hpp>
 #include <entt/core/type_info.hpp>
 #include <entt/entity/entity.hpp>
 #include <entt/entity/storage.hpp>
+#include "../../common/config.h"
+#include "../../common/empty.h"
+#include "../../common/linter.hpp"
 
 template<typename Type>
 struct StorageNoInstance: testing::Test {

test/entt/entity/view.cpp

@@ -4,15 +4,15 @@
 #include <tuple>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
-#include "common/empty.h"
-#include "common/pointer_stable.h"
 #include <entt/core/any.hpp>
 #include <entt/core/hashed_string.hpp>
 #include <entt/core/type_info.hpp>
 #include <entt/entity/entity.hpp>
 #include <entt/entity/registry.hpp>
 #include <entt/entity/view.hpp>
+#include "../../common/boxed_type.h"
+#include "../../common/empty.h"
+#include "../../common/pointer_stable.h"
 
 TEST(SingleComponentView, Functionalities) {
     entt::registry registry;

test/entt/graph/adjacency_matrix.cpp

@@ -2,9 +2,9 @@
 #include <memory>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/linter.hpp"
-#include "common/throwing_allocator.hpp"
 #include <entt/graph/adjacency_matrix.hpp>
+#include "../../common/linter.hpp"
+#include "../../common/throwing_allocator.hpp"
 
 TEST(AdjacencyMatrix, Resize) {
     entt::adjacency_matrix<entt::directed_tag> adjacency_matrix{2};

test/entt/graph/flow.cpp

@@ -3,11 +3,11 @@
 #include <memory>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/config.h"
-#include "common/linter.hpp"
-#include "common/throwing_allocator.hpp"
 #include <entt/core/hashed_string.hpp>
 #include <entt/graph/flow.hpp>
+#include "../../common/config.h"
+#include "../../common/linter.hpp"
+#include "../../common/throwing_allocator.hpp"
 
 TEST(Flow, Constructors) {
     entt::flow flow{};

test/entt/locator/locator.cpp

@@ -1,7 +1,7 @@
 #include <memory>
 #include <gtest/gtest.h>
-#include "common/config.h"
 #include <entt/locator/locator.hpp>
+#include "../../common/config.h"
 
 struct base_service {
     virtual ~base_service() = default;

test/entt/meta/meta_any.cpp

@@ -4,13 +4,13 @@
 #include <memory>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/config.h"
-#include "common/linter.hpp"
-#include "common/non_comparable.h"
 #include <entt/core/hashed_string.hpp>
 #include <entt/meta/factory.hpp>
 #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 {
     void member(int i) {

test/entt/meta/meta_container.cpp

@@ -6,14 +6,14 @@
 #include <utility>
 #include <vector>
 #include <gtest/gtest.h>
-#include "common/config.h"
-#include "common/empty.h"
-#include "common/non_default_constructible.h"
 #include <entt/container/dense_map.hpp>
 #include <entt/container/dense_set.hpp>
 #include <entt/meta/container.hpp>
 #include <entt/meta/meta.hpp>
 #include <entt/meta/resolve.hpp>
+#include "../../common/config.h"
+#include "../../common/empty.h"
+#include "../../common/non_default_constructible.h"
 
 TEST(MetaContainer, Invalid) {
     ASSERT_FALSE(entt::meta_any{0}.as_sequence_container());

test/entt/meta/meta_context.cpp

@@ -3,7 +3,6 @@
 #include <utility>
 #include <vector>
 #include <gtest/gtest.h>
-#include "common/empty.h"
 #include <entt/core/hashed_string.hpp>
 #include <entt/core/type_info.hpp>
 #include <entt/meta/container.hpp>
@@ -13,6 +12,7 @@
 #include <entt/meta/pointer.hpp>
 #include <entt/meta/resolve.hpp>
 #include <entt/meta/template.hpp>
+#include "../../common/empty.h"
 
 struct base {
     base() = default;

test/entt/meta/meta_data.cpp

@@ -2,7 +2,6 @@
 #include <string>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/config.h"
 #include <entt/core/hashed_string.hpp>
 #include <entt/core/type_traits.hpp>
 #include <entt/locator/locator.hpp>
@@ -13,6 +12,7 @@
 #include <entt/meta/policy.hpp>
 #include <entt/meta/range.hpp>
 #include <entt/meta/resolve.hpp>
+#include "../../common/config.h"
 
 struct base {
     virtual ~base() = default;

test/entt/meta/meta_func.cpp

@@ -1,7 +1,6 @@
 #include <cstddef>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/config.h"
 #include <entt/core/hashed_string.hpp>
 #include <entt/core/utility.hpp>
 #include <entt/entity/registry.hpp>
@@ -10,6 +9,7 @@
 #include <entt/meta/policy.hpp>
 #include <entt/meta/range.hpp>
 #include <entt/meta/resolve.hpp>
+#include "../../common/config.h"
 
 struct base {
     base() = default;

test/entt/meta/meta_pointer.cpp

@@ -2,12 +2,12 @@
 #include <type_traits>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/config.h"
 #include <entt/meta/adl_pointer.hpp>
 #include <entt/meta/meta.hpp>
 #include <entt/meta/pointer.hpp>
 #include <entt/meta/resolve.hpp>
 #include <entt/meta/type_traits.hpp>
+#include "../../common/config.h"
 
 template<typename Type>
 struct wrapped_shared_ptr {

test/entt/meta/meta_type.cpp

@@ -4,7 +4,6 @@
 #include <utility>
 #include <vector>
 #include <gtest/gtest.h>
-#include "common/config.h"
 #include <entt/core/hashed_string.hpp>
 #include <entt/core/type_info.hpp>
 #include <entt/core/utility.hpp>
@@ -17,6 +16,7 @@
 #include <entt/meta/range.hpp>
 #include <entt/meta/resolve.hpp>
 #include <entt/meta/template.hpp>
+#include "../../common/config.h"
 
 template<typename Type>
 void set(Type &prop, Type value) {

test/entt/meta/meta_utility.cpp

@@ -2,13 +2,13 @@
 #include <iterator>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/config.h"
-#include "common/empty.h"
 #include <entt/core/type_traits.hpp>
 #include <entt/meta/meta.hpp>
 #include <entt/meta/policy.hpp>
 #include <entt/meta/resolve.hpp>
 #include <entt/meta/utility.hpp>
+#include "../../common/config.h"
+#include "../../common/empty.h"
 
 struct clazz {
     void setter(int v) {

test/entt/poly/poly.cpp

@@ -3,11 +3,11 @@
 #include <cstdint>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/config.h"
-#include "common/linter.hpp"
 #include <entt/core/type_info.hpp>
 #include <entt/core/type_traits.hpp>
 #include <entt/poly/poly.hpp>
+#include "../../common/config.h"
+#include "../../common/linter.hpp"
 
 template<typename Base>
 struct common_type: Base {

test/entt/process/process.cpp

@@ -1,7 +1,7 @@
 #include <cstdint>
 #include <gtest/gtest.h>
-#include "common/empty.h"
 #include <entt/process/process.hpp>
+#include "../../common/empty.h"
 
 template<typename Delta>
 struct fake_process: entt::process<fake_process<Delta>, Delta> {

test/entt/resource/resource.cpp

@@ -1,9 +1,9 @@
 #include <memory>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/linter.hpp"
 #include <entt/core/type_info.hpp>
 #include <entt/resource/resource.hpp>
+#include "../../common/linter.hpp"
 
 struct base {
     virtual ~base() = default;

test/entt/resource/resource_cache.cpp

@@ -3,14 +3,14 @@
 #include <tuple>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/linter.hpp"
-#include "common/throwing_allocator.hpp"
 #include <entt/container/dense_map.hpp>
 #include <entt/core/hashed_string.hpp>
 #include <entt/core/iterator.hpp>
 #include <entt/resource/cache.hpp>
 #include <entt/resource/loader.hpp>
 #include <entt/resource/resource.hpp>
+#include "../../common/linter.hpp"
+#include "../../common/throwing_allocator.hpp"
 
 struct broken_tag {};
 struct with_callback {};

test/entt/signal/delegate.cpp

@@ -1,8 +1,8 @@
 #include <memory>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/config.h"
 #include <entt/signal/delegate.hpp>
+#include "../../common/config.h"
 
 int power_of_two(const int &i) {
     return i * i;

test/entt/signal/emitter.cpp

@@ -2,11 +2,11 @@
 #include <memory>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
-#include "common/emitter.h"
-#include "common/empty.h"
-#include "common/linter.hpp"
 #include <entt/signal/emitter.hpp>
+#include "../../common/boxed_type.h"
+#include "../../common/emitter.h"
+#include "../../common/empty.h"
+#include "../../common/linter.hpp"
 
 TEST(Emitter, Move) {
     test::emitter emitter{};

test/entt/signal/sigh.cpp

@@ -1,8 +1,8 @@
 #include <memory>
 #include <utility>
 #include <gtest/gtest.h>
-#include "common/linter.hpp"
 #include <entt/signal/sigh.hpp>
+#include "../../common/linter.hpp"
 
 struct sigh_listener {
     static void f(int &v) {

test/lib/dispatcher/plugin/main.cpp

@@ -1,10 +1,10 @@
 #define CR_HOST
 
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
-#include "common/listener.h"
 #include <cr.h>
 #include <entt/signal/dispatcher.hpp>
+#include "../../../common/boxed_type.h"
+#include "../../../common/listener.h"
 
 struct listener {
     void on(test::boxed_int msg) {

test/lib/dispatcher/plugin/plugin.cpp

@@ -1,7 +1,7 @@
-#include "common/boxed_type.h"
-#include "common/empty.h"
 #include <cr.h>
 #include <entt/signal/dispatcher.hpp>
+#include "../../../common/boxed_type.h"
+#include "../../../common/empty.h"
 
 CR_EXPORT int cr_main(cr_plugin *ctx, cr_op operation) {
     switch(operation) {

test/lib/dispatcher/shared/lib.cpp

@@ -1,7 +1,7 @@
-#include "common/boxed_type.h"
-#include "common/empty.h"
 #include <entt/core/attribute.h>
 #include <entt/signal/dispatcher.hpp>
+#include "../../../common/boxed_type.h"
+#include "../../../common/empty.h"
 
 ENTT_API void trigger(entt::dispatcher &dispatcher) {
     dispatcher.trigger<test::empty>();

test/lib/dispatcher/shared/main.cpp

@@ -1,9 +1,9 @@
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
-#include "common/listener.h"
 #include <entt/core/attribute.h>
 #include <entt/core/utility.hpp>
 #include <entt/signal/dispatcher.hpp>
+#include "../../../common/boxed_type.h"
+#include "../../../common/listener.h"
 
 ENTT_API void trigger(entt::dispatcher &);
 

test/lib/emitter/plugin/main.cpp

@@ -2,9 +2,9 @@
 
 #include <functional>
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
-#include "common/emitter.h"
 #include <cr.h>
+#include "../../../common/boxed_type.h"
+#include "../../../common/emitter.h"
 
 TEST(Lib, Emitter) {
     test::emitter emitter;

test/lib/emitter/plugin/plugin.cpp

@@ -1,7 +1,7 @@
-#include "common/boxed_type.h"
-#include "common/emitter.h"
-#include "common/empty.h"
 #include <cr.h>
+#include "../../../common/boxed_type.h"
+#include "../../../common/emitter.h"
+#include "../../../common/empty.h"
 
 CR_EXPORT int cr_main(cr_plugin *ctx, cr_op operation) {
     switch(operation) {

test/lib/emitter/shared/lib.cpp

@@ -1,7 +1,7 @@
-#include "common/boxed_type.h"
-#include "common/emitter.h"
-#include "common/empty.h"
 #include <entt/core/attribute.h>
+#include "../../../common/boxed_type.h"
+#include "../../../common/emitter.h"
+#include "../../../common/empty.h"
 
 ENTT_API void emit(test::emitter &emitter) {
     emitter.publish(test::empty{});

test/lib/emitter/shared/main.cpp

@@ -1,8 +1,8 @@
 #include <functional>
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
-#include "common/emitter.h"
 #include <entt/core/attribute.h>
+#include "../../../common/boxed_type.h"
+#include "../../../common/emitter.h"
 
 ENTT_API void emit(test::emitter &);
 

test/lib/locator/plugin/main.cpp

@@ -1,9 +1,9 @@
 #define CR_HOST
 
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
 #include <cr.h>
 #include <entt/locator/locator.hpp>
+#include "../../../common/boxed_type.h"
 #include "userdata.h"
 
 TEST(Lib, Locator) {

test/lib/locator/plugin/plugin.cpp

@@ -1,6 +1,6 @@
-#include "common/boxed_type.h"
 #include <cr.h>
 #include <entt/locator/locator.hpp>
+#include "../../../common/boxed_type.h"
 #include "userdata.h"
 
 CR_EXPORT int cr_main(cr_plugin *ctx, cr_op operation) {

test/lib/locator/plugin/userdata.h

@@ -1,8 +1,8 @@
 #ifndef ENTT_LIB_LOCATOR_PLUGIN_USERDATA_H
 #define ENTT_LIB_LOCATOR_PLUGIN_USERDATA_H
 
-#include "common/boxed_type.h"
 #include <entt/locator/locator.hpp>
+#include "../../../common/boxed_type.h"
 
 struct userdata {
     typename entt::locator<test::boxed_int>::node_type handle{};

test/lib/locator/shared/lib.cpp

@@ -1,6 +1,6 @@
-#include "common/boxed_type.h"
 #include <entt/core/attribute.h>
 #include <entt/locator/locator.hpp>
+#include "../../../common/boxed_type.h"
 
 ENTT_API void set_up(const entt::locator<test::boxed_int>::node_type &handle) {
     entt::locator<test::boxed_int>::reset(handle);

test/lib/locator/shared/main.cpp

@@ -1,7 +1,7 @@
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
 #include <entt/core/attribute.h>
 #include <entt/locator/locator.hpp>
+#include "../../../common/boxed_type.h"
 
 ENTT_API void set_up(const entt::locator<test::boxed_int>::node_type &);
 ENTT_API void use_service(int);

test/lib/meta/plugin/plugin.cpp

@@ -1,11 +1,11 @@
-#include "common/boxed_type.h"
-#include "common/empty.h"
 #include <cr.h>
 #include <entt/core/hashed_string.hpp>
 #include <entt/locator/locator.hpp>
 #include <entt/meta/context.hpp>
 #include <entt/meta/factory.hpp>
 #include <entt/meta/meta.hpp>
+#include "../../../common/boxed_type.h"
+#include "../../../common/empty.h"
 #include "userdata.h"
 
 test::boxed_int create_boxed_int(int value) {

test/lib/meta/plugin_std/plugin.cpp

@@ -1,11 +1,11 @@
-#include "common/boxed_type.h"
-#include "common/empty.h"
 #include <cr.h>
 #include <entt/core/hashed_string.hpp>
 #include <entt/locator/locator.hpp>
 #include <entt/meta/context.hpp>
 #include <entt/meta/factory.hpp>
 #include <entt/meta/meta.hpp>
+#include "../../../common/boxed_type.h"
+#include "../../../common/empty.h"
 #include "userdata.h"
 
 test::boxed_int create_boxed_int(int value) {

test/lib/meta/plugin_std/userdata.h

@@ -2,12 +2,12 @@
 #define ENTT_LIB_META_PLUGIN_STD_USERDATA_H
 
 #include <type_traits>
-#include "common/boxed_type.h"
-#include "common/empty.h"
 #include <entt/core/hashed_string.hpp>
 #include <entt/core/type_info.hpp>
 #include <entt/meta/context.hpp>
 #include <entt/meta/meta.hpp>
+#include "../../../common/boxed_type.h"
+#include "../../../common/empty.h"
 
 #define ASSIGN_TYPE_ID(clazz) \
     template<> \

test/lib/meta/shared/lib.cpp

@@ -1,11 +1,11 @@
-#include "common/boxed_type.h"
-#include "common/empty.h"
 #include <entt/core/attribute.h>
 #include <entt/core/hashed_string.hpp>
 #include <entt/locator/locator.hpp>
 #include <entt/meta/context.hpp>
 #include <entt/meta/factory.hpp>
 #include <entt/meta/meta.hpp>
+#include "../../../common/boxed_type.h"
+#include "../../../common/empty.h"
 
 test::boxed_int create_boxed_int(int value) {
     return test::boxed_int{value};
@@ -19,7 +19,7 @@ ENTT_API void set_up() {
     using namespace entt::literals;
 
     entt::meta<test::boxed_int>()
-        .type(mboxed_intm_hs)
+        .type("boxed_int"_hs)
         .ctor<&create_boxed_int>()
         .data<&test::boxed_int::value>("value"_hs);
 

test/lib/meta/shared/main.cpp

@@ -1,12 +1,12 @@
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
-#include "common/empty.h"
 #include <entt/core/attribute.h>
 #include <entt/core/hashed_string.hpp>
 #include <entt/locator/locator.hpp>
 #include <entt/meta/context.hpp>
 #include <entt/meta/meta.hpp>
 #include <entt/meta/resolve.hpp>
+#include "../../../common/boxed_type.h"
+#include "../../../common/empty.h"
 
 ENTT_API void share(const entt::locator<entt::meta_ctx>::node_type &);
 ENTT_API void set_up();
@@ -16,7 +16,7 @@ ENTT_API entt::meta_any wrap_int(int);
 TEST(Lib, Meta) {
     using namespace entt::literals;
 
-    ASSERT_FALSE(entt::resolve(mboxed_int"_hs));
+    ASSERT_FALSE(entt::resolve("boxed_int"_hs));
     ASSERT_FALSE(entt::resolve("empty"_hs));
 
     share(entt::locator<entt::meta_ctx>::handle());

test/lib/registry/plugin/main.cpp

@@ -1,12 +1,12 @@
 #define CR_HOST
 
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
-#include "common/empty.h"
 #include <cr.h>
 #include <entt/entity/entity.hpp>
 #include <entt/entity/registry.hpp>
 #include <entt/entity/view.hpp>
+#include "../../../common/boxed_type.h"
+#include "../../../common/empty.h"
 
 TEST(Lib, Registry) {
     constexpr auto count = 3;

test/lib/registry/plugin/plugin.cpp

@@ -1,7 +1,7 @@
-#include "common/boxed_type.h"
-#include "common/empty.h"
 #include <cr.h>
 #include <entt/entity/registry.hpp>
+#include "../../../common/boxed_type.h"
+#include "../../../common/empty.h"
 
 CR_EXPORT int cr_main(cr_plugin *ctx, cr_op operation) {
     constexpr auto count = 3;

test/lib/registry/shared/lib.cpp

@@ -1,7 +1,7 @@
-#include "common/boxed_type.h"
-#include "common/empty.h"
 #include <entt/core/attribute.h>
 #include <entt/entity/registry.hpp>
+#include "../../../common/boxed_type.h"
+#include "../../../common/empty.h"
 
 template class entt::basic_registry<entt::entity>;
 

test/lib/registry/shared/main.cpp

@@ -1,10 +1,10 @@
 #include <gtest/gtest.h>
-#include "common/boxed_type.h"
-#include "common/empty.h"
 #include <entt/core/attribute.h>
 #include <entt/entity/entity.hpp>
 #include <entt/entity/registry.hpp>
 #include <entt/entity/view.hpp>
+#include "../../../common/boxed_type.h"
+#include "../../../common/empty.h"
 
 ENTT_API void update(entt::registry &, int);
 ENTT_API void insert(entt::registry &);