alexpete
1022 lines
43 KiB
C++
1022 lines
43 KiB
C++
/*
|
|
* 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 "precompiled.h"
|
|
|
|
#include <Tests/ScriptCanvasTestFixture.h>
|
|
|
|
using namespace ScriptCanvasTests;
|
|
|
|
TEST_F(ScriptCanvasTestFixture, StringOperations)
|
|
{
|
|
RETURN_IF_TEST_BODIES_ARE_DISABLED(TEST_BODY_DEFAULT);
|
|
using namespace ScriptCanvas;
|
|
|
|
// 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 AZ::EntityId& graphUniqueId = graph->GetUniqueId();
|
|
|
|
// Make the nodes.
|
|
|
|
// Start
|
|
AZ::Entity* startEntity{ aznew AZ::Entity };
|
|
startEntity->Init();
|
|
AZ::EntityId startNodeID{ startEntity->GetId() };
|
|
SystemRequestBus::Broadcast(&SystemRequests::CreateNodeOnEntity, startNodeID, graphUniqueId, Nodes::Core::Start::TYPEINFO_Uuid());
|
|
|
|
AZ::Uuid typeID = azrtti_typeid<AZStd::string>();
|
|
const AZStd::string string0("abcd");
|
|
AZ::EntityId string0NodeID;
|
|
auto string0NodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, string0NodeID);
|
|
string0NodePtr->SetInput_UNIT_TEST("Set", string0);
|
|
|
|
// String 1
|
|
const AZStd::string string1("ef");
|
|
AZ::EntityId string1NodeID;
|
|
auto string1NodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, string1NodeID);
|
|
string1NodePtr->SetInput_UNIT_TEST("Set", string1);
|
|
|
|
// String 2
|
|
const AZStd::string string2(" abcd");
|
|
AZ::EntityId string2NodeID;
|
|
auto string2NodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, string2NodeID);
|
|
string2NodePtr->SetInput_UNIT_TEST("Set", string2);
|
|
|
|
// String 3
|
|
const AZStd::string string3("abcd ");
|
|
AZ::EntityId string3NodeID;
|
|
auto string3NodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, string3NodeID);
|
|
string3NodePtr->SetInput_UNIT_TEST("Set", string3);
|
|
|
|
// String 4
|
|
const AZStd::string string4("abcd/ef/ghi");
|
|
AZ::EntityId string4NodeID;
|
|
auto string4NodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, string4NodeID);
|
|
string4NodePtr->SetInput_UNIT_TEST("Set", string4);
|
|
|
|
// String 5
|
|
const AZStd::string string5("ab");
|
|
AZ::EntityId string5NodeID;
|
|
auto string5NodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, string5NodeID);
|
|
string5NodePtr->SetInput_UNIT_TEST("Set", string5);
|
|
|
|
// String 6
|
|
const AZStd::string string6("ABCD");
|
|
AZ::EntityId string6NodeID;
|
|
auto string6NodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, string6NodeID);
|
|
string6NodePtr->SetInput_UNIT_TEST("Set", string6);
|
|
|
|
// String 7
|
|
const AZStd::string string7("/");
|
|
AZ::EntityId string7NodeID;
|
|
auto string7NodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, string7NodeID);
|
|
string7NodePtr->SetInput_UNIT_TEST("Set", string7);
|
|
|
|
//Int 0
|
|
AZ::EntityId int0NodeID;
|
|
auto int0NodePtr = CreateTestNode<ScriptCanvas::Nodes::Math::Number>(graphUniqueId, int0NodeID);
|
|
int0NodePtr->SetInput_UNIT_TEST("Set", 0);
|
|
|
|
// Int 1
|
|
AZ::EntityId int1NodeID;
|
|
auto int1NodePtr = CreateTestNode<ScriptCanvas::Nodes::Math::Number>(graphUniqueId, int1NodeID);
|
|
int1NodePtr->SetInput_UNIT_TEST("Set", 2);
|
|
|
|
// Vector 0
|
|
const AZStd::vector<AZStd::string> vector0({ AZStd::string("abcd"), AZStd::string("ef") });
|
|
AZ::EntityId vector0NodeID;
|
|
auto vector0NodePtr = CreateTestObjectNode(graphUniqueId, vector0NodeID, azrtti_typeid<AZStd::vector<AZStd::string>>());
|
|
vector0NodePtr->SetInput_UNIT_TEST("Set", vector0);
|
|
|
|
// LengthResult
|
|
AZ::EntityId lengthResultNodeID;
|
|
auto lengthResultNodePtr = CreateTestNode<ScriptCanvas::Nodes::Math::Number>(graphUniqueId, lengthResultNodeID);
|
|
|
|
// FindResult
|
|
AZ::EntityId findResultNodeID;
|
|
auto findResultNodePtr = CreateTestNode<ScriptCanvas::Nodes::Math::Number>(graphUniqueId, findResultNodeID);
|
|
|
|
// SubstringResult
|
|
AZ::EntityId substringResultNodeID;
|
|
auto* substringResultNodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, substringResultNodeID);
|
|
|
|
// ReplaceResult
|
|
AZ::EntityId replaceResultNodeID;
|
|
auto* replaceResultNodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, replaceResultNodeID);
|
|
|
|
// ReplaceByIndexResult
|
|
AZ::EntityId replaceByIndexResultNodeID;
|
|
auto* replaceByIndexResultNodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, replaceByIndexResultNodeID);
|
|
|
|
// AddResult
|
|
AZ::EntityId addResultNodeID;
|
|
auto* addResultNodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, addResultNodeID);
|
|
|
|
// TrimLeftResult
|
|
AZ::EntityId trimLeftResultNodeID;
|
|
auto* trimLeftResultNodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, trimLeftResultNodeID);
|
|
|
|
// TrimRightResult
|
|
AZ::EntityId trimRightResultNodeID;
|
|
auto* trimRightResultNodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, trimRightResultNodeID);
|
|
|
|
// ToLowerResult
|
|
AZ::EntityId toLowerResultNodeID;
|
|
auto* toLowerResultNodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, toLowerResultNodeID);
|
|
|
|
// ToUpperResult
|
|
AZ::EntityId toUpperResultNodeID;
|
|
auto* toUpperResultNodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, toUpperResultNodeID);
|
|
|
|
// JoinResult
|
|
AZ::EntityId joinResultNodeID;
|
|
auto* joinResultNodePtr = CreateTestNode<ScriptCanvas::Nodes::Core::String>(graphUniqueId, joinResultNodeID);
|
|
|
|
// SplitResult
|
|
AZ::EntityId splitResultNodeID;
|
|
auto* splitResultNodePtr = CreateTestObjectNode(graphUniqueId, splitResultNodeID, azrtti_typeid<AZStd::vector<AZStd::string>>());
|
|
|
|
const AZStd::string stringClassName("AZStd::basic_string<char, AZStd::char_traits<char>, allocator>");
|
|
|
|
// Length
|
|
AZ::EntityId lengthNodeID = CreateClassFunctionNode(graphUniqueId, stringClassName, AZStd::string("Length"));
|
|
|
|
//Find
|
|
AZ::EntityId findNodeID = CreateClassFunctionNode(graphUniqueId, stringClassName, AZStd::string("Find"));
|
|
|
|
//Substring
|
|
AZ::EntityId substringNodeID = CreateClassFunctionNode(graphUniqueId, stringClassName, AZStd::string("Substring"));
|
|
|
|
//Replace
|
|
AZ::EntityId replaceNodeID = CreateClassFunctionNode(graphUniqueId, stringClassName, AZStd::string("Replace"));
|
|
|
|
//ReplaceByIndex
|
|
AZ::EntityId replaceByIndexNodeID = CreateClassFunctionNode(graphUniqueId, stringClassName, AZStd::string("ReplaceByIndex"));
|
|
|
|
//Add
|
|
AZ::EntityId addNodeID = CreateClassFunctionNode(graphUniqueId, stringClassName, AZStd::string("Add"));
|
|
|
|
//TrimLeft
|
|
AZ::EntityId trimLeftNodeID = CreateClassFunctionNode(graphUniqueId, stringClassName, AZStd::string("TrimLeft"));
|
|
|
|
//TrimRight
|
|
AZ::EntityId trimRightNodeID = CreateClassFunctionNode(graphUniqueId, stringClassName, AZStd::string("TrimRight"));
|
|
|
|
//ToLower
|
|
AZ::EntityId toLowerNodeID = CreateClassFunctionNode(graphUniqueId, stringClassName, AZStd::string("ToLower"));
|
|
|
|
//ToUpper
|
|
AZ::EntityId toUpperNodeID = CreateClassFunctionNode(graphUniqueId, stringClassName, AZStd::string("ToUpper"));
|
|
|
|
//Join
|
|
AZ::EntityId joinNodeID = CreateClassFunctionNode(graphUniqueId, stringClassName, AZStd::string("Join"));
|
|
|
|
//Split
|
|
AZ::EntityId splitNodeID = CreateClassFunctionNode(graphUniqueId, stringClassName, AZStd::string("Split"));
|
|
|
|
// Flow
|
|
ScriptCanvas::SlotId firstSlotId;
|
|
ScriptCanvas::SlotId secondSlotId;
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, startNodeID, &NodeRequests::GetSlotId, "Out");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, lengthNodeID, &NodeRequests::GetSlotId, "In");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(startNodeID, firstSlotId, lengthNodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, lengthNodeID, &NodeRequests::GetSlotId, "Out");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, findNodeID, &NodeRequests::GetSlotId, "In");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(lengthNodeID, firstSlotId, findNodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, findNodeID, &NodeRequests::GetSlotId, "Out");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, substringNodeID, &NodeRequests::GetSlotId, "In");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(findNodeID, firstSlotId, substringNodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, substringNodeID, &NodeRequests::GetSlotId, "Out");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, addNodeID, &NodeRequests::GetSlotId, "In");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(substringNodeID, firstSlotId, addNodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, addNodeID, &NodeRequests::GetSlotId, "Out");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, trimLeftNodeID, &NodeRequests::GetSlotId, "In");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(addNodeID, firstSlotId, trimLeftNodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, trimLeftNodeID, &NodeRequests::GetSlotId, "Out");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, trimRightNodeID, &NodeRequests::GetSlotId, "In");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(trimLeftNodeID, firstSlotId, trimRightNodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, trimRightNodeID, &NodeRequests::GetSlotId, "Out");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, toLowerNodeID, &NodeRequests::GetSlotId, "In");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(trimRightNodeID, firstSlotId, toLowerNodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, toLowerNodeID, &NodeRequests::GetSlotId, "Out");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, toUpperNodeID, &NodeRequests::GetSlotId, "In");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(toLowerNodeID, firstSlotId, toUpperNodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, toUpperNodeID, &NodeRequests::GetSlotId, "Out");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, joinNodeID, &NodeRequests::GetSlotId, "In");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(toUpperNodeID, firstSlotId, joinNodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, joinNodeID, &NodeRequests::GetSlotId, "Out");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, splitNodeID, &NodeRequests::GetSlotId, "In");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(joinNodeID, firstSlotId, splitNodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, splitNodeID, &NodeRequests::GetSlotId, "Out");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, replaceNodeID, &NodeRequests::GetSlotId, "In");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(splitNodeID, firstSlotId, replaceNodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, replaceNodeID, &NodeRequests::GetSlotId, "Out");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, replaceByIndexNodeID, &NodeRequests::GetSlotId, "In");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(replaceNodeID, firstSlotId, replaceByIndexNodeID, secondSlotId));
|
|
|
|
// Length
|
|
NodeRequestBus::EventResult(firstSlotId, lengthNodeID, &NodeRequests::GetSlotId, "String: 0");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string0NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(lengthNodeID, firstSlotId, string0NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, lengthNodeID, &NodeRequests::GetSlotId, "Result: Number");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, lengthResultNodeID, &NodeRequests::GetSlotId, "Set");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(lengthNodeID, firstSlotId, lengthResultNodeID, secondSlotId));
|
|
|
|
// Find
|
|
NodeRequestBus::EventResult(firstSlotId, findNodeID, &NodeRequests::GetSlotId, "String: 0");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string0NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(findNodeID, firstSlotId, string0NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, findNodeID, &NodeRequests::GetSlotId, "String: 1");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string5NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(findNodeID, firstSlotId, string5NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, findNodeID, &NodeRequests::GetSlotId, "Number: 2");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, int0NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(findNodeID, firstSlotId, int0NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, findNodeID, &NodeRequests::GetSlotId, "Result: Number");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, findResultNodeID, &NodeRequests::GetSlotId, "Set");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(findNodeID, firstSlotId, findResultNodeID, secondSlotId));
|
|
|
|
// Substring
|
|
NodeRequestBus::EventResult(firstSlotId, substringNodeID, &NodeRequests::GetSlotId, "String: 0");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string0NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(substringNodeID, firstSlotId, string0NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, substringNodeID, &NodeRequests::GetSlotId, "Number: 1");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, int0NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(substringNodeID, firstSlotId, int0NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, substringNodeID, &NodeRequests::GetSlotId, "Number: 2");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, int1NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(substringNodeID, firstSlotId, int1NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, substringNodeID, &NodeRequests::GetSlotId, "Result: String");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, substringResultNodeID, &NodeRequests::GetSlotId, "Set");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(substringNodeID, firstSlotId, substringResultNodeID, secondSlotId));
|
|
|
|
// Replace
|
|
NodeRequestBus::EventResult(firstSlotId, replaceNodeID, &NodeRequests::GetSlotId, "String: 0");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string0NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(replaceNodeID, firstSlotId, string0NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, replaceNodeID, &NodeRequests::GetSlotId, "String: 1");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string5NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(replaceNodeID, firstSlotId, string5NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, replaceNodeID, &NodeRequests::GetSlotId, "String: 2");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string1NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(replaceNodeID, firstSlotId, string1NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, replaceNodeID, &NodeRequests::GetSlotId, "Result: String");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, replaceResultNodeID, &NodeRequests::GetSlotId, "Set");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(replaceNodeID, firstSlotId, replaceResultNodeID, secondSlotId));
|
|
|
|
//ReplaceByIndex
|
|
NodeRequestBus::EventResult(firstSlotId, replaceByIndexNodeID, &NodeRequests::GetSlotId, "String: 0");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string0NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(replaceByIndexNodeID, firstSlotId, string0NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, replaceByIndexNodeID, &NodeRequests::GetSlotId, "Number: 1");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, int0NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(replaceByIndexNodeID, firstSlotId, int0NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, replaceByIndexNodeID, &NodeRequests::GetSlotId, "Number: 2");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, int1NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(replaceByIndexNodeID, firstSlotId, int1NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, replaceByIndexNodeID, &NodeRequests::GetSlotId, "String: 3");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string5NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(replaceByIndexNodeID, firstSlotId, string5NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, replaceByIndexNodeID, &NodeRequests::GetSlotId, "Result: String");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, replaceByIndexResultNodeID, &NodeRequests::GetSlotId, "Set");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(replaceByIndexNodeID, firstSlotId, replaceByIndexResultNodeID, secondSlotId));
|
|
|
|
// Add
|
|
NodeRequestBus::EventResult(firstSlotId, addNodeID, &NodeRequests::GetSlotId, "String: 0");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string0NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(addNodeID, firstSlotId, string0NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, addNodeID, &NodeRequests::GetSlotId, "String: 1");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string1NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(addNodeID, firstSlotId, string1NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, addNodeID, &NodeRequests::GetSlotId, "Result: String");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, addResultNodeID, &NodeRequests::GetSlotId, "Set");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(addNodeID, firstSlotId, addResultNodeID, secondSlotId));
|
|
|
|
//TrimLeft
|
|
NodeRequestBus::EventResult(firstSlotId, trimLeftNodeID, &NodeRequests::GetSlotId, "String: 0");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string2NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(trimLeftNodeID, firstSlotId, string2NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, trimLeftNodeID, &NodeRequests::GetSlotId, "Result: String");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, trimLeftResultNodeID, &NodeRequests::GetSlotId, "Set");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(trimLeftNodeID, firstSlotId, trimLeftResultNodeID, secondSlotId));
|
|
|
|
// TrimRight
|
|
NodeRequestBus::EventResult(firstSlotId, trimRightNodeID, &NodeRequests::GetSlotId, "String: 0");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string3NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(trimRightNodeID, firstSlotId, string3NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, trimRightNodeID, &NodeRequests::GetSlotId, "Result: String");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, trimRightResultNodeID, &NodeRequests::GetSlotId, "Set");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(trimRightNodeID, firstSlotId, trimRightResultNodeID, secondSlotId));
|
|
|
|
// ToLower
|
|
NodeRequestBus::EventResult(firstSlotId, toLowerNodeID, &NodeRequests::GetSlotId, "String: 0");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string6NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(toLowerNodeID, firstSlotId, string6NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, toLowerNodeID, &NodeRequests::GetSlotId, "Result: String");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, toLowerResultNodeID, &NodeRequests::GetSlotId, "Set");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(toLowerNodeID, firstSlotId, toLowerResultNodeID, secondSlotId));
|
|
|
|
// ToUpper
|
|
NodeRequestBus::EventResult(firstSlotId, toUpperNodeID, &NodeRequests::GetSlotId, "String: 0");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string0NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(toUpperNodeID, firstSlotId, string0NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, toUpperNodeID, &NodeRequests::GetSlotId, "Result: String");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, toUpperResultNodeID, &NodeRequests::GetSlotId, "Set");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(toUpperNodeID, firstSlotId, toUpperResultNodeID, secondSlotId));
|
|
|
|
// Join
|
|
NodeRequestBus::EventResult(firstSlotId, joinNodeID, &NodeRequests::GetSlotId, "AZStd::vector<AZStd::basic_string<char, AZStd::char_traits<char>, allocator>, allocator>: 0");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, vector0NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(joinNodeID, firstSlotId, vector0NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, joinNodeID, &NodeRequests::GetSlotId, "String: 1");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string7NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(joinNodeID, firstSlotId, string7NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, joinNodeID, &NodeRequests::GetSlotId, "Result: String");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, joinResultNodeID, &NodeRequests::GetSlotId, "Set");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(joinNodeID, firstSlotId, joinResultNodeID, secondSlotId));
|
|
|
|
// Split
|
|
NodeRequestBus::EventResult(firstSlotId, splitNodeID, &NodeRequests::GetSlotId, "String: 0");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string4NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(splitNodeID, firstSlotId, string4NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, splitNodeID, &NodeRequests::GetSlotId, "String: 1");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, string7NodeID, &NodeRequests::GetSlotId, "Get");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(splitNodeID, firstSlotId, string7NodeID, secondSlotId));
|
|
|
|
NodeRequestBus::EventResult(firstSlotId, splitNodeID, &NodeRequests::GetSlotId, "Result: AZStd::vector<AZStd::basic_string<char, AZStd::char_traits<char>, allocator>, allocator>");
|
|
EXPECT_TRUE(firstSlotId.IsValid());
|
|
NodeRequestBus::EventResult(secondSlotId, splitResultNodeID, &NodeRequests::GetSlotId, "Set");
|
|
EXPECT_TRUE(secondSlotId.IsValid());
|
|
EXPECT_TRUE(graph->Connect(splitNodeID, firstSlotId, splitResultNodeID, secondSlotId));
|
|
|
|
graph->SetStartNode(startNodeID);
|
|
graph->GetEntity()->Activate();
|
|
EXPECT_FALSE(graph->IsInErrorState());
|
|
|
|
if (lengthResultNodePtr)
|
|
{
|
|
if (auto result = lengthResultNodePtr->GetInput_UNIT_TEST<int>("Set"))
|
|
{
|
|
EXPECT_EQ(4, *result);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
if (findResultNodePtr)
|
|
{
|
|
if (auto result = findResultNodePtr->GetInput_UNIT_TEST<int>("Set"))
|
|
{
|
|
EXPECT_EQ(0, *result);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
if (substringResultNodePtr)
|
|
{
|
|
auto resultValue = substringResultNodePtr->GetInput_UNIT_TEST<Data::StringType>("Set");
|
|
if (resultValue)
|
|
{
|
|
EXPECT_EQ("ab", *resultValue);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
if (replaceResultNodePtr)
|
|
{
|
|
auto resultValue = replaceResultNodePtr->GetInput_UNIT_TEST<Data::StringType>("Set");
|
|
if (resultValue)
|
|
{
|
|
EXPECT_EQ("efcd", *resultValue);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
if (replaceByIndexResultNodePtr)
|
|
{
|
|
auto resultValue = replaceByIndexResultNodePtr->GetInput_UNIT_TEST<Data::StringType>("Set");
|
|
if (resultValue)
|
|
{
|
|
EXPECT_EQ("abd", *resultValue);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
if (addResultNodePtr)
|
|
{
|
|
auto resultValue = addResultNodePtr->GetInput_UNIT_TEST<Data::StringType>("Set");
|
|
if (resultValue)
|
|
{
|
|
EXPECT_EQ("abcdef", *resultValue);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
if (trimLeftResultNodePtr)
|
|
{
|
|
auto resultValue = trimLeftResultNodePtr->GetInput_UNIT_TEST<Data::StringType>("Set");
|
|
if (resultValue)
|
|
{
|
|
EXPECT_EQ("abcd", *resultValue);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
if (trimRightResultNodePtr)
|
|
{
|
|
auto resultValue = trimRightResultNodePtr->GetInput_UNIT_TEST<Data::StringType>("Set");
|
|
if (resultValue)
|
|
{
|
|
EXPECT_EQ("abcd", *resultValue);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
if (toLowerResultNodePtr)
|
|
{
|
|
auto resultValue = toLowerResultNodePtr->GetInput_UNIT_TEST<Data::StringType>("Set");
|
|
if (resultValue)
|
|
{
|
|
EXPECT_EQ("abcd", *resultValue);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
if (toUpperResultNodePtr)
|
|
{
|
|
auto resultValue = toUpperResultNodePtr->GetInput_UNIT_TEST<Data::StringType>("Set");
|
|
if (resultValue)
|
|
{
|
|
EXPECT_EQ("ABCD", *resultValue);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
if (joinResultNodePtr)
|
|
{
|
|
auto resultValue = joinResultNodePtr->GetInput_UNIT_TEST<Data::StringType>("Set");
|
|
if (resultValue)
|
|
{
|
|
EXPECT_EQ("abcd/ef", *resultValue);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
if (splitResultNodePtr)
|
|
{
|
|
auto result = splitResultNodePtr->GetInput_UNIT_TEST<AZStd::vector<AZStd::string>>("Set");
|
|
if (result)
|
|
{
|
|
AZStd::vector<AZStd::string> ans = { "abcd", "ef", "ghi" };
|
|
EXPECT_EQ(ans, *result);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
graph->GetEntity()->Deactivate();
|
|
delete graph;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
TEST_F(ScriptCanvasTestFixture, SimplestNotTrue)
|
|
{
|
|
RETURN_IF_TEST_BODIES_ARE_DISABLED(TEST_BODY_DEFAULT);
|
|
|
|
using namespace ScriptCanvas;
|
|
|
|
const bool s_value = true;
|
|
|
|
Graph* graph = nullptr;
|
|
SystemRequestBus::BroadcastResult(graph, &SystemRequests::MakeGraph);
|
|
EXPECT_TRUE(graph != nullptr);
|
|
|
|
AZ::Entity* graphEntity = graph->GetEntity();
|
|
graphEntity->Init();
|
|
|
|
const AZ::EntityId& graphEntityId = graph->GetEntityId();
|
|
const AZ::EntityId& graphUniqueId = graph->GetUniqueId();
|
|
|
|
// Nodes
|
|
AZ::EntityId startNodeId;
|
|
Nodes::Core::Start* startNode = CreateTestNode<Nodes::Core::Start>(graphUniqueId, startNodeId);
|
|
ASSERT_TRUE(startNode != nullptr);
|
|
|
|
AZ::EntityId booleanNodeId;
|
|
Nodes::Logic::Boolean* booleanNode = CreateTestNode<Nodes::Logic::Boolean>(graphUniqueId, booleanNodeId);
|
|
ASSERT_TRUE(booleanNode != nullptr);
|
|
booleanNode->SetInput_UNIT_TEST("Set", s_value);
|
|
|
|
AZ::EntityId printNodeId;
|
|
Print* printNode = CreateTestNode<Print>(graphUniqueId, printNodeId);
|
|
ASSERT_TRUE(printNode != nullptr);
|
|
|
|
AZ::EntityId notNodeId;
|
|
Nodes::Logic::Not* notNode = CreateTestNode<Nodes::Logic::Not>(graphUniqueId, notNodeId);
|
|
ASSERT_TRUE(notNode != nullptr);
|
|
|
|
AZ::EntityId notNotNodeId;
|
|
Nodes::Logic::Not* notNotNode = CreateTestNode<Nodes::Logic::Not>(graphUniqueId, notNotNodeId);
|
|
ASSERT_TRUE(notNotNode != nullptr);
|
|
|
|
AZ::EntityId printNode2Id;
|
|
Print* printNode2 = CreateTestNode<Print>(graphUniqueId, printNode2Id);
|
|
ASSERT_TRUE(printNode2 != nullptr);
|
|
|
|
// Start -> Not (false) => Print (true) -> Not (true) => Print
|
|
// / \_________________________/
|
|
// Boolean /
|
|
EXPECT_TRUE(Connect(*graph, startNodeId, "Out", notNodeId, Nodes::UnaryOperator::k_evaluateName));
|
|
|
|
EXPECT_TRUE(Connect(*graph, notNodeId, Nodes::UnaryOperator::k_valueName, booleanNodeId, PureData::k_getThis));
|
|
|
|
EXPECT_TRUE(Connect(*graph, notNodeId, Nodes::UnaryOperator::k_onTrue, printNodeId, "In"));
|
|
EXPECT_TRUE(Connect(*graph, notNodeId, Nodes::UnaryOperator::k_onFalse, printNodeId, "In"));
|
|
EXPECT_TRUE(Connect(*graph, notNodeId, Nodes::UnaryOperator::k_resultName, printNodeId, "Value"));
|
|
|
|
EXPECT_TRUE(Connect(*graph, printNodeId, "Out", notNotNodeId, Nodes::UnaryOperator::k_evaluateName));
|
|
EXPECT_TRUE(Connect(*graph, notNotNodeId, Nodes::UnaryOperator::k_valueName, notNodeId, Nodes::UnaryOperator::k_resultName));
|
|
|
|
EXPECT_TRUE(Connect(*graph, notNotNodeId, Nodes::UnaryOperator::k_onTrue, printNode2Id, "In"));
|
|
EXPECT_TRUE(Connect(*graph, notNotNodeId, Nodes::UnaryOperator::k_onFalse, printNode2Id, "In"));
|
|
EXPECT_TRUE(Connect(*graph, notNotNodeId, Nodes::UnaryOperator::k_resultName, printNode2Id, "Value"));
|
|
|
|
graph->SetStartNode(startNodeId);
|
|
graph->GetEntity()->Activate();
|
|
EXPECT_FALSE(graph->IsInErrorState());
|
|
|
|
// Validate results
|
|
{
|
|
const bool* result = printNode->GetInput_UNIT_TEST<bool>("Value");
|
|
if (result)
|
|
{
|
|
EXPECT_EQ(*result, !s_value);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
{
|
|
const bool* result = printNode2->GetInput_UNIT_TEST<bool>("Value");
|
|
if (result)
|
|
{
|
|
EXPECT_EQ(*result, s_value);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
graph->GetEntity()->Deactivate();
|
|
|
|
delete graph->GetEntity();
|
|
}
|
|
|
|
TEST_F(ScriptCanvasTestFixture, SimplestNotFalse)
|
|
{
|
|
RETURN_IF_TEST_BODIES_ARE_DISABLED(TEST_BODY_DEFAULT);
|
|
|
|
using namespace ScriptCanvas;
|
|
|
|
const bool s_value = false;
|
|
|
|
Graph* graph = nullptr;
|
|
SystemRequestBus::BroadcastResult(graph, &SystemRequests::MakeGraph);
|
|
EXPECT_TRUE(graph != nullptr);
|
|
|
|
AZ::Entity* graphEntity = graph->GetEntity();
|
|
graphEntity->Init();
|
|
|
|
const AZ::EntityId& graphEntityId = graph->GetEntityId();
|
|
const AZ::EntityId& graphUniqueId = graph->GetUniqueId();
|
|
|
|
// Nodes
|
|
AZ::EntityId startNodeId;
|
|
Nodes::Core::Start* startNode = CreateTestNode<Nodes::Core::Start>(graphUniqueId, startNodeId);
|
|
ASSERT_TRUE(startNode != nullptr);
|
|
|
|
AZ::EntityId booleanNodeId;
|
|
Nodes::Logic::Boolean* booleanNode = CreateTestNode<Nodes::Logic::Boolean>(graphUniqueId, booleanNodeId);
|
|
ASSERT_TRUE(booleanNode != nullptr);
|
|
booleanNode->SetInput_UNIT_TEST("Set", s_value);
|
|
|
|
AZ::EntityId printNodeId;
|
|
Print* printNode = CreateTestNode<Print>(graphUniqueId, printNodeId);
|
|
ASSERT_TRUE(printNode != nullptr);
|
|
|
|
AZ::EntityId notNodeId;
|
|
Nodes::Logic::Not* notNode = CreateTestNode<Nodes::Logic::Not>(graphUniqueId, notNodeId);
|
|
ASSERT_TRUE(notNode != nullptr);
|
|
|
|
AZ::EntityId notNotNodeId;
|
|
Nodes::Logic::Not* notNotNode = CreateTestNode<Nodes::Logic::Not>(graphUniqueId, notNotNodeId);
|
|
ASSERT_TRUE(notNotNode != nullptr);
|
|
|
|
AZ::EntityId printNode2Id;
|
|
Print* printNode2 = CreateTestNode<Print>(graphUniqueId, printNode2Id);
|
|
ASSERT_TRUE(printNode2 != nullptr);
|
|
|
|
// Start -> Not (false) => Print (true) -> Not (true) => Print
|
|
// / \_________________________/
|
|
// Boolean /
|
|
EXPECT_TRUE(Connect(*graph, startNodeId, "Out", notNodeId, Nodes::UnaryOperator::k_evaluateName));
|
|
|
|
EXPECT_TRUE(Connect(*graph, notNodeId, Nodes::UnaryOperator::k_valueName, booleanNodeId, PureData::k_getThis));
|
|
|
|
EXPECT_TRUE(Connect(*graph, notNodeId, Nodes::UnaryOperator::k_onTrue, printNodeId, "In"));
|
|
EXPECT_TRUE(Connect(*graph, notNodeId, Nodes::UnaryOperator::k_onFalse, printNodeId, "In"));
|
|
EXPECT_TRUE(Connect(*graph, notNodeId, Nodes::UnaryOperator::k_resultName, printNodeId, "Value"));
|
|
|
|
EXPECT_TRUE(Connect(*graph, printNodeId, "Out", notNotNodeId, Nodes::UnaryOperator::k_evaluateName));
|
|
EXPECT_TRUE(Connect(*graph, notNotNodeId, Nodes::UnaryOperator::k_valueName, notNodeId, Nodes::UnaryOperator::k_resultName));
|
|
|
|
EXPECT_TRUE(Connect(*graph, notNotNodeId, Nodes::UnaryOperator::k_onTrue, printNode2Id, "In"));
|
|
EXPECT_TRUE(Connect(*graph, notNotNodeId, Nodes::UnaryOperator::k_onFalse, printNode2Id, "In"));
|
|
EXPECT_TRUE(Connect(*graph, notNotNodeId, Nodes::UnaryOperator::k_resultName, printNode2Id, "Value"));
|
|
|
|
graph->SetStartNode(startNodeId);
|
|
graph->GetEntity()->Activate();
|
|
EXPECT_FALSE(graph->IsInErrorState());
|
|
|
|
// Validate results
|
|
{
|
|
const bool* result = printNode->GetInput_UNIT_TEST<bool>("Value");
|
|
if (result)
|
|
{
|
|
EXPECT_EQ(*result, !s_value);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
{
|
|
const bool* result = printNode2->GetInput_UNIT_TEST<bool>("Value");
|
|
if (result)
|
|
{
|
|
EXPECT_EQ(*result, s_value);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
graph->GetEntity()->Deactivate();
|
|
|
|
delete graph->GetEntity();
|
|
}
|
|
|
|
TEST_F(ScriptCanvasTestFixture, LogicTest)
|
|
{
|
|
RETURN_IF_TEST_BODIES_ARE_DISABLED(TEST_BODY_DEFAULT);
|
|
|
|
using namespace ScriptCanvas;
|
|
|
|
Graph* graph = nullptr;
|
|
SystemRequestBus::BroadcastResult(graph, &SystemRequests::MakeGraph);
|
|
EXPECT_TRUE(graph != nullptr);
|
|
|
|
AZ::Entity* graphEntity = graph->GetEntity();
|
|
graphEntity->Init();
|
|
|
|
const AZ::EntityId& graphEntityId = graph->GetEntityId();
|
|
const AZ::EntityId& graphUniqueId = graph->GetUniqueId();
|
|
|
|
// Nodes
|
|
AZ::EntityId startNodeId;
|
|
Nodes::Core::Start* startNode = CreateTestNode<Nodes::Core::Start>(graphUniqueId, startNodeId);
|
|
|
|
enum BooleanNodes
|
|
{
|
|
False,
|
|
True
|
|
};
|
|
|
|
AZ::EntityId booleanNodeIds[2];
|
|
Nodes::Logic::Boolean* booleanNodes[2];
|
|
|
|
booleanNodes[BooleanNodes::False] = CreateTestNode<Nodes::Logic::Boolean>(graphUniqueId, booleanNodeIds[BooleanNodes::False]);
|
|
ASSERT_TRUE(booleanNodes[BooleanNodes::False] != nullptr);
|
|
booleanNodes[BooleanNodes::False]->SetInput_UNIT_TEST("Set", false);
|
|
ASSERT_FALSE(*booleanNodes[BooleanNodes::False]->GetInput_UNIT_TEST<bool>("Set"));
|
|
|
|
booleanNodes[BooleanNodes::True] = CreateTestNode<Nodes::Logic::Boolean>(graphUniqueId, booleanNodeIds[BooleanNodes::True]);
|
|
ASSERT_TRUE(booleanNodes[BooleanNodes::True] != nullptr);
|
|
booleanNodes[BooleanNodes::True]->SetInput_UNIT_TEST("Set", true);
|
|
ASSERT_TRUE(*booleanNodes[BooleanNodes::True]->GetInput_UNIT_TEST<bool>("Set"));
|
|
|
|
enum PrintNodes
|
|
{
|
|
Or,
|
|
And,
|
|
Not,
|
|
NotNot,
|
|
Count
|
|
};
|
|
|
|
AZ::EntityId printNodeIds[PrintNodes::Count];
|
|
Print* printNodes[PrintNodes::Count];
|
|
|
|
printNodes[PrintNodes::Or] = CreateTestNode<Print>(graphUniqueId, printNodeIds[Or]);
|
|
ASSERT_TRUE(printNodes[PrintNodes::Or] != nullptr);
|
|
|
|
printNodes[PrintNodes::And] = CreateTestNode<Print>(graphUniqueId, printNodeIds[And]);
|
|
ASSERT_TRUE(printNodes[PrintNodes::And] != nullptr);
|
|
|
|
printNodes[PrintNodes::Not] = CreateTestNode<Print>(graphUniqueId, printNodeIds[Not]);
|
|
ASSERT_TRUE(printNodes[PrintNodes::Not] != nullptr);
|
|
|
|
printNodes[PrintNodes::NotNot] = CreateTestNode<Print>(graphUniqueId, printNodeIds[NotNot]);
|
|
ASSERT_TRUE(printNodes[PrintNodes::NotNot] != nullptr);
|
|
|
|
AZ::EntityId orNodeId;
|
|
Nodes::Logic::Or* orNode = CreateTestNode<Nodes::Logic::Or>(graphUniqueId, orNodeId);
|
|
|
|
AZ::EntityId andNodeId;
|
|
Nodes::Logic::And* andNode = CreateTestNode<Nodes::Logic::And>(graphUniqueId, andNodeId);
|
|
|
|
AZ::EntityId notNodeId;
|
|
Nodes::Logic::Not* notNode = CreateTestNode<Nodes::Logic::Not>(graphUniqueId, notNodeId);
|
|
|
|
AZ::EntityId notNotNodeId;
|
|
Nodes::Logic::Not* notNotNode = CreateTestNode<Nodes::Logic::Not>(graphUniqueId, notNotNodeId);
|
|
|
|
// Start ----------------> And --> Print --> Or -> Print -> Not -> Print -> NotNot -> Print
|
|
// Boolean (true) _________/_/_____true______/_ /___ true ____/ \__ false ___/ \____true
|
|
// Boolean (false) ____________________________/
|
|
|
|
EXPECT_TRUE(Connect(*graph, startNodeId, "Out", andNodeId, "In"));
|
|
|
|
EXPECT_TRUE(Connect(*graph, andNodeId, Nodes::BinaryOperator::k_onTrue, printNodeIds[And], "In"));
|
|
EXPECT_TRUE(Connect(*graph, andNodeId, Nodes::BinaryOperator::k_onFalse, printNodeIds[And], "In"));
|
|
EXPECT_TRUE(Connect(*graph, andNodeId, Nodes::BinaryOperator::k_lhsName, booleanNodeIds[True], PureData::k_getThis));
|
|
EXPECT_TRUE(Connect(*graph, andNodeId, Nodes::BinaryOperator::k_rhsName, booleanNodeIds[True], PureData::k_getThis));
|
|
EXPECT_TRUE(Connect(*graph, andNodeId, Nodes::BinaryOperator::k_resultName, printNodeIds[And], "Value"));
|
|
|
|
EXPECT_TRUE(Connect(*graph, printNodeIds[And], "Out", orNodeId, Nodes::UnaryOperator::k_evaluateName));
|
|
EXPECT_TRUE(Connect(*graph, orNodeId, Nodes::BinaryOperator::k_onTrue, printNodeIds[Or], "In"));
|
|
EXPECT_TRUE(Connect(*graph, orNodeId, Nodes::BinaryOperator::k_onFalse, printNodeIds[Or], "In"));
|
|
EXPECT_TRUE(Connect(*graph, orNodeId, Nodes::BinaryOperator::k_lhsName, booleanNodeIds[True], PureData::k_getThis));
|
|
EXPECT_TRUE(Connect(*graph, orNodeId, Nodes::BinaryOperator::k_rhsName, booleanNodeIds[False], PureData::k_getThis));
|
|
EXPECT_TRUE(Connect(*graph, orNodeId, Nodes::BinaryOperator::k_resultName, printNodeIds[Or], "Value"));
|
|
|
|
EXPECT_TRUE(Connect(*graph, printNodeIds[Or], "Out", notNodeId, Nodes::UnaryOperator::k_evaluateName));
|
|
EXPECT_TRUE(Connect(*graph, notNodeId, Nodes::UnaryOperator::k_onTrue, printNodeIds[Not], "In"));
|
|
EXPECT_TRUE(Connect(*graph, notNodeId, Nodes::UnaryOperator::k_onFalse, printNodeIds[Not], "In"));
|
|
EXPECT_TRUE(Connect(*graph, notNodeId, Nodes::UnaryOperator::k_valueName, orNodeId, Nodes::BinaryOperator::k_resultName));
|
|
EXPECT_TRUE(Connect(*graph, notNodeId, Nodes::UnaryOperator::k_resultName, printNodeIds[Not], "Value"));
|
|
|
|
EXPECT_TRUE(Connect(*graph, printNodeIds[Not], "Out", notNotNodeId, Nodes::UnaryOperator::k_evaluateName));
|
|
EXPECT_TRUE(Connect(*graph, notNotNodeId, Nodes::UnaryOperator::k_onTrue, printNodeIds[NotNot], "In"));
|
|
EXPECT_TRUE(Connect(*graph, notNotNodeId, Nodes::UnaryOperator::k_onFalse, printNodeIds[NotNot], "In"));
|
|
EXPECT_TRUE(Connect(*graph, notNotNodeId, Nodes::UnaryOperator::k_valueName, notNotNodeId, Nodes::BinaryOperator::k_resultName));
|
|
EXPECT_TRUE(Connect(*graph, notNotNodeId, Nodes::UnaryOperator::k_resultName, printNodeIds[NotNot], "Value"));
|
|
|
|
graph->SetStartNode(startNodeId);
|
|
graph->GetEntity()->Activate();
|
|
EXPECT_FALSE(graph->IsInErrorState());
|
|
|
|
// Validate results
|
|
|
|
if (printNodes[And])
|
|
{
|
|
const bool* result = printNodes[And]->GetInput_UNIT_TEST<bool>("Value");
|
|
if (result)
|
|
{
|
|
EXPECT_EQ(*result, true);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
if (printNodes[Or])
|
|
{
|
|
const bool* result = printNodes[And]->GetInput_UNIT_TEST<bool>("Value");
|
|
if (result)
|
|
{
|
|
EXPECT_EQ(*result, true);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
if (printNodes[Not])
|
|
{
|
|
const bool* result = printNodes[Not]->GetInput_UNIT_TEST<bool>("Value");
|
|
if (result)
|
|
{
|
|
EXPECT_EQ(*result, false);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
if (printNodes[NotNot])
|
|
{
|
|
const bool* result = printNodes[NotNot]->GetInput_UNIT_TEST<bool>("Value");
|
|
if (result)
|
|
{
|
|
EXPECT_EQ(*result, true);
|
|
}
|
|
else
|
|
{
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
|
|
graph->GetEntity()->Deactivate();
|
|
|
|
delete graph->GetEntity();
|
|
} |