From 0c9e57bfdc2ac5bead6c5f4984d3ae26eaeb5769 Mon Sep 17 00:00:00 2001
From: Stanislaw Halik <sthalik@misaki.pl>
Date: Sun, 5 Nov 2023 17:20:50 +0100
Subject: cc

---
 test/entity.cpp | 259 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 test/object.cpp | 259 --------------------------------------------------------
 2 files changed, 259 insertions(+), 259 deletions(-)
 create mode 100644 test/entity.cpp
 delete mode 100644 test/object.cpp

(limited to 'test')

diff --git a/test/entity.cpp b/test/entity.cpp
new file mode 100644
index 00000000..3c099a37
--- /dev/null
+++ b/test/entity.cpp
@@ -0,0 +1,259 @@
+#include "app.hpp"
+#include "compat/assert.hpp"
+#include "entity/metadata.hpp"
+#include <tuple>
+
+using namespace floormat;
+using namespace floormat::entities;
+
+namespace {
+
+struct TestAccessors {
+    constexpr int bar() const { return _bar; }
+    constexpr void set_bar(int value) { _bar = value; }
+    int foo;
+    int _bar;
+    int _baz;
+};
+
+} // namespace
+
+namespace floormat::entities {
+
+template<> struct entity_accessors<TestAccessors, inspect_intent_t> {
+    static constexpr auto accessors()
+    {
+        using entity = Entity<TestAccessors>;
+        constexpr auto r_baz = [](const TestAccessors& x) { return x._baz; };
+        constexpr auto w_baz = [](TestAccessors& x, int v) { x._baz = v; };
+
+        constexpr auto tuple = std::make_tuple(
+            entity::type<int>::field{"foo"_s, &TestAccessors::foo, &TestAccessors::foo},
+            entity::type<int>::field{"bar"_s, &TestAccessors::bar, &TestAccessors::set_bar},
+            entity::type<int>::field("baz"_s, r_baz, w_baz)
+        );
+        return tuple;
+    }
+};
+
+} // namespace floormat::entities
+
+namespace {
+
+using entity = Entity<TestAccessors>;
+constexpr auto m_foo = entity::type<int>::field{"foo"_s, &TestAccessors::foo, &TestAccessors::foo};
+constexpr auto m_bar = entity::type<int>::field{"bar"_s, &TestAccessors::bar, &TestAccessors::set_bar};
+constexpr auto r_baz = [](const TestAccessors& x) { return x._baz; };
+constexpr auto w_baz = [](TestAccessors& x, int v) { x._baz = v; };
+constexpr auto m_baz = entity::type<int>::field("baz"_s, r_baz, w_baz);
+
+} // namespace
+
+namespace floormat {
+
+namespace {
+
+constexpr bool test_accessors()
+{
+    auto x = TestAccessors{111, 222, 333};
+
+    {
+        auto a = m_foo.read(x), b = m_bar.read(x), c = m_baz.read(x);
+        fm_assert(a == 111 && b == 222 && c == 333);
+    }
+
+    {
+        m_foo.write(x, 1111);
+        m_bar.write(x, 2222);
+        m_baz.write(x, 3333);
+        auto a = m_foo.read(x), b = m_bar.read(x), c = m_baz.read(x);
+        fm_assert(a == 1111 && b == 2222 && c == 3333);
+    }
+    return true;
+}
+
+constexpr bool test_visitor()
+{
+    {
+        auto tuple = std::make_tuple((unsigned char)1, (unsigned short)2, (int)3, (long)4);
+        long ret = 0;
+        visit_tuple([&](auto x) { ret += (long)x; }, tuple);
+        fm_assert(ret == 1 + 2 + 3 + 4);
+    }
+    {
+        int ret = 0;
+        visit_tuple([&] { ret++; }, std::tuple<>{});
+        fm_assert(ret == 0);
+    }
+    {
+        constexpr auto tuple = std::make_tuple((char)1, (short)2, (long)3);
+        static_assert(find_in_tuple([](auto x) { return x == 3; }, tuple));
+        static_assert(!find_in_tuple([](auto x) { return x == 5; }, tuple));
+    }
+
+    return true;
+}
+
+void test_fun2() {
+    using entity = Entity<TestAccessors>;
+    static constexpr auto read_fn = [](const TestAccessors& x) constexpr { return x.bar(); };
+    static constexpr auto write_fn = [](TestAccessors& x, int value) constexpr { x.set_bar(value); };
+    constexpr auto read_bar = fu2::function_view<int(const TestAccessors&) const>{read_fn};
+    constexpr auto write_bar = fu2::function_view<void(TestAccessors&, int) const>{write_fn};
+    constexpr auto m_bar2 = entity::type<int>::field{"bar"_s, read_bar, write_bar};
+
+    auto x = TestAccessors{1, 2, 3};
+    fm_assert(m_bar2.read(x) == 2);
+    m_bar2.write(x, 22);
+    fm_assert(m_bar2.read(x) == 22);
+}
+
+void test_erasure() {
+    erased_accessor accessors[] = {
+        m_foo.erased(),
+        m_bar.erased(),
+        m_baz.erased(),
+    };
+    auto obj = TestAccessors{1, 2, 3};
+    int value = 0;
+    accessors[1].read_fun(&obj, accessors[1].reader, &value);
+    fm_assert(value == 2);
+    int value2 = 22222, value2_ = 0;
+    accessors[1].write_fun(&obj, accessors[1].writer, &value2);
+    accessors[1].read_fun(&obj, accessors[1].reader, &value2_);
+    fm_assert(value2 == value2_);
+}
+
+void test_metadata()
+{
+    constexpr auto m = entity_metadata<TestAccessors, inspect_intent_t>();
+    static_assert(sizeof m == 1);
+    fm_assert(m.class_name == name_of<TestAccessors>);
+    fm_assert(m.class_name.contains("TestAccessors"_s));
+    const auto [foo, bar, baz] = m.accessors;
+    const auto [foo2, bar2, baz2] = m.erased_accessors;
+    TestAccessors x{0, 0, 0};
+    foo.write(x, 1);
+    fm_assert(x.foo == 1);
+    int bar_ = 2;
+    bar2.write_fun(&x, bar2.writer, &bar_);
+    fm_assert(x.bar() == 2);
+    baz2.write<TestAccessors, int>(x, 3);
+    fm_assert(baz2.read<TestAccessors, int>(x) == 3);
+}
+
+void test_type_name()
+{
+    struct foobar;
+    constexpr StringView name = name_of<foobar>;
+    fm_assert(name.contains("foobar"_s));
+    static_assert(name.data() == name_of<foobar>.data());
+    static_assert(name_of<int> != name_of<unsigned>);
+    static_assert(name_of<foobar*> != name_of<const foobar*>);
+    using foobar2 = foobar;
+    static_assert(name_of<foobar2>.data() == name_of<foobar>.data());
+}
+
+[[maybe_unused]] constexpr void test_null_writer()
+{
+    using entity = Entity<TestAccessors>;
+    constexpr auto foo = entity::type<int>::field{"foo"_s, &TestAccessors::foo, nullptr};
+    static_assert(foo.writer == nullptr);
+    static_assert(!foo.can_write);
+    static_assert(std::get<0>(entity_accessors<TestAccessors, inspect_intent_t>::accessors()).can_write);
+}
+
+void test_predicate()
+{
+    using entity = Entity<TestAccessors>;
+    constexpr TestAccessors x{0, 0, 0};
+    constexpr auto foo = entity::type<int>::field{"foo"_s, &TestAccessors::foo, &TestAccessors::foo,
+                                                  [](const TestAccessors&) { return field_status::hidden; }};
+    static_assert(foo.is_enabled(x) == field_status::hidden);
+    fm_assert(foo.erased().is_enabled(&x) == field_status::hidden);
+
+    foo.erased().do_asserts<TestAccessors>();
+
+    constexpr auto foo2 = entity::type<int>::field{"foo"_s, &TestAccessors::foo, &TestAccessors::foo,
+                                                   [](const TestAccessors&) { return field_status::readonly; }};
+    static_assert(foo2.is_enabled(x) == field_status::readonly);
+    fm_assert(foo2.erased().is_enabled(&x) == field_status::readonly);
+    constexpr auto foo3 = entity::type<int>::field{"foo"_s, &TestAccessors::foo, &TestAccessors::foo};
+    static_assert(foo3.is_enabled(x) == field_status::enabled);
+    fm_assert(foo3.erased().is_enabled(&x) == field_status::enabled);
+}
+
+constexpr bool test_names()
+{
+    constexpr auto m = entity_metadata<TestAccessors, inspect_intent_t>();
+    auto [foo1, bar1, baz1] = m.accessors;
+    auto [foo2, bar2, baz2] = m.erased_accessors;
+
+    fm_assert(foo1.name == "foo"_s);
+    fm_assert(bar1.name == "bar"_s);
+    fm_assert(baz1.name == "baz"_s);
+
+    fm_assert(foo2.field_name == "foo"_s);
+    fm_assert(bar2.field_name == "bar"_s);
+    fm_assert(baz2.field_name == "baz"_s);
+    return true;
+}
+
+constexpr void test_constraints()
+{
+    using entity = Entity<TestAccessors>;
+    constexpr auto x = TestAccessors{};
+    constexpr auto foo = entity::type<int>::field {
+        "foo"_s, &TestAccessors::foo, &TestAccessors::foo,
+        constantly(constraints::max_length{42}),
+        constantly(constraints::range<int>{37, 42}),
+    };
+
+    static_assert(foo.get_range(x) == constraints::range<int>{37, 42});
+    static_assert(foo.get_max_length(x) == 42);
+
+    static_assert(m_foo.get_range(x) == constraints::range<int>{});
+    static_assert(m_foo.get_max_length(x) == (size_t)-1);
+
+    constexpr auto foo2 = entity::type<int>::field {
+        "foo"_s, &TestAccessors::foo, &TestAccessors::foo,
+        constantly(constraints::max_length {123}),
+    };
+    static_assert(foo2.get_range(x) == constraints::range<int>{});
+    static_assert(foo2.get_max_length(x) == 123);
+}
+
+void test_erased_constraints()
+{
+    using entity = Entity<TestAccessors>;
+    static constexpr auto foo = entity::type<int>::field{
+        "foo"_s, &TestAccessors::foo, &TestAccessors::foo,
+        constantly(constraints::max_length{42}),
+        constantly(constraints::range<int>{37, 42}),
+    };
+    static constexpr auto erased = foo.erased();
+    const auto x = TestAccessors{};
+
+    erased.do_asserts<TestAccessors>();
+    fm_assert(erased.get_range(&x) == constraints::range<int>{37, 42});
+    fm_assert(erased.get_max_length(&x) == 42);
+}
+
+} // namespace
+
+void test_app::test_entity()
+{
+    static_assert(test_accessors());
+    static_assert(test_visitor());
+    test_null_writer();
+    static_assert(test_names());
+    test_predicate();
+    test_fun2();
+    test_erasure();
+    test_type_name();
+    test_metadata();
+    test_constraints();
+    test_erased_constraints();
+}
+
+} // namespace floormat
diff --git a/test/object.cpp b/test/object.cpp
deleted file mode 100644
index 3c099a37..00000000
--- a/test/object.cpp
+++ /dev/null
@@ -1,259 +0,0 @@
-#include "app.hpp"
-#include "compat/assert.hpp"
-#include "entity/metadata.hpp"
-#include <tuple>
-
-using namespace floormat;
-using namespace floormat::entities;
-
-namespace {
-
-struct TestAccessors {
-    constexpr int bar() const { return _bar; }
-    constexpr void set_bar(int value) { _bar = value; }
-    int foo;
-    int _bar;
-    int _baz;
-};
-
-} // namespace
-
-namespace floormat::entities {
-
-template<> struct entity_accessors<TestAccessors, inspect_intent_t> {
-    static constexpr auto accessors()
-    {
-        using entity = Entity<TestAccessors>;
-        constexpr auto r_baz = [](const TestAccessors& x) { return x._baz; };
-        constexpr auto w_baz = [](TestAccessors& x, int v) { x._baz = v; };
-
-        constexpr auto tuple = std::make_tuple(
-            entity::type<int>::field{"foo"_s, &TestAccessors::foo, &TestAccessors::foo},
-            entity::type<int>::field{"bar"_s, &TestAccessors::bar, &TestAccessors::set_bar},
-            entity::type<int>::field("baz"_s, r_baz, w_baz)
-        );
-        return tuple;
-    }
-};
-
-} // namespace floormat::entities
-
-namespace {
-
-using entity = Entity<TestAccessors>;
-constexpr auto m_foo = entity::type<int>::field{"foo"_s, &TestAccessors::foo, &TestAccessors::foo};
-constexpr auto m_bar = entity::type<int>::field{"bar"_s, &TestAccessors::bar, &TestAccessors::set_bar};
-constexpr auto r_baz = [](const TestAccessors& x) { return x._baz; };
-constexpr auto w_baz = [](TestAccessors& x, int v) { x._baz = v; };
-constexpr auto m_baz = entity::type<int>::field("baz"_s, r_baz, w_baz);
-
-} // namespace
-
-namespace floormat {
-
-namespace {
-
-constexpr bool test_accessors()
-{
-    auto x = TestAccessors{111, 222, 333};
-
-    {
-        auto a = m_foo.read(x), b = m_bar.read(x), c = m_baz.read(x);
-        fm_assert(a == 111 && b == 222 && c == 333);
-    }
-
-    {
-        m_foo.write(x, 1111);
-        m_bar.write(x, 2222);
-        m_baz.write(x, 3333);
-        auto a = m_foo.read(x), b = m_bar.read(x), c = m_baz.read(x);
-        fm_assert(a == 1111 && b == 2222 && c == 3333);
-    }
-    return true;
-}
-
-constexpr bool test_visitor()
-{
-    {
-        auto tuple = std::make_tuple((unsigned char)1, (unsigned short)2, (int)3, (long)4);
-        long ret = 0;
-        visit_tuple([&](auto x) { ret += (long)x; }, tuple);
-        fm_assert(ret == 1 + 2 + 3 + 4);
-    }
-    {
-        int ret = 0;
-        visit_tuple([&] { ret++; }, std::tuple<>{});
-        fm_assert(ret == 0);
-    }
-    {
-        constexpr auto tuple = std::make_tuple((char)1, (short)2, (long)3);
-        static_assert(find_in_tuple([](auto x) { return x == 3; }, tuple));
-        static_assert(!find_in_tuple([](auto x) { return x == 5; }, tuple));
-    }
-
-    return true;
-}
-
-void test_fun2() {
-    using entity = Entity<TestAccessors>;
-    static constexpr auto read_fn = [](const TestAccessors& x) constexpr { return x.bar(); };
-    static constexpr auto write_fn = [](TestAccessors& x, int value) constexpr { x.set_bar(value); };
-    constexpr auto read_bar = fu2::function_view<int(const TestAccessors&) const>{read_fn};
-    constexpr auto write_bar = fu2::function_view<void(TestAccessors&, int) const>{write_fn};
-    constexpr auto m_bar2 = entity::type<int>::field{"bar"_s, read_bar, write_bar};
-
-    auto x = TestAccessors{1, 2, 3};
-    fm_assert(m_bar2.read(x) == 2);
-    m_bar2.write(x, 22);
-    fm_assert(m_bar2.read(x) == 22);
-}
-
-void test_erasure() {
-    erased_accessor accessors[] = {
-        m_foo.erased(),
-        m_bar.erased(),
-        m_baz.erased(),
-    };
-    auto obj = TestAccessors{1, 2, 3};
-    int value = 0;
-    accessors[1].read_fun(&obj, accessors[1].reader, &value);
-    fm_assert(value == 2);
-    int value2 = 22222, value2_ = 0;
-    accessors[1].write_fun(&obj, accessors[1].writer, &value2);
-    accessors[1].read_fun(&obj, accessors[1].reader, &value2_);
-    fm_assert(value2 == value2_);
-}
-
-void test_metadata()
-{
-    constexpr auto m = entity_metadata<TestAccessors, inspect_intent_t>();
-    static_assert(sizeof m == 1);
-    fm_assert(m.class_name == name_of<TestAccessors>);
-    fm_assert(m.class_name.contains("TestAccessors"_s));
-    const auto [foo, bar, baz] = m.accessors;
-    const auto [foo2, bar2, baz2] = m.erased_accessors;
-    TestAccessors x{0, 0, 0};
-    foo.write(x, 1);
-    fm_assert(x.foo == 1);
-    int bar_ = 2;
-    bar2.write_fun(&x, bar2.writer, &bar_);
-    fm_assert(x.bar() == 2);
-    baz2.write<TestAccessors, int>(x, 3);
-    fm_assert(baz2.read<TestAccessors, int>(x) == 3);
-}
-
-void test_type_name()
-{
-    struct foobar;
-    constexpr StringView name = name_of<foobar>;
-    fm_assert(name.contains("foobar"_s));
-    static_assert(name.data() == name_of<foobar>.data());
-    static_assert(name_of<int> != name_of<unsigned>);
-    static_assert(name_of<foobar*> != name_of<const foobar*>);
-    using foobar2 = foobar;
-    static_assert(name_of<foobar2>.data() == name_of<foobar>.data());
-}
-
-[[maybe_unused]] constexpr void test_null_writer()
-{
-    using entity = Entity<TestAccessors>;
-    constexpr auto foo = entity::type<int>::field{"foo"_s, &TestAccessors::foo, nullptr};
-    static_assert(foo.writer == nullptr);
-    static_assert(!foo.can_write);
-    static_assert(std::get<0>(entity_accessors<TestAccessors, inspect_intent_t>::accessors()).can_write);
-}
-
-void test_predicate()
-{
-    using entity = Entity<TestAccessors>;
-    constexpr TestAccessors x{0, 0, 0};
-    constexpr auto foo = entity::type<int>::field{"foo"_s, &TestAccessors::foo, &TestAccessors::foo,
-                                                  [](const TestAccessors&) { return field_status::hidden; }};
-    static_assert(foo.is_enabled(x) == field_status::hidden);
-    fm_assert(foo.erased().is_enabled(&x) == field_status::hidden);
-
-    foo.erased().do_asserts<TestAccessors>();
-
-    constexpr auto foo2 = entity::type<int>::field{"foo"_s, &TestAccessors::foo, &TestAccessors::foo,
-                                                   [](const TestAccessors&) { return field_status::readonly; }};
-    static_assert(foo2.is_enabled(x) == field_status::readonly);
-    fm_assert(foo2.erased().is_enabled(&x) == field_status::readonly);
-    constexpr auto foo3 = entity::type<int>::field{"foo"_s, &TestAccessors::foo, &TestAccessors::foo};
-    static_assert(foo3.is_enabled(x) == field_status::enabled);
-    fm_assert(foo3.erased().is_enabled(&x) == field_status::enabled);
-}
-
-constexpr bool test_names()
-{
-    constexpr auto m = entity_metadata<TestAccessors, inspect_intent_t>();
-    auto [foo1, bar1, baz1] = m.accessors;
-    auto [foo2, bar2, baz2] = m.erased_accessors;
-
-    fm_assert(foo1.name == "foo"_s);
-    fm_assert(bar1.name == "bar"_s);
-    fm_assert(baz1.name == "baz"_s);
-
-    fm_assert(foo2.field_name == "foo"_s);
-    fm_assert(bar2.field_name == "bar"_s);
-    fm_assert(baz2.field_name == "baz"_s);
-    return true;
-}
-
-constexpr void test_constraints()
-{
-    using entity = Entity<TestAccessors>;
-    constexpr auto x = TestAccessors{};
-    constexpr auto foo = entity::type<int>::field {
-        "foo"_s, &TestAccessors::foo, &TestAccessors::foo,
-        constantly(constraints::max_length{42}),
-        constantly(constraints::range<int>{37, 42}),
-    };
-
-    static_assert(foo.get_range(x) == constraints::range<int>{37, 42});
-    static_assert(foo.get_max_length(x) == 42);
-
-    static_assert(m_foo.get_range(x) == constraints::range<int>{});
-    static_assert(m_foo.get_max_length(x) == (size_t)-1);
-
-    constexpr auto foo2 = entity::type<int>::field {
-        "foo"_s, &TestAccessors::foo, &TestAccessors::foo,
-        constantly(constraints::max_length {123}),
-    };
-    static_assert(foo2.get_range(x) == constraints::range<int>{});
-    static_assert(foo2.get_max_length(x) == 123);
-}
-
-void test_erased_constraints()
-{
-    using entity = Entity<TestAccessors>;
-    static constexpr auto foo = entity::type<int>::field{
-        "foo"_s, &TestAccessors::foo, &TestAccessors::foo,
-        constantly(constraints::max_length{42}),
-        constantly(constraints::range<int>{37, 42}),
-    };
-    static constexpr auto erased = foo.erased();
-    const auto x = TestAccessors{};
-
-    erased.do_asserts<TestAccessors>();
-    fm_assert(erased.get_range(&x) == constraints::range<int>{37, 42});
-    fm_assert(erased.get_max_length(&x) == 42);
-}
-
-} // namespace
-
-void test_app::test_entity()
-{
-    static_assert(test_accessors());
-    static_assert(test_visitor());
-    test_null_writer();
-    static_assert(test_names());
-    test_predicate();
-    test_fun2();
-    test_erasure();
-    test_type_name();
-    test_metadata();
-    test_constraints();
-    test_erased_constraints();
-}
-
-} // namespace floormat
-- 
cgit v1.2.3