Merge branch 'development' of https://github.com/o3de/o3de into daimini/FocusMode/breadcrumbs

Signed-off-by: Danilo Aimini <[email protected]>

# Conflicts:
#	Code/Framework/AzToolsFramework/Tests/FocusMode/EditorFocusModeTests.cpp
#	Code/Framework/AzToolsFramework/Tests/Prefab/PrefabFocus/PrefabFocusTests.cpp

Code/Framework/AzGameFramework/AzGameFramework/Application/GameApplication.cpp

@@ -32,17 +32,14 @@ namespace AzGameFramework
         // at the Assets alias, otherwise to attempting to mount the engine pak
         // from the Cache folder
         AZ::IO::FixedMaxPath enginePakPath = AZ::Utils::GetExecutableDirectory();
-        enginePakPath /= "Engine.pak";
-        if (m_archiveFileIO->Exists(enginePakPath.c_str()))
+        enginePakPath /= "engine.pak";
+        if (!m_archive->OpenPack("@assets@", enginePakPath.Native()))
         {
-            m_archive->OpenPack("@assets@", enginePakPath.Native());
-        }
-        else if (enginePakPath.clear(); m_settingsRegistry->Get(enginePakPath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_CacheRootFolder))
-        {
-            // fall back to checking if there is an Engine.pak in the Asset Cache
-            enginePakPath /= "Engine.pak";
-            if (m_archiveFileIO->Exists(enginePakPath.c_str()))
+            enginePakPath.clear();
+            if (m_settingsRegistry->Get(enginePakPath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_CacheRootFolder))
             {
+                // fall back to checking Project Cache Root.
+                enginePakPath /= "engine.pak";
                 m_archive->OpenPack("@assets@", enginePakPath.Native());
             }
         }

Code/Framework/AzNetworking/AzNetworking/DataStructures/FixedSizeBitsetView.inl

@@ -15,12 +15,12 @@ namespace AzNetworking
         , m_startOffset(startOffset)
         , m_count(startOffset < bitset.GetValidBitCount() && startOffset + count <= bitset.GetValidBitCount() ? count : 0)
     {
-        AZ_Assert(startOffset + count <= bitset.GetValidBitCount(), "Out of bounds setup in BitsetSubset. Defaulting to 0 bit count.");
+        AZ_Warning("FixedSizeBitsetView", startOffset + count <= bitset.GetValidBitCount(), "Out of bounds setup in BitsetSubset. Defaulting to 0 bit count.");
     }
 
     inline void FixedSizeBitsetView::SetBit(uint32_t index, bool value)
     {
-        AZ_Assert(index < m_count, "Out of bounds access in BitsetSubset (requested %u, count %u)", index, m_count);
+        AZ_Warning("FixedSizeBitsetView", index < m_count, "Out of bounds access in BitsetSubset (requested %u, count %u)", index, m_count);
         if (m_count)
         {
             m_bitset.SetBit(m_startOffset + index, value);
@@ -29,7 +29,7 @@ namespace AzNetworking
 
     inline bool FixedSizeBitsetView::GetBit(uint32_t index) const
     {
-        AZ_Assert(index < m_count, "Out of bounds access in BitsetSubset (requested %u, count %u)", index, m_count);
+        AZ_Warning("FixedSizeBitsetView", index < m_count, "Out of bounds access in BitsetSubset (requested %u, count %u)", index, m_count);
         if (m_count)
         {
             return m_bitset.GetBit(m_startOffset + index);

Code/Framework/AzNetworking/Tests/DataStructures/FixedSizeBitsetTests.cpp

@@ -55,5 +55,8 @@ namespace UnitTest
             unusedBitTest.SetBit(i, false);
         }
         EXPECT_FALSE(unusedBitTest.AnySet());
+
+        unusedBitTest.SetBit(0, true);
+        EXPECT_TRUE(unusedBitTest.AnySet());
     }
 }

Code/Framework/AzNetworking/Tests/DataStructures/FixedSizeBitsetViewTests.cpp

@@ -42,4 +42,29 @@ namespace UnitTest
             EXPECT_FALSE(view.GetBit(0));
         }
     }
+
+    TEST(FixedSizeBitsetView, EmptyBitset)
+    {
+        AzNetworking::FixedSizeBitset<32> bitset;
+        AzNetworking::FixedSizeBitsetView view(bitset, 10, 0);
+        EXPECT_FALSE(view.GetBit(0));
+    }
+
+    TEST(FixedSizeBitsetView, TestAnySet)
+    {
+        const uint32_t VIEW_SIZE = 5;
+
+        AzNetworking::FixedSizeBitset<9> unusedBitTest(true);
+        AzNetworking::FixedSizeBitsetView view(unusedBitTest, 0, VIEW_SIZE);
+        for (uint32_t i = 0; i < VIEW_SIZE; ++i)
+        {
+            view.SetBit(i, false);
+        }
+        EXPECT_FALSE(view.AnySet());
+
+        view.SetBit(0, true);
+        EXPECT_TRUE(view.AnySet());
+
+        EXPECT_EQ(view.GetValidBitCount(), VIEW_SIZE);
+    }
 }

Code/Framework/AzNetworking/Tests/TcpTransport/TcpTransportTests.cpp

@@ -148,6 +148,11 @@ namespace UnitTest
 
         EXPECT_EQ(testServer.m_serverNetworkInterface->GetConnectionSet().GetConnectionCount(), 1);
         EXPECT_EQ(testClient.m_clientNetworkInterface->GetConnectionSet().GetConnectionCount(), 1);
+
+        testClient.m_clientNetworkInterface->SetTimeoutEnabled(true);
+        EXPECT_TRUE(testClient.m_clientNetworkInterface->IsTimeoutEnabled());
+
+        EXPECT_TRUE(testServer.m_serverNetworkInterface->StopListening());
     }
 
     #if AZ_TRAIT_DISABLE_FAILED_NETWORKING_TESTS

Code/Framework/AzNetworking/Tests/UdpTransport/UdpTransportTests.cpp

@@ -125,6 +125,18 @@ namespace UnitTest
         AzNetworking::NetworkingSystemComponent* m_networkingSystemComponent;
     };
 
+    TEST_F(UdpTransportTests, PacketIdWrap)
+    {
+        const uint32_t SEQUENCE_BOUNDARY = 0xFFFF;
+        UdpPacketTracker tracker;
+
+        for (uint32_t i = 0; i < SEQUENCE_BOUNDARY; ++i)
+        {
+            tracker.GetNextPacketId();
+        }
+        EXPECT_EQ(tracker.GetNextPacketId(), PacketId(SEQUENCE_BOUNDARY + 1));
+    }
+
     TEST_F(UdpTransportTests, AckReplication)
     {
         static const SequenceId TestReliableSequenceId = InvalidSequenceId;
@@ -266,6 +278,15 @@ namespace UnitTest
 
         EXPECT_EQ(testServer.m_serverNetworkInterface->GetConnectionSet().GetConnectionCount(), 1);
         EXPECT_EQ(testClient.m_clientNetworkInterface->GetConnectionSet().GetConnectionCount(), 1);
+
+        testClient.m_clientNetworkInterface->SetTimeoutEnabled(true);
+        EXPECT_TRUE(testClient.m_clientNetworkInterface->IsTimeoutEnabled());
+
+        EXPECT_FALSE(dynamic_cast<UdpNetworkInterface*>(testClient.m_clientNetworkInterface)->IsEncrypted());
+
+        EXPECT_TRUE(testServer.m_serverNetworkInterface->StopListening());
+        EXPECT_FALSE(testServer.m_serverNetworkInterface->StopListening());
+        EXPECT_FALSE(dynamic_cast<UdpNetworkInterface*>(testServer.m_serverNetworkInterface)->IsOpen());
     }
 
     TEST_F(UdpTransportTests, TestMultipleClients)

Code/Framework/AzNetworking/Tests/Utilities/IpAddressTests.cpp

@@ -11,4 +11,16 @@
 
 namespace UnitTest
 {
+    TEST(IpAddressTests, TestIpQuads)
+    {
+        const AzNetworking::IpAddress ip = AzNetworking::IpAddress(127, 0, 0, 1, 12345);
+
+        EXPECT_EQ(ip.GetQuadA(), 127);
+        EXPECT_EQ(ip.GetQuadB(), 0);
+        EXPECT_EQ(ip.GetQuadC(), 0);
+        EXPECT_EQ(ip.GetQuadD(), 1);
+
+        EXPECT_EQ(ip.GetString(), "127.0.0.1:12345");
+        EXPECT_EQ(ip.GetIpString(), "127.0.0.1");
+    }
 }

Code/Framework/AzNetworking/Tests/Utilities/QuantizedValuesTests.cpp

@@ -79,13 +79,12 @@ namespace UnitTest
     template <uint32_t NUM_ELEMENTS, uint32_t NUM_BYTES>
     void TestQuantizedValuesHelper01()
     {
-        AzNetworking::QuantizedValues<NUM_ELEMENTS, NUM_BYTES, 0, 1> testIn, testOut; // Transmits float values between 0 and 1 using NUM_BYTES
+        AzNetworking::QuantizedValues<NUM_ELEMENTS, NUM_BYTES, 0, 1> testIn(ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f)), testOut; // Transmits float values between 0 and 1 using NUM_BYTES
 
         AZStd::array<uint8_t, 1024> buffer;
         AzNetworking::NetworkInputSerializer  inputSerializer(buffer.data(), static_cast<uint32_t>(buffer.size()));
         AzNetworking::NetworkOutputSerializer outputSerializer(buffer.data(), static_cast<uint32_t>(buffer.size()));
 
-        testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f);
         EXPECT_EQ(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(0.0f));
         testIn.Serialize(inputSerializer);
         EXPECT_EQ(inputSerializer.GetSize(), NUM_BYTES * NUM_ELEMENTS);
@@ -95,6 +94,8 @@ namespace UnitTest
         testIn = ValueFromFloat<NUM_ELEMENTS>::Construct(1.0f);
         EXPECT_EQ(static_cast<typename ValueFromFloat<NUM_ELEMENTS>::ValueType>(testIn), ValueFromFloat<NUM_ELEMENTS>::Construct(1.0f));
         testIn.Serialize(inputSerializer);
+        EXPECT_NE(testIn, testOut);
+        EXPECT_NE(testIn.GetQuantizedIntegralValues()[0], testOut.GetQuantizedIntegralValues()[0]);
         testOut.Serialize(outputSerializer);
         EXPECT_EQ(testIn, testOut);
 

Code/Framework/AzTest/AzTest/Platform/Common/Unimplemented/Platform_Unimplemented.cpp

@@ -5,7 +5,7 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
-#include "Platform.h"
+#include <AzTest/Platform.h>
 #include <iostream>
 
 class ModuleHandle

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.cpp

@@ -818,7 +818,14 @@ namespace AzToolsFramework
                 auto linkIterator = m_linkIdMap.find(linkId);
                 if (linkIterator != m_linkIdMap.end())
                 {
-                    return AreDirtyTemplatesPresent(linkIterator->second.GetSourceTemplateId());
+                    if (AreDirtyTemplatesPresent(linkIterator->second.GetSourceTemplateId()))
+                    {
+                        return true;
+                    }
+                    else
+                    {
+                        continue;
+                    }
                 }
             }
             return false;

Code/Framework/AzToolsFramework/Tests/BoundsTestComponent.cpp

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <Tests/BoundsTestComponent.h>
+
+#include <AzToolsFramework/ViewportSelection/EditorSelectionUtil.h>
+
+namespace UnitTest
+{
+    AZ::Aabb BoundsTestComponent::GetEditorSelectionBoundsViewport([[maybe_unused]] const AzFramework::ViewportInfo& viewportInfo)
+    {
+        return GetWorldBounds();
+    }
+
+    bool BoundsTestComponent::EditorSelectionIntersectRayViewport(
+        [[maybe_unused]] const AzFramework::ViewportInfo& viewportInfo, const AZ::Vector3& src, const AZ::Vector3& dir, float& distance)
+    {
+        return AzToolsFramework::AabbIntersectRay(src, dir, GetWorldBounds(), distance);
+    }
+
+    bool BoundsTestComponent::SupportsEditorRayIntersect()
+    {
+        return true;
+    }
+
+    void BoundsTestComponent::Reflect([[maybe_unused]] AZ::ReflectContext* context)
+    {
+        // noop
+    }
+
+    void BoundsTestComponent::Activate()
+    {
+        AzFramework::BoundsRequestBus::Handler::BusConnect(GetEntityId());
+        AzToolsFramework::EditorComponentSelectionRequestsBus::Handler::BusConnect(GetEntityId());
+    }
+
+    void BoundsTestComponent::Deactivate()
+    {
+        AzToolsFramework::EditorComponentSelectionRequestsBus::Handler::BusDisconnect();
+        AzFramework::BoundsRequestBus::Handler::BusDisconnect();
+    }
+
+    AZ::Aabb BoundsTestComponent::GetWorldBounds()
+    {
+        AZ::Transform worldFromLocal = AZ::Transform::CreateIdentity();
+        AZ::TransformBus::EventResult(worldFromLocal, GetEntityId(), &AZ::TransformBus::Events::GetWorldTM);
+        return GetLocalBounds().GetTransformedAabb(worldFromLocal);
+    }
+
+    AZ::Aabb BoundsTestComponent::GetLocalBounds()
+    {
+        return AZ::Aabb::CreateFromMinMax(AZ::Vector3(-0.5f), AZ::Vector3(0.5f));
+    }
+
+} // namespace UnitTest

Code/Framework/AzToolsFramework/Tests/BoundsTestComponent.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzFramework/Visibility/BoundsBus.h>
+#include <AzToolsFramework/API/ComponentEntitySelectionBus.h>
+#include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
+
+namespace UnitTest
+{
+    //! Basic component that implements BoundsRequestBus and EditorComponentSelectionRequestsBus to be compatible
+    //! with the Editor visibility system.
+    //! Note: Used for simulating selection (picking) in the viewport.
+    class BoundsTestComponent
+        : public AzToolsFramework::Components::EditorComponentBase
+        , public AzFramework::BoundsRequestBus::Handler
+        , public AzToolsFramework::EditorComponentSelectionRequestsBus::Handler
+    {
+    public:
+        AZ_EDITOR_COMPONENT(
+            BoundsTestComponent, "{E6312E9D-8489-4677-9980-C93C328BC92C}", AzToolsFramework::Components::EditorComponentBase);
+
+        static void Reflect(AZ::ReflectContext* context);
+
+        // AZ::Component overrides ...
+        void Activate() override;
+        void Deactivate() override;
+
+        // EditorComponentSelectionRequestsBus overrides ...
+        AZ::Aabb GetEditorSelectionBoundsViewport(const AzFramework::ViewportInfo& viewportInfo) override;
+        bool EditorSelectionIntersectRayViewport(
+            const AzFramework::ViewportInfo& viewportInfo, const AZ::Vector3& src, const AZ::Vector3& dir, float& distance) override;
+        bool SupportsEditorRayIntersect() override;
+
+        // BoundsRequestBus overrides ...
+        AZ::Aabb GetWorldBounds() override;
+        AZ::Aabb GetLocalBounds() override;
+    };
+
+} // namespace UnitTest

Code/Framework/AzToolsFramework/Tests/EditorTransformComponentSelectionTests.cpp

@@ -13,7 +13,6 @@
 #include <AzFramework/Components/TransformComponent.h>
 #include <AzFramework/Entity/EntityContext.h>
 #include <AzFramework/Viewport/ViewportScreen.h>
-#include <AzFramework/Visibility/BoundsBus.h>
 #include <AzManipulatorTestFramework/AzManipulatorTestFramework.h>
 #include <AzManipulatorTestFramework/AzManipulatorTestFrameworkTestHelpers.h>
 #include <AzManipulatorTestFramework/AzManipulatorTestFrameworkUtils.h>
@@ -22,12 +21,10 @@
 #include <AzManipulatorTestFramework/ViewportInteraction.h>
 #include <AzQtComponents/Components/GlobalEventFilter.h>
 #include <AzTest/AzTest.h>
-#include <AzToolsFramework/API/ComponentEntitySelectionBus.h>
 #include <AzToolsFramework/Application/ToolsApplication.h>
 #include <AzToolsFramework/Entity/EditorEntityActionComponent.h>
 #include <AzToolsFramework/Entity/EditorEntityHelpers.h>
 #include <AzToolsFramework/Entity/EditorEntityModel.h>
-#include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
 #include <AzToolsFramework/ToolsComponents/EditorLockComponent.h>
 #include <AzToolsFramework/ToolsComponents/EditorVisibilityComponent.h>
 #include <AzToolsFramework/ToolsComponents/TransformComponent.h>
@@ -41,6 +38,8 @@
 #include <AzToolsFramework/ViewportSelection/EditorVisibleEntityDataCache.h>
 #include <AzToolsFramework/ViewportUi/ViewportUiManager.h>
 
+#include<Tests/BoundsTestComponent.h>
+
 namespace AZ
 {
     std::ostream& operator<<(std::ostream& os, const EntityId entityId)
@@ -123,80 +122,6 @@ namespace UnitTest
         EXPECT_FALSE(m_cache.IsVisibleEntityVisible(m_cache.GetVisibleEntityIndexFromId(m_entityIds[2]).value()));
     }
 
-    //! Basic component that implements BoundsRequestBus and EditorComponentSelectionRequestsBus to be compatible
-    //! with the Editor visibility system.
-    //! Note: Used for simulating selection (picking) in the viewport.
-    class BoundsTestComponent
-        : public AzToolsFramework::Components::EditorComponentBase
-        , public AzFramework::BoundsRequestBus::Handler
-        , public AzToolsFramework::EditorComponentSelectionRequestsBus::Handler
-    {
-    public:
-        AZ_EDITOR_COMPONENT(
-            BoundsTestComponent, "{E6312E9D-8489-4677-9980-C93C328BC92C}", AzToolsFramework::Components::EditorComponentBase);
-
-        static void Reflect(AZ::ReflectContext* context);
-
-        // AZ::Component overrides ...
-        void Activate() override;
-        void Deactivate() override;
-
-        // EditorComponentSelectionRequestsBus overrides ...
-        AZ::Aabb GetEditorSelectionBoundsViewport(const AzFramework::ViewportInfo& viewportInfo) override;
-        bool EditorSelectionIntersectRayViewport(
-            const AzFramework::ViewportInfo& viewportInfo, const AZ::Vector3& src, const AZ::Vector3& dir, float& distance) override;
-        bool SupportsEditorRayIntersect() override;
-
-        // BoundsRequestBus overrides ...
-        AZ::Aabb GetWorldBounds() override;
-        AZ::Aabb GetLocalBounds() override;
-    };
-
-    AZ::Aabb BoundsTestComponent::GetEditorSelectionBoundsViewport([[maybe_unused]] const AzFramework::ViewportInfo& viewportInfo)
-    {
-        return GetWorldBounds();
-    }
-
-    bool BoundsTestComponent::EditorSelectionIntersectRayViewport(
-        [[maybe_unused]] const AzFramework::ViewportInfo& viewportInfo, const AZ::Vector3& src, const AZ::Vector3& dir, float& distance)
-    {
-        return AzToolsFramework::AabbIntersectRay(src, dir, GetWorldBounds(), distance);
-    }
-
-    bool BoundsTestComponent::SupportsEditorRayIntersect()
-    {
-        return true;
-    }
-
-    void BoundsTestComponent::Reflect([[maybe_unused]] AZ::ReflectContext* context)
-    {
-        // noop
-    }
-
-    void BoundsTestComponent::Activate()
-    {
-        AzFramework::BoundsRequestBus::Handler::BusConnect(GetEntityId());
-        AzToolsFramework::EditorComponentSelectionRequestsBus::Handler::BusConnect(GetEntityId());
-    }
-
-    void BoundsTestComponent::Deactivate()
-    {
-        AzToolsFramework::EditorComponentSelectionRequestsBus::Handler::BusDisconnect();
-        AzFramework::BoundsRequestBus::Handler::BusDisconnect();
-    }
-
-    AZ::Aabb BoundsTestComponent::GetWorldBounds()
-    {
-        AZ::Transform worldFromLocal = AZ::Transform::CreateIdentity();
-        AZ::TransformBus::EventResult(worldFromLocal, GetEntityId(), &AZ::TransformBus::Events::GetWorldTM);
-        return GetLocalBounds().GetTransformedAabb(worldFromLocal);
-    }
-
-    AZ::Aabb BoundsTestComponent::GetLocalBounds()
-    {
-        return AZ::Aabb::CreateFromMinMax(AZ::Vector3(-0.5f), AZ::Vector3(0.5f));
-    }
-
     // Fixture to support testing EditorTransformComponentSelection functionality on an Entity selection.
     class EditorTransformComponentSelectionFixture : public ToolsApplicationFixture
     {

Code/Framework/AzToolsFramework/Tests/FocusMode/EditorFocusModeFixture.cpp

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <Tests/FocusMode/EditorFocusModeFixture.h>
+
+#include <AzToolsFramework/Entity/EditorEntityHelpers.h>
+
+#include <Tests/BoundsTestComponent.h>
+
+namespace AzToolsFramework
+{
+    void EditorFocusModeFixture::SetUpEditorFixtureImpl()
+    {
+        // Without this, the user settings component would attempt to save on finalize/shutdown. Since the file is
+        // shared across the whole engine, if multiple tests are run in parallel, the saving could cause a crash 
+        // in the unit tests.
+        AZ::UserSettingsComponentRequestBus::Broadcast(&AZ::UserSettingsComponentRequests::DisableSaveOnFinalize);
+
+        m_focusModeInterface = AZ::Interface<FocusModeInterface>::Get();
+        ASSERT_TRUE(m_focusModeInterface != nullptr);
+
+        // register a simple component implementing BoundsRequestBus and EditorComponentSelectionRequestsBus
+        GetApplication()->RegisterComponentDescriptor(UnitTest::BoundsTestComponent::CreateDescriptor());
+
+        AzToolsFramework::EditorEntityContextRequestBus::BroadcastResult(
+            m_editorEntityContextId, &AzToolsFramework::EditorEntityContextRequestBus::Events::GetEditorEntityContextId);
+
+        GenerateTestHierarchy();
+    }
+
+    void EditorFocusModeFixture::GenerateTestHierarchy() 
+    {
+        /*
+        *   City
+        *   |_  Street
+        *       |_  Car
+        *       |   |_ Passenger
+        *       |_  SportsCar
+        *           |_ Passenger
+        */
+
+        m_entityMap[CityEntityName] =       CreateEditorEntity(CityEntityName,          AZ::EntityId());
+        m_entityMap[StreetEntityName] =     CreateEditorEntity(StreetEntityName,        m_entityMap[CityEntityName]);
+        m_entityMap[CarEntityName] =        CreateEditorEntity(CarEntityName,           m_entityMap[StreetEntityName]);
+        m_entityMap[Passenger1EntityName] = CreateEditorEntity(Passenger1EntityName,    m_entityMap[CarEntityName]);
+        m_entityMap[SportsCarEntityName] =  CreateEditorEntity(SportsCarEntityName,     m_entityMap[StreetEntityName]);
+        m_entityMap[Passenger2EntityName] = CreateEditorEntity(Passenger2EntityName,    m_entityMap[SportsCarEntityName]);
+
+        // Add a BoundsTestComponent to the Car entity.
+        AZ::Entity* entity = GetEntityById(m_entityMap[CarEntityName]);
+
+        entity->Deactivate();
+        entity->CreateComponent<UnitTest::BoundsTestComponent>();
+        entity->Activate();
+
+        // Move the CarEntity so it's out of the way.
+        AZ::TransformBus::Event(m_entityMap[CarEntityName], &AZ::TransformBus::Events::SetWorldTranslation, CarEntityPosition);
+
+        // Setup the camera so the Car entity is in view.
+        AzFramework::SetCameraTransform(
+            m_cameraState,
+            AZ::Transform::CreateFromQuaternionAndTranslation(
+                AZ::Quaternion::CreateFromEulerAnglesDegrees(AZ::Vector3(0.0f, 0.0f, 0.0f)), CameraPosition));
+    }
+
+    AZ::EntityId EditorFocusModeFixture::CreateEditorEntity(const char* name, AZ::EntityId parentId)
+    {
+        AZ::Entity* entity = nullptr;
+        UnitTest::CreateDefaultEditorEntity(name, &entity);
+
+        // Parent
+        AZ::TransformBus::Event(entity->GetId(), &AZ::TransformInterface::SetParent, parentId);
+
+        return entity->GetId();
+    }
+}

Code/Framework/AzToolsFramework/Tests/FocusMode/EditorFocusModeFixture.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Component/TransformBus.h>
+#include <AzCore/UnitTest/TestTypes.h>
+#include <AzCore/UserSettings/UserSettingsComponent.h>
+
+#include <AzTest/AzTest.h>
+
+#include <AzToolsFramework/FocusMode/FocusModeInterface.h>
+#include <AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h>
+
+namespace AzToolsFramework
+{
+    class EditorFocusModeFixture
+        : public UnitTest::ToolsApplicationFixture
+    {
+    protected:
+        void SetUpEditorFixtureImpl() override;
+
+        void GenerateTestHierarchy();
+        AZ::EntityId CreateEditorEntity(const char* name, AZ::EntityId parentId);
+
+        AZStd::unordered_map<AZStd::string, AZ::EntityId> m_entityMap;
+        FocusModeInterface* m_focusModeInterface = nullptr;
+
+    public:
+        AzFramework::EntityContextId m_editorEntityContextId = AzFramework::EntityContextId::CreateNull();
+
+        AzFramework::CameraState m_cameraState;
+
+        inline static const AZ::Vector3 CameraPosition = AZ::Vector3(10.0f, 15.0f, 10.0f);
+
+        inline static const char* CityEntityName = "City";
+        inline static const char* StreetEntityName = "Street";
+        inline static const char* CarEntityName = "Car";
+        inline static const char* SportsCarEntityName = "SportsCar";
+        inline static const char* Passenger1EntityName = "Passenger1";
+        inline static const char* Passenger2EntityName = "Passenger2";
+
+        inline static AZ::Vector3 CarEntityPosition = AZ::Vector3(5.0f, 15.0f, 0.0f);
+    };
+}

Code/Framework/AzToolsFramework/Tests/FocusMode/EditorFocusModeSelectionTests.cpp

@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <Tests/FocusMode/EditorFocusModeFixture.h>
+
+#include <AzCore/Component/TransformBus.h>
+#include <AzCore/std/string/string.h>
+
+#include <AzFramework/Viewport/ViewportScreen.h>
+
+#include <AzManipulatorTestFramework/AzManipulatorTestFramework.h>
+#include <AzManipulatorTestFramework/AzManipulatorTestFrameworkTestHelpers.h>
+#include <AzManipulatorTestFramework/DirectManipulatorViewportInteraction.h>
+#include <AzManipulatorTestFramework/ImmediateModeActionDispatcher.h>
+#include <AzManipulatorTestFramework/IndirectManipulatorViewportInteraction.h>
+
+#include <AzToolsFramework/Component/EditorComponentAPIBus.h>
+#include <AzToolsFramework/Manipulators/LinearManipulator.h>
+#include <AzToolsFramework/Manipulators/ManipulatorManager.h>
+#include <AzToolsFramework/ViewportSelection/EditorVisibleEntityDataCache.h>
+
+
+namespace AzToolsFramework
+{
+    class EditorFocusModeSelectionFixture
+        : public UnitTest::IndirectCallManipulatorViewportInteractionFixtureMixin<EditorFocusModeFixture>
+    {
+    public:
+        void ClickAtWorldPositionOnViewport(const AZ::Vector3& worldPosition)
+        {
+            // Calculate the world position in screen space
+            const auto carScreenPosition = AzFramework::WorldToScreen(worldPosition, m_cameraState);
+
+            // Click the entity in the viewport
+            m_actionDispatcher->CameraState(m_cameraState)->MousePosition(carScreenPosition)->MouseLButtonDown()->MouseLButtonUp();
+        }
+    };
+
+    void ClearSelectedEntities()
+    {
+        AzToolsFramework::ToolsApplicationRequestBus::Broadcast(
+            &AzToolsFramework::ToolsApplicationRequestBus::Events::SetSelectedEntities, AzToolsFramework::EntityIdList());
+    }
+
+    AzToolsFramework::EntityIdList GetSelectedEntities()
+    {
+        AzToolsFramework::EntityIdList selectedEntities;
+        AzToolsFramework::ToolsApplicationRequestBus::BroadcastResult(
+            selectedEntities, &AzToolsFramework::ToolsApplicationRequestBus::Events::GetSelectedEntities);
+        return selectedEntities;
+    }
+
+    TEST_F(EditorFocusModeSelectionFixture, EditorFocusModeSelectionTests_SelectEntityWithFocusOnLevel)
+    {
+        // Clear the focus, disabling focus mode
+        m_focusModeInterface->ClearFocusRoot(AzFramework::EntityContextId::CreateNull());
+        // Clear selection
+        ClearSelectedEntities();
+
+        // Click on Car Entity
+        ClickAtWorldPositionOnViewport(CarEntityPosition);
+
+        // Verify entity is selected
+        auto selectedEntitiesAfter = GetSelectedEntities();
+        EXPECT_EQ(selectedEntitiesAfter.size(), 1);
+        EXPECT_EQ(selectedEntitiesAfter.front(), m_entityMap[CarEntityName]);
+    }
+
+    TEST_F(EditorFocusModeSelectionFixture, EditorFocusModeSelectionTests_SelectEntityWithFocusOnAncestor)
+    {
+        // Set the focus on the Street Entity (parent of the test entity)
+        m_focusModeInterface->SetFocusRoot(m_entityMap[StreetEntityName]);
+        // Clear selection
+        ClearSelectedEntities();
+
+        // Click on Car Entity
+        ClickAtWorldPositionOnViewport(CarEntityPosition);
+
+        // Verify entity is selected
+        auto selectedEntitiesAfter = GetSelectedEntities();
+        EXPECT_EQ(selectedEntitiesAfter.size(), 1);
+        EXPECT_EQ(selectedEntitiesAfter.front(), m_entityMap[CarEntityName]);
+
+        // Clear the focus, disabling focus mode
+        m_focusModeInterface->ClearFocusRoot(AzFramework::EntityContextId::CreateNull());
+    }
+
+    TEST_F(EditorFocusModeSelectionFixture, EditorFocusModeSelectionTests_SelectEntityWithFocusOnItself)
+    {
+        // Set the focus on the Car Entity (test entity)
+        m_focusModeInterface->SetFocusRoot(m_entityMap[CarEntityName]);
+        // Clear selection
+        ClearSelectedEntities();
+
+        // Click on Car Entity
+        ClickAtWorldPositionOnViewport(CarEntityPosition);
+
+        // Verify entity is selected
+        auto selectedEntitiesAfter = GetSelectedEntities();
+        EXPECT_EQ(selectedEntitiesAfter.size(), 1);
+        EXPECT_EQ(selectedEntitiesAfter.front(), m_entityMap[CarEntityName]);
+
+        // Clear the focus, disabling focus mode
+        m_focusModeInterface->ClearFocusRoot(AzFramework::EntityContextId::CreateNull());
+    }
+
+    TEST_F(EditorFocusModeSelectionFixture, EditorFocusModeSelectionTests_SelectEntityWithFocusOnSibling)
+    {
+        // Set the focus on the SportsCar Entity (sibling of the test entity)
+        m_focusModeInterface->SetFocusRoot(m_entityMap[SportsCarEntityName]);
+        // Clear selection
+        ClearSelectedEntities();
+
+        // Click on Car Entity
+        ClickAtWorldPositionOnViewport(CarEntityPosition);
+
+        // Verify entity is selected
+        auto selectedEntitiesAfter = GetSelectedEntities();
+        EXPECT_EQ(selectedEntitiesAfter.size(), 0);
+
+        // Clear the focus, disabling focus mode
+        m_focusModeInterface->ClearFocusRoot(AzFramework::EntityContextId::CreateNull());
+    }
+
+    TEST_F(EditorFocusModeSelectionFixture, EditorFocusModeSelectionTests_SelectEntityWithFocusOnDescendant)
+    {
+        // Set the focus on the Passenger1 Entity (child of the entity)
+        m_focusModeInterface->SetFocusRoot(m_entityMap[Passenger1EntityName]);
+        // Clear selection
+        ClearSelectedEntities();
+
+        // Click on Car Entity
+        ClickAtWorldPositionOnViewport(CarEntityPosition);
+
+        // Verify entity is selected
+        auto selectedEntitiesAfter = GetSelectedEntities();
+        EXPECT_EQ(selectedEntitiesAfter.size(), 0);
+
+        // Clear the focus, disabling focus mode
+        m_focusModeInterface->ClearFocusRoot(AzFramework::EntityContextId::CreateNull());
+    }
+}

Code/Framework/AzToolsFramework/Tests/FocusMode/EditorFocusModeTests.cpp

@@ -6,131 +6,99 @@
  *
  */
 
-#include <AzTest/AzTest.h>
-#include <AzCore/UserSettings/UserSettingsComponent.h>
-#include <AzCore/Component/TransformBus.h>
-#include <AzToolsFramework/FocusMode/FocusModeInterface.h>
-#include <AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h>
+#include <Tests/FocusMode/EditorFocusModeFixture.h>
 
 namespace AzToolsFramework
 {
-    class EditorFocusModeTests
-        : public ::testing::Test
+    TEST_F(EditorFocusModeFixture, EditorFocusModeTests_SetFocus)
     {
-    protected:
-        void SetUp() override
-        {
-            m_app.Start(m_descriptor);
+        // When an entity is set as the focus root, GetFocusRoot should return its EntityId.
+        m_focusModeInterface->SetFocusRoot(m_entityMap[CarEntityName]);
+        EXPECT_EQ(m_focusModeInterface->GetFocusRoot(m_editorEntityContextId), m_entityMap[CarEntityName]);
 
-            // Without this, the user settings component would attempt to save on finalize/shutdown. Since the file is
-            // shared across the whole engine, if multiple tests are run in parallel, the saving could cause a crash 
-            // in the unit tests.
-            AZ::UserSettingsComponentRequestBus::Broadcast(&AZ::UserSettingsComponentRequests::DisableSaveOnFinalize);
+        // Restore default expected focus.
+        m_focusModeInterface->ClearFocusRoot(m_editorEntityContextId);
+    }
 
-            GenerateTestHierarchy();
-        }
+    TEST_F(EditorFocusModeFixture, EditorFocusModeTests_ClearFocus)
+    {
+        // Change the value from the default.
+        m_focusModeInterface->SetFocusRoot(m_entityMap[CarEntityName]);
 
-        void GenerateTestHierarchy() 
-        {
-            /*
-            *   City
-            *   |_  Street
-            *       |_  Car
-            *       |   |_ Passenger
-            *       |_  SportsCar
-            *           |_ Passenger
-            */
-
-            m_entityMap["cityId"] =         CreateEditorEntity("City",      AZ::EntityId());
-            m_entityMap["streetId"] =       CreateEditorEntity("Street",    m_entityMap["cityId"]);
-            m_entityMap["carId"] =          CreateEditorEntity("Car",       m_entityMap["streetId"]);
-            m_entityMap["passengerId1"] =   CreateEditorEntity("Passenger", m_entityMap["carId"]);
-            m_entityMap["sportsCarId"] =    CreateEditorEntity("SportsCar", m_entityMap["streetId"]);
-            m_entityMap["passengerId2"] =   CreateEditorEntity("Passenger", m_entityMap["sportsCarId"]);
-        }
+        // Calling ClearFocusRoot restores the default focus root (which is an invalid EntityId).
+        m_focusModeInterface->ClearFocusRoot(m_editorEntityContextId);
+        EXPECT_EQ(m_focusModeInterface->GetFocusRoot(editorEntityContextId), AZ::EntityId());
+    }
 
-        AZ::EntityId CreateEditorEntity(const char* name, AZ::EntityId parentId)
+    TEST_F(EditorFocusModeFixture, EditorFocusModeTests_IsInFocusSubTree_AncestorsDescendants)
+    {
+        // When the focus is set to an entity, all its descendants are in the focus subtree while the ancestors aren't.
         {
-            AZ::Entity* entity = nullptr;
-            UnitTest::CreateDefaultEditorEntity(name, &entity);
-
-            // Parent
-            AZ::TransformBus::Event(entity->GetId(), &AZ::TransformInterface::SetParent, parentId);
-
-            return entity->GetId();
+            m_focusModeInterface->SetFocusRoot(m_entityMap[StreetEntityName]);
+
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CityEntityName]), false);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[StreetEntityName]), true);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CarEntityName]), true);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger1EntityName]), true);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[SportsCarEntityName]), true);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger2EntityName]), true);
         }
 
-        void TearDown() override
+        // Restore default expected focus.
+        m_focusModeInterface->ClearFocusRoot(m_editorEntityContextId);
+    }
+
+    TEST_F(EditorFocusModeFixture, EditorFocusModeTests_IsInFocusSubTree_Siblings)
+    {
+        // If the root entity has siblings, they are also outside of the focus subtree.
         {
-            m_app.Stop();
+            m_focusModeInterface->SetFocusRoot(m_entityMap[CarEntityName]);
+
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CityEntityName]), false);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[StreetEntityName]), false);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CarEntityName]), true);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger1EntityName]), true);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[SportsCarEntityName]), false);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger2EntityName]), false);
         }
 
-        UnitTest::ToolsTestApplication m_app{ "EditorFocusModeTests" };
-        AZ::ComponentApplication::Descriptor m_descriptor;
-        AZStd::unordered_map<AZStd::string, AZ::EntityId> m_entityMap;
-    };
+        // Restore default expected focus.
+        m_focusModeInterface->ClearFocusRoot(m_editorEntityContextId);
+    }
 
-    TEST_F(EditorFocusModeTests, EditorFocusModeTests_SetFocus)
+    TEST_F(EditorFocusModeFixture, EditorFocusModeTests_IsInFocusSubTree_Leaf)
     {
-        FocusModeInterface* focusModeInterface = AZ::Interface<FocusModeInterface>::Get();
-        EXPECT_TRUE(focusModeInterface != nullptr);
-
-        AzFramework::EntityContextId editorEntityContextId = AzFramework::EntityContextId::CreateNull();
-        AzToolsFramework::EditorEntityContextRequestBus::BroadcastResult(
-            editorEntityContextId, &AzToolsFramework::EditorEntityContextRequestBus::Events::GetEditorEntityContextId);
-
-        focusModeInterface->SetFocusRoot(m_entityMap["carId"]);
-        EXPECT_EQ(focusModeInterface->GetFocusRoot(editorEntityContextId), m_entityMap["carId"]);
+        // If the root is a leaf, then the focus subtree will consists of just that entity.
+        {
+            m_focusModeInterface->SetFocusRoot(m_entityMap[Passenger2EntityName]);
+
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CityEntityName]), false);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[StreetEntityName]), false);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CarEntityName]), false);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger1EntityName]), false);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[SportsCarEntityName]), false);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger2EntityName]), true);
+        }
 
-        focusModeInterface->ClearFocusRoot(editorEntityContextId);
-        EXPECT_EQ(focusModeInterface->GetFocusRoot(editorEntityContextId), AZ::EntityId());
+        // Restore default expected focus.
+        m_focusModeInterface->ClearFocusRoot(m_editorEntityContextId);
     }
 
-    TEST_F(EditorFocusModeTests, EditorFocusModeTests_IsInFocusSubTree)
+    TEST_F(EditorFocusModeFixture, EditorFocusModeTests_IsInFocusSubTree_Clear)
     {
-        FocusModeInterface* focusModeInterface = AZ::Interface<FocusModeInterface>::Get();
-        EXPECT_TRUE(focusModeInterface != nullptr);
-
-        AzFramework::EntityContextId editorEntityContextId = AzFramework::EntityContextId::CreateNull();
-        AzToolsFramework::EditorEntityContextRequestBus::BroadcastResult(
-            editorEntityContextId, &AzToolsFramework::EditorEntityContextRequestBus::Events::GetEditorEntityContextId);
-
-        focusModeInterface->ClearFocusRoot(editorEntityContextId);
-        
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["cityId"]), true);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["streetId"]), true);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["carId"]), true);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["passengerId1"]), true);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["sportsCarId"]), true);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["passengerId2"]), true);
-
-        focusModeInterface->SetFocusRoot(m_entityMap["streetId"]);
-
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["cityId"]), false);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["streetId"]), true);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["carId"]), true);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["passengerId1"]), true);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["sportsCarId"]), true);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["passengerId2"]), true);
-
-        focusModeInterface->SetFocusRoot(m_entityMap["carId"]);
-
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["cityId"]), false);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["streetId"]), false);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["carId"]), true);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["passengerId1"]), true);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["sportsCarId"]), false);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["passengerId2"]), false);
-
-        focusModeInterface->SetFocusRoot(m_entityMap["passengerId2"]);
-
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["cityId"]), false);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["streetId"]), false);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["carId"]), false);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["passengerId1"]), false);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["sportsCarId"]), false);
-        EXPECT_EQ(focusModeInterface->IsInFocusSubTree(m_entityMap["passengerId2"]), true);
-
-        focusModeInterface->ClearFocusRoot(editorEntityContextId);
+        // Change the value from the default.
+        m_focusModeInterface->SetFocusRoot(m_entityMap[StreetEntityName]);
+
+        // When the focus is cleared, the whole level is in the focus subtree; so we expect all entities to return true.
+        {
+            m_focusModeInterface->ClearFocusRoot(m_editorEntityContextId);
+
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CityEntityName]), true);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[StreetEntityName]), true);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CarEntityName]), true);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger1EntityName]), true);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[SportsCarEntityName]), true);
+            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger2EntityName]), true);
+        }
     }
 }

Code/Framework/AzToolsFramework/Tests/Prefab/PrefabFocus/PrefabFocusTests.cpp

@@ -30,92 +30,137 @@ namespace UnitTest
              *          |_ Passenger
              */
 
-            m_entityMap["passenger1"] = CreateEntity("Passenger1");
-            m_entityMap["passenger2"] = CreateEntity("Passenger2");
-            m_entityMap["city"] = CreateEntity("City");
+            // Create loose entities
+            m_entityMap[Passenger1EntityName] = CreateEntity(Passenger1EntityName);
+            m_entityMap[Passenger2EntityName] = CreateEntity(Passenger2EntityName);
+            m_entityMap[CityEntityName] = CreateEntity(CityEntityName);
 
+            // Call HandleEntitiesAdded to the loose entities to register them with the Prefab EOS
             AzToolsFramework::EditorEntityContextRequestBus::Broadcast(
                 &AzToolsFramework::EditorEntityContextRequests::HandleEntitiesAdded,
-                AzToolsFramework::EntityList{ m_entityMap["passenger1"], m_entityMap["passenger2"], m_entityMap["city"] });
+                AzToolsFramework::EntityList{ m_entityMap[Passenger1EntityName], m_entityMap[Passenger2EntityName], m_entityMap[CityEntityName] });
 
+            // Create a car prefab from the passenger1 entity. The container entity will be created as part of the process.
             AZStd::unique_ptr<AzToolsFramework::Prefab::Instance> carInstance =
-                m_prefabSystemComponent->CreatePrefab({ m_entityMap["passenger1"] }, {}, "test/car");
+                m_prefabSystemComponent->CreatePrefab({ m_entityMap[Passenger1EntityName] }, {}, "test/car");
             ASSERT_TRUE(carInstance);
-            m_instanceMap["car"] = carInstance.get();
+            m_instanceMap[CarEntityName] = carInstance.get();
 
+            // Create a sportscar prefab from the passenger2 entity. The container entity will be created as part of the process.
             AZStd::unique_ptr<AzToolsFramework::Prefab::Instance> sportsCarInstance =
-                m_prefabSystemComponent->CreatePrefab({ m_entityMap["passenger2"] }, {}, "test/sportsCar");
+                m_prefabSystemComponent->CreatePrefab({ m_entityMap[Passenger2EntityName] }, {}, "test/sportsCar");
             ASSERT_TRUE(sportsCarInstance);
-            m_instanceMap["sportsCar"] = sportsCarInstance.get();
+            m_instanceMap[SportsCarEntityName] = sportsCarInstance.get();
 
+            // Create a street prefab that nests the car and sportscar instances created above. The container entity will be created as part of the process.
             AZStd::unique_ptr<AzToolsFramework::Prefab::Instance> streetInstance =
                 m_prefabSystemComponent->CreatePrefab({}, MakeInstanceList( AZStd::move(carInstance), AZStd::move(sportsCarInstance) ), "test/street");
             ASSERT_TRUE(streetInstance);
-            m_instanceMap["street"] = streetInstance.get();
+            m_instanceMap[StreetEntityName] = streetInstance.get();
 
+            // Create a city prefab that nests the street instances created above and the city entity. The container entity will be created as part of the process.
             m_rootInstance =
-                m_prefabSystemComponent->CreatePrefab({ m_entityMap["city"] }, MakeInstanceList(AZStd::move(streetInstance)), "test/city");
+                m_prefabSystemComponent->CreatePrefab({ m_entityMap[CityEntityName] }, MakeInstanceList(AZStd::move(streetInstance)), "test/city");
             ASSERT_TRUE(m_rootInstance);
-            m_instanceMap["city"] = m_rootInstance.get();
+            m_instanceMap[CityEntityName] = m_rootInstance.get();
+        }
+
+        void SetUpEditorFixtureImpl() override
+        {
+            PrefabTestFixture::SetUpEditorFixtureImpl();
+
+            m_prefabFocusInterface = AZ::Interface<PrefabFocusInterface>::Get();
+            ASSERT_TRUE(m_prefabFocusInterface != nullptr);
+
+            AzToolsFramework::EditorEntityContextRequestBus::BroadcastResult(
+                m_editorEntityContextId, &AzToolsFramework::EditorEntityContextRequestBus::Events::GetEditorEntityContextId);
+
+            GenerateTestHierarchy();
+        }
+
+        void TearDownEditorFixtureImpl() override
+        {
+            m_rootInstance.release();
+
+            PrefabTestFixture::TearDownEditorFixtureImpl();
         }
 
         AZStd::unordered_map<AZStd::string, AZ::Entity*> m_entityMap;
         AZStd::unordered_map<AZStd::string, Instance*> m_instanceMap;
 
         AZStd::unique_ptr<AzToolsFramework::Prefab::Instance> m_rootInstance;
-    };
 
-    TEST_F(PrefabFocusTests, PrefabFocus_FocusOnOwningPrefab)
-    {
-        GenerateTestHierarchy();
+        PrefabFocusInterface* m_prefabFocusInterface = nullptr;
+        AzFramework::EntityContextId m_editorEntityContextId = AzFramework::EntityContextId::CreateNull();
 
-        AzFramework::EntityContextId editorEntityContextId = AzFramework::EntityContextId::CreateNull();
-        AzToolsFramework::EditorEntityContextRequestBus::BroadcastResult(
-            editorEntityContextId, &AzToolsFramework::EditorEntityContextRequestBus::Events::GetEditorEntityContextId);
+        inline static const char* CityEntityName = "City";
+        inline static const char* StreetEntityName = "Street";
+        inline static const char* CarEntityName = "Car";
+        inline static const char* SportsCarEntityName = "SportsCar";
+        inline static const char* Passenger1EntityName = "Passenger1";
+        inline static const char* Passenger2EntityName = "Passenger2";
+    };
 
-        PrefabFocusInterface* prefabFocusInterface = AZ::Interface<PrefabFocusInterface>::Get();
-        EXPECT_TRUE(prefabFocusInterface != nullptr);
-        
+    TEST_F(PrefabFocusTests, PrefabFocus_FocusOnOwningPrefab_RootContainer)
+    {
         // Verify FocusOnOwningPrefab works when passing the container entity of the root prefab.
         {
-            prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap["city"]->GetContainerEntityId());
-            EXPECT_EQ(prefabFocusInterface->GetFocusedPrefabTemplateId(editorEntityContextId), m_instanceMap["city"]->GetTemplateId());
+            m_prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap[CityEntityName]->GetContainerEntityId());
+            EXPECT_EQ(
+                m_prefabFocusInterface->GetFocusedPrefabTemplateId(m_editorEntityContextId),
+                m_instanceMap[CityEntityName]->GetTemplateId());
 
-            auto instance = prefabFocusInterface->GetFocusedPrefabInstance(editorEntityContextId);
+            auto instance = m_prefabFocusInterface->GetFocusedPrefabInstance(m_editorEntityContextId);
             EXPECT_TRUE(instance.has_value());
-            EXPECT_EQ(&instance->get(), m_instanceMap["city"]);
+            EXPECT_EQ(&instance->get(), m_instanceMap[CityEntityName]);
         }
+    }
 
+    TEST_F(PrefabFocusTests, PrefabFocus_FocusOnOwningPrefab_RootEntity)
+    {
         // Verify FocusOnOwningPrefab works when passing a nested entity of the root prefab.
         {
-            prefabFocusInterface->FocusOnOwningPrefab(m_entityMap["city"]->GetId());
-            EXPECT_EQ(prefabFocusInterface->GetFocusedPrefabTemplateId(editorEntityContextId), m_instanceMap["city"]->GetTemplateId());
+            m_prefabFocusInterface->FocusOnOwningPrefab(m_entityMap[CityEntityName]->GetId());
+            EXPECT_EQ(
+                m_prefabFocusInterface->GetFocusedPrefabTemplateId(m_editorEntityContextId),
+                m_instanceMap[CityEntityName]->GetTemplateId());
 
-            auto instance = prefabFocusInterface->GetFocusedPrefabInstance(editorEntityContextId);
+            auto instance = m_prefabFocusInterface->GetFocusedPrefabInstance(m_editorEntityContextId);
             EXPECT_TRUE(instance.has_value());
-            EXPECT_EQ(&instance->get(), m_instanceMap["city"]);
+            EXPECT_EQ(&instance->get(), m_instanceMap[CityEntityName]);
         }
+    }
 
+    TEST_F(PrefabFocusTests, PrefabFocus_FocusOnOwningPrefab_NestedContainer)
+    {
         // Verify FocusOnOwningPrefab works when passing the container entity of a nested prefab.
         {
-            prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap["car"]->GetContainerEntityId());
-            EXPECT_EQ(prefabFocusInterface->GetFocusedPrefabTemplateId(editorEntityContextId), m_instanceMap["car"]->GetTemplateId());
+            m_prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap[CarEntityName]->GetContainerEntityId());
+            EXPECT_EQ(
+                m_prefabFocusInterface->GetFocusedPrefabTemplateId(m_editorEntityContextId), m_instanceMap[CarEntityName]->GetTemplateId());
 
-            auto instance = prefabFocusInterface->GetFocusedPrefabInstance(editorEntityContextId);
+            auto instance = m_prefabFocusInterface->GetFocusedPrefabInstance(m_editorEntityContextId);
             EXPECT_TRUE(instance.has_value());
-            EXPECT_EQ(&instance->get(), m_instanceMap["car"]);
+            EXPECT_EQ(&instance->get(), m_instanceMap[CarEntityName]);
         }
+    }
 
+    TEST_F(PrefabFocusTests, PrefabFocus_FocusOnOwningPrefab_NestedEntity)
+    {
         // Verify FocusOnOwningPrefab works when passing a nested entity of the a nested prefab.
         {
-            prefabFocusInterface->FocusOnOwningPrefab(m_entityMap["passenger1"]->GetId());
-            EXPECT_EQ(prefabFocusInterface->GetFocusedPrefabTemplateId(editorEntityContextId), m_instanceMap["car"]->GetTemplateId());
+            m_prefabFocusInterface->FocusOnOwningPrefab(m_entityMap[Passenger1EntityName]->GetId());
+            EXPECT_EQ(
+                m_prefabFocusInterface->GetFocusedPrefabTemplateId(m_editorEntityContextId), m_instanceMap[CarEntityName]->GetTemplateId());
 
-            auto instance = prefabFocusInterface->GetFocusedPrefabInstance(editorEntityContextId);
+            auto instance = m_prefabFocusInterface->GetFocusedPrefabInstance(m_editorEntityContextId);
             EXPECT_TRUE(instance.has_value());
-            EXPECT_EQ(&instance->get(), m_instanceMap["car"]);
+            EXPECT_EQ(&instance->get(), m_instanceMap[CarEntityName]);
         }
+    }
 
+    TEST_F(PrefabFocusTests, PrefabFocus_FocusOnOwningPrefab_Clear)
+    {
         // Verify FocusOnOwningPrefab points to the root prefab when the focus is cleared.
         {
             AzToolsFramework::PrefabEditorEntityOwnershipInterface* prefabEditorEntityOwnershipInterface =
@@ -124,54 +169,52 @@ namespace UnitTest
                 prefabEditorEntityOwnershipInterface->GetRootPrefabInstance();
             EXPECT_TRUE(rootPrefabInstance.has_value());
 
-            prefabFocusInterface->FocusOnOwningPrefab(AZ::EntityId());
-            EXPECT_EQ(prefabFocusInterface->GetFocusedPrefabTemplateId(editorEntityContextId), rootPrefabInstance->get().GetTemplateId());
+            m_prefabFocusInterface->FocusOnOwningPrefab(AZ::EntityId());
+            EXPECT_EQ(
+                m_prefabFocusInterface->GetFocusedPrefabTemplateId(m_editorEntityContextId), rootPrefabInstance->get().GetTemplateId());
 
-            auto instance = prefabFocusInterface->GetFocusedPrefabInstance(editorEntityContextId);
+            auto instance = m_prefabFocusInterface->GetFocusedPrefabInstance();
             EXPECT_TRUE(instance.has_value());
             EXPECT_EQ(&instance->get(), &rootPrefabInstance->get());
         }
-
-        m_rootInstance.release();
     }
 
-    TEST_F(PrefabFocusTests, PrefabFocus_IsOwningPrefabBeingFocused)
+    TEST_F(PrefabFocusTests, PrefabFocus_IsOwningPrefabBeingFocused_Content)
     {
-        GenerateTestHierarchy();
-
-        PrefabFocusInterface* prefabFocusInterface = AZ::Interface<PrefabFocusInterface>::Get();
-        EXPECT_TRUE(prefabFocusInterface != nullptr);
-
         // Verify IsOwningPrefabBeingFocused returns true for all entities in a focused prefab (container/nested)
         {
-            prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap["city"]->GetContainerEntityId());
+            m_prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap[CityEntityName]->GetContainerEntityId());
 
-            EXPECT_TRUE(prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap["city"]->GetContainerEntityId()));
-            EXPECT_TRUE(prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap["city"]->GetId()));
+            EXPECT_TRUE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap[CityEntityName]->GetContainerEntityId()));
+            EXPECT_TRUE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap[CityEntityName]->GetId()));
         }
+    }
 
+    TEST_F(PrefabFocusTests, PrefabFocus_IsOwningPrefabBeingFocused_AncestorsDescendants)
+    {
         // Verify IsOwningPrefabBeingFocused returns false for all entities not in a focused prefab (ancestors/descendants)
         {
-            prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap["street"]->GetContainerEntityId());
+            m_prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap[StreetEntityName]->GetContainerEntityId());
 
-            EXPECT_TRUE(prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap["street"]->GetContainerEntityId()));
-            EXPECT_FALSE(prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap["city"]->GetContainerEntityId()));
-            EXPECT_FALSE(prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap["city"]->GetId()));
-            EXPECT_FALSE(prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap["car"]->GetContainerEntityId()));
-            EXPECT_FALSE(prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap["passenger1"]->GetId()));
+            EXPECT_TRUE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap[StreetEntityName]->GetContainerEntityId()));
+            EXPECT_FALSE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap[CityEntityName]->GetContainerEntityId()));
+            EXPECT_FALSE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap[CityEntityName]->GetId()));
+            EXPECT_FALSE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap[CarEntityName]->GetContainerEntityId()));
+            EXPECT_FALSE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap[Passenger1EntityName]->GetId()));
         }
+    }
 
+    TEST_F(PrefabFocusTests, PrefabFocus_IsOwningPrefabBeingFocused_Siblings)
+    {
         // Verify IsOwningPrefabBeingFocused returns false for all entities not in a focused prefab (siblings)
         {
-            prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap["sportsCar"]->GetContainerEntityId());
+            m_prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap[SportsCarEntityName]->GetContainerEntityId());
 
-            EXPECT_TRUE(prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap["sportsCar"]->GetContainerEntityId()));
-            EXPECT_TRUE(prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap["passenger2"]->GetId()));
-            EXPECT_FALSE(prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap["car"]->GetContainerEntityId()));
-            EXPECT_FALSE(prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap["passenger1"]->GetId()));
+            EXPECT_TRUE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap[SportsCarEntityName]->GetContainerEntityId()));
+            EXPECT_TRUE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap[Passenger2EntityName]->GetId()));
+            EXPECT_FALSE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap[CarEntityName]->GetContainerEntityId()));
+            EXPECT_FALSE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap[Passenger1EntityName]->GetId()));
         }
-
-        m_rootInstance.release();
     }
 
 }

Code/Framework/AzToolsFramework/Tests/aztoolsframeworktests_files.cmake

@@ -12,6 +12,8 @@ set(FILES
     AssetFileInfoListComparison.cpp
     AssetSeedManager.cpp
     AssetSystemMocks.h
+    BoundsTestComponent.cpp
+    BoundsTestComponent.h
     ComponentAdapterTests.cpp
     ComponentAddRemove.cpp
     ComponentModeTestDoubles.cpp
@@ -34,6 +36,9 @@ set(FILES
     EntityTestbed.h
     FileFunc.cpp
     FingerprintingTests.cpp
+    FocusMode/EditorFocusModeFixture.cpp
+    FocusMode/EditorFocusModeFixture.h
+    FocusMode/EditorFocusModeSelectionTests.cpp
     FocusMode/EditorFocusModeTests.cpp
     GenericComponentWrapperTest.cpp
     InstanceDataHierarchy.cpp

Code/Legacy/CrySystem/SystemInit.cpp

@@ -808,7 +808,7 @@ void CSystem::OpenBasicPaks()
     const char* const assetsDir = "@assets@";
 
     // After game paks to have same search order as with files on disk
-    m_env.pCryPak->OpenPack(assetsDir, "Engine.pak");
+    m_env.pCryPak->OpenPack(assetsDir, "engine.pak");
 
 #if defined(AZ_RESTRICTED_PLATFORM)
 #define AZ_RESTRICTED_SECTION SYSTEMINIT_CPP_SECTION_15
@@ -1261,7 +1261,7 @@ AZ_POP_DISABLE_WARNING
         InlineInitializationProcessing("CSystem::Init Create console");
 
         // Need to load the engine.pak that includes the config files needed during initialization
-        m_env.pCryPak->OpenPack("@assets@", "Engine.pak");
+        m_env.pCryPak->OpenPack("@assets@", "engine.pak");
 
         InitFileSystem_LoadEngineFolders(startupParams);
 

Gems/Atom/RPI/Code/Source/RPI.Public/Shader/Metrics/ShaderMetricsSystem.cpp

@@ -23,11 +23,11 @@ namespace AZ
 {
     namespace RPI
     {
-        AZStd::string GetMetricsFilePath()
+        AZ::IO::FixedMaxPath GetMetricsFilePath()
         {
-            char shaderMetricPath[AZ_MAX_PATH_LEN];
-            AZ::Utils::GetExecutableDirectory(shaderMetricPath, AZ_MAX_PATH_LEN);
-            return AZStd::string(shaderMetricPath) + AZ_CORRECT_FILESYSTEM_SEPARATOR_STRING + "ShaderMetrics.json";
+            AZ::IO::FixedMaxPath resolvedPath;
+            AZ::IO::LocalFileIO::GetInstance()->ResolvePath(resolvedPath, "@user@/ShaderMetrics.json");
+            return resolvedPath;
         }
 
         ShaderMetricsSystemInterface* ShaderMetricsSystemInterface::Get()
@@ -64,7 +64,7 @@ namespace AZ
 
         void ShaderMetricsSystem::ReadLog()
         {
-            const AZStd::string metricsFilePath = GetMetricsFilePath();
+            const AZ::IO::FixedMaxPath metricsFilePath = GetMetricsFilePath();
 
             if (AZ::IO::LocalFileIO::GetInstance()->Exists(metricsFilePath.c_str()))
             {
@@ -80,7 +80,7 @@ namespace AZ
 
         void ShaderMetricsSystem::WriteLog()
         {
-            const AZStd::string metricsFilePath = GetMetricsFilePath();
+            const AZ::IO::FixedMaxPath metricsFilePath = GetMetricsFilePath();
 
             auto saveResult = AZ::JsonSerializationUtils::SaveObjectToFile<ShaderVariantMetrics>(&m_metrics, metricsFilePath.c_str());
 

cmake/Projects.cmake

@@ -151,18 +151,18 @@ if("${CMAKE_INSTALL_CONFIG_NAME}" MATCHES "^([Rr][Ee][Ll][Ee][Aa][Ss][Ee])$")
     if(NOT DEFINED LY_ASSET_DEPLOY_ASSET_TYPE)
         set(LY_ASSET_DEPLOY_ASSET_TYPE @LY_ASSET_DEPLOY_ASSET_TYPE@)
     endif()
-    message(STATUS "Generating ${install_output_folder}/Engine.pak from @full_directory_path@/Cache/${LY_ASSET_DEPLOY_ASSET_TYPE}")
+    message(STATUS "Generating ${install_output_folder}/engine.pak from @full_directory_path@/Cache/${LY_ASSET_DEPLOY_ASSET_TYPE}")
     file(MAKE_DIRECTORY "${install_output_folder}")
     cmake_path(SET cache_product_path "@full_directory_path@/Cache/${LY_ASSET_DEPLOY_ASSET_TYPE}")
     file(GLOB product_assets "${cache_product_path}/*")
     if(product_assets)
         execute_process(
-            COMMAND ${CMAKE_COMMAND} -E tar "cf" "${install_output_folder}/Engine.pak" --format=zip -- ${product_assets}
+            COMMAND ${CMAKE_COMMAND} -E tar "cf" "${install_output_folder}/engine.pak" --format=zip -- ${product_assets}
             WORKING_DIRECTORY "${cache_product_path}"
             RESULT_VARIABLE archive_creation_result
         )
         if(archive_creation_result EQUAL 0)
-            message(STATUS "${install_output_folder}/Engine.pak generated")
+            message(STATUS "${install_output_folder}/engine.pak generated")
         endif()
     endif()
 endif()