From 661e98cf8bb61f29049d405aef9cdaace1449ac8 Mon Sep 17 00:00:00 2001
From: Felix Morgner <felix.morgner@gmail.com>
Date: Tue, 13 May 2025 14:19:42 +0200
Subject: libmm: add tests

---
 lib/src/turnsmm/enums.cpp       | 38 ++++++++++++++++++++++++
 lib/src/turnsmm/enums.hpp       | 37 +++++++++++++++++++++++
 lib/src/turnsmm/init.cpp        | 28 +++++++++++++++++
 lib/src/turnsmm/init.hpp        |  9 ++++++
 lib/src/turnsmm/participant.cpp | 66 ++++++++++++++++++++++++++++++++++++-----
 lib/src/turnsmm/participant.hpp | 19 ++++++++++--
 6 files changed, 186 insertions(+), 11 deletions(-)
 create mode 100644 lib/src/turnsmm/enums.cpp
 create mode 100644 lib/src/turnsmm/enums.hpp
 create mode 100644 lib/src/turnsmm/init.cpp
 create mode 100644 lib/src/turnsmm/init.hpp

(limited to 'lib/src')

diff --git a/lib/src/turnsmm/enums.cpp b/lib/src/turnsmm/enums.cpp
new file mode 100644
index 0000000..91d6eb3
--- /dev/null
+++ b/lib/src/turnsmm/enums.cpp
@@ -0,0 +1,38 @@
+#include "turnsmm/enums.hpp"
+
+#include "turns-disposition.h"
+#include "turns-enums.h"  // IWYU pragma: keep
+
+#include <glib-object.h>
+
+#include <type_traits>
+
+namespace
+{
+  template<auto Wrapped, auto Unwrapped>
+  auto constexpr matches =
+      static_cast<std::underlying_type_t<decltype(Wrapped)>>(Wrapped) == static_cast<std::underlying_type_t<decltype(Unwrapped)>>(Unwrapped);
+}  // namespace
+
+namespace Turns
+{
+
+  static_assert(matches<Disposition::Neutral, TURNS_DISPOSITION_NEUTRAL>);
+  static_assert(matches<Disposition::Friendly, TURNS_DISPOSITION_FRIENDLY>);
+  static_assert(matches<Disposition::Hostile, TURNS_DISPOSITION_HOSTILE>);
+  static_assert(matches<Disposition::Secret, TURNS_DISPOSITION_SECRET>);
+
+}  // namespace Turns
+
+namespace Glib
+{
+#define VALUE_SPECIALIZATION(Enum, TurnsEnumName)                                                                                              \
+  auto Value<Turns::Enum>::value_type() -> GType                                                                                               \
+  {                                                                                                                                            \
+    return turns_##TurnsEnumName##_get_type();                                                                                                 \
+  }
+
+  VALUE_SPECIALIZATION(Disposition, disposition)
+
+#undef VALUE_SPECIALIZATION
+}  // namespace Glib
\ No newline at end of file
diff --git a/lib/src/turnsmm/enums.hpp b/lib/src/turnsmm/enums.hpp
new file mode 100644
index 0000000..f99a6f1
--- /dev/null
+++ b/lib/src/turnsmm/enums.hpp
@@ -0,0 +1,37 @@
+#ifndef TURNSMM_ENUMS_HPP
+#define TURNSMM_ENUMS_HPP
+
+#include <glibmm/value.h>
+
+#include <glib-object.h>
+
+namespace Turns
+{
+  enum struct Disposition
+  {
+    Neutral,
+    Friendly,
+    Hostile,
+    Secret,
+  };
+
+}  // namespace Turns
+
+namespace Glib
+{
+
+#define VALUE_SPECIALIZATION(Enum)                                                                                                             \
+  template<>                                                                                                                                   \
+  class Value<Turns::Enum> : public Glib::Value_Enum<Turns::Enum>                                                                              \
+  {                                                                                                                                            \
+  public:                                                                                                                                      \
+    auto static value_type() -> GType;                                                                                                         \
+  }
+
+  VALUE_SPECIALIZATION(Disposition);
+
+#undef VALUE_SPECIALIZATION
+
+}  // namespace Glib
+
+#endif
\ No newline at end of file
diff --git a/lib/src/turnsmm/init.cpp b/lib/src/turnsmm/init.cpp
new file mode 100644
index 0000000..77c217b
--- /dev/null
+++ b/lib/src/turnsmm/init.cpp
@@ -0,0 +1,28 @@
+#include "turnsmm/init.hpp"
+
+#include "turns-init.h"
+#include "turnsmm/enums.hpp"
+#include "turnsmm/participant.hpp"
+#include "turnsmm/private/participant_p.hpp"  // IWYU pragma: keep
+
+#include <glibmm/value.h>
+#include <glibmm/wrap.h>
+
+#include <glib-object.h>
+
+#define WRAP_CLASS(Name, name) Glib::wrap_register(turns_##name##_get_type(), &Name##_Class::wrap_new)
+#define ENSURE_TYPE(Name) g_type_ensure(Name::get_type())
+
+namespace Turns
+{
+
+  auto init() -> void
+  {
+    turns_init();
+
+    WRAP_CLASS(Participant, participant);
+
+    ENSURE_TYPE(Participant);
+  }
+
+}  // namespace Turns
\ No newline at end of file
diff --git a/lib/src/turnsmm/init.hpp b/lib/src/turnsmm/init.hpp
new file mode 100644
index 0000000..a9ee8cc
--- /dev/null
+++ b/lib/src/turnsmm/init.hpp
@@ -0,0 +1,9 @@
+#ifndef TURNSMM_INIT_HPP
+#define TURNSMM_INIT_HPP
+
+namespace Turns
+{
+  void init(void);
+}
+
+#endif
diff --git a/lib/src/turnsmm/participant.cpp b/lib/src/turnsmm/participant.cpp
index 0086ada..5cc3db6 100644
--- a/lib/src/turnsmm/participant.cpp
+++ b/lib/src/turnsmm/participant.cpp
@@ -2,12 +2,14 @@
 
 #include "turns-disposition.h"
 #include "turns-participant.h"
+#include "turnsmm/enums.hpp"
 #include "turnsmm/private/participant_p.hpp"
 
 #include <glibmm/class.h>
 #include <glibmm/object.h>
 #include <glibmm/objectbase.h>
 #include <glibmm/private/object_p.h>
+#include <glibmm/propertyproxy.h>
 #include <glibmm/refptr.h>
 #include <glibmm/ustring.h>
 #include <glibmm/utility.h>
@@ -23,8 +25,6 @@ namespace Turns
   namespace
   {
     auto constinit _class = Participant_Class{};
-
-    auto constexpr type_name = "TurnsParticipant";
   }  // namespace
 
   auto Participant_Class::init() -> Glib::Class const &
@@ -49,13 +49,13 @@ namespace Turns
   }
 
   Participant::Participant()
-      : Glib::ObjectBase{type_name}
+      : Glib::ObjectBase{nullptr}
       , Glib::Object{Glib::ConstructParams{_class.init()}}
   {
   }
 
-  Participant::Participant(Glib::ustring const & name, float priority, int disposition)
-      : Glib::ObjectBase{type_name}
+  Participant::Participant(Glib::ustring const & name, float priority, Disposition disposition)
+      : Glib::ObjectBase{nullptr}
       , Glib::Object{Glib::ConstructParams{_class.init(), "name", name.c_str(), "priority", priority, "disposition", disposition, nullptr}}
   {
   }
@@ -86,9 +86,9 @@ namespace Turns
     return turns_participant_get_defeated(const_cast<BaseObjectType *>(unwrap(this)));
   }
 
-  auto Participant::get_disposition() const noexcept -> int
+  auto Participant::get_disposition() const noexcept -> Disposition
   {
-    return turns_participant_get_disposition(const_cast<BaseObjectType *>(unwrap(this)));
+    return static_cast<Disposition>(turns_participant_get_disposition(const_cast<BaseObjectType *>(unwrap(this))));
   }
 
   auto Participant::get_name() const -> Glib::ustring
@@ -111,7 +111,7 @@ namespace Turns
     return turns_participant_set_defeated(unwrap(this), value);
   }
 
-  auto Participant::set_disposition(int value) noexcept -> void
+  auto Participant::set_disposition(Disposition value) noexcept -> void
   {
     return turns_participant_set_disposition(unwrap(this), static_cast<TurnsDisposition>(value));
   }
@@ -126,6 +126,56 @@ namespace Turns
     return turns_participant_set_priority(unwrap(this), value);
   }
 
+  auto Participant::property_active() const noexcept -> Glib::PropertyProxy_ReadOnly<bool>
+  {
+    return {this, "active"};
+  }
+
+  auto Participant::property_active() noexcept -> Glib::PropertyProxy<bool>
+  {
+    return {this, "active"};
+  }
+
+  auto Participant::property_defeated() const noexcept -> Glib::PropertyProxy_ReadOnly<bool>
+  {
+    return {this, "defeated"};
+  }
+
+  auto Participant::property_defeated() noexcept -> Glib::PropertyProxy<bool>
+  {
+    return {this, "defeated"};
+  }
+
+  auto Participant::property_disposition() const noexcept -> Glib::PropertyProxy_ReadOnly<Disposition>
+  {
+    return {this, "disposition"};
+  }
+
+  auto Participant::property_disposition() noexcept -> Glib::PropertyProxy<Disposition>
+  {
+    return {this, "disposition"};
+  }
+
+  auto Participant::property_name() const noexcept -> Glib::PropertyProxy_ReadOnly<Glib::ustring const &>
+  {
+    return {this, "name"};
+  }
+
+  auto Participant::property_name() noexcept -> Glib::PropertyProxy<Glib::ustring const &>
+  {
+    return {this, "name"};
+  }
+
+  auto Participant::property_priority() const noexcept -> Glib::PropertyProxy_ReadOnly<float>
+  {
+    return {this, "priority"};
+  }
+
+  auto Participant::property_priority() noexcept -> Glib::PropertyProxy<float>
+  {
+    return {this, "priority"};
+  }
+
   Participant::Participant(BaseObjectType * gobj)
       : Glib::Object((GObject *)gobj)
   {
diff --git a/lib/src/turnsmm/participant.hpp b/lib/src/turnsmm/participant.hpp
index 1eb5c1e..b41c64b 100644
--- a/lib/src/turnsmm/participant.hpp
+++ b/lib/src/turnsmm/participant.hpp
@@ -2,8 +2,10 @@
 #define TURNSMM_PARTICIPANT_HPP
 
 #include "turns-participant.h"
+#include "turnsmm/enums.hpp"
 
 #include <glibmm/object.h>
+#include <glibmm/propertyproxy.h>
 #include <glibmm/refptr.h>
 #include <glibmm/ustring.h>
 
@@ -19,7 +21,7 @@ namespace Turns
     using CppObjectType = Participant;
 
     Participant();
-    Participant(Glib::ustring const & name, float priority, int disposition);
+    Participant(Glib::ustring const & name, float priority, Disposition disposition);
 
     [[nodiscard]] auto gobj() noexcept -> BaseObjectType *;
     [[nodiscard]] auto gobj() const -> BaseObjectType const *;
@@ -27,16 +29,27 @@ namespace Turns
 
     [[nodiscard]] auto get_active() const noexcept -> bool;
     [[nodiscard]] auto get_defeated() const noexcept -> bool;
-    [[nodiscard]] auto get_disposition() const noexcept -> int;
+    [[nodiscard]] auto get_disposition() const noexcept -> Disposition;
     [[nodiscard]] auto get_name() const -> Glib::ustring;
     [[nodiscard]] auto get_priority() const noexcept -> float;
 
     auto set_active(bool value) noexcept -> void;
     auto set_defeated(bool value) noexcept -> void;
-    auto set_disposition(int value) noexcept -> void;
+    auto set_disposition(Disposition value) noexcept -> void;
     auto set_name(Glib::ustring const & value) noexcept -> void;
     auto set_priority(float value) noexcept -> void;
 
+    [[nodiscard]] auto property_active() const noexcept -> Glib::PropertyProxy_ReadOnly<bool>;
+    [[nodiscard]] auto property_active() noexcept -> Glib::PropertyProxy<bool>;
+    [[nodiscard]] auto property_defeated() const noexcept -> Glib::PropertyProxy_ReadOnly<bool>;
+    [[nodiscard]] auto property_defeated() noexcept -> Glib::PropertyProxy<bool>;
+    [[nodiscard]] auto property_disposition() const noexcept -> Glib::PropertyProxy_ReadOnly<Disposition>;
+    [[nodiscard]] auto property_disposition() noexcept -> Glib::PropertyProxy<Disposition>;
+    [[nodiscard]] auto property_name() const noexcept -> Glib::PropertyProxy_ReadOnly<Glib::ustring const &>;
+    [[nodiscard]] auto property_name() noexcept -> Glib::PropertyProxy<Glib::ustring const &>;
+    [[nodiscard]] auto property_priority() const noexcept -> Glib::PropertyProxy_ReadOnly<float>;
+    [[nodiscard]] auto property_priority() noexcept -> Glib::PropertyProxy<float>;
+
   protected:
     friend Participant_Class;
 
-- 
cgit v1.2.3