Merge pull request #20 from Neko-Box-Coder/v2

v2 overhaul

Author: Neko-Box-Coder

Example.cpp

@@ -1,10 +1,24 @@
 #include "CppOverride.hpp"
 
+#include <iostream>
+#include <vector>
+#include <string>
+
 CO_DECLARE_INSTANCE(OverrideInstanceName);
 
+namespace MyNameSpace
+{
+    int OverrideMyScopedFunc(int value1, float& value2)
+    {
+        CO_INSERT_IMPL(OverrideInstanceName, int, (value1, value2));
+        //The rest of the implementations...
+        return 0;
+    }
+}
+
 int OverrideMyReturnValue(int value1, float value2)
 {
-    CO_OVERRIDE_IMPL(OverrideInstanceName, int, (value1, value2));
+    CO_INSERT_IMPL(OverrideInstanceName, int, (value1, value2));
     //The rest of the implementations...
     return 0;
 }
@@ -13,19 +27,19 @@ int SomeRef = 0;
 
 int& OverrideMyReturnRef(int value1, float value2)
 {
-    CO_OVERRIDE_IMPL(OverrideInstanceName, int&, (value1, value2));
+    CO_INSERT_IMPL(OverrideInstanceName, int&, (value1, value2));
     //The rest of the implementations...
     return SomeRef;
 }
 
 void OverrideMyArgs(float& value1, int* value2)
 {
-    CO_OVERRIDE_IMPL(OverrideInstanceName, void, (value1, value2));
+    CO_INSERT_IMPL(OverrideInstanceName, void, (value1, value2));
 }
 
 bool OverrideMyArgsWithStstus(float& value1, int* value2)
 {
-    CO_OVERRIDE_IMPL(OverrideInstanceName, bool, (value1, value2));
+    CO_INSERT_IMPL(OverrideInstanceName, bool, (value1, value2));
     return false;
 }
 
@@ -46,19 +60,17 @@ do\
 
 void ResetAll()
 {
-    CO_CLEAR_ALL_OVERRIDE_SETUP(OverrideInstanceName);
+    CO_CLEAR_ALL_INSTRUCTS(OverrideInstanceName);
 }
 
 void OverrideReturnsExample()
 {
-    CO_SETUP_OVERRIDE   (OverrideInstanceName, OverrideMyReturnValue)
-                        .Returns<int>(1);
+    CO_INSTRUCT_REF(OverrideInstanceName, CO_GLOBAL, OverrideMyReturnValue).Returns<int>(1);
 
     CO_QUICK_ASSERT(OverrideMyReturnValue(0, 0.f) == 1);
 
     int returnRef = 1;
-    CO_SETUP_OVERRIDE   (OverrideInstanceName, OverrideMyReturnRef)
-                        .Returns<int&>(returnRef);
+    CO_INSTRUCT_REF(OverrideInstanceName, CO_GLOBAL, OverrideMyReturnRef).Returns<int&>(returnRef);
 
     CO_QUICK_ASSERT(&returnRef == &OverrideMyReturnRef(0, 0.f));
 
@@ -67,8 +79,7 @@ void OverrideReturnsExample()
 
 void OverrideArgumentsExample()
 {
-    CO_SETUP_OVERRIDE   (OverrideInstanceName, OverrideMyArgs)
-                        .SetArgs<float&, int*>(1.f, 3);
+    CO_INSTRUCT_REF(OverrideInstanceName, CO_GLOBAL, OverrideMyArgs).SetArgs<float&, int*>(1.f, 3);
 
     float arg1 = 0.f;
     int arg2 = 0;
@@ -79,16 +90,38 @@ void OverrideArgumentsExample()
     ResetAll();
 }
 
+void OverrideScopedFunctionExample()
+{
+    CO_INSTRUCT_REF(OverrideInstanceName, MyNameSpace, OverrideMyScopedFunc).Returns<int>(1);
+
+    float floatArg = 0.f;
+    CO_QUICK_ASSERT(MyNameSpace::OverrideMyScopedFunc(1, floatArg) == 1);
+    
+    CO_REMOVE_INSTRUCT_REF(OverrideInstanceName, MyNameSpace, OverrideMyScopedFunc);
+    
+    CO_INSTRUCT_REF (OverrideInstanceName, MyNameSpace, OverrideMyScopedFunc)
+                    .SetArgs<CO_ANY_TYPE, float&>(CO_DONT_SET, 3);
+
+    MyNameSpace::OverrideMyScopedFunc(1, floatArg);
+    CO_QUICK_ASSERT(floatArg == 3);
+}
+
 void OverrideReturnsWithActionLambda()
 {
-    CO_SETUP_OVERRIDE   (OverrideInstanceName, OverrideMyReturnValue)
-                        .ReturnsByAction<int>
-                        ( 
-                            [](void*, const std::vector<void*>&, void* out)
-                            { 
-                                *static_cast<int*>(out) = 5;
-                            }
-                        );
+    CO_INSTRUCT_REF (OverrideInstanceName, CO_GLOBAL, OverrideMyReturnValue)
+                    .ReturnsByAction<int>
+                    ( 
+                        []( void*, 
+                            const std::vector<CppOverride::TypedDataInfo>& args, 
+                            CppOverride::TypedDataInfo& out)
+                        { 
+                            (void)args;
+                            //Can access args with type safety if needed
+                            //e.g., if(args.at(0).IsType<int>()) { ... }
+                            if(out.IsType<int>())
+                                *out.GetTypedDataPtr<int>() = 5;
+                        }
+                    );
 
     CO_QUICK_ASSERT(OverrideMyReturnValue(0, 0.f) == 5);
 
@@ -97,13 +130,15 @@ void OverrideReturnsWithActionLambda()
 
 void OverrideArgumentsWithActionLambda()
 {
-    CO_SETUP_OVERRIDE(OverrideInstanceName, OverrideMyArgs)
+    CO_INSTRUCT_REF (OverrideInstanceName, CO_GLOBAL, OverrideMyArgs)
                     .SetArgsByAction<float&, int*>
                     (
-                        [](void*, std::vector<void*>& args)
+                        [](void*, std::vector<CppOverride::TypedDataInfo>& args)
                         {
-                            *static_cast<float*>(args.at(0)) = 1.f;
-                            **static_cast<int**>(args.at(1)) = 2;
+                            if(args.at(0).IsType<float>())
+                                *args.at(0).GetTypedDataPtr<float>() = 1.f;
+                            if(args.at(1).IsType<int*>())
+                                **args.at(1).GetTypedDataPtr<int*>() = 2;
                         }
                     );
 
@@ -118,9 +153,9 @@ void OverrideArgumentsWithActionLambda()
 
 void WhenCalledWithExample()
 {
-    CO_SETUP_OVERRIDE   (OverrideInstanceName, OverrideMyReturnValue)
-                        .WhenCalledWith(2, 3.f)
-                        .Returns<int>(1);
+    CO_INSTRUCT_REF (OverrideInstanceName, CO_GLOBAL, OverrideMyReturnValue)
+                    .WhenCalledWith(2, 3.f)
+                    .Returns<int>(1);
 
     int ret1 = OverrideMyReturnValue(2, 3.f);   //Returns 1
     int ret2 = OverrideMyReturnValue(1, 2.f);   //Won't return 1
@@ -133,9 +168,9 @@ void WhenCalledWithExample()
 
 void TimesExample()
 {
-    CO_SETUP_OVERRIDE   (OverrideInstanceName, OverrideMyArgs)
-                        .SetArgs<float&, int*>(1.f, 2)
-                        .Times(1);
+    CO_INSTRUCT_REF (OverrideInstanceName, CO_GLOBAL, OverrideMyArgs)
+                    .SetArgs<float&, int*>(1.f, 2)
+                    .Times(1);
 
     float testFloat = 2.f;
     int testInt = 3;
@@ -156,18 +191,18 @@ void TimesExample()
 
 void IfConditionLambdaExample()
 {
-    CO_SETUP_OVERRIDE   (OverrideInstanceName, OverrideMyReturnValue)
-                        .If
-                        (
-                            [](void*, const std::vector<void*>& args)
-                            {
-                                if(*static_cast<int*>(args.at(0)) == 1)
-                                    return true;
-                                else
-                                    return false;
-                            }
-                        )
-                        .Returns<int>(1);
+    CO_INSTRUCT_REF (OverrideInstanceName, CO_GLOBAL, OverrideMyReturnValue)
+                    .If
+                    (
+                        [](void*, const std::vector<CppOverride::TypedDataInfo>& args)
+                        {
+                            if(args.at(0).IsType<int>() && *args.at(0).GetTypedDataPtr<int>() == 1)
+                                return true;
+                            else
+                                return false;
+                        }
+                    )
+                    .Returns<int>(1);
 
     int ret1 = OverrideMyReturnValue(1, 2.f);   //Returns 1
     int ret2 = OverrideMyReturnValue(2, 3.f);   //Won't return 1
@@ -181,16 +216,22 @@ void IfConditionLambdaExample()
 void WhenCalledExpectedlyDoLambdaExample()
 {
     bool called = false;
-    CO_SETUP_OVERRIDE   (OverrideInstanceName, OverrideMyReturnValue)
-                        .WhenCalledWith(2, 3.f)
-                        .Returns<int>(1)
-                        .WhenCalledExpectedly_Do
-                        (
-                            [&called](...)
-                            {
-                                called = true;
-                            }
-                        );
+    CO_INSTRUCT_REF (OverrideInstanceName, CO_GLOBAL, OverrideMyReturnValue)
+                    .WhenCalledWith(2, 3.f)
+                    .Returns<int>(1)
+                    .WhenCalledExpectedly_Do
+                    (
+                        [&called](  void* instance, 
+                                    const std::vector<CppOverride::TypedDataInfo>& args)
+                        {
+                            (void)instance;
+                            (void)args;
+                            //Can access args with type safety if needed
+                            //e.g., if(args.at(0).IsType<int>()) { ... }
+                            
+                            called = true;
+                        }
+                    );
 
     int ret1 = OverrideMyReturnValue(2, 3.f);   //Returns 1 and sets called to true
     CO_QUICK_ASSERT(ret1 == 1);
@@ -202,16 +243,22 @@ void WhenCalledExpectedlyDoLambdaExample()
 void OtherwiseDoLambdaExample()
 {
     bool called = false;
-    CO_SETUP_OVERRIDE   (OverrideInstanceName, OverrideMyReturnValue)
-                        .WhenCalledWith(2, 3.f)
-                        .Returns<int>(1)
-                        .Otherwise_Do
-                        (
-                            [&called](...)
-                            {
-                                called = true;
-                            }
-                        );
+    CO_INSTRUCT_REF (OverrideInstanceName, CO_GLOBAL, OverrideMyReturnValue)
+                    .WhenCalledWith(2, 3.f)
+                    .Returns<int>(1)
+                    .Otherwise_Do
+                    (
+                        [&called](  void* instance, 
+                                    const std::vector<CppOverride::TypedDataInfo>& args)
+                        {
+                            (void)instance;
+                            (void)args;
+                            //Can access args with type safety if needed
+                            //e.g., if(args.at(0).IsType<int>()) { ... }
+                            
+                            called = true;
+                        }
+                    );
 
     int ret1 = OverrideMyReturnValue(1, 2.f);   //Won't return 1
     CO_QUICK_ASSERT(ret1 != 1);
@@ -222,11 +269,11 @@ void OtherwiseDoLambdaExample()
 
 void AssignStatusExample()
 {
-    std::shared_ptr<CppOverride::OverrideResult> result = CppOverride::CreateOverrideResult();
-    CO_SETUP_OVERRIDE (OverrideInstanceName, OverrideMyReturnValue)
-                        .WhenCalledWith(2, 3.f)
-                        .Returns<int>(1)
-                        .AssignResult(result);
+    CppOverride::ResultPtr result;
+    CO_INSTRUCT_REF (OverrideInstanceName, CO_GLOBAL, OverrideMyReturnValue)
+                    .WhenCalledWith(2, 3.f)
+                    .Returns<int>(1)
+                    .AssignsResult(result);
 
     int ret1 = OverrideMyReturnValue(1, 2.f);
 
@@ -238,12 +285,51 @@ void AssignStatusExample()
     ResetAll();
 }
 
+void ExpectedExample()
+{
+    CO_INSTRUCT_REF (OverrideInstanceName, CO_GLOBAL, OverrideMyReturnValue)
+                    .WhenCalledWith(2, 3.f)
+                    .Times(1)
+                    .Returns<int>(1)
+                    .Expected();
+    
+    CO_INSTRUCT_REF (OverrideInstanceName, CO_GLOBAL, OverrideMyReturnValue)
+                    .WhenCalledWith(3, 4.f)
+                    .Returns<int>(1)
+                    .ExpectedNotSatisfy();
+    
+    std::vector<CppOverride::FunctionName> failedFunctions;
+    
+    //Not triggering any instructed overrides when we expected to do so, 
+    //therefore failed expectations.
+    int ret1 = OverrideMyReturnValue(1, 2.f);
+    failedFunctions = CO_GET_FAILED_EXPECTS(OverrideInstanceName);
+    CO_QUICK_ASSERT(ret1 != 1);
+    CO_QUICK_ASSERT(failedFunctions.size() == 1);
+    
+    //Triggered the first instructed override, filled all expectations.
+    ret1 = OverrideMyReturnValue(2, 3.f);
+    failedFunctions = CO_GET_FAILED_EXPECTS(OverrideInstanceName);
+    CO_QUICK_ASSERT(ret1 == 1);
+    CO_QUICK_ASSERT(failedFunctions.empty());
+    
+    //Triggered the second instructed override when we expect to not be triggered, 
+    //therefore failing expectation
+    OverrideMyReturnValue(3, 4.f);
+    failedFunctions = CO_GET_FAILED_EXPECTS(OverrideInstanceName);
+    CO_QUICK_ASSERT(failedFunctions.size() == 1);
+
+    ResetAll();
+}
+
 int main(int, char**)
 {
     OverrideReturnsExample();
 
     OverrideArgumentsExample();
 
+    OverrideScopedFunctionExample();
+    
     OverrideReturnsWithActionLambda();
 
     OverrideArgumentsWithActionLambda();
@@ -258,6 +344,8 @@ int main(int, char**)
 
     AssignStatusExample();
 
+    ExpectedExample();
+    
     std::cout << "All examples are running correctly" << std::endl;
 
     return 0;

External/MacroPowerToys

@@ -1,14 +1,15 @@
 #ifndef CO_ARGS_DATA_ACTION_INFO_HPP
 #define CO_ARGS_DATA_ACTION_INFO_HPP
 
+#include "./TypedDataInfo.hpp"
 #include <functional>
 #include <vector>
 
 namespace CppOverride
 {
     struct ArgsDataActionInfo
     {
-        std::function<void(void* instance, std::vector<void*>& args)> DataAction;
+        std::function<void(void* instance, std::vector<TypedDataInfo>& args)> DataAction;
         std::vector<std::size_t> DataTypes;
         std::vector<bool> DataTypesSet;
         bool DataActionSet = false;

External/ssTest

@@ -2,6 +2,7 @@
 #define CO_CONDITION_INFO_HPP
 
 #include "./DataInfo.hpp"
+#include "./TypedDataInfo.hpp"
 
 #include <functional>
 #include <vector>
@@ -10,7 +11,7 @@ namespace CppOverride
 {
     struct ConditionInfo
     {
-        std::function<bool(void* instance, const std::vector<void*>& args)> LambdaCondition;
+        std::function<bool(void* instance, const std::vector<TypedDataInfo>& args)> LambdaCondition;
         std::vector<DataInfo> ArgsCondition = {};
         int Times = -1;
         int CalledTimes = 0;