merging latest development

Signed-off-by: kberg-amzn <karlberg@amazon.com>

.gitignore

@@ -7,7 +7,7 @@ AssetProcessorTemp/**
 [Oo]ut/**
 CMakeUserPresets.json
 [Cc]ache/
-/install/
+/[Ii]nstall/
 Editor/EditorEventLog.xml
 Editor/EditorLayout.xml
 **/*egg-info/**

Assets/Engine/Config/performance.cfg

@@ -1,6 +0,0 @@
-e_StatoscopeScreenshotCapturePeriod = 1
-
-e_StatoscopeDataGroups = Oulm
-sys_pakLogInvalidFileAccess = 1
-e_StatoscopeWriteTimeout = 10
-e_StatoscopeConnectTimeout = 10

AutomatedTesting/Gem/PythonTests/AWS/CMakeLists.txt

@@ -17,15 +17,15 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
         return()
     endif()
 
-    # Enable after installing NodeJS and CDK on jenkins Windows AMI.
     ly_add_pytest(
         NAME AutomatedTesting::AWSTests
-        TEST_SUITE periodic
+        TEST_SUITE awsi
         TEST_SERIAL
         PATH ${CMAKE_CURRENT_LIST_DIR}/${PAL_PLATFORM_NAME}/
         RUNTIME_DEPENDENCIES
             Legacy::Editor
             AZ::AssetProcessor
+            AutomatedTesting.GameLauncher
             AutomatedTesting.Assets
         COMPONENT
             AWS

AutomatedTesting/Gem/PythonTests/AWS/Windows/aws_metrics/aws_metrics_automation_test.py

@@ -133,7 +133,7 @@ def update_kinesis_analytics_application_status(aws_metrics_utils: pytest.fixtur
         aws_metrics_utils.stop_kinesis_data_analytics_application(
             resource_mappings.get_resource_name_id('AWSMetrics.AnalyticsApplicationName'))
 
-@pytest.mark.SUITE_periodic
+@pytest.mark.SUITE_awsi
 @pytest.mark.usefixtures('automatic_process_killer')
 @pytest.mark.usefixtures('aws_credentials')
 @pytest.mark.usefixtures('resource_mappings')

AutomatedTesting/Gem/PythonTests/AWS/Windows/client_auth/aws_client_auth_automation_test.py

@@ -21,7 +21,7 @@ AWS_CLIENT_AUTH_FEATURE_NAME = 'AWSClientAuth'
 logger = logging.getLogger(__name__)
 
 
-@pytest.mark.SUITE_periodic
+@pytest.mark.SUITE_awsi
 @pytest.mark.usefixtures('asset_processor')
 @pytest.mark.usefixtures('automatic_process_killer')
 @pytest.mark.usefixtures('aws_utils')

AutomatedTesting/Gem/PythonTests/AWS/Windows/core/test_aws_resource_interaction.py

@@ -74,7 +74,7 @@ def write_test_data_to_dynamodb_table(resource_mappings: pytest.fixture, aws_uti
         raise
 
 
-@pytest.mark.SUITE_periodic
+@pytest.mark.SUITE_awsi
 @pytest.mark.usefixtures('automatic_process_killer')
 @pytest.mark.usefixtures('asset_processor')
 @pytest.mark.parametrize('feature_name', [AWS_CORE_FEATURE_NAME])

AutomatedTesting/Gem/PythonTests/Blast/CMakeLists.txt

@@ -8,10 +8,10 @@
 
 if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
     ly_add_pytest(
-        NAME AutomatedTesting::BlastTests
+        NAME AutomatedTesting::BlastTests_Main
         TEST_SUITE main
         TEST_SERIAL TRUE
-        PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Active.py
+        PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Main.py
         RUNTIME_DEPENDENCIES
             Legacy::Editor
             AZ::AssetProcessor

AutomatedTesting/Gem/PythonTests/Blast/ImportPathHelper.py

@@ -1,11 +0,0 @@
-"""
-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
-"""
-
-def init():
-    import os
-    import sys
-    sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/../automatedtesting_shared')

AutomatedTesting/Gem/PythonTests/Blast/TestSuite_Main.py

@@ -22,29 +22,29 @@ from base import TestAutomationBase
 @pytest.mark.parametrize("project", ["AutomatedTesting"])
 class TestAutomation(TestAutomationBase):
     def test_ActorSplitsAfterCollision(self, request, workspace, editor, launcher_platform):
-        from . import ActorSplitsAfterCollision as test_module
+        from .tests import Blast_ActorSplitsAfterCollision as test_module
         self._run_test(request, workspace, editor, test_module)
 
     def test_ActorSplitsAfterRadialDamage(self, request, workspace, editor, launcher_platform):
-        from . import ActorSplitsAfterRadialDamage as test_module
+        from .tests import Blast_ActorSplitsAfterRadialDamage as test_module
         self._run_test(request, workspace, editor, test_module)
 
     def test_ActorSplitsAfterCapsuleDamage(self, request, workspace, editor, launcher_platform):
-        from . import ActorSplitsAfterCapsuleDamage as test_module
+        from .tests import Blast_ActorSplitsAfterCapsuleDamage as test_module
         self._run_test(request, workspace, editor, test_module)
 
     def test_ActorSplitsAfterImpactSpreadDamage(self, request, workspace, editor, launcher_platform):
-        from . import ActorSplitsAfterImpactSpreadDamage as test_module
+        from .tests import Blast_ActorSplitsAfterImpactSpreadDamage as test_module
         self._run_test(request, workspace, editor, test_module)
 
     def test_ActorSplitsAfterShearDamage(self, request, workspace, editor, launcher_platform):
-        from . import ActorSplitsAfterShearDamage as test_module
+        from .tests import Blast_ActorSplitsAfterShearDamage as test_module
         self._run_test(request, workspace, editor, test_module)
 
     def test_ActorSplitsAfterTriangleDamage(self, request, workspace, editor, launcher_platform):
-        from . import ActorSplitsAfterTriangleDamage as test_module
+        from .tests import Blast_ActorSplitsAfterTriangleDamage as test_module
         self._run_test(request, workspace, editor, test_module)
 
     def test_ActorSplitsAfterStressDamage(self, request, workspace, editor, launcher_platform):
-        from . import ActorSplitsAfterStressDamage as test_module
+        from .tests import Blast_ActorSplitsAfterStressDamage as test_module
         self._run_test(request, workspace, editor, test_module)

AutomatedTesting/Gem/PythonTests/Blast/tests/BaseDamageTest.py

@@ -41,11 +41,7 @@ def base_run(damage_func):
 
     :return: None
     """
-
-    import ImportPathHelper as imports
-
-    imports.init()
-
+    
     from editor_python_test_tools.utils import Report
     from editor_python_test_tools.utils import TestHelper as helper
 

AutomatedTesting/Gem/PythonTests/Blast/tests/Blast_ActorSplitsAfterCapsuleDamage.py

@@ -9,10 +9,8 @@ import os
 import sys
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
-from ActorSplitsAfterDamage import Tests
-
-def ActorSplitsAfterCapsuleDamage():
-    from ActorSplitsAfterDamage import base_run as internal_run
+def Blast_ActorSplitsAfterCapsuleDamage():
+    from BaseDamageTest import base_run as internal_run
     from BlastUtils import Constants
 
     def CapsuleDamage(target_id, position0):
@@ -26,8 +24,5 @@ def ActorSplitsAfterCapsuleDamage():
 
 
 if __name__ == "__main__":
-    import ImportPathHelper as imports
-    imports.init()
-
     from editor_python_test_tools.utils import Report
-    Report.start_test(ActorSplitsAfterCapsuleDamage)
+    Report.start_test(Blast_ActorSplitsAfterCapsuleDamage)

AutomatedTesting/Gem/PythonTests/Blast/tests/Blast_ActorSplitsAfterCollision.py

@@ -18,7 +18,7 @@ class Tests():
 # fmt: on
 
 
-def ActorSplitsAfterCollision():
+def Blast_ActorSplitsAfterCollision():
 
     """
     Summary:
@@ -46,10 +46,6 @@ def ActorSplitsAfterCollision():
     :return: None
     """
 
-    import ImportPathHelper as imports
-
-    imports.init()
-
     from editor_python_test_tools.utils import Report
     from editor_python_test_tools.utils import TestHelper as helper
 
@@ -103,8 +99,5 @@ def ActorSplitsAfterCollision():
 
 
 if __name__ == "__main__":
-    import ImportPathHelper as imports
-    imports.init()
-
     from editor_python_test_tools.utils import Report
-    Report.start_test(ActorSplitsAfterCollision)
+    Report.start_test(Blast_ActorSplitsAfterCollision)

AutomatedTesting/Gem/PythonTests/Blast/tests/Blast_ActorSplitsAfterImpactSpreadDamage.py

@@ -9,10 +9,8 @@ import os
 import sys
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
-from ActorSplitsAfterDamage import Tests
-
-def ActorSplitsAfterImpactSpreadDamage():
-    from ActorSplitsAfterDamage import base_run as internal_run
+def Blast_ActorSplitsAfterImpactSpreadDamage():
+    from BaseDamageTest import base_run as internal_run
     from BlastUtils import Constants
 
     def ImpactSpreadDamage(target_id, position):
@@ -24,8 +22,5 @@ def ActorSplitsAfterImpactSpreadDamage():
 
 
 if __name__ == "__main__":
-    import ImportPathHelper as imports
-    imports.init()
-
     from editor_python_test_tools.utils import Report
-    Report.start_test(ActorSplitsAfterImpactSpreadDamage)
+    Report.start_test(Blast_ActorSplitsAfterImpactSpreadDamage)

AutomatedTesting/Gem/PythonTests/Blast/tests/Blast_ActorSplitsAfterRadialDamage.py

@@ -9,10 +9,8 @@ import os
 import sys
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
-from ActorSplitsAfterDamage import Tests
-
-def ActorSplitsAfterRadialDamage():
-    from ActorSplitsAfterDamage import base_run as internal_run
+def Blast_ActorSplitsAfterRadialDamage():
+    from BaseDamageTest import base_run as internal_run
     from BlastUtils import Constants
 
     def RadialDamage(target_id, position):
@@ -24,8 +22,5 @@ def ActorSplitsAfterRadialDamage():
 
 
 if __name__ == "__main__":
-    import ImportPathHelper as imports
-    imports.init()
-
     from editor_python_test_tools.utils import Report
-    Report.start_test(ActorSplitsAfterRadialDamage)
+    Report.start_test(Blast_ActorSplitsAfterRadialDamage)

AutomatedTesting/Gem/PythonTests/Blast/tests/Blast_ActorSplitsAfterShearDamage.py

@@ -9,10 +9,8 @@ import os
 import sys
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
-from ActorSplitsAfterDamage import Tests
-
-def ActorSplitsAfterShearDamage():
-    from ActorSplitsAfterDamage import base_run as internal_run
+def Blast_ActorSplitsAfterShearDamage():
+    from BaseDamageTest import base_run as internal_run
     from BlastUtils import Constants
 
     def ShearDamage(target_id, position):
@@ -25,8 +23,5 @@ def ActorSplitsAfterShearDamage():
 
 
 if __name__ == "__main__":
-    import ImportPathHelper as imports
-    imports.init()
-
     from editor_python_test_tools.utils import Report
-    Report.start_test(ActorSplitsAfterShearDamage)
+    Report.start_test(Blast_ActorSplitsAfterShearDamage)

AutomatedTesting/Gem/PythonTests/Blast/tests/Blast_ActorSplitsAfterStressDamage.py

@@ -9,10 +9,8 @@ import os
 import sys
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
-from ActorSplitsAfterDamage import Tests
-
-def ActorSplitsAfterStressDamage():
-    from ActorSplitsAfterDamage import base_run as internal_run
+def Blast_ActorSplitsAfterStressDamage():
+    from BaseDamageTest import base_run as internal_run
     from BlastUtils import Constants
 
     def StressDamage(target_id, position):
@@ -24,8 +22,5 @@ def ActorSplitsAfterStressDamage():
 
 
 if __name__ == "__main__":
-    import ImportPathHelper as imports
-    imports.init()
-
     from editor_python_test_tools.utils import Report
-    Report.start_test(ActorSplitsAfterStressDamage)
+    Report.start_test(Blast_ActorSplitsAfterStressDamage)

AutomatedTesting/Gem/PythonTests/Blast/tests/Blast_ActorSplitsAfterTriangleDamage.py

@@ -9,10 +9,8 @@ import os
 import sys
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
-from ActorSplitsAfterDamage import Tests
-
-def ActorSplitsAfterTriangleDamage():
-    from ActorSplitsAfterDamage import base_run as internal_run
+def Blast_ActorSplitsAfterTriangleDamage():
+    from BaseDamageTest import base_run as internal_run
     from BlastUtils import Constants
 
     def TriangleDamage(target_id, position):
@@ -28,8 +26,5 @@ def ActorSplitsAfterTriangleDamage():
 
 
 if __name__ == "__main__":
-    import ImportPathHelper as imports
-    imports.init()
-
     from editor_python_test_tools.utils import Report
-    Report.start_test(ActorSplitsAfterTriangleDamage)
+    Report.start_test(Blast_ActorSplitsAfterTriangleDamage)

AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/editor_entity_utils.py

@@ -214,6 +214,12 @@ class EditorEntity:
         """
         return editor.EditorEntityInfoRequestBus(bus.Event, "GetParent", self.id)
 
+    def get_children_ids(self) -> List[azlmbr.entity.EntityId]:
+        """
+        :return: Entity ids of children. Type: [entity.EntityId()]
+        """
+        return editor.EditorEntityInfoRequestBus(bus.Event, "GetChildren", self.id)
+
     def add_component(self, component_name: str) -> EditorComponent:
         """
         Used to add new component to Entity.

AutomatedTesting/Gem/PythonTests/NvCloth/CMakeLists.txt

@@ -12,7 +12,7 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
         TEST_SUITE main
         TEST_REQUIRES gpu
         TEST_SERIAL
-        PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Active.py
+        PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Main.py
         RUNTIME_DEPENDENCIES
             Legacy::Editor
             AZ::AssetProcessor

AutomatedTesting/Gem/PythonTests/NvCloth/ImportPathHelper.py

@@ -1,11 +0,0 @@
-"""
-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
-"""
-
-def init():
-    import os
-    import sys
-    sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/../automatedtesting_shared')

AutomatedTesting/Gem/PythonTests/NvCloth/TestSuite_Main.py

@@ -22,12 +22,11 @@ from base import TestAutomationBase
 class TestAutomation(TestAutomationBase):
 
     use_null_renderer = False  # Use default renderer (needs gpu)
-    extra_cmdline_args = []
 
-    def test_C18977329_NvCloth_AddClothSimulationToMesh(self, request, workspace, editor, launcher_platform):
-        from . import C18977329_NvCloth_AddClothSimulationToMesh as test_module
-        self._run_test(request, workspace, editor, test_module, self.extra_cmdline_args, self.use_null_renderer)
+    def test_NvCloth_AddClothSimulationToMesh(self, request, workspace, editor, launcher_platform):
+        from .tests import NvCloth_AddClothSimulationToMesh as test_module
+        self._run_test(request, workspace, editor, test_module, use_null_renderer = self.use_null_renderer)
 
-    def test_C18977330_NvCloth_AddClothSimulationToActor(self, request, workspace, editor, launcher_platform):
-        from . import C18977330_NvCloth_AddClothSimulationToActor as test_module
-        self._run_test(request, workspace, editor, test_module, self.extra_cmdline_args, self.use_null_renderer)
+    def test_NvCloth_AddClothSimulationToActor(self, request, workspace, editor, launcher_platform):
+        from .tests import NvCloth_AddClothSimulationToActor as test_module
+        self._run_test(request, workspace, editor, test_module, use_null_renderer = self.use_null_renderer)

AutomatedTesting/Gem/PythonTests/NvCloth/tests/NvCloth_AddClothSimulationToActor.py

@@ -15,7 +15,7 @@ class Tests:
     exit_game_mode               = ("Exited game mode",               "Failed to exit game mode")
 # fmt: on
 
-def C18977330_NvCloth_AddClothSimulationToActor():
+def NvCloth_AddClothSimulationToActor():
     """
     Summary:
     Load level with Entity having Actor and Cloth components already setup. Verify that editor remains stable in Game mode.
@@ -44,11 +44,7 @@ def C18977330_NvCloth_AddClothSimulationToActor():
     
     from editor_python_test_tools.editor_entity_utils import EditorEntity
     from editor_python_test_tools.utils import Report
-    
-    # Helper file Imports
-    import ImportPathHelper as imports
 
-    imports.init()
     from editor_python_test_tools.utils import TestHelper as helper
     from editor_python_test_tools.utils import Tracer
     
@@ -57,7 +53,7 @@ def C18977330_NvCloth_AddClothSimulationToActor():
 
     helper.init_idle()
     # 1) Load the level
-    helper.open_level("NvCloth", "C18977330_NvCloth_AddClothSimulationToActor")
+    helper.open_level("NvCloth", "NvCloth_AddClothSimulationToActor")
 
     # 2) Start the Tracer to catch any errors and warnings
     with Tracer() as section_tracer:
@@ -84,7 +80,5 @@ def C18977330_NvCloth_AddClothSimulationToActor():
     helper.close_editor()
 
 if __name__ == "__main__":
-    import ImportPathHelper as imports
-    imports.init()
     from editor_python_test_tools.utils import Report
-    Report.start_test(C18977330_NvCloth_AddClothSimulationToActor)
+    Report.start_test(NvCloth_AddClothSimulationToActor)

AutomatedTesting/Gem/PythonTests/NvCloth/tests/NvCloth_AddClothSimulationToMesh.py

@@ -15,7 +15,7 @@ class Tests:
     exit_game_mode               = ("Exited game mode",               "Failed to exit game mode")
 # fmt: on
 
-def C18977329_NvCloth_AddClothSimulationToMesh():
+def NvCloth_AddClothSimulationToMesh():
     """
     Summary:
     Load level with Entity having Mesh and Cloth components already setup. Verify that editor remains stable in Game mode.
@@ -45,10 +45,6 @@ def C18977329_NvCloth_AddClothSimulationToMesh():
     from editor_python_test_tools.editor_entity_utils import EditorEntity
     from editor_python_test_tools.utils import Report
     
-    # Helper file Imports
-    import ImportPathHelper as imports
-
-    imports.init()
     from editor_python_test_tools.utils import TestHelper as helper
     from editor_python_test_tools.utils import Tracer
     
@@ -57,7 +53,7 @@ def C18977329_NvCloth_AddClothSimulationToMesh():
 
     helper.init_idle()
     # 1) Load the level
-    helper.open_level("NvCloth", "C18977329_NvCloth_AddClothSimulationToMesh")
+    helper.open_level("NvCloth", "NvCloth_AddClothSimulationToMesh")
 
     # 2) Start the Tracer to catch any errors and warnings
     with Tracer() as section_tracer:
@@ -84,7 +80,5 @@ def C18977329_NvCloth_AddClothSimulationToMesh():
     helper.close_editor()
 
 if __name__ == "__main__":
-    import ImportPathHelper as imports
-    imports.init()
     from editor_python_test_tools.utils import Report
-    Report.start_test(C18977329_NvCloth_AddClothSimulationToMesh)
+    Report.start_test(NvCloth_AddClothSimulationToMesh)

AutomatedTesting/Gem/PythonTests/WhiteBox/CMakeLists.txt

@@ -11,7 +11,7 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
         NAME AutomatedTesting::WhiteBoxTests
         TEST_SUITE main
         TEST_SERIAL
-        PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Active.py
+        PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Main.py
         RUNTIME_DEPENDENCIES
             Legacy::Editor
             AZ::AssetProcessor

AutomatedTesting/Gem/PythonTests/WhiteBox/FileManagement.py

@@ -1,350 +0,0 @@
-"""
-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
-
-"""
-
-# Imports
-import os
-import shutil
-import json
-import logging
-import ly_test_tools.environment.file_system as fs
-
-
-class FileManagement:
-    """
-    File Management static class: Handles file backup and restoration.
-    Organizes backing up files into a single directory and
-    mapping the back up files to their original files.
-
-    Features accessible via the exposed decorator functions.
-    """
-
-    # Static variables
-    MAX_BACKUPS = 10000  # Arbitrary number to cap same-file-name name generating
-    backup_folder_name = ".backup"
-    backup_folder_path = os.path.join(os.path.split(__file__)[0], backup_folder_name)  # CWD plus backup folder name
-    file_map_name = "_filebackup_map.json"  # JSON file to store original to back up file mappings
-
-    @staticmethod
-    def _load_file_map():
-        # type: () -> {str: str}
-        """
-        Loads the FileManagement's json file map.
-        The returned dictionary has key: value sets such that:
-                keys:   full path to an original file currently being backed up
-                values: name of the original file's backup file. Uses a numbering system for
-                    storing multiple file names that are identical but located in different directories.
-        If there is no current json file or the file cannot be parsed, an empty dictionary is returned.
-        :return: Dictionary to map original file's to their back up file names.
-        """
-        json_file_path = os.path.join(FileManagement.backup_folder_path, FileManagement.file_map_name)
-        if os.path.exists(json_file_path):
-            try:
-                with open(json_file_path, "r") as f:
-                    return json.load(f)
-            except ValueError:
-                logging.info("Decoding JSON file {} failed. Empty dictionary used".format(json_file_path))
-        return {}
-
-    @staticmethod
-    def _save_file_map(file_map):
-        # type: ({str: str}) -> None
-        """
-        Saves the [file_map] dictionary as a json file.
-        If [file_map] is empty, deletes the json file.
-        :param file_map: A dictionary mapping original file paths to their back up file names.
-        :return: None
-        """
-        file_path = os.path.join(FileManagement.backup_folder_path, FileManagement.file_map_name)
-        if os.path.exists(file_path):
-            fs.unlock_file(file_path)
-        if len(file_map) > 0:
-            with open(file_path, "w") as f:
-                json.dump(file_map, f)
-                fs.lock_file(file_path)
-        else:
-            fs.delete([file_path], True, False)
-
-    @staticmethod
-    def _next_available_name(file_name, file_map):
-        # type: (str, {str: str}) -> str or None
-        """
-        Generates the next available backup file name using a FILE_NAME_x.ext naming convention
-        where x is a number. Returns None if we've maxed out the numbering system.
-        :param file_name: The base file to generate a back up file name for.
-        :param file_map: The file_map for the FileManagement system
-        :return: str
-        """
-        suffix, extension = file_name.split(".", 1)
-        for i in range(FileManagement.MAX_BACKUPS):
-            potential_name = suffix + "_" + str(i) + "." + extension
-            if potential_name not in file_map.values():
-                return potential_name
-        return None
-
-    @staticmethod
-    def _backup_file(file_name, file_path):
-        # type: (str, str) -> None
-        """
-        Backs up the [file_name] located at [file_path] into the FileManagement's backup folder.
-        Leaves the backup file locked from writing privileges.
-        :param file_name: The file's name that will be backed up
-        :param file_path: The path to the file to back up
-        :return: None
-        """
-        file_map = FileManagement._load_file_map()
-        backup_path = FileManagement.backup_folder_path
-        backup_file_name = "{}.bak".format(file_name)
-        backup_file = os.path.join(backup_path, backup_file_name)
-        # If backup directory DNE, make one
-        if not os.path.exists(backup_path):
-            os.mkdir(backup_path)
-        # If "traditional" backup file exists, delete it (myFile.txt.bak)
-        if os.path.exists(backup_file):
-            fs.delete([backup_file], True, False)
-        # Find my next storage name (myFile_1.txt.bak)
-        backup_storage_file_name = FileManagement._next_available_name(backup_file_name, file_map)
-        if backup_storage_file_name is None:
-            # If _next_available_name returns None, we have backed up MAX_BACKUPS of files name [file_name]
-            raise Exception(
-                "FileManagement class ran out of backups per name. Max: {}".format(FileManagement.MAX_BACKUPS)
-            )
-        backup_storage_file = os.path.join(backup_path, backup_storage_file_name)
-        if os.path.exists(backup_storage_file):
-            # This file should not exists, but if it does it's about to get clobbered!
-            fs.unlock_file(backup_storage_file)
-        # Create "traditional" backup file (myFile.txt.bak)
-        fs.create_backup(os.path.join(file_path, file_name), backup_path)
-        # Copy "traditional" backup file into storage backup (myFile_1.txt.bak)
-        FileManagement._copy_file(backup_file_name, backup_path, backup_storage_file_name, backup_path)
-        fs.lock_file(backup_storage_file)
-        # Delete "traditional" back up file
-        fs.unlock_file(backup_file)
-        fs.delete([backup_file], True, False)
-        # Update file map with new file
-        file_map[os.path.join(file_path, file_name)] = backup_storage_file_name
-        FileManagement._save_file_map(file_map)
-        # Unlock original file to get it ready to be edited by the test
-        fs.unlock_file(os.path.join(file_path, file_name))
-
-    @staticmethod
-    def _restore_file(file_name, file_path):
-        # type: (str, str) -> None
-        """
-        Restores the [file_name] located at [file_path] which is backed up in FileManagement's backup folder.
-        Locks [file_name] from writing privileges when done restoring.
-        :param file_name: The Original file that was backed up, and now restored
-        :param file_path: The location of the original file that was backed up
-        :return: None
-        """
-        file_map = FileManagement._load_file_map()
-        backup_path = FileManagement.backup_folder_path
-        src_file = os.path.join(file_path, file_name)
-        if src_file in file_map:
-            backup_file = os.path.join(backup_path, file_map[src_file])
-            if os.path.exists(backup_file):
-                fs.unlock_file(backup_file)
-                fs.unlock_file(src_file)
-                # Make temporary copy of backed up file to restore from
-                temp_file = "{}.bak".format(file_name)
-                FileManagement._copy_file(file_map[src_file], backup_path, temp_file, backup_path)
-                fs.restore_backup(src_file, backup_path)
-                fs.lock_file(src_file)
-                # Delete backup file
-                fs.delete([os.path.join(backup_path, temp_file)], True, False)
-                fs.delete([backup_file], True, False)
-                # Remove from file map
-                del file_map[src_file]
-                FileManagement._save_file_map(file_map)
-                if not os.listdir(backup_path):
-                    # Delete backup folder if it's empty now
-                    os.rmdir(backup_path)
-
-    @staticmethod
-    def _find_files(file_names, root_dir, search_subdirs=False):
-        # type: ([str], str, bool) -> {str:str}
-        """
-        Searches the [root_dir] directory tree for each of the file names in [file_names]. Returns a dictionary
-        where keys = the entries in file_names, and their values are the paths they were found at.
-        Raises a runtime warning if not exactly one copy of each file is found.
-        :param file_names: A list of file_names to look for
-        :param root_dir: The root directory to begin the search
-        collect all file paths matching that file_name
-        :param search_subdirs: Optional boolean flag for searching sub-directories of [parent_path]
-        :return: A dictionary where keys are file names, and values are the file's path.
-        """
-        file_list = {}
-        found_count = 0
-        for file_name in file_names:
-            file_list[file_name] = None
-        if search_subdirs:
-            # Search parent path for all file name arguments
-            for dir_path, _, dir_files in os.walk(root_dir):
-                for dir_file in dir_files:
-                    if dir_file in file_list.keys():
-                        if file_list[dir_file] is None:
-                            file_list[dir_file] = dir_path
-                            found_count += 1
-                        else:
-                            # Found multiple files with same name. Raise warning.
-                            raise RuntimeWarning("Found multiple files with the name {}.".format(dir_file))
-        else:
-            for dir_file in os.listdir(root_dir):
-                if os.path.isfile(os.path.join(root_dir, dir_file)) and dir_file in file_names:
-                    file_list[dir_file] = root_dir
-        not_found = [file_name for file_name in file_names if file_list[file_name] is None]
-        if not_found:
-            raise RuntimeWarning("Could not find the following files: {}".format(not_found))
-
-        return file_list
-
-    @staticmethod
-    def _copy_file(src_file, src_path, target_file, target_path):
-        # type: (str, str, str, str) -> None
-        """
-        Copies the [src_file] at located in [src_path] to the [target_file] located at [target_path].
-        Leaves the [target_file] unlocked for reading and writing privileges
-        :param src_file: The source file to copy (file name)
-        :param src_path: The source file's path
-        :param target_file: The target file to copy into (file name)
-        :param target_path: The target file's path
-        :return: None
-        """
-        target_file_path = os.path.join(target_path, target_file)
-        src_file_path = os.path.join(src_path, src_file)
-        if os.path.exists(target_file_path):
-            fs.unlock_file(target_file_path)
-        shutil.copyfile(src_file_path, target_file_path)
-
-    @staticmethod
-    def file_revert(file_name, parent_path=None, search_subdirs=False):
-        # type: (str, str, bool) -> function
-        """
-        Function decorator:
-        Convenience version of file_revert_list for passing a single file
-        Calls file_revert_list on a list one [file_name]
-        :param file_name: The name of a file to backup (not path)
-        :param parent_path: The root directory to search for the [file_names] (relative to the dev folder).
-                    Defaults to the project folder described by the inner function's workspace fixture
-        :param search_subdirs: A boolean option for searching sub-directories for the files in [file_names]
-        :return: function as per the function decorator pattern
-        """
-        return FileManagement.file_revert_list([file_name], parent_path, search_subdirs)
-
-    @staticmethod
-    def file_revert_list(file_names, parent_path=None, search_subdirs=False):
-        # type: ([str], str, bool) -> function
-        """
-        Function decorator:
-        Collects file names specified in [file_names] in the [parent_path] directory.
-        Backs up these files before executing the parameter to the "wrap" function.
-        If the search_subdirs flag is True, searches all subdirectories of [parent_path] for files.
-        :param file_names: A list of file names (not paths)
-        :param parent_path: The root directory to search for the [file_names] (relative to the dev folder).
-                    Defaults to the project folder described by the inner function's workspace fixture
-        :param search_subdirs: A boolean option for searching sub-directories for the files in [file_names]
-        :return: function as per the function decorator pattern
-        """
-
-        def wrap(func):
-            # type: (function) -> function
-            def inner(self, request, workspace, editor, launcher_platform):
-                # type: (...) -> None
-                """
-                Inner function to wrap around decorated function. Function being decorated must match this
-                functions parameter order.
-                """
-                root_path = parent_path
-                if root_path is not None:
-                    root_path = os.path.join(workspace.paths.engine_root(), root_path)
-                else:
-                    # Default to project folder (AutomatedTesting)
-                    root_path = workspace.paths.project()
-
-                # Try to locate files
-                try:
-                    file_list = FileManagement._find_files(file_names, root_path, search_subdirs)
-                except RuntimeWarning as w:
-                    assert False, (
-                        w.message
-                        + " Please check use of search_subdirs; make sure you are using the correct parent directory."
-                    )
-
-                # Restore from backups
-                for file_name, file_path in file_list.items():
-                    FileManagement._restore_file(file_name, file_path)
-
-                # Create backups for each discovered path for each specified filename
-                for file_name, file_path in file_list.items():
-                    FileManagement._backup_file(file_name, file_path)
-
-                try:
-                    # Run the test
-                    func(self, request, workspace, editor, launcher_platform)
-                finally:
-                    # Restore backups for each discovered path for each specified filename if they exist
-                    for file_name, file_path in file_list.items():
-                        FileManagement._restore_file(file_name, file_path)
-
-            return inner
-
-        return wrap
-
-    @staticmethod
-    def file_override(target_file, src_file, parent_path=None, search_subdirs=False):
-        # type: (str, str, str, bool) -> function
-        """
-        Function decorator:
-        Searches for [target_file] and [src_file] in [parent_path](relative to the project dev folder)
-        and performs backup and file swapping. [target_file] is backed up and replaced with [src_file] before the
-        decorated function executes.
-        After the decorated function is executed [target_file] is restored to the state before being swapped.
-        If [parent_path] is not specified, the project folder described by the current workspace will be used.
-        If the search_subdirs flag is True, searches all subdirectories of [parent_path] for files.
-        :param target_file: The name of the file being backed up and swapped into
-        :param src_file: The name of the file to swap into [target_file]
-        :param parent_path: The root directory to search for the [file_names] (relative to the dev folder).
-                    Defaults to the project folder described by the inner function's workspace fixture
-        :param search_subdirs: A boolean option for searching sub-directories for the files in [file_names]
-        :return: The decorated function
-        """
-
-        def wrap(func):
-            def inner(self, request, workspace, editor, launcher_platform):
-                """
-                Inner function to wrap around decorated function. Function being decorated must match this
-                functions parameter order.
-                """
-                root_path = parent_path
-                if root_path is not None:
-                    root_path = os.path.join(workspace.paths.engine_root(), root_path)
-                else:
-                    # Default to project folder (AutomatedTesting)
-                    root_path = workspace.paths.project()
-
-                # Try to locate both target and source files
-                try:
-                    file_list = FileManagement._find_files([target_file, src_file], root_path, search_subdirs)
-                except RuntimeWarning as w:
-                    assert False, (
-                        w.message
-                        + " Please check use of search_subdirs; make sure you are using the correct parent directory."
-                    )
-
-                FileManagement._restore_file(target_file, file_list[target_file])
-                FileManagement._backup_file(target_file, file_list[target_file])
-                FileManagement._copy_file(src_file, file_list[src_file], target_file, file_list[target_file])
-
-                try:
-                    # Run Test
-                    func(self, request, workspace, editor, launcher_platform)
-                finally:
-                    FileManagement._restore_file(target_file, file_list[target_file])
-
-            return inner
-
-        return wrap

AutomatedTesting/Gem/PythonTests/WhiteBox/ImportPathHelper.py

@@ -1,11 +0,0 @@
-"""
-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
-"""
-
-def init():
-    import os
-    import sys
-    sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/../automatedtesting_shared')

AutomatedTesting/Gem/PythonTests/WhiteBox/TestSuite_Main.py

@@ -12,7 +12,6 @@ import pytest
 import sys
 import os
 
-from .FileManagement import FileManagement as fm
 from ly_test_tools import LAUNCHERS
 
 sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/../automatedtesting_shared')
@@ -23,14 +22,14 @@ from base import TestAutomationBase
 @pytest.mark.parametrize("launcher_platform", ['windows_editor'])
 @pytest.mark.parametrize("project", ["AutomatedTesting"])
 class TestAutomation(TestAutomationBase):
-    def test_C28798177_WhiteBox_AddComponentToEntity(self, request, workspace, editor, launcher_platform):
-        from . import C28798177_WhiteBox_AddComponentToEntity as test_module
+    def test_WhiteBox_AddComponentToEntity(self, request, workspace, editor, launcher_platform):
+        from .tests import WhiteBox_AddComponentToEntity as test_module
         self._run_test(request, workspace, editor, test_module)
 
-    def test_C29279329_WhiteBox_SetDefaultShape(self, request, workspace, editor, launcher_platform):
-        from . import C29279329_WhiteBox_SetDefaultShape as test_module
+    def test_WhiteBox_SetDefaultShape(self, request, workspace, editor, launcher_platform):
+        from .tests import WhiteBox_SetDefaultShape as test_module
         self._run_test(request, workspace, editor, test_module)
 
-    def test_C28798205_WhiteBox_SetInvisible(self, request, workspace, editor, launcher_platform):
-        from . import C28798205_WhiteBox_SetInvisible as test_module
+    def test_WhiteBox_SetInvisible(self, request, workspace, editor, launcher_platform):
+        from .tests import WhiteBox_SetInvisible as test_module
         self._run_test(request, workspace, editor, test_module)

AutomatedTesting/Gem/PythonTests/WhiteBox/tests/WhiteBox_AddComponentToEntity.py

@@ -21,8 +21,6 @@ def C28798177_WhiteBox_AddComponentToEntity():
     import os
     import sys
     from Gems.WhiteBox.Editor.Scripts import WhiteBoxInit as init
-    import ImportPathHelper as imports
-    imports.init()
 
     import azlmbr.bus as bus
     import azlmbr.editor as editor
@@ -53,8 +51,5 @@ def C28798177_WhiteBox_AddComponentToEntity():
 
 
 if __name__ == "__main__":
-    import ImportPathHelper as imports
-    imports.init()
-
     from editor_python_test_tools.utils import Report
     Report.start_test(C28798177_WhiteBox_AddComponentToEntity)

AutomatedTesting/Gem/PythonTests/WhiteBox/tests/WhiteBox_SetDefaultShape.py

@@ -25,8 +25,6 @@ def C29279329_WhiteBox_SetDefaultShape():
     import os
     import sys
     from Gems.WhiteBox.Editor.Scripts import WhiteBoxInit as init
-    import ImportPathHelper as imports
-    imports.init()
 
     import azlmbr.whitebox.api as api
     import azlmbr.bus as bus
@@ -102,8 +100,5 @@ def C29279329_WhiteBox_SetDefaultShape():
 
 
 if __name__ == "__main__":
-    import ImportPathHelper as imports
-    imports.init()
-    
     from editor_python_test_tools.utils import Report
     Report.start_test(C29279329_WhiteBox_SetDefaultShape)

AutomatedTesting/Gem/PythonTests/WhiteBox/tests/WhiteBox_SetInvisible.py

@@ -24,9 +24,7 @@ def C28798205_WhiteBox_SetInvisible():
     import os
     import sys
     from Gems.WhiteBox.Editor.Scripts import WhiteBoxInit as init
-    import ImportPathHelper as imports
     import editor_python_test_tools.hydra_editor_utils as hydra
-    imports.init()
 
     import azlmbr.whitebox.api as api
     import azlmbr.whitebox
@@ -63,8 +61,5 @@ def C28798205_WhiteBox_SetInvisible():
 
 
 if __name__ == "__main__":
-    import ImportPathHelper as imports
-    imports.init()
-    
     from editor_python_test_tools.utils import Report
     Report.start_test(C28798205_WhiteBox_SetInvisible)

AutomatedTesting/Gem/PythonTests/atom_renderer/test_Atom_GPUTests.py

@@ -7,8 +7,10 @@ SPDX-License-Identifier: Apache-2.0 OR MIT
 Tests that require a GPU in order to run.
 """
 
+import datetime
 import logging
 import os
+import zipfile
 
 import pytest
 
@@ -40,6 +42,33 @@ def golden_images_directory():
     return golden_images_dir
 
 
+def create_screenshots_archive(screenshot_path):
+    """
+    Creates a new zip file archive at archive_path containing all files listed within archive_path.
+    :param screenshot_path: location containing the files to archive, the zip archive file will also be saved here.
+    :return: None, but creates a new zip file archive inside path containing all of the files inside archive_path.
+    """
+    files_to_archive = []
+
+    # Search for .png and .ppm files to add to the zip archive file.
+    for (folder_name, sub_folders, file_names) in os.walk(screenshot_path):
+        for file_name in file_names:
+            if file_name.endswith(".png") or file_name.endswith(".ppm"):
+                file_path = os.path.join(folder_name, file_name)
+                files_to_archive.append(file_path)
+
+    # Setup variables for naming the zip archive file.
+    timestamp = datetime.datetime.now().timestamp()
+    formatted_timestamp = datetime.datetime.utcfromtimestamp(timestamp).strftime("%Y-%m-%d_%H-%M-%S")
+    screenshots_file = os.path.join(screenshot_path, f'zip_archive_{formatted_timestamp}.zip')
+
+    # Write all of the valid .png and .ppm files to the archive file.
+    with zipfile.ZipFile(screenshots_file, 'w', compression=zipfile.ZIP_DEFLATED, allowZip64=True) as zip_archive:
+        for file_path in files_to_archive:
+            file_name = os.path.basename(file_path)
+            zip_archive.write(file_path, file_name)
+
+
 @pytest.mark.parametrize("project", ["AutomatedTesting"])
 @pytest.mark.parametrize("launcher_platform", ["windows_editor"])
 @pytest.mark.parametrize("level", ["auto_test"])
@@ -53,8 +82,8 @@ class TestAllComponentsIndepthTests(object):
         Tests that a basic rendering level setup can be created (lighting, meshes, materials, etc.).
         """
         # Clear existing test screenshots before starting test.
-        test_screenshots = [os.path.join(
-            workspace.paths.project(), DEFAULT_SUBFOLDER_PATH, screenshot_name)]
+        screenshot_directory = os.path.join(workspace.paths.project(), DEFAULT_SUBFOLDER_PATH)
+        test_screenshots = [os.path.join(screenshot_directory, screenshot_name)]
         file_system.delete(test_screenshots, True, True)
 
         golden_images = [os.path.join(golden_images_directory(), screenshot_name)]
@@ -86,6 +115,8 @@ class TestAllComponentsIndepthTests(object):
         for test_screenshot, golden_screenshot in zip(test_screenshots, golden_images):
             compare_screenshots(test_screenshot, golden_screenshot)
 
+        create_screenshots_archive(screenshot_directory)
+
     def test_LightComponent_ScreenshotMatchesGoldenImage(
             self, request, editor, workspace, project, launcher_platform, level):
         """
@@ -105,9 +136,10 @@ class TestAllComponentsIndepthTests(object):
             "SpotLight_5.ppm",
             "SpotLight_6.ppm",
         ]
+        screenshot_directory = os.path.join(workspace.paths.project(), DEFAULT_SUBFOLDER_PATH)
         test_screenshots = []
         for screenshot in screenshot_names:
-            screenshot_path = os.path.join(workspace.paths.project(), DEFAULT_SUBFOLDER_PATH, screenshot)
+            screenshot_path = os.path.join(screenshot_directory, screenshot)
             test_screenshots.append(screenshot_path)
         file_system.delete(test_screenshots, True, True)
 
@@ -139,6 +171,8 @@ class TestAllComponentsIndepthTests(object):
         for test_screenshot, golden_screenshot in zip(test_screenshots, golden_images):
             compare_screenshots(test_screenshot, golden_screenshot)
 
+        create_screenshots_archive(screenshot_directory)
+
 
 @pytest.mark.parametrize('rhi', ['dx12', 'vulkan'])
 @pytest.mark.parametrize("project", ["AutomatedTesting"])

AutomatedTesting/Gem/PythonTests/editor/TestSuite_Sandbox_Optimized.py

@@ -11,7 +11,6 @@ import pytest
 from ly_test_tools.o3de.editor_test import EditorSingleTest, EditorSharedTest, EditorParallelTest, EditorTestSuite
 
 
-@pytest.mark.xfail(reason="Optimized tests are experimental, we will enable xfail and monitor them temporarily.")
 @pytest.mark.SUITE_sandbox
 @pytest.mark.parametrize("launcher_platform", ['windows_editor'])
 @pytest.mark.parametrize("project", ["AutomatedTesting"])

AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PhysXColliderSurfaceTagEmitter_E2E_Editor.py

@@ -156,7 +156,7 @@ class TestPhysXColliderSurfaceTagEmitter(EditorTestHelper):
         # Setup collider entity with a PhysX Mesh
         test_physx_mesh_asset_id = asset.AssetCatalogRequestBus(
             bus.Broadcast, "GetAssetIdByPath", os.path.join("levels", "physics",
-                                                            "c4044697_material_perfacematerialvalidation",
+                                                            "Material_PerFaceMaterialGetsCorrectMaterial",
                                                             "test.pxmesh"), math.Uuid(), False)
 
         # Remove/re-add component due to LYN-5496

AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/TestSuite_Periodic_Optimized.py

@@ -10,6 +10,7 @@ import pytest
 from ly_test_tools.o3de.editor_test import EditorSingleTest, EditorSharedTest, EditorParallelTest, EditorTestSuite
 
 
+@pytest.mark.xfail(reason="Optimized tests are experimental, we will enable xfail and monitor them temporarily.")
 @pytest.mark.SUITE_periodic
 @pytest.mark.parametrize("launcher_platform", ['windows_editor'])
 @pytest.mark.parametrize("project", ["AutomatedTesting"])

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/TestSuite_Main_Optimized.py

@@ -12,6 +12,7 @@ import ly_test_tools.environment.file_system as file_system
 from ly_test_tools.o3de.editor_test import EditorSingleTest, EditorSharedTest, EditorParallelTest, EditorTestSuite
 
 
+@pytest.mark.xfail(reason="Optimized tests are experimental, we will enable xfail and monitor them temporarily.")
 @pytest.mark.SUITE_periodic
 @pytest.mark.parametrize("launcher_platform", ['windows_editor'])
 @pytest.mark.parametrize("project", ["AutomatedTesting"])
@@ -58,11 +59,11 @@ class TestAutomation(EditorTestSuite):
         from .EditorScripts import GraphClosed_TabbedGraph as test_module
 
     class test_LandscapeCanvas_Slice_CreateInstantiate(EditorSingleTest):
+        from .EditorScripts import Slice_CreateInstantiate as test_module
         # Custom teardown to remove slice asset created during test
         def teardown(self, request, workspace, editor, editor_test_results, launcher_platform):
             file_system.delete([os.path.join(workspace.paths.engine_root(), "AutomatedTesting", "slices",
                                              "TestSlice.slice")], True, True)
-        from .EditorScripts import Slice_CreateInstantiate as test_module
 
     class test_LandscapeCanvas_GradientModifierNodes_EntityCreatedOnNodeAdd(EditorSharedTest):
         from .EditorScripts import GradientModifierNodes_EntityCreatedOnNodeAdd as test_module

AutomatedTesting/Gem/PythonTests/physics/TestSuite_InDevelopment.py

@@ -20,368 +20,164 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/../automatedtesti
 from base import TestAutomationBase
 
 @pytest.mark.parametrize("project", ["AutomatedTesting"])
+@pytest.mark.parametrize("launcher_platform", ['windows_editor'])
 class TestAutomation(TestAutomationBase):
     @fm.file_revert("ragdollbones.physmaterial",
-                    r"AutomatedTesting\Levels\Physics\C4925582_Material_AddModifyDeleteOnRagdollBones")
-    def test_C4925582_Material_AddModifyDeleteOnRagdollBones(self, request, workspace, editor):
-        from .material import C4925582_Material_AddModifyDeleteOnRagdollBones as test_module
+                    r"AutomatedTesting\Levels\Physics\Material_LibraryCrudOperationsReflectOnRagdollBones")
+    def test_Material_LibraryCrudOperationsReflectOnRagdollBones(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_LibraryCrudOperationsReflectOnRagdollBones as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    def test_C4925580_Material_RagdollBonesMaterial(self, request, workspace, editor):
-        from .material import C4925580_Material_RagdollBonesMaterial as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    def test_Material_RagdollBones(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_RagdollBones as test_module
+        self._run_test(request, workspace, editor, test_module)
 
     @fm.file_revert("c15308221_material_componentsinsyncwithlibrary.physmaterial",
-                    r"AutomatedTesting\Levels\Physics\C15308221_Material_ComponentsInSyncWithLibrary")
-    def test_C15308221_Material_ComponentsInSyncWithLibrary(self, request, workspace, editor):
-        from .material import C15308221_Material_ComponentsInSyncWithLibrary as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+                    r"AutomatedTesting\Levels\Physics\Material_ComponentsInSyncWithLibrary")
+    def test_Material_ComponentsInSyncWithLibrary(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_ComponentsInSyncWithLibrary as test_module
+        self._run_test(request, workspace, editor, test_module)
 
     # BUG: LY-107723")
-    def test_C14976308_ScriptCanvas_SetKinematicTargetTransform(self, request, workspace, editor):
-        from .script_canvas import C14976308_ScriptCanvas_SetKinematicTargetTransform as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    def test_ScriptCanvas_SetKinematicTargetTransform(self, request, workspace, editor, launcher_platform):
+        from .tests.script_canvas import ScriptCanvas_SetKinematicTargetTransform as test_module
+        self._run_test(request, workspace, editor, test_module)
 
     # Failing, PhysXTerrain
     @fm.file_revert("c4925579_material_addmodifydeleteonterrain.physmaterial",
-                    r"AutomatedTesting\Levels\Physics\C4925579_Material_AddModifyDeleteOnTerrain")
-    def test_C4925579_Material_AddModifyDeleteOnTerrain(self, request, workspace, editor):
-        from .material import C4925579_Material_AddModifyDeleteOnTerrain as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+                    r"AutomatedTesting\Levels\Physics\Material_LibraryCrudOperationsReflectOnTerrain")
+    def test_Material_LibraryCrudOperationsReflectOnTerrain(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_LibraryCrudOperationsReflectOnTerrain as test_module
+        self._run_test(request, workspace, editor, test_module)
 
     # Failing, PhysXTerrain
-    def test_C13508019_Terrain_TerrainTexturePainterWorks(self, request, workspace, editor):
-        from .terrain import C13508019_Terrain_TerrainTexturePainterWorks as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    def test_Terrain_TerrainTexturePainterWorks(self, request, workspace, editor, launcher_platform):
+        from .tests.terrain import Terrain_TerrainTexturePainterWorks as test_module
+        self._run_test(request, workspace, editor, test_module)
 
     # Failing, PhysXTerrain
-    def test_C4925577_Materials_MaterialAssignedToTerrain(self, request, workspace, editor):
-        from .material import C4925577_Materials_MaterialAssignedToTerrain as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    def test_Material_CanBeAssignedToTerrain(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_CanBeAssignedToTerrain as test_module
+        self._run_test(request, workspace, editor, test_module)
 
     # Failing, PhysXTerrain
-    def test_C15096735_Materials_DefaultLibraryConsistency(self, request, workspace, editor):
-        from .material import C15096735_Materials_DefaultLibraryConsistency as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    def test_Material_DefaultLibraryConsistentOnAllFeatures(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_DefaultLibraryConsistentOnAllFeatures as test_module
+        self._run_test(request, workspace, editor, test_module)
 
     # Failing, PhysXTerrain
-    @fm.file_revert("all_ones_1.physmaterial", r"AutomatedTesting\Levels\Physics\C15096737_Materials_DefaultMaterialLibraryChanges")
-    @fm.file_override("default.physxconfiguration", "C15096737_Materials_DefaultMaterialLibraryChanges.physxconfiguration", "AutomatedTesting")
-    def test_C15096737_Materials_DefaultMaterialLibraryChanges(self, request, workspace, editor):
-        from .material import C15096737_Materials_DefaultMaterialLibraryChanges as test_module
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    @fm.file_revert("all_ones_1.physmaterial", r"AutomatedTesting\Levels\Physics\Material_DefaultMaterialLibraryChangesWork")
+    @fm.file_override("default.physxconfiguration", "Material_DefaultMaterialLibraryChangesWork.physxconfiguration", "AutomatedTesting")
+    def test_Material_DefaultMaterialLibraryChangesWork(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_DefaultMaterialLibraryChangesWork as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-    def test_C4976242_Collision_SameCollisionlayerSameCollisiongroup(self, request, workspace, editor):
-        from .collider import C4976242_Collision_SameCollisionlayerSameCollisiongroup as test_module
+    def test_Collider_SameCollisionGroupSameLayerCollide(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_SameCollisionGroupSameLayerCollide as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    def test_Ragdoll_OldRagdollSerializationNoErrors(self, request, workspace, editor, launcher_platform):
+        from .tests.ragdoll import Ragdoll_OldRagdollSerializationNoErrors as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-    def test_C15096732_Material_DefaultLibraryUpdatedAcrossLevels(self, request, workspace, editor):
-        @fm.file_override("default.physxconfiguration",
-                          "Material_DefaultLibraryUpdatedAcrossLevels_before.physxconfiguration", "AutomatedTesting",
-                          search_subdirs=True)
-        def test_levels_before(self, request, workspace, editor):
-            from .material import C15096732_Material_DefaultLibraryUpdatedAcrossLevels_before as test_module_0
-            expected_lines = []
-            unexpected_lines = ["Assert"]
-            self._run_test(request, workspace, editor, test_module_0, expected_lines, unexpected_lines)
+    @fm.file_override("default.physxconfiguration", "ScriptCanvas_OverlapNode.physxconfiguration")
+    def test_ScriptCanvas_OverlapNode(self, request, workspace, editor, launcher_platform):
+        from .tests.script_canvas import ScriptCanvas_OverlapNode as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-        # File override replaces the previous physxconfiguration file with another where the only difference is the default material library
-        @fm.file_override("default.physxconfiguration",
-                          "Material_DefaultLibraryUpdatedAcrossLevels_after.physxconfiguration", "AutomatedTesting",
-                          search_subdirs=True)
-        def test_levels_after(self, request, workspace, editor):
-            from .material import C15096732_Material_DefaultLibraryUpdatedAcrossLevels_after as test_module_1
-            expected_lines = []
-            unexpected_lines = ["Assert"]
-            self._run_test(request, workspace, editor, test_module_1, expected_lines, unexpected_lines)
-
-        test_levels_before(self, request, workspace, editor)
-        test_levels_after(self, request, workspace, editor)
-
-    def test_C14654882_Ragdoll_ragdollAPTest(self, request, workspace, editor):
-        from .ragdoll import C14654882_Ragdoll_ragdollAPTest as test_module
-
-        expected_lines = []
-        unexpected_lines = test_module.UnexpectedLines.lines
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    @fm.file_override("default.physxconfiguration", "C12712454_ScriptCanvas_OverlapNodeVerification.physxconfiguration")
-    def test_C12712454_ScriptCanvas_OverlapNodeVerification(self, request, workspace, editor):
-        from .script_canvas import C12712454_ScriptCanvas_OverlapNodeVerification as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    def test_C4044460_Material_StaticFriction(self, request, workspace, editor):
-        from .material import C4044460_Material_StaticFriction as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-        
-    
+    def test_Material_StaticFriction(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_StaticFriction as test_module
+        self._run_test(request, workspace, editor, test_module)
         
     @fm.file_revert("c4888315_material_addmodifydeleteoncollider.physmaterial",
-                    r"AutomatedTesting\Levels\Physics\C4888315_Material_AddModifyDeleteOnCollider")
-    def test_C4888315_Material_AddModifyDeleteOnCollider(self, request, workspace, editor):
-        from .material import C4888315_Material_AddModifyDeleteOnCollider as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+                    r"AutomatedTesting\Levels\Physics\Material_LibraryCrudOperationsReflectOnCollider")
+    def test_Material_LibraryCrudOperationsReflectOnCollider(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_LibraryCrudOperationsReflectOnCollider as test_module
+        self._run_test(request, workspace, editor, test_module)
 
     @fm.file_revert("c15563573_material_addmodifydeleteoncharactercontroller.physmaterial",
-                    r"AutomatedTesting\Levels\Physics\C15563573_Material_AddModifyDeleteOnCharacterController")
-    def test_C15563573_Material_AddModifyDeleteOnCharacterController(self, request, workspace, editor):
-        from .material import C15563573_Material_AddModifyDeleteOnCharacterController as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+                    r"AutomatedTesting\Levels\Physics\Material_LibraryCrudOperationsReflectOnCharacterController")
+    def test_Material_LibraryCrudOperationsReflectOnCharacterController(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_LibraryCrudOperationsReflectOnCharacterController as test_module
+        self._run_test(request, workspace, editor, test_module)
 
     @fm.file_revert("c4888315_material_addmodifydeleteoncollider.physmaterial",
-                    r"AutomatedTesting\Levels\Physics\C4888315_Material_AddModifyDeleteOnCollider")
-    def test_C4888315_Material_AddModifyDeleteOnCollider(self, request, workspace, editor):
-        from .material import C4888315_Material_AddModifyDeleteOnCollider as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-        
+                    r"AutomatedTesting\Levels\Physics\Material_LibraryCrudOperationsReflectOnCollider")
+    def test_Material_LibraryCrudOperationsReflectOnCollider(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_LibraryCrudOperationsReflectOnCollider as test_module
+        self._run_test(request, workspace, editor, test_module)
     
 
     @fm.file_revert("c15563573_material_addmodifydeleteoncharactercontroller.physmaterial",
-                    r"AutomatedTesting\Levels\Physics\C15563573_Material_AddModifyDeleteOnCharacterController")
-    def test_C15563573_Material_AddModifyDeleteOnCharacterController(self, request, workspace, editor):
-        from .material import C15563573_Material_AddModifyDeleteOnCharacterController as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+                    r"AutomatedTesting\Levels\Physics\Material_LibraryCrudOperationsReflectOnCharacterController")
+    def test_Material_LibraryCrudOperationsReflectOnCharacterController(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_LibraryCrudOperationsReflectOnCharacterController as test_module
+        self._run_test(request, workspace, editor, test_module)
 
     @fm.file_revert("c4044455_material_librarychangesinstantly.physmaterial",
                     r"AutomatedTesting\Levels\Physics\C4044455_Material_LibraryChangesInstantly")
-    def test_C4044455_Material_libraryChangesInstantly(self, request, workspace, editor):
-        from .material import C4044455_Material_libraryChangesInstantly as test_module
+    def test_Material_LibraryChangesReflectInstantly(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_LibraryChangesReflectInstantly as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-
-    @fm.file_revert("C15425935_Material_LibraryUpdatedAcrossLevels.physmaterial",
-                    r"AutomatedTesting\Levels\Physics\C15425935_Material_LibraryUpdatedAcrossLevels")
-    def test_C15425935_Material_LibraryUpdatedAcrossLevels(self, request, workspace, editor):
-        from .material import C15425935_Material_LibraryUpdatedAcrossLevels as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    @fm.file_revert("Material_LibraryUpdatedAcrossLevels.physmaterial",
+                    r"AutomatedTesting\Levels\Physics\Material_LibraryUpdatedAcrossLevels")
+    def test_Material_LibraryUpdatedAcrossLevels(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_LibraryUpdatedAcrossLevels as test_module
+        self._run_test(request, workspace, editor, test_module)
     
-    def test_C4976199_RigidBodies_LinearDampingObjectMotion(self, request, workspace, editor):
-        from .rigid_body import C4976199_RigidBodies_LinearDampingObjectMotion as test_module
+    def test_RigidBody_LinearDampingAffectsMotion(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_LinearDampingAffectsMotion as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    def test_Terrain_CollisionAgainstRigidBody(self, request, workspace, editor, launcher_platform):
+        from .tests.terrain import Terrain_CollisionAgainstRigidBody as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-    def test_C5689518_PhysXTerrain_CollidesWithPhysXTerrain(self, request, workspace, editor):
-        from .terrain import C5689518_PhysXTerrain_CollidesWithPhysXTerrain as test_module
+    def test_ShapeCollider_CylinderShapeCollides(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import ShapeCollider_CylinderShapeCollides as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    def test_Physics_WorldBodyBusWorksOnEditorComponents(self, request, workspace, editor, launcher_platform):
+        from .tests import Physics_WorldBodyBusWorksOnEditorComponents as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-    def test_C24308873_CylinderShapeCollider_CollidesWithPhysXTerrain(self, request, workspace, editor):
-        from .collider import C24308873_CylinderShapeCollider_CollidesWithPhysXTerrain as test_module
+    def test_Collider_PxMeshErrorIfNoMesh(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_PxMeshErrorIfNoMesh as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    def test_ForceRegion_ImpulsesBoxShapedRigidBody(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_ImpulsesBoxShapedRigidBody as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-    def test_C29032500_EditorComponents_WorldBodyBusWorks(self, request, workspace, editor):
-        from .general import C29032500_EditorComponents_WorldBodyBusWorks as test_module
+    def test_Terrain_SpawnSecondTerrainComponentWarning(self, request, workspace, editor, launcher_platform):
+        from .tests.terrain import Terrain_SpawnSecondTerrainComponentWarning as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    def test_Terrain_AddPhysTerrainComponent(self, request, workspace, editor, launcher_platform):
+        from .tests.terrain import Terrain_AddPhysTerrainComponent as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-    def test_C14861498_ConfirmError_NoPxMesh(self, request, workspace, editor, launcher_platform):
-        from .collider import C14861498_ConfirmError_NoPxMesh as test_module
+    def test_Terrain_CanAddMultipleTerrainComponents(self, request, workspace, editor, launcher_platform):
+        from .tests.terrain import Terrain_CanAddMultipleTerrainComponents as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    def test_Terrain_MultipleTerrainComponentsWarning(self, request, workspace, editor, launcher_platform):
+        from .tests.terrain import Terrain_MultipleTerrainComponentsWarning as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-    def test_C5959763_ForceRegion_ForceRegionImpulsesCube(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5959763_ForceRegion_ForceRegionImpulsesCube as test_module
+    def test_Terrain_MultipleTerrainComponentsWarning(self, request, workspace, editor, launcher_platform):
+        from .tests.terrain import Terrain_MultipleTerrainComponentsWarning as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    def test_ForceRegion_HighValuesDirectionAxesWorkWithNoError(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_HighValuesDirectionAxesWorkWithNoError as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-    def test_C5689531_Warning_TerrainSliceTerrainComponent(self, request, workspace, editor, launcher_platform):
-        from .terrain import C5689531_Warning_TerrainSliceTerrainComponent as test_module
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    def test_Terrain_MultipleResolutionsValid(self, request, workspace, editor, launcher_platform):
+        from .tests.terrain import Terrain_MultipleResolutionsValid as test_module
+        self._run_test(request, workspace, editor, test_module)
 
-    def test_C5689522_Physxterrain_AddPhysxterrainNoEditorCrash(self, request, workspace, editor, launcher_platform):
-        from .terrain import C5689522_Physxterrain_AddPhysxterrainNoEditorCrash as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    def test_C5689524_MultipleTerrains_CheckWarningInConsole(self, request, workspace, editor, launcher_platform):
-        from .terrain import C5689524_MultipleTerrains_CheckWarningInConsole as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    def test_C5689528_Terrain_MultipleTerrainComponents(self, request, workspace, editor, launcher_platform):
-        from .terrain import C5689528_Terrain_MultipleTerrainComponents as test_module
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    def test_C5689528_Terrain_MultipleTerrainComponents(self, request, workspace, editor, launcher_platform):
-        from .terrain import C5689528_Terrain_MultipleTerrainComponents as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    def test_C6321601_Force_HighValuesDirectionAxes(self, request, workspace, editor, launcher_platform):
-        from .force_region import C6321601_Force_HighValuesDirectionAxes as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    def test_C6032082_Terrain_MultipleResolutionsValid(self, request, workspace, editor, launcher_platform):
-        from .terrain import C6032082_Terrain_MultipleResolutionsValid as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    def test_C12905527_ForceRegion_MagnitudeDeviation(self, request, workspace, editor, launcher_platform):
-        from .force_region import C12905527_ForceRegion_MagnitudeDeviation as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    # Removed from active suite to meet 60 minutes limit in AR job
-    def test_C18243580_Joints_Fixed2BodiesConstrained(self, request, workspace, editor, launcher_platform):
-        from .joints import C18243580_Joints_Fixed2BodiesConstrained as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    # Removed from active suite to meet 60 minutes limit in AR job
-    def test_C18243583_Joints_Hinge2BodiesConstrained(self, request, workspace, editor, launcher_platform):
-        from .joints import C18243583_Joints_Hinge2BodiesConstrained as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    # Removed from active suite to meet 60 minutes limit in AR job
-    def test_C18243588_Joints_Ball2BodiesConstrained(self, request, workspace, editor, launcher_platform):
-        from .joints import C18243588_Joints_Ball2BodiesConstrained as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    # Removed from active suite to meet 60 minutes limit in AR job
-    def test_C18243581_Joints_FixedBreakable(self, request, workspace, editor, launcher_platform):
-        from .joints import C18243581_Joints_FixedBreakable as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    # Removed from active suite to meet 60 minutes limit in AR job
-    def test_C18243587_Joints_HingeBreakable(self, request, workspace, editor, launcher_platform):
-        from .joints import C18243587_Joints_HingeBreakable as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    # Removed from active suite to meet 60 minutes limit in AR job
-    def test_C18243592_Joints_BallBreakable(self, request, workspace, editor, launcher_platform):
-        from .joints import C18243592_Joints_BallBreakable as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    # Removed from active suite to meet 60 minutes limit in AR job
-    def test_C18243585_Joints_HingeNoLimitsConstrained(self, request, workspace, editor, launcher_platform):
-        from .joints import C18243585_Joints_HingeNoLimitsConstrained as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    # Removed from active suite to meet 60 minutes limit in AR job
-    def test_C18243590_Joints_BallNoLimitsConstrained(self, request, workspace, editor, launcher_platform):
-        from .joints import C18243590_Joints_BallNoLimitsConstrained as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    # Removed from active suite to meet 60 minutes limit in AR job
-    def test_C18243582_Joints_FixedLeadFollowerCollide(self, request, workspace, editor, launcher_platform):
-        from .joints import C18243582_Joints_FixedLeadFollowerCollide as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
-
-    # Removed from active suite to meet 60 minutes limit in AR job
-    def test_C18243593_Joints_GlobalFrameConstrained(self, request, workspace, editor, launcher_platform):
-        from .joints import C18243593_Joints_GlobalFrameConstrained as test_module
-
-        expected_lines = []
-        unexpected_lines = ["Assert"]
-        self._run_test(request, workspace, editor, test_module, expected_lines, unexpected_lines)
+    def test_ForceRegion_SmallMagnitudeDeviationOnLargeForces(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_SmallMagnitudeDeviationOnLargeForces as test_module
+        self._run_test(request, workspace, editor, test_module)

AutomatedTesting/Gem/PythonTests/physics/TestSuite_Main.py

@@ -28,59 +28,67 @@ revert_physics_config = fm.file_revert_list(['physxdebugconfiguration.setreg', '
 @pytest.mark.parametrize("project", ["AutomatedTesting"])
 class TestAutomation(TestAutomationBase):
 
-    def test_C111111_RigidBody_EnablingGravityWorksUsingNotificationsPoC(self, request, workspace, editor, launcher_platform):
-        from .collider import C111111_RigidBody_EnablingGravityWorksUsingNotificationsPoC as test_module
+    def test_RigidBody_EnablingGravityWorksUsingNotificationsPoC(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_EnablingGravityWorksUsingNotificationsPoC as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C5932041_PhysXForceRegion_LocalSpaceForceOnRigidBodies(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5932041_PhysXForceRegion_LocalSpaceForceOnRigidBodies as test_module
+    def test_ForceRegion_LocalSpaceForceOnRigidBodies(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_LocalSpaceForceOnRigidBodies as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    @fm.file_override('physxsystemconfiguration.setreg','C4044459_Material_DynamicFriction.setreg_override', 'AutomatedTesting/Registry')
-    def test_C4044459_Material_DynamicFriction(self, request, workspace, editor, launcher_platform):
-        from .material import C4044459_Material_DynamicFriction as test_module
+    @fm.file_override('physxsystemconfiguration.setreg','Material_DynamicFriction.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_Material_DynamicFriction(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_DynamicFriction as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4976243_Collision_SameCollisionGroupDiffCollisionLayers(self, request, workspace, editor,
-                                                                      launcher_platform):
-        from .collider import C4976243_Collision_SameCollisionGroupDiffCollisionLayers as test_module
+    def test_Collider_SameCollisionGroupDiffLayersCollide(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_SameCollisionGroupDiffLayersCollide as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C14654881_CharacterController_SwitchLevels(self, request, workspace, editor, launcher_platform):
-        from .character_controller import C14654881_CharacterController_SwitchLevels as test_module
+    def test_CharacterController_SwitchLevels(self, request, workspace, editor, launcher_platform):
+        from .tests.character_controller import CharacterController_SwitchLevels as test_module
         self._run_test(request, workspace, editor, test_module)
 
-    def test_C17411467_AddPhysxRagdollComponent(self, request, workspace, editor, launcher_platform):
-        from .ragdoll import C17411467_AddPhysxRagdollComponent as test_module
+    def test_Ragdoll_AddPhysxRagdollComponentWorks(self, request, workspace, editor, launcher_platform):
+        from .tests.ragdoll import Ragdoll_AddPhysxRagdollComponentWorks as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C12712453_ScriptCanvas_MultipleRaycastNode(self, request, workspace, editor, launcher_platform):
-        from .script_canvas import C12712453_ScriptCanvas_MultipleRaycastNode as test_module
-        # Fixme: unexpected_lines = ["Assert"] + test_module.Lines.unexpected
+    def test_ScriptCanvas_MultipleRaycastNode(self, request, workspace, editor, launcher_platform):
+        from .tests.script_canvas import ScriptCanvas_MultipleRaycastNode as test_module
+        # Fixme: This test previously relied on unexpected lines log reading with is now not supported.
+        # Now the log reading must be done inside the test, preferably with the Tracer() utility
+        #  unexpected_lines = ["Assert"] + test_module.Lines.unexpected
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    @fm.file_override('physxsystemconfiguration.setreg','C4982593_PhysXCollider_CollisionLayer.setreg_override', 'AutomatedTesting/Registry')
-    def test_C4982593_PhysXCollider_CollisionLayerTest(self, request, workspace, editor, launcher_platform):
-        from .collider import C4982593_PhysXCollider_CollisionLayerTest as test_module
+    @fm.file_override('physxsystemconfiguration.setreg','Collider_DiffCollisionGroupDiffCollidingLayersNotCollide.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_Collider_DiffCollisionGroupDiffCollidingLayersNotCollide(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_DiffCollisionGroupDiffCollidingLayersNotCollide as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C18243586_Joints_HingeLeadFollowerCollide(self, request, workspace, editor, launcher_platform):
-        from .joints import C18243586_Joints_HingeLeadFollowerCollide as test_module
+    def test_Joints_HingeLeadFollowerCollide(self, request, workspace, editor, launcher_platform):
+        from .tests.joints import Joints_HingeLeadFollowerCollide as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4982803_Enable_PxMesh_Option(self, request, workspace, editor, launcher_platform):
-        from .collider import C4982803_Enable_PxMesh_Option as test_module
+    def test_Collider_PxMeshConvexMeshCollides(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_PxMeshConvexMeshCollides as test_module
         self._run_test(request, workspace, editor, test_module)
     
     @revert_physics_config    
-    def test_C24308873_CylinderShapeCollider_CollidesWithPhysXTerrain(self, request, workspace, editor, launcher_platform):
-        from .collider import C24308873_CylinderShapeCollider_CollidesWithPhysXTerrain as test_module
+    def test_ShapeCollider_CylinderShapeCollides(self, request, workspace, editor, launcher_platform):
+        from .tests.shape_collider import ShapeCollider_CylinderShapeCollides as test_module
         self._run_test(request, workspace, editor, test_module)
+
+    @revert_physics_config
+    def test_C15425929_Undo_Redo(self, request, workspace, editor, launcher_platform):
+        from .tests import Physics_UndoRedoWorksOnEntityWithPhysComponents as test_module
+        self._run_test(request, workspace, editor, test_module)

AutomatedTesting/Gem/PythonTests/physics/TestSuite_Main_Optimized.py

@@ -21,7 +21,7 @@ class EditorSingleTest_WithFileOverrides(EditorSingleTest):
     # Base directory of the files (Default path is {ProjectName})
     base_dir = None
     # True will will search sub-directories for the files in base 
-    search_subdirs = False
+    search_subdirs = True
 
     @classmethod
     def wrap_run(cls, instance, request, workspace, editor, editor_test_results, launcher_platform):
@@ -47,13 +47,14 @@ class EditorSingleTest_WithFileOverrides(EditorSingleTest):
             fm._backup_file(f, file_list[f])
         
         for original, override in cls.files_to_override:
-            fm._copy_file(override, file_list[override], original, file_list[override])
+            fm._copy_file(override, file_list[override], original, file_list[original])
 
         yield # Run Test
         for f in original_file_list:
             fm._restore_file(f, file_list[f])
 
 
+@pytest.mark.xfail(reason="Optimized tests are experimental, we will enable xfail and monitor them temporarily.")
 @pytest.mark.SUITE_main
 @pytest.mark.parametrize("launcher_platform", ['windows_editor'])
 @pytest.mark.parametrize("project", ["AutomatedTesting"])
@@ -66,283 +67,280 @@ class TestAutomation(EditorTestSuite):
     #########################################
     # Non-atomic tests: These need to be run in a single editor because they have custom setup and teardown
     class C4044459_Material_DynamicFriction(EditorSingleTest_WithFileOverrides):
-        from .material import C4044459_Material_DynamicFriction as test_module        
+        from .tests.material import Material_DynamicFriction as test_module        
         files_to_override = [
-            ('physxsystemconfiguration.setreg', 'C4044459_Material_DynamicFriction.setreg_override')
+            ('physxsystemconfiguration.setreg', 'Material_DynamicFriction.setreg_override')
         ]
         base_dir = "AutomatedTesting/Registry"
 
     class C4982593_PhysXCollider_CollisionLayerTest(EditorSingleTest_WithFileOverrides):
-        from .collider import C4982593_PhysXCollider_CollisionLayerTest as test_module
+        from .tests.collider import Collider_DiffCollisionGroupDiffCollidingLayersNotCollide as test_module
         files_to_override = [
-            ('physxsystemconfiguration.setreg', 'C4982593_PhysXCollider_CollisionLayer.setreg_override')
+            ('physxsystemconfiguration.setreg', 'Collider_DiffCollisionGroupDiffCollidingLayersNotCollide.setreg_override')
         ]
         base_dir = "AutomatedTesting/Registry"
     #########################################
 
     class C111111_RigidBody_EnablingGravityWorksUsingNotificationsPoC(EditorSharedTest):
-        from .collider import C111111_RigidBody_EnablingGravityWorksUsingNotificationsPoC as test_module
+        from .tests.rigid_body import RigidBody_EnablingGravityWorksUsingNotificationsPoC as test_module
 
     class C5932041_PhysXForceRegion_LocalSpaceForceOnRigidBodies(EditorSharedTest):
-        from .force_region import C5932041_PhysXForceRegion_LocalSpaceForceOnRigidBodies as test_module
+        from .tests.force_region import ForceRegion_LocalSpaceForceOnRigidBodies as test_module
 
     class C15425929_Undo_Redo(EditorSharedTest):
-        from .general import C15425929_Undo_Redo as test_module
+        from .tests import Physics_UndoRedoWorksOnEntityWithPhysComponents as test_module
         
     class C4976243_Collision_SameCollisionGroupDiffCollisionLayers(EditorSharedTest):
-        from .collider import C4976243_Collision_SameCollisionGroupDiffCollisionLayers as test_module
+        from .tests.collider import Collider_SameCollisionGroupDiffLayersCollide as test_module
 
     class C14654881_CharacterController_SwitchLevels(EditorSharedTest):
-        from .character_controller import C14654881_CharacterController_SwitchLevels as test_module
+        from .tests.character_controller import CharacterController_SwitchLevels as test_module
  
     class C17411467_AddPhysxRagdollComponent(EditorSharedTest):
-        from .ragdoll import C17411467_AddPhysxRagdollComponent as test_module
+        from .tests.ragdoll import Ragdoll_AddPhysxRagdollComponentWorks as test_module
  
     class C12712453_ScriptCanvas_MultipleRaycastNode(EditorSharedTest):
-        from .script_canvas import C12712453_ScriptCanvas_MultipleRaycastNode as test_module
+        from .tests.script_canvas import ScriptCanvas_MultipleRaycastNode as test_module
 
     class C18243586_Joints_HingeLeadFollowerCollide(EditorSharedTest):
-        from .joints import C18243586_Joints_HingeLeadFollowerCollide as test_module
+        from .tests.joints import Joints_HingeLeadFollowerCollide as test_module
 
     class C4982803_Enable_PxMesh_Option(EditorSharedTest):
-        from .collider import C4982803_Enable_PxMesh_Option as test_module
+        from .tests.collider import Collider_PxMeshConvexMeshCollides as test_module
     
     class C24308873_CylinderShapeCollider_CollidesWithPhysXTerrain(EditorSharedTest):
-        from .collider import C24308873_CylinderShapeCollider_CollidesWithPhysXTerrain as test_module
+        from .tests.shape_collider import ShapeCollider_CylinderShapeCollides as test_module
 
     class C3510642_Terrain_NotCollideWithTerrain(EditorSharedTest):
-        from .terrain import C3510642_Terrain_NotCollideWithTerrain as test_module
+        from .tests.terrain import Terrain_NoPhysTerrainComponentNoCollision as test_module
 
     class C4976195_RigidBodies_InitialLinearVelocity(EditorSharedTest):
-        from .rigid_body import C4976195_RigidBodies_InitialLinearVelocity as test_module
+        from .tests.rigid_body import RigidBody_InitialLinearVelocity as test_module
 
     class C4976206_RigidBodies_GravityEnabledActive(EditorSharedTest):
-        from .rigid_body import C4976206_RigidBodies_GravityEnabledActive as test_module
+        from .tests.rigid_body import RigidBody_StartGravityEnabledWorks as test_module
 
     class C4976207_PhysXRigidBodies_KinematicBehavior(EditorSharedTest):
-        from .rigid_body import C4976207_PhysXRigidBodies_KinematicBehavior as test_module
+        from .tests.rigid_body import RigidBody_KinematicModeWorks as test_module
 
     class C5932042_PhysXForceRegion_LinearDamping(EditorSharedTest):
-        from .force_region import C5932042_PhysXForceRegion_LinearDamping as test_module
+        from .tests.force_region import ForceRegion_LinearDampingForceOnRigidBodies as test_module
 
     class C5932043_ForceRegion_SimpleDragOnRigidBodies(EditorSharedTest):
-        from .force_region import C5932043_ForceRegion_SimpleDragOnRigidBodies as test_module
+        from .tests.force_region import ForceRegion_SimpleDragForceOnRigidBodies as test_module
 
     class C5959760_PhysXForceRegion_PointForceExertion(EditorSharedTest):
-        from .force_region import C5959760_PhysXForceRegion_PointForceExertion as test_module
+        from .tests.force_region import ForceRegion_CapsuleShapedForce as test_module
 
     class C5959764_ForceRegion_ForceRegionImpulsesCapsule(EditorSharedTest):
-        from .force_region import C5959764_ForceRegion_ForceRegionImpulsesCapsule as test_module
+        from .tests.force_region import ForceRegion_ImpulsesCapsuleShapedRigidBody as test_module
 
     class C5340400_RigidBody_ManualMomentOfInertia(EditorSharedTest):
-        from .rigid_body import C5340400_RigidBody_ManualMomentOfInertia as test_module
+        from .tests.rigid_body import RigidBody_MomentOfInertiaManualSetting as test_module
 
     class C4976210_COM_ManualSetting(EditorSharedTest):
-        from .rigid_body import C4976210_COM_ManualSetting as test_module
+        from .tests.rigid_body import RigidBody_COM_ManualSettingWorks as test_module
 
     class C4976194_RigidBody_PhysXComponentIsValid(EditorSharedTest):
-        from .rigid_body import C4976194_RigidBody_PhysXComponentIsValid as test_module
+        from .tests.rigid_body import RigidBody_AddRigidBodyComponent as test_module
 
     class C5932045_ForceRegion_Spline(EditorSharedTest):
-        from .force_region import C5932045_ForceRegion_Spline as test_module
+        from .tests.force_region import ForceRegion_SplineForceOnRigidBodies as test_module
 
     class C4982797_Collider_ColliderOffset(EditorSharedTest):
-        from .collider import C4982797_Collider_ColliderOffset as test_module
+        from .tests.collider import Collider_ColliderPositionOffset as test_module
 
     class C4976200_RigidBody_AngularDampingObjectRotation(EditorSharedTest):
-        from .rigid_body import C4976200_RigidBody_AngularDampingObjectRotation as test_module
+        from .tests.rigid_body import RigidBody_AngularDampingAffectsRotation as test_module
 
     class C5689529_Verify_Terrain_RigidBody_Collider_Mesh(EditorSharedTest):
-        from .general import C5689529_Verify_Terrain_RigidBody_Collider_Mesh as test_module
+        from .tests import Physics_VerifyColliderRigidBodyMeshAndTerrainWorkTogether as test_module
 
     class C5959810_ForceRegion_ForceRegionCombinesForces(EditorSharedTest):
-        from .force_region import C5959810_ForceRegion_ForceRegionCombinesForces as test_module
+        from .tests.force_region import ForceRegion_MultipleForcesInSameComponentCombineForces as test_module
 
     class C5959765_ForceRegion_AssetGetsImpulsed(EditorSharedTest):
-        from .force_region import C5959765_ForceRegion_AssetGetsImpulsed as test_module
+        from .tests.force_region import ForceRegion_ImpulsesPxMeshShapedRigidBody as test_module
 
     class C6274125_ScriptCanvas_TriggerEvents(EditorSharedTest):
-        from .script_canvas import C6274125_ScriptCanvas_TriggerEvents as test_module
+        from .tests.script_canvas import ScriptCanvas_TriggerEvents as test_module
         # needs to be updated to log for unexpected lines
         # expected_lines = test_module.LogLines.expected_lines
 
     class C6090554_ForceRegion_PointForceNegative(EditorSharedTest):
-        from .force_region import C6090554_ForceRegion_PointForceNegative as test_module
+        from .tests.force_region import ForceRegion_ZeroPointForceDoesNothing as test_module
 
     class C6090550_ForceRegion_WorldSpaceForceNegative(EditorSharedTest):
-        from .force_region import C6090550_ForceRegion_WorldSpaceForceNegative as test_module
+        from .tests.force_region import ForceRegion_ZeroWorldSpaceForceDoesNothing as test_module
 
     class C6090552_ForceRegion_LinearDampingNegative(EditorSharedTest):
-        from .force_region import C6090552_ForceRegion_LinearDampingNegative as test_module
+        from .tests.force_region import ForceRegion_ZeroLinearDampingDoesNothing as test_module
 
     class C5968760_ForceRegion_CheckNetForceChange(EditorSharedTest):
-        from .force_region import C5968760_ForceRegion_CheckNetForceChange as test_module
+        from .tests.force_region import ForceRegion_MovingForceRegionChangesNetForce as test_module
 
+    @pytest.mark.xfail(reason="Ongoing issue in Script Canvas, AZ::Event fail to compile on Script Canvas")
     class C12712452_ScriptCanvas_CollisionEvents(EditorSharedTest):
-        from .script_canvas import C12712452_ScriptCanvas_CollisionEvents as test_module
+        from .tests.script_canvas import ScriptCanvas_CollisionEvents as test_module
 
     class C12868578_ForceRegion_DirectionHasNoAffectOnMagnitude(EditorSharedTest):
-        from .force_region import C12868578_ForceRegion_DirectionHasNoAffectOnMagnitude as test_module
+        from .tests.force_region import ForceRegion_DirectionHasNoAffectOnTotalForce as test_module
 
     class C4976204_Verify_Start_Asleep_Condition(EditorSharedTest):
-        from .rigid_body import C4976204_Verify_Start_Asleep_Condition as test_module
+        from .tests.rigid_body import RigidBody_StartAsleepWorks as test_module
 
     class C6090546_ForceRegion_SliceFileInstantiates(EditorSharedTest):
-        from .force_region import C6090546_ForceRegion_SliceFileInstantiates as test_module
+        from .tests.force_region import ForceRegion_SliceFileInstantiates as test_module
 
     class C6090551_ForceRegion_LocalSpaceForceNegative(EditorSharedTest):
-        from .force_region import C6090551_ForceRegion_LocalSpaceForceNegative as test_module
+        from .tests.force_region import ForceRegion_ZeroLocalSpaceForceDoesNothing as test_module
 
     class C6090553_ForceRegion_SimpleDragForceOnRigidBodies(EditorSharedTest):
-        from .force_region import C6090553_ForceRegion_SimpleDragForceOnRigidBodies as test_module
+        from .tests.force_region import ForceRegion_ZeroSimpleDragForceDoesNothing as test_module
 
     class C4976209_RigidBody_ComputesCOM(EditorSharedTest):
-        from .rigid_body import C4976209_RigidBody_ComputesCOM as test_module
+        from .tests.rigid_body import RigidBody_COM_ComputingWorks as test_module
 
     class C4976201_RigidBody_MassIsAssigned(EditorSharedTest):
-        from .rigid_body import C4976201_RigidBody_MassIsAssigned as test_module
+        from .tests.rigid_body import RigidBody_MassDifferentValuesWorks as test_module
 
     class C12868580_ForceRegion_SplineModifiedTransform(EditorSharedTest):
-        from .force_region import C12868580_ForceRegion_SplineModifiedTransform as test_module
+        from .tests.force_region import ForceRegion_SplineRegionWithModifiedTransform as test_module
 
     class C12712455_ScriptCanvas_ShapeCastVerification(EditorSharedTest):
-        from .script_canvas import C12712455_ScriptCanvas_ShapeCastVerification as test_module
+        from .tests.script_canvas import ScriptCanvas_ShapeCast as test_module
 
     class C4976197_RigidBodies_InitialAngularVelocity(EditorSharedTest):
-        from .rigid_body import C4976197_RigidBodies_InitialAngularVelocity as test_module
+        from .tests.rigid_body import RigidBody_InitialAngularVelocity as test_module
 
     class C6090555_ForceRegion_SplineFollowOnRigidBodies(EditorSharedTest):
-        from .force_region import C6090555_ForceRegion_SplineFollowOnRigidBodies as test_module
+        from .tests.force_region import ForceRegion_ZeroSplineForceDoesNothing as test_module
 
     class C6131473_StaticSlice_OnDynamicSliceSpawn(EditorSharedTest):
-        from .general import C6131473_StaticSlice_OnDynamicSliceSpawn as test_module
+        from .tests import Physics_DynamicSliceWithPhysNotSpawnsStaticSlice as test_module
 
     class C5959808_ForceRegion_PositionOffset(EditorSharedTest):
-        from .force_region import C5959808_ForceRegion_PositionOffset as test_module
+        from .tests.force_region import ForceRegion_PositionOffset as test_module
 
     @pytest.mark.xfail(reason="Something with the CryRenderer disabling is causing this test to fail now.")
     class C13895144_Ragdoll_ChangeLevel(EditorSharedTest):
-        from .ragdoll import C13895144_Ragdoll_ChangeLevel as test_module
+        from .tests.ragdoll import Ragdoll_LevelSwitchDoesNotCrash as test_module
     
     class C5968759_ForceRegion_ExertsSeveralForcesOnRigidBody(EditorSharedTest):
-        from .force_region import C5968759_ForceRegion_ExertsSeveralForcesOnRigidBody as test_module
+        from .tests.force_region import ForceRegion_MultipleComponentsCombineForces as test_module
 
     @pytest.mark.xfail(reason="This test will sometimes fail as the ball will continue to roll before the timeout is reached.")
     class C4976202_RigidBody_StopsWhenBelowKineticThreshold(EditorSharedTest):
-        from .rigid_body import C4976202_RigidBody_StopsWhenBelowKineticThreshold as test_module
+        from .tests.rigid_body import RigidBody_SleepWhenBelowKineticThreshold as test_module
 
     class C13351703_COM_NotIncludeTriggerShapes(EditorSharedTest):
-        from .rigid_body import C13351703_COM_NotIncludeTriggerShapes as test_module
+        from .tests.rigid_body import RigidBody_COM_NotIncludesTriggerShapes as test_module
 
     class C5296614_PhysXMaterial_ColliderShape(EditorSharedTest):
-        from .material import C5296614_PhysXMaterial_ColliderShape as test_module
+        from .tests.material import Material_NoEffectIfNoColliderShape as test_module
 
     class C4982595_Collider_TriggerDisablesCollision(EditorSharedTest):
-        from .collider import C4982595_Collider_TriggerDisablesCollision as test_module
+        from .tests.collider import Collider_TriggerPassThrough as test_module
 
     class C14976307_Gravity_SetGravityWorks(EditorSharedTest):
-        from .general import C14976307_Gravity_SetGravityWorks as test_module
+        from .tests.rigid_body import RigidBody_SetGravityWorks as test_module
 
     class C4044694_Material_EmptyLibraryUsesDefault(EditorSharedTest):
-        from .material import C4044694_Material_EmptyLibraryUsesDefault as test_module
+        from .tests.material import Material_EmptyLibraryUsesDefault as test_module
 
     class C15845879_ForceRegion_HighLinearDampingForce(EditorSharedTest):
-        from .force_region import C15845879_ForceRegion_HighLinearDampingForce as test_module
+        from .tests.force_region import ForceRegion_NoQuiverOnHighLinearDampingForce as test_module
 
     class C4976218_RigidBodies_InertiaObjectsNotComputed(EditorSharedTest):
-        from .rigid_body import C4976218_RigidBodies_InertiaObjectsNotComputed as test_module
+        from .tests.rigid_body import RigidBody_ComputeInertiaWorks as test_module
 
     class C14902098_ScriptCanvas_PostPhysicsUpdate(EditorSharedTest):
-        from .script_canvas import C14902098_ScriptCanvas_PostPhysicsUpdate as test_module
+        from .tests.script_canvas import ScriptCanvas_PostPhysicsUpdate as test_module
         # Note: Test needs to be updated to log for unexpected lines
         # unexpected_lines = ["Assert"] + test_module.Lines.unexpected
 
     class C5959761_ForceRegion_PhysAssetExertsPointForce(EditorSharedTest):
-        from .force_region import C5959761_ForceRegion_PhysAssetExertsPointForce as test_module
+        from .tests.force_region import ForceRegion_PxMeshShapedForce as test_module
         
     # Marking the Test as expected to fail using the xfail decorator due to sporadic failure on Automated Review: SPEC-3146
     # The test still runs, but a failure of the test doesn't result in the test run failing
     @pytest.mark.xfail(reason="Test Sporadically fails with message [ NOT FOUND ] Success: Bar1 : Expected angular velocity")
     class C13352089_RigidBodies_MaxAngularVelocity(EditorSharedTest):
-        from .rigid_body import C13352089_RigidBodies_MaxAngularVelocity as test_module
+        from .tests.rigid_body import RigidBody_MaxAngularVelocityWorks as test_module
 
     class C18243584_Joints_HingeSoftLimitsConstrained(EditorSharedTest):
-        from .joints import C18243584_Joints_HingeSoftLimitsConstrained as test_module
+        from .tests.joints import Joints_HingeSoftLimitsConstrained as test_module
 
     class C18243589_Joints_BallSoftLimitsConstrained(EditorSharedTest):
-        from .joints import C18243589_Joints_BallSoftLimitsConstrained as test_module
+        from .tests.joints import Joints_BallSoftLimitsConstrained as test_module
 
     class C18243591_Joints_BallLeadFollowerCollide(EditorSharedTest):
-        from .joints import C18243591_Joints_BallLeadFollowerCollide as test_module
+        from .tests.joints import Joints_BallLeadFollowerCollide as test_module
 
     class C19578018_ShapeColliderWithNoShapeComponent(EditorSharedTest):
-        from .collider import C19578018_ShapeColliderWithNoShapeComponent as test_module
+        from .tests.shape_collider import ShapeCollider_InactiveWhenNoShapeComponent as test_module
 
     class C14861500_DefaultSetting_ColliderShape(EditorSharedTest):
-        from .collider import C14861500_DefaultSetting_ColliderShape as test_module
+        from .tests.collider import Collider_CheckDefaultShapeSettingIsPxMesh as test_module
 
     class C19723164_ShapeCollider_WontCrashEditor(EditorSharedTest):
-        from .collider import C19723164_ShapeColliders_WontCrashEditor as test_module
+        from .tests.shape_collider import ShapeCollider_LargeNumberOfShapeCollidersWontCrashEditor as test_module
 
     class C4982800_PhysXColliderShape_CanBeSelected(EditorSharedTest):
-        from .collider import C4982800_PhysXColliderShape_CanBeSelected as test_module
+        from .tests.collider import Collider_SphereShapeEditting as test_module
 
     class C4982801_PhysXColliderShape_CanBeSelected(EditorSharedTest):
-        from .collider import C4982801_PhysXColliderShape_CanBeSelected as test_module
+        from .tests.collider import Collider_BoxShapeEditting as test_module
 
     class C4982802_PhysXColliderShape_CanBeSelected(EditorSharedTest):
-        from .collider import C4982802_PhysXColliderShape_CanBeSelected as test_module
+        from .tests.collider import Collider_CapsuleShapeEditting as test_module
        
     class C12905528_ForceRegion_WithNonTriggerCollider(EditorSharedTest):
-        from .force_region import C12905528_ForceRegion_WithNonTriggerCollider as test_module
+        from .tests.force_region import ForceRegion_WithNonTriggerColliderWarning as test_module
         # Fixme: expected_lines = ["[Warning] (PhysX Force Region) - Please ensure collider component marked as trigger exists in entity"]
         
     class C5932040_ForceRegion_CubeExertsWorldForce(EditorSharedTest):
-        from .force_region import C5932040_ForceRegion_CubeExertsWorldForce as test_module
+        from .tests.force_region import ForceRegion_WorldSpaceForceOnRigidBodies as test_module
         
     class C5932044_ForceRegion_PointForceOnRigidBody(EditorSharedTest):
-        from .force_region import C5932044_ForceRegion_PointForceOnRigidBody as test_module
+        from .tests.force_region import ForceRegion_PointForceOnRigidBodies as test_module
         
     class C5959759_RigidBody_ForceRegionSpherePointForce(EditorSharedTest):
-        from .force_region import C5959759_RigidBody_ForceRegionSpherePointForce as test_module
+        from .tests.force_region import ForceRegion_SphereShapedForce as test_module
         
     class C5959809_ForceRegion_RotationalOffset(EditorSharedTest):
-        from .force_region import C5959809_ForceRegion_RotationalOffset as test_module
+        from .tests.force_region import ForceRegion_RotationalOffset as test_module
        
     class C15096740_Material_LibraryUpdatedCorrectly(EditorSharedTest):
-        from .material import C15096740_Material_LibraryUpdatedCorrectly as test_module
+        from .tests.material import Material_LibraryClearingAssignsDefault as test_module
         
     class C4976236_AddPhysxColliderComponent(EditorSharedTest):
-        from .collider import C4976236_AddPhysxColliderComponent as test_module
-        
+        from .tests.collider import Collider_AddColliderComponent as test_module
 
     @pytest.mark.xfail(reason="This will fail due to this issue ATOM-15487.")
     class C14861502_PhysXCollider_AssetAutoAssigned(EditorSharedTest):
-        from .collider import C14861502_PhysXCollider_AssetAutoAssigned as test_module
+        from .tests.collider import Collider_PxMeshAutoAssignedWhenModifyingRenderMeshComponent as test_module
         
     class C14861501_PhysXCollider_RenderMeshAutoAssigned(EditorSharedTest):
-        from .collider import C14861501_PhysXCollider_RenderMeshAutoAssigned as test_module
+        from .tests.collider import Collider_PxMeshAutoAssignedWhenAddingRenderMeshComponent as test_module
         
     class C4044695_PhysXCollider_AddMultipleSurfaceFbx(EditorSharedTest):
-        from .collider import C4044695_PhysXCollider_AddMultipleSurfaceFbx as test_module
+        from .tests.collider import Collider_MultipleSurfaceSlots as test_module
         
     class C14861504_RenderMeshAsset_WithNoPxAsset(EditorSharedTest):
-        from .collider import C14861504_RenderMeshAsset_WithNoPxAsset as test_module
+        from .tests.collider import Collider_PxMeshNotAutoAssignedWhenNoPhysicsFbx as test_module
         
     class C100000_RigidBody_EnablingGravityWorksPoC(EditorSharedTest):
-        from .collider import C100000_RigidBody_EnablingGravityWorksPoC as test_module
+        from .tests.rigid_body import RigidBody_EnablingGravityWorksPoC as test_module
 
     class C4982798_Collider_ColliderRotationOffset(EditorSharedTest):
-        from .collider import C4982798_Collider_ColliderRotationOffset as test_module
-
-    class C15308217_NoCrash_LevelSwitch(EditorSharedTest):
-        from .terrain import C15308217_NoCrash_LevelSwitch as test_module
+        from .tests.collider import Collider_ColliderRotationOffset as test_module
 
     class C6090547_ForceRegion_ParentChildForceRegions(EditorSharedTest):
-        from .force_region import C6090547_ForceRegion_ParentChildForceRegions as test_module
+        from .tests.force_region import ForceRegion_ParentChildForcesCombineForces as test_module
 
     class C19578021_ShapeCollider_CanBeAdded(EditorSharedTest):
-        from .collider import C19578021_ShapeCollider_CanBeAdded as test_module
+        from .tests.shape_collider import ShapeCollider_CanBeAddedWitNoWarnings as test_module
 
     class C15425929_Undo_Redo(EditorSharedTest):
-        from .general import C15425929_Undo_Redo as test_module
+        from .tests import Physics_UndoRedoWorksOnEntityWithPhysComponents as test_module

AutomatedTesting/Gem/PythonTests/physics/TestSuite_Periodic.py

@@ -29,220 +29,224 @@ revert_physics_config = fm.file_revert_list(['physxdebugconfiguration.setreg', '
 class TestAutomation(TestAutomationBase):
 
     @revert_physics_config
-    def test_C3510642_Terrain_NotCollideWithTerrain(self, request, workspace, editor, launcher_platform):
-        from .terrain import C3510642_Terrain_NotCollideWithTerrain as test_module
+    def test_Terrain_NoPhysTerrainComponentNoCollision(self, request, workspace, editor, launcher_platform):
+        from .tests.terrain import Terrain_NoPhysTerrainComponentNoCollision as test_module
         self._run_test(request, workspace, editor, test_module)
         
     @revert_physics_config
-    def test_C4976195_RigidBodies_InitialLinearVelocity(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C4976195_RigidBodies_InitialLinearVelocity as test_module
+    def test_RigidBody_InitialLinearVelocity(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_InitialLinearVelocity as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4976206_RigidBodies_GravityEnabledActive(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C4976206_RigidBodies_GravityEnabledActive as test_module
+    def test_RigidBody_StartGravityEnabledWorks(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_StartGravityEnabledWorks as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4976207_PhysXRigidBodies_KinematicBehavior(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C4976207_PhysXRigidBodies_KinematicBehavior as test_module
+    def test_RigidBody_KinematicModeWorks(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_KinematicModeWorks as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C5932042_PhysXForceRegion_LinearDamping(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5932042_PhysXForceRegion_LinearDamping as test_module
+    def test_ForceRegion_LinearDampingForceOnRigidBodies(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_LinearDampingForceOnRigidBodies as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C5932043_ForceRegion_SimpleDragOnRigidBodies(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5932043_ForceRegion_SimpleDragOnRigidBodies as test_module
+    def test_ForceRegion_SimpleDragForceOnRigidBodies(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_SimpleDragForceOnRigidBodies as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C5959760_PhysXForceRegion_PointForceExertion(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5959760_PhysXForceRegion_PointForceExertion as test_module
+    def test_ForceRegion_CapsuleShapedForce(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_CapsuleShapedForce as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C5959764_ForceRegion_ForceRegionImpulsesCapsule(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5959764_ForceRegion_ForceRegionImpulsesCapsule as test_module
+    def test_ForceRegion_ImpulsesCapsuleShapedRigidBody(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_ImpulsesCapsuleShapedRigidBody as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C5340400_RigidBody_ManualMomentOfInertia(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C5340400_RigidBody_ManualMomentOfInertia as test_module
+    def test_RigidBody_MomentOfInertiaManualSetting(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_MomentOfInertiaManualSetting as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4976210_COM_ManualSetting(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C4976210_COM_ManualSetting as test_module
+    def test_RigidBody_COM_ManualSettingWorks(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_COM_ManualSettingWorks as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4976194_RigidBody_PhysXComponentIsValid(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C4976194_RigidBody_PhysXComponentIsValid as test_module
+    def test_RigidBody_AddRigidBodyComponent(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_AddRigidBodyComponent as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C5932045_ForceRegion_Spline(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5932045_ForceRegion_Spline as test_module
+    def test_ForceRegion_SplineForceOnRigidBodies(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_SplineForceOnRigidBodies as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    @fm.file_override('physxsystemconfiguration.setreg','C4044457_Material_RestitutionCombine.setreg_override', 'AutomatedTesting/Registry')
-    def test_C4044457_Material_RestitutionCombine(self, request, workspace, editor, launcher_platform):
-        from .material import C4044457_Material_RestitutionCombine as test_module
+    @fm.file_override('physxsystemconfiguration.setreg','Material_RestitutionCombine.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_Material_RestitutionCombine(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_RestitutionCombine as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    @fm.file_override('physxsystemconfiguration.setreg','C4044456_Material_FrictionCombine.setreg_override', 'AutomatedTesting/Registry')
-    def test_C4044456_Material_FrictionCombine(self, request, workspace, editor, launcher_platform):
-        from .material import C4044456_Material_FrictionCombine as test_module
+    @fm.file_override('physxsystemconfiguration.setreg','Material_FrictionCombine.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_Material_FrictionCombine(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_FrictionCombine as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4982797_Collider_ColliderOffset(self, request, workspace, editor, launcher_platform):
-        from .collider import C4982797_Collider_ColliderOffset as test_module
+    def test_Collider_ColliderPositionOffset(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_ColliderPositionOffset as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4976200_RigidBody_AngularDampingObjectRotation(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C4976200_RigidBody_AngularDampingObjectRotation as test_module
+    def test_RigidBody_AngularDampingAffectsRotation(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_AngularDampingAffectsRotation as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C5689529_Verify_Terrain_RigidBody_Collider_Mesh(self, request, workspace, editor, launcher_platform):
-        from .general import C5689529_Verify_Terrain_RigidBody_Collider_Mesh as test_module
+    def test_Physics_VerifyColliderRigidBodyMeshAndTerrainWorkTogether(self, request, workspace, editor, launcher_platform):
+        from .tests import Physics_VerifyColliderRigidBodyMeshAndTerrainWorkTogether as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C5959810_ForceRegion_ForceRegionCombinesForces(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5959810_ForceRegion_ForceRegionCombinesForces as test_module
+    def test_ForceRegion_MultipleForcesInSameComponentCombineForces(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_MultipleForcesInSameComponentCombineForces as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C5959765_ForceRegion_AssetGetsImpulsed(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5959765_ForceRegion_AssetGetsImpulsed as test_module
+    def test_ForceRegion_ImpulsesPxMeshShapedRigidBody(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_ImpulsesPxMeshShapedRigidBody as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C6274125_ScriptCanvas_TriggerEvents(self, request, workspace, editor, launcher_platform):
-        from .script_canvas import C6274125_ScriptCanvas_TriggerEvents as test_module
+    def test_ScriptCanvas_TriggerEvents(self, request, workspace, editor, launcher_platform):
+        from .tests.script_canvas import ScriptCanvas_TriggerEvents as test_module
         # FIXME: expected_lines = test_module.LogLines.expected_lines
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C6090554_ForceRegion_PointForceNegative(self, request, workspace, editor, launcher_platform):
-        from .force_region import C6090554_ForceRegion_PointForceNegative as test_module
+    def test_ForceRegion_ZeroPointForceDoesNothing(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_ZeroPointForceDoesNothing as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C6090550_ForceRegion_WorldSpaceForceNegative(self, request, workspace, editor, launcher_platform):
-        from .force_region import C6090550_ForceRegion_WorldSpaceForceNegative as test_module
+    def test_ForceRegion_ZeroWorldSpaceForceDoesNothing(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_ZeroWorldSpaceForceDoesNothing as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C6090552_ForceRegion_LinearDampingNegative(self, request, workspace, editor, launcher_platform):
-        from .force_region import C6090552_ForceRegion_LinearDampingNegative as test_module
+    def test_ForceRegion_ZeroLinearDampingDoesNothing(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_ZeroLinearDampingDoesNothing as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C5968760_ForceRegion_CheckNetForceChange(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5968760_ForceRegion_CheckNetForceChange as test_module
+    def test_ForceRegion_MovingForceRegionChangesNetForce(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_MovingForceRegionChangesNetForce as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C12712452_ScriptCanvas_CollisionEvents(self, request, workspace, editor, launcher_platform):
-        from .script_canvas import C12712452_ScriptCanvas_CollisionEvents as test_module
+    def test_ScriptCanvas_CollisionEvents(self, request, workspace, editor, launcher_platform):
+        from .tests.script_canvas import ScriptCanvas_CollisionEvents as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C12868578_ForceRegion_DirectionHasNoAffectOnMagnitude(self, request, workspace, editor, launcher_platform):
-        from .force_region import C12868578_ForceRegion_DirectionHasNoAffectOnMagnitude as test_module
+    def test_ForceRegion_DirectionHasNoAffectOnTotalForce(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_DirectionHasNoAffectOnTotalForce as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4976204_Verify_Start_Asleep_Condition(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C4976204_Verify_Start_Asleep_Condition as test_module
+    def test_RigidBody_StartAsleepWorks(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_StartAsleepWorks as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C6090546_ForceRegion_SliceFileInstantiates(self, request, workspace, editor, launcher_platform):
-        from .force_region import C6090546_ForceRegion_SliceFileInstantiates as test_module
+    def test_ForceRegion_SliceFileInstantiates(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_SliceFileInstantiates as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C6090551_ForceRegion_LocalSpaceForceNegative(self, request, workspace, editor, launcher_platform):
-        from .force_region import C6090551_ForceRegion_LocalSpaceForceNegative as test_module
+    def test_ForceRegion_ZeroLocalSpaceForceDoesNothing(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_ZeroLocalSpaceForceDoesNothing as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C6090553_ForceRegion_SimpleDragForceOnRigidBodies(self, request, workspace, editor, launcher_platform):
-        from .force_region import C6090553_ForceRegion_SimpleDragForceOnRigidBodies as test_module
+    def test_ForceRegion_ZeroSimpleDragForceDoesNothing(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_ZeroSimpleDragForceDoesNothing as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4976209_RigidBody_ComputesCOM(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C4976209_RigidBody_ComputesCOM as test_module
+    def test_RigidBody_COM_ComputingWorks(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_COM_ComputingWorks as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4976201_RigidBody_MassIsAssigned(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C4976201_RigidBody_MassIsAssigned as test_module
+    def test_RigidBody_MassDifferentValuesWorks(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_MassDifferentValuesWorks as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    @fm.file_override('physxsystemconfiguration.setreg','C18981526_Material_RestitutionCombinePriority.setreg_override', 'AutomatedTesting/Registry')
-    def test_C18981526_Material_RestitutionCombinePriority(self, request, workspace, editor, launcher_platform):
-        from .material import C18981526_Material_RestitutionCombinePriority as test_module
+    @fm.file_override('physxsystemconfiguration.setreg','Material_RestitutionCombinePriorityOrder.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_Material_RestitutionCombinePriorityOrder(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_RestitutionCombinePriorityOrder as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C12868580_ForceRegion_SplineModifiedTransform(self, request, workspace, editor, launcher_platform):
-        from .force_region import C12868580_ForceRegion_SplineModifiedTransform as test_module
+    def test_ForceRegion_SplineRegionWithModifiedTransform(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_SplineRegionWithModifiedTransform as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C12712455_ScriptCanvas_ShapeCastVerification(self, request, workspace, editor, launcher_platform):
-        from .script_canvas import C12712455_ScriptCanvas_ShapeCastVerification as test_module
+    def test_ScriptCanvas_ShapeCast(self, request, workspace, editor, launcher_platform):
+        from .tests.script_canvas import ScriptCanvas_ShapeCast as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4976197_RigidBodies_InitialAngularVelocity(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C4976197_RigidBodies_InitialAngularVelocity as test_module
+    def test_RigidBody_InitialAngularVelocity(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_InitialAngularVelocity as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C6090555_ForceRegion_SplineFollowOnRigidBodies(self, request, workspace, editor, launcher_platform):
-        from .force_region import C6090555_ForceRegion_SplineFollowOnRigidBodies as test_module
+    def test_ForceRegion_ZeroSplineForceDoesNothing(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_ZeroSplineForceDoesNothing as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C6131473_StaticSlice_OnDynamicSliceSpawn(self, request, workspace, editor, launcher_platform):
-        from .general import C6131473_StaticSlice_OnDynamicSliceSpawn as test_module
+    def test_Physics_DynamicSliceWithPhysNotSpawnsStaticSlice(self, request, workspace, editor, launcher_platform):
+        from .tests import Physics_DynamicSliceWithPhysNotSpawnsStaticSlice as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C5959808_ForceRegion_PositionOffset(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5959808_ForceRegion_PositionOffset as test_module
+    def test_ForceRegion_PositionOffset(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_PositionOffset as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    @fm.file_override('physxsystemconfiguration.setreg','C18977601_Material_FrictionCombinePriority.setreg_override', 'AutomatedTesting/Registry')
-    def test_C18977601_Material_FrictionCombinePriority(self, request, workspace, editor, launcher_platform):
-        from .material import C18977601_Material_FrictionCombinePriority as test_module
+    @fm.file_override('physxsystemconfiguration.setreg','Material_FrictionCombinePriorityOrder.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_Material_FrictionCombinePriorityOrder(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_FrictionCombinePriorityOrder as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @pytest.mark.xfail(
         reason="Something with the CryRenderer disabling is causing this test to fail now.")
     @revert_physics_config
-    def test_C13895144_Ragdoll_ChangeLevel(self, request, workspace, editor, launcher_platform):
-        from .ragdoll import C13895144_Ragdoll_ChangeLevel as test_module
+    def test_Ragdoll_LevelSwitchDoesNotCrash(self, request, workspace, editor, launcher_platform):
+        from .tests.ragdoll import Ragdoll_LevelSwitchDoesNotCrash as test_module
         self._run_test(request, workspace, editor, test_module)
     
     @revert_physics_config
-    def test_C5968759_ForceRegion_ExertsSeveralForcesOnRigidBody(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5968759_ForceRegion_ExertsSeveralForcesOnRigidBody as test_module
+    def test_ForceRegion_MultipleComponentsCombineForces(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_MultipleComponentsCombineForces as test_module
         self._run_test(request, workspace, editor, test_module)
 
     # Marking the test as an expected failure due to sporadic failure on Automated Review: LYN-2580
@@ -250,237 +254,303 @@ class TestAutomation(TestAutomationBase):
     @pytest.mark.xfail(
         reason="This test needs new physics asset with multiple materials to be more stable.")
     @revert_physics_config
-    @fm.file_override('physxsystemconfiguration.setreg','C4044697_Material_PerfaceMaterialValidation.setreg_override', 'AutomatedTesting/Registry')
-    def test_C4044697_Material_PerfaceMaterialValidation(self, request, workspace, editor, launcher_platform):
-        from .material import C4044697_Material_PerfaceMaterialValidation as test_module
+    @fm.file_override('physxsystemconfiguration.setreg', 'Material_PerFaceMaterialGetsCorrectMaterial.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_Material_PerFaceMaterialGetsCorrectMaterial(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_PerFaceMaterialGetsCorrectMaterial as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @pytest.mark.xfail(
         reason="This test will sometimes fail as the ball will continue to roll before the timeout is reached.")
     @revert_physics_config
-    def test_C4976202_RigidBody_StopsWhenBelowKineticThreshold(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C4976202_RigidBody_StopsWhenBelowKineticThreshold as test_module
+    def test_RigidBody_SleepWhenBelowKineticThreshold(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_SleepWhenBelowKineticThreshold as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C13351703_COM_NotIncludeTriggerShapes(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C13351703_COM_NotIncludeTriggerShapes as test_module
+    def test_RigidBody_COM_NotIncludesTriggerShapes(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_COM_NotIncludesTriggerShapes as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C5296614_PhysXMaterial_ColliderShape(self, request, workspace, editor, launcher_platform):
-        from .material import C5296614_PhysXMaterial_ColliderShape as test_module
+    def test_Material_NoEffectIfNoColliderShape(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_NoEffectIfNoColliderShape as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4982595_Collider_TriggerDisablesCollision(self, request, workspace, editor, launcher_platform):
-        from .collider import C4982595_Collider_TriggerDisablesCollision as test_module
+    def test_Collider_TriggerPassThrough(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_TriggerPassThrough as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C14976307_Gravity_SetGravityWorks(self, request, workspace, editor, launcher_platform):
-        from .general import C14976307_Gravity_SetGravityWorks as test_module
+    def test_RigidBody_SetGravityWorks(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_SetGravityWorks as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    @fm.file_override('physxsystemconfiguration.setreg','C15556261_PhysXMaterials_CharacterControllerMaterialAssignment.setreg_override', 'AutomatedTesting/Registry')
-    def test_C15556261_PhysXMaterials_CharacterControllerMaterialAssignment(self, request, workspace, editor, launcher_platform):
-        from .material import C15556261_PhysXMaterials_CharacterControllerMaterialAssignment as test_module
+    @fm.file_override('physxsystemconfiguration.setreg','Material_CharacterController.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_Material_CharacterController(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_CharacterController as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4044694_Material_EmptyLibraryUsesDefault(self, request, workspace, editor, launcher_platform):
-        from .material import C4044694_Material_EmptyLibraryUsesDefault as test_module
+    def test_Material_EmptyLibraryUsesDefault(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_EmptyLibraryUsesDefault as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C15845879_ForceRegion_HighLinearDampingForce(self, request, workspace, editor, launcher_platform):
-        from .force_region import C15845879_ForceRegion_HighLinearDampingForce as test_module
+    def test_ForceRegion_NoQuiverOnHighLinearDampingForce(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_NoQuiverOnHighLinearDampingForce as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4976218_RigidBodies_InertiaObjectsNotComputed(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C4976218_RigidBodies_InertiaObjectsNotComputed as test_module
+    def test_RigidBody_ComputeInertiaWorks(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_ComputeInertiaWorks as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C14902098_ScriptCanvas_PostPhysicsUpdate(self, request, workspace, editor, launcher_platform):
-        from .script_canvas import C14902098_ScriptCanvas_PostPhysicsUpdate as test_module
+    def test_ScriptCanvas_PostPhysicsUpdate(self, request, workspace, editor, launcher_platform):
+        from .tests.script_canvas import ScriptCanvas_PostPhysicsUpdate as test_module
         # Fixme: unexpected_lines = ["Assert"] + test_module.Lines.unexpected
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    @fm.file_override('physxsystemconfiguration.setreg','C4976245_PhysXCollider_CollisionLayerTest.setreg_override', 'AutomatedTesting/Registry')
-    def test_C4976245_PhysXCollider_CollisionLayerTest(self, request, workspace, editor, launcher_platform):
-        from .collider import C4976245_PhysXCollider_CollisionLayerTest as test_module
+    @fm.file_override('physxsystemconfiguration.setreg','Collider_NoneCollisionGroupSameLayerNotCollide.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_Collider_NoneCollisionGroupSameLayerNotCollide(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_NoneCollisionGroupSameLayerNotCollide as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    @fm.file_override('physxsystemconfiguration.setreg','C4976244_Collider_SameGroupSameLayerCollision.setreg_override', 'AutomatedTesting/Registry')
-    def test_C4976244_Collider_SameGroupSameLayerCollision(self, request, workspace, editor, launcher_platform):
-        from .collider import C4976244_Collider_SameGroupSameLayerCollision as test_module
+    @fm.file_override('physxsystemconfiguration.setreg','Collider_SameCollisionGroupSameCustomLayerCollide.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_Collider_SameCollisionGroupSameCustomLayerCollide(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_SameCollisionGroupSameCustomLayerCollide as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    @fm.file_override('physxdefaultsceneconfiguration.setreg','C14195074_ScriptCanvas_PostUpdateEvent.setreg_override', 'AutomatedTesting/Registry')
-    def test_C14195074_ScriptCanvas_PostUpdateEvent(self, request, workspace, editor, launcher_platform):
-        from .script_canvas import C14195074_ScriptCanvas_PostUpdateEvent as test_module
+    @fm.file_override('physxdefaultsceneconfiguration.setreg','ScriptCanvas_PostUpdateEvent.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_ScriptCanvas_PostUpdateEvent(self, request, workspace, editor, launcher_platform):
+        from .tests.script_canvas import ScriptCanvas_PostUpdateEvent as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    @fm.file_override('physxsystemconfiguration.setreg','C4044461_Material_Restitution.setreg_override', 'AutomatedTesting/Registry')
-    def test_C4044461_Material_Restitution(self, request, workspace, editor, launcher_platform):
-        from .material import C4044461_Material_Restitution as test_module
+    @fm.file_override('physxsystemconfiguration.setreg','Material_Restitution.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_Material_Restitution(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_Restitution as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    @fm.file_override('physxdefaultsceneconfiguration.setreg','C14902097_ScriptCanvas_PreUpdateEvent.setreg_override', 'AutomatedTesting/Registry')
-    def test_C14902097_ScriptCanvas_PreUpdateEvent(self, request, workspace, editor, launcher_platform):
-        from .script_canvas import C14902097_ScriptCanvas_PreUpdateEvent as test_module
+    @fm.file_override('physxdefaultsceneconfiguration.setreg', 'ScriptCanvas_PreUpdateEvent.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_ScriptCanvas_PreUpdateEvent(self, request, workspace, editor, launcher_platform):
+        from .tests.script_canvas import ScriptCanvas_PreUpdateEvent as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C5959761_ForceRegion_PhysAssetExertsPointForce(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5959761_ForceRegion_PhysAssetExertsPointForce as test_module
+    def test_ForceRegion_PxMeshShapedForce(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_PxMeshShapedForce as test_module
         self._run_test(request, workspace, editor, test_module)
 
     # Marking the Test  as expected to fail using the xfail decorator due to sporadic failure on Automated Review: SPEC-3146
     # The test still runs, but a failure of the test doesn't result in the test run failing
     @pytest.mark.xfail(reason="Test Sporadically fails with message [ NOT FOUND ] Success: Bar1 : Expected angular velocity")
     @revert_physics_config
-    def test_C13352089_RigidBodies_MaxAngularVelocity(self, request, workspace, editor, launcher_platform):
-        from .rigid_body import C13352089_RigidBodies_MaxAngularVelocity as test_module
+    def test_RigidBody_MaxAngularVelocityWorks(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_MaxAngularVelocityWorks as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C18243584_Joints_HingeSoftLimitsConstrained(self, request, workspace, editor, launcher_platform):
-        from .joints import C18243584_Joints_HingeSoftLimitsConstrained as test_module
+    def test_Joints_HingeSoftLimitsConstrained(self, request, workspace, editor, launcher_platform):
+        from .tests.joints import Joints_HingeSoftLimitsConstrained as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C18243589_Joints_BallSoftLimitsConstrained(self, request, workspace, editor, launcher_platform):
-        from .joints import C18243589_Joints_BallSoftLimitsConstrained as test_module
+    def test_Joints_BallSoftLimitsConstrained(self, request, workspace, editor, launcher_platform):
+        from .tests.joints import Joints_BallSoftLimitsConstrained as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C18243591_Joints_BallLeadFollowerCollide(self, request, workspace, editor, launcher_platform):
-        from .joints import C18243591_Joints_BallLeadFollowerCollide as test_module
+    def test_Joints_BallLeadFollowerCollide(self, request, workspace, editor, launcher_platform):
+        from .tests.joints import Joints_BallLeadFollowerCollide as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    @fm.file_override('physxsystemconfiguration.setreg','C4976227_Collider_NewGroup.setreg_override', 'AutomatedTesting/Registry')
-    def test_C4976227_Collider_NewGroup(self, request, workspace, editor, launcher_platform):
-        from .collider import C4976227_Collider_NewGroup as test_module
+    @fm.file_override('physxsystemconfiguration.setreg','Collider_AddingNewGroupWorks.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_Collider_AddingNewGroupWorks(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_AddingNewGroupWorks as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C19578018_ShapeColliderWithNoShapeComponent(self, request, workspace, editor, launcher_platform):
-        from .collider import C19578018_ShapeColliderWithNoShapeComponent as test_module
+    def test_ShapeCollider_InactiveWhenNoShapeComponent(self, request, workspace, editor, launcher_platform):
+        from .tests.shape_collider import ShapeCollider_InactiveWhenNoShapeComponent as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C14861500_DefaultSetting_ColliderShape(self, request, workspace, editor, launcher_platform):
-        from .collider import C14861500_DefaultSetting_ColliderShape as test_module
+    def test_Collider_CheckDefaultShapeSettingIsPxMesh(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_CheckDefaultShapeSettingIsPxMesh as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C19723164_ShapeCollider_WontCrashEditor(self, request, workspace, editor, launcher_platform):
-        from .collider import C19723164_ShapeColliders_WontCrashEditor as test_module
+    def test_ShapeCollider_LargeNumberOfShapeCollidersWontCrashEditor(self, request, workspace, editor, launcher_platform):
+        from .tests.shape_collider import ShapeCollider_LargeNumberOfShapeCollidersWontCrashEditor as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4982800_PhysXColliderShape_CanBeSelected(self, request, workspace, editor, launcher_platform):
-        from .collider import C4982800_PhysXColliderShape_CanBeSelected as test_module
+    def test_Collider_SphereShapeEditting(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_SphereShapeEditting as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4982801_PhysXColliderShape_CanBeSelected(self, request, workspace, editor, launcher_platform):
-        from .collider import C4982801_PhysXColliderShape_CanBeSelected as test_module
+    def test_Collider_BoxShapeEditting(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_BoxShapeEditting as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4982802_PhysXColliderShape_CanBeSelected(self, request, workspace, editor, launcher_platform):
-        from .collider import C4982802_PhysXColliderShape_CanBeSelected as test_module
+    def test_Collider_CapsuleShapeEditting(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_CapsuleShapeEditting as test_module
         self._run_test(request, workspace, editor, test_module)
 
-    def test_C12905528_ForceRegion_WithNonTriggerCollider(self, request, workspace, editor, launcher_platform):
-        from .force_region import C12905528_ForceRegion_WithNonTriggerCollider as test_module
+    def test_ForceRegion_WithNonTriggerColliderWarning(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_WithNonTriggerColliderWarning as test_module
         # Fixme: expected_lines = ["[Warning] (PhysX Force Region) - Please ensure collider component marked as trigger exists in entity"]
         self._run_test(request, workspace, editor, test_module)
 
-    def test_C5932040_ForceRegion_CubeExertsWorldForce(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5932040_ForceRegion_CubeExertsWorldForce as test_module
+    def test_ForceRegion_WorldSpaceForceOnRigidBodies(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_WorldSpaceForceOnRigidBodies as test_module
         self._run_test(request, workspace, editor, test_module)
 
-    def test_C5932044_ForceRegion_PointForceOnRigidBody(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5932044_ForceRegion_PointForceOnRigidBody as test_module
+    def test_ForceRegion_PointForceOnRigidBodies(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_PointForceOnRigidBodies as test_module
         self._run_test(request, workspace, editor, test_module)
 
-    def test_C5959759_RigidBody_ForceRegionSpherePointForce(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5959759_RigidBody_ForceRegionSpherePointForce as test_module
+    def test_ForceRegion_SphereShapedForce(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_SphereShapedForce as test_module
         self._run_test(request, workspace, editor, test_module)
 
-    def test_C5959809_ForceRegion_RotationalOffset(self, request, workspace, editor, launcher_platform):
-        from .force_region import C5959809_ForceRegion_RotationalOffset as test_module
+    def test_ForceRegion_RotationalOffset(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_RotationalOffset as test_module
         self._run_test(request, workspace, editor, test_module)
 
-    def test_C15096740_Material_LibraryUpdatedCorrectly(self, request, workspace, editor, launcher_platform):
-        from .material import C15096740_Material_LibraryUpdatedCorrectly as test_module
+    def test_Material_LibraryClearingAssignsDefault(self, request, workspace, editor, launcher_platform):
+        from .tests.material import Material_LibraryClearingAssignsDefault as test_module
         self._run_test(request, workspace, editor, test_module)
 
-    def test_C4976236_AddPhysxColliderComponent(self, request, workspace, editor, launcher_platform):
-        from .collider import C4976236_AddPhysxColliderComponent as test_module
+    def test_Collider_AddColliderComponent(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_AddColliderComponent as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @pytest.mark.xfail(
         reason="This will fail due to this issue ATOM-15487.")
-    def test_C14861502_PhysXCollider_AssetAutoAssigned(self, request, workspace, editor, launcher_platform):
-        from .collider import C14861502_PhysXCollider_AssetAutoAssigned as test_module
+    def test_Collider_PxMeshAutoAssignedWhenModifyingRenderMeshComponent(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_PxMeshAutoAssignedWhenModifyingRenderMeshComponent as test_module
         self._run_test(request, workspace, editor, test_module)
 
-    def test_C14861501_PhysXCollider_RenderMeshAutoAssigned(self, request, workspace, editor, launcher_platform):
-        from .collider import C14861501_PhysXCollider_RenderMeshAutoAssigned as test_module
+    def test_Collider_PxMeshAutoAssignedWhenAddingRenderMeshComponent(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_PxMeshAutoAssignedWhenAddingRenderMeshComponent as test_module
         self._run_test(request, workspace, editor, test_module)
 
-    def test_C4044695_PhysXCollider_AddMultipleSurfaceFbx(self, request, workspace, editor, launcher_platform):
-        from .collider import C4044695_PhysXCollider_AddMultipleSurfaceFbx as test_module
+    def test_Collider_MultipleSurfaceSlots(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_MultipleSurfaceSlots as test_module
         self._run_test(request, workspace, editor, test_module)
 
-    def test_C14861504_RenderMeshAsset_WithNoPxAsset(self, request, workspace, editor, launcher_platform):
-        from .collider import C14861504_RenderMeshAsset_WithNoPxAsset as test_module
+    def test_Collider_PxMeshNotAutoAssignedWhenNoPhysicsFbx(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_PxMeshNotAutoAssignedWhenNoPhysicsFbx as test_module
         self._run_test(request, workspace, editor, test_module)
 
-    def test_C100000_RigidBody_EnablingGravityWorksPoC(self, request, workspace, editor, launcher_platform):
-        from .collider import C100000_RigidBody_EnablingGravityWorksPoC as test_module
+    def test_RigidBody_EnablingGravityWorksPoC(self, request, workspace, editor, launcher_platform):
+        from .tests.rigid_body import RigidBody_EnablingGravityWorksPoC as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    @fm.file_override('physxsystemconfiguration.setreg','C3510644_Collider_CollisionGroups.setreg_override', 'AutomatedTesting/Registry')
-    def test_C3510644_Collider_CollisionGroups(self, request, workspace, editor, launcher_platform):
-        from .collider import C3510644_Collider_CollisionGroups as test_module
+    @fm.file_override('physxsystemconfiguration.setreg','Collider_CollisionGroupsWorkflow.setreg_override',
+                      'AutomatedTesting/Registry', search_subdirs=True)
+    def test_Collider_CollisionGroupsWorkflow(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_CollisionGroupsWorkflow as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C4982798_Collider_ColliderRotationOffset(self, request, workspace, editor, launcher_platform):
-        from .collider import C4982798_Collider_ColliderRotationOffset as test_module
+    def test_Collider_ColliderRotationOffset(self, request, workspace, editor, launcher_platform):
+        from .tests.collider import Collider_ColliderRotationOffset as test_module
         self._run_test(request, workspace, editor, test_module)
 
     @revert_physics_config
-    def test_C15308217_NoCrash_LevelSwitch(self, request, workspace, editor, launcher_platform):
-        from .terrain import C15308217_NoCrash_LevelSwitch as test_module
-        self._run_test(request, workspace, editor, test_module)
-
-    @revert_physics_config
-    def test_C6090547_ForceRegion_ParentChildForceRegions(self, request, workspace, editor, launcher_platform):
-        from .force_region import C6090547_ForceRegion_ParentChildForceRegions as test_module
+    def test_ForceRegion_ParentChildForcesCombineForces(self, request, workspace, editor, launcher_platform):
+        from .tests.force_region import ForceRegion_ParentChildForcesCombineForces as test_module
         self._run_test(request, workspace, editor, test_module)
         
     @revert_physics_config
-    def test_C19578021_ShapeCollider_CanBeAdded(self, request, workspace, editor, launcher_platform):
-        from .collider import C19578021_ShapeCollider_CanBeAdded as test_module
+    def test_ShapeCollider_CanBeAddedWitNoWarnings(self, request, workspace, editor, launcher_platform):
+        from .tests.shape_collider import ShapeCollider_CanBeAddedWitNoWarnings as test_module
         self._run_test(request, workspace, editor, test_module)
         
     @revert_physics_config
-    def test_C15425929_Undo_Redo(self, request, workspace, editor, launcher_platform):
-        from .general import C15425929_Undo_Redo as test_module
+    def test_Physics_UndoRedoWorksOnEntityWithPhysComponents(self, request, workspace, editor, launcher_platform):
+        from .tests import Physics_UndoRedoWorksOnEntityWithPhysComponents as test_module
         self._run_test(request, workspace, editor, test_module)
+    
+    def test_Joints_Fixed2BodiesConstrained(self, request, workspace, editor, launcher_platform):
+        from .tests.joints import Joints_Fixed2BodiesConstrained as test_module
+        self._run_test(request, workspace, editor, test_module)
+
+    def test_Joints_Hinge2BodiesConstrained(self, request, workspace, editor, launcher_platform):
+        from .tests.joints import Joints_Hinge2BodiesConstrained as test_module
+        self._run_test(request, workspace, editor, test_module)
+
+    def test_Joints_Ball2BodiesConstrained(self, request, workspace, editor, launcher_platform):
+        from .tests.joints import Joints_Ball2BodiesConstrained as test_module
+        self._run_test(request, workspace, editor, test_module)
+
+    def test_Joints_FixedBreakable(self, request, workspace, editor, launcher_platform):
+        from .tests.joints import Joints_FixedBreakable as test_module
+        self._run_test(request, workspace, editor, test_module)
+
+    def test_Joints_HingeBreakable(self, request, workspace, editor, launcher_platform):
+        from .tests.joints import Joints_HingeBreakable as test_module
+        self._run_test(request, workspace, editor, test_module)
+
+    def test_Joints_BallBreakable(self, request, workspace, editor, launcher_platform):
+        from .tests.joints import Joints_BallBreakable as test_module
+        self._run_test(request, workspace, editor, test_module)
+
+    def test_Joints_HingeNoLimitsConstrained(self, request, workspace, editor, launcher_platform):
+        from .tests.joints import Joints_HingeNoLimitsConstrained as test_module
+        self._run_test(request, workspace, editor, test_module)
+
+    def test_Joints_BallNoLimitsConstrained(self, request, workspace, editor, launcher_platform):
+        from .tests.joints import Joints_BallNoLimitsConstrained as test_module
+        self._run_test(request, workspace, editor, test_module)
+
+    def test_Joints_FixedLeadFollowerCollide(self, request, workspace, editor, launcher_platform):
+        from .tests.joints import Joints_FixedLeadFollowerCollide as test_module
+        self._run_test(request, workspace, editor, test_module)
+
+    def test_Joints_GlobalFrameConstrained(self, request, workspace, editor, launcher_platform):
+        from .tests.joints import Joints_GlobalFrameConstrained as test_module
+        self._run_test(request, workspace, editor, test_module)
+    
+    @revert_physics_config
+    def test_Material_DefaultLibraryUpdatedAcrossLevels(self, request, workspace, editor, launcher_platform):
+        @fm.file_override("physxsystemconfiguration.setreg",
+                          "Material_DefaultLibraryUpdatedAcrossLevels_before.setreg",
+                          "AutomatedTesting",
+                          search_subdirs=True)
+        def levels_before(self, request, workspace, editor, launcher_platform):
+            from .tests.material import Material_DefaultLibraryUpdatedAcrossLevels_before as test_module_0
+            self._run_test(request, workspace, editor, test_module_0)
+
+        # File override replaces the previous physxconfiguration file with another where the only difference is the default material library
+        @fm.file_override("physxsystemconfiguration.setreg",
+                          "Material_DefaultLibraryUpdatedAcrossLevels_after.setreg",
+                          "AutomatedTesting",
+                          search_subdirs=True)
+        def levels_after(self, request, workspace, editor, launcher_platform):
+            from .tests.material import Material_DefaultLibraryUpdatedAcrossLevels_after as test_module_1
+            self._run_test(request, workspace, editor, test_module_1)
+
+        levels_before(self, request, workspace, editor, launcher_platform)
+        levels_after(self, request, workspace, editor, launcher_platform)

AutomatedTesting/Gem/PythonTests/physics/TestSuite_Sandbox.py

@@ -29,25 +29,17 @@ revert_physics_config = fm.file_revert_list(['physxdebugconfiguration.setreg', '
 class TestAutomation(TestAutomationBase):
 
     ## Seems to be flaky, need to investigate
-    def test_C19536274_GetCollisionName_PrintsName(self, request, workspace, editor, launcher_platform):
-        from .general import C19536274_GetCollisionName_PrintsName as test_module
+    def test_ScriptCanvas_GetCollisionNameReturnsName(self, request, workspace, editor, launcher_platform):
+        from .tests.script_canvas import ScriptCanvas_GetCollisionNameReturnsName as test_module
         # Fixme: expected_lines=["Layer Name: Right"]
         self._run_test(request, workspace, editor, test_module)
 
     ## Seems to be flaky, need to investigate
-    def test_C19536277_GetCollisionName_PrintsNothing(self, request, workspace, editor, launcher_platform):
-        from .general import C19536277_GetCollisionName_PrintsNothing as test_module
+    def test_ScriptCanvas_GetCollisionNameReturnsNothingWhenHasToggledLayer(self, request, workspace, editor, launcher_platform):
+        from .tests.script_canvas import ScriptCanvas_GetCollisionNameReturnsNothingWhenHasToggledLayer as test_module
         # All groups present in the PhysX Collider that could show up in test
         # Fixme: collision_groups = ["All", "None", "All_NoTouchBend", "All_3", "None_1", "All_NoTouchBend_1", "All_2", "None_1_1", "All_NoTouchBend_1_1", "All_1", "None_1_1_1", "All_NoTouchBend_1_1_1", "All_4", "None_1_1_1_1", "All_NoTouchBend_1_1_1_1", "GroupLeft", "GroupRight"]
         # Fixme: for group in collision_groups:
         # Fixme:    unexpected_lines.append(f"GroupName: {group}")
         # Fixme: expected_lines=["GroupName: "]
         self._run_test(request, workspace, editor, test_module)
-
-    ## Seems to be flaky, need to investigate
-    @pytest.mark.xfail(
-        reason="Editor crashes and errors about files accessed by multiple processes appear in the log.")
-    @revert_physics_config
-    def test_C15425929_Undo_Redo(self, request, workspace, editor, launcher_platform):
-        from .general import C15425929_Undo_Redo as test_module
-        self._run_test(request, workspace, editor, test_module)

AutomatedTesting/Gem/PythonTests/physics/terrain/C15308217_NoCrash_LevelSwitch.py

@@ -1,105 +0,0 @@
-"""
-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
-"""
-
-
-# Test case ID : C15308217
-# Test Case Title : Verify that the Terrain texture layer doesn't crash when changing
-# from on a level with a terrain component to another level without a terrain component
-
-
-
-# fmt: off
-class Tests():
-    enter_game_mode_1 = ("Entered game mode for level1", "Failed to enter game mode for level1")
-    enter_game_mode_2 = ("Entered game mode for level2", "Failed to enter game mode for level2")
-    find_terrain      = ("Terrain found",                "Terrain not found")
-    exit_game_mode_1  = ("Exited game mode for level1",  "Couldn't exit game mode for level1")
-    exit_game_mode_2  = ("Exited game mode for level2",  "Couldn't exit game mode for level2")
-# fmt: on
-
-
-def C15308217_NoCrash_LevelSwitch():
-
-    """
-    Summary:
-    Verify that the Terrain texture layer doesn't crash when changing from on a level with a
-    terrain component to another level without a terrain component
-
-    Level Description:
-        Level C15308217_NoCrash_LevelSwitchWithOutTerrain:
-            No entities
-        Level C15308217_NoCrash_LevelSwitchWithTerrain:
-            Terrain (entity) - PhysX Terrain entity is created in the level
-
-    Expected Behavior:
-    Editior should not crash.
-    We are switching the levels and validating the entities and checking any crash is happening while 
-    switching between levels
-
-    Test Steps:
-     1) Open level with PhysX Terrain component
-     2) Enter game mode
-     3) Retrieve and validate entities
-     4) Exit game mode
-     5) Open level which doesn't have a PhysX Terrain component
-     6) Enter game mode
-     7) Wait for WAIT_TIME to check if any crash happens
-     8) Exit game mode
-     9) Close the editor
-
-
-    Note:
-    - This test file must be called from the Open 3D Engine Editor command terminal
-    - Any passed and failed tests are written to the Editor.log file.
-            Parsing the file or running a log_monitor are required to observe the test results.
-
-    :return: None
-    """
-
-    import os
-    import sys
-    from editor_python_test_tools.utils import Report
-    from editor_python_test_tools.utils import TestHelper as helper
-
-    import azlmbr.legacy.general as general
-    import azlmbr.bus
-
-    # Constants
-    WAIT_TIME = 1.0
-
-    helper.init_idle()
-
-    # 1) Open level with PhysX Terrain component
-    helper.open_level("Physics", "C15308217_NoCrash_LevelSwitchWithTerrain")
-
-    # 2) Enter game mode
-    helper.enter_game_mode(Tests.enter_game_mode_1)
-
-    # 3) Retrieve and validate entities
-    terrain_id = general.find_game_entity("Terrain")
-    Report.critical_result(Tests.find_terrain, terrain_id.IsValid())
-
-    # 4) Exit game mode
-    helper.exit_game_mode(Tests.exit_game_mode_1)
-
-    # 5) Open level which doesn't have a PhysX Terrain component
-    helper.open_level("Physics", "C15308217_NoCrash_LevelSwitchWithOutTerrain")
-
-    # 6) Enter game mode
-    helper.enter_game_mode(Tests.enter_game_mode_2)
-
-    # 7) Wait for WAIT_TIME to check if any crash happens
-    general.idle_wait(WAIT_TIME)
-
-    # 8) Exit game mode
-    helper.exit_game_mode(Tests.exit_game_mode_2)
-
-
-
-if __name__ == "__main__":
-    from editor_python_test_tools.utils import Report
-    Report.start_test(C15308217_NoCrash_LevelSwitch)

AutomatedTesting/Gem/PythonTests/physics/tests/Physics_DynamicSliceWithPhysNotSpawnsStaticSlice.py

@@ -21,7 +21,7 @@ class Tests():
 # fmt: on
 
 
-def C6131473_StaticSlice_OnDynamicSliceSpawn():
+def Physics_DynamicSliceWithPhysNotSpawnsStaticSlice():
 
     """
     Summary:
@@ -71,7 +71,7 @@ def C6131473_StaticSlice_OnDynamicSliceSpawn():
     helper.init_idle()
 
     # 1) Open level
-    helper.open_level("Physics", "C6131473_StaticSlice_OnDynamicSliceSpawn")
+    helper.open_level("Physics", "Physics_DynamicSliceWithPhysNotSpawnsStaticSlice")
 
     # 2) Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -99,4 +99,4 @@ def C6131473_StaticSlice_OnDynamicSliceSpawn():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C6131473_StaticSlice_OnDynamicSliceSpawn)
+    Report.start_test(Physics_DynamicSliceWithPhysNotSpawnsStaticSlice)

AutomatedTesting/Gem/PythonTests/physics/tests/Physics_UndoRedoWorksOnEntityWithPhysComponents.py

@@ -20,7 +20,7 @@ class Tests:
 # fmt: off
 
 
-def C15425929_Undo_Redo():
+def Physics_UndoRedoWorksOnEntityWithPhysComponents():
     """
     Summary:
     Tests that no error messages arise when using the undo and redo functions in the editor.
@@ -53,7 +53,7 @@ def C15425929_Undo_Redo():
     helper.init_idle()
 
     # 1) Load the level
-    helper.open_level("Physics", "C15425929_Undo_Redo")
+    helper.open_level("Physics", "Physics_UndoRedoWorksOnEntityWithPhysComponents")
 
     with Tracer() as error_tracer:
         # Entity to delete and undo and re-delete
@@ -87,4 +87,4 @@ def C15425929_Undo_Redo():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C15425929_Undo_Redo)
+    Report.start_test(Physics_UndoRedoWorksOnEntityWithPhysComponents)

AutomatedTesting/Gem/PythonTests/physics/tests/Physics_VerifyColliderRigidBodyMeshAndTerrainWorkTogether.py

@@ -23,7 +23,7 @@ class Tests():
 # fmt: on
 
 
-def C5689529_Verify_Terrain_RigidBody_Collider_Mesh():
+def Physics_VerifyColliderRigidBodyMeshAndTerrainWorkTogether():
 
     """
     Summary:
@@ -71,7 +71,7 @@ def C5689529_Verify_Terrain_RigidBody_Collider_Mesh():
     helper.init_idle()
 
     # 1) Open level
-    helper.open_level("Physics", "C5689529_Verify_Terrain_RigidBody_Collider_Mesh")
+    helper.open_level("Physics", "Physics_VerifyColliderRigidBodyMeshAndTerrainWorkTogether")
 
     # 2) Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -102,4 +102,4 @@ def C5689529_Verify_Terrain_RigidBody_Collider_Mesh():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5689529_Verify_Terrain_RigidBody_Collider_Mesh)
+    Report.start_test(Physics_VerifyColliderRigidBodyMeshAndTerrainWorkTogether)

AutomatedTesting/Gem/PythonTests/physics/tests/Physics_WorldBodyBusWorksOnEditorComponents.py

@@ -48,7 +48,7 @@ class Tests():
 # fmt: on
 
 
-def C29032500_EditorComponents_WorldBodyBusWorks():
+def Physics_WorldBodyBusWorksOnEditorComponents():
     r"""
     Summary:
     Runs a test to make sure that a WorldBodyBus works property for components
@@ -92,7 +92,7 @@ def C29032500_EditorComponents_WorldBodyBusWorks():
     AABB_THRESHOLD = 0.01 # Entities won't move in the simulation 
                                                       
     helper.init_idle()
-    helper.open_level("Physics", "C29032500_EditorComponents_WorldBodyBusWorks")
+    helper.open_level("Physics", "Physics_WorldBodyBusWorksOnEditorComponents")
     
     def create_aabb(aabb_min_tuple, aabb_max_tuple):
         return azlmbr.math.Aabb_CreateFromMinMax(azlmbr.math.Vector3(aabb_min_tuple[0], aabb_min_tuple[1], aabb_min_tuple[2]),
@@ -150,4 +150,4 @@ def C29032500_EditorComponents_WorldBodyBusWorks():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C29032500_EditorComponents_WorldBodyBusWorks)
+    Report.start_test(Physics_WorldBodyBusWorksOnEditorComponents)

AutomatedTesting/Gem/PythonTests/physics/tests/character_controller/CharacterController_SwitchLevels.py

@@ -23,7 +23,7 @@ class Tests:
 # fmt: on
 
 
-def C14654881_CharacterController_SwitchLevels():
+def CharacterController_SwitchLevels():
     """
     Summary:
     Runs an automated test to verify that switching levels from a level containing a character controller component
@@ -64,7 +64,7 @@ def C14654881_CharacterController_SwitchLevels():
     helper.init_idle()
 
     # 1.1) Load level 1 (with character controller)
-    helper.open_level("Physics", "C14654881_CharacterController_SwitchLevels")
+    helper.open_level("Physics", "CharacterController_SwitchLevels")
 
     # 1.2) Enter game mode
     helper.enter_game_mode(Tests.level1_enter_game_mode)
@@ -77,7 +77,7 @@ def C14654881_CharacterController_SwitchLevels():
     helper.exit_game_mode(Tests.level1_exit_game_mode)
 
     # 2.1) Load level 2 (empty level)
-    helper.open_level("Physics", "C14654881_CharacterController_SwitchLevelsEmpty")
+    helper.open_level("Physics", "Base")
 
     # 2.2) Enter game mode
     helper.enter_game_mode(Tests.level2_enter_game_mode)
@@ -89,4 +89,4 @@ def C14654881_CharacterController_SwitchLevels():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C14654881_CharacterController_SwitchLevels)
+    Report.start_test(CharacterController_SwitchLevels)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_AddColliderComponent.py

@@ -20,7 +20,7 @@ class Tests():
 # fmt: on
 
 
-def C4976236_AddPhysxColliderComponent():
+def Collider_AddColliderComponent():
     """
     Summary:
     Opens an empty level and creates an Entity with PhysX Collider. Verify that editor remains stable in Game mode.
@@ -83,4 +83,4 @@ def C4976236_AddPhysxColliderComponent():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4976236_AddPhysxColliderComponent)
+    Report.start_test(Collider_AddColliderComponent)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_AddingNewGroupWorks.py

@@ -20,7 +20,7 @@ class Tests:
 # fmt: on
 
 
-def C4976227_Collider_NewGroup():
+def Collider_AddingNewGroupWorks():
     """
     Summary:
     Runs an automated test to ensure that a collision group can be added.
@@ -59,7 +59,7 @@ def C4976227_Collider_NewGroup():
 
     helper.init_idle()
     # 1) Open Level
-    helper.open_level("Physics", "C4976227_Collider_NewGroup")
+    helper.open_level("Physics", "Collider_AddingNewGroupWorks")
 
     # 2) Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -80,4 +80,4 @@ def C4976227_Collider_NewGroup():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4976227_Collider_NewGroup)
+    Report.start_test(Collider_AddingNewGroupWorks)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_BoxShapeEditting.py

@@ -19,7 +19,7 @@ class Tests():
 # fmt: on
 
 
-def C4982801_PhysXColliderShape_CanBeSelected():
+def Collider_BoxShapeEditting():
     """
     Summary:
      Adding PhysX Collider and Shape components to test entity, then attempting to modify the shape's dimensions
@@ -102,4 +102,4 @@ def C4982801_PhysXColliderShape_CanBeSelected():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4982801_PhysXColliderShape_CanBeSelected)
+    Report.start_test(Collider_BoxShapeEditting)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_CapsuleShapeEditting.py

@@ -19,7 +19,7 @@ class Tests():
 # fmt: on
 
 
-def C4982802_PhysXColliderShape_CanBeSelected():
+def Collider_CapsuleShapeEditting():
     """
     Summary:
      Adding PhysX Collider and Shape components to test entity, then attempting to modify the shape's dimensions
@@ -102,4 +102,4 @@ def C4982802_PhysXColliderShape_CanBeSelected():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4982802_PhysXColliderShape_CanBeSelected)
+    Report.start_test(Collider_CapsuleShapeEditting)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_CheckDefaultShapeSettingIsPxMesh.py

@@ -18,7 +18,7 @@ class Tests():
 # fmt: on
 
 
-def C14861500_DefaultSetting_ColliderShape():
+def Collider_CheckDefaultShapeSettingIsPxMesh():
     """
     Summary:
      Check the default for Shape on the PhysX Collider component
@@ -69,4 +69,4 @@ def C14861500_DefaultSetting_ColliderShape():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C14861500_DefaultSetting_ColliderShape)
+    Report.start_test(Collider_CheckDefaultShapeSettingIsPxMesh)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_ColliderPositionOffset.py

@@ -25,7 +25,7 @@ class Tests:
 # fmt: on
 
 
-def C4982797_Collider_ColliderOffset():
+def Collider_ColliderPositionOffset():
     # type: () -> None
     """
     Summary:
@@ -287,7 +287,7 @@ def C4982797_Collider_ColliderOffset():
     helper.init_idle()
 
     # 1) Open level
-    helper.open_level("Physics", "C4982797_Collider_ColliderOffset")
+    helper.open_level("Physics", "Collider_ColliderPositionOffset")
 
     # 2) Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -331,4 +331,4 @@ def C4982797_Collider_ColliderOffset():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4982797_Collider_ColliderOffset)
+    Report.start_test(Collider_ColliderPositionOffset)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_ColliderRotationOffset.py

@@ -29,7 +29,7 @@ class Tests:
 # fmt: on
 
 
-def C4982798_Collider_ColliderRotationOffset():
+def Collider_ColliderRotationOffset():
     # type: () -> None
     """
     Summary:
@@ -255,7 +255,7 @@ def C4982798_Collider_ColliderRotationOffset():
     helper.init_idle()
 
     # 1) Open level
-    helper.open_level("Physics", "C4982798_Collider_ColliderRotationOffset")
+    helper.open_level("Physics", "Collider_ColliderRotationOffset")
 
     # 2) Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -299,4 +299,4 @@ def C4982798_Collider_ColliderRotationOffset():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4982798_Collider_ColliderRotationOffset)
+    Report.start_test(Collider_ColliderRotationOffset)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_CollisionGroupsWorkflow.py

@@ -38,7 +38,7 @@ class Tests:
 # fmt: on
 
 
-def C3510644_Collider_CollisionGroups():
+def Collider_CollisionGroupsWorkflow():
     # type: () -> None
     """
     Summary:
@@ -261,7 +261,7 @@ def C3510644_Collider_CollisionGroups():
 
     # 1) Open level
     helper.init_idle()
-    helper.open_level("Physics", "C3510644_Collider_CollisionGroups")
+    helper.open_level("Physics", "Collider_CollisionGroupsWorkflow")
 
     # 2) Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -358,4 +358,4 @@ def C3510644_Collider_CollisionGroups():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C3510644_Collider_CollisionGroups)
+    Report.start_test(Collider_CollisionGroupsWorkflow)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_DiffCollisionGroupDiffCollidingLayersNotCollide.py

@@ -30,7 +30,7 @@ class Tests:
 # fmt: on
 
 
-def C4982593_PhysXCollider_CollisionLayerTest():
+def Collider_DiffCollisionGroupDiffCollidingLayersNotCollide():
     # type: () -> None
     """
     Summary:
@@ -96,7 +96,7 @@ def C4982593_PhysXCollider_CollisionLayerTest():
 
     # 1) Open level / Enter game mode
     helper.init_idle()
-    helper.open_level("Physics", "C4982593_PhysxCollider_CollisionLayerTest")
+    helper.open_level("Physics", "Collider_DiffCollisionGroupDiffCollidingLayersNotCollide")
     helper.enter_game_mode(Tests.enter_game_mode)
 
     # 2) Retrieve/validate entities
@@ -227,4 +227,4 @@ def C4982593_PhysXCollider_CollisionLayerTest():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4982593_PhysXCollider_CollisionLayerTest)
+    Report.start_test(Collider_DiffCollisionGroupDiffCollidingLayersNotCollide)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_MultipleSurfaceSlots.py

@@ -23,7 +23,7 @@ class Tests():
 # fmt: on
 
 
-def C4044695_PhysXCollider_AddMultipleSurfaceFbx():
+def Collider_MultipleSurfaceSlots():
     """
     Summary:
      Create entity with Mesh and PhysX Collider components and assign a fbx file in both the components.
@@ -59,8 +59,8 @@ def C4044695_PhysXCollider_AddMultipleSurfaceFbx():
     SURFACE_TAG_COUNT = 4  # Number of surface tags included in used asset
 
     # Asset paths
-    STATIC_MESH = os.path.join("assets", "c4044695_physxcollider_addmultiplesurfacefbx", "test.azmodel")
-    PHYSX_MESH = os.path.join("assets", "c4044695_physxcollider_addmultiplesurfacefbx", "test.pxmesh")
+    STATIC_MESH = os.path.join("assets", "Physics", "Collider_MultipleSurfaceSlots", "test.azmodel")
+    PHYSX_MESH = os.path.join("assets", "Physics","Collider_MultipleSurfaceSlots", "test.pxmesh")
 
     helper.init_idle()
     # 1) Load the empty level
@@ -86,12 +86,12 @@ def C4044695_PhysXCollider_AddMultipleSurfaceFbx():
     px_asset = Asset.find_asset_by_path(PHYSX_MESH)
     collider_component.set_component_property_value("Shape Configuration|Asset|PhysX Mesh", px_asset.id)
     px_asset.id = collider_component.get_component_property_value("Shape Configuration|Asset|PhysX Mesh")
-    Report.result(Tests.assign_px_mesh_asset, px_asset.get_path() == PHYSX_MESH.replace(os.sep, "/"))
+    Report.result(Tests.assign_px_mesh_asset, px_asset.get_path().lower() == PHYSX_MESH.replace(os.sep, "/").lower())
 
     mesh_asset = Asset.find_asset_by_path(STATIC_MESH)
     mesh_component.set_component_property_value("Controller|Configuration|Mesh Asset", mesh_asset.id)
     mesh_asset.id = mesh_component.get_component_property_value("Controller|Configuration|Mesh Asset")
-    Report.result(Tests.assign_mesh_asset, mesh_asset.get_path() == STATIC_MESH.replace(os.sep, "/"))
+    Report.result(Tests.assign_mesh_asset, mesh_asset.get_path().lower() == STATIC_MESH.replace(os.sep, "/").lower())
 
     # 6) Check if multiple material slots show up under Materials section in the PhysX Collider component
     pte = collider_component.get_property_tree()
@@ -106,4 +106,4 @@ def C4044695_PhysXCollider_AddMultipleSurfaceFbx():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4044695_PhysXCollider_AddMultipleSurfaceFbx)
+    Report.start_test(Collider_MultipleSurfaceSlots)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_NoneCollisionGroupSameLayerNotCollide.py

@@ -30,7 +30,7 @@ class Tests:
 # fmt: on
 
 
-def C4976245_PhysXCollider_CollisionLayerTest():
+def Collider_NoneCollisionGroupSameLayerNotCollide():
     # type: () -> None
     """
     Summary:
@@ -105,7 +105,7 @@ def C4976245_PhysXCollider_CollisionLayerTest():
 
     # 1) Open level / Enter game mode
     helper.init_idle()
-    helper.open_level("Physics", "C4976245_PhysxCollider_CollisionLayerTest")
+    helper.open_level("Physics", "Collider_NoneCollisionGroupSameLayerNotCollide")
     helper.enter_game_mode(Tests.enter_game_mode)
 
     # 2) Retrieve/validate entities
@@ -219,4 +219,4 @@ def C4976245_PhysXCollider_CollisionLayerTest():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4976245_PhysXCollider_CollisionLayerTest)
+    Report.start_test(Collider_NoneCollisionGroupSameLayerNotCollide)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_PxMeshAutoAssignedWhenAddingRenderMeshComponent.py

@@ -20,7 +20,7 @@ class Tests():
 # fmt: on
 
 
-def C14861501_PhysXCollider_RenderMeshAutoAssigned():
+def Collider_PxMeshAutoAssignedWhenAddingRenderMeshComponent():
     """
     Summary:
      Create entity with Mesh component and assign a render mesh to the Mesh component. Add Physics Collider component
@@ -55,9 +55,9 @@ def C14861501_PhysXCollider_RenderMeshAutoAssigned():
     from editor_python_test_tools.asset_utils import Asset
 
     # Asset paths
-    STATIC_MESH = os.path.join("assets", "c14861501_physxcollider_rendermeshautoassigned", "spherebot", "r0-b_body.azmodel")
+    STATIC_MESH = os.path.join("assets", "Physics", "Collider_PxMeshAutoAssigned", "spherebot", "r0-b_body.azmodel")
     PHYSX_MESH = os.path.join(
-        "assets", "c14861501_physxcollider_rendermeshautoassigned", "spherebot", "r0-b_body.pxmesh"
+        "assets", "Physics", "Collider_PxMeshAutoAssigned", "spherebot", "r0-b_body.pxmesh"
     )
 
     helper.init_idle()
@@ -76,7 +76,7 @@ def C14861501_PhysXCollider_RenderMeshAutoAssigned():
     mesh_asset = Asset.find_asset_by_path(STATIC_MESH)
     mesh_component.set_component_property_value("Controller|Configuration|Mesh Asset", mesh_asset.id)
     mesh_asset.id = mesh_component.get_component_property_value("Controller|Configuration|Mesh Asset")
-    Report.result(Tests.assign_mesh_asset, mesh_asset.get_path() == STATIC_MESH.replace(os.sep, "/"))
+    Report.result(Tests.assign_mesh_asset, mesh_asset.get_path().lower() == STATIC_MESH.replace(os.sep, "/").lower())
 
     # 5) Add PhysX Collider component
     test_component = test_entity.add_component("PhysX Collider")
@@ -85,9 +85,9 @@ def C14861501_PhysXCollider_RenderMeshAutoAssigned():
     # 6) The physics asset in PhysX Collider component is auto-assigned.
     asset_id = test_component.get_component_property_value("Shape Configuration|Asset|PhysX Mesh")
     test_asset = Asset(asset_id)
-    Report.result(Tests.automatic_shape_change, test_asset.get_path() == PHYSX_MESH.replace(os.sep, "/"))
+    Report.result(Tests.automatic_shape_change, test_asset.get_path().lower() == PHYSX_MESH.replace(os.sep, "/").lower())
 
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C14861501_PhysXCollider_RenderMeshAutoAssigned)
+    Report.start_test(Collider_PxMeshAutoAssignedWhenAddingRenderMeshComponent)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_PxMeshAutoAssignedWhenModifyingRenderMeshComponent.py

@@ -20,7 +20,7 @@ class Tests():
 # fmt: on
 
 
-def C14861502_PhysXCollider_AssetAutoAssigned():
+def Collider_PxMeshAutoAssignedWhenModifyingRenderMeshComponent():
     """
     Summary:
      Create entity with Mesh and PhysX Collider components, then assign a render mesh to the Mesh component
@@ -92,4 +92,4 @@ def C14861502_PhysXCollider_AssetAutoAssigned():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C14861502_PhysXCollider_AssetAutoAssigned)
+    Report.start_test(Collider_PxMeshAutoAssignedWhenModifyingRenderMeshComponent)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_PxMeshConvexMeshCollides.py

@@ -27,7 +27,7 @@ class Tests():
 # fmt: on
 
 
-def C4982803_Enable_PxMesh_Option():
+def Collider_PxMeshConvexMeshCollides():
     """
     Summary:
     Load level with Entity above ground having PhysX Collider, PhysX Rigid Body and Mesh components.
@@ -70,7 +70,7 @@ def C4982803_Enable_PxMesh_Option():
 
     # Constants
     PHYSICS_ASSET_INDEX = 7  # Hardcoded enum index value for Shape property
-    MESH_ASSET_PATH = os.path.join("assets", "c4982803_enable_pxmesh_option", "spherebot", "r0-b_body.pxmesh")
+    MESH_ASSET_PATH = os.path.join("assets", "Physics", "Collider_PxMeshConvexMeshCollides", "spherebot", "r0-b_body.pxmesh")
     TIMEOUT = 2.0
 
     helper.init_idle()
@@ -99,7 +99,7 @@ def C4982803_Enable_PxMesh_Option():
     mesh_asset = Asset.find_asset_by_path(MESH_ASSET_PATH)
     collider_component.set_component_property_value("Shape Configuration|Asset|PhysX Mesh", mesh_asset.id)
     mesh_asset.id = collider_component.get_component_property_value("Shape Configuration|Asset|PhysX Mesh")
-    Report.result(Tests.assign_fbx_mesh, mesh_asset.get_path() == MESH_ASSET_PATH.replace(os.sep, "/"))
+    Report.result(Tests.assign_fbx_mesh, mesh_asset.get_path().lower() == MESH_ASSET_PATH.replace(os.sep, "/").lower())
 
     # 5) Create terrain entity with physx terrain
     terrain = EditorEntity.create_editor_entity_at([512.0, 512.0, 31.0], "Terrain")
@@ -140,4 +140,4 @@ def C4982803_Enable_PxMesh_Option():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4982803_Enable_PxMesh_Option)
+    Report.start_test(Collider_PxMeshConvexMeshCollides)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_PxMeshErrorIfNoMesh.py

@@ -21,7 +21,7 @@ class Tests():
 # fmt:on
 
 
-def C14861498_ConfirmError_NoPxMesh():
+def Collider_PxMeshErrorIfNoMesh():
     """
     Summary:
     This test looks for the presence of an error when an entity with a PhysXCollider has no physics mesh, but has its
@@ -63,7 +63,7 @@ def C14861498_ConfirmError_NoPxMesh():
                 'EditorColliderComponent' in warningInfo.message for warningInfo in warning_tracer.warnings)
 
         # 1) Load level / enter game mode
-        helper.open_level("Physics", "C14861498_ConfirmError_NoPxMesh")
+        helper.open_level("Physics", "Collider_PxMeshErrorIfNoMesh")
         helper.enter_game_mode(Tests.enter_game_mode)
 
         # 2) Find game entity
@@ -81,4 +81,4 @@ def C14861498_ConfirmError_NoPxMesh():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C14861498_ConfirmError_NoPxMesh)
+    Report.start_test(Collider_PxMeshErrorIfNoMesh)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_PxMeshNotAutoAssignedWhenNoPhysicsFbx.py

@@ -22,7 +22,7 @@ class Tests():
 # fmt: on
 
 
-def C14861504_RenderMeshAsset_WithNoPxAsset():
+def Collider_PxMeshNotAutoAssignedWhenNoPhysicsFbx():
     """
     Summary:
      Create entity with Mesh component and assign a render mesh that has no physics asset to the Mesh component.
@@ -63,7 +63,7 @@ def C14861504_RenderMeshAsset_WithNoPxAsset():
     import azlmbr.asset as azasset
 
     # Asset paths
-    STATIC_MESH = os.path.join("assets", "c14861504_rendermeshasset_withnopxasset", "test_asset.azmodel")
+    STATIC_MESH = os.path.join("assets", "Physics", "Collider_PxMeshNotAutoAssignedWhenNoPhysicsFbx", "test_asset.azmodel")
 
     helper.init_idle()
     # 1) Load the empty level
@@ -81,7 +81,7 @@ def C14861504_RenderMeshAsset_WithNoPxAsset():
     mesh_asset = Asset.find_asset_by_path(STATIC_MESH)
     mesh_component.set_component_property_value("Controller|Configuration|Mesh Asset", mesh_asset.id)
     mesh_asset.id = mesh_component.get_component_property_value("Controller|Configuration|Mesh Asset")
-    Report.result(Tests.assign_mesh_asset, mesh_asset.get_path() == STATIC_MESH.replace(os.sep, "/"))
+    Report.result(Tests.assign_mesh_asset, mesh_asset.get_path().lower() == STATIC_MESH.replace(os.sep, "/").lower())
 
     # 5) Add PhysX Collider component
     test_component = test_entity.add_component("PhysX Collider")
@@ -101,4 +101,4 @@ def C14861504_RenderMeshAsset_WithNoPxAsset():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C14861504_RenderMeshAsset_WithNoPxAsset)
+    Report.start_test(Collider_PxMeshNotAutoAssignedWhenNoPhysicsFbx)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_SameCollisionGroupDiffLayersCollide.py

@@ -25,7 +25,7 @@ class Tests():
 # fmt: on
 
 
-def C4976243_Collision_SameCollisionGroupDiffCollisionLayers():
+def Collider_SameCollisionGroupDiffLayersCollide():
 
     """
     Summary:
@@ -78,7 +78,7 @@ def C4976243_Collision_SameCollisionGroupDiffCollisionLayers():
     helper.init_idle()
 
     # 1) Open level
-    helper.open_level("Physics", "C4976243_Collision_SameCollisionGroupDiffCollisionLayers")
+    helper.open_level("Physics", "Collider_SameCollisionGroupDiffLayersCollide")
 
     # 2) Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -123,4 +123,4 @@ def C4976243_Collision_SameCollisionGroupDiffCollisionLayers():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4976243_Collision_SameCollisionGroupDiffCollisionLayers)
+    Report.start_test(Collider_SameCollisionGroupDiffLayersCollide)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_SameCollisionGroupSameCustomLayerCollide.py

@@ -26,7 +26,7 @@ class Tests:
 # fmt: on
 
 
-def C4976244_Collider_SameGroupSameLayerCollision():
+def Collider_SameCollisionGroupSameCustomLayerCollide():
     # type: () -> None
     """
     Summary:
@@ -127,7 +127,7 @@ def C4976244_Collider_SameGroupSameLayerCollision():
     # Main Script
     # 1) Load the level
     helper.init_idle()
-    helper.open_level("physics", "C4976244_Collider_SameGroupSameLayerCollision")
+    helper.open_level("physics", "Collider_SameCollisionGroupSameCustomLayerCollide")
 
     # 2) Enter Game Mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -181,4 +181,4 @@ def C4976244_Collider_SameGroupSameLayerCollision():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4976244_Collider_SameGroupSameLayerCollision)
+    Report.start_test(Collider_SameCollisionGroupSameCustomLayerCollide)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_SameCollisionGroupSameLayerCollide.py

@@ -26,7 +26,7 @@ class Tests():
 # fmt: on
 
 
-def C4976242_Collision_SameCollisionlayerSameCollisiongroup():
+def Collider_SameCollisionGroupSameLayerCollide():
 
     """
     Summary:
@@ -77,7 +77,7 @@ def C4976242_Collision_SameCollisionlayerSameCollisiongroup():
     helper.init_idle()
 
     # 1) Open level and Enter game mode
-    helper.open_level("Physics", "C4976242_Collision_SameCollisionlayerSameCollisiongroup")
+    helper.open_level("Physics", "Collider_SameCollisionGroupSameLayerCollide")
     helper.enter_game_mode(Tests.enter_game_mode)
 
     # 2) Retrieve and validate Entities
@@ -184,4 +184,4 @@ def C4976242_Collision_SameCollisionlayerSameCollisiongroup():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4976242_Collision_SameCollisionlayerSameCollisiongroup)
+    Report.start_test(Collider_SameCollisionGroupSameLayerCollide)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_SphereShapeEditting.py

@@ -19,7 +19,7 @@ class Tests():
 # fmt: on
 
 
-def C4982800_PhysXColliderShape_CanBeSelected():
+def Collider_SphereShapeEditting():
     """
     Summary:
      Adding PhysX Collider and Shape components to test entity, then attempting to modify the shape's dimensions
@@ -90,4 +90,4 @@ def C4982800_PhysXColliderShape_CanBeSelected():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4982800_PhysXColliderShape_CanBeSelected)
+    Report.start_test(Collider_SphereShapeEditting)

AutomatedTesting/Gem/PythonTests/physics/tests/collider/Collider_TriggerPassThrough.py

@@ -30,7 +30,7 @@ class Tests:
 # fmt: on
 
 
-def C4982595_Collider_TriggerDisablesCollision():
+def Collider_TriggerPassThrough():
     """
     Summary:
     This script runs an automated test to verify that when an entity's PhysX collider is set as a trigger, the entity no
@@ -184,7 +184,7 @@ def C4982595_Collider_TriggerDisablesCollision():
 
     # 1) Open level and enter game mode
     helper.init_idle()
-    helper.open_level("Physics", "C4982595_Collider_TriggerDisablesCollision")
+    helper.open_level("Physics", "Collider_TriggerPassThrough")
     helper.enter_game_mode(Tests.enter_game_mode)
 
     # 2) Retrieve and validate entities
@@ -230,4 +230,4 @@ def C4982595_Collider_TriggerDisablesCollision():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C4982595_Collider_TriggerDisablesCollision)
+    Report.start_test(Collider_TriggerPassThrough)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_CapsuleShapedForce.py

@@ -30,7 +30,7 @@ class Tests:
 # fmt: on
 
 
-def C5959760_PhysXForceRegion_PointForceExertion():
+def ForceRegion_CapsuleShapedForce():
     # type: () -> None
     """
     Summary:
@@ -121,7 +121,7 @@ def C5959760_PhysXForceRegion_PointForceExertion():
 
     # 1) Open level / Enter game mode
     helper.init_idle()
-    helper.open_level("Physics", "C5959760_PhysXForceRegion_PointForceExertion")
+    helper.open_level("Physics", "ForceRegion_CapsuleShapedForce")
     helper.enter_game_mode(Tests.enter_game_mode)
 
     # 2) Retrieve entities
@@ -219,4 +219,4 @@ def C5959760_PhysXForceRegion_PointForceExertion():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5959760_PhysXForceRegion_PointForceExertion)
+    Report.start_test(ForceRegion_CapsuleShapedForce)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_DirectionHasNoAffectOnTotalForce.py

@@ -50,7 +50,7 @@ class Tests:
 # fmt: on
 
 
-def C12868578_ForceRegion_DirectionHasNoAffectOnMagnitude():
+def ForceRegion_DirectionHasNoAffectOnTotalForce():
     """
     Summary: Check that world and local space force direction should not affect magnitude of force exerted on entity.
 
@@ -219,7 +219,7 @@ def C12868578_ForceRegion_DirectionHasNoAffectOnMagnitude():
     # Main Script
     helper.init_idle()
     # 1) Open Level
-    helper.open_level("Physics", "C12868578_ForceRegion_DirectionHasNoAffectOnMagnitude")
+    helper.open_level("Physics", "ForceRegion_DirectionHasNoAffectOnTotalForce")
 
     # 2) Enter Game Mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -279,4 +279,4 @@ def C12868578_ForceRegion_DirectionHasNoAffectOnMagnitude():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C12868578_ForceRegion_DirectionHasNoAffectOnMagnitude)
+    Report.start_test(ForceRegion_DirectionHasNoAffectOnTotalForce)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_HighValuesDirectionAxesWorkWithNoError.py

@@ -37,7 +37,7 @@ class Tests():
 # fmt: on
 
 
-def C6321601_Force_HighValuesDirectionAxes():
+def ForceRegion_HighValuesDirectionAxesWorkWithNoError():
 
     """
     Summary:
@@ -204,7 +204,7 @@ def C6321601_Force_HighValuesDirectionAxes():
             return entity_error_tracer.has_errors
 
         # 1) Open level
-        helper.open_level("Physics", "C6321601_Force_HighValuesDirectionAxes")
+        helper.open_level("Physics", "ForceRegion_HighValuesDirectionAxesWorkWithNoError")
 
         # 2) Enter game mode
         helper.enter_game_mode(Tests.enter_game_mode)
@@ -243,4 +243,4 @@ def C6321601_Force_HighValuesDirectionAxes():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C6321601_Force_HighValuesDirectionAxes)
+    Report.start_test(ForceRegion_HighValuesDirectionAxesWorkWithNoError)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_ImpulsesBoxShapedRigidBody.py

@@ -24,7 +24,7 @@ class Tests:
 # fmt: on
 
 
-def C5959763_ForceRegion_ForceRegionImpulsesCube():
+def ForceRegion_ImpulsesBoxShapedRigidBody():
     """
     This run() function will open a a level and validate that a Cube gets impulsed by a force region.
     It does this by:
@@ -42,8 +42,6 @@ def C5959763_ForceRegion_ForceRegionImpulsesCube():
     # Setup path
     import os, sys
 
-
-
     from editor_python_test_tools.utils import Report
     from editor_python_test_tools.utils import TestHelper as helper
     import azlmbr.legacy.general as general
@@ -80,7 +78,7 @@ def C5959763_ForceRegion_ForceRegionImpulsesCube():
     UPWARD_Z_VECTOR = 1.0
 
     # Open level
-    helper.open_level("Physics", "C5959763_ForceRegion_ForceRegionImpulsesCube")
+    helper.open_level("Physics", "ForceRegion_ImpulsesBoxShapedRigidBody")
 
     # Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -164,4 +162,4 @@ def C5959763_ForceRegion_ForceRegionImpulsesCube():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5959763_ForceRegion_ForceRegionImpulsesCube)
+    Report.start_test(ForceRegion_ImpulsesBoxShapedRigidBody)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_ImpulsesCapsuleShapedRigidBody.py

@@ -24,7 +24,7 @@ class Tests:
 # fmt: on
 
 
-def C5959764_ForceRegion_ForceRegionImpulsesCapsule():
+def ForceRegion_ImpulsesCapsuleShapedRigidBody():
     """
     This run() function will open a a level and validate that a Capsule gets impulsed by a force region.
     It does this by:
@@ -80,7 +80,7 @@ def C5959764_ForceRegion_ForceRegionImpulsesCapsule():
     UPWARD_Z_VECTOR = 1.0
 
     # Open level
-    helper.open_level("Physics", "C5959764_ForceRegion_ForceRegionImpulsesCapsule")
+    helper.open_level("Physics", "ForceRegion_ImpulsesCapsuleShapedRigidBody")
 
     # Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -166,4 +166,4 @@ def C5959764_ForceRegion_ForceRegionImpulsesCapsule():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5959764_ForceRegion_ForceRegionImpulsesCapsule)
+    Report.start_test(ForceRegion_ImpulsesCapsuleShapedRigidBody)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_ImpulsesPxMeshShapedRigidBody.py

@@ -23,7 +23,7 @@ class Tests:
     tests_completed      = ("Tests completed",             "Tests did not complete")
 # fmt: on
 
-def C5959765_ForceRegion_AssetGetsImpulsed():
+def ForceRegion_ImpulsesPxMeshShapedRigidBody():
     """
     # This run() function will open a a level and validate that a asset gets impulsed by a force region.
     # It does this by:
@@ -83,7 +83,7 @@ def C5959765_ForceRegion_AssetGetsImpulsed():
     UPWARD_Z_VECTOR = 1.0
 
     # 1) Open level
-    helper.open_level("Physics", "C5959765_ForceRegion_AssetGetsImpulsed")
+    helper.open_level("Physics", "ForceRegion_ImpulsesPxMeshShapedRigidBody")
 
     #  2) Enters Game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -168,4 +168,4 @@ def C5959765_ForceRegion_AssetGetsImpulsed():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5959765_ForceRegion_AssetGetsImpulsed)
+    Report.start_test(ForceRegion_ImpulsesPxMeshShapedRigidBody)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_LinearDampingForceOnRigidBodies.py

@@ -34,7 +34,7 @@ class Tests:
 # fmt: on
 
 
-def C5932042_PhysXForceRegion_LinearDamping():
+def ForceRegion_LinearDampingForceOnRigidBodies():
     # type: () -> None
     """
     Summary:
@@ -131,7 +131,7 @@ def C5932042_PhysXForceRegion_LinearDamping():
 
     # 1) Open level / Enter game mode
     helper.init_idle()
-    helper.open_level("Physics", "C5932042_PhysXForceRegion_LinearDamping")
+    helper.open_level("Physics", "ForceRegion_LinearDampingForceOnRigidBodies")
     helper.enter_game_mode(Tests.enter_game_mode)
 
     # 2) Retrieve and validate entities
@@ -265,4 +265,4 @@ def C5932042_PhysXForceRegion_LinearDamping():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5932042_PhysXForceRegion_LinearDamping)
+    Report.start_test(ForceRegion_LinearDampingForceOnRigidBodies)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_LocalSpaceForceOnRigidBodies.py

@@ -30,7 +30,7 @@ class Tests:
 # fmt: on
 
 
-def C5932041_PhysXForceRegion_LocalSpaceForceOnRigidBodies():
+def ForceRegion_LocalSpaceForceOnRigidBodies():
     """
     Summary:
     Runs an automated test to ensure that when a rigid body enters a force region a local space force is exerted.
@@ -80,7 +80,7 @@ def C5932041_PhysXForceRegion_LocalSpaceForceOnRigidBodies():
     helper.init_idle()
 
     # 1) Open level
-    helper.open_level("Physics", "C5932041_PhysXForceRegion_LocalSpaceForceOnRigidBodies")
+    helper.open_level("Physics", "ForceRegion_LocalSpaceForceOnRigidBodies")
 
     # 2) Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -157,4 +157,4 @@ def C5932041_PhysXForceRegion_LocalSpaceForceOnRigidBodies():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5932041_PhysXForceRegion_LocalSpaceForceOnRigidBodies)
+    Report.start_test(ForceRegion_LocalSpaceForceOnRigidBodies)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_MovingForceRegionChangesNetForce.py

@@ -22,7 +22,7 @@ class Tests():
 # fmt: on
 
 
-def C5968760_ForceRegion_CheckNetForceChange():
+def ForceRegion_MovingForceRegionChangesNetForce():
 
     """
     Summary:
@@ -96,7 +96,7 @@ def C5968760_ForceRegion_CheckNetForceChange():
     helper.init_idle()
 
     # 1) Open level
-    helper.open_level("Physics", "C5968760_ForceRegion_CheckNetForceChange")
+    helper.open_level("Physics", "ForceRegion_MovingForceRegionChangesNetForce")
 
     # 2) Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -159,4 +159,4 @@ def C5968760_ForceRegion_CheckNetForceChange():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5968760_ForceRegion_CheckNetForceChange)
+    Report.start_test(ForceRegion_MovingForceRegionChangesNetForce)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_MultipleComponentsCombineForces.py

@@ -32,7 +32,7 @@ class Tests:
 import os, sys
 
 
-def C5968759_ForceRegion_ExertsSeveralForcesOnRigidBody():
+def ForceRegion_MultipleComponentsCombineForces():
     """
     Run() will open a a level and validate that the spheres are affected by the force regions as expected.
 
@@ -92,7 +92,7 @@ def C5968759_ForceRegion_ExertsSeveralForcesOnRigidBody():
 
     #   1) Opens level with spheres above a force region
     helper.init_idle()
-    helper.open_level("Physics", "C5968759_ForceRegion_ExertsSeveralForcesOnRigidBody")
+    helper.open_level("Physics", "ForceRegion_MultipleComponentsCombineForces")
     helper.enter_game_mode(Tests.enter_game_mode)
 
     #   2) Finds the entities in the scene
@@ -174,4 +174,4 @@ def C5968759_ForceRegion_ExertsSeveralForcesOnRigidBody():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5968759_ForceRegion_ExertsSeveralForcesOnRigidBody)
+    Report.start_test(ForceRegion_MultipleComponentsCombineForces)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_MultipleForcesInSameComponentCombineForces.py

@@ -31,7 +31,7 @@ class Tests:
 # fmt: on
 
 
-def C5959810_ForceRegion_ForceRegionCombinesForces():
+def ForceRegion_MultipleForcesInSameComponentCombineForces():
     # type: () -> None
     """
     Summary: Runs an automated test to ensure that separate forces in a force region add correctly
@@ -162,7 +162,7 @@ def C5959810_ForceRegion_ForceRegionCombinesForces():
     helper.init_idle()
 
     # 1) Load Level
-    helper.open_level("physics", "C5959810_ForceRegion_ForceRegionCombinesForces")
+    helper.open_level("physics", "ForceRegion_MultipleForcesInSameComponentCombineForces")
 
     # 2) Enter Game Mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -230,4 +230,4 @@ def C5959810_ForceRegion_ForceRegionCombinesForces():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5959810_ForceRegion_ForceRegionCombinesForces)
+    Report.start_test(ForceRegion_MultipleForcesInSameComponentCombineForces)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_NoQuiverOnHighLinearDampingForce.py

@@ -24,7 +24,7 @@ class Tests:
 # fmt: on
 
 
-def C15845879_ForceRegion_HighLinearDampingForce():
+def ForceRegion_NoQuiverOnHighLinearDampingForce():
     """
     Summary: Check that linear damping with high values do not make the object to quiver
 
@@ -126,7 +126,7 @@ def C15845879_ForceRegion_HighLinearDampingForce():
     # Main Script
     helper.init_idle()
     # 1) Open Level
-    helper.open_level("Physics", "C15845879_ForceRegion_HighLinearDampingForce")
+    helper.open_level("Physics", "ForceRegion_NoQuiverOnHighLinearDampingForce")
 
     # 2) Enter Game Mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -165,4 +165,4 @@ def C15845879_ForceRegion_HighLinearDampingForce():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C15845879_ForceRegion_HighLinearDampingForce)
+    Report.start_test(ForceRegion_NoQuiverOnHighLinearDampingForce)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_ParentChildForcesCombineForces.py

@@ -29,7 +29,7 @@ class Tests():
 # fmt: on
 
 
-def C6090547_ForceRegion_ParentChildForceRegions():
+def ForceRegion_ParentChildForcesCombineForces():
     """
     Summary:
     Runs an automated test to ensure that force regions in parent and child entities work together.
@@ -89,7 +89,7 @@ def C6090547_ForceRegion_ParentChildForceRegions():
     helper.init_idle()
 
     # 1) Open level
-    helper.open_level("Physics", "C6090547_ForceRegion_ParentChildForceRegions")
+    helper.open_level("Physics", "ForceRegion_ParentChildForcesCombineForces")
 
     # 2) Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -195,4 +195,4 @@ def C6090547_ForceRegion_ParentChildForceRegions():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C6090547_ForceRegion_ParentChildForceRegions)
+    Report.start_test(ForceRegion_ParentChildForcesCombineForces)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_PointForceOnRigidBodies.py

@@ -27,7 +27,7 @@ class Tests():
 # fmt: on
 
 
-def C5932044_ForceRegion_PointForceOnRigidBody():
+def ForceRegion_PointForceOnRigidBodies():
     """
     Summary:
     Runs an automated test to ensure that that a force region exerts point force on rigid bodies
@@ -83,7 +83,7 @@ def C5932044_ForceRegion_PointForceOnRigidBody():
 
     helper.init_idle()
     # 1) Open level
-    helper.open_level("Physics", "C5932044_PhysX_ForceRegion_PointForceOnRigidBodies")
+    helper.open_level("Physics", "ForceRegion_PointForceOnRigidBodies")
 
     # 2) Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -185,4 +185,4 @@ def C5932044_ForceRegion_PointForceOnRigidBody():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5932044_ForceRegion_PointForceOnRigidBody)
+    Report.start_test(ForceRegion_PointForceOnRigidBodies)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_PositionOffset.py

@@ -88,7 +88,7 @@ class Tests:
         else:
             return None
 
-def C5959808_ForceRegion_PositionOffset():
+def ForceRegion_PositionOffset():
     """
     Summary:
     Force Region positional offset is tested for each of the 3 axises (X, Y, and Z). Each axis's test has one
@@ -363,7 +363,7 @@ def C5959808_ForceRegion_PositionOffset():
 
     # 1) Open level
     helper.init_idle()
-    helper.open_level("Physics", "C5959808_ForceRegion_PositionOffset")
+    helper.open_level("Physics", "ForceRegion_PositionOffset")
     helper.enter_game_mode(Tests.enter_game_mode)
 
     # 2) Variable set up
@@ -401,4 +401,4 @@ def C5959808_ForceRegion_PositionOffset():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5959808_ForceRegion_PositionOffset)
+    Report.start_test(ForceRegion_PositionOffset)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_PxMeshShapedForce.py

@@ -25,7 +25,7 @@ class Tests():
 # fmt: on
 
 
-def C5959761_ForceRegion_PhysAssetExertsPointForce():
+def ForceRegion_PxMeshShapedForce():
     """
     Summary:
     Runs an automated test to ensure that PhysX force regions with physics assets exert point force on rigid bodies
@@ -85,7 +85,7 @@ def C5959761_ForceRegion_PhysAssetExertsPointForce():
 
     helper.init_idle()
     # 1) Open level
-    helper.open_level("Physics", "C5959761_ForceRegion_ExertsPointForce_Sedan")
+    helper.open_level("Physics", "ForceRegion_PxMeshShapedForce")
 
     # 2) Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -135,4 +135,4 @@ def C5959761_ForceRegion_PhysAssetExertsPointForce():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5959761_ForceRegion_PhysAssetExertsPointForce)
+    Report.start_test(ForceRegion_PxMeshShapedForce)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_RotationalOffset.py

@@ -89,7 +89,7 @@ class Tests:
             return None
 
 
-def C5959809_ForceRegion_RotationalOffset():
+def ForceRegion_RotationalOffset():
     """
     Summary:
     Force Region rotational offset is tested for each of the 3 axises (X, Y, and Z). Each axis's test has one
@@ -367,7 +367,7 @@ def C5959809_ForceRegion_RotationalOffset():
 
     # 1) Open level
     helper.init_idle()
-    helper.open_level("Physics", "C5959809_ForceRegion_RotationalOffset")
+    helper.open_level("Physics", "ForceRegion_RotationalOffset")
     helper.enter_game_mode(Tests.enter_game_mode)
 
     # 2) Variable set up
@@ -401,4 +401,4 @@ def C5959809_ForceRegion_RotationalOffset():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5959809_ForceRegion_RotationalOffset)
+    Report.start_test(ForceRegion_RotationalOffset)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_SimpleDragForceOnRigidBodies.py

@@ -26,7 +26,7 @@ class Tests:
 # fmt: on
 
 
-def C5932043_ForceRegion_SimpleDragOnRigidBodies():
+def ForceRegion_SimpleDragForceOnRigidBodies():
     # This run() function will open a a level and validate that the force region slows down a spheres fall.
     # It does this by:
     #   1) Opens level with sphere above a force region
@@ -64,7 +64,7 @@ def C5932043_ForceRegion_SimpleDragOnRigidBodies():
     helper.init_idle()
 
     # 1) Open level
-    helper.open_level("Physics", "C5932043_ForceRegion_SimpleDragOnRigidBody")
+    helper.open_level("Physics", "ForceRegion_SimpleDragForceOnRigidBodies")
 
     # 2) Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -138,4 +138,4 @@ def C5932043_ForceRegion_SimpleDragOnRigidBodies():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C5932043_ForceRegion_SimpleDragOnRigidBodies)
+    Report.start_test(ForceRegion_SimpleDragForceOnRigidBodies)

AutomatedTesting/Gem/PythonTests/physics/tests/force_region/ForceRegion_SliceFileInstantiates.py

@@ -22,7 +22,7 @@ class Tests():
 # fmt: on
 
 
-def C6090546_ForceRegion_SliceFileInstantiates():
+def ForceRegion_SliceFileInstantiates():
 
     """
     Summary:
@@ -95,7 +95,7 @@ def C6090546_ForceRegion_SliceFileInstantiates():
     helper.init_idle()
 
     # 1) Open level
-    helper.open_level("Physics", "C6090546_ForceRegion_SliceFileInstantiates")
+    helper.open_level("Physics", "ForceRegion_SliceFileInstantiates")
 
     # 2) Enter game mode
     helper.enter_game_mode(Tests.enter_game_mode)
@@ -134,4 +134,4 @@ def C6090546_ForceRegion_SliceFileInstantiates():
 
 if __name__ == "__main__":
     from editor_python_test_tools.utils import Report
-    Report.start_test(C6090546_ForceRegion_SliceFileInstantiates)
+    Report.start_test(ForceRegion_SliceFileInstantiates)