birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
a10351f38ddf50af2b01ed071c04cda52d6069ed
o3de/Gems/ScriptCanvasTesting/Code/Tests/ScriptCanvas_Core.cpp
T
alexpete a10351f38d Initial commit
2021-03-08 14:30:57 -08:00

2039 lines
78 KiB
C++
Raw Blame History

/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright EntityRef license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <Source/Framework/ScriptCanvasTestFixture.h>
#include <Source/Framework/ScriptCanvasTestUtilities.h>
#include <Source/Framework/ScriptCanvasTestNodes.h>
#include <AzCore/Serialization/IdUtils.h>
#include <AzCore/std/smart_ptr/make_shared.h>
#include <ScriptCanvas/Asset/RuntimeAsset.h>
#include <ScriptCanvas/Asset/RuntimeAssetHandler.h>
#include <ScriptCanvas/Execution/RuntimeComponent.h>
#include <ScriptCanvas/Variable/GraphVariableManagerComponent.h>
using namespace ScriptCanvasTests;
using namespace TestNodes;
TEST_F(ScriptCanvasTestFixture, CoreNodeFunction_OwningGraphCheck)
{
using namespace ScriptCanvas;
Graph* graph = CreateGraph();
ConfigurableUnitTestNode* groupedNode = CreateConfigurableNode();
EXPECT_EQ(graph, groupedNode->GetGraph());
}
TEST_F(ScriptCanvasTestFixture, AddRemoveSlot)
{
RegisterComponentDescriptor<AddNodeWithRemoveSlot>();
using namespace ScriptCanvas;
using namespace Nodes;
AZStd::unique_ptr<AZ::Entity> graphEntity = AZStd::make_unique<AZ::Entity>("RemoveSlotGraph");
graphEntity->Init();
Graph* graph{};
SystemRequestBus::BroadcastResult(graph, &SystemRequests::CreateGraphOnEntity, graphEntity.get());
ScriptCanvasId graphUniqueId = graph->GetScriptCanvasId();
AZ::EntityId outID;
auto startNode = CreateTestNode<Nodes::Core::Start>(graphUniqueId, outID);
auto numberAddNode = CreateTestNode<AddNodeWithRemoveSlot>(graphUniqueId, outID);
auto number1Node = CreateDataNode<Data::NumberType>(graphUniqueId, 1.0, outID);
auto number2Node = CreateDataNode<Data::NumberType>(graphUniqueId, 2.0, outID);
auto number3Node = CreateDataNode<Data::NumberType>(graphUniqueId, 4.0, outID);
auto numberResultNode = CreateDataNode<Data::NumberType>(graphUniqueId, 0.0, outID);
// data
EXPECT_TRUE(Connect(*graph, number1Node->GetEntityId(), "Get", numberAddNode->GetEntityId(), "A"));
EXPECT_TRUE(Connect(*graph, number2Node->GetEntityId(), "Get", numberAddNode->GetEntityId(), "B"));
EXPECT_TRUE(Connect(*graph, number3Node->GetEntityId(), "Get", numberAddNode->GetEntityId(), "C"));
EXPECT_TRUE(Connect(*graph, numberAddNode->GetEntityId(), "Result", numberResultNode->GetEntityId(), "Set"));
// logic
EXPECT_TRUE(Connect(*graph, startNode->GetEntityId(), "Out", numberAddNode->GetEntityId(), "In"));
// execute pre remove
graphEntity->Activate();
ReportErrors(graph);
graphEntity->Deactivate();
if (auto result = GetInput_UNIT_TEST<Data::NumberType>(numberResultNode, "Set"))
{
SC_EXPECT_DOUBLE_EQ(7.0, *result);
}
else
{
ADD_FAILURE();
}
// Remove the second number slot from the AddNodeWithRemoveSlot node(the one that contains value = 2.0)
numberAddNode->RemoveSlot(numberAddNode->GetSlotId("B"));
EXPECT_FALSE(numberAddNode->GetSlotId("B").IsValid());
// execute post-remove
graphEntity->Activate();
ReportErrors(graph);
graphEntity->Deactivate();
if (auto result = GetInput_UNIT_TEST<Data::NumberType>(numberResultNode, "Set"))
{
SC_EXPECT_DOUBLE_EQ(5.0, *result);
}
else
{
ADD_FAILURE();
}
// Add two more slots and set there values to 8.0 and 16.0
EXPECT_TRUE(numberAddNode->AddSlot("D").IsValid());
EXPECT_TRUE(numberAddNode->AddSlot("B").IsValid());
auto number4Node = CreateDataNode<Data::NumberType>(graphUniqueId, 8.0, outID);
auto number5Node = CreateDataNode<Data::NumberType>(graphUniqueId, 16.0, outID);
EXPECT_TRUE(Connect(*graph, number4Node->GetEntityId(), "Get", numberAddNode->GetEntityId(), "D"));
EXPECT_TRUE(Connect(*graph, number5Node->GetEntityId(), "Get", numberAddNode->GetEntityId(), "B"));
// execute post-add of slot "D" and re-add of slot "A"
graphEntity->Activate();
ReportErrors(graph);
graphEntity->Deactivate();
if (auto result = GetInput_UNIT_TEST<Data::NumberType>(numberResultNode, "Set"))
{
SC_EXPECT_DOUBLE_EQ(1.0 + 4.0 + 8.0 + 16.0, *result);
}
else
{
ADD_FAILURE();
}
// Remove the first number slot from the AddNodeWithRemoveSlot node(the one that contains value = 1.0
numberAddNode->RemoveSlot(numberAddNode->GetSlotId("A"));
EXPECT_FALSE(numberAddNode->GetSlotId("A").IsValid());
// execute post-remove of "A" slot
graphEntity->Activate();
ReportErrors(graph);
graphEntity->Deactivate();
if (auto result = GetInput_UNIT_TEST<Data::NumberType>(numberResultNode, "Set"))
{
SC_EXPECT_DOUBLE_EQ(4.0 + 8.0 + 16.0, *result);
}
else
{
ADD_FAILURE();
}
graphEntity.reset();
}
TEST_F(ScriptCanvasTestFixture, AddRemoveSlotNotifications)
{
RegisterComponentDescriptor<AddNodeWithRemoveSlot>();
using namespace ScriptCanvas;
using namespace Nodes;
AZStd::unique_ptr<AZ::Entity> numberAddEntity = AZStd::make_unique<AZ::Entity>("numberAddEntity");
auto numberAddNode = numberAddEntity->CreateComponent<AddNodeWithRemoveSlot>();
numberAddEntity->Init();
ScriptUnitTestNodeNotificationHandler nodeNotifications(numberAddNode->GetEntityId());
SlotId testSlotId = numberAddNode->AddSlot("test");
EXPECT_EQ(1U, nodeNotifications.GetSlotsAdded());
numberAddNode->RemoveSlot(testSlotId);
EXPECT_EQ(1U, nodeNotifications.GetSlotsRemoved());
testSlotId = numberAddNode->AddSlot("duplicate");
EXPECT_EQ(2U, nodeNotifications.GetSlotsAdded());
// This should not signal the NodeNotification::OnSlotAdded event as the slot already exist on the node
SlotId duplicateSlotId = numberAddNode->AddSlot("duplicate");
EXPECT_EQ(2U, nodeNotifications.GetSlotsAdded());
EXPECT_EQ(testSlotId, duplicateSlotId);
numberAddNode->RemoveSlot(testSlotId);
EXPECT_EQ(2U, nodeNotifications.GetSlotsRemoved());
// This should not signal the NodeNotification::OnSlotRemoved event as the slot no longer exist on the node
numberAddNode->RemoveSlot(testSlotId);
EXPECT_EQ(2U, nodeNotifications.GetSlotsRemoved());
numberAddEntity.reset();
}
TEST_F(ScriptCanvasTestFixture, InsertSlot_Basic)
{
using namespace ScriptCanvas;
Graph* graph = CreateGraph();
ConfigurableUnitTestNode* basicNode = CreateConfigurableNode();
SlotId firstSlotAdded;
SlotId secondSlotAdded;
SlotId thirdSlotAdded;
{
DataSlotConfiguration slotConfiguration;
slotConfiguration.m_name = "A";
slotConfiguration.SetDefaultValue(0);
slotConfiguration.SetConnectionType(ConnectionType::Input);
Slot* slot = basicNode->AddTestingSlot(slotConfiguration);
firstSlotAdded = slot->GetId();
}
{
DataSlotConfiguration slotConfiguration;
slotConfiguration.m_name = "C";
slotConfiguration.SetDefaultValue(2);
slotConfiguration.SetConnectionType(ConnectionType::Input);
Slot* slot = basicNode->AddTestingSlot(slotConfiguration);
secondSlotAdded = slot->GetId();
}
{
DataSlotConfiguration slotConfiguration;
slotConfiguration.m_name = "B";
slotConfiguration.SetDefaultValue(1);
slotConfiguration.SetConnectionType(ConnectionType::Input);
auto index = basicNode->FindSlotIndex(secondSlotAdded);
EXPECT_EQ(index, 1);
Slot* slot = basicNode->InsertTestingSlot(index, slotConfiguration);
thirdSlotAdded = slot->GetId();
}
{
AZStd::vector< const Slot* > slotList = basicNode->GetAllSlots();
EXPECT_EQ(slotList.size(), 3);
{
const Slot* firstSlot = slotList[0];
EXPECT_EQ(firstSlot->GetId(), firstSlotAdded);
EXPECT_EQ(firstSlot->GetName(), "A");
EXPECT_FLOAT_EQ(static_cast<float>((*firstSlot->FindDatum()->GetAs<Data::NumberType>())), 0.0f);
}
{
const Slot* secondSlot = slotList[1];
EXPECT_EQ(secondSlot->GetId(), thirdSlotAdded);
EXPECT_EQ(secondSlot->GetName(), "B");
EXPECT_FLOAT_EQ(static_cast<float>((*secondSlot->FindDatum()->GetAs<Data::NumberType>())), 1.0f);
}
{
const Slot* thirdSlot = slotList[2];
EXPECT_EQ(thirdSlot->GetId(), secondSlotAdded);
EXPECT_EQ(thirdSlot->GetName(), "C");
EXPECT_FLOAT_EQ(static_cast<float>((*thirdSlot->FindDatum()->GetAs<Data::NumberType>())), 2.0f);
}
}
graph->Activate();
{
AZStd::vector< const Slot* > slotList = basicNode->GetAllSlots();
EXPECT_EQ(slotList.size(), 3);
{
const Slot* firstSlot = slotList[0];
EXPECT_EQ(firstSlot->GetId(), firstSlotAdded);
EXPECT_EQ(firstSlot->GetName(), "A");
EXPECT_FLOAT_EQ(static_cast<float>((*firstSlot->FindDatum()->GetAs<Data::NumberType>())), 0.0f);
}
{
const Slot* secondSlot = slotList[1];
EXPECT_EQ(secondSlot->GetId(), thirdSlotAdded);
EXPECT_EQ(secondSlot->GetName(), "B");
EXPECT_FLOAT_EQ(static_cast<float>((*secondSlot->FindDatum()->GetAs<Data::NumberType>())), 1.0f);
}
{
const Slot* thirdSlot = slotList[2];
EXPECT_EQ(thirdSlot->GetId(), secondSlotAdded);
EXPECT_EQ(thirdSlot->GetName(), "C");
EXPECT_FLOAT_EQ(static_cast<float>((*thirdSlot->FindDatum()->GetAs<Data::NumberType>())), 2.0f);
}
}
graph->Deactivate();
{
AZStd::vector< const Slot* > slotList = basicNode->GetAllSlots();
EXPECT_EQ(slotList.size(), 3);
{
const Slot* firstSlot = slotList[0];
EXPECT_EQ(firstSlot->GetId(), firstSlotAdded);
EXPECT_EQ(firstSlot->GetName(), "A");
EXPECT_FLOAT_EQ(static_cast<float>((*firstSlot->FindDatum()->GetAs<Data::NumberType>())), 0.0f);
}
{
const Slot* secondSlot = slotList[1];
EXPECT_EQ(secondSlot->GetId(), thirdSlotAdded);
EXPECT_EQ(secondSlot->GetName(), "B");
EXPECT_FLOAT_EQ(static_cast<float>((*secondSlot->FindDatum()->GetAs<Data::NumberType>())), 1.0f);
}
{
const Slot* thirdSlot = slotList[2];
EXPECT_EQ(thirdSlot->GetId(), secondSlotAdded);
EXPECT_EQ(thirdSlot->GetName(), "C");
EXPECT_FLOAT_EQ(static_cast<float>((*thirdSlot->FindDatum()->GetAs<Data::NumberType>())), 2.0f);
}
}
}
TEST_F(ScriptCanvasTestFixture, InsertSlot_FrontPadded)
{
using namespace ScriptCanvas;
Graph* graph = CreateGraph();
ConfigurableUnitTestNode* basicNode = CreateConfigurableNode();
basicNode->AddTestingSlot(ExecutionSlotConfiguration("Input", ConnectionType::Input));
basicNode->AddTestingSlot(ExecutionSlotConfiguration("Input-1", ConnectionType::Input));
basicNode->AddTestingSlot(ExecutionSlotConfiguration("Input-2", ConnectionType::Input));
basicNode->AddTestingSlot(ExecutionSlotConfiguration("Input-3", ConnectionType::Input));
SlotId firstSlotAdded;
SlotId secondSlotAdded;
SlotId thirdSlotAdded;
{
DataSlotConfiguration slotConfiguration;
slotConfiguration.m_name = "A";
slotConfiguration.SetDefaultValue(0);
slotConfiguration.SetConnectionType(ConnectionType::Input);
Slot* slot = basicNode->AddTestingSlot(slotConfiguration);
firstSlotAdded = slot->GetId();
}
{
DataSlotConfiguration slotConfiguration;
slotConfiguration.m_name = "C";
slotConfiguration.SetDefaultValue(2);
slotConfiguration.SetConnectionType(ConnectionType::Input);
Slot* slot = basicNode->AddTestingSlot(slotConfiguration);
secondSlotAdded = slot->GetId();
}
{
DataSlotConfiguration slotConfiguration;
slotConfiguration.m_name = "B";
slotConfiguration.SetDefaultValue(1);
slotConfiguration.SetConnectionType(ConnectionType::Input);
auto index = basicNode->FindSlotIndex(secondSlotAdded);
Slot* slot = basicNode->InsertTestingSlot(index, slotConfiguration);
thirdSlotAdded = slot->GetId();
}
{
AZStd::vector< const Slot* > slotList = basicNode->FindSlotsByDescriptor(SlotDescriptors::DataIn());
EXPECT_EQ(slotList.size(), 3);
{
const Slot* firstSlot = slotList[0];
EXPECT_EQ(firstSlot->GetId(), firstSlotAdded);
EXPECT_EQ(firstSlot->GetName(), "A");
EXPECT_FLOAT_EQ(static_cast<float>((*firstSlot->FindDatum()->GetAs<Data::NumberType>())), 0.0f);
}
{
const Slot* secondSlot = slotList[1];
EXPECT_EQ(secondSlot->GetId(), thirdSlotAdded);
EXPECT_EQ(secondSlot->GetName(), "B");
EXPECT_FLOAT_EQ(static_cast<float>((*secondSlot->FindDatum()->GetAs<Data::NumberType>())), 1.0f);
}
{
const Slot* thirdSlot = slotList[2];
EXPECT_EQ(thirdSlot->GetId(), secondSlotAdded);
EXPECT_EQ(thirdSlot->GetName(), "C");
EXPECT_FLOAT_EQ(static_cast<float>((*thirdSlot->FindDatum()->GetAs<Data::NumberType>())), 2.0f);
}
}
graph->Activate();
{
AZStd::vector< const Slot* > slotList = basicNode->FindSlotsByDescriptor(SlotDescriptors::DataIn());
EXPECT_EQ(slotList.size(), 3);
{
const Slot* firstSlot = slotList[0];
EXPECT_EQ(firstSlot->GetId(), firstSlotAdded);
EXPECT_EQ(firstSlot->GetName(), "A");
EXPECT_FLOAT_EQ(static_cast<float>((*firstSlot->FindDatum()->GetAs<Data::NumberType>())), 0.0f);
}
{
const Slot* secondSlot = slotList[1];
EXPECT_EQ(secondSlot->GetId(), thirdSlotAdded);
EXPECT_EQ(secondSlot->GetName(), "B");
EXPECT_FLOAT_EQ(static_cast<float>((*secondSlot->FindDatum()->GetAs<Data::NumberType>())), 1.0f);
}
{
const Slot* thirdSlot = slotList[2];
EXPECT_EQ(thirdSlot->GetId(), secondSlotAdded);
EXPECT_EQ(thirdSlot->GetName(), "C");
EXPECT_FLOAT_EQ(static_cast<float>((*thirdSlot->FindDatum()->GetAs<Data::NumberType>())), 2.0f);
}
}
graph->Deactivate();
{
AZStd::vector< const Slot* > slotList = basicNode->FindSlotsByDescriptor(SlotDescriptors::DataIn());
EXPECT_EQ(slotList.size(), 3);
{
const Slot* firstSlot = slotList[0];
EXPECT_EQ(firstSlot->GetId(), firstSlotAdded);
EXPECT_EQ(firstSlot->GetName(), "A");
EXPECT_FLOAT_EQ(static_cast<float>((*firstSlot->FindDatum()->GetAs<Data::NumberType>())), 0.0f);
}
{
const Slot* secondSlot = slotList[1];
EXPECT_EQ(secondSlot->GetId(), thirdSlotAdded);
EXPECT_EQ(secondSlot->GetName(), "B");
EXPECT_FLOAT_EQ(static_cast<float>((*secondSlot->FindDatum()->GetAs<Data::NumberType>())), 1.0f);
}
{
const Slot* thirdSlot = slotList[2];
EXPECT_EQ(thirdSlot->GetId(), secondSlotAdded);
EXPECT_EQ(thirdSlot->GetName(), "C");
EXPECT_FLOAT_EQ(static_cast<float>((*thirdSlot->FindDatum()->GetAs<Data::NumberType>())), 2.0f);
}
}
}
TEST_F(ScriptCanvasTestFixture, InsertSlot)
{
RegisterComponentDescriptor<InsertSlotConcatNode>();
using namespace ScriptCanvas;
using namespace Nodes;
AZStd::unique_ptr<AZ::Entity> graphEntity = AZStd::make_unique<AZ::Entity>("RemoveSlotGraph");
graphEntity->Init();
SystemRequestBus::Broadcast(&SystemRequests::CreateEngineComponentsOnEntity, graphEntity.get());
Graph* graph = AZ::EntityUtils::FindFirstDerivedComponent<Graph>(graphEntity.get());
ScriptCanvasId graphUniqueId = graph->GetScriptCanvasId();
AZ::EntityId outId;
auto startNode = CreateTestNode<Nodes::Core::Start>(graphUniqueId, outId);
auto insertSlotConcatNode = CreateTestNode<InsertSlotConcatNode>(graphUniqueId, outId);
auto setVariableNode = CreateTestNode<Nodes::Core::SetVariableNode>(graphUniqueId, outId);
VariableId resultVarId = CreateVariable(graphUniqueId, Data::StringType(), "result");
setVariableNode->SetId(resultVarId);
EXPECT_TRUE(setVariableNode->GetDataInSlotId().IsValid());
//logic connections
EXPECT_TRUE(Connect(*graph, startNode->GetEntityId(), "Out", insertSlotConcatNode->GetEntityId(), "In"));
EXPECT_TRUE(Connect(*graph, insertSlotConcatNode->GetEntityId(), "Out", setVariableNode->GetEntityId(), "In"));
// insert slots
auto concatSlotId = insertSlotConcatNode->InsertSlot(-1, "A");
auto slotAId = concatSlotId;
SetInput_UNIT_TEST(insertSlotConcatNode, concatSlotId, Data::StringType("Hello"));
concatSlotId = insertSlotConcatNode->InsertSlot(-1, "B");
auto slotBId = concatSlotId;
SetInput_UNIT_TEST(insertSlotConcatNode, concatSlotId, Data::StringType(" World"));
// data connections
EXPECT_TRUE(graph->Connect(insertSlotConcatNode->GetEntityId(), insertSlotConcatNode->GetSlotId("Result"), setVariableNode->GetEntityId(), setVariableNode->GetDataInSlotId()));
graphEntity->Activate();
ReportErrors(graph);
graphEntity->Deactivate();
const GraphVariable* resultDatum{};
VariableRequestBus::EventResult(resultDatum, GraphScopedVariableId(graphUniqueId, resultVarId), &VariableRequests::GetVariableConst);
ASSERT_NE(nullptr, resultDatum);
EXPECT_EQ("Hello World", resultDatum->GetDatum()->ToString());
// insert additional slot between A and B
auto slotIndex = insertSlotConcatNode->FindSlotIndex(slotBId);
EXPECT_GE(slotIndex, 0);
concatSlotId = insertSlotConcatNode->InsertSlot(slotIndex, "Alpha");
SetInput_UNIT_TEST(insertSlotConcatNode, concatSlotId, Data::StringType(" Ice Cream"));
// re-execute the graph
graphEntity->Activate();
ReportErrors(graph);
graphEntity->Deactivate();
// the new concatenated string should be in the middle
EXPECT_EQ("Hello Ice Cream World", resultDatum->GetDatum()->ToString());
graphEntity.reset();
}
TEST_F(ScriptCanvasTestFixture, NativeProperties)
{
using namespace ScriptCanvas;
using namespace Nodes;
AZ::Entity* graphEntity = aznew AZ::Entity("Graph");
graphEntity->Init();
SystemRequestBus::Broadcast(&SystemRequests::CreateGraphOnEntity, graphEntity);
auto graph = graphEntity->FindComponent<Graph>();
EXPECT_NE(nullptr, graph);
const AZ::EntityId& graphEntityId = graph->GetEntityId();
const ScriptCanvasId& graphUniqueId = graph->GetScriptCanvasId();
AZ::EntityId startID;
CreateTestNode<Nodes::Core::Start>(graphUniqueId, startID);
AZ::EntityId addId;
CreateTestNode<Vector3Nodes::AddNode>(graphUniqueId, addId);
AZ::EntityId vector3IdA, vector3IdB, vector3IdC;
auto vector3NodeA = CreateTestNode<Nodes::Math::Vector3>(graphUniqueId, vector3IdA);
auto vector3NodeB = CreateTestNode<Nodes::Math::Vector3>(graphUniqueId, vector3IdB);
auto vector3NodeC = CreateTestNode<Nodes::Math::Vector3>(graphUniqueId, vector3IdC);
AZ::EntityId number1Id, number2Id, number3Id, number4Id, number5Id, number6Id, number7Id, number8Id, number9Id;
Node* number1Node = CreateDataNode<Data::NumberType>(graphUniqueId, 1, number1Id);
Node* number2Node = CreateDataNode<Data::NumberType>(graphUniqueId, 2, number2Id);
Node* number3Node = CreateDataNode<Data::NumberType>(graphUniqueId, 3, number3Id);
Node* number4Node = CreateDataNode<Data::NumberType>(graphUniqueId, 4, number4Id);
Node* number5Node = CreateDataNode<Data::NumberType>(graphUniqueId, 5, number5Id);
Node* number6Node = CreateDataNode<Data::NumberType>(graphUniqueId, 6, number6Id);
Node* number7Node = CreateDataNode<Data::NumberType>(graphUniqueId, 7, number7Id);
Node* number8Node = CreateDataNode<Data::NumberType>(graphUniqueId, 8, number8Id);
Node* number9Node = CreateDataNode<Data::NumberType>(graphUniqueId, 0, number9Id);
// data
EXPECT_TRUE(Connect(*graph, number1Id, "Get", vector3IdA, "Number: x"));
EXPECT_TRUE(Connect(*graph, number2Id, "Get", vector3IdA, "Number: y"));
EXPECT_TRUE(Connect(*graph, number3Id, "Get", vector3IdA, "Number: z"));
EXPECT_TRUE(Connect(*graph, number4Id, "Get", vector3IdB, "Number: x"));
EXPECT_TRUE(Connect(*graph, number5Id, "Get", vector3IdB, "Number: y"));
EXPECT_TRUE(Connect(*graph, number6Id, "Get", vector3IdB, "Number: z"));
EXPECT_TRUE(Connect(*graph, vector3IdA, "Get", addId, "Vector3: A"));
EXPECT_TRUE(Connect(*graph, vector3IdB, "Get", addId, "Vector3: B"));
EXPECT_TRUE(Connect(*graph, addId, "Result: Vector3", vector3IdC, "Set"));
EXPECT_TRUE(Connect(*graph, vector3IdC, "x: Number", number7Id, "Set"));
EXPECT_TRUE(Connect(*graph, vector3IdC, "y: Number", number8Id, "Set"));
EXPECT_TRUE(Connect(*graph, vector3IdC, "z: Number", number9Id, "Set"));
// code
EXPECT_TRUE(Connect(*graph, startID, "Out", addId, "In"));
graphEntity->Activate();
ReportErrors(graph);
if (auto result = GetInput_UNIT_TEST<AZ::Vector3>(vector3NodeC, "Set"))
{
EXPECT_EQ(AZ::Vector3(5, 7, 9), *result);
}
else
{
ADD_FAILURE();
}
if (auto result = GetInput_UNIT_TEST<Data::NumberType>(number7Node, "Set"))
{
EXPECT_EQ(5, *result);
}
else
{
ADD_FAILURE();
}
if (auto result = GetInput_UNIT_TEST<Data::NumberType>(number8Node, "Set"))
{
EXPECT_EQ(7, *result);
}
else
{
ADD_FAILURE();
}
if (auto result = GetInput_UNIT_TEST<Data::NumberType>(number9Node, "Set"))
{
EXPECT_EQ(9, *result);
}
else
{
ADD_FAILURE();
}
graphEntity->Deactivate();
delete graphEntity;
}
TEST_F(ScriptCanvasTestFixture, ExtractPropertiesNativeType)
{
// TODO: Add Extract test for all Native Types
using namespace ScriptCanvas;
using namespace Nodes;
AZStd::unique_ptr<AZ::Entity> graphEntity = AZStd::make_unique<AZ::Entity>("PropertyGraph");
Graph* graph{};
SystemRequestBus::BroadcastResult(graph, &SystemRequests::CreateGraphOnEntity, graphEntity.get());
ASSERT_NE(nullptr, graph);
AZ::EntityId propertyEntityId = graphEntity->GetId();
ScriptCanvasId graphUniqueId = graph->GetScriptCanvasId();
graphEntity->Init();
// Create Extract Property Node
AZ::EntityId outID;
auto startNode = CreateTestNode<Nodes::Core::Start>(graphUniqueId, outID);
auto extractPropertyNode = CreateTestNode<Nodes::Core::ExtractProperty>(graphUniqueId, outID);
auto printNode = CreateTestNode<TestResult>(graphUniqueId, outID);
// Test Native Vector3 Properties
auto vector3Node = CreateDataNode(graphUniqueId, Data::Vector3Type(10.0f, 23.3f, 77.45f), outID);
auto numberResultNode1 = CreateDataNode(graphUniqueId, 0.0f, outID);
auto numberResultNode2 = CreateDataNode(graphUniqueId, 0.0f, outID);
auto numberResultNode3 = CreateDataNode(graphUniqueId, 0.0f, outID);
// data
EXPECT_EQ(0, extractPropertyNode->GetPropertyFields().size());
EXPECT_FALSE(extractPropertyNode->GetSourceSlotDataType().IsValid());
EXPECT_TRUE(Connect(*graph, vector3Node->GetEntityId(), "Get", extractPropertyNode->GetEntityId(), "Source"));
auto propertyFields = extractPropertyNode->GetPropertyFields();
EXPECT_EQ(3, propertyFields.size());
EXPECT_TRUE(extractPropertyNode->GetSourceSlotDataType().IS_A(Data::Type::Vector3()));
// Vector3::x
auto propIt = AZStd::find_if(propertyFields.begin(), propertyFields.end(), [](const AZStd::pair<AZStd::string_view, SlotId> propertyField)
{
return propertyField.first == "x";
});
ASSERT_NE(propIt, propertyFields.end());
EXPECT_TRUE(graph->Connect(extractPropertyNode->GetEntityId(), propIt->second, numberResultNode1->GetEntityId(), numberResultNode1->GetSlotId("Set")));
// Vector3::y
propIt = AZStd::find_if(propertyFields.begin(), propertyFields.end(), [](const AZStd::pair<AZStd::string_view, SlotId> propertyField)
{
return propertyField.first == "y";
});
ASSERT_NE(propIt, propertyFields.end());
EXPECT_TRUE(graph->Connect(extractPropertyNode->GetEntityId(), propIt->second, numberResultNode2->GetEntityId(), numberResultNode2->GetSlotId("Set")));
// Vector3::z
propIt = AZStd::find_if(propertyFields.begin(), propertyFields.end(), [](const AZStd::pair<AZStd::string_view, SlotId> propertyField)
{
return propertyField.first == "z";
});
ASSERT_NE(propIt, propertyFields.end());
EXPECT_TRUE(graph->Connect(extractPropertyNode->GetEntityId(), propIt->second, numberResultNode3->GetEntityId(), numberResultNode3->GetSlotId("Set")));
// Print the z value to console
EXPECT_TRUE(graph->Connect(numberResultNode3->GetEntityId(), numberResultNode3->GetSlotId("Get"), printNode->GetEntityId(), printNode->GetSlotId("Value")));
// logic
EXPECT_TRUE(Connect(*graph, startNode->GetEntityId(), "Out", extractPropertyNode->GetEntityId(), "In"));
EXPECT_TRUE(Connect(*graph, extractPropertyNode->GetEntityId(), "Out", printNode->GetEntityId(), "In"));
// execute
{
ScriptCanvasEditor::ScopedOutputSuppression suppressOutput;
graphEntity->Activate();
}
ReportErrors(graph);
graphEntity->Deactivate();
AZ::Entity* connectionEntity{};
EXPECT_TRUE(graph->FindConnection(connectionEntity, { vector3Node->GetEntityId(), vector3Node->GetSlotId("Get") }, { extractPropertyNode->GetEntityId(), extractPropertyNode->GetSlotId("Source") }));
EXPECT_TRUE(graph->DisconnectById(connectionEntity->GetId()));
const float tolerance = 0.001f;
// x result
auto vectorElementResult = GetInput_UNIT_TEST<Data::NumberType>(numberResultNode1, "Set");
ASSERT_NE(nullptr, vectorElementResult);
EXPECT_NEAR(10.0f, *vectorElementResult, tolerance);
// y result
vectorElementResult = GetInput_UNIT_TEST<Data::NumberType>(numberResultNode2, "Set");
ASSERT_NE(nullptr, vectorElementResult);
EXPECT_NEAR(23.3f, *vectorElementResult, tolerance);
// z result
vectorElementResult = GetInput_UNIT_TEST<Data::NumberType>(numberResultNode3, "Set");
ASSERT_NE(nullptr, vectorElementResult);
EXPECT_NEAR(77.45f, *vectorElementResult, tolerance);
graphEntity.reset();
}
TEST_F(ScriptCanvasTestFixture, ExtractPropertiesBehaviorType)
{
TestBehaviorContextProperties::Reflect(m_serializeContext);
TestBehaviorContextProperties::Reflect(m_behaviorContext);
using namespace ScriptCanvas;
using namespace Nodes;
AZStd::unique_ptr<AZ::Entity> graphEntity = AZStd::make_unique<AZ::Entity>("PropertyGraph");
Graph* graph{};
SystemRequestBus::BroadcastResult(graph, &SystemRequests::CreateGraphOnEntity, graphEntity.get());
ASSERT_NE(nullptr, graph);
AZ::EntityId propertyEntityId = graphEntity->GetId();
ScriptCanvasId graphUniqueId = graph->GetScriptCanvasId();
graphEntity->Init();
// Create Extract Property Node
AZ::EntityId outID;
auto startNode = CreateTestNode<Nodes::Core::Start>(graphUniqueId, outID);
auto extractPropertyNode = CreateTestNode<Nodes::Core::ExtractProperty>(graphUniqueId, outID);
auto printNode = CreateTestNode<TestResult>(graphUniqueId, outID);
// Test BehaviorContext Properties
TestBehaviorContextProperties behaviorContextProperties;
behaviorContextProperties.m_booleanProp = true;
behaviorContextProperties.m_numberProp = 11.90f;
behaviorContextProperties.m_stringProp = "String Property";
auto behaviorContextPropertyNode = CreateDataNode(graphUniqueId, behaviorContextProperties, outID);
auto booleanResultNode = CreateDataNode(graphUniqueId, false, outID);
auto numberResultNode = CreateDataNode(graphUniqueId, 0.0f, outID);
auto stringResultNode = CreateDataNode(graphUniqueId, Data::StringType("Uninitialized"), outID);
// data
EXPECT_EQ(0, extractPropertyNode->GetPropertyFields().size());
EXPECT_FALSE(extractPropertyNode->GetSourceSlotDataType().IsValid());
EXPECT_TRUE(Connect(*graph, behaviorContextPropertyNode->GetEntityId(), "Get", extractPropertyNode->GetEntityId(), "Source"));
auto propertyFields = extractPropertyNode->GetPropertyFields();
EXPECT_EQ(4, propertyFields.size());
EXPECT_TRUE(extractPropertyNode->GetSourceSlotDataType().IS_A(Data::FromAZType<TestBehaviorContextProperties>()));
// TestBehaviorContextProperties::boolean
auto propIt = AZStd::find_if(propertyFields.begin(), propertyFields.end(), [](const AZStd::pair<AZStd::string_view, SlotId> propertyField)
{
return propertyField.first == "boolean";
});
ASSERT_NE(propIt, propertyFields.end());
EXPECT_TRUE(graph->Connect(extractPropertyNode->GetEntityId(), propIt->second, booleanResultNode->GetEntityId(), booleanResultNode->GetSlotId("Set")));
// TestBehaviorContextProperties::number
propIt = AZStd::find_if(propertyFields.begin(), propertyFields.end(), [](const AZStd::pair<AZStd::string_view, SlotId> propertyField)
{
return propertyField.first == "number";
});
ASSERT_NE(propIt, propertyFields.end());
EXPECT_TRUE(graph->Connect(extractPropertyNode->GetEntityId(), propIt->second, numberResultNode->GetEntityId(), numberResultNode->GetSlotId("Set")));
// TestBehaviorContextProperties::string
propIt = AZStd::find_if(propertyFields.begin(), propertyFields.end(), [](const AZStd::pair<AZStd::string_view, SlotId> propertyField)
{
return propertyField.first == "string";
});
ASSERT_NE(propIt, propertyFields.end());
EXPECT_TRUE(graph->Connect(extractPropertyNode->GetEntityId(), propIt->second, stringResultNode->GetEntityId(), stringResultNode->GetSlotId("Set")));
// Print the string value to console
EXPECT_TRUE(graph->Connect(stringResultNode->GetEntityId(), stringResultNode->GetSlotId("Get"), printNode->GetEntityId(), printNode->GetSlotId("Value")));
// logic
EXPECT_TRUE(Connect(*graph, startNode->GetEntityId(), "Out", extractPropertyNode->GetEntityId(), "In"));
EXPECT_TRUE(Connect(*graph, extractPropertyNode->GetEntityId(), "Out", printNode->GetEntityId(), "In"));
// execute
{
ScriptCanvasEditor::ScopedOutputSuppression suppressOutput;
graphEntity->Activate();
}
ReportErrors(graph);
graphEntity->Deactivate();
AZ::Entity* connectionEntity{};
EXPECT_TRUE(graph->FindConnection(connectionEntity, { behaviorContextPropertyNode->GetEntityId(), behaviorContextPropertyNode->GetSlotId("Get") }, { extractPropertyNode->GetEntityId(), extractPropertyNode->GetSlotId("Source") }));
EXPECT_TRUE(graph->DisconnectById(connectionEntity->GetId()));
// boolean result
auto booleanResult = GetInput_UNIT_TEST<Data::BooleanType>(booleanResultNode, "Set");
ASSERT_NE(nullptr, booleanResult);
EXPECT_TRUE(booleanResult);
// number result
const float tolerance = 0.001f;
auto numberResult = GetInput_UNIT_TEST<Data::NumberType>(numberResultNode, "Set");
ASSERT_NE(nullptr, numberResult);
EXPECT_NEAR(11.90f, *numberResult, tolerance);
// string result
auto stringResult = GetInput_UNIT_TEST<Data::StringType>(stringResultNode, "Set");
ASSERT_NE(nullptr, stringResult);
EXPECT_EQ("String Property", *stringResult);
graphEntity.reset();
m_serializeContext->EnableRemoveReflection();
TestBehaviorContextProperties::Reflect(m_serializeContext);
m_serializeContext->DisableRemoveReflection();
m_behaviorContext->EnableRemoveReflection();
TestBehaviorContextProperties::Reflect(m_behaviorContext);
m_behaviorContext->DisableRemoveReflection();
}
TEST_F(ScriptCanvasTestFixture, IsNullCheck)
{
using namespace ScriptCanvas;
EventTestHandler::Reflect(m_serializeContext);
EventTestHandler::Reflect(m_behaviorContext);
TestBehaviorContextObject::Reflect(m_serializeContext);
TestBehaviorContextObject::Reflect(m_behaviorContext);
Graph* graph(nullptr);
SystemRequestBus::BroadcastResult(graph, &SystemRequests::MakeGraph);
EXPECT_TRUE(graph != nullptr);
graph->GetEntity()->Init();
const AZ::EntityId& graphEntityID = graph->GetEntityId();
const ScriptCanvasId& graphUniqueId = graph->GetScriptCanvasId();
AZ::EntityId startID;
CreateTestNode<Nodes::Core::Start>(graphUniqueId, startID);
AZ::EntityId isNullFalseID;
CreateTestNode<Nodes::Logic::IsNull>(graphUniqueId, isNullFalseID);
AZ::EntityId isNullTrueID;
CreateTestNode<Nodes::Logic::IsNull>(graphUniqueId, isNullTrueID);
AZ::EntityId isNullResultFalseID;
auto isNullResultFalse = CreateDataNode(graphUniqueId, true, isNullResultFalseID);
AZ::EntityId isNullResultTrueID;
auto isNullResultTrue = CreateDataNode(graphUniqueId, false, isNullResultTrueID);
AZ::EntityId normalizeID;
Nodes::Core::Method* normalize = CreateTestNode<Nodes::Core::Method>(graphUniqueId, normalizeID);
Namespaces empty;
normalize->InitializeClass(empty, "TestBehaviorContextObject", "Normalize");
AZ::EntityId vectorID;
Nodes::Core::BehaviorContextObjectNode* vector = CreateTestNode<Nodes::Core::BehaviorContextObjectNode>(graphUniqueId, vectorID);
const AZStd::string vector3("TestBehaviorContextObject");
vector->InitializeObject(vector3);
if (auto vector3_2 = ModInput_UNIT_TEST<TestBehaviorContextObject>(vector, "Set"))
{
EXPECT_FALSE(vector3_2->IsNormalized());
}
else
{
ADD_FAILURE();
}
// test the reference type contract
{
ScriptCanvasEditor::ScopedOutputSuppression suppressOutput;
EXPECT_FALSE(Connect(*graph, isNullResultFalseID, "Get", isNullTrueID, "Reference"));
}
// data
EXPECT_TRUE(Connect(*graph, vectorID, "Get", normalizeID, "TestBehaviorContextObject: 0"));
EXPECT_TRUE(Connect(*graph, vectorID, "Get", isNullFalseID, "Reference"));
EXPECT_TRUE(Connect(*graph, isNullTrueID, "Is Null", isNullResultTrueID, "Set"));
EXPECT_TRUE(Connect(*graph, isNullFalseID, "Is Null", isNullResultFalseID, "Set"));
// execution
EXPECT_TRUE(Connect(*graph, startID, "Out", isNullTrueID, "In"));
EXPECT_TRUE(Connect(*graph, isNullTrueID, "True", isNullFalseID, "In"));
EXPECT_TRUE(Connect(*graph, isNullFalseID, "False", normalizeID, "In"));
AZ::Entity* graphEntity = graph->GetEntity();
{
ScriptCanvasEditor::ScopedOutputSuppression suppressOutput;
graphEntity->Activate();
}
ReportErrors(graph);
if (auto vector3_2 = GetInput_UNIT_TEST<TestBehaviorContextObject>(vector, "Set"))
{
EXPECT_TRUE(vector3_2->IsNormalized());
}
else
{
ADD_FAILURE();
}
if (auto shouldBeFalse = GetInput_UNIT_TEST<bool>(isNullResultFalse, "Set"))
{
EXPECT_FALSE(*shouldBeFalse);
}
else
{
ADD_FAILURE();
}
if (auto shouldBeTrue = GetInput_UNIT_TEST<bool>(isNullResultTrue, "Set"))
{
EXPECT_TRUE(*shouldBeTrue);
}
else
{
ADD_FAILURE();
}
graphEntity->Deactivate();
delete graphEntity;
m_serializeContext->EnableRemoveReflection();
m_behaviorContext->EnableRemoveReflection();
EventTestHandler::Reflect(m_serializeContext);
EventTestHandler::Reflect(m_behaviorContext);
TestBehaviorContextObject::Reflect(m_serializeContext);
TestBehaviorContextObject::Reflect(m_behaviorContext);
m_serializeContext->DisableRemoveReflection();
m_behaviorContext->DisableRemoveReflection();
}
TEST_F(ScriptCanvasTestFixture, NullThisPointerDoesNotCrash)
{
using namespace ScriptCanvas;
EventTestHandler::Reflect(m_serializeContext);
EventTestHandler::Reflect(m_behaviorContext);
TestBehaviorContextObject::Reflect(m_serializeContext);
TestBehaviorContextObject::Reflect(m_behaviorContext);
Graph* graph(nullptr);
SystemRequestBus::BroadcastResult(graph, &SystemRequests::MakeGraph);
EXPECT_TRUE(graph != nullptr);
graph->GetEntity()->Init();
const AZ::EntityId& graphEntityID = graph->GetEntityId();
const ScriptCanvasId& graphUniqueId = graph->GetScriptCanvasId();
AZ::EntityId startID;
CreateTestNode<Nodes::Core::Start>(graphUniqueId, startID);
AZ::EntityId normalizeID;
Nodes::Core::Method* normalize = CreateTestNode<Nodes::Core::Method>(graphUniqueId, normalizeID);
Namespaces empty;
normalize->InitializeClass(empty, "TestBehaviorContextObject", "Normalize");
EXPECT_TRUE(Connect(*graph, startID, "Out", normalizeID, "In"));
AZ::Entity* graphEntity = graph->GetEntity();
{
ScriptCanvasEditor::ScopedOutputSuppression suppressOutput;
graphEntity->Activate();
}
// just don't crash, but be in error
const bool expectError = true;
const bool expectIrrecoverableError = true;
ReportErrors(graph, expectError, expectIrrecoverableError);
graphEntity->Deactivate();
delete graphEntity;
m_serializeContext->EnableRemoveReflection();
m_behaviorContext->EnableRemoveReflection();
EventTestHandler::Reflect(m_serializeContext);
EventTestHandler::Reflect(m_behaviorContext);
TestBehaviorContextObject::Reflect(m_serializeContext);
TestBehaviorContextObject::Reflect(m_behaviorContext);
m_serializeContext->DisableRemoveReflection();
m_behaviorContext->DisableRemoveReflection();
}
TEST_F(ScriptCanvasTestFixture, ValueTypes)
{
using namespace ScriptCanvas;
Datum number0(Datum(0));
int number0Value = *number0.GetAs<int>();
Datum number1(Datum(1));
int number1Value = *number1.GetAs<int>();
Datum numberFloat(Datum(2.f));
float numberFloatValue = *numberFloat.GetAs<float>();
Datum numberDouble(Datum(3.0));
double numberDoubleValue = *numberDouble.GetAs<double>();
Datum numberHex(Datum(0xff));
int numberHexValue = *numberHex.GetAs<int>();
Datum numberPi(Datum(3.14f));
float numberPiValue = *numberPi.GetAs<float>();
Datum numberSigned(Datum(-100));
int numberSignedValue = *numberSigned.GetAs<int>();
Datum numberUnsigned(Datum(100u));
unsigned int numberUnsignedValue = *numberUnsigned.GetAs<unsigned int>();
Datum numberDoublePi(Datum(6.28));
double numberDoublePiValue = *numberDoublePi.GetAs<double>();
EXPECT_EQ(number0Value, 0);
EXPECT_EQ(number1Value, 1);
EXPECT_TRUE(AZ::IsClose(numberFloatValue, 2.f, std::numeric_limits<float>::epsilon()));
EXPECT_TRUE(AZ::IsClose(numberDoubleValue, 3.0, std::numeric_limits<double>::epsilon()));
EXPECT_NE(number0Value, number1Value);
SC_EXPECT_FLOAT_EQ(numberPiValue, 3.14f);
EXPECT_NE(number0Value, numberPiValue);
EXPECT_NE(numberPiValue, numberDoublePiValue);
Datum boolTrue(Datum(true));
EXPECT_TRUE(*boolTrue.GetAs<bool>());
Datum boolFalse(Datum(false));
EXPECT_FALSE(*boolFalse.GetAs<bool>());
boolFalse = boolTrue;
EXPECT_TRUE(*boolFalse.GetAs<bool>());
Datum boolFalse2(Datum(false));
boolTrue = boolFalse2;
EXPECT_FALSE(*boolTrue.GetAs<bool>());
{
const int k_count(10000);
AZStd::vector<Datum> objects;
for (int i = 0; i < k_count; ++i)
{
objects.push_back(Datum("Vector3", Datum::eOriginality::Original));
}
}
GTEST_SUCCEED();
}
namespace
{
using namespace ScriptCanvas;
using namespace ScriptCanvas::Nodes;
bool GraphHasVectorWithValue(const Graph& graph, const AZ::Vector3& vector)
{
for (auto nodeId : graph.GetNodes())
{
AZ::Entity* entity{};
AZ::ComponentApplicationBus::BroadcastResult(entity, &AZ::ComponentApplicationRequests::FindEntity, nodeId);
if (entity)
{
if (auto node = AZ::EntityUtils::FindFirstDerivedComponent<Core::BehaviorContextObjectNode>(entity))
{
if (auto candidate = NodeAccessor::GetInput_UNIT_TEST<AZ::Vector3>(node, "Set"))
{
if (*candidate == vector)
{
return true;
}
}
}
}
}
return false;
}
}
TEST_F(ScriptCanvasTestFixture, SerializationSaveTest)
{
using namespace ScriptCanvas;
using namespace ScriptCanvas::Nodes;
//////////////////////////////////////////////////////////////////////////
// Make the graph.
Graph* graph = nullptr;
SystemRequestBus::BroadcastResult(graph, &SystemRequests::MakeGraph);
EXPECT_TRUE(graph != nullptr);
graph->GetEntity()->Init();
const AZ::EntityId& graphEntityId = graph->GetEntityId();
const ScriptCanvasId& graphUniqueId = graph->GetScriptCanvasId();
// Make the nodes.
// Start
AZ::Entity* startEntity{ aznew AZ::Entity };
startEntity->Init();
AZ::EntityId startNode{ startEntity->GetId() };
SystemRequestBus::Broadcast(&SystemRequests::CreateNodeOnEntity, startNode, graphUniqueId, Nodes::Core::Start::TYPEINFO_Uuid());
// Constant 0
AZ::Entity* constant0Entity{ aznew AZ::Entity };
constant0Entity->Init();
AZ::EntityId constant0Node{ constant0Entity->GetId() };
SystemRequestBus::Broadcast(&SystemRequests::CreateNodeOnEntity, constant0Node, graphUniqueId, Nodes::Math::Number::TYPEINFO_Uuid());
// Get the node and set the value
Nodes::Math::Number* constant0NodePtr = nullptr;
SystemRequestBus::BroadcastResult(constant0NodePtr, &SystemRequests::GetNode<Nodes::Math::Number>, constant0Node);
EXPECT_TRUE(constant0NodePtr != nullptr);
if (constant0NodePtr)
{
SetInput_UNIT_TEST(constant0NodePtr, "Set", 4);
}
// Constant 1
AZ::Entity* constant1Entity{ aznew AZ::Entity };
constant1Entity->Init();
AZ::EntityId constant1Node{ constant1Entity->GetId() };
SystemRequestBus::Broadcast(&SystemRequests::CreateNodeOnEntity, constant1Node, graphUniqueId, Nodes::Math::Number::TYPEINFO_Uuid());
// Get the node and set the value
Nodes::Math::Number* constant1NodePtr = nullptr;
SystemRequestBus::BroadcastResult(constant1NodePtr, &SystemRequests::GetNode<Nodes::Math::Number>, constant1Node);
EXPECT_TRUE(constant1NodePtr != nullptr);
if (constant1NodePtr)
{
SetInput_UNIT_TEST(constant1NodePtr, "Set", 12);
}
// Sum
AZ::Entity* sumEntity{ aznew AZ::Entity };
sumEntity->Init();
AZ::EntityId sumNode{ sumEntity->GetId() };
SystemRequestBus::Broadcast(&SystemRequests::CreateNodeOnEntity, sumNode, graphUniqueId, Nodes::Math::Sum::TYPEINFO_Uuid());
AZ::EntityId printID;
auto printNode = CreateTestNode<TestResult>(graphUniqueId, printID);
// Connect, disconnect and reconnect to validate disconnection
graph->Connect(sumNode, AZ::EntityUtils::FindFirstDerivedComponent<Node>(sumEntity)->GetSlotId(BinaryOperator::k_lhsName), constant0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(constant0Entity)->GetSlotId("Get"));
graph->Disconnect(sumNode, AZ::EntityUtils::FindFirstDerivedComponent<Node>(sumEntity)->GetSlotId(BinaryOperator::k_lhsName), constant0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(constant0Entity)->GetSlotId("Get"));
graph->Connect(sumNode, AZ::EntityUtils::FindFirstDerivedComponent<Node>(sumEntity)->GetSlotId(BinaryOperator::k_lhsName), constant0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(constant0Entity)->GetSlotId("Get"));
{
auto* sumNodePtr = AZ::EntityUtils::FindFirstDerivedComponent<Nodes::Math::Sum>(sumEntity);
EXPECT_NE(nullptr, sumNodePtr);
EXPECT_EQ(1, graph->GetConnectedEndpoints({ sumNode, sumNodePtr->GetSlotId(BinaryOperator::k_lhsName) }).size());
}
graph->Connect(sumNode, AZ::EntityUtils::FindFirstDerivedComponent<Node>(sumEntity)->GetSlotId(BinaryOperator::k_rhsName), constant1Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(constant1Entity)->GetSlotId("Get"));
EXPECT_TRUE(Connect(*graph, sumNode, "Result", printID, "Value"));
EXPECT_TRUE(Connect(*graph, startNode, "Out", sumNode, Nodes::BinaryOperator::k_evaluateName));
EXPECT_TRUE(Connect(*graph, sumNode, Nodes::BinaryOperator::k_outName, printID, "In"));
AZ::EntityId vector3IdA, vector3IdB, vector3IdC;
const AZ::Vector3 allOne(1, 1, 1);
const AZ::Vector3 allTwo(2, 2, 2);
const AZ::Vector3 allThree(3, 3, 3);
const AZ::Vector3 allFour(4, 4, 4);
Core::BehaviorContextObjectNode* vector3NodeA = CreateTestNode<Core::BehaviorContextObjectNode>(graphUniqueId, vector3IdA);
vector3NodeA->InitializeObject(azrtti_typeid<AZ::Vector3>());
*ModInput_UNIT_TEST<AZ::Vector3>(vector3NodeA, "Set") = allOne;
Core::BehaviorContextObjectNode* vector3NodeB = CreateTestNode<Core::BehaviorContextObjectNode>(graphUniqueId, vector3IdB);
vector3NodeB->InitializeObject(azrtti_typeid<AZ::Vector3>());
*ModInput_UNIT_TEST<AZ::Vector3>(vector3NodeB, "Set") = allTwo;
Core::BehaviorContextObjectNode* vector3NodeC = CreateTestNode<Core::BehaviorContextObjectNode>(graphUniqueId, vector3IdC);
vector3NodeC->InitializeObject(azrtti_typeid<AZ::Vector3>());
*ModInput_UNIT_TEST<AZ::Vector3>(vector3NodeC, "Set") = allFour;
AZ::EntityId add3IdA;
CreateTestNode<Vector3Nodes::AddNode>(graphUniqueId, add3IdA);
EXPECT_TRUE(Connect(*graph, printID, "Out", add3IdA, "In"));
EXPECT_TRUE(Connect(*graph, vector3IdA, "Get", add3IdA, "Vector3: A"));
EXPECT_TRUE(Connect(*graph, vector3IdB, "Get", add3IdA, "Vector3: B"));
EXPECT_TRUE(Connect(*graph, vector3IdC, "Set", add3IdA, "Result: Vector3"));
AZStd::unique_ptr<AZ::Entity> graphEntity{ graph->GetEntity() };
EXPECT_EQ(allOne, *GetInput_UNIT_TEST<AZ::Vector3>(vector3NodeA, "Set"));
EXPECT_EQ(allTwo, *GetInput_UNIT_TEST<AZ::Vector3>(vector3NodeB, "Set"));
auto vector3C = *GetInput_UNIT_TEST<AZ::Vector3>(vector3NodeC, "Set");
EXPECT_EQ(allFour, vector3C);
auto nodeIDs = graph->GetNodes();
EXPECT_EQ(9, nodeIDs.size());
ScriptCanvasEditor::TraceSuppressionBus::Broadcast(&ScriptCanvasEditor::TraceSuppressionRequests::SuppressPrintf, true);
graphEntity->Activate();
ScriptCanvasEditor::TraceSuppressionBus::Broadcast(&ScriptCanvasEditor::TraceSuppressionRequests::SuppressPrintf, false);
ReportErrors(graph);
vector3C = *GetInput_UNIT_TEST<AZ::Vector3>(vector3NodeC, "Set");
EXPECT_EQ(allThree, vector3C);
if (auto result = GetInput_UNIT_TEST<float>(printNode, "Value"))
{
SC_EXPECT_FLOAT_EQ(*result, 16.0f);
}
else
{
ADD_FAILURE();
}
graphEntity->Deactivate();
auto* fileIO = AZ::IO::LocalFileIO::GetInstance();
EXPECT_TRUE(fileIO != nullptr);
auto pathResult = fileIO->CreatePath(k_tempCoreAssetDir);;
EXPECT_EQ(pathResult.GetResultCode(), AZ::IO::ResultCode::Success) << "Path failed to create";
// Save it
bool result = false;
AZ::IO::FileIOStream outFileStream(k_tempCoreAssetPath, AZ::IO::OpenMode::ModeWrite);
if (outFileStream.IsOpen())
{
RuntimeAssetHandler runtimeAssetHandler;
AZ::Data::Asset<RuntimeAsset> runtimeAsset = CreateRuntimeAsset(graph);
EXPECT_TRUE(runtimeAssetHandler.SaveAssetData(runtimeAsset, &outFileStream)) << "Asset failed to save";
EXPECT_TRUE(fileIO->Exists(k_tempCoreAssetPath));
}
else
{
ADD_FAILURE() << "File stream not open";
}
outFileStream.Close();
}
TEST_F(ScriptCanvasTestFixture, SerializationLoadTest_Graph)
{
using namespace ScriptCanvas;
//////////////////////////////////////////////////////////////////////////
// Make the graph.
Graph* graph = nullptr;
AZStd::unique_ptr<AZ::Entity> graphEntity = AZStd::make_unique<AZ::Entity>("Loaded Graph");
SystemRequestBus::BroadcastResult(graph, &SystemRequests::CreateGraphOnEntity, graphEntity.get());
auto* fileIO = AZ::IO::LocalFileIO::GetInstance();
ASSERT_NE(nullptr, fileIO);
EXPECT_TRUE(fileIO->Exists(k_tempCoreAssetPath));
// Load it
AZ::Data::Asset<RuntimeAsset> runtimeAsset;
runtimeAsset.Create(AZ::Uuid::CreateRandom());
AZ::u64 fileLength = 0;
AZ::IO::FileIOBase::GetInstance()->Size(k_tempCoreAssetPath, fileLength);
AZStd::shared_ptr<AZ::Data::AssetDataStream> stream = AZStd::make_shared<AZ::Data::AssetDataStream>();
stream->Open(k_tempCoreAssetPath, 0, fileLength);
stream->BlockUntilLoadComplete();
// Serialize the graph entity back in.
RuntimeAssetHandler runtimeAssetHandler;
EXPECT_EQ(runtimeAssetHandler.LoadAssetData(runtimeAsset, stream, {}), AZ::Data::AssetHandler::LoadResult::LoadComplete);
GraphData& assetGraphData = runtimeAsset.Get()->GetData().m_graphData;
AZStd::unordered_map<AZ::EntityId, AZ::EntityId> idRemap;
AZ::IdUtils::Remapper<AZ::EntityId>::GenerateNewIdsAndFixRefs(&assetGraphData, idRemap, m_serializeContext);
graph->AddGraphData(assetGraphData);
// Clear GraphData on asset to prevent it from deleting the graph data, the Graph component takes care of cleaning it up
assetGraphData.Clear();
// Initialize the entity
graphEntity->Init();
ScriptCanvasEditor::TraceSuppressionBus::Broadcast(&ScriptCanvasEditor::TraceSuppressionRequests::SuppressPrintf, true);
graphEntity->Activate();
ScriptCanvasEditor::TraceSuppressionBus::Broadcast(&ScriptCanvasEditor::TraceSuppressionRequests::SuppressPrintf, false);
// Run the graph component
graph = graphEntity->FindComponent<Graph>();
EXPECT_TRUE(graph != nullptr); // "Graph entity did not have the graph component.");
ReportErrors(graph);
const AZ::Vector3 allOne(1, 1, 1);
const AZ::Vector3 allTwo(2, 2, 2);
const AZ::Vector3 allThree(3, 3, 3);
const AZ::Vector3 allFour(4, 4, 4);
auto nodeIDs = graph->GetNodes();
EXPECT_EQ(9, nodeIDs.size());
// Graph result should be still 16
// Serialized graph has new remapped entity ids
auto nodes = graph->GetNodes();
auto sumNodeIt = AZStd::find_if(nodes.begin(), nodes.end(), [](const AZ::EntityId& nodeId) -> bool
{
AZ::Entity* entity{};
AZ::ComponentApplicationBus::BroadcastResult(entity, &AZ::ComponentApplicationRequests::FindEntity, nodeId);
return entity ? AZ::EntityUtils::FindFirstDerivedComponent<TestResult>(entity) ? true : false : false;
});
EXPECT_NE(nodes.end(), sumNodeIt);
TestResult* printNode = nullptr;
SystemRequestBus::BroadcastResult(printNode, &SystemRequests::GetNode<TestResult>, *sumNodeIt);
EXPECT_TRUE(printNode != nullptr);
if (auto result = GetInput_UNIT_TEST<float>(printNode, "Value"))
{
SC_EXPECT_FLOAT_EQ(*result, 16.0f);
}
else
{
ADD_FAILURE();
}
EXPECT_TRUE(GraphHasVectorWithValue(*graph, allOne));
EXPECT_TRUE(GraphHasVectorWithValue(*graph, allTwo));
EXPECT_TRUE(GraphHasVectorWithValue(*graph, allThree));
EXPECT_FALSE(GraphHasVectorWithValue(*graph, allFour));
}
TEST_F(ScriptCanvasTestFixture, SerializationLoadTest_RuntimeComponent)
{
using namespace ScriptCanvas;
//////////////////////////////////////////////////////////////////////////
// Make the graph.
AZStd::unique_ptr<AZ::Entity> executionEntity = AZStd::make_unique<AZ::Entity>("Loaded Graph");
auto executionComponent = executionEntity->CreateComponent<ScriptCanvas::RuntimeComponent>();
auto* fileIO = AZ::IO::LocalFileIO::GetInstance();
EXPECT_NE(nullptr, fileIO);
EXPECT_TRUE(fileIO->Exists(k_tempCoreAssetPath));
// Load it
AZ::Data::Asset<ScriptCanvas::RuntimeAsset> runtimeAsset;
runtimeAsset.Create(AZ::Uuid::CreateRandom());
AZ::u64 fileLength = 0;
AZ::IO::FileIOBase::GetInstance()->Size(k_tempCoreAssetPath, fileLength);
AZStd::shared_ptr<AZ::Data::AssetDataStream> stream = AZStd::make_shared<AZ::Data::AssetDataStream>();
stream->Open(k_tempCoreAssetPath, 0, fileLength);
stream->BlockUntilLoadComplete();
// Serialize the runtime asset back in.
RuntimeAssetHandler runtimeAssetHandler;
EXPECT_EQ(runtimeAssetHandler.LoadAssetData(runtimeAsset, stream, {}), AZ::Data::AssetHandler::LoadResult::LoadComplete);
runtimeAssetHandler.InitAsset(runtimeAsset, true, false);
// Initialize the entity
executionComponent->SetRuntimeAsset(runtimeAsset);
executionEntity->Init();
{
ScriptCanvasEditor::ScopedOutputSuppression suppressOutput;
executionEntity->Activate();
// Dispatch the AssetBus events to force onAssetReady event
AZ::Data::AssetManager::Instance().DispatchEvents();
}
EXPECT_FALSE(executionComponent->IsInErrorState());
const AZ::Vector3 allOne(1, 1, 1);
const AZ::Vector3 allTwo(2, 2, 2);
const AZ::Vector3 allThree(3, 3, 3);
const AZ::Vector3 allFour(4, 4, 4);
auto nodeIds = executionComponent->GetNodes();
EXPECT_EQ(9, nodeIds.size());
// Graph result should be still 16
// Serialized graph has new remapped entity ids
auto sumNodeIt = AZStd::find_if(nodeIds.begin(), nodeIds.end(), [](const AZ::EntityId& nodeId) -> bool
{
AZ::Entity* entity{};
AZ::ComponentApplicationBus::BroadcastResult(entity, &AZ::ComponentApplicationRequests::FindEntity, nodeId);
return entity ? AZ::EntityUtils::FindFirstDerivedComponent<TestResult>(entity) ? true : false : false;
});
EXPECT_NE(nodeIds.end(), sumNodeIt);
TestResult* printNode = nullptr;
SystemRequestBus::BroadcastResult(printNode, &SystemRequests::GetNode<TestResult>, *sumNodeIt);
EXPECT_TRUE(printNode != nullptr);
if (auto result = GetInput_UNIT_TEST<float>(printNode, "Value"))
{
SC_EXPECT_FLOAT_EQ(*result, 16.0f);
}
else
{
ADD_FAILURE();
}
AZStd::vector<AZ::Vector3> vector3Results;
for (auto nodeId : nodeIds)
{
AZ::Entity* entity{};
AZ::ComponentApplicationBus::BroadcastResult(entity, &AZ::ComponentApplicationRequests::FindEntity, nodeId);
auto behaviorContextNode = entity ? AZ::EntityUtils::FindFirstDerivedComponent<Core::BehaviorContextObjectNode>(entity) : nullptr;
auto rawVector3 = behaviorContextNode ? GetInput_UNIT_TEST<AZ::Vector3>(behaviorContextNode, PureData::k_setThis) : nullptr;
if (rawVector3)
{
vector3Results.push_back(*rawVector3);
}
}
auto allOneFound = AZStd::any_of(vector3Results.begin(), vector3Results.end(), [allOne](const AZ::Vector3& vector3Result)
{
return allOne == vector3Result;
});
auto allTwoFound = AZStd::any_of(vector3Results.begin(), vector3Results.end(), [allTwo](const AZ::Vector3& vector3Result)
{
return allTwo == vector3Result;
});
auto allThreeFound = AZStd::any_of(vector3Results.begin(), vector3Results.end(), [allThree](const AZ::Vector3& vector3Result)
{
return allThree == vector3Result;
});
auto allFourFound = AZStd::any_of(vector3Results.begin(), vector3Results.end(), [allFour](const AZ::Vector3& vector3Result)
{
return allFour == vector3Result;
});
EXPECT_TRUE(allOneFound);
EXPECT_TRUE(allTwoFound);
EXPECT_TRUE(allThreeFound);
EXPECT_FALSE(allFourFound);
}
TEST_F(ScriptCanvasTestFixture, Contracts)
{
using namespace ScriptCanvas;
RegisterComponentDescriptor<ContractNode>();
//////////////////////////////////////////////////////////////////////////
// Make the graph.
Graph* graph = nullptr;
SystemRequestBus::BroadcastResult(graph, &SystemRequests::MakeGraph);
EXPECT_TRUE(graph != nullptr);
graph->GetEntity()->Init();
const AZ::EntityId& graphEntityId = graph->GetEntityId();
const ScriptCanvasId& graphUniqueId = graph->GetScriptCanvasId();
// Make the nodes.
// Start
AZ::Entity* startEntity{ aznew AZ::Entity("Start") };
startEntity->Init();
AZ::EntityId startNode{ startEntity->GetId() };
SystemRequestBus::Broadcast(&SystemRequests::CreateNodeOnEntity, startNode, graphUniqueId, Nodes::Core::Start::TYPEINFO_Uuid());
// ContractNode 0
AZ::Entity* contract0Entity{ aznew AZ::Entity("Contract 0") };
contract0Entity->Init();
AZ::EntityId contract0Node{ contract0Entity->GetId() };
SystemRequestBus::Broadcast(&SystemRequests::CreateNodeOnEntity, contract0Node, graphUniqueId, ContractNode::TYPEINFO_Uuid());
// ContractNode 1
AZ::Entity* contract1Entity{ aznew AZ::Entity("Contract 1") };
contract1Entity->Init();
AZ::EntityId contract1Node{ contract1Entity->GetId() };
SystemRequestBus::Broadcast(&SystemRequests::CreateNodeOnEntity, contract1Node, graphUniqueId, ContractNode::TYPEINFO_Uuid());
// invalid
{
ScriptCanvasEditor::ScopedOutputSuppression suppressOutput;
EXPECT_FALSE(graph->Connect(startNode, AZ::EntityUtils::FindFirstDerivedComponent<Node>(startEntity)->GetSlotId("Out"), contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("Out")));
EXPECT_FALSE(graph->Connect(startNode, AZ::EntityUtils::FindFirstDerivedComponent<Node>(startEntity)->GetSlotId("In"), contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("In")));
EXPECT_FALSE(graph->Connect(startNode, AZ::EntityUtils::FindFirstDerivedComponent<Node>(startEntity)->GetSlotId("In"), contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("Get String")));
EXPECT_FALSE(graph->Connect(startNode, AZ::EntityUtils::FindFirstDerivedComponent<Node>(startEntity)->GetSlotId("Out"), contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("Get String")));
EXPECT_FALSE(graph->Connect(startNode, AZ::EntityUtils::FindFirstDerivedComponent<Node>(startEntity)->GetSlotId("In"), contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("Set String")));
EXPECT_FALSE(graph->Connect(startNode, AZ::EntityUtils::FindFirstDerivedComponent<Node>(startEntity)->GetSlotId("Out"), contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("Set String")));
EXPECT_FALSE(graph->Connect(contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("Set String"), contract1Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract1Entity)->GetSlotId("Set String")));
EXPECT_FALSE(graph->Connect(contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("Set String"), contract1Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract1Entity)->GetSlotId("Set Number")));
EXPECT_FALSE(graph->Connect(contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("Set String"), contract1Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract1Entity)->GetSlotId("Get Number")));
EXPECT_FALSE(graph->Connect(contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("Set String"), contract1Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract1Entity)->GetSlotId("Set String")));
EXPECT_FALSE(graph->Connect(contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("Out"), contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("In")));
}
// valid
EXPECT_TRUE(graph->Connect(startNode, AZ::EntityUtils::FindFirstDerivedComponent<Node>(startEntity)->GetSlotId("Out"), contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("In")));
EXPECT_TRUE(graph->Connect(contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("Set String"), contract1Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract1Entity)->GetSlotId("Get String")));
EXPECT_TRUE(graph->Connect(contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("In"), contract1Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract1Entity)->GetSlotId("Out")));
EXPECT_TRUE(graph->Connect(contract0Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract0Entity)->GetSlotId("Set Number"), contract1Node, AZ::EntityUtils::FindFirstDerivedComponent<Node>(contract1Entity)->GetSlotId("Get Number")));
// Execute it
graph->GetEntity()->Activate();
ReportErrors(graph);
graph->GetEntity()->Deactivate();
delete graph->GetEntity();
}
#if defined (SCRIPTCANVAS_ERRORS_ENABLED)
TEST_F(ScriptCanvasTestFixture, Error)
{
using namespace ScriptCanvas;
RegisterComponentDescriptor<UnitTestErrorNode>();
RegisterComponentDescriptor<InfiniteLoopNode>();
Graph* graph = nullptr;
SystemRequestBus::BroadcastResult(graph, &SystemRequests::MakeGraph);
EXPECT_TRUE(graph != nullptr);
graph->GetEntity()->Init();
const AZ::EntityId& graphEntityId = graph->GetEntityId();
const ScriptCanvasId& graphUniqueId = graph->GetScriptCanvasId();
UnitTestEventsHandler unitTestHandler;
unitTestHandler.BusConnect();
AZ::EntityId startID;
CreateTestNode<Nodes::Core::Start>(graphUniqueId, startID);
AZStd::string description = "Unit test error!";
AZ::EntityId stringNodeID;
CreateDataNode(graphUniqueId, description, stringNodeID);
AZStd::string sideFX1 = "Side FX 1";
AZ::EntityId sideFX1NodeID;
CreateDataNode(graphUniqueId, sideFX1, sideFX1NodeID);
AZ::EntityId errorNodeID;
CreateTestNode<UnitTestErrorNode>(graphUniqueId, errorNodeID);
AZ::EntityId sideEffectID = CreateClassFunctionNode(graphUniqueId, "UnitTestEventsBus", "SideEffect");
EXPECT_TRUE(Connect(*graph, sideFX1NodeID, "Get", sideEffectID, "String: 0"));
EXPECT_TRUE(Connect(*graph, startID, "Out", errorNodeID, "In"));
EXPECT_TRUE(Connect(*graph, errorNodeID, "Out", sideEffectID, "In"));
// test to make sure the graph received an error
{
ScriptCanvasEditor::ScopedOutputSuppression suppressOutput;
graph->GetEntity()->Activate();
}
const bool expectErrors = true;
const bool expectIrrecoverableErrors = true;
ReportErrors(graph, expectErrors, expectIrrecoverableErrors);
EXPECT_EQ(unitTestHandler.SideEffectCount(sideFX1), 0);
graph->GetEntity()->Deactivate();
delete graph->GetEntity();
}
TEST_F(ScriptCanvasTestFixture, ErrorNode)
{
using namespace ScriptCanvas;
Graph* graph = nullptr;
SystemRequestBus::BroadcastResult(graph, &SystemRequests::MakeGraph);
EXPECT_TRUE(graph != nullptr);
graph->GetEntity()->Init();
const AZ::EntityId& graphEntityId = graph->GetEntityId();
const ScriptCanvasId& graphUniqueId = graph->GetScriptCanvasId();
UnitTestEventsHandler unitTestHandler;
unitTestHandler.BusConnect();
// Start
AZ::EntityId startID;
CreateTestNode<Nodes::Core::Start>(graphUniqueId, startID);
AZStd::string description = "Test Error Report";
AZ::EntityId stringNodeID;
CreateDataNode(graphUniqueId, description, stringNodeID);
AZStd::string sideFX1 = "Side FX 1";
AZ::EntityId sideFX1NodeID;
CreateDataNode(graphUniqueId, sideFX1, sideFX1NodeID);
AZ::EntityId errorNodeID;
CreateTestNode<Nodes::Core::Error>(graphUniqueId, errorNodeID);
AZ::EntityId sideEffectID = CreateClassFunctionNode(graphUniqueId, "UnitTestEventsBus", "SideEffect");
EXPECT_TRUE(Connect(*graph, startID, "Out", sideEffectID, "In"));
EXPECT_TRUE(Connect(*graph, sideFX1NodeID, "Get", sideEffectID, "String: 0"));
EXPECT_TRUE(Connect(*graph, sideEffectID, "Out", errorNodeID, "In"));
EXPECT_TRUE(Connect(*graph, stringNodeID, "Get", errorNodeID, "Description"));
// test to make sure the graph received an error
{
ScriptCanvasEditor::ScopedOutputSuppression suppressOutput;
graph->GetEntity()->Activate();
}
const bool expectErrors = true;
const bool expectIrrecoverableErrors = true;
ReportErrors(graph, expectErrors, expectIrrecoverableErrors);
EXPECT_EQ(unitTestHandler.SideEffectCount(sideFX1), 1);
graph->GetEntity()->Deactivate();
// test to make sure the graph did to retry execution
graph->GetEntity()->Activate();
ReportErrors(graph, expectErrors, expectIrrecoverableErrors);
// if the graph was allowed to execute, the side effect counter should be higher
EXPECT_EQ(unitTestHandler.SideEffectCount(sideFX1), 1);
delete graph->GetEntity();
}
TEST_F(ScriptCanvasTestFixture, InfiniteLoopDetected)
{
using namespace ScriptCanvas;
RegisterComponentDescriptor<InfiniteLoopNode>();
Graph* graph = nullptr;
SystemRequestBus::BroadcastResult(graph, &SystemRequests::MakeGraph);
EXPECT_TRUE(graph != nullptr);
graph->GetEntity()->Init();
const AZ::EntityId& graphEntityId = graph->GetEntityId();
const ScriptCanvasId& graphUniqueId = graph->GetScriptCanvasId();
UnitTestEventsHandler unitTestHandler;
unitTestHandler.BusConnect();
AZStd::string sideFXpass = "Side FX Infinite Loop Error Handled";
AZ::EntityId sideFXpassNodeID;
CreateDataNode(graphUniqueId, sideFXpass, sideFXpassNodeID);
AZStd::string sideFXfail = "Side FX Infinite Loop Node Failed";
AZ::EntityId sideFXfailNodeID;
CreateDataNode(graphUniqueId, sideFXfail, sideFXfailNodeID);
AZ::EntityId startID;
CreateTestNode<Nodes::Core::Start>(graphUniqueId, startID);
AZ::EntityId infiniteLoopNodeID;
CreateTestNode<InfiniteLoopNode>(graphUniqueId, infiniteLoopNodeID);
AZ::EntityId errorHandlerID;
CreateTestNode<Nodes::Core::ErrorHandler>(graphUniqueId, errorHandlerID);
AZ::EntityId sideEffectPassID = CreateClassFunctionNode(graphUniqueId, "UnitTestEventsBus", "SideEffect");
AZ::EntityId sideEffectFailID = CreateClassFunctionNode(graphUniqueId, "UnitTestEventsBus", "SideEffect");
EXPECT_TRUE(Connect(*graph, sideFXpassNodeID, "Get", sideEffectPassID, "String: 0"));
EXPECT_TRUE(Connect(*graph, sideFXfailNodeID, "Get", sideEffectFailID, "String: 0"));
EXPECT_TRUE(Connect(*graph, startID, "Out", infiniteLoopNodeID, "In"));
EXPECT_TRUE(Connect(*graph, infiniteLoopNodeID, "In", infiniteLoopNodeID, "Before Infinity"));
EXPECT_TRUE(Connect(*graph, infiniteLoopNodeID, "After Infinity", sideEffectFailID, "In"));
EXPECT_TRUE(Connect(*graph, errorHandlerID, "Out", sideEffectPassID, "In"));
{
ScriptCanvasEditor::ScopedOutputSuppression suppressOutput;
graph->GetEntity()->Activate();
}
const bool expectError = true;
const bool expectIrrecoverableError = true;
ReportErrors(graph, expectError, expectIrrecoverableError);
EXPECT_EQ(0, unitTestHandler.SideEffectCount(sideFXpass));
EXPECT_EQ(0, unitTestHandler.SideEffectCount(sideFXfail));
graph->GetEntity()->Deactivate();
graph->GetEntity()->Activate();
ReportErrors(graph, expectError, expectIrrecoverableError);
EXPECT_EQ(0, unitTestHandler.SideEffectCount(sideFXpass));
EXPECT_EQ(0, unitTestHandler.SideEffectCount(sideFXfail));
delete graph->GetEntity();
}
#endif // SCRIPTCANAS_ERRORS_ENABLED
TEST_F(ScriptCanvasTestFixture, BinaryOperationTest)
{
using namespace ScriptCanvas::Nodes;
using namespace ScriptCanvas::Nodes::Comparison;
TestBehaviorContextObject::Reflect(m_serializeContext);
TestBehaviorContextObject::Reflect(m_behaviorContext);
BinaryOpTest<EqualTo>(1, 1, true);
BinaryOpTest<EqualTo>(1, 0, false);
BinaryOpTest<EqualTo>(0, 1, false);
BinaryOpTest<EqualTo>(0, 0, true);
BinaryOpTest<NotEqualTo>(1, 1, false);
BinaryOpTest<NotEqualTo>(1, 0, true);
BinaryOpTest<NotEqualTo>(0, 1, true);
BinaryOpTest<NotEqualTo>(0, 0, false);
BinaryOpTest<Greater>(1, 1, false);
BinaryOpTest<Greater>(1, 0, true);
BinaryOpTest<Greater>(0, 1, false);
BinaryOpTest<Greater>(0, 0, false);
BinaryOpTest<GreaterEqual>(1, 1, true);
BinaryOpTest<GreaterEqual>(1, 0, true);
BinaryOpTest<GreaterEqual>(0, 1, false);
BinaryOpTest<GreaterEqual>(0, 0, true);
BinaryOpTest<Less>(1, 1, false);
BinaryOpTest<Less>(1, 0, false);
BinaryOpTest<Less>(0, 1, true);
BinaryOpTest<Less>(0, 0, false);
BinaryOpTest<LessEqual>(1, 1, true);
BinaryOpTest<LessEqual>(1, 0, false);
BinaryOpTest<LessEqual>(0, 1, true);
BinaryOpTest<LessEqual>(0, 0, true);
BinaryOpTest<EqualTo>(true, true, true);
BinaryOpTest<EqualTo>(true, false, false);
BinaryOpTest<EqualTo>(false, true, false);
BinaryOpTest<EqualTo>(false, false, true);
BinaryOpTest<NotEqualTo>(true, true, false);
BinaryOpTest<NotEqualTo>(true, false, true);
BinaryOpTest<NotEqualTo>(false, true, true);
BinaryOpTest<NotEqualTo>(false, false, false);
AZStd::string string0("a string");
AZStd::string string1("b string");
BinaryOpTest<EqualTo>(string1, string1, true);
BinaryOpTest<EqualTo>(string1, string0, false);
BinaryOpTest<EqualTo>(string0, string1, false);
BinaryOpTest<EqualTo>(string0, string0, true);
BinaryOpTest<NotEqualTo>(string1, string1, false);
BinaryOpTest<NotEqualTo>(string1, string0, true);
BinaryOpTest<NotEqualTo>(string0, string1, true);
BinaryOpTest<NotEqualTo>(string0, string0, false);
BinaryOpTest<Greater>(string1, string1, false);
BinaryOpTest<Greater>(string1, string0, true);
BinaryOpTest<Greater>(string0, string1, false);
BinaryOpTest<Greater>(string0, string0, false);
BinaryOpTest<GreaterEqual>(string1, string1, true);
BinaryOpTest<GreaterEqual>(string1, string0, true);
BinaryOpTest<GreaterEqual>(string0, string1, false);
BinaryOpTest<GreaterEqual>(string0, string0, true);
BinaryOpTest<Less>(string1, string1, false);
BinaryOpTest<Less>(string1, string0, false);
BinaryOpTest<Less>(string0, string1, true);
BinaryOpTest<Less>(string0, string0, false);
BinaryOpTest<LessEqual>(string1, string1, true);
BinaryOpTest<LessEqual>(string1, string0, false);
BinaryOpTest<LessEqual>(string0, string1, true);
BinaryOpTest<LessEqual>(string0, string0, true);
const AZ::Vector3 vectorOne(1.0f, 1.0f, 1.0f);
const AZ::Vector3 vectorZero(0.0f, 0.0f, 0.0f);
BinaryOpTest<EqualTo>(vectorOne, vectorOne, true);
BinaryOpTest<EqualTo>(vectorOne, vectorZero, false);
BinaryOpTest<EqualTo>(vectorZero, vectorOne, false);
BinaryOpTest<EqualTo>(vectorZero, vectorZero, true);
BinaryOpTest<NotEqualTo>(vectorOne, vectorOne, false);
BinaryOpTest<NotEqualTo>(vectorOne, vectorZero, true);
BinaryOpTest<NotEqualTo>(vectorZero, vectorOne, true);
BinaryOpTest<NotEqualTo>(vectorZero, vectorZero, false);
const TestBehaviorContextObject zero(0);
const TestBehaviorContextObject one(1);
const TestBehaviorContextObject otherOne(1);
BinaryOpTest<EqualTo>(one, one, true);
BinaryOpTest<EqualTo>(one, zero, false);
BinaryOpTest<EqualTo>(zero, one, false);
BinaryOpTest<EqualTo>(zero, zero, true);
BinaryOpTest<NotEqualTo>(one, one, false);
BinaryOpTest<NotEqualTo>(one, zero, true);
BinaryOpTest<NotEqualTo>(zero, one, true);
BinaryOpTest<NotEqualTo>(zero, zero, false);
BinaryOpTest<Greater>(one, one, false);
BinaryOpTest<Greater>(one, zero, true);
BinaryOpTest<Greater>(zero, one, false);
BinaryOpTest<Greater>(zero, zero, false);
BinaryOpTest<GreaterEqual>(one, one, true);
BinaryOpTest<GreaterEqual>(one, zero, true);
BinaryOpTest<GreaterEqual>(zero, one, false);
BinaryOpTest<GreaterEqual>(zero, zero, true);
BinaryOpTest<Less>(one, one, false);
BinaryOpTest<Less>(one, zero, false);
BinaryOpTest<Less>(zero, one, true);
BinaryOpTest<Less>(zero, zero, false);
BinaryOpTest<LessEqual>(one, one, true);
BinaryOpTest<LessEqual>(one, zero, false);
BinaryOpTest<LessEqual>(zero, one, true);
BinaryOpTest<LessEqual>(zero, zero, true);
BinaryOpTest<EqualTo>(one, otherOne, true);
BinaryOpTest<EqualTo>(otherOne, one, true);
BinaryOpTest<NotEqualTo>(one, otherOne, false);
BinaryOpTest<NotEqualTo>(otherOne, one, false);
BinaryOpTest<Greater>(one, otherOne, false);
BinaryOpTest<Greater>(otherOne, one, false);
BinaryOpTest<GreaterEqual>(one, otherOne, true);
BinaryOpTest<GreaterEqual>(otherOne, one, true);
BinaryOpTest<Less>(one, otherOne, false);
BinaryOpTest<Less>(otherOne, one, false);
BinaryOpTest<LessEqual>(one, otherOne, true);
BinaryOpTest<LessEqual>(otherOne, one, true);
// force failures, to verify crash proofiness
BinaryOpTest<EqualTo>(one, zero, false, true);
BinaryOpTest<NotEqualTo>(one, zero, true, true);
BinaryOpTest<Greater>(one, zero, true, true);
BinaryOpTest<GreaterEqual>(one, zero, true, true);
BinaryOpTest<Less>(one, zero, false, true);
BinaryOpTest<LessEqual>(one, zero, false, true);
m_serializeContext->EnableRemoveReflection();
m_behaviorContext->EnableRemoveReflection();
TestBehaviorContextObject::Reflect(m_serializeContext);
TestBehaviorContextObject::Reflect(m_behaviorContext);
m_serializeContext->DisableRemoveReflection();
m_behaviorContext->DisableRemoveReflection();
}
TEST_F(ScriptCanvasTestFixture, EntityRefTest)
{
using namespace ScriptCanvas;
using namespace ScriptCanvas::Nodes;
// Fake "world" entities
AZ::Entity first("First");
first.CreateComponent<ScriptCanvasTests::TestComponent>();
first.Init();
first.Activate();
AZ::Entity second("Second");
second.CreateComponent<ScriptCanvasTests::TestComponent>();
second.Init();
second.Activate();
// Script Canvas Graph
Graph* graph = nullptr;
SystemRequestBus::BroadcastResult(graph, &SystemRequests::MakeGraph);
EXPECT_TRUE(graph != nullptr);
m_entityContext.AddEntity(first.GetId());
m_entityContext.AddEntity(second.GetId());
m_entityContext.AddEntity(graph->GetEntityId());
graph->GetEntity()->SetName("Graph Owner Entity");
graph->GetEntity()->CreateComponent<ScriptCanvasTests::TestComponent>();
graph->GetEntity()->Init();
const AZ::EntityId& graphEntityId = graph->GetEntityId();
const ScriptCanvasId& graphUniqueId = graph->GetScriptCanvasId();
AZ::EntityId startID;
CreateTestNode<Nodes::Core::Start>(graphUniqueId, startID);
// EntityRef node to some specific entity #1
AZ::EntityId selfEntityIdNode;
auto selfEntityRef = CreateTestNode<Nodes::Entity::EntityRef>(graphUniqueId, selfEntityIdNode);
selfEntityRef->SetEntityRef(first.GetId());
// EntityRef node to some specific entity #2
AZ::EntityId otherEntityIdNode;
auto otherEntityRef = CreateTestNode<Nodes::Entity::EntityRef>(graphUniqueId, otherEntityIdNode);
otherEntityRef->SetEntityRef(second.GetId());
// Explicitly set an EntityRef node with this graph's entity Id.
AZ::EntityId graphEntityIdNode;
auto graphEntityRef = CreateTestNode<Nodes::Entity::EntityRef>(graphUniqueId, graphEntityIdNode);
graphEntityRef->SetEntityRef(graph->GetEntity()->GetId());
// First test: directly set an entity Id on the EntityID: 0 slot
AZ::EntityId eventAid;
Nodes::Core::Method* nodeA = CreateTestNode<Nodes::Core::Method>(graphUniqueId, eventAid);
nodeA->InitializeEvent({ {} }, "EntityRefTestEventBus", "TestEvent");
if (auto entityId = ModInput_UNIT_TEST<AZ::EntityId>(nodeA, "EntityID: 0"))
{
*entityId = first.GetId();
}
// Second test: Will connect the slot to an EntityRef node
AZ::EntityId eventBid;
Nodes::Core::Method* nodeB = CreateTestNode<Nodes::Core::Method>(graphUniqueId, eventBid);
nodeB->InitializeEvent({ {} }, "EntityRefTestEventBus", "TestEvent");
// Third test: Set the slot's EntityId: 0 to GraphOwnerId, this should result in the same Id as graph->GetEntityId()
AZ::EntityId eventCid;
Nodes::Core::Method* nodeC = CreateTestNode<Nodes::Core::Method>(graphUniqueId, eventCid);
nodeC->InitializeEvent({ {} }, "EntityRefTestEventBus", "TestEvent");
if (auto entityId = ModInput_UNIT_TEST<AZ::EntityId>(nodeC, "EntityID: 0"))
{
*entityId = ScriptCanvas::GraphOwnerId;
}
// True
AZ::EntityId trueNodeId;
CreateDataNode<Data::BooleanType>(graphUniqueId, true, trueNodeId);
// False
AZ::EntityId falseNodeId;
CreateDataNode<Data::BooleanType>(graphUniqueId, false, falseNodeId);
// Start -> TestEvent
// O EntityId: 0 (not connected, it was set directly on the slot)
// EntityRef: first -O EntityId: 1
// False -O Boolean: 2
EXPECT_TRUE(Connect(*graph, startID, "Out", eventAid, "In"));
EXPECT_TRUE(Connect(*graph, eventAid, "EntityID: 1", selfEntityIdNode, "Get"));
EXPECT_TRUE(Connect(*graph, eventAid, "Boolean: 2", falseNodeId, "Get"));
// Start -> TestEvent
// EntityRef: second -O EntityId: 0
// EntityRef: second -O EntityId: 1
// False -O Boolean: 2
EXPECT_TRUE(Connect(*graph, startID, "Out", eventBid, "In"));
EXPECT_TRUE(Connect(*graph, eventBid, "EntityID: 0", otherEntityIdNode, "Get"));
EXPECT_TRUE(Connect(*graph, eventBid, "EntityID: 1", otherEntityIdNode, "Get"));
EXPECT_TRUE(Connect(*graph, eventBid, "Boolean: 2", falseNodeId, "Get"));
// Start -> TestEvent
// -O EntityId: 0 (not connected, slot is set to GraphOwnerId)
// graphEntityIdNode -O EntityId: 1
// True -O Boolean: 2
EXPECT_TRUE(Connect(*graph, startID, "Out", eventCid, "In"));
EXPECT_TRUE(Connect(*graph, eventCid, "EntityID: 1", graphEntityIdNode, "Get"));
EXPECT_TRUE(Connect(*graph, eventCid, "Boolean: 2", trueNodeId, "Get"));
// Execute the graph
{
ScriptCanvasEditor::ScopedOutputSuppression suppressOutput;
graph->GetEntity()->Activate();
}
ReportErrors(graph);
delete graph->GetEntity();
}
const int k_executionCount = 998;
TEST_F(ScriptCanvasTestFixture, ExecutionLength)
{
using namespace ScriptCanvas;
Graph* graph(nullptr);
SystemRequestBus::BroadcastResult(graph, &SystemRequests::MakeGraph);
EXPECT_TRUE(graph != nullptr);
graph->GetEntity()->Init();
const AZ::EntityId& graphEntityID = graph->GetEntityId();
const ScriptCanvasId& graphUniqueId = graph->GetScriptCanvasId();
AZ::EntityId startID;
CreateTestNode<Nodes::Core::Start>(graphUniqueId, startID);
AZ::EntityId previousID = startID;
for (int i = 0; i < k_executionCount; ++i)
{
AZ::EntityId printNodeID;
TestResult* printNode = CreateTestNode<TestResult>(graphUniqueId, printNodeID);
SetInput_UNIT_TEST<int>(printNode, "Value", i);
EXPECT_TRUE(Connect(*graph, previousID, "Out", printNodeID, "In"));
previousID = printNodeID;
}
AZ::Entity* graphEntity = graph->GetEntity();
{
ScriptCanvasEditor::ScopedOutputSuppression suppressOutput;
graphEntity->Activate();
}
ReportErrors(graph);
graphEntity->Deactivate();
delete graphEntity;
}
TEST_F(ScriptCanvasTestFixture, AnyNode)
{
RunUnitTestGraph("LY_SC_UnitTest_Any");
}
Reference in New Issue View Git Blame Copy Permalink