added tests

include/omath/rev_eng/internal_rev_object.hpp

@@ -3,7 +3,6 @@
 //
 
 #pragma once
-#include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
@@ -22,20 +21,6 @@
 
 namespace omath::rev_eng
 {
-    template<std::size_t N>
-    struct FixedString
-    {
-        char data[N]{};
-        constexpr FixedString(const char (&str)[N])
-        {
-            std::copy_n(str, N, data);
-        }
-        constexpr operator std::string_view() const
-        {
-            return {data, N - 1};
-        }
-    };
-
     class InternalReverseEngineeredObject
     {
     protected:
@@ -72,47 +57,17 @@ namespace omath::rev_eng
             return reinterpret_cast<MethodType>(const_cast<void*>(ptr))(this, arg_list...);
         }
 
-        template<FixedString module_name, FixedString pattern, class ReturnType>
+        template<auto module_name, auto pattern, class ReturnType>
         ReturnType call_method(auto... arg_list)
         {
-            static const auto address = []() -> const void*
-            {
-                const auto* base = get_module_base(module_name);
-                assert(base && "Failed to find module");
-
-#ifdef _WIN32
-                auto result = PePatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
-#elif defined(__APPLE__)
-                auto result = MachOPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
-#else
-                auto result = ElfPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
-#endif
-                assert(result.has_value() && "Pattern scan failed");
-                return reinterpret_cast<const void*>(*result);
-            }();
-
+            static const auto* address = resolve_pattern(module_name, pattern);
             return call_method<ReturnType>(address, arg_list...);
         }
 
-        template<FixedString module_name, FixedString pattern, class ReturnType>
+        template<auto module_name, auto pattern, class ReturnType>
         ReturnType call_method(auto... arg_list) const
         {
-            static const auto address = []() -> const void*
-            {
-                const auto* base = get_module_base(module_name);
-                assert(base && "Failed to find module");
-
-#ifdef _WIN32
-                auto result = PePatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
-#elif defined(__APPLE__)
-                auto result = MachOPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
-#else
-                auto result = ElfPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
-#endif
-                assert(result.has_value() && "Pattern scan failed");
-                return reinterpret_cast<const void*>(*result);
-            }();
-
+            static const auto* address = resolve_pattern(module_name, pattern);
             return call_method<ReturnType>(address, arg_list...);
         }
 
@@ -130,6 +85,22 @@ namespace omath::rev_eng
         }
 
     private:
+        static const void* resolve_pattern(const std::string_view module_name, const std::string_view pattern)
+        {
+            const auto* base = get_module_base(module_name);
+            assert(base && "Failed to find module");
+
+#ifdef _WIN32
+            auto result = PePatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
+#elif defined(__APPLE__)
+            auto result = MachOPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
+#else
+            auto result = ElfPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
+#endif
+            assert(result.has_value() && "Pattern scan failed");
+            return reinterpret_cast<const void*>(*result);
+        }
+
         static const void* get_module_base(const std::string_view module_name)
         {
 #ifdef _WIN32

tests/general/unit_test_reverse_enineering.cpp

@@ -20,6 +20,11 @@ public:
     int m_health{123};
 };
 
+// Free functions that mimic member function calling convention (this as first arg)
+inline int free_add(void* /*this_ptr*/, int a, int b) { return a + b; }
+inline float free_scale(void* /*this_ptr*/, float val, float factor) { return val * factor; }
+inline int free_get_42(const void* /*this_ptr*/) { return 42; }
+
 class RevPlayer final : omath::rev_eng::InternalReverseEngineeredObject
 {
 public:
@@ -51,6 +56,22 @@ public:
     {
         return call_virtual_method<1, int>();
     }
+
+    // Wrappers exposing call_method for testing
+    int call_add(int a, int b)
+    {
+        return call_method<int>(reinterpret_cast<const void*>(&free_add), a, b);
+    }
+
+    float call_scale(float val, float factor)
+    {
+        return call_method<float>(reinterpret_cast<const void*>(&free_scale), val, factor);
+    }
+
+    int call_get_42() const
+    {
+        return call_method<int>(reinterpret_cast<const void*>(&free_get_42));
+    }
 };
 
 TEST(unit_test_reverse_enineering, read_test)
@@ -64,4 +85,50 @@ TEST(unit_test_reverse_enineering, read_test)
     EXPECT_EQ(player_original.bar(), player_reversed->rev_bar());
     EXPECT_EQ(player_original.foo(), player_reversed->rev_foo());
     EXPECT_EQ(player_original.bar(), player_reversed->rev_bar_const());
+}
+
+TEST(unit_test_reverse_enineering, call_method_with_args)
+{
+    Player player_original;
+    auto* player_reversed = reinterpret_cast<RevPlayer*>(&player_original);
+
+    EXPECT_EQ(free_add(nullptr, 3, 4), player_reversed->call_add(3, 4));
+    EXPECT_EQ(7, player_reversed->call_add(3, 4));
+}
+
+TEST(unit_test_reverse_enineering, call_method_float_args)
+{
+    Player player_original;
+    auto* player_reversed = reinterpret_cast<RevPlayer*>(&player_original);
+
+    EXPECT_FLOAT_EQ(6.0f, player_reversed->call_scale(2.0f, 3.0f));
+    EXPECT_FLOAT_EQ(0.0f, player_reversed->call_scale(0.0f, 100.0f));
+    EXPECT_FLOAT_EQ(-5.0f, player_reversed->call_scale(5.0f, -1.0f));
+}
+
+TEST(unit_test_reverse_enineering, call_method_const)
+{
+    Player player_original;
+    const auto* player_reversed = reinterpret_cast<const RevPlayer*>(&player_original);
+
+    EXPECT_EQ(42, player_reversed->call_get_42());
+}
+
+TEST(unit_test_reverse_enineering, call_method_no_extra_args)
+{
+    Player player_original;
+    const auto* player_reversed = reinterpret_cast<const RevPlayer*>(&player_original);
+
+    // call_get_42 takes no arguments beyond this — verifies zero-arg pack works
+    EXPECT_EQ(42, player_reversed->call_get_42());
+}
+
+TEST(unit_test_reverse_enineering, call_virtual_method_delegates_to_call_method)
+{
+    // call_virtual_method now internally uses call_method — verify both vtable slots
+    Player player_original;
+    auto* player_reversed = reinterpret_cast<RevPlayer*>(&player_original);
+
+    EXPECT_EQ(1, player_reversed->rev_foo());
+    EXPECT_EQ(2, player_reversed->rev_bar());
 }