fixed unit testing code

Signed-off-by: chcurran <82187351+carlitosan@users.noreply.github.com>
2021-11-23 23:57:03 -08:00
parent 27cc659ab9
commit 8357fa34e9
10 changed files with 155 additions and 23 deletions
@@ -5073,13 +5073,26 @@ LUA_API const Node* lua_getDummyNode()
                    // Check all constructors if they have use ScriptDataContext and if so choose this one 
                    if (!customConstructorMethod)
                    {
+                        int overrideIndex = -1;
+                        AZ::AttributeReader(nullptr, FindAttribute
+                            ( Script::Attributes::DefaultConstructorOverrideIndex, behaviorClass->m_attributes)).Read<int>(overrideIndex);
+
+                        int methodIndex = 0;
                        for (BehaviorMethod* method : behaviorClass->m_constructors)
                        {
+                            if (methodIndex == overrideIndex)
+                            {
+                                customConstructorMethod = method;
+                                break;
+                            }
+
                            if (method->GetNumArguments() && method->GetArgument(method->GetNumArguments() - 1)->m_typeId == AZ::AzTypeInfo<ScriptDataContext>::Uuid())
                            {
                                customConstructorMethod = method;
                                break;
                            }
+
+                            ++methodIndex;
                        }
                    }

@@ -21,6 +21,7 @@ namespace AZ
            static constexpr AZ::Crc32 ClassNameOverride = AZ_CRC_CE("ScriptClassNameOverride"); ///< Provide a custom name for script reflection, that doesn't match the behavior Context name
            static constexpr AZ::Crc32 MethodOverride = AZ_CRC_CE("ScriptFunctionOverride"); ///< Use a custom function in the attribute instead of the function  
            static constexpr AZ::Crc32 ConstructorOverride = AZ_CRC_CE("ConstructorOverride"); ///< You can provide a custom constructor to be called when created from Lua script
+            static constexpr AZ::Crc32 DefaultConstructorOverrideIndex = AZ_CRC_CE("DefaultConstructorOverrideIndex"); ///< Use a different class constructor as the default constructor in Lua
            static constexpr AZ::Crc32 EventHandlerCreationFunction = AZ_CRC_CE("EventHandlerCreationFunction"); ///< helps create a handler for any script target so that script functions can be used for AZ::Event signals
            static constexpr AZ::Crc32 GenericConstructorOverride = AZ_CRC_CE("GenericConstructorOverride"); ///< You can provide a custom constructor to be called when creating a script
            static constexpr AZ::Crc32 ReaderWriterOverride = AZ_CRC_CE("ReaderWriterOverride"); ///< paired with \ref ScriptContext::CustomReaderWriter allows you to customize read/write to Lua VM
@@ -30,6 +30,8 @@
 #include <ScriptCanvas/Utils/BehaviorContextUtils.h>
 #include <Source/Components/SceneComponent.h>
 #include <ScriptCanvas/Core/Core.h>
+#include <AzCore/Asset/AssetManagerBus.h>
+

 namespace ScriptCanvasBuilder
 {
@@ -93,19 +95,6 @@ namespace ScriptCanvasBuilder
        request.printModelToConsole = ScriptCanvas::Grammar::g_printAbstractCodeModel;
        request.path = fullPath;

-        bool pathFound = false;
-        AZStd::string relativePath;
-        AzToolsFramework::AssetSystemRequestBus::BroadcastResult
-            ( pathFound
-            , &AzToolsFramework::AssetSystem::AssetSystemRequest::GetRelativeProductPathFromFullSourceOrProductPath
-            , fullPath.c_str(), relativePath);
-
-        if (!pathFound)
-        {
-            AZ::Failure(AZStd::string::format("Failed to get engine relative path from %s", fullPath.c_str()));
-        }
-
-        request.namespacePath = relativePath;
        const ScriptCanvas::Translation::Result translationResult = TranslateToLua(request);

        auto isSuccessOutcome = translationResult.IsSuccess(ScriptCanvas::Translation::TargetFlags::Lua);
@@ -114,12 +114,17 @@ namespace ScriptCanvasEditor
    {
        if (auto loadFileOutcome = LoadFromFile(graphPath); loadFileOutcome.IsSuccess())
        {
-            AZ::Outcome< AZ::Data::Asset<ScriptCanvas::RuntimeAsset>, AZStd::string> assetOutcome = AZ::Failure(AZStd::string("asset creation failed"));
-            ScriptCanvasEditor::EditorAssetConversionBus::BroadcastResult(assetOutcome, &ScriptCanvasEditor::EditorAssetConversionBusTraits::CreateRuntimeAsset, loadFileOutcome.GetValue());
+            auto& source = loadFileOutcome.GetValue();
+            auto testableSource = SourceHandle(source, AZ::Uuid::CreateRandom(), source.Path().c_str());
+
+            AZ::Outcome<AZ::Data::Asset<ScriptCanvas::RuntimeAsset>, AZStd::string> assetOutcome(AZ::Failure(AZStd::string("asset create failed")));
+            ScriptCanvasEditor::EditorAssetConversionBus::BroadcastResult(assetOutcome
+                , &ScriptCanvasEditor::EditorAssetConversionBusTraits::CreateRuntimeAsset, testableSource);
+
            if (assetOutcome.IsSuccess())
            {
                LoadTestGraphResult result;
-                result.m_editorAsset = loadFileOutcome.TakeValue();
+                result.m_editorAsset = AZStd::move(testableSource);
                result.m_runtimeAsset = assetOutcome.GetValue();
                result.m_entity = AZStd::make_unique<AZ::Entity>("Loaded Graph");
                return result;
@@ -216,6 +221,8 @@ namespace ScriptCanvasEditor
                    {
                        RuntimeDataOverrides runtimeDataOverrides;
                        runtimeDataOverrides.m_runtimeAsset = loadResult.m_runtimeAsset;
+                        runtimeDataOverrides.m_runtimeAsset.SetHint("original");
+                        runtimeDataOverrides.m_runtimeAsset.Get()->m_runtimeData.m_script.SetHint("original");

 #if defined(LINUX) //////////////////////////////////////////////////////////////////////////
                        // Temporarily disable testing on the Linux build until the file name casing discrepancy
@@ -261,6 +268,10 @@ namespace ScriptCanvasEditor

                                RuntimeDataOverrides dependencyRuntimeDataOverrides;
                                dependencyRuntimeDataOverrides.m_runtimeAsset = dependency.runtimeAsset;
+                                AZStd::string dependencyHint = AZStd::string::format("dependency_%d", index);
+                                dependencyRuntimeDataOverrides.m_runtimeAsset.SetHint(dependencyHint);
+                                dependencyRuntimeDataOverrides.m_runtimeAsset.Get()->m_runtimeData.m_script.SetHint(dependencyHint);
+
                                runtimeDataOverrides.m_dependencies.push_back(dependencyRuntimeDataOverrides);

                                RuntimeData& dependencyData = dependencyDataBuffer[index];
@@ -161,15 +161,15 @@ namespace ScriptCanvasEditor

    struct ScopedOutputSuppression
    {
-        ScopedOutputSuppression(bool suppressState = true)
+        ScopedOutputSuppression([[maybe_unused]] bool suppressState = true)
        {
-            AZ::Debug::TraceMessageBus::BroadcastResult(m_oldSuppression, &AZ::Debug::TraceMessageEvents::OnOutput, "", "");
-            TraceSuppressionBus::Broadcast(&TraceSuppressionRequests::SuppressAllOutput, suppressState);
+            // AZ::Debug::TraceMessageBus::BroadcastResult(m_oldSuppression, &AZ::Debug::TraceMessageEvents::OnOutput, "", "");
+            // TraceSuppressionBus::Broadcast(&TraceSuppressionRequests::SuppressAllOutput, suppressState);
        }

        ~ScopedOutputSuppression()
        {
-            TraceSuppressionBus::Broadcast(&TraceSuppressionRequests::SuppressAllOutput, m_oldSuppression);
+            // TraceSuppressionBus::Broadcast(&TraceSuppressionRequests::SuppressAllOutput, m_oldSuppression);
        }
    private:
        bool m_oldSuppression = false;
@@ -120,7 +120,10 @@ namespace ScriptCanvasEditor
        PopulateEditorCreatableTypes();

        AzToolsFramework::RegisterGenericComboBoxHandler<ScriptCanvas::VariableId>();
-        AzToolsFramework::PropertyTypeRegistrationMessages::Bus::Broadcast(&AzToolsFramework::PropertyTypeRegistrationMessages::RegisterPropertyType, aznew SourceHandlePropertyHandler());
+        if (AzToolsFramework::PropertyTypeRegistrationMessages::Bus::FindFirstHandler())
+        {
+            AzToolsFramework::PropertyTypeRegistrationMessages::Bus::Broadcast(&AzToolsFramework::PropertyTypeRegistrationMessages::RegisterPropertyType, aznew SourceHandlePropertyHandler());
+        }

        SystemRequestBus::Handler::BusConnect();
        ScriptCanvasExecutionBus::Handler::BusConnect();
@@ -22,12 +22,16 @@ namespace ScriptCanvas

    Nodeable::Nodeable()
        : m_noOpFunctor(&NodeableOutCpp::NoOp)
-    {}
+    {
+        AZ_TracePrintf("SCDB", "How many times does this get called? Because it should....NOT GET CALLED!");
+    }

    Nodeable::Nodeable(ExecutionStateWeakPtr executionState)
        : m_noOpFunctor(&NodeableOutCpp::NoOp)
        , m_executionState(executionState)
-    {}   
+    {
+        AZ_TracePrintf("SCDB", "How many times does this get called 2?");
+    }   

 #if !defined(RELEASE) 
    void Nodeable::CallOut(size_t index, AZ::BehaviorValueParameter* resultBVP, AZ::BehaviorValueParameter* argsBVPs, int numArguments) const
@@ -80,6 +84,7 @@ namespace ScriptCanvas
                ->Attribute(AZ::ScriptCanvasAttributes::VariableCreationForbidden, AZ::AttributeIsValid::IfPresent)
                ->Attribute(AZ::Script::Attributes::UseClassIndexAllowNil, AZ::AttributeIsValid::IfPresent)
                ->Constructor<ExecutionStateWeakPtr>()
+                    ->Attribute(AZ::Script::Attributes::DefaultConstructorOverrideIndex, 0)
                ->Method("Deactivate", &Nodeable::Deactivate)
                ->Method("InitializeExecutionState", &Nodeable::InitializeExecutionState)
                ->Method("InitializeExecutionOuts", &Nodeable::InitializeExecutionOuts)
@@ -68,6 +68,8 @@ namespace ExecutionInterpretedAPICpp
    {
        if (lua_isstring(lua, -1))
        {
+            AZStd::string errorResult = lua_tostring(lua, -1);
+            AZ_TracePrintf("ScriptCanvas", errorResult.c_str());
            AZ::ScriptContext::FromNativeContext(lua)->Error(AZ::ScriptContext::ErrorType::Error, true, "%s", lua_tostring(lua, -1));
        }
        else
@@ -402,6 +404,50 @@ namespace ScriptCanvas
            AZ_Assert(lua_isuserdata(lua, -2) && !lua_islightuserdata(lua, -2), "Error in compiled lua file, 1st argument to OverrideNodeableMetatable is not userdata (Nodeable)");
            AZ_Assert(lua_istable(lua, -1), "Error in compiled lua file, 2nd argument to OverrideNodeableMetatable is not a Lua table");

+            /* table is in the stack at index 't' */
+            if (lua_istable(lua, -1))
+            {
+                lua_getfield(lua, -1, "__index");
+
+                if (lua_istable(lua, -1))
+                {
+                    int t = -2;
+                    AZStd::string tableGuts;
+                    lua_pushnil(lua);
+                    /* first key */
+                    while (lua_next(lua, t) != 0)
+                    {
+                        /* uses 'key' (at index -2) and 'value' (at index -1) */
+                        if (lua_type(lua, -2) == LUA_TSTRING)
+                        {
+                            size_t len;
+                            tableGuts += AZStd::string::format("%s - %s\n",
+                                lua_tolstring(lua, -2, &len),
+                                lua_typename(lua, lua_type(lua, -1)));
+                        }
+                        else if (lua_type(lua, -2) == LUA_TNUMBER)
+                        {
+                            tableGuts += AZStd::string::format("%f - %s\n",
+                                lua_tonumber(lua, -2),
+                                lua_typename(lua, lua_type(lua, -1)));
+                        }
+                        else
+                        {
+                            tableGuts += AZStd::string::format("%s - %s\n",
+                                lua_typename(lua, lua_type(lua, -2)),
+                                lua_typename(lua, lua_type(lua, -1)));
+                        }
+
+                        /* removes 'value'; keeps 'key' for next iteration */
+                        lua_pop(lua, 1);
+                    }
+
+                    AZ_TracePrintf("SCDB", tableGuts.c_str());
+                }
+
+                lua_pop(lua, 1);
+            }                        
+
            [[maybe_unused]] auto userData = reinterpret_cast<AZ::LuaUserData*>(lua_touserdata(lua, -2));
            AZ_Assert(userData && userData->magicData == AZ_CRC_CE("AZLuaUserData"), "this isn't user data");
            // Lua: LuaUserData::nodeable, class_mt
@@ -143,6 +143,8 @@ namespace ScriptCanvas
        AZ_Assert(m_luaRegistryIndex == LUA_NOREF, "ExecutionStateInterpreted already in the Lua registry and risks double deletion");
        // Lua: instance
        m_luaRegistryIndex = luaL_ref(m_luaState, LUA_REGISTRYINDEX);
+        AZ_Assert(m_luaRegistryIndex != LUA_REFNIL, "ExecutionStateInterpreted was nil when trying to gain a reference");
+        AZ_Assert(m_luaRegistryIndex != LUA_NOREF, "ExecutionStateInterpreted failed to gain a reference");
    }

    void ExecutionStateInterpreted::Reflect(AZ::ReflectContext* reflectContext)
@@ -111,10 +111,72 @@ namespace ScriptCanvas
        auto& lua = m_luaState;
        // Lua:
        lua_rawgeti(lua, LUA_REGISTRYINDEX, registryIndex);
+        if (!lua_isuserdata(lua, -1))
+        {
+            AZ_TracePrintf("SCDB", "No light userdata");
+        }
+        // Lua: instance
+
+        lua_getmetatable(lua, -1);
+        if (!lua_istable(lua, -1))
+        {
+            AZ_TracePrintf("SCDB", "no metatable");
+        }
+
+        
+        /* table is in the stack at index 't' */
+        if (lua_istable(lua, -1))
+        {
+            int t = -2;
+            AZStd::string tableGuts;
+            lua_pushnil(lua);
+            /* first key */
+            while (lua_next(lua, t) != 0)
+            {
+                /* uses 'key' (at index -2) and 'value' (at index -1) */
+                if (lua_type(lua, -2) == LUA_TSTRING)
+                {
+                    size_t len;
+                    tableGuts += AZStd::string::format("%s - %s\n",
+                        lua_tolstring(lua, -2, &len),
+                        lua_typename(lua, lua_type(lua, -1)));
+                }
+                else if (lua_type(lua, -2) == LUA_TNUMBER)
+                {
+                    tableGuts += AZStd::string::format("%f - %s\n",
+                        lua_tonumber(lua, -2),
+                        lua_typename(lua, lua_type(lua, -1)));
+                }
+                else
+                {
+                    tableGuts += AZStd::string::format("%s - %s\n",
+                        lua_typename(lua, lua_type(lua, -2)),
+                        lua_typename(lua, lua_type(lua, -1)));
+                }
+
+                /* removes 'value'; keeps 'key' for next iteration */
+                lua_pop(lua, 1);
+            }
+
+            AZ_TracePrintf("SCDB", tableGuts.c_str());
+        }
+
+        // Lua: instance, instance_mt
+        lua_pop (lua, 1);
+
+
        // Lua: instance
        lua_getfield(lua, -1, Grammar::k_OnGraphStartFunctionName);
        // Lua: instance, graph_VM.k_OnGraphStartFunctionName
+        if (!lua_isfunction(lua, -1))
+        {
+            AZ_TracePrintf("SCDB", "No function");
+        }
        lua_pushvalue(lua, -2);
+        if (!lua_isuserdata(lua, -1))
+        {
+            AZ_TracePrintf("SCDB", "No light userdata");
+        }
        // Lua: instance, graph_VM.k_OnGraphStartFunctionName, instance
        const int result = Execution::InterpretedSafeCall(lua, 1, 0);
        // Lua: instance ?