SPEC-6685: Updating/adding test summaries for TestRail decoupling effort

2021-05-26 14:41:08 -05:00
parent 63ce0c1a62
commit b72cb2c601
29 changed files with 547 additions and 65 deletions
@@ -23,6 +23,25 @@ class TestSurfaceMaskFilter_BasicSurfaceTagCreation(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="TestSurfaceMaskFilter_BasicSurfaceTagCreation", args=["level"])
        
    def run_test(self):
+        """
+        Summary:
+        Verifies basic surface tag value equality
+
+        Expected Behavior:
+        Surface tags of the same name are equal, and different names aren't.
+
+        Test Steps:
+         1) Open level
+         2) Create 2 new surface tags of identical names and verify they resolve as equal.
+         3) Create another new tag of a different name and verify they resolve as different.
+
+        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
+        """
        self.log("SurfaceTag test started")
        
        # Create a level
@@ -33,6 +33,25 @@ class TestVegetationInstances_DespawnWhenOutOfRange(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix='VegetationInstances_DespawnWhenOutOfRange', args=['level'])

    def run_test(self):
+        """
+        Summary:
+        Verifies that vegetation instances properly spawn/despawn based on camera range.
+
+        Expected Behavior:
+        Vegetation instances despawn when out of camera range.
+
+        Test Steps:
+         1) Create a new level
+         2) Create a simple vegetation area, and set the view position near the spawner. Verify instances plant.
+         3) Move the view position away from the spawner. Verify instances despawn.
+
+        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
+        """

        # Create a new level
        self.test_success = self.create_level(
@@ -28,8 +28,21 @@ class TestGradientGeneratorIncompatibilities(EditorTestHelper):
    def run_test(self):
        """
        Summary:
-        Verify that Entities are not active when a Gradient Generator and incompatible component are both present
-        on the same Entity.
+        This test verifies that components are disabled when conflicting components are present on the same entity.
+
+        Expected Behavior:
+        Gradient Generator components are incompatible with Vegetation area components.
+
+        Test Steps:
+         1) Create a new level
+         2) Create a new entity in the level
+         3) Add each Gradient Generator component to an entity, and add a Vegetation Area component to the same entity
+         4) Verify that components are only enabled when entity is free of a conflicting component
+
+        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
        """
@@ -28,8 +28,21 @@ class TestGradientModifiersIncompatibilities(EditorTestHelper):
    def run_test(self):
        """
        Summary:
-        Verify that Entities are not active when a Gradient Modifier and incompatible component are both present
-        on the same Entity.
+        This test verifies that components are disabled when conflicting components are present on the same entity.
+
+        Expected Behavior:
+        Gradient Modifier components are incompatible with Vegetation area components.
+
+        Test Steps:
+         1) Create a new level
+         2) Create a new entity in the level
+         3) Add each Gradient Modifier component to an entity, and add a Vegetation Area component to the same entity
+         4) Verify that components are only enabled when entity is free of a conflicting component
+
+        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
        """
@@ -9,19 +9,6 @@ remove or modify any license notices. This file is distributed on an "AS IS" BAS
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 """

-"""
-The below cases are combined in this script
-C2676829
-C3961326
-C3980659
-C3980664
-C3980669
-C3416548
-C2676823
-C3961321
-C2676826
-"""
-
 import os
 import sys

@@ -33,6 +33,26 @@ class TestAreaNodeComponentDependency(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="AreaNodeComponentDependency", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas nodes can be added to a graph, and correctly create entities with
+        proper dependent components.
+
+        Expected Behavior:
+        All expected component dependencies are met when adding an area node to a graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the area nodes to the graph area, and ensure the proper dependent components are added
+
+        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
+        """

        def onEntityCreated(parameters):
            global newEntityId
@@ -33,7 +33,25 @@ class TestGradientNodeEntityCreate(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="AreaNodeEntityCreate", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas nodes can be added to a graph, and correctly create entities.

+        Expected Behavior:
+        New entities are created when dragging area nodes to graph area.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the area nodes to the graph area, and ensure a new entity is created
+
+        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
+        """
        def onEntityCreated(parameters):
            global newEntityId
            newEntityId = parameters[0]
@@ -34,7 +34,26 @@ class TestAreaNodeEntityDelete(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="AreaNodeEntityDelete", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas node deletion properly cleans up entities in the Editor.

+        Expected Behavior:
+        Entities are removed when area nodes are deleted from a graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the area nodes to the graph area, and ensure a new entity is created
+         4) Delete the nodes, and ensure the newly created entities are removed
+
+        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
+        """
        def onEntityCreated(parameters):
            global createdEntityId
            createdEntityId = parameters[0]
@@ -9,24 +9,6 @@ remove or modify any license notices. This file is distributed on an "AS IS" BAS
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 """

-
-"""
-C22602072 - Graph is updated when underlying components are added/removed
-
-1. Open Level.
-2. Find LandscapeCanvas named entity.
-3. Ensure Vegetation Distribution Component is present on the BushSpawner entity.
-4. Open graph and ensure Distribution Filter wrapped node is present.
-5. Delete the Vegetation Distribution Filter component from the BushSpawner entity via Entity Inspector.
-6. Ensure the Vegetation Distribution Filter component was deleted from the BushSpawner entity and node is no longer 
-present in the graph.
-7. Add Vegetation Altitude Filter to the BushSpawner entity through Entity Inspector.
-8. Ensure Altitude Filter was added to the BushSpawner node in the open graph.
-9. Add a new entity with unique name as a child of the Landscape Canvas entity.
-10. Add a Box Shape component to the new child entity.
-11. Ensure Box Shape node is present on the open graph.
-"""
-
 import os
 import sys

@@ -50,6 +32,36 @@ class TestComponentUpdatesUpdateGraph(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="ComponentUpdatesUpdateGraph", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas graphs update properly when components are added/removed outside of
+        Landscape Canvas.
+
+        Expected Behavior:
+        Graphs properly reflect component changes made to entities outside of Landscape Canvas.
+
+        Test Steps:
+            1. Open Level
+            2. Find LandscapeCanvas named entity
+            3. Ensure Vegetation Distribution Component is present on the BushSpawner entity
+            4. Open graph and ensure Distribution Filter wrapped node is present
+            5. Delete the Vegetation Distribution Filter component from the BushSpawner entity via Entity Inspector
+            6. Ensure the Vegetation Distribution Filter component was deleted from the BushSpawner entity and node is
+            no longer present in the graph
+            7. Add Vegetation Altitude Filter to the BushSpawner entity through Entity Inspector
+            8. Ensure Altitude Filter was added to the BushSpawner node in the open graph
+            9. Add a new entity with unique name as a child of the Landscape Canvas entity
+            10. Add a Box Shape component to the new child entity
+            11. Ensure Box Shape node is present on the open graph
+
+        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
+        """
+
        # Create a new empty level and instantiate LC_BushFlowerBlender.slice
        self.test_success = self.create_level(
            self.args["level"],
@@ -37,6 +37,25 @@ class TestCreateNewGraph(EditorTestHelper):
        print("New root entity created")

    def run_test(self):
+        """
+        Summary:
+        This test verifies that new graphs can be created in Landscape Canvas.
+
+        Expected Behavior:
+        New graphs can be created, and proper entity is created to hold graph data with a Landscape Canvas component.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Ensures the root entity created contains a Landscape Canvas component
+
+        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
+        """
        self.test_success = self.create_level(
            self.args["level"],
            heightmap_resolution=128,
@@ -33,7 +33,25 @@ class TestDisabledNodeDuplication(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="DisabledNodeDuplication", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies Editor stability after duplicating disabled Landscape Canvas nodes.

+        Expected Behavior:
+        Editor remains stable and free of crashes.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Create several new nodes, disable the nodes via disabling/deleting components, and duplicate the nodes
+
+        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
+        """
        def onEntityCreated(parameters):
            global newEntityId
            newEntityId = parameters[0]
@@ -9,17 +9,6 @@ remove or modify any license notices. This file is distributed on an "AS IS" BAS
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 """

-
-"""
-C30813586 - Editor remains stable after Undoing deletion of a node on a slice entity
-
-1. Open level with instantiated slice.
-2. Open the graph.
-3. Find the BushSpawner's Vegetation Layer Spawner node.
-4. Delete the node.
-5. Undo to restore the node.
-"""
-
 import os
 import sys

@@ -44,7 +33,26 @@ class TestUndoNodeDeleteSlice(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="UndoNodeDeleteSlice", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies Editor stability after undoing the deletion of nodes on a slice entity.

+        Expected Behavior:
+        Editor remains stable and free of crashes.
+
+        Test Steps:
+         1) Create a new level
+         2) Instantiate a slice with a Landscape Canvas setup
+         3) Find a specific node on the graph, and delete it
+         4) Restore the node with Undo
+
+        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
+        """
        # Create a new empty level and instantiate LC_BushFlowerBlender.slice
        self.test_success = self.create_level(
            self.args["level"],
@@ -34,6 +34,27 @@ class TestGradientMixerNodeConstruction(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="GradientMixerNodeConstruction", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies a Gradient Mixer vegetation setup can be constructed through Landscape Canvas.
+
+        Expected Behavior:
+        Entities contain all required components and component references after creating nodes and setting connections
+        on a Landscape Canvas graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Add all necessary nodes to the graph and set connections to form a Gradient Mixer setup
+         4) Verify all components and component references were properly set during graph construction
+
+        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
+        """

        def onEntityCreated(parameters):
            global newEntityId
@@ -33,6 +33,25 @@ class TestGradientModifierNodeEntityCreate(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="GradientModifierNodeEntityCreate", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas nodes can be added to a graph, and correctly create entities.
+
+        Expected Behavior:
+        New entities are created when dragging Gradient Modifier nodes to graph area.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the Gradient Modifier nodes to the graph area, and ensure a new entity is created
+
+        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
+        """

        def onEntityCreated(parameters):
            global newEntityId
@@ -34,7 +34,26 @@ class TestGradientModifierNodeEntityDelete(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="GradientModifierNodeEntityDelete", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas node deletion properly cleans up entities in the Editor.

+        Expected Behavior:
+        Entities are removed when Gradient Modifier nodes are deleted from a graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the Gradient Modifier nodes to the graph area, and ensure a new entity is created
+         4) Delete the nodes, and ensure the newly created entities are removed
+
+        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
+        """
        def onEntityCreated(parameters):
            global createdEntityId
            createdEntityId = parameters[0]
@@ -33,6 +33,27 @@ class TestGradientNodeComponentDependency(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="GradientNodeComponentDependency", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas nodes can be added to a graph, and correctly create entities with
+        proper dependent components.
+
+        Expected Behavior:
+        All expected component dependencies are met when adding a Gradient Modifier node to a graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the Gradient Modifier nodes to the graph area, and ensure the proper dependent components are
+         added
+
+        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
+        """

        def onEntityCreated(parameters):
            global newEntityId
@@ -32,6 +32,25 @@ class TestGradientNodeEntityCreate(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="GradientNodeEntityCreate", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas nodes can be added to a graph, and correctly create entities.
+
+        Expected Behavior:
+        New entities are created when dragging Gradient nodes to graph area.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the Gradient nodes to the graph area, and ensure a new entity is created
+
+        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
+        """

        def onEntityCreated(parameters):
            global newEntityId
@@ -34,6 +34,26 @@ class TestGradientNodeEntityDelete(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="GradientNodeEntityDelete", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas node deletion properly cleans up entities in the Editor.
+
+        Expected Behavior:
+        Entities are removed when Gradient nodes are deleted from a graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the Gradient nodes to the graph area, and ensure a new entity is created
+         4) Delete the nodes, and ensure the newly created entities are removed
+
+        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
+        """

        def onEntityCreated(parameters):
            global createdEntityId
@@ -31,6 +31,26 @@ class TestGraphClosedOnEntityDelete(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="GraphClosedOnEntityDelete", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that Landscape Canvas graphs are auto-closed when the corresponding entity is deleted.
+
+        Expected Behavior:
+        When a Landscape Canvas root entity is deleted, the corresponding graph automatically closes.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Delete the automatically created entity
+         4) Verify the open graph is closed
+
+        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
+        """

        def onEntityCreated(parameters):
            global newRootEntityId
@@ -29,7 +29,26 @@ class TestGraphClosedOnLevelChange(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="GraphClosedOnLevelChange", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that Landscape Canvas graphs are auto-closed when the currently open level changes.

+        Expected Behavior:
+        When a new level is loaded in the Editor, open Landscape Canvas graphs are automatically closed.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Open a different level
+         4) Verify the open graph is closed
+
+        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
+        """
        # Create a new empty level
        self.test_success = self.create_level(
            self.args["level"],
@@ -29,6 +29,26 @@ class TestGraphClosedTabbedGraph(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="GraphClosedTabbedGraph", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that Landscape Canvas tabbed graphs can be independently closed.
+
+        Expected Behavior:
+        Closing a tabbed graph only closes the appropriate graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create several new graphs
+         3) Close one of the open graphs
+         4) Ensure the graph properly closed, and other open graphs remain open
+
+        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
+        """

        # Create a new empty level
        self.test_success = self.create_level(
@@ -9,21 +9,6 @@ remove or modify any license notices. This file is distributed on an "AS IS" BAS
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 """

-
-"""
-C22715182 - Components are updated when nodes are added/removed/updated
-
-1. Open Level.
-2. Open the graph on LC_BushFlowerBlender.slice
-3. Find the Rotation Modifier node on the BushSpawner entity
-4. Delete the Rotation Modifier node
-5. Ensure the Vegetation Rotation Modifier component is removed from the BushSpawner entity
-6. Delete the Vegetation Layer Spawner node from the graph
-7. Ensure BushSpawner entity is deleted
-8. Change connection from second Rotation Modifier node to a different Gradient
-9. Ensure Gradient reference on component is updated
-"""
-
 import os
 import sys

@@ -50,6 +35,31 @@ class TestGraphUpdatesUpdateComponents(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="GraphUpdatesUpdateComponents", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that components are properly updated as nodes are added/removed/updated.
+
+        Expected Behavior:
+        Landscape Canvas node CRUD properly updates component entities.
+
+        Test Steps:
+            1. Open Level.
+            2. Open the graph on LC_BushFlowerBlender.slice
+            3. Find the Rotation Modifier node on the BushSpawner entity
+            4. Delete the Rotation Modifier node
+            5. Ensure the Vegetation Rotation Modifier component is removed from the BushSpawner entity
+            6. Delete the Vegetation Layer Spawner node from the graph
+            7. Ensure BushSpawner entity is deleted
+            8. Change connection from second Rotation Modifier node to a different Gradient
+            9. Ensure Gradient reference on component is updated
+
+        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
+        """
        # Create a new empty level and instantiate LC_BushFlowerBlender.slice
        self.test_success = self.create_level(
            self.args["level"],
@@ -30,6 +30,26 @@ class TestLandscapeCanvasComponentAddedRemoved(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="LandscapeCanvasComponentAddedRemoved", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas component can be added to/removed from an entity.
+
+        Expected Behavior:
+        Closing a tabbed graph only closes the appropriate graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Create a new entity
+         3) Add a Landscape Canvas component to the entity
+         4) Remove the Landscape Canvas component from the entity
+
+        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
+        """

        # Create a new empty level
        self.test_success = self.create_level(
@@ -30,12 +30,21 @@ class TestLandscapeCanvasSliceCreateInstantiate(EditorTestHelper):
    def run_test(self):
        """
        Summary:
-        C22602016 A slice containing the LandscapeCanvas component can be created/instantiated.
+        A slice containing the LandscapeCanvas component can be created/instantiated.

        Expected Result:
-        Slice is created and processed successfully and free of errors/warnings.
-        Another copy of the slice is instantiated.
+        Slice is created/processed/instantiated successfully and free of errors/warnings.

+        Test Steps:
+         1) Create a new level
+         2) Create a new entity with a Landscape Canvas component
+         3) Create a slice of the new entity
+         4) Instantiate a new copy of the slice
+
+         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
        """

@@ -34,6 +34,27 @@ class TestLayerBlenderNodeConstruction(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="LayerBlenderNodeConstruction", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies a Layer Blender vegetation setup can be constructed through Landscape Canvas.
+
+        Expected Behavior:
+        Entities contain all required components and component references after creating nodes and setting connections
+        on a Landscape Canvas graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Add all necessary nodes to the graph and set connections to form a Layer Blender setup
+         4) Verify all components and component references were properly set during graph construction
+
+        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
+        """

        def onEntityCreated(parameters):
            global newEntityId
@@ -34,6 +34,25 @@ class TestLayerExtenderNodeComponentEntitySync(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="LayerExtenderNodeComponentEntitySync", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that all wrapped nodes can be successfully added to/removed from parent nodes.
+
+        Expected Behavior:
+        All wrapped extender nodes can be added to/removed from appropriate parent nodes.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Add Area Blender and Layer Spawner nodes to the graph, and add/remove each extender node to/from each
+
+        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
+        """

        def onEntityCreated(parameters):
            global newEntityId
@@ -33,6 +33,25 @@ class TestShapeNodeEntityCreate(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="ShapeNodeEntityCreate", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas nodes can be added to a graph, and correctly create entities.
+
+        Expected Behavior:
+        New entities are created when dragging shape nodes to graph area.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the shape nodes to the graph area, and ensure a new entity is created
+
+        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
+        """

        def onEntityCreated(parameters):
            global newEntityId
@@ -34,7 +34,27 @@ class TestShapeNodeEntityDelete(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="ShapeNodeEntityDelete", args=["level"])

    def run_test(self):
-        
+        """
+        Summary:
+        This test verifies that the Landscape Canvas node deletion properly cleans up entities in the Editor.
+
+        Expected Behavior:
+        Entities are removed when shape nodes are deleted from a graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the shape nodes to the graph area, and ensure a new entity is created
+         4) Delete the nodes, and ensure the newly created entities are removed
+
+        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
+        """
+
        def onEntityCreated(parameters):
            global createdEntityId
            createdEntityId = parameters[0]
@@ -33,6 +33,27 @@ class TestSlotConnectionsUpdateComponents(EditorTestHelper):
        EditorTestHelper.__init__(self, log_prefix="SlotConnectionsUpdateComponents", args=["level"])

    def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas slot connections properly update component references.
+
+        Expected Behavior:
+        A reference created through slot connections in Landscape Canvas is reflected in the Entity Inspector.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Several nodes are added to a graph, and connections are set between the nodes
+         4) Component references are verified via Entity Inspector
+
+        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
+        """
+
        # Retrieve the proper component TypeIds per component name
        componentNames = [
            'Random Noise Gradient',