birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
alexpete
2021-03-05 11:26:34 -08:00
commit a10351f38d
27091 changed files with 5521199 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/Tools/SceneAPI/SceneCore/Tests/Utilities/PatternMatcherTests.cpp
+65
View File
@@ -0,0 +1,65 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and 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 <AzTest/AzTest.h>
#include <SceneAPI/SceneCore/Utilities/PatternMatcher.h>
namespace AZ
{
namespace SceneAPI
{
namespace SceneCore
{
TEST(PatternMatcherTest, MatchesPattern_MatchingNameWithPostFix_ReturnsTrue)
{
PatternMatcher matcher("_postfix", PatternMatcher::MatchApproach::PostFix);
EXPECT_TRUE(matcher.MatchesPattern("string_with_postfix"));
}
TEST(PatternMatcherTest, MatchesPattern_NonMatchingNameWithPostFix_ReturnsFalse)
{
PatternMatcher matcher("_postfix", PatternMatcher::MatchApproach::PostFix);
EXPECT_FALSE(matcher.MatchesPattern("string_with_something_else"));
}
TEST(PatternMatcherTest, MatchesPattern_NonMatchingNameWithPostFixAndEarlyOutForSmallerTestThanPattern_ReturnsFalse)
{
PatternMatcher matcher("_postfix", PatternMatcher::MatchApproach::PostFix);
EXPECT_FALSE(matcher.MatchesPattern("small"));
}
TEST(PatternMatcherTest, MatchesPattern_MatchingNameWithPreFix_ReturnsTrue)
{
PatternMatcher matcher("prefix_", PatternMatcher::MatchApproach::PreFix);
EXPECT_TRUE(matcher.MatchesPattern("prefix_for_string"));
}
TEST(PatternMatcherTest, MatchesPattern_NonMatchingNameWithPreFix_ReturnsFalse)
{
PatternMatcher matcher("prefix_", PatternMatcher::MatchApproach::PreFix);
EXPECT_FALSE(matcher.MatchesPattern("string_with_something_else"));
}
TEST(PatternMatcherTest, MatchesPattern_MatchingNameWithRegex_ReturnsTrue)
{
PatternMatcher matcher("^.{4}$", PatternMatcher::MatchApproach::Regex);
EXPECT_TRUE(matcher.MatchesPattern("fits"));
}
TEST(PatternMatcherTest, MatchesPattern_NonMatchingNameWithRegex_ReturnsFalse)
{
PatternMatcher matcher("^.{4}$", PatternMatcher::MatchApproach::Regex);
EXPECT_FALSE(matcher.MatchesPattern("string_to_long_for_regex"));
}
} // SceneCore
} // SceneAPI
} // AZ
Code/Tools/SceneAPI/SceneCore/Tests/Utilities/SceneGraphSelectorTests.cpp
+352
View File
@@ -0,0 +1,352 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and 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 <AzTest/AzTest.h>
#include <AzCore/std/containers/vector.h>
#include <AzCore/std/string/string.h>
#include <SceneAPI/SceneCore/Utilities/SceneGraphSelector.h>
#include <SceneAPI/SceneCore/Containers/SceneGraph.h>
#include <SceneAPI/SceneCore/Mocks/DataTypes/ManifestBase/MockISceneNodeSelectionList.h>
#include <SceneAPI/SceneCore/Mocks/DataTypes/GraphData/MockIMeshData.h>
namespace AZ
{
namespace SceneAPI
{
namespace Utilities
{
using ::testing::NiceMock;
using ::testing::Return;
using ::testing::ReturnRef;
using ::testing::Eq;
using ::testing::Invoke;
using ::testing::_;
using ::testing::Matcher;
class SceneGraphSelectorTest
: public ::testing::Test
{
public:
virtual ~SceneGraphSelectorTest() = default;
void SetUp()
{
/*---------------------------------------\
| Root |
| | |
| A |
| / | \ |
| B C D |
| \ |
| E |
| |
\---------------------------------------*/
Containers::SceneGraph::NodeIndex root = m_graph.GetRoot();
Containers::SceneGraph::NodeIndex indexA = m_graph.AddChild(root, "A");
Containers::SceneGraph::NodeIndex indexB = m_graph.AddChild(indexA, "B");
Containers::SceneGraph::NodeIndex indexC = m_graph.AddSibling(indexB, "C");
Containers::SceneGraph::NodeIndex indexD = m_graph.AddSibling(indexC, "D");
m_graph.AddChild(indexD, "E");
}
void CreateMeshGroup(AZStd::vector<AZStd::string>& selectedNodes, AZStd::vector<AZStd::string>& unselectedNodes)
{
EXPECT_CALL(m_testNodeSelectionList, GetSelectedNodeCount())
.WillRepeatedly(Return(selectedNodes.size()));
EXPECT_CALL(m_testNodeSelectionList, GetUnselectedNodeCount())
.WillRepeatedly(Return(unselectedNodes.size()));
for (size_t i = 0; i < selectedNodes.size(); ++i)
{
EXPECT_CALL(m_testNodeSelectionList, GetSelectedNode(Eq(i)))
.WillRepeatedly(ReturnRef(selectedNodes[i]));
}
for (size_t i = 0; i < unselectedNodes.size(); ++i)
{
EXPECT_CALL(m_testNodeSelectionList, GetUnselectedNode(Eq(i)))
.WillRepeatedly(ReturnRef(unselectedNodes[i]));
}
auto selectedNodeInvoke = [&selectedNodes](const AZStd::string& name) -> size_t
{
size_t index = selectedNodes.size();
selectedNodes.push_back(name);
return index;
};
EXPECT_CALL(m_testNodeSelectionList, AddSelectedNode(_))
.WillRepeatedly(Invoke(selectedNodeInvoke));
auto removeNodeInvoke = [&unselectedNodes](const AZStd::string& name)
{
unselectedNodes.push_back(name);
};
EXPECT_CALL(m_testNodeSelectionList, RemoveSelectedNode(Matcher<const AZStd::string&>(_)))
.WillRepeatedly(Invoke(removeNodeInvoke));
auto clearSelectedNodes = [&selectedNodes]()
{
selectedNodes.clear();
};
EXPECT_CALL(m_testNodeSelectionList, ClearSelectedNodes())
.WillRepeatedly(Invoke(clearSelectedNodes));
auto clearUnselectedNodes = [&unselectedNodes]()
{
unselectedNodes.clear();
};
EXPECT_CALL(m_testNodeSelectionList, ClearUnselectedNodes())
.WillRepeatedly(Invoke(clearUnselectedNodes));
}
static bool IsValidTestNodeType([[maybe_unused]] const Containers::SceneGraph& graph, [[maybe_unused]] Containers::SceneGraph::NodeIndex& index)
{
return true;
}
static bool IsValidTestNodeTypeSomeInvalid(const Containers::SceneGraph& graph, Containers::SceneGraph::NodeIndex& index)
{
if (strcmp(graph.GetNodeName(index).GetPath(), "") == 0 || strcmp(graph.GetNodeName(index).GetPath(), "A.D") == 0)
{
return false;
}
else
{
return true;
}
}
protected:
using TestNodeSelectionList = DataTypes::MockISceneNodeSelectionList;
Containers::SceneGraph m_graph;
NiceMock<TestNodeSelectionList> m_testNodeSelectionList;
};
TEST_F(SceneGraphSelectorTest, GenerateTargetNodes_EmptySelectedAndEmptyUnselectedNodes_AllTargetNodes)
{
AZStd::vector<AZStd::string> selectedNodes;
AZStd::vector<AZStd::string> unselectedNodes;
CreateMeshGroup(selectedNodes, unselectedNodes);
auto targetNodes = SceneGraphSelector::GenerateTargetNodes(m_graph, m_testNodeSelectionList, IsValidTestNodeType);
EXPECT_EQ(targetNodes.size(), 5);
EXPECT_STREQ("A", targetNodes[0].c_str());
EXPECT_STREQ("A.B", targetNodes[1].c_str());
EXPECT_STREQ("A.C", targetNodes[2].c_str());
EXPECT_STREQ("A.D", targetNodes[3].c_str());
EXPECT_STREQ("A.D.E", targetNodes[4].c_str());
}
TEST_F(SceneGraphSelectorTest, GenerateTargetNodes_OnlySelectedRootNode_AllNodesInTargetNodes)
{
AZStd::vector<AZStd::string> selectedNodes = { "A" };
AZStd::vector<AZStd::string> unselectedNodes;
CreateMeshGroup(selectedNodes, unselectedNodes);
auto targetNodes = SceneGraphSelector::GenerateTargetNodes(m_graph, m_testNodeSelectionList, IsValidTestNodeType);
EXPECT_EQ(targetNodes.size(), 5);
EXPECT_STREQ("A", targetNodes[0].c_str());
EXPECT_STREQ("A.B", targetNodes[1].c_str());
EXPECT_STREQ("A.C", targetNodes[2].c_str());
EXPECT_STREQ("A.D", targetNodes[3].c_str());
EXPECT_STREQ("A.D.E", targetNodes[4].c_str());
}
TEST_F(SceneGraphSelectorTest, GenerateTargetNodes_OnlyUnselectedRootNode_NoTargetNode)
{
AZStd::vector<AZStd::string> selectedNodes;
AZStd::vector<AZStd::string> unselectedNodes = { "A" };
CreateMeshGroup(selectedNodes, unselectedNodes);
auto targetNodes = SceneGraphSelector::GenerateTargetNodes(m_graph, m_testNodeSelectionList, IsValidTestNodeType);
EXPECT_TRUE(targetNodes.empty());
}
TEST_F(SceneGraphSelectorTest, GenerateTargetNodes_NonemptySelectedAndEmptyUnselectedNodes_AllNodesInTargetNodes)
{
AZStd::vector<AZStd::string> selectedNodes = { "A", "A.B", "A.D" };
AZStd::vector<AZStd::string> unselectedNodes;
CreateMeshGroup(selectedNodes, unselectedNodes);
auto targetNodes = SceneGraphSelector::GenerateTargetNodes(m_graph, m_testNodeSelectionList, IsValidTestNodeType);
EXPECT_EQ(targetNodes.size(), 5);
EXPECT_STREQ("A", targetNodes[0].c_str());
EXPECT_STREQ("A.B", targetNodes[1].c_str());
EXPECT_STREQ("A.C", targetNodes[2].c_str());
EXPECT_STREQ("A.D", targetNodes[3].c_str());
EXPECT_STREQ("A.D.E", targetNodes[4].c_str());
}
TEST_F(SceneGraphSelectorTest, GenerateTargetNodes_EmptySelectedAndNonemptyUnselectedNodes_NoTargetNodes)
{
AZStd::vector<AZStd::string> selectedNodes;
AZStd::vector<AZStd::string> unselectedNodes = { "A", "A.B", "A.D" };
CreateMeshGroup(selectedNodes, unselectedNodes);
auto targetNodes = SceneGraphSelector::GenerateTargetNodes(m_graph, m_testNodeSelectionList, IsValidTestNodeType);
EXPECT_TRUE(targetNodes.empty());
}
TEST_F(SceneGraphSelectorTest, GenerateTargetNodes_SelectedParentNodeUnselectedChildNode_NodeAandAB)
{
AZStd::vector<AZStd::string> selectedNodes = { "A", "A.B" };
AZStd::vector<AZStd::string> unselectedNodes = { "A.C", "A.D" };
CreateMeshGroup(selectedNodes, unselectedNodes);
auto targetNodes = SceneGraphSelector::GenerateTargetNodes(m_graph, m_testNodeSelectionList, IsValidTestNodeType);
EXPECT_EQ(targetNodes.size(), 2);
EXPECT_STREQ("A", targetNodes[0].c_str());
EXPECT_STREQ("A.B", targetNodes[1].c_str());
}
TEST_F(SceneGraphSelectorTest, GenerateTargetNodes_UnselectedParentNodeSelectedChildNode_NodeACandADandADE)
{
AZStd::vector<AZStd::string> selectedNodes = { "A.C", "A.D" };
AZStd::vector<AZStd::string> unselectedNodes = { "A", "A.B" };
CreateMeshGroup(selectedNodes, unselectedNodes);
auto targetNodes = SceneGraphSelector::GenerateTargetNodes(m_graph, m_testNodeSelectionList, IsValidTestNodeType);
EXPECT_EQ(targetNodes.size(), 3);
EXPECT_STREQ("A.C", targetNodes[0].c_str());
EXPECT_STREQ("A.D", targetNodes[1].c_str());
EXPECT_STREQ("A.D.E", targetNodes[2].c_str());
}
TEST_F(SceneGraphSelectorTest, GenerateTargetNodes_SelectedParentUnselectedChild_ParentNodeInTargetNodes)
{
AZStd::vector<AZStd::string> selectedNodes = { "A.D" };
AZStd::vector<AZStd::string> unselectedNodes = { "A.D.E" };
CreateMeshGroup(selectedNodes, unselectedNodes);
auto targetNodes = SceneGraphSelector::GenerateTargetNodes(m_graph, m_testNodeSelectionList, IsValidTestNodeType);
EXPECT_NE(targetNodes.end(), AZStd::find(targetNodes.begin(), targetNodes.end(), "A.D"));
}
TEST_F(SceneGraphSelectorTest, GenerateTargetNodes_UnselectedParentSelectedChild_ChildNodeInTargetNodesButNotParent)
{
AZStd::vector<AZStd::string> selectedNodes = { "A.D.E" };
AZStd::vector<AZStd::string> unselectedNodes = { "A.D" };
CreateMeshGroup(selectedNodes, unselectedNodes);
auto targetNodes = SceneGraphSelector::GenerateTargetNodes(m_graph, m_testNodeSelectionList, IsValidTestNodeType);
EXPECT_EQ(targetNodes.end(), AZStd::find(targetNodes.begin(), targetNodes.end(), "A.D"));
EXPECT_NE(targetNodes.end(), AZStd::find(targetNodes.begin(), targetNodes.end(), "A.D.E"));
}
TEST_F(SceneGraphSelectorTest, GenerateTargetNodes_GrandparentNodeSelectedParentNodeUnknown_GrandchildNodeInTargetNodes)
{
AZStd::vector<AZStd::string> selectedNodes = { "A" };
AZStd::vector<AZStd::string> unselectedNodes = { "A.B", "A.C" };
CreateMeshGroup(selectedNodes, unselectedNodes);
auto targetNodes = SceneGraphSelector::GenerateTargetNodes(m_graph, m_testNodeSelectionList, IsValidTestNodeType);
EXPECT_EQ(targetNodes.size(), 3);
EXPECT_STREQ("A", targetNodes[0].c_str());
EXPECT_STREQ("A.D", targetNodes[1].c_str());
EXPECT_STREQ("A.D.E", targetNodes[2].c_str());
}
TEST_F(SceneGraphSelectorTest, GenerateTargetNodes_GrandparentNodeUnselectedParentNodeUnknown_GrandchildNodeNotInTargetNodes)
{
AZStd::vector<AZStd::string> selectedNodes = { "A.B", "A.C" };
AZStd::vector<AZStd::string> unselectedNodes = { "A" };
CreateMeshGroup(selectedNodes, unselectedNodes);
auto targetNodes = SceneGraphSelector::GenerateTargetNodes(m_graph, m_testNodeSelectionList, IsValidTestNodeType);
EXPECT_EQ(targetNodes.size(), 2);
EXPECT_STREQ("A.B", targetNodes[0].c_str());
EXPECT_STREQ("A.C", targetNodes[1].c_str());
}
TEST_F(SceneGraphSelectorTest, GenerateTargetNodes_OverlappedSelectedAndUnselectedNodes_OverlappedNodeNotInTargetNodes)
{
AZStd::vector<AZStd::string> selectedNodes = { "A", "A.B", "A.D" };
AZStd::vector<AZStd::string> unselectedNodes = { "A.B", "A.D" };
CreateMeshGroup(selectedNodes, unselectedNodes);
auto targetNodes = SceneGraphSelector::GenerateTargetNodes(m_graph, m_testNodeSelectionList, IsValidTestNodeType);
EXPECT_EQ(targetNodes.size(), 2);
EXPECT_STREQ("A", targetNodes[0].c_str());
EXPECT_STREQ("A.C", targetNodes[1].c_str());
}
TEST_F(SceneGraphSelectorTest, GenerateTargetNodes_OnlySelectedRootNodeSomeInvalidNodes_NodeAandABandACandADE)
{
AZStd::vector<AZStd::string> selectedNodes = { "A" };
AZStd::vector<AZStd::string> unselectedNodes;
CreateMeshGroup(selectedNodes, unselectedNodes);
auto targetNodes = SceneGraphSelector::GenerateTargetNodes(m_graph, m_testNodeSelectionList, IsValidTestNodeTypeSomeInvalid);
EXPECT_EQ(targetNodes.size(), 4);
EXPECT_STREQ("A", targetNodes[0].c_str());
EXPECT_STREQ("A.B", targetNodes[1].c_str());
EXPECT_STREQ("A.C", targetNodes[2].c_str());
EXPECT_STREQ("A.D.E", targetNodes[3].c_str());
}
TEST_F(SceneGraphSelectorTest, GenerateTargetNodes_NonemptySelectedandUnselectedNodseSomeInvalidNodes_NodeAandAC)
{
AZStd::vector<AZStd::string> selectedNodes = { "A" };
AZStd::vector<AZStd::string> unselectedNodes = { "A.B", "A.D.E"};
CreateMeshGroup(selectedNodes, unselectedNodes);
auto targetNodes = SceneGraphSelector::GenerateTargetNodes(m_graph, m_testNodeSelectionList, IsValidTestNodeTypeSomeInvalid);
EXPECT_EQ(targetNodes.size(), 2);
EXPECT_STREQ("A", targetNodes[0].c_str());
EXPECT_STREQ("A.C", targetNodes[1].c_str());
}
TEST_F(SceneGraphSelectorTest, UpdateNodeSelection_EmptySelection_AllNodesInSelected)
{
AZStd::vector<AZStd::string> selectedNodes;
AZStd::vector<AZStd::string> unselectedNodes;
CreateMeshGroup(selectedNodes, unselectedNodes);
SceneGraphSelector::UpdateNodeSelection(m_graph, m_testNodeSelectionList);
EXPECT_EQ(5, selectedNodes.size());
EXPECT_EQ(0, unselectedNodes.size());
}
TEST_F(SceneGraphSelectorTest, UpdateNodeSelection_UnselectedNodeA_AllNodesUnselectedExceptRoot)
{
AZStd::vector<AZStd::string> selectedNodes;
AZStd::vector<AZStd::string> unselectedNodes = { "A" };
CreateMeshGroup(selectedNodes, unselectedNodes);
SceneGraphSelector::UpdateNodeSelection(m_graph, m_testNodeSelectionList);
EXPECT_EQ(0, selectedNodes.size());
EXPECT_EQ(5, unselectedNodes.size());
}
TEST_F(SceneGraphSelectorTest, UpdateNodeSelection_DuplicateEntryRemovedFromSelected_ADotDNotFoundInSelectedNodes)
{
AZStd::vector<AZStd::string> selectedNodes = { "A", "A.B", "A.C", "A.D", "A.D.E" };
AZStd::vector<AZStd::string> unselectedNodes = { "A.D" };
CreateMeshGroup(selectedNodes, unselectedNodes);
SceneGraphSelector::UpdateNodeSelection(m_graph, m_testNodeSelectionList);
EXPECT_EQ(4, selectedNodes.size());
EXPECT_EQ(1, unselectedNodes.size());
EXPECT_EQ(selectedNodes.end(), AZStd::find(selectedNodes.begin(), selectedNodes.end(), "A.D"));
EXPECT_NE(unselectedNodes.end(), AZStd::find(unselectedNodes.begin(), unselectedNodes.end(), "A.D"));
}
TEST_F(SceneGraphSelectorTest, UpdateNodeSelection_InvalidEntryInSelected_InvalidEntryRemoved)
{
AZStd::vector<AZStd::string> selectedNodes = { "A", "A.B", "X", "A.C", "A.D", "A.D.E" };
AZStd::vector<AZStd::string> unselectedNodes;
CreateMeshGroup(selectedNodes, unselectedNodes);
SceneGraphSelector::UpdateNodeSelection(m_graph, m_testNodeSelectionList);
EXPECT_EQ(selectedNodes.end(), AZStd::find(selectedNodes.begin(), selectedNodes.end(), "X"));
}
TEST_F(SceneGraphSelectorTest, UpdateNodeSelection_InvalidEntryInUnselected_InvalidEntryRemoved)
{
AZStd::vector<AZStd::string> selectedNodes = { "A", "A.B", "A.C", "A.D", "A.D.E" };
AZStd::vector<AZStd::string> unselectedNodes = { "X" };
CreateMeshGroup(selectedNodes, unselectedNodes);
SceneGraphSelector::UpdateNodeSelection(m_graph, m_testNodeSelectionList);
EXPECT_EQ(unselectedNodes.end(), AZStd::find(unselectedNodes.begin(), unselectedNodes.end(), "X"));
}
}
}
}