Removed ununeeded includes from EBus EBus.h and Policies.h (#4256)

* Removed ununeeded includes from EBus EBus.h and Policies.h

Updated the locations which needed those includes

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>

* Adding missing include for <memory> to AWsClientAuthBus.h

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>

* Remove the while true loop in the EBusQueuePolicy Execute() function

The while true loop in Execute was for allowing additional functions to be queued in the middle of execution of current list of functions.
That functionality was dangerous, because if a queued function added itself during execution unconditionally, then it would result in an infinite loop

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>

* Updated the AssetManager::DispatchEvents function to pump the AssetBus event queue until empty

Queued Events on the AssetBus is able to queue additional events on that Bus during execution of those events.

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>

* Changed the AssetManager::DispatchEvents function to only execute the
AssetBus queued events once

Changed the AssetJobsFloodTest.AssetWithNoLoadReference_LoadDependencies_BehaviorObeyed test to dispatch events until the OnAssetContainerReady callback is signaled.

This happens after every asset load to make sure that the
expiring AssetContainer instances are removed from `AssetManager::m_ownedAssetContainer` container before retrying to load the same asset.

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>

* Added a MaxTimeoutSeconds constant for the maximum amount of the time to run a single DispatchEvents loop

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>

Code/Framework/AzCore/AzCore/Asset/AssetManager.cpp

@@ -340,6 +340,14 @@ namespace AZ
                     // (Load jobs will attempt to reuse blocked threads before spinning off new job threads)
                     ProcessLoadJob();
                 }
+
+                // Pump the AssetBus function queue once more after the load has completed in case additional
+                // functions have been queued between the last call to DispatchEvents and the completion
+                // of the current load job
+                if (m_shouldDispatchEvents)
+                {
+                    AssetManager::Instance().DispatchEvents();
+                }
             }
 
             void Finish()

Code/Framework/AzCore/AzCore/Component/Component.h

@@ -22,6 +22,7 @@
 #include <AzCore/Memory/Memory.h>
 #include <AzCore/Memory/SystemAllocator.h> // Used as the allocator for most components.
 #include <AzCore/Outcome/Outcome.h>
+#include <AzCore/std/containers/unordered_set.h>
 
 namespace AZ
 {

Code/Framework/AzCore/AzCore/Debug/AssetTracking.h

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <AzCore/Memory/OSAllocator.h>
 #include <AzCore/std/smart_ptr/unique_ptr.h>
 #include <AzCore/EBus/Policies.h>
 

Code/Framework/AzCore/AzCore/EBus/EBus.h

@@ -19,14 +19,11 @@
 #pragma once
 
 #include <AzCore/EBus/BusImpl.h>
+#include <AzCore/EBus/Environment.h>
 #include <AzCore/EBus/Results.h>
 #include <AzCore/EBus/Internal/Debug.h>
 
- // Included for backwards compatibility purposes
-#include <AzCore/std/smart_ptr/unique_ptr.h>
-#include <AzCore/std/containers/unordered_set.h>
 #include <AzCore/std/typetraits/is_same.h>
-// End backwards compat
 
 #include <AzCore/std/utils.h>
 #include <AzCore/std/parallel/scoped_lock.h>
@@ -90,14 +87,14 @@ namespace AZ
          * For available settings, see AZ::EBusHandlerPolicy.
          * By default, an EBus supports any number of handlers.
          */
-        static const EBusHandlerPolicy HandlerPolicy = EBusHandlerPolicy::Multiple;
+        static constexpr EBusHandlerPolicy HandlerPolicy = EBusHandlerPolicy::Multiple;
 
         /**
          * Defines how many addresses exist on the EBus.
          * For available settings, see AZ::EBusAddressPolicy.
          * By default, an EBus uses a single address.
          */
-        static const EBusAddressPolicy AddressPolicy = EBusAddressPolicy::Single;
+        static constexpr EBusAddressPolicy AddressPolicy = EBusAddressPolicy::Single;
 
         /**
          * The type of ID that is used to address the EBus.
@@ -152,14 +149,14 @@ namespace AZ
          * `<BusName>::ExecuteQueuedEvents()`.
          * By default, the event queue is disabled.
          */
-        static const bool EnableEventQueue = false;
+        static constexpr bool EnableEventQueue = false;
 
         /**
          * Specifies whether the bus should accept queued messages by default or not.
          * If set to false, Bus::AllowFunctionQueuing(true) must be called before events are accepted.
          * Used only when #EnableEventQueue is true.
          */
-        static const bool EventQueueingActiveByDefault = true;
+        static constexpr bool EventQueueingActiveByDefault = true;
 
         /**
          * Specifies whether the EBus supports queueing functions which take reference
@@ -168,7 +165,7 @@ namespace AZ
          * You should only use this if you know that the data being passed as arguments will
          * outlive the dispatch of the queued event.
          */
-        static const bool EnableQueuedReferences = false;
+        static constexpr bool EnableQueuedReferences = false;
 
         /**
          * Locking primitive that is used when adding and removing
@@ -197,7 +194,7 @@ namespace AZ
         * to do.
         * By default, the standard policy is used, which locks around all dispatches
         */
-        static const bool LocklessDispatch = false;
+        static constexpr bool LocklessDispatch = false;
 
         /**
          * Specifies where EBus data is stored.

Code/Framework/AzCore/AzCore/EBus/IEventScheduler.h

@@ -13,6 +13,7 @@
 #include <AzCore/EBus/EBus.h>
 #include <AzCore/RTTI/RTTI.h>
 #include <AzCore/RTTI/TypeSafeIntegral.h>
+#include <AzCore/std/smart_ptr/unique_ptr.h>
 
 namespace AZ
 {

Code/Framework/AzCore/AzCore/EBus/Policies.h

@@ -18,9 +18,8 @@
 #include <AzCore/std/function/invoke.h>
 #include <AzCore/std/containers/queue.h>
 #include <AzCore/std/containers/intrusive_set.h>
+#include <AzCore/std/parallel/scoped_lock.h>
 
-#include <AzCore/Module/Environment.h>
-#include <AzCore/EBus/Environment.h>
 
 namespace AZ
 {
@@ -251,29 +250,21 @@ namespace AZ
         void Execute()
         {
             AZ_Warning("System", m_isActive, "You are calling execute queued functions on a bus which has not activated its function queuing! Call YourBus::AllowFunctionQueuing(true)!");
-            while (true)
-            {
-                BusMessageCall invoke;
 
-                //////////////////////////////////////////////////////////////////////////
+            MessageQueueType localMessages;
-                // Pop element from the queue.
+
-                {
+            // Swap the current list of queue functions with a local instance
-                    AZStd::lock_guard<MutexType> lock(m_messagesMutex);
-                    size_t numMessages = m_messages.size();
-                    if (numMessages == 0)
-                    {
-                        break;
-                    }
-                    AZStd::swap(invoke, m_messages.front());
-                    m_messages.pop();
-                    if (numMessages == 1)
             {
-                        m_messages = {};
+                AZStd::scoped_lock lock(m_messagesMutex);
-                    }
+                AZStd::swap(localMessages, m_messages);
             }
-                //////////////////////////////////////////////////////////////////////////
 
-                invoke();
+            // Execute the queue functions safely now that are owned by the function
+            while (!localMessages.empty())
+            {
+                const BusMessageCall& localMessage = localMessages.front();
+                localMessage();
+                localMessages.pop();
             }
         }
 

Code/Framework/AzCore/AzCore/RTTI/BehaviorContext.h

@@ -14,6 +14,7 @@
 #include <AzCore/RTTI/ReflectContext.h>
 #include <AzCore/std/containers/array.h>
 #include <AzCore/std/containers/unordered_map.h>
+#include <AzCore/std/containers/unordered_set.h>
 #include <AzCore/std/function/invoke.h>
 #include <AzCore/std/string/string.h>
 #include <AzCore/std/string/string_view.h>

Code/Framework/AzCore/Tests/Asset/AssetManagerLoadingTests.cpp

@@ -366,6 +366,42 @@ namespace UnitTest
 
     };
 
+    static constexpr AZStd::chrono::seconds MaxDispatchTimeoutSeconds = BaseAssetManagerTest::DefaultTimeoutSeconds * 12;
+    
+    template <typename Pred>
+    bool DispatchEventsUntilCondition(AZ::Data::AssetManager& assetManager, Pred&& conditionPredicate,
+        AZStd::chrono::seconds logIntervalSeconds = BaseAssetManagerTest::DefaultTimeoutSeconds,
+        AZStd::chrono::seconds maxTimeoutSeconds = MaxDispatchTimeoutSeconds)
+    {
+        // If the Max Timeout is hit the test will be marked as a failure
+
+        AZStd::chrono::time_point dispatchEventTimeStart = AZStd::chrono::system_clock::now();
+        AZStd::chrono::seconds dispatchEventNextLogTime = logIntervalSeconds;
+
+        while (!conditionPredicate())
+        {
+            AZStd::chrono::time_point currentTime = AZStd::chrono::system_clock::now();
+            if (AZStd::chrono::seconds elapsedTime{ currentTime - dispatchEventTimeStart };
+                elapsedTime >= dispatchEventNextLogTime)
+            {
+                const testing::TestInfo* test_info = ::testing::UnitTest::GetInstance()->current_test_info();
+                AZ_Printf("AssetManagerLoadingTest", "The DispatchEventsUntiTimeout function has been waiting for %llu seconds"
+                    " in test %s.%s", elapsedTime.count(), test_info->test_case_name(), test_info->name());
+                // Update the next log time to be the next multiple of DefaultTimeout Seconds
+                // after current elapsed time
+                dispatchEventNextLogTime = elapsedTime + logIntervalSeconds - ((elapsedTime + logIntervalSeconds) % logIntervalSeconds);
+                if (elapsedTime >= maxTimeoutSeconds)
+                {
+                    return false;
+                }
+            }
+            assetManager.DispatchEvents();
+            AZStd::this_thread::yield();
+        }
+
+        return true;
+    }
+
 #if AZ_TRAIT_DISABLE_FAILED_ASSET_MANAGER_TESTS || AZ_TRAIT_DISABLE_ASSET_MANAGER_FLOOD_TEST
     TEST_F(AssetJobsFloodTest, DISABLED_FloodTest)
 #else
@@ -1358,42 +1394,74 @@ namespace UnitTest
         m_assetHandlerAndCatalog->m_numCreations = 0;
         m_assetHandlerAndCatalog->m_numDestructions = 0;
         {
+            ContainerReadyListener containerLoadingCompleteListener(NoLoadAssetId);
             OnAssetReadyListener readyListener(NoLoadAssetId, azrtti_typeid<AssetWithAssetReference>());
-            OnAssetReadyListener depenencyListener(MyAsset2Id, azrtti_typeid<AssetWithAssetReference>());
+            OnAssetReadyListener dependencyListener(MyAsset2Id, azrtti_typeid<AssetWithAssetReference>());
 
-            auto noLoadRef = m_testAssetManager->GetAsset(NoLoadAssetId, azrtti_typeid<AssetWithAssetReference>(),
+            SCOPED_TRACE("LoadDependencies_BehaviorObeyed");
-                AZ::Data::AssetLoadBehavior::Default);
 
-            auto maxTimeout = AZStd::chrono::system_clock::now() + DefaultTimeoutSeconds;
+            auto AssetOnlyReady = [&readyListener]() -> bool
-
-            while (!readyListener.m_ready)
             {
-                m_testAssetManager->DispatchEvents();
+                return readyListener.m_ready;
-                if (AZStd::chrono::system_clock::now() > maxTimeout)
+            };
+            auto AssetAndDependencyReady = [&readyListener, &dependencyListener]() -> bool
             {
-                    break;
+                return readyListener.m_ready && dependencyListener.m_ready;
-                }
+            };
-                AZStd::this_thread::yield();
+            auto AssetContainerReady = [&containerLoadingCompleteListener]() -> bool
-            }
+            {
-            EXPECT_EQ(readyListener.m_ready, 1);
+                return containerLoadingCompleteListener.m_ready;
-            EXPECT_EQ(depenencyListener.m_ready, 0);
+            };
+
+            auto noLoadRef = m_testAssetManager->GetAsset(NoLoadAssetId, azrtti_typeid<AssetWithAssetReference>(),
+                AZ::Data::AssetLoadBehavior::Default);
+
+            // Dispatch AssetBus events until the NoLoadAssetId has signaled an OnAssetReady
+            // event or the timeout has been reached
+            EXPECT_TRUE(DispatchEventsUntilCondition(*m_testAssetManager, AssetOnlyReady))
+                << "The DispatchEventsUntiTimeout function has not completed in "
+                << MaxDispatchTimeoutSeconds.count() << " seconds. The test will be marked as a failure\n";
+
+            // Dispatch AssetBus events until the asset container used to load
+            // NoLoadAssetId has signaled an OnAssetContainerReady event
+            // or the timeout has been reached
+            // Wait until the current asset container has finished loading the NoLoadAssetId
+            // before trigger another load
+            // If the wait does not occur here, most likely what would occur is
+            // the AssetManager::m_ownedAssetContainers object is still loading the NoLoadAssetId
+            // using the default AssetLoadParameters
+            // If a call to GetAsset occurs at this point while the Asset is still loading
+            // it will ignore the new loadParams below and instead just re-use the existing
+            // AssetContainerReader instance, resulting in the dependent MyAsset2Id not
+            // being loaded
+            // The function that can return an existing AssetContainer instance is the
+            // AssetManager::GetAssetContainer. Since it can be in the middle of a load,
+            // updating the AssetLoadParams would have an effect on the current in progress
+            // load
+            EXPECT_TRUE(DispatchEventsUntilCondition(*m_testAssetManager, AssetContainerReady))
+                << "The DispatchEventsUntiTimeout function has not completed in "
+                << MaxDispatchTimeoutSeconds.count() << " seconds. The test will be marked as a failure\n";
+
+            // Reset the ContainerLoadingComplete ready status back to 0
+            containerLoadingCompleteListener.m_ready = 0;
 
             AZ::Data::AssetLoadParameters loadParams(nullptr, AZ::Data::AssetDependencyLoadRules::LoadAll);
             loadParams.m_reloadMissingDependencies = true;
             auto loadDependencyRef = m_testAssetManager->GetAsset(NoLoadAssetId, azrtti_typeid<AssetWithAssetReference>(),
                 AZ::Data::AssetLoadBehavior::Default, loadParams);
 
-            while (!depenencyListener.m_ready || !readyListener.m_ready)
+            // Dispatch AssetBus events until the NoLoadAssetId and the MyAsset2Id has signaled
-            {
+            // an OnAssetReady event or the timeout has been reached
-                m_testAssetManager->DispatchEvents();
+            EXPECT_TRUE(DispatchEventsUntilCondition(*m_testAssetManager, AssetAndDependencyReady))
-                if (AZStd::chrono::system_clock::now() > maxTimeout)
+                << "The DispatchEventsUntiTimeout function has not completed in "
-                {
+                << MaxDispatchTimeoutSeconds.count() << " seconds. The test will be marked as a failure\n";
-                    break;
+
-                }
-                AZStd::this_thread::yield();
-            }
             EXPECT_EQ(readyListener.m_ready, 1);
-            EXPECT_EQ(depenencyListener.m_ready, 1);
+            EXPECT_EQ(dependencyListener.m_ready, 1);
+
+            EXPECT_TRUE(DispatchEventsUntilCondition(*m_testAssetManager, AssetContainerReady))
+                << "The DispatchEventsUntiTimeout function has not completed in "
+                << MaxDispatchTimeoutSeconds.count() << " seconds. The test will be marked as a failure\n";
         }
 
         CheckFinishedCreationsAndDestructions();

Code/Framework/AzCore/Tests/UUIDTests.cpp

@@ -7,6 +7,7 @@
  */
 #include <AzCore/UnitTest/TestTypes.h>
 #include <AzCore/Math/Uuid.h>
+#include <AzCore/std/containers/unordered_set.h>
 
 using namespace AZ;
 

Code/Framework/AzFramework/AzFramework/Archive/ZipDirCache.h

@@ -18,6 +18,7 @@
 #include <AzCore/IO/FileIO.h>
 #include <AzCore/IO/Path/Path.h>
 #include <AzCore/Memory/PoolAllocator.h>
+#include <AzCore/std/containers/unordered_set.h>
 #include <AzCore/std/smart_ptr/intrusive_base.h>
 #include <AzFramework/Archive/Codec.h>
 #include <AzFramework/Archive/ZipDirStructures.h>

Code/Framework/AzFramework/AzFramework/Logging/MissingAssetLogger.h

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <AzCore/std/smart_ptr/unique_ptr.h>
 #include <AzFramework/Logging/MissingAssetNotificationBus.h>
 
 namespace AzFramework { class LogFile; }

Code/Framework/AzFramework/AzFramework/Render/GeometryIntersectionStructures.h

@@ -11,6 +11,7 @@
 #include <AzCore/Math/Vector2.h>
 #include <AzCore/Math/Vector3.h>
 #include <AzCore/Component/ComponentBus.h>
+#include <AzCore/std/containers/unordered_set.h>
 #include <AzCore/std/functional.h>
 
 //! Common structures for Render geometry queries

Code/Framework/AzFramework/AzFramework/Windowing/NativeWindow.h

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <AzCore/Memory/SystemAllocator.h>
+#include <AzCore/std/smart_ptr/unique_ptr.h>
 
 #include <AzFramework/Windowing/WindowBus.h>
 

Code/Framework/AzNetworking/AzNetworking/UdpTransport/UdpConnectionSet.h

@@ -11,6 +11,7 @@
 #include <AzNetworking/Utilities/IpAddress.h>
 #include <AzNetworking/ConnectionLayer/IConnectionSet.h>
 #include <AzCore/std/containers/unordered_map.h>
+#include <AzCore/std/smart_ptr/unique_ptr.h>
 
 namespace AzNetworking
 {

Code/Framework/AzToolsFramework/AzToolsFramework/AssetBrowser/Entries/AssetBrowserEntryCache.h

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <AzCore/Memory/SystemAllocator.h>
+#include <AzCore/std/containers/unordered_set.h>
 #include <AzCore/std/containers/unordered_map.h>
 #include <AzToolsFramework/AssetBrowser/Entries/AssetBrowserEntry.h>
 

Code/Framework/AzToolsFramework/AzToolsFramework/AssetBrowser/Entries/RootAssetBrowserEntry.h

@@ -7,6 +7,7 @@
  */
 #pragma once
 
+#include <AzCore/std/containers/unordered_set.h>
 #include <AzCore/std/string/string.h>
 #include <AzCore/Asset/AssetCommon.h>
 #include <AzCore/IO/Path/Path.h>

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/BaseManipulator.h

@@ -15,7 +15,7 @@
 #include <AzCore/Math/Quaternion.h>
 #include <AzCore/Math/Transform.h>
 #include <AzCore/RTTI/RTTI.h>
-#include <AzCore/std/containers/set.h>
+#include <AzCore/std/containers/unordered_set.h>
 #include <AzCore/std/smart_ptr/enable_shared_from_this.h>
 #include <AzToolsFramework/Manipulators/ManipulatorBus.h>
 #include <AzToolsFramework/Manipulators/ManipulatorSpace.h>

Code/Framework/AzToolsFramework/AzToolsFramework/SourceControl/SourceControlAPI.h

@@ -10,6 +10,7 @@
 
 #include <AzCore/base.h>
 #include <AzCore/EBus/EBus.h>
+#include <AzCore/std/containers/unordered_set.h>
 #include <AzCore/std/string/string.h>
 
 namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportUi/ButtonGroup.h

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <AzCore/std/smart_ptr/unique_ptr.h>
 #include <AzToolsFramework/ViewportUi/ViewportUiRequestBus.h>
 
 namespace AzToolsFramework::ViewportUi::Internal

Code/Tools/AssetProcessor/native/unittests/AssetProcessorServerUnitTests.h

@@ -11,6 +11,7 @@
 #if !defined(Q_MOC_RUN)
 #include "UnitTestRunner.h"
 #include "native/utilities/IniConfiguration.h"
+#include <AzCore/std/smart_ptr/unique_ptr.h>
 #include <QString>
 #endif
 

Code/Tools/ProjectManager/Source/PythonBindings.cpp

@@ -21,6 +21,7 @@
 
 #include <AzCore/IO/FileIO.h>
 #include <AzCore/IO/SystemFile.h>
+#include <AzCore/std/containers/unordered_set.h>
 #include <AzCore/std/string/conversions.h>
 #include <AzCore/StringFunc/StringFunc.h>
 

Code/Tools/Standalone/Source/LUA/LUAEditorStyleMessages.h

@@ -8,6 +8,7 @@
 
 #include <AzCore/base.h>
 #include <AzCore/EBus/EBus.h>
+#include <AzCore/std/containers/unordered_set.h>
 #include <AzCore/UserSettings/UserSettings.h>
 #include <AzCore/Math/Vector3.h>
 #include <AzCore/Memory/SystemAllocator.h>

Gems/AWSClientAuth/Code/Include/Private/AWSClientAuthBus.h

@@ -9,6 +9,8 @@
 
 #include <AzCore/EBus/EBus.h>
 
+#include <memory>
+
 namespace Aws
 {
     namespace CognitoIdentityProvider

Gems/AWSCore/Code/Include/Private/Editor/UI/AWSCoreEditorMenu.h

@@ -9,6 +9,7 @@
 
 #include <AzCore/EBus/EBus.h>
 #include <AzCore/std/string/string.h>
+#include <AzCore/std/smart_ptr/unique_ptr.h>
 
 #include <AWSCoreBus.h>
 

Gems/AssetMemoryAnalyzer/Code/Source/AssetMemoryAnalyzer.cpp

@@ -11,6 +11,7 @@
 #include <AzCore/Memory/MemoryDrillerBus.h>
 #include <AzCore/Debug/AssetTrackingTypesImpl.h>
 #include <AzCore/Debug/AssetTracking.h>
+#include <AzCore/std/containers/unordered_set.h>
 #include <AzCore/std/smart_ptr/make_shared.h>
 
 ///////////////////////////////////////////////////////////////////////////////

Gems/Atom/RHI/Code/Include/Atom/RHI/ThreadLocalContext.h

@@ -11,6 +11,7 @@
 
 #include <AzCore/std/parallel/threadbus.h>
 #include <AzCore/std/parallel/shared_mutex.h>
+#include <AzCore/std/smart_ptr/unique_ptr.h>
 
 namespace AZ
 {

Gems/Atom/Tools/MaterialEditor/Code/Include/Atom/Window/MaterialEditorWindowSettings.h

@@ -12,6 +12,7 @@
 #include <AzCore/Memory/Memory.h>
 #include <AzCore/RTTI/RTTI.h>
 #include <AzCore/RTTI/ReflectContext.h>
+#include <AzCore/std/containers/unordered_set.h>
 #include <AzCore/UserSettings/UserSettings.h>
 #endif
 

Gems/Atom/Utils/Code/Include/Atom/Utils/AssetCollectionAsyncLoader.h

@@ -7,6 +7,7 @@
  */
 #pragma once
 
+#include <AzCore/std/containers/unordered_set.h>
 #include <AzCore/std/containers/vector.h>
 #include <AzCore/std/string/string.h>
 #include <AzCore/std/parallel/shared_mutex.h>

Gems/GraphCanvas/Code/StaticLib/GraphCanvas/Utils/StateControllers/StateController.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <AzCore/EBus/EBus.h>
+#include <AzCore/std/containers/unordered_set.h>
 
 // A configurable queue that allows for multiple sources to try to control a single value in a configurable way
 // such that each object can control the object independently of the other systems, while still maintaining a reasonable state.

Gems/ScriptCanvasDeveloper/Code/Editor/Include/ScriptCanvasDeveloperEditor/EditorAutomation/EditorAutomationTest.h

@@ -11,6 +11,7 @@
 
 #include <AzCore/Component/TickBus.h>
 #include <AzCore/std/any.h>
+#include <AzCore/std/containers/unordered_set.h>
 
 #include <ScriptCanvasDeveloperEditor/EditorAutomation/EditorAutomationAction.h>
 #include <ScriptCanvasDeveloperEditor/EditorAutomation/EditorAutomationModelIds.h>