Initial commit

Code/Tools/GemRegistry/tests/DependencyTest.cpp

@@ -0,0 +1,408 @@
+/*
+* 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 <GemRegistry/Dependency.h>
+
+using namespace Gems;
+using GemComp = GemDependency::Bound::Comparison;
+using EngineComp = EngineDependency::Bound::Comparison;
+
+class DependencyTest
+    : public ::testing::Test
+{
+protected:
+    enum class Bound
+    {
+        Upper,
+        Lower
+    };
+
+    void SetUp() override
+    {
+        m_errCopyCtorFailed         = "Failed to copy Dependency instance.";
+        m_errParseInvalidSucceeded  = "Failed to report invalid version.";
+        m_errParseFailed            = "Failed to parse valid version string.";
+        m_errIncorrectBoundCount    = "Improper number of bounds generated.";
+        m_errComparisonMismatch     = "Comparison generated does not match ";
+        m_errSpecFulfillsFailed     = "Spec that fulfills dependency was reported as invalid.";
+        m_errInvalidSpecFulfills    = "Spec that does not fulfill dependency was reported as valid.";
+        m_errToStringIncorrect      = "ToString result is incorrect.";
+    }
+
+    const char* ErrComparisonMismatch(const char* op)
+    {
+        return AZStd::string::format("Comparison generated does not match %s.", op).c_str();
+    }
+
+    const char* ErrInvalidBound(Bound b)
+    {
+        return AZStd::string::format("Version generated does not match %s bound.", b == Bound::Upper ? "upper" : "lower").c_str();
+    }
+
+    const char* m_errCopyCtorFailed;
+    const char* m_errParseInvalidSucceeded;
+    const char* m_errParseFailed;
+    const char* m_errIncorrectBoundCount;
+    const char* m_errComparisonMismatch;
+    const char* m_errSpecFulfillsFailed;
+    const char* m_errInvalidSpecFulfills;
+    const char* m_errToStringIncorrect;
+};
+
+TEST_F(DependencyTest, MiscTests)
+{
+    {
+        GemDependency dep1;
+        dep1.m_id = AZ::Uuid::CreateRandom();
+        dep1.m_bounds.push_back(GemDependency::Bound{});
+
+        GemDependency dep2{
+            dep1
+        };
+        EXPECT_EQ(dep2.m_id, dep1.m_id)                                     << m_errCopyCtorFailed;
+        EXPECT_EQ(dep2.m_bounds.size(), dep1.m_bounds.size())               << m_errCopyCtorFailed;
+    }
+
+    {
+        EngineDependency dep1;
+        dep1.m_id = AZ::Uuid::CreateRandom();
+        dep1.m_bounds.push_back(EngineDependency::Bound{});
+
+        EngineDependency dep2 {
+            dep1
+        };
+        EXPECT_EQ(dep2.m_id, dep1.m_id)                                     << m_errCopyCtorFailed;
+        EXPECT_EQ(dep2.m_bounds.size(), dep1.m_bounds.size())               << m_errCopyCtorFailed;
+    }
+}
+
+TEST_F(DependencyTest, FailureTest)
+{
+    {
+        GemDependency dep;
+    
+        EXPECT_FALSE(dep.ParseVersions({ "Not a version requirement!" }).IsSuccess())   << m_errParseInvalidSucceeded;
+        EXPECT_FALSE(dep.ParseVersions({ "~>1" }).IsSuccess())                          << m_errParseInvalidSucceeded;
+        EXPECT_FALSE(dep.ParseVersions({ "~>1.invalid" }).IsSuccess())                  << m_errParseInvalidSucceeded;
+    }
+
+    {
+        EngineDependency dep;
+    
+        EXPECT_FALSE(dep.ParseVersions({ "Not a version requirement!" }).IsSuccess())   << m_errParseInvalidSucceeded;
+        EXPECT_FALSE(dep.ParseVersions({ "~>1" }).IsSuccess())                          << m_errParseInvalidSucceeded;
+        EXPECT_FALSE(dep.ParseVersions({ "~>1.invalid" }).IsSuccess())                  << m_errParseInvalidSucceeded;
+    }
+}
+
+TEST_F(DependencyTest, TwiddleWakkaTest)
+{
+    {
+        GemDependency dep;
+    
+        ASSERT_TRUE(dep.ParseVersions({ "~>1.0" }).IsSuccess())             << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1)                                << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), GemComp::TwiddleWakka)   << ErrComparisonMismatch("Twiddle Wakka");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), GemVersion(1, 0, 0))        << ErrInvalidBound(Bound::Lower);
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ "~>1.0.1" }).IsSuccess())           << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1)                                << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), GemComp::TwiddleWakka) << ErrComparisonMismatch("Twiddle Wakka");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), GemVersion(1, 0, 1)) << ErrInvalidBound(Bound::Lower);
+    }
+
+    {
+        EngineDependency dep;
+    
+        ASSERT_TRUE(dep.ParseVersions({ "~>1.0" }).IsSuccess())             << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1)                                << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), EngineComp::TwiddleWakka) << ErrComparisonMismatch("Twiddle Wakka");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), EngineVersion({ 1, 0, 0, 0 })) << ErrInvalidBound(Bound::Lower);
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ "~>1.0.1" }).IsSuccess())           << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1)                                << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), EngineComp::TwiddleWakka) << ErrComparisonMismatch("Twiddle Wakka");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), EngineVersion({ 1, 0, 1, 0 })) << ErrInvalidBound(Bound::Lower);
+    }
+}
+
+TEST_F(DependencyTest, SingleVersionTest)
+{
+    {
+        GemDependency dep;
+    
+        ASSERT_TRUE(dep.ParseVersions({ ">=1.0.0" }).IsSuccess())           << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1)                                << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), GemComp::GreaterThan | GemComp::EqualTo) << ErrComparisonMismatch(">=");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), GemVersion(1, 0, 0)) << ErrInvalidBound(Bound::Lower);
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ ">2.20.0" }).IsSuccess())           << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1)                                << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), GemComp::GreaterThan) << ErrComparisonMismatch(">");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), GemVersion(2, 20, 0)) << ErrInvalidBound(Bound::Lower);
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ "==3.4.0" }).IsSuccess())           << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1)                                << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), GemComp::EqualTo) << ErrComparisonMismatch("==");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), GemVersion(3, 4, 0)) << ErrInvalidBound(Bound::Lower);
+    }
+
+    {
+        EngineDependency dep;
+    
+        ASSERT_TRUE(dep.ParseVersions({ ">=1.0.0.0" }).IsSuccess())         << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1)                                << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), EngineComp::GreaterThan | EngineComp::EqualTo) << ErrComparisonMismatch(">=");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), EngineVersion({ 1, 0, 0, 0 })) << ErrInvalidBound(Bound::Lower);
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ ">2.20.0.0" }).IsSuccess())         << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1)                                << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), EngineComp::GreaterThan) << ErrComparisonMismatch(">");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), EngineVersion({ 2, 20, 0, 0 })) << ErrInvalidBound(Bound::Lower);
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ "==3.4.0.0" }).IsSuccess())         << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1)                                << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), EngineComp::EqualTo) << ErrComparisonMismatch("==");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), EngineVersion({ 3, 4, 0, 0 })) << ErrInvalidBound(Bound::Lower);
+    }
+}
+
+TEST_F(DependencyTest, DoubleVersionTest)
+{
+    {
+        GemDependency dep;
+    
+        ASSERT_TRUE(dep.ParseVersions({ ">=1.0.0", "<2.0.0" }).IsSuccess()) << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 2)                                << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), GemComp::GreaterThan | GemComp::EqualTo) << ErrComparisonMismatch(">=");
+        EXPECT_EQ(dep.GetBounds()[1].GetComparison(), GemComp::LessThan) << ErrComparisonMismatch("<");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), GemVersion(1, 0, 0)) << ErrInvalidBound(Bound::Lower);
+        EXPECT_EQ(dep.GetBounds()[1].GetVersion(), GemVersion(2, 0, 0)) << ErrInvalidBound(Bound::Upper);
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ ">2.20.0", "<=3" }).IsSuccess())    << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 2)                                << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), GemComp::GreaterThan) << ErrComparisonMismatch(">");
+        EXPECT_EQ(dep.GetBounds()[1].GetComparison(), GemComp::LessThan | GemComp::EqualTo) << ErrComparisonMismatch("<=");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), GemVersion(2, 20, 0)) << ErrInvalidBound(Bound::Lower);
+        EXPECT_EQ(dep.GetBounds()[1].GetVersion(), GemVersion(3, 0, 0)) << ErrInvalidBound(Bound::Upper);
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ "<3.4.0", ">=20.1" }).IsSuccess())  << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 2)                                << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), GemComp::LessThan) << ErrComparisonMismatch("<");
+        EXPECT_EQ(dep.GetBounds()[1].GetComparison(), GemComp::GreaterThan | GemComp::EqualTo) << ErrComparisonMismatch(">=");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), GemVersion(3, 4, 0)) << ErrInvalidBound(Bound::Lower);
+        EXPECT_EQ(dep.GetBounds()[1].GetVersion(), GemVersion(20, 1, 0)) << ErrInvalidBound(Bound::Upper);
+    }
+
+    {
+        EngineDependency dep;
+    
+        ASSERT_TRUE(dep.ParseVersions({ ">=1.0.0.0", "<2.0.0.0" }).IsSuccess()) << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 2)                                    << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), EngineComp::GreaterThan | EngineComp::EqualTo) << ErrComparisonMismatch(">=");
+        EXPECT_EQ(dep.GetBounds()[1].GetComparison(), EngineComp::LessThan) << ErrComparisonMismatch("<");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), EngineVersion({ 1, 0, 0, 0 })) << ErrInvalidBound(Bound::Lower);
+        EXPECT_EQ(dep.GetBounds()[1].GetVersion(), EngineVersion({ 2, 0, 0, 0 })) << ErrInvalidBound(Bound::Upper);
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ ">2.20.0.0", "<=3" }).IsSuccess())      << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 2)                                    << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), EngineComp::GreaterThan) << ErrComparisonMismatch(">");
+        EXPECT_EQ(dep.GetBounds()[1].GetComparison(), EngineComp::LessThan | EngineComp::EqualTo) << ErrComparisonMismatch("<=");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), EngineVersion({ 2, 20, 0, 0 })) << ErrInvalidBound(Bound::Lower);
+        EXPECT_EQ(dep.GetBounds()[1].GetVersion(), EngineVersion({ 3, 0, 0, 0 })) << ErrInvalidBound(Bound::Upper);
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ "<3.4.0.0", ">=20.1" }).IsSuccess())    << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 2)                                    << m_errIncorrectBoundCount;
+        EXPECT_EQ(dep.GetBounds()[0].GetComparison(), EngineComp::LessThan) << ErrComparisonMismatch("<");
+        EXPECT_EQ(dep.GetBounds()[1].GetComparison(), EngineComp::GreaterThan | EngineComp::EqualTo) << ErrComparisonMismatch(">=");
+        EXPECT_EQ(dep.GetBounds()[0].GetVersion(), EngineVersion({ 3, 4, 0, 0 })) << ErrInvalidBound(Bound::Lower);
+        EXPECT_EQ(dep.GetBounds()[1].GetVersion(), EngineVersion({ 20, 1, 0, 0 })) << ErrInvalidBound(Bound::Upper);
+    }
+}
+
+TEST_F(DependencyTest, FullfillmentTest)
+{
+    {
+    AZ::Uuid gemId = AZ::Uuid::CreateRandom();
+    
+        GemDependency dep;
+        dep.SetID(gemId);
+    
+        GemSpecifier spec1 = { gemId, GemVersion(1, 0, 0) };
+        GemSpecifier specR = { AZ::Uuid::CreateRandom(), GemVersion(0, 0, 0) };
+    
+        ASSERT_TRUE(dep.ParseVersions(AZStd::vector<AZStd::string>()).IsSuccess())<< m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 0)                                << m_errIncorrectBoundCount;
+        EXPECT_TRUE(dep.IsFullfilledBy(spec1))                              << m_errSpecFulfillsFailed;
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ ">=1" }).IsSuccess())               << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1)                                << m_errIncorrectBoundCount;
+        EXPECT_TRUE(dep.IsFullfilledBy(spec1))                              << m_errSpecFulfillsFailed;
+        EXPECT_FALSE(dep.IsFullfilledBy(specR))                             << m_errInvalidSpecFulfills;
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ ">0", "<1.1" }).IsSuccess())        << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 2)                                << m_errIncorrectBoundCount;
+        EXPECT_TRUE(dep.IsFullfilledBy(spec1))                              << m_errSpecFulfillsFailed;
+        EXPECT_FALSE(dep.IsFullfilledBy(specR))                             << m_errInvalidSpecFulfills;
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ ">1", "<2", "==1.2" }).IsSuccess()) << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 3)                                << m_errIncorrectBoundCount;
+        EXPECT_FALSE(dep.IsFullfilledBy(spec1))                             << m_errInvalidSpecFulfills;
+        EXPECT_FALSE(dep.IsFullfilledBy(specR))                             << m_errInvalidSpecFulfills;
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ "~>1.0" }).IsSuccess())             << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1)                                << m_errIncorrectBoundCount;
+        EXPECT_TRUE(dep.IsFullfilledBy({ gemId, GemVersion(1, 0, 0) }))     << m_errSpecFulfillsFailed;
+        EXPECT_TRUE(dep.IsFullfilledBy({ gemId, GemVersion(1, 1, 0) }))     << m_errSpecFulfillsFailed;
+        EXPECT_FALSE(dep.IsFullfilledBy({ gemId, GemVersion(2, 0, 0) }))    << m_errSpecFulfillsFailed;
+        EXPECT_FALSE(dep.IsFullfilledBy({ gemId, GemVersion(0, 0, 1) }))    << m_errSpecFulfillsFailed;
+    
+        dep.m_bounds.clear();
+    
+        ASSERT_TRUE(dep.ParseVersions({ "~>1.0.1" }).IsSuccess())           << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1)                                << m_errIncorrectBoundCount;
+        EXPECT_TRUE(dep.IsFullfilledBy({ gemId, GemVersion(1, 0, 1) }))     << m_errSpecFulfillsFailed;
+        EXPECT_FALSE(dep.IsFullfilledBy({ gemId, GemVersion(1, 1, 0) }))    << m_errSpecFulfillsFailed;
+        EXPECT_FALSE(dep.IsFullfilledBy({ gemId, GemVersion(1, 0, 0) }))    << m_errSpecFulfillsFailed;
+    }
+
+    {
+        AZ::Uuid engineId = AZ::Uuid::CreateRandom();
+
+        EngineDependency dep;
+        dep.SetID(engineId);
+
+        EngineSpecifier spec1 = { engineId, EngineVersion({ 1, 0, 0, 0 }) };
+        EngineSpecifier specR = { AZ::Uuid::CreateRandom(), EngineVersion({ 0, 0, 0, 0 }) };
+
+        ASSERT_TRUE(dep.ParseVersions(AZStd::vector<AZStd::string>()).IsSuccess()) << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 0) << m_errIncorrectBoundCount;
+        EXPECT_TRUE(dep.IsFullfilledBy(spec1)) << m_errSpecFulfillsFailed;
+
+        dep.m_bounds.clear();
+
+        ASSERT_TRUE(dep.ParseVersions({ ">=1" }).IsSuccess()) << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1) << m_errIncorrectBoundCount;
+        EXPECT_TRUE(dep.IsFullfilledBy(spec1)) << m_errSpecFulfillsFailed;
+        EXPECT_FALSE(dep.IsFullfilledBy(specR)) << m_errInvalidSpecFulfills;
+
+        dep.m_bounds.clear();
+
+        ASSERT_TRUE(dep.ParseVersions({ ">0", "<1.1" }).IsSuccess()) << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 2) << m_errIncorrectBoundCount;
+        EXPECT_TRUE(dep.IsFullfilledBy(spec1)) << m_errSpecFulfillsFailed;
+        EXPECT_FALSE(dep.IsFullfilledBy(specR)) << m_errInvalidSpecFulfills;
+
+        dep.m_bounds.clear();
+
+        ASSERT_TRUE(dep.ParseVersions({ ">1", "<2", "==1.2" }).IsSuccess()) << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 3) << m_errIncorrectBoundCount;
+        EXPECT_FALSE(dep.IsFullfilledBy(spec1)) << m_errInvalidSpecFulfills;
+        EXPECT_FALSE(dep.IsFullfilledBy(specR)) << m_errInvalidSpecFulfills;
+
+        dep.m_bounds.clear();
+
+        ASSERT_TRUE(dep.ParseVersions({ "~>1.0" }).IsSuccess()) << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1) << m_errIncorrectBoundCount;
+        EXPECT_TRUE(dep.IsFullfilledBy({ engineId, EngineVersion({ 1, 0, 0, 0 }) })) << m_errSpecFulfillsFailed;
+        EXPECT_TRUE(dep.IsFullfilledBy({ engineId, EngineVersion({ 1, 1, 0, 0 }) })) << m_errSpecFulfillsFailed;
+        EXPECT_FALSE(dep.IsFullfilledBy({ engineId, EngineVersion({ 2, 0, 0, 0 }) })) << m_errSpecFulfillsFailed;
+        EXPECT_FALSE(dep.IsFullfilledBy({ engineId, EngineVersion({ 0, 0, 1, 0 }) })) << m_errSpecFulfillsFailed;
+
+        dep.m_bounds.clear();
+
+        ASSERT_TRUE(dep.ParseVersions({ "~>1.0.1" }).IsSuccess()) << m_errParseFailed;
+        ASSERT_EQ(dep.GetBounds().size(), 1) << m_errIncorrectBoundCount;
+        EXPECT_TRUE(dep.IsFullfilledBy({ engineId, EngineVersion({ 1, 0, 1, 0 }) })) << m_errSpecFulfillsFailed;
+        EXPECT_FALSE(dep.IsFullfilledBy({ engineId, EngineVersion({ 1, 1, 0, 0 }) })) << m_errSpecFulfillsFailed;
+        EXPECT_FALSE(dep.IsFullfilledBy({ engineId, EngineVersion({ 1, 0, 0, 0 }) })) << m_errSpecFulfillsFailed;
+    }
+}
+
+TEST_F(DependencyTest, BoundToStringTest)
+{
+    {
+        GemVersion v1 {
+            1, 0, 0
+        };
+    
+        GemDependency::Bound bnd;
+        bnd.SetVersion(v1);
+    
+        bnd.SetComparison(GemComp::EqualTo);
+        EXPECT_STREQ(bnd.ToString().c_str(), "==1.0.0")                     << m_errToStringIncorrect;
+    
+        bnd.SetComparison(GemComp::GreaterThan);
+        EXPECT_STREQ(bnd.ToString().c_str(), ">1.0.0")                      << m_errToStringIncorrect;
+    
+        bnd.SetComparison(GemComp::LessThan);
+        EXPECT_STREQ(bnd.ToString().c_str(), "<1.0.0")                      << m_errToStringIncorrect;
+    
+        bnd.SetComparison(GemComp::GreaterThan | GemComp::EqualTo);
+        EXPECT_STREQ(bnd.ToString().c_str(), ">=1.0.0")                     << m_errToStringIncorrect;
+    
+        bnd.SetComparison(GemComp::LessThan | GemComp::EqualTo);
+        EXPECT_STREQ(bnd.ToString().c_str(), "<=1.0.0")                     << m_errToStringIncorrect;
+    }
+
+    {
+        EngineVersion v1{
+            1, 0, 0, 0
+        };
+
+        EngineDependency::Bound bnd;
+        bnd.SetVersion(v1);
+
+        bnd.SetComparison(EngineComp::EqualTo);
+        EXPECT_STREQ(bnd.ToString().c_str(), "==1.0.0.0")                   << m_errToStringIncorrect;
+
+        bnd.SetComparison(EngineComp::GreaterThan);
+        EXPECT_STREQ(bnd.ToString().c_str(), ">1.0.0.0")                    << m_errToStringIncorrect;
+
+        bnd.SetComparison(EngineComp::LessThan);
+        EXPECT_STREQ(bnd.ToString().c_str(), "<1.0.0.0")                    << m_errToStringIncorrect;
+
+        bnd.SetComparison(EngineComp::GreaterThan | EngineComp::EqualTo);
+        EXPECT_STREQ(bnd.ToString().c_str(), ">=1.0.0.0")                   << m_errToStringIncorrect;
+
+        bnd.SetComparison(EngineComp::LessThan | EngineComp::EqualTo);
+        EXPECT_STREQ(bnd.ToString().c_str(), "<=1.0.0.0")                   << m_errToStringIncorrect;
+    }
+}

Code/Tools/GemRegistry/tests/DescriptionTest.cpp

@@ -0,0 +1,378 @@
+/*
+ * 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 "GemDescription.h"
+
+using Gems::GemDescription;
+using Gems::ModuleDefinition;
+
+class DescriptionTest
+    : public ::testing::Test
+{
+protected:
+    void SetUp() override
+    {
+    }
+
+    void TearDown() override
+    {
+
+    }
+
+    /// Helper to parse json text to a GemDescription result
+    static AZ::Outcome<GemDescription, AZStd::string> CreateFromString(const char* text)
+    {
+        rapidjson::Document document;
+        document.Parse(text);
+        EXPECT_FALSE(document.HasParseError());
+
+        return GemDescription::CreateFromJson(document, "", "");
+    }
+
+    /// Helper to parse json text (that should compile) to a GemDescription
+    static GemDescription ParseString(const char* text)
+    {
+        auto result = CreateFromString(text);
+        EXPECT_TRUE(result.IsSuccess());
+
+        return AZStd::move(result.GetValue());
+    }
+};
+
+// Helper asserts
+#define EXPECT_MODULE_COUNT(desc, expectedCount)            EXPECT_EQ(expectedCount, desc.GetModules().size());
+#define EXPECT_MODULE_TYPE_COUNT(desc, type, expectedCount) EXPECT_EQ(expectedCount, desc.GetModulesOfType(ModuleDefinition::Type::type).size())
+
+////////////////////////////////////////////////////////////////////////
+// Success tests
+////////////////////////////////////////////////////////////////////////
+
+// Test for parsing V3 Gem Descriptions
+TEST_F(DescriptionTest, ParseJson_V3_GameModule)
+{
+    static const char* description = R"JSON(
+{
+    "GemFormatVersion": 3,
+    "Uuid": "ff06785f7145416b9d46fde39098cb0c",
+    "Name": "LmbrCentral",
+    "Version": "0.1.0",
+    "LinkType": "Dynamic",
+    "Summary": "Required LmbrCentral Engine Gem.",
+    "Tags": ["Untagged"],
+    "IconPath": "preview.png",
+    "IsRequired": true
+}
+)JSON";
+
+    GemDescription desc = ParseString(description);
+
+    EXPECT_MODULE_COUNT(desc, 1);
+
+    EXPECT_MODULE_TYPE_COUNT(desc, GameModule, 1);
+    EXPECT_MODULE_TYPE_COUNT(desc, EditorModule, 1);
+    EXPECT_MODULE_TYPE_COUNT(desc, StaticLib, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, Builder, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, Standalone, 0);
+}
+
+// Test for parsing V3 Gem Descriptions with an editor module
+TEST_F(DescriptionTest, ParseJson_V3_EditorModule)
+{
+    static const char* description = R"JSON(
+{
+    "GemFormatVersion": 3,
+    "Uuid": "ff06785f7145416b9d46fde39098cb0c",
+    "Name": "LmbrCentral",
+    "Version": "0.1.0",
+    "LinkType": "Dynamic",
+    "Summary": "Required LmbrCentral Engine Gem.",
+    "Tags": ["Untagged"],
+    "IconPath": "preview.png",
+    "EditorModule": true,
+    "IsRequired": true
+}
+)JSON";
+
+    GemDescription desc = ParseString(description);
+
+    EXPECT_MODULE_COUNT(desc, 2);
+
+    EXPECT_MODULE_TYPE_COUNT(desc, GameModule, 1);
+    EXPECT_MODULE_TYPE_COUNT(desc, EditorModule, 1);
+    EXPECT_MODULE_TYPE_COUNT(desc, StaticLib, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, Builder, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, Standalone, 0);
+}
+
+// Test for parsing V4 Gem Descriptions with a game module
+TEST_F(DescriptionTest, ParseJson_V4_GameModule)
+{
+    static const char* description = R"JSON(
+{
+    "GemFormatVersion": 4,
+    "Uuid": "f910686b6725452fbfc4671f95f733c6",
+    "Name": "Camera",
+    "Version": "0.1.0",
+    "DisplayName": "Camera",
+    "Tags": ["Camera"],
+    "Summary": "The Camera Gem includes a basic camera component that defines a frustum for runtime rendering.",
+    "IconPath": "preview.png",
+    "Modules": [
+        {
+            "Type": "GameModule"
+        }
+    ]
+}
+)JSON";
+
+    GemDescription desc = ParseString(description);
+
+    EXPECT_MODULE_COUNT(desc, 1);
+
+    EXPECT_MODULE_TYPE_COUNT(desc, GameModule, 1);
+    EXPECT_MODULE_TYPE_COUNT(desc, EditorModule, 1);
+    EXPECT_MODULE_TYPE_COUNT(desc, StaticLib, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, Builder, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, Standalone, 0);
+}
+
+// Test for parsing V4 Gem Descriptions with an editor module
+TEST_F(DescriptionTest, ParseJson_V4_EditorModule)
+{
+    static const char* description = R"JSON(
+{
+    "GemFormatVersion": 4,
+    "Uuid": "f910686b6725452fbfc4671f95f733c6",
+    "Name": "Camera",
+    "Version": "0.1.0",
+    "DisplayName": "Camera",
+    "Tags": ["Camera"],
+    "Summary": "The Camera Gem includes a basic camera component that defines a frustum for runtime rendering.",
+    "IconPath": "preview.png",
+    "Modules": [
+        {
+            "Name": "Editor",
+            "Type": "EditorModule"
+        }
+    ]
+}
+)JSON";
+
+    GemDescription desc = ParseString(description);
+
+    EXPECT_MODULE_COUNT(desc, 1);
+
+    EXPECT_MODULE_TYPE_COUNT(desc, GameModule, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, EditorModule, 1);
+    EXPECT_MODULE_TYPE_COUNT(desc, StaticLib, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, Builder, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, Standalone, 0);
+}
+
+// Test for parsing V4 Gem Descriptions with a game and an editor module (that extends the editor module
+TEST_F(DescriptionTest, ParseJson_V4_EditorModuleExtends)
+{
+    static const char* description = R"JSON(
+{
+    "GemFormatVersion": 4,
+    "Uuid": "f910686b6725452fbfc4671f95f733c6",
+    "Name": "Camera",
+    "Version": "0.1.0",
+    "DisplayName": "Camera",
+    "Tags": ["Camera"],
+    "Summary": "The Camera Gem includes a basic camera component that defines a frustum for runtime rendering.",
+    "IconPath": "preview.png",
+    "Modules": [
+        {
+            "Type": "GameModule"
+        },
+        {
+            "Name": "Editor",
+            "Type": "EditorModule",
+            "Extends": "GameModule"
+        }
+    ]
+}
+)JSON";
+
+    GemDescription desc = ParseString(description);
+
+    EXPECT_MODULE_COUNT(desc, 2);
+
+    EXPECT_MODULE_TYPE_COUNT(desc, GameModule, 1);
+    EXPECT_MODULE_TYPE_COUNT(desc, EditorModule, 1);
+    EXPECT_MODULE_TYPE_COUNT(desc, StaticLib, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, Builder, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, Standalone, 0);
+}
+
+// Test for parsing V4 Gem Descriptions with a static lib
+TEST_F(DescriptionTest, ParseJson_V4_StaticLib)
+{
+    static const char* description = R"JSON(
+{
+    "GemFormatVersion": 4,
+    "Uuid": "f910686b6725452fbfc4671f95f733c6",
+    "Name": "Camera",
+    "Version": "0.1.0",
+    "DisplayName": "Camera",
+    "Tags": ["Camera"],
+    "Summary": "The Camera Gem includes a basic camera component that defines a frustum for runtime rendering.",
+    "IconPath": "preview.png",
+    "Modules": [
+        {
+            "Name": "CameraHelper",
+            "Type": "StaticLib"
+        }
+    ]
+}
+)JSON";
+
+    GemDescription desc = ParseString(description);
+
+    EXPECT_MODULE_COUNT(desc, 1);
+
+    EXPECT_MODULE_TYPE_COUNT(desc, GameModule, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, EditorModule, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, StaticLib, 1);
+    EXPECT_MODULE_TYPE_COUNT(desc, Builder, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, Standalone, 0);
+}
+
+// Test for parsing V4 Gem Descriptions with a static lib
+TEST_F(DescriptionTest, ParseJson_V4_Standalone)
+{
+    static const char* description = R"JSON(
+{
+    "GemFormatVersion": 4,
+    "Uuid": "f910686b6725452fbfc4671f95f733c6",
+    "Name": "Camera",
+    "Version": "0.1.0",
+    "DisplayName": "Camera",
+    "Tags": ["Camera"],
+    "Summary": "The Camera Gem includes a basic camera component that defines a frustum for runtime rendering.",
+    "IconPath": "preview.png",
+    "Modules": [
+        {
+            "Name": "CameraHelper",
+            "Type": "Standalone"
+        }
+    ]
+}
+)JSON";
+
+    GemDescription desc = ParseString(description);
+
+    EXPECT_MODULE_COUNT(desc, 1);
+
+    EXPECT_MODULE_TYPE_COUNT(desc, GameModule, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, EditorModule, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, StaticLib, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, Builder, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, Standalone, 1);
+}
+
+// Test for parsing V4 Gem Descriptions with a builder module
+TEST_F(DescriptionTest, ParseJson_V4_BuilderModule)
+{
+    static const char* description = R"JSON(
+{
+    "GemFormatVersion": 4,
+    "Uuid": "f910686b6725452fbfc4671f95f733c6",
+    "Name": "Camera",
+    "Version": "0.1.0",
+    "DisplayName": "Camera",
+    "Tags": ["Camera"],
+    "Summary": "The Camera Gem includes a basic camera component that defines a frustum for runtime rendering.",
+    "IconPath": "preview.png",
+    "Modules": [
+        {
+            "Name": "CameraBuilder",
+            "Type": "Builder"
+        }
+    ]
+}
+)JSON";
+
+    GemDescription desc = ParseString(description);
+
+    EXPECT_MODULE_COUNT(desc, 1);
+
+    EXPECT_MODULE_TYPE_COUNT(desc, GameModule, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, EditorModule, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, StaticLib, 0);
+    EXPECT_MODULE_TYPE_COUNT(desc, Builder, 1);
+    EXPECT_MODULE_TYPE_COUNT(desc, Standalone, 0);
+}
+
+////////////////////////////////////////////////////////////////////////
+// Failure tests
+////////////////////////////////////////////////////////////////////////
+
+// Test for parsing V4 Gem Descriptions with an invalid extends
+TEST_F(DescriptionTest, ParseJson_V4_ExtendsNonExistantModule)
+{
+    static const char* description = R"JSON(
+{
+    "GemFormatVersion": 4,
+    "Uuid": "f910686b6725452fbfc4671f95f733c6",
+    "Name": "Camera",
+    "Version": "0.1.0",
+    "DisplayName": "Camera",
+    "Tags": ["Camera"],
+    "Summary": "The Camera Gem includes a basic camera component that defines a frustum for runtime rendering.",
+    "IconPath": "preview.png",
+    "Modules": [
+        {
+            "Type": "GameModule"
+        },
+        {
+            "Name": "Editor",
+            "Type": "EditorModule",
+            "Extends": "ModuleThatDoesntExist"
+        }
+    ]
+}
+)JSON";
+
+    EXPECT_FALSE(CreateFromString(description).IsSuccess());
+}
+
+// Test for parsing V4 Gem Descriptions with an invalid extends
+TEST_F(DescriptionTest, ParseJson_V4_ExtendsStaticLib)
+{
+    static const char* description = R"JSON(
+{
+    "GemFormatVersion": 4,
+    "Uuid": "f910686b6725452fbfc4671f95f733c6",
+    "Name": "Camera",
+    "Version": "0.1.0",
+    "DisplayName": "Camera",
+    "Tags": ["Camera"],
+    "Summary": "The Camera Gem includes a basic camera component that defines a frustum for runtime rendering.",
+    "IconPath": "preview.png",
+    "Modules": [
+        {
+            "Name": "CameraHelper",
+            "Type": "StaticLib"
+        },
+        {
+            "Name": "Editor",
+            "Type": "EditorModule",
+            "Extends": "CameraHelper"
+        }
+    ]
+}
+)JSON";
+
+    EXPECT_FALSE(CreateFromString(description).IsSuccess());
+}

Code/Tools/GemRegistry/tests/ProjectSettingsTest.cpp

@@ -0,0 +1,247 @@
+/*
+* 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 "ProjectSettings.h"
+#include "GemDescription.h"
+
+using Gems::ProjectSettings;
+using Gems::ProjectGemSpecifier;
+using AzFramework::Specifier;
+using Gems::GemVersion;
+
+class ProjectSettingsTest
+    : public ::testing::Test
+{
+protected:
+    void SetUp() override
+    {
+        m_registry = aznew Gems::GemRegistry();
+        m_errCreationFailed                     = "Failed to create a ProjectSettings instance.";
+        m_errNonEmptyEnabledGems                = "EnabledGems should start empty.";
+        m_errEnableGemFailed                    = "Failed to enable valid Gem Spec.";
+        m_errIsGemEnabledFailed                 = "Failed to accurately determine if a gem was enabled or not";
+        m_errDescriptionParseFailed             = "Failed to parse valid Description: ";
+        m_errInvalidDescriptionParseSucceeded   = "Parsing of invalid Description succeeded.";
+    }
+
+    void TearDown() override
+    {
+        delete m_registry;
+    }
+
+    enum GenerateJsonFlags : AZ::u8
+    {
+        GJF_IncludeID       = 1 << 0,
+        GJF_IncludeVersion  = 1 << 1,
+        GJF_IncludePath     = 1 << 2,
+        GJF_All             = GJF_IncludeID | GJF_IncludeVersion | GJF_IncludePath,
+    };
+
+    rapidjson::Document ParseFromString(AZStd::string document)
+    {
+        rapidjson::Document root(rapidjson::kObjectType);
+        root.Parse(document.c_str());
+        return root;
+    }
+
+    void GenerateJson(rapidjson::Document& rootObj, AZ::Uuid id, GemVersion version, const AZStd::string& path, AZ::u8 flags)
+    {
+        rootObj.SetObject();
+        rootObj.AddMember(GPF_TAG_LIST_FORMAT_VERSION, GEMS_PROJECT_FILE_VERSION, rootObj.GetAllocator());
+
+        rapidjson::Value gemsArray(rapidjson::kArrayType);
+
+        if (flags != 0)
+        {
+            // build a gem
+            rapidjson::Value gemObj(rapidjson::kObjectType);
+
+            if (flags & GJF_IncludeID)
+            {
+                char idstr[UUID_STR_BUF_LEN];
+                id.ToString(idstr, UUID_STR_BUF_LEN, false, false);
+                rapidjson::Value v(idstr, rootObj.GetAllocator());
+                gemObj.AddMember(GPF_TAG_UUID, v.Move(), rootObj.GetAllocator());
+            }
+
+            if (flags & GJF_IncludeVersion)
+            {
+                rapidjson::Value v(version.ToString().c_str(), rootObj.GetAllocator());
+                gemObj.AddMember(GPF_TAG_VERSION, v.Move(), rootObj.GetAllocator());
+            }
+
+            if (flags & GJF_IncludePath)
+            {
+                rapidjson::Value v(path.c_str(), rootObj.GetAllocator());
+                gemObj.AddMember(GPF_TAG_PATH, v.Move(), rootObj.GetAllocator());
+            }
+
+            gemsArray.PushBack(gemObj.Move(), rootObj.GetAllocator()); // copy into array
+        }
+
+        rootObj.AddMember(GPF_TAG_GEM_ARRAY, gemsArray.Move(), rootObj.GetAllocator()); // copy into root object
+    }
+
+    Gems::GemRegistry* m_registry;
+    const char* m_errCreationFailed;
+    const char* m_errNonEmptyEnabledGems;
+    const char* m_errEnableGemFailed;
+    const char* m_errIsGemEnabledFailed;
+    const char* m_errDescriptionParseFailed;
+    const char* m_errInvalidDescriptionParseSucceeded;
+};
+
+TEST_F(ProjectSettingsTest, CreateAndDestroyTest)
+{
+    Gems::IProjectSettings* ps = m_registry->CreateProjectSettings();
+    EXPECT_NE(ps, nullptr)                                  << m_errCreationFailed;
+    m_registry->DestroyProjectSettings(ps);
+}
+
+TEST_F(ProjectSettingsTest, EnableDisableTest)
+{
+    ProjectSettings ps {
+        m_registry
+    };
+    AZ::Uuid id = AZ::Uuid::CreateRandom();
+    GemVersion v1 {
+        1, 0, 0
+    };
+    AZStd::string path {
+        "some\\path"
+    };
+    ProjectGemSpecifier s0 {
+        id, v1, path
+    };
+
+    EXPECT_TRUE(ps.EnableGem(s0))                           << m_errEnableGemFailed;
+    EXPECT_TRUE(ps.IsGemEnabled(s0))                        << m_errEnableGemFailed;
+
+    EXPECT_TRUE(ps.DisableGem(s0))                          << m_errEnableGemFailed;
+    EXPECT_FALSE(ps.IsGemEnabled(s0))                       << m_errEnableGemFailed;
+}
+
+TEST_F(ProjectSettingsTest, IsEnabledTest)
+{
+    ProjectSettings ps {
+        m_registry
+    };
+    ProjectGemSpecifier enabledGemSpecifier {
+        AZ::Uuid::CreateRandom(), GemVersion {
+            1, 0, 0
+        }, "some\\path"
+    };
+
+    EXPECT_TRUE(ps.EnableGem(enabledGemSpecifier))          << m_errEnableGemFailed;
+
+    // Compare 1.0.0 to 1.0.0
+    EXPECT_FALSE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "<1.0.0" }))  << m_errIsGemEnabledFailed;
+    EXPECT_TRUE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "<=1.0.0" }))  << m_errIsGemEnabledFailed;
+    EXPECT_TRUE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "==1.0.0" }))  << m_errIsGemEnabledFailed;
+    EXPECT_TRUE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { ">=1.0.0" }))  << m_errIsGemEnabledFailed;
+    EXPECT_FALSE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { ">1.0.0" }))  << m_errIsGemEnabledFailed;
+
+    // Compare 1.0.0 to 1.0.1
+    EXPECT_TRUE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "<1.0.1" }))   << m_errIsGemEnabledFailed;
+    EXPECT_TRUE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "<=1.0.1" }))  << m_errIsGemEnabledFailed;
+    EXPECT_FALSE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "==1.0.1" })) << m_errIsGemEnabledFailed;
+    EXPECT_FALSE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { ">=1.0.1" })) << m_errIsGemEnabledFailed;
+    EXPECT_FALSE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { ">1.0.1" }))  << m_errIsGemEnabledFailed;
+
+    // Compare 1.0.0 to 0.1.1
+    EXPECT_FALSE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "<0.1.1" }))  << m_errIsGemEnabledFailed;
+    EXPECT_FALSE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "<=0.1.1" })) << m_errIsGemEnabledFailed;
+    EXPECT_FALSE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "==0.1.1" })) << m_errIsGemEnabledFailed;
+    EXPECT_TRUE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { ">=0.1.1" }))  << m_errIsGemEnabledFailed;
+    EXPECT_TRUE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { ">0.1.1" }))   << m_errIsGemEnabledFailed;
+
+    // Test ranges around the enabled gem
+    EXPECT_TRUE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { ">=0.1.0", "<=1.1.0" }))   << m_errIsGemEnabledFailed;
+    EXPECT_TRUE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "<=1.1.0", ">=0.1.0" }))   << m_errIsGemEnabledFailed;
+    EXPECT_TRUE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "~>1.0.0" }))              << m_errIsGemEnabledFailed;
+    EXPECT_TRUE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "~>1.0" }))                << m_errIsGemEnabledFailed;
+
+    // Test ranges at or above the enabled gem
+    EXPECT_TRUE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { ">=1.0.0", "<=1.1.0" }))   << m_errIsGemEnabledFailed;
+    EXPECT_FALSE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { ">1.0.0", "<=1.1.0" }))   << m_errIsGemEnabledFailed;
+    EXPECT_FALSE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "~>1.1.0" }))             << m_errIsGemEnabledFailed;
+
+    //// Test ranges at or below the enabled gem
+    EXPECT_FALSE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { ">=0.1.0", "<1.0.0" }))   << m_errIsGemEnabledFailed;
+    EXPECT_TRUE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { ">=0.1.0", "<=1.0.0" }))   << m_errIsGemEnabledFailed;
+    EXPECT_FALSE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "~>0.1.0" }))             << m_errIsGemEnabledFailed;
+    EXPECT_FALSE(ps.IsGemEnabled(enabledGemSpecifier.m_id, { "~>0.1" }))               << m_errIsGemEnabledFailed;
+}
+
+TEST_F(ProjectSettingsTest, ParseTest)
+{
+    ProjectSettings ps {
+        m_registry
+    };
+    AZ::Uuid id = AZ::Uuid::CreateRandom();
+    GemVersion v1 {
+        1, 0, 0
+    };
+    AZStd::string path("Some\\Path");
+
+    rapidjson::Document json(rapidjson::kObjectType);
+    GenerateJson(json, id, v1, path, GJF_All);
+    AZ::Outcome<void, AZStd::string> outcome = ps.ParseGemsJson(json);
+    ASSERT_TRUE(outcome.IsSuccess())                << m_errDescriptionParseFailed << outcome.GetError().c_str();
+    auto gemMap = ps.GetGems();
+    EXPECT_EQ(gemMap.size(), 1)                     << m_errDescriptionParseFailed << outcome.GetError().c_str();
+    EXPECT_EQ(gemMap.begin()->second.m_id, id)      << m_errDescriptionParseFailed << outcome.GetError().c_str();
+    EXPECT_EQ(gemMap.begin()->second.m_version, v1) << m_errDescriptionParseFailed << outcome.GetError().c_str();
+
+    GenerateJson(json, id, v1, path, GJF_IncludeVersion | GJF_IncludePath);
+    EXPECT_FALSE(ps.ParseGemsJson(json))                << m_errInvalidDescriptionParseSucceeded;
+
+    GenerateJson(json, id, v1, path, GJF_IncludeID | GJF_IncludePath);
+    EXPECT_FALSE(ps.ParseGemsJson(json))                << m_errInvalidDescriptionParseSucceeded;
+
+    GenerateJson(json, id, v1, path, GJF_IncludeVersion | GJF_IncludeID);
+    EXPECT_FALSE(ps.ParseGemsJson(json))                << m_errInvalidDescriptionParseSucceeded;
+
+    GenerateJson(json, id, v1, path, GJF_IncludeID | GJF_IncludeVersion | GJF_IncludePath);
+    EXPECT_TRUE(ps.ParseGemsJson(json))                 << m_errDescriptionParseFailed;
+}
+
+TEST_F(ProjectSettingsTest, SaveTest)
+{
+    ProjectSettings ps {
+        m_registry
+    };
+    AZ::Uuid id = AZ::Uuid::CreateRandom();
+    char idStr[UUID_STR_BUF_LEN];
+    id.ToString(idStr, UUID_STR_BUF_LEN, false, false);
+    GemVersion v1 {
+        1, 0, 0
+    };
+    AZStd::string path("Some\\Path");
+
+    rapidjson::Document json(rapidjson::kObjectType);
+    GenerateJson(json, id, v1, path, GJF_All);
+    ASSERT_TRUE(ps.ParseGemsJson(json))                             << m_errDescriptionParseFailed;
+    EXPECT_TRUE(json.HasMember(GPF_TAG_LIST_FORMAT_VERSION))    << m_errDescriptionParseFailed;
+    EXPECT_TRUE(json[GPF_TAG_LIST_FORMAT_VERSION].IsInt())      << m_errDescriptionParseFailed;
+    EXPECT_EQ(json[GPF_TAG_LIST_FORMAT_VERSION].GetInt(), GEMS_PROJECT_FILE_VERSION) << m_errDescriptionParseFailed;
+    ASSERT_TRUE(json.HasMember(GPF_TAG_GEM_ARRAY))              << m_errDescriptionParseFailed;
+    ASSERT_TRUE(json[GPF_TAG_GEM_ARRAY].IsArray())              << m_errDescriptionParseFailed;
+    ASSERT_EQ(json[GPF_TAG_GEM_ARRAY].Size(), 1)                << m_errDescriptionParseFailed;
+    EXPECT_STRCASEEQ(json[GPF_TAG_GEM_ARRAY][0][GPF_TAG_UUID].GetString(), idStr) << m_errDescriptionParseFailed;
+    EXPECT_STRCASEEQ(json[GPF_TAG_GEM_ARRAY][0][GPF_TAG_VERSION].GetString(), v1.ToString().c_str()) << m_errDescriptionParseFailed;
+    EXPECT_STRCASEEQ(json[GPF_TAG_GEM_ARRAY][0][GPF_TAG_PATH].GetString(), path.c_str()) << m_errDescriptionParseFailed;
+
+    ps.DisableGem({ id, v1 });
+    json = ps.GetJsonRepresentation();
+    ASSERT_EQ(json[GPF_TAG_GEM_ARRAY].Size(), 0);
+}

Code/Tools/GemRegistry/tests/RegistryTest.cpp

@@ -0,0 +1,36 @@
+/*
+* 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 "GemRegistry.h"
+
+using Gems::GemRegistry;
+
+class RegistryTest
+    : public ::testing::Test
+{
+protected:
+    void SetUp() override
+    {
+        m_errCreationFailed         = "Failed to create a GemRegistry instance.";
+        m_errInvalidErrorMessage    = "Error message is not what it was set to.";
+    }
+
+    const char* m_errCreationFailed;
+    const char* m_errInvalidErrorMessage;
+};
+
+TEST_F(RegistryTest, CreateAndDestroyTest)
+{
+    Gems::IGemRegistry* gr = CreateGemRegistry();
+    ASSERT_NE(gr, nullptr)                                                  << m_errCreationFailed;
+    DestroyGemRegistry(gr);
+}

Code/Tools/GemRegistry/tests/VersionTest.cpp

@@ -0,0 +1,465 @@
+/*
+* 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 <AzCore/std/containers/unordered_map.h>
+
+#include <AzTest/AzTest.h>
+#include <GemRegistry/Version.h>
+
+using Gems::GemVersion;
+using Gems::EngineVersion;
+
+class VersionTest
+    : public ::testing::Test
+{
+protected:
+    void SetUp() override
+    {
+        m_errParseFailed            = "Failed to parse valid version string.";
+        m_errParseInvalidSucceeded  = "Parsing invalid version string succeeded.";
+        m_errParseInvalid           = "ParseFromString resulted in incorrect version.";
+        m_errCompareIncorrect       = "Result of Compare is incorrect.";
+        m_errToStringIncorrect      = "ToString result is incorrect.";
+        m_errHasherIncorrect        = "Did not get back the same value from hash map.";
+    }
+
+    const char* m_errParseFailed;
+    const char* m_errParseInvalidSucceeded;
+    const char* m_errParseInvalid;
+    const char* m_errCompareIncorrect;
+    const char* m_errToStringIncorrect;
+    const char* m_errHasherIncorrect;
+};
+
+TEST_F(VersionTest, InitializerListConstructor_ValidValues_ReturnSameValues)
+{
+    GemVersion v0 = { 1, 2, 3 };
+
+    ASSERT_EQ(v0.m_parts[0], 1) << m_errParseInvalid;
+    ASSERT_EQ(v0.m_parts[1], 2) << m_errParseInvalid;
+    ASSERT_EQ(v0.m_parts[2], 3) << m_errParseInvalid;
+
+    EngineVersion v1 = { 1, 2, 3, 4 };
+
+    ASSERT_EQ(v1.m_parts[0], 1) << m_errParseInvalid;
+    ASSERT_EQ(v1.m_parts[1], 2) << m_errParseInvalid;
+    ASSERT_EQ(v1.m_parts[2], 3) << m_errParseInvalid;
+    ASSERT_EQ(v1.m_parts[3], 4) << m_errParseInvalid;
+}
+
+TEST_F(VersionTest, ParseFromString_ValidString_ReturnSuccessOutcomeWithCorrectValues)
+{
+    auto version0Outcome = GemVersion::ParseFromString("1.2.3");
+    ASSERT_TRUE(version0Outcome.IsSuccess()) << m_errParseFailed;
+
+    GemVersion v0 = version0Outcome.GetValue();
+
+    ASSERT_EQ(v0.GetMajor(), 1)                        << m_errParseInvalid;
+    ASSERT_EQ(v0.GetMinor(), 2)                        << m_errParseInvalid;
+    ASSERT_EQ(v0.GetPatch(), 3)                        << m_errParseInvalid;
+
+    auto version1Outcome = EngineVersion::ParseFromString("1.2.3.4");
+    ASSERT_TRUE(version1Outcome.IsSuccess()) << m_errParseFailed;
+
+    EngineVersion v1 = version1Outcome.GetValue();
+
+    ASSERT_EQ(v1.m_parts[0], 1) << m_errParseInvalid;
+    ASSERT_EQ(v1.m_parts[1], 2) << m_errParseInvalid;
+    ASSERT_EQ(v1.m_parts[2], 3) << m_errParseInvalid;
+    ASSERT_EQ(v1.m_parts[3], 4) << m_errParseInvalid;
+}
+
+TEST_F(VersionTest, ParseFromString_EmptyString_ReturnFailureOutcome)
+{
+    ASSERT_FALSE(GemVersion::ParseFromString("").IsSuccess()) << m_errParseInvalidSucceeded;
+    ASSERT_FALSE(EngineVersion::ParseFromString("").IsSuccess()) << m_errParseInvalidSucceeded;
+}
+
+TEST_F(VersionTest, ParseFromString_InvalidPartSize_ReturnFailureOutcome)
+{
+    ASSERT_FALSE(GemVersion::ParseFromString("1.2").IsSuccess()) << m_errParseInvalidSucceeded;
+    ASSERT_FALSE(GemVersion::ParseFromString("1.2.3.4").IsSuccess()) << m_errParseInvalidSucceeded;
+
+    ASSERT_FALSE(EngineVersion::ParseFromString("1.4.2.1.1").IsSuccess()) << m_errParseInvalidSucceeded;
+    ASSERT_FALSE(EngineVersion::ParseFromString("1.2.3").IsSuccess()) << m_errParseInvalidSucceeded;
+}
+
+TEST_F(VersionTest, ParseFromString_InvalidCharactersString_ReturnFailureOutcome)
+{
+    ASSERT_FALSE(GemVersion::ParseFromString("NotAVersion").IsSuccess()) << m_errParseInvalidSucceeded;
+    ASSERT_FALSE(GemVersion::ParseFromString("NotAVersion.2.3").IsSuccess()) << m_errParseInvalidSucceeded;
+    ASSERT_FALSE(GemVersion::ParseFromString("1.NotAVersion.3").IsSuccess()) << m_errParseInvalidSucceeded;
+    ASSERT_FALSE(GemVersion::ParseFromString("1.2.NotAVersion").IsSuccess()) << m_errParseInvalidSucceeded;
+
+    ASSERT_FALSE(EngineVersion::ParseFromString("NotBVersion").IsSuccess()) << m_errParseInvalidSucceeded;
+    ASSERT_FALSE(EngineVersion::ParseFromString("NotBVersion.2.3").IsSuccess()) << m_errParseInvalidSucceeded;
+    ASSERT_FALSE(EngineVersion::ParseFromString("1.NotBVersion.3").IsSuccess()) << m_errParseInvalidSucceeded;
+    ASSERT_FALSE(EngineVersion::ParseFromString("1.2.NotBVersion").IsSuccess()) << m_errParseInvalidSucceeded;
+}
+
+TEST_F(VersionTest, ParseFromString_InvalidSeparator_ReturnFailureOutcome)
+{
+    ASSERT_FALSE(GemVersion::ParseFromString("1,2,3").IsSuccess()) << m_errParseInvalidSucceeded;
+
+    ASSERT_FALSE(EngineVersion::ParseFromString("1,2,3,4").IsSuccess()) << m_errParseInvalidSucceeded;
+}
+
+TEST_F(VersionTest, Compare_DifferentMajor_ReturnLesserThanZero)
+{
+    GemVersion v1 = { 1, 0, 0 };
+    GemVersion v2 = { 2, 0, 0 };
+
+    ASSERT_LT(GemVersion::Compare(v1, v2), 0) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 1, 0, 0, 0 };
+    EngineVersion v4 = { 2, 0, 0, 0 };
+
+    ASSERT_LT(EngineVersion::Compare(v3, v4), 0) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, Compare_DifferentMinor_ReturnLesserThanZero)
+{
+    GemVersion v1 = { 1, 0, 0 };
+    GemVersion v2 = { 1, 1, 0 };
+
+    ASSERT_LT(GemVersion::Compare(v1, v2), 0) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 1, 0, 0, 0 };
+    EngineVersion v4 = { 1, 1, 0, 0 };
+
+    ASSERT_LT(EngineVersion::Compare(v3, v4), 0) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, Compare_DifferentMajorAndMinor_ReturnGreaterThanZero)
+{
+    GemVersion v1 = { 2, 0, 0 };
+    GemVersion v2 = { 1, 1, 0 };
+
+    ASSERT_GT(GemVersion::Compare(v1, v2), 0) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 2, 0, 0, 0 };
+    EngineVersion v4 = { 1, 1, 0, 0 };
+
+    ASSERT_GT(EngineVersion::Compare(v3, v4), 0) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, Compare_SameValue_ReturnZero)
+{
+    GemVersion v1 = { 1, 1, 0 };
+    GemVersion v2 = { 1, 1, 0 };
+
+    ASSERT_EQ(GemVersion::Compare(v1, v2), 0) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 1, 1, 0, 0 };
+    EngineVersion v4 = { 1, 1, 0, 0 };
+
+    ASSERT_EQ(EngineVersion::Compare(v3, v4), 0) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, CompareLesserThan_DifferentMajor_ReturnTrue)
+{
+    GemVersion v1 = { 1, 0, 0 };
+    GemVersion v2 = { 2, 0, 0 };
+
+    ASSERT_TRUE(v1 < v2) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 1, 0, 0, 0 };
+    EngineVersion v4 = { 2, 0, 0, 0 };
+
+    ASSERT_TRUE(v3 < v4) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, CompareLesserThan_SameMajor_ReturnTrue)
+{
+    GemVersion v1 = { 1, 0, 0 };
+    GemVersion v2 = { 1, 1, 0 };
+
+    ASSERT_TRUE(v1 < v2) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 1, 0, 0, 0 };
+    EngineVersion v4 = { 1, 1, 0, 0 };
+
+    ASSERT_TRUE(v3 < v4) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, CompareLesserEqualsTo_DifferentMajor_ReturnTrue)
+{
+    GemVersion v1 = { 1, 0, 0 };
+    GemVersion v2 = { 2, 0, 0 };
+
+    ASSERT_TRUE(v1 <= v2) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 1, 0, 0, 0 };
+    EngineVersion v4 = { 2, 0, 0, 0 };
+
+    ASSERT_TRUE(v3 <= v4) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, CompareLesserEqualsTo_SameMajorSmallerMinor_ReturnTrue)
+{
+    GemVersion v1 = { 1, 0, 0 };
+    GemVersion v2 = { 1, 1, 0 };
+
+    ASSERT_TRUE(v1 <= v2) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 1, 0, 0, 0 };
+    EngineVersion v4 = { 1, 1, 0, 0 };
+
+    ASSERT_TRUE(v3 <= v4) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, CompareLesserEqualsTo_Samevalues_ReturnTrue)
+{
+    GemVersion v1 = { 1, 0, 0 };
+    GemVersion v2 = { 1, 0, 0 };
+
+    ASSERT_TRUE(v1 <= v2) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 1, 0, 0, 0 };
+    EngineVersion v4 = { 1, 0, 0, 0 };
+
+    ASSERT_TRUE(v3 <= v4) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, CompareGreaterThan_DifferentMajor_ReturnTrue)
+{
+    GemVersion v1 = { 2, 0, 0 };
+    GemVersion v2 = { 1, 0, 0 };
+
+    ASSERT_TRUE(v1 > v2) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 2, 0, 0, 0 };
+    EngineVersion v4 = { 1, 0, 0, 0 };
+
+    ASSERT_TRUE(v3 > v4) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, CompareGreaterThan_SameMajor_ReturnTrue)
+{
+    GemVersion v1 = { 1, 1, 0 };
+    GemVersion v2 = { 1, 0, 0 };
+
+    ASSERT_TRUE(v1 > v2) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 1, 1, 0, 0 };
+    EngineVersion v4 = { 1, 0, 0, 0 };
+
+    ASSERT_TRUE(v3 > v4) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, CompareGreaterEqualsTo_DifferentMajor_ReturnTrue)
+{
+    GemVersion v1 = { 2, 0, 0 };
+    GemVersion v2 = { 1, 0, 0 };
+
+    ASSERT_TRUE(v1 >= v2) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 2, 0, 0, 0 };
+    EngineVersion v4 = { 1, 0, 0, 0 };
+
+    ASSERT_TRUE(v3 >= v4) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, CompareGreaterEqualsTo_SameMajorSmallerMinor_ReturnTrue)
+{
+    GemVersion v1 = { 1, 1, 0 };
+    GemVersion v2 = { 1, 0, 0 };
+
+    ASSERT_TRUE(v1 >= v2) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 1, 1, 0, 0 };
+    EngineVersion v4 = { 1, 0, 0, 0 };
+
+    ASSERT_TRUE(v3 >= v4) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, CompareGreaterEqualsTo_Samevalues_ReturnTrue)
+{
+    GemVersion v1 = { 1, 0, 0 };
+    GemVersion v2 = { 1, 0, 0 };
+
+    ASSERT_TRUE(v1 >= v2) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 1, 0, 0, 0 };
+    EngineVersion v4 = { 1, 0, 0, 0 };
+
+    ASSERT_TRUE(v3 >= v4) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, CompareEqualsTo_SameValue_ReturnTrue)
+{
+    GemVersion v1 = { 1, 1, 0 };
+    GemVersion v2 = { 1, 1, 0 };
+
+    ASSERT_TRUE(v1 == v2) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 1, 1, 0, 0 };
+    EngineVersion v4 = { 1, 1, 0, 0 };
+
+    ASSERT_TRUE(v3 == v4) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, CompareEqualsTo_DifferentValue_ReturnFalse)
+{
+    GemVersion v1 = { 1, 1, 0 };
+    GemVersion v2 = { 0, 1, 0 };
+
+    ASSERT_FALSE(v1 == v2) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 1, 1, 0, 0 };
+    EngineVersion v4 = { 0, 1, 0, 0 };
+
+    ASSERT_FALSE(v3 == v4) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, CompareNotEqualsTo_DifferentValues_ReturnTrue)
+{
+    GemVersion v1 = { 1, 0, 0 };
+    GemVersion v2 = { 2, 0, 0 };
+
+    ASSERT_TRUE(v1 != v2) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 1, 0, 0, 0 };
+    EngineVersion v4 = { 2, 0, 0, 0 };
+
+    ASSERT_TRUE(v3 != v4) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, CompareNotEqualsTo_SameValues_ReturnFalse)
+{
+    GemVersion v1 = { 2, 0, 1 };
+    GemVersion v2 = { 2, 0, 1 };
+
+    ASSERT_FALSE(v1 != v2) << m_errCompareIncorrect;
+
+    EngineVersion v3 = { 2, 0, 1, 0 };
+    EngineVersion v4 = { 2, 0, 1, 0 };
+
+    ASSERT_FALSE(v3 != v4) << m_errCompareIncorrect;
+}
+
+TEST_F(VersionTest, ToString_VariousValues_ReturnsCorrectStringOutput)
+{
+    GemVersion v1 = { 1, 0, 0 };
+    GemVersion v2 = { 2, 0, 0 };
+    GemVersion v3 = { 1, 1, 0 };
+    GemVersion v4 = { 1, 1, 0 };
+
+    ASSERT_STREQ(v1.ToString().c_str(), "1.0.0")        << m_errToStringIncorrect;
+    ASSERT_STREQ(v2.ToString().c_str(), "2.0.0")        << m_errToStringIncorrect;
+    ASSERT_STREQ(v3.ToString().c_str(), "1.1.0")        << m_errToStringIncorrect;
+    ASSERT_STREQ(v4.ToString().c_str(), "1.1.0")        << m_errToStringIncorrect;
+
+
+    EngineVersion v5 = { 1, 0, 0, 0 };
+    EngineVersion v6 = { 2, 0, 0, 0 };
+    EngineVersion v7 = { 1, 1, 0, 0 };
+    EngineVersion v8 = { 1, 1, 0, 0 };
+
+    ASSERT_STREQ(v5.ToString().c_str(), "1.0.0.0") << m_errToStringIncorrect;
+    ASSERT_STREQ(v6.ToString().c_str(), "2.0.0.0") << m_errToStringIncorrect;
+    ASSERT_STREQ(v7.ToString().c_str(), "1.1.0.0") << m_errToStringIncorrect;
+    ASSERT_STREQ(v8.ToString().c_str(), "1.1.0.0") << m_errToStringIncorrect;
+}
+
+TEST_F(VersionTest, ToString_ToStringFromParseStringValue_ReturnSameStringFromInput)
+{
+    const char* version0String = "1.2.3";
+
+    auto version0Outcome = GemVersion::ParseFromString(version0String);
+    GemVersion v0 = version0Outcome.GetValue();
+
+    ASSERT_TRUE(version0Outcome.IsSuccess()) << m_errParseFailed;
+    ASSERT_STREQ(v0.ToString().c_str(), version0String) << m_errToStringIncorrect;
+
+
+    const char* version1String = "1.2.3.4";
+
+    auto version1Outcome = EngineVersion::ParseFromString(version1String);
+    EngineVersion v1 = version1Outcome.GetValue();
+
+    ASSERT_TRUE(version1Outcome.IsSuccess()) << m_errParseFailed;
+    ASSERT_STREQ(v1.ToString().c_str(), version1String) << m_errToStringIncorrect;
+}
+
+TEST_F(VersionTest, Hasher_DifferentValues_GetBackSameValue)
+{
+    {
+        AZStd::unordered_map<GemVersion, int> unorderedMap;
+        GemVersion v1 = { 1, 0, 0 };
+        int v1value = 1;
+        GemVersion v2 = { 2, 0, 0 };
+        int v2value = 2;
+        GemVersion v3 = { 1, 1, 0 };
+        int v3value = 3;
+        GemVersion v4 = { 1, 1, 1 };
+        int v4value = 4;
+
+        unorderedMap[v1] = v1value;
+        unorderedMap[v2] = v2value;
+        unorderedMap[v3] = v3value;
+        unorderedMap[v4] = v4value;
+
+        ASSERT_EQ(unorderedMap[v1], v1value) << m_errHasherIncorrect;
+        ASSERT_EQ(unorderedMap[v2], v2value) << m_errHasherIncorrect;
+        ASSERT_EQ(unorderedMap[v3], v3value) << m_errHasherIncorrect;
+        ASSERT_EQ(unorderedMap[v4], v4value) << m_errHasherIncorrect;
+    }
+
+    {
+        AZStd::unordered_map<EngineVersion, int> unorderedMap;
+        EngineVersion v1 = { 1, 0, 0, 0 };
+        int v1value = 1;
+        EngineVersion v2 = { 2, 0, 0, 0 };
+        int v2value = 2;
+        EngineVersion v3 = { 1, 1, 0, 0 };
+        int v3value = 3;
+        EngineVersion v4 = { 1, 1, 1, 0 };
+        int v4value = 4;
+
+        unorderedMap[v1] = v1value;
+        unorderedMap[v2] = v2value;
+        unorderedMap[v3] = v3value;
+        unorderedMap[v4] = v4value;
+
+        ASSERT_EQ(unorderedMap[v1], v1value) << m_errHasherIncorrect;
+        ASSERT_EQ(unorderedMap[v2], v2value) << m_errHasherIncorrect;
+        ASSERT_EQ(unorderedMap[v3], v3value) << m_errHasherIncorrect;
+        ASSERT_EQ(unorderedMap[v4], v4value) << m_errHasherIncorrect;
+    }
+}
+
+TEST_F(VersionTest, Hasher_SameValues_GetBackSameValue)
+{
+    {
+        AZStd::unordered_map<GemVersion, int> unorderedMap;
+        GemVersion v1 = { 1, 1, 1 };
+        GemVersion v2 = { 1, 1, 1 };
+        int v12value = 1;
+
+        unorderedMap[v1] = v12value;
+
+        ASSERT_EQ(unorderedMap.at(v1), v12value) << m_errHasherIncorrect;
+        ASSERT_EQ(unorderedMap.at(v2), v12value) << m_errHasherIncorrect;
+    }
+
+    {
+        AZStd::unordered_map<EngineVersion, int> unorderedMap;
+        EngineVersion v1 = { 1, 1, 1, 0 };
+        EngineVersion v2 = { 1, 1, 1, 0 };
+        int v12value = 1;
+
+        unorderedMap[v1] = v12value;
+
+        ASSERT_EQ(unorderedMap.at(v1), v12value) << m_errHasherIncorrect;
+        ASSERT_EQ(unorderedMap.at(v2), v12value) << m_errHasherIncorrect;
+    }
+}

Code/Tools/GemRegistry/tests/main.cpp

@@ -0,0 +1,38 @@
+/*
+* 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/Memory/AllocatorManager.h>
+#include <AzCore/Memory/OSAllocator.h>
+#include <AzCore/Memory/SystemAllocator.h>
+
+class GemRegistryTestEnvironment
+    : public AZ::Test::ITestEnvironment
+{
+public:
+    virtual ~GemRegistryTestEnvironment()
+    {}
+
+protected:
+    void SetupEnvironment() override
+    {
+        AZ::AllocatorInstance<AZ::OSAllocator>::Create();
+        AZ::AllocatorInstance<AZ::SystemAllocator>::Create();
+    }
+
+    void TeardownEnvironment() override
+    {
+        AZ::AllocatorInstance<AZ::OSAllocator>::Destroy();
+        AZ::AllocatorInstance<AZ::SystemAllocator>::Destroy();
+    }
+};
+
+AZ_UNIT_TEST_HOOK(new GemRegistryTestEnvironment);