Merge pull request #172 from orange-cpp/feaute/methods_calling_improvement

Feaute/methods calling improvement

include/omath/rev_eng/internal_rev_object.hpp

@@ -117,6 +117,7 @@ namespace omath::rev_eng
         }
 
     private:
+        [[nodiscard]]
         static const void* resolve_pattern(const std::string_view module_name, const std::string_view pattern)
         {
             const auto* base = get_module_base(module_name);
@@ -133,6 +134,7 @@ namespace omath::rev_eng
             return reinterpret_cast<const void*>(*result);
         }
 
+        [[nodiscard]]
         static const void* get_module_base(const std::string_view module_name)
         {
 #ifdef _WIN32

tests/general/unit_test_reverse_enineering.cpp

@@ -20,10 +20,12 @@ 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; }
+// Extract a raw function pointer from an object's vtable
+inline const void* get_vtable_entry(const void* obj, const std::size_t index)
+{
+    const auto vtable = *static_cast<void* const* const*>(obj);
+    return vtable[index];
+}
 
 class RevPlayer final : omath::rev_eng::InternalReverseEngineeredObject
 {
@@ -57,20 +59,15 @@ public:
         return call_virtual_method<1, int>();
     }
 
-    // Wrappers exposing call_method for testing
-    int call_add(int a, int b)
+    // Wrappers exposing call_method for testing — use vtable entries as known-good function pointers
+    int call_foo_via_ptr(const void* fn_ptr) const
     {
-        return call_method<int>(reinterpret_cast<const void*>(&free_add), a, b);
+        return call_method<int>(fn_ptr);
     }
 
-    float call_scale(float val, float factor)
+    int call_bar_via_ptr(const void* fn_ptr) const
     {
-        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));
+        return call_method<int>(fn_ptr);
     }
 };
 
@@ -87,48 +84,37 @@ TEST(unit_test_reverse_enineering, read_test)
     EXPECT_EQ(player_original.bar(), player_reversed->rev_bar_const());
 }
 
-TEST(unit_test_reverse_enineering, call_method_with_args)
+TEST(unit_test_reverse_enineering, call_method_with_vtable_ptr)
 {
-    Player player_original;
-    auto* player_reversed = reinterpret_cast<RevPlayer*>(&player_original);
+    // Extract raw function pointers from Player's vtable, then call them via call_method
+    Player player;
+    const auto* rev = reinterpret_cast<const RevPlayer*>(&player);
 
-    EXPECT_EQ(free_add(nullptr, 3, 4), player_reversed->call_add(3, 4));
-    EXPECT_EQ(7, player_reversed->call_add(3, 4));
+    const auto* foo_ptr = get_vtable_entry(&player, 0);
+    const auto* bar_ptr = get_vtable_entry(&player, 1);
+
+    EXPECT_EQ(player.foo(), rev->call_foo_via_ptr(foo_ptr));
+    EXPECT_EQ(player.bar(), rev->call_bar_via_ptr(bar_ptr));
+    EXPECT_EQ(1, rev->call_foo_via_ptr(foo_ptr));
+    EXPECT_EQ(2, rev->call_bar_via_ptr(bar_ptr));
 }
 
-TEST(unit_test_reverse_enineering, call_method_float_args)
+TEST(unit_test_reverse_enineering, call_method_same_result_as_virtual)
 {
-    Player player_original;
-    auto* player_reversed = reinterpret_cast<RevPlayer*>(&player_original);
+    // call_virtual_method delegates to call_method — both paths must agree
+    Player player;
+    const auto* rev = reinterpret_cast<const RevPlayer*>(&player);
 
-    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());
+    EXPECT_EQ(rev->rev_foo(), rev->call_foo_via_ptr(get_vtable_entry(&player, 0)));
+    EXPECT_EQ(rev->rev_bar(), rev->call_bar_via_ptr(get_vtable_entry(&player, 1)));
 }
 
 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);
+    Player player;
+    auto* rev = reinterpret_cast<RevPlayer*>(&player);
 
-    EXPECT_EQ(1, player_reversed->rev_foo());
-    EXPECT_EQ(2, player_reversed->rev_bar());
+    EXPECT_EQ(1, rev->rev_foo());
+    EXPECT_EQ(2, rev->rev_bar());
+    EXPECT_EQ(2, rev->rev_bar_const());
 }