o3de/AutomatedTesting/Gem/PythonTests/assetpipeline/fbx_tests/fbx_tests.py

"""
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
"""

import binascii
from dataclasses import dataclass
import logging
import os
import pytest
from typing import List
import distutils.dir_util

# Import LyTestTools
import ly_test_tools.builtin.helpers as helpers
from ly_test_tools.o3de import asset_processor as asset_processor_utils
from ly_test_tools.o3de.asset_processor import ASSET_PROCESSOR_PLATFORM_MAP

# Import fixtures
from ..ap_fixtures.asset_processor_fixture import asset_processor as asset_processor
from ..ap_fixtures.ap_setup_fixture import ap_setup_fixture as ap_setup_fixture
from ..ap_fixtures.ap_config_backup_fixture import ap_config_backup_fixture as ap_config_backup_fixture
from ..ap_fixtures.ap_config_default_platform_fixture \
    import ap_config_default_platform_fixture as ap_config_default_platform_fixture

# Import LyShared
import ly_test_tools.o3de.pipeline_utils as utils
from automatedtesting_shared import asset_database_utils as asset_db_utils

logger = logging.getLogger(__name__)

# Helper: variables we will use for parameter values in the test:
targetProjects = ["AutomatedTesting"]


@pytest.fixture
def local_resources(request, workspace, ap_setup_fixture):
    ap_setup_fixture["tests_dir"] = os.path.dirname(os.path.realpath(__file__))


@dataclass
@pytest.mark.SUITE_sandbox
class BlackboxAssetTest:
    test_name: str
    asset_folder: str
    override_asset_folder: str = ""
    scene_debug_file: str = ""
    override_scene_debug_file: str = ""
    assets: List[asset_db_utils.DBSourceAsset] = ()
    override_assets: List[asset_db_utils.DBSourceAsset] = ()


blackbox_fbx_tests = [
    pytest.param(
        BlackboxAssetTest(
            test_name="OneMeshOneMaterial_RunAP_SuccessWithMatchingProducts",
            asset_folder="OneMeshOneMaterial",
            scene_debug_file="onemeshonematerial.dbgsg",
            assets=[
                asset_db_utils.DBSourceAsset(
                    source_file_name="OneMeshOneMaterial.fbx",
                    uuid=b"8a9164adb84859be893e18aa819438e1",
                    jobs=[
                        asset_db_utils.DBJob(
                            job_key='Scene compilation',
                            builder_guid=b'bd8bf65894854fe3830e8ec3a23c35f3',
                            status=4,
                            error_count=0,
                            products=[
                                asset_db_utils.DBProduct(
                                    product_name='onemeshonematerial/onemeshonematerial.assetinfo.dbg',
                                    sub_id=-1450203600,
                                    asset_type=b'48a78be7b3f244b88aa6f0607e9a75a5'),
                                asset_db_utils.DBProduct(
                                    product_name='onemeshonematerial/onemeshonematerial.dbgsg',
                                    sub_id=1918494907,
                                    asset_type=b'07f289d14dc74c4094b40a53bbcb9f0b'),
                                asset_db_utils.DBProduct(
                                    product_name='onemeshonematerial/onemeshonematerial.dbgsg.xml',
                                    sub_id=556355570, asset_type=b'51f376140d774f369ac67ed70a0ac868'),
                                asset_db_utils.DBProduct(
                                    product_name='onemeshonematerial/onemeshonematerial_fbx.procprefab',
                                    sub_id=-1819295853,
                                    asset_type=b'9b7c8459471e4eada3637990cc4065a9'),
                                asset_db_utils.DBProduct(
                                    product_name='onemeshonematerial/onemeshonematerial_fbx.procprefab.json',
                                    sub_id=-1860036023,
                                    asset_type=b'00000000000000000000000000000000')
                            ]
                        )
                    ]
                )
            ]
        ),
        id="32250017",
        marks=pytest.mark.test_case_id("C32250017"),
    ),
    pytest.param(
        BlackboxAssetTest(
            # Verifies that the soft naming convention feature with level of detail meshes works.
            test_name="SoftNamingLOD_RunAP_SuccessWithMatchingProducts",
            asset_folder="SoftNamingLOD",
            scene_debug_file="lodtest.dbgsg",
            assets=[
                asset_db_utils.DBSourceAsset(
                    source_file_name="lodtest.fbx",
                    uuid=b"44c8627fe2c25aae91fe3ff9547be3b9",
                    jobs=[
                        asset_db_utils.DBJob(
                            job_key='Scene compilation',
                            builder_guid=b'bd8bf65894854fe3830e8ec3a23c35f3',
                            status=4,
                            error_count=0,
                            products=[
                                asset_db_utils.DBProduct(
                                    product_name='softnaminglod/lodtest.assetinfo.dbg',
                                    sub_id=1928041548,
                                    asset_type=b'48a78be7b3f244b88aa6f0607e9a75a5'),
                                asset_db_utils.DBProduct(
                                    product_name='softnaminglod/lodtest.dbgsg',
                                    sub_id=-632012261,
                                    asset_type=b'07f289d14dc74c4094b40a53bbcb9f0b'),
                                asset_db_utils.DBProduct(
                                    product_name='softnaminglod/lodtest.dbgsg.xml',
                                    sub_id=-2036095434,
                                    asset_type=b'51f376140d774f369ac67ed70a0ac868'),
                                asset_db_utils.DBProduct(
                                    product_name='softnaminglod/lodtest_fbx.procprefab',
                                    sub_id=838906682,
                                    asset_type=b'9b7c8459471e4eada3637990cc4065a9'),
                                asset_db_utils.DBProduct(
                                    product_name='softnaminglod/lodtest_fbx.procprefab.json',
                                    sub_id=-71923453,
                                    asset_type=b'00000000000000000000000000000000'
                                )
                            ]
                        ),
                    ]
                )
            ]
        ),
        id="33887870",
        marks=pytest.mark.test_case_id("33887870"),
    ),
    pytest.param(
        BlackboxAssetTest(
            # Verifies that the soft naming convention feature with physics proxies works.
            test_name="SoftNamingPhysics_RunAP_SuccessWithMatchingProducts",
            asset_folder="SoftNamingPhysics",
            scene_debug_file="physicstest.dbgsg",
            assets=[
                asset_db_utils.DBSourceAsset(
                    source_file_name="physicstest.fbx",
                    uuid=b"df957b7918cf5b029806c73f630fa1c8",
                    jobs=[
                        asset_db_utils.DBJob(
                            job_key='Scene compilation',
                            builder_guid=b'bd8bf65894854fe3830e8ec3a23c35f3',
                            status=4,
                            error_count=0,
                            products=[
                                asset_db_utils.DBProduct(
                                    product_name='softnamingphysics/physicstest.assetinfo.dbg',
                                    sub_id=-2134016152,
                                    asset_type=b'48a78be7b3f244b88aa6f0607e9a75a5'),
                                asset_db_utils.DBProduct(
                                    product_name='softnamingphysics/physicstest.dbgsg',
                                    sub_id=-740411732,
                                    asset_type=b'07f289d14dc74c4094b40a53bbcb9f0b'),
                                asset_db_utils.DBProduct(
                                    product_name='softnamingphysics/physicstest.dbgsg.xml',
                                    sub_id=330338417,
                                    asset_type=b'51f376140d774f369ac67ed70a0ac868'),
                                asset_db_utils.DBProduct(
                                    product_name='softnamingphysics/physicstest.pxmesh',
                                    sub_id=640975857,
                                    asset_type=b'7a2871b95eab4de0a901b0d2c6920ddb'),
                                asset_db_utils.DBProduct(
                                    product_name='softnamingphysics/physicstest_fbx.procprefab',
                                    sub_id=651014275,
                                    asset_type=b'9b7c8459471e4eada3637990cc4065a9'),
                                asset_db_utils.DBProduct(
                                    product_name='softnamingphysics/physicstest_fbx.procprefab.json',
                                    sub_id=1124966094,
                                    asset_type=b'00000000000000000000000000000000'
                                )
                            ]
                        ),
                    ]
                )
            ]
        ),
    ),
    pytest.param(
        BlackboxAssetTest(
            test_name="MultipleMeshOneMaterial_RunAP_SuccessWithMatchingProducts",
            asset_folder="TwoMeshOneMaterial",
            scene_debug_file="multiple_mesh_one_material.dbgsg",
            assets=[
                asset_db_utils.DBSourceAsset(
                    source_file_name="multiple_mesh_one_material.fbx",
                    uuid=b"597618fd497659a1b197a015fe47aa95",
                    jobs=[
                        asset_db_utils.DBJob(
                            job_key='Scene compilation',
                            builder_guid=b'bd8bf65894854fe3830e8ec3a23c35f3',
                            status=4,
                            error_count=0,
                            products=[
                                asset_db_utils.DBProduct(
                                    product_name='twomeshonematerial/multiple_mesh_one_material.assetinfo.dbg',
                                    sub_id=-1522579082,
                                    asset_type=b'48a78be7b3f244b88aa6f0607e9a75a5'),
                                asset_db_utils.DBProduct(
                                    product_name='twomeshonematerial/multiple_mesh_one_material.dbgsg',
                                    sub_id=2077268018,
                                    asset_type=b'07f289d14dc74c4094b40a53bbcb9f0b'),
                                asset_db_utils.DBProduct(
                                    product_name='twomeshonematerial/multiple_mesh_one_material.dbgsg.xml',
                                    sub_id=1321067730,
                                    asset_type=b'51f376140d774f369ac67ed70a0ac868'
                                )
                            ]
                        ),
                    ]
                )
            ]
        ),
        id="34448178",
        marks=pytest.mark.test_case_id("C34448178"),
    ),
    pytest.param(
        BlackboxAssetTest(
            # Verifies whether multiple meshes can share linked materials
            test_name="MultipleMeshLinkedMaterials_RunAP_SuccessWithMatchingProducts",
            asset_folder="TwoMeshLinkedMaterials",
            scene_debug_file="multiple_mesh_linked_materials.dbgsg",
            assets=[
                asset_db_utils.DBSourceAsset(
                    source_file_name="multiple_mesh_linked_materials.fbx",
                    uuid=b"25d8301c2eef5dc7bded310db8ea608d",
                    jobs=[
                        asset_db_utils.DBJob(
                            job_key='Scene compilation',
                            builder_guid=b'bd8bf65894854fe3830e8ec3a23c35f3',
                            status=4,
                            error_count=0,
                            products=[
                                asset_db_utils.DBProduct(
                                    product_name='twomeshlinkedmaterials/multiple_mesh_linked_materials.assetinfo.dbg',
                                    sub_id=-1625296771,
                                    asset_type=b'48a78be7b3f244b88aa6f0607e9a75a5'),
                                asset_db_utils.DBProduct(
                                    product_name='twomeshlinkedmaterials/multiple_mesh_linked_materials.dbgsg',
                                    sub_id=-1898461950,
                                    asset_type=b'07f289d14dc74c4094b40a53bbcb9f0b'),
                                asset_db_utils.DBProduct(
                                    product_name='twomeshlinkedmaterials/multiple_mesh_linked_materials.dbgsg.xml',
                                    sub_id=-772341513,
                                    asset_type=b'51f376140d774f369ac67ed70a0ac868'),
                                asset_db_utils.DBProduct(
                                    product_name='twomeshlinkedmaterials/multiple_mesh_linked_materials_fbx.procprefab',
                                    sub_id=-859152125,
                                    asset_type=b'9b7c8459471e4eada3637990cc4065a9'),
                                asset_db_utils.DBProduct(
                                    product_name='twomeshlinkedmaterials/multiple_mesh_linked_materials_fbx.procprefab.json',
                                    sub_id=-841089725,
                                    asset_type=b'00000000000000000000000000000000'
                                )
                            ]
                        ),
                    ]
                )
            ]
        ),
        id="32250018",
        marks=pytest.mark.test_case_id("C32250018"),
    ),
    pytest.param(
        BlackboxAssetTest(
            # Verifies a mesh with multiple materials
            test_name="SingleMeshMultipleMaterials_RunAP_SuccessWithMatchingProducts",
            asset_folder="OneMeshMultipleMaterials",
            scene_debug_file="single_mesh_multiple_materials.dbgsg",
            assets=[
                asset_db_utils.DBSourceAsset(
                    source_file_name="single_mesh_multiple_materials.fbx",
                    uuid=b"f08fd585dfa35881b4bf86637da5e858",
                    jobs=[
                        asset_db_utils.DBJob(
                            job_key='Scene compilation',
                            builder_guid=b'bd8bf65894854fe3830e8ec3a23c35f3',
                            status=4,
                            error_count=0,
                            products=[
                                asset_db_utils.DBProduct(
                                    product_name='onemeshmultiplematerials/single_mesh_multiple_materials.assetinfo.dbg',
                                    sub_id=-250120843,
                                    asset_type=b'48a78be7b3f244b88aa6f0607e9a75a5'),
                                asset_db_utils.DBProduct(
                                    product_name='onemeshmultiplematerials/single_mesh_multiple_materials.dbgsg',
                                    sub_id=-262822238,
                                    asset_type=b'07f289d14dc74c4094b40a53bbcb9f0b'),
                                asset_db_utils.DBProduct(
                                    product_name='onemeshmultiplematerials/single_mesh_multiple_materials.dbgsg.xml',
                                    sub_id=1462358160,
                                    asset_type=b'51f376140d774f369ac67ed70a0ac868'),
                                asset_db_utils.DBProduct(
                                    product_name='onemeshmultiplematerials/single_mesh_multiple_materials_fbx.procprefab',
                                    sub_id=1496946180,
                                    asset_type=b'9b7c8459471e4eada3637990cc4065a9'),
                                asset_db_utils.DBProduct(
                                    product_name='onemeshmultiplematerials/single_mesh_multiple_materials_fbx.procprefab.json',
                                    sub_id=-537346917,
                                    asset_type=b'00000000000000000000000000000000'
                                )
                            ]
                        ),
                    ]
                )
            ]
        ),
        id="32250020",
        marks=pytest.mark.test_case_id("C32250020"),
    ),
    pytest.param(
        BlackboxAssetTest(
            test_name="MeshWithVertexColors_RunAP_SuccessWithMatchingProducts",
            asset_folder="VertexColor",
            scene_debug_file="vertexcolor.dbgsg",
            assets=[
                asset_db_utils.DBSourceAsset(
                    source_file_name="VertexColor.fbx",
                    uuid=b"207e7e1540785a26b064e9be67361cdf",
                    jobs=[
                        asset_db_utils.DBJob(
                            job_key='Scene compilation',
                            builder_guid=b'bd8bf65894854fe3830e8ec3a23c35f3',
                            status=4,
                            error_count=0,
                            products=[
                                asset_db_utils.DBProduct(
                                    product_name='vertexcolor/vertexcolor.assetinfo.dbg',
                                    sub_id=-772831195,
                                    asset_type=b'48a78be7b3f244b88aa6f0607e9a75a5'),
                                asset_db_utils.DBProduct(
                                    product_name='vertexcolor/vertexcolor.dbgsg',
                                    sub_id=-1543877170,
                                    asset_type=b'07f289d14dc74c4094b40a53bbcb9f0b'),
                                asset_db_utils.DBProduct(
                                    product_name='vertexcolor/vertexcolor.dbgsg.xml',
                                    sub_id=1743516586,
                                    asset_type=b'51f376140d774f369ac67ed70a0ac868'),
                                asset_db_utils.DBProduct(
                                    product_name='vertexcolor/vertexcolor_fbx.procprefab',
                                    sub_id=604991654,
                                    asset_type=b'9b7c8459471e4eada3637990cc4065a9'),
                                asset_db_utils.DBProduct(
                                    product_name='vertexcolor/vertexcolor_fbx.procprefab.json',
                                    sub_id=-1669533680,
                                    asset_type=b'00000000000000000000000000000000'
                                )
                            ]
                        ),
                    ]
                )
            ]
        ),
        id="35796285",
        marks=pytest.mark.test_case_id("C35796285"),
    ),
    pytest.param(
        BlackboxAssetTest(
            test_name="MotionTest_RunAP_SuccessWithMatchingProducts",
            asset_folder="Motion",
            scene_debug_file="Jack_Idle_Aim_ZUp.dbgsg",
            assets=[
                asset_db_utils.DBSourceAsset(
                    source_file_name="Jack_Idle_Aim_ZUp.fbx",
                    uuid=b"eda904ae0e145f8b973d57fc5809918b",
                    jobs=[
                        asset_db_utils.DBJob(
                            job_key='Scene compilation',
                            builder_guid=b'bd8bf65894854fe3830e8ec3a23c35f3',
                            status=4,
                            error_count=0,
                            products=[
                                asset_db_utils.DBProduct(
                                    product_name='motion/jack_idle_aim_zup.assetinfo.dbg',
                                    sub_id=-1508868345,
                                    asset_type=b'48a78be7b3f244b88aa6f0607e9a75a5'),
                                asset_db_utils.DBProduct(
                                    product_name='motion/jack_idle_aim_zup.dbgsg',
                                    sub_id=-517610290,
                                    asset_type=b'07f289d14dc74c4094b40a53bbcb9f0b'),
                                asset_db_utils.DBProduct(
                                    product_name='motion/jack_idle_aim_zup.dbgsg.xml',
                                    sub_id=-817863914,
                                    asset_type=b'51f376140d774f369ac67ed70a0ac868'),
                                asset_db_utils.DBProduct(
                                    product_name='motion/jack_idle_aim_zup.motion',
                                    sub_id=186392073,
                                    asset_type=b'00494b8e75784ba28b28272e90680787'
                                )
                            ]
                        ),
                    ]
                )
            ]
        ),
    ),
    pytest.param(
        BlackboxAssetTest(
            test_name="ShaderBall_RunAP_SuccessWithMatchingProducts",
            asset_folder="ShaderBall",
            scene_debug_file="shaderball.dbgsg",
            assets=[
                asset_db_utils.DBSourceAsset(
                    source_file_name="shaderball.fbx",
                    uuid=b"48181ba8038e5193997540fc8dffb06d",
                    jobs=[
                        asset_db_utils.DBJob(
                            job_key='Scene compilation',
                            builder_guid=b'bd8bf65894854fe3830e8ec3a23c35f3',
                            status=4,
                            error_count=0,
                            products=[
                                asset_db_utils.DBProduct(
                                    product_name='shaderball/shaderball.assetinfo.dbg',
                                    sub_id=-2030891151,
                                    asset_type=b'48a78be7b3f244b88aa6f0607e9a75a5'),
                                asset_db_utils.DBProduct(
                                    product_name='shaderball/shaderball.dbgsg',
                                    sub_id=-1607815784,
                                    asset_type=b'07f289d14dc74c4094b40a53bbcb9f0b'),
                                asset_db_utils.DBProduct(
                                    product_name='shaderball/shaderball.dbgsg.xml',
                                    sub_id=-1153118555,
                                    asset_type=b'51f376140d774f369ac67ed70a0ac868'),
                                asset_db_utils.DBProduct(
                                    product_name='shaderball/shaderball_fbx.procprefab',
                                    sub_id=-1501914312,
                                    asset_type=b'9b7c8459471e4eada3637990cc4065a9'),
                                asset_db_utils.DBProduct(
                                    product_name='shaderball/shaderball_fbx.procprefab.json',
                                    sub_id=-1464074454,
                                    asset_type=b'00000000000000000000000000000000'
                                ),
                            ]
                        ),
                    ]
                )
            ]
        ),
    ),
    pytest.param(
        BlackboxAssetTest(
            test_name="cubewithline_RunAP_CubeOutputsWithoutLine",
            asset_folder="cubewithline",
            scene_debug_file="cubewithline.dbgsg",
            assets=[
                asset_db_utils.DBSourceAsset(
                    source_file_name="cubewithline.fbx",
                    uuid=b'1ee8fbf7c1f25b8399395a112e51906c',
                    jobs=[
                        asset_db_utils.DBJob(
                            job_key='Scene compilation',
                            builder_guid=b'bd8bf65894854fe3830e8ec3a23c35f3',
                            status=4,
                            error_count=0,
                            products=[
                                asset_db_utils.DBProduct(
                                    product_name='cubewithline/cubewithline.assetinfo.dbg',
                                    sub_id=-1674123269,
                                    asset_type=b'48a78be7b3f244b88aa6f0607e9a75a5'),
                                asset_db_utils.DBProduct(
                                    product_name='cubewithline/cubewithline.dbgsg',
                                    sub_id=1173066699,
                                    asset_type=b'07f289d14dc74c4094b40a53bbcb9f0b'),
                                asset_db_utils.DBProduct(
                                    product_name='cubewithline/cubewithline.dbgsg.xml',
                                    sub_id=1357518515,
                                    asset_type=b'51f376140d774f369ac67ed70a0ac868'),
                                asset_db_utils.DBProduct(
                                    product_name='cubewithline/cubewithline_fbx.procprefab',
                                    sub_id=1800163200,
                                    asset_type=b'9b7c8459471e4eada3637990cc4065a9'),
                                asset_db_utils.DBProduct(
                                    product_name='cubewithline/cubewithline_fbx.procprefab.json',
                                    sub_id=2139660816,
                                    asset_type=b'00000000000000000000000000000000'
                                ),
                            ]
                        ),
                    ]
                )
            ]
        ),
    ),
]

blackbox_fbx_special_tests = [
    pytest.param(
        BlackboxAssetTest(
            test_name="MultipleMeshMultipleMaterial_MultipleAssetInfo_RunAP_SuccessWithMatchingProducts",
            asset_folder="TwoMeshTwoMaterial",
            override_asset_folder="OverrideAssetInfoForTwoMeshTwoMaterial",
            scene_debug_file="multiple_mesh_multiple_material.dbgsg",
            override_scene_debug_file="multiple_mesh_multiple_material_override.dbgsg",
            assets=[
                asset_db_utils.DBSourceAsset(
                    source_file_name="multiple_mesh_multiple_material.fbx",
                    uuid=b"b5915fb874af5c8a866ccabbddb57595",
                    jobs=[
                        asset_db_utils.DBJob(
                            job_key='Scene compilation',
                            builder_guid=b'bd8bf65894854fe3830e8ec3a23c35f3',
                            status=4,
                            error_count=0,
                            products=[
                                asset_db_utils.DBProduct(
                                    product_name='twomeshtwomaterial/multiple_mesh_multiple_material.assetinfo.dbg',
                                    sub_id=1718635869,
                                    asset_type=b'48a78be7b3f244b88aa6f0607e9a75a5'),
                                asset_db_utils.DBProduct(
                                    product_name='twomeshtwomaterial/multiple_mesh_multiple_material.dbgsg',
                                    sub_id=896980093,
                                    asset_type=b'07f289d14dc74c4094b40a53bbcb9f0b'),
                                asset_db_utils.DBProduct(
                                    product_name='twomeshtwomaterial/multiple_mesh_multiple_material.dbgsg.xml',
                                    sub_id=-1556988544,
                                    asset_type=b'51f376140d774f369ac67ed70a0ac868'
                                )
                            ]
                        ),
                    ]
                )
            ],
            override_assets=[
                asset_db_utils.DBSourceAsset(
                    source_file_name="multiple_mesh_multiple_material.fbx",
                    uuid=b"b5915fb874af5c8a866ccabbddb57595",
                    jobs=[
                        asset_db_utils.DBJob(
                            job_key='Scene compilation',
                            builder_guid=b'bd8bf65894854fe3830e8ec3a23c35f3',
                            status=4,
                            error_count=0,
                            products=[
                                asset_db_utils.DBProduct(
                                    product_name='twomeshtwomaterial/multiple_mesh_multiple_material.assetinfo.dbg',
                                    sub_id=1718635869,
                                    asset_type=b'48a78be7b3f244b88aa6f0607e9a75a5'),
                                asset_db_utils.DBProduct(
                                    product_name='twomeshtwomaterial/multiple_mesh_multiple_material.dbgsg',
                                    sub_id=896980093,
                                    asset_type=b'07f289d14dc74c4094b40a53bbcb9f0b'),
                                asset_db_utils.DBProduct(
                                    product_name='twomeshtwomaterial/multiple_mesh_multiple_material.dbgsg.xml',
                                    sub_id=-1556988544,
                                    asset_type=b'51f376140d774f369ac67ed70a0ac868'
                                )
                            ]
                        ),
                    ]
                )
            ]
        ),
        id="34389075",
        marks=pytest.mark.test_case_id("C34389075"),
    ),
]


@pytest.mark.usefixtures("asset_processor")
@pytest.mark.usefixtures("ap_setup_fixture")
@pytest.mark.usefixtures("local_resources")
@pytest.mark.parametrize("project", targetProjects)
@pytest.mark.assetpipeline
@pytest.mark.SUITE_sandbox
class TestsFBX_AllPlatforms(object):

    @pytest.mark.BAT
    @pytest.mark.parametrize("blackbox_param", blackbox_fbx_tests)
    def test_FBXBlackboxTest_SourceFiles_Processed_ResultInExpectedProducts(self, workspace, ap_setup_fixture,
                                                                            asset_processor, project, blackbox_param):
        """

        Please see run_fbx_test(...) for details
        Test Steps:
        1. Determine if blackbox is set to none
        2. Run FBX Test

        """

        if blackbox_param == None:
            return
        self.run_fbx_test(workspace, ap_setup_fixture, asset_processor, project, blackbox_param)

    @pytest.mark.BAT
    @pytest.mark.parametrize("blackbox_param", blackbox_fbx_special_tests)
    def test_FBXBlackboxTest_AssetInfoModified_AssetReprocessed_ResultInExpectedProducts(
            self, workspace, ap_setup_fixture, asset_processor, project, blackbox_param):
        """
        Please see run_fbx_test(...) for details

        Test Steps:
        1. Determine if blackbox is set to none
        2. Run FBX Test
        2. Re-run FBX test and validate the information in override assets
        """

        if blackbox_param == None:
            return
        self.run_fbx_test(workspace, ap_setup_fixture,
                          asset_processor, project, blackbox_param)

        # Run the test again and validate the information in the override assets
        self.run_fbx_test(workspace, ap_setup_fixture,
                          asset_processor, project, blackbox_param, True)

    @staticmethod
    def populate_asset_info(workspace, project, assets):

        # Check that each given source asset resulted in the expected jobs and products.
        for expected_source in assets:
            for job in expected_source.jobs:
                job.platform = ASSET_PROCESSOR_PLATFORM_MAP[workspace.asset_processor_platform]
                for product in job.products:
                    product.product_name = job.platform + "/" \
                                           + product.product_name

    @staticmethod
    def compare_scene_debug_file(asset_processor, expected_file_path, actual_file_path):
        debug_graph_path = os.path.join(asset_processor.project_test_cache_folder(), actual_file_path)
        expected_debug_graph_path = os.path.join(asset_processor.project_test_source_folder(), "SceneDebug", expected_file_path)

        logger.info(f"Parsing scene graph: {debug_graph_path}")
        with open(debug_graph_path, "r") as scene_file:
            actual_lines = scene_file.readlines()

        logger.info(f"Parsing scene graph: {expected_debug_graph_path}")
        with open(expected_debug_graph_path, "r") as scene_file:
            expected_lines = scene_file.readlines()
        assert utils.compare_lists(actual_lines, expected_lines), "Scene mismatch"

    # Helper to run Asset Processor with debug output enabled and Atom output disabled
    @staticmethod
    def run_ap_debug_skip_atom_output(asset_processor):
        result = asset_processor.batch_process(extra_params=["--debugOutput",
                                                             "--regset=\"/O3DE/SceneAPI/AssetImporter/SkipAtomOutput=true\""])
        assert result, "Asset Processor Failed"

    def run_fbx_test(self, workspace, ap_setup_fixture, asset_processor,
                     project, blackbox_params: BlackboxAssetTest, overrideAsset=False):
        """
        These tests work by having the test case ingest the test data and determine the run pattern.
        Tests will process scene settings files and will additionally do a verification against a provided debug file
        Additionally, if an override is passed, the output is checked against the override.

        Test Steps:
        1. Create temporary test environment
        2. Process Assets
        3. Determine what assets to validate based upon test data
        4. Validate assets were created in cache
        5. If debug file provided, verify scene files were generated correctly
        6. Verify that each given source asset resulted in the expected jobs and products
        """

        test_assets_folder = blackbox_params.override_asset_folder if overrideAsset else blackbox_params.asset_folder
        logger.info(f"{blackbox_params.test_name}: Processing assets in folder '"
                    f"{test_assets_folder}' and verifying they match expected output.")

        # Prepare test environment and process assets
        if not overrideAsset:
            asset_processor.prepare_test_environment(ap_setup_fixture['tests_dir'], test_assets_folder)
        else:
            asset_processor.prepare_test_environment(ap_setup_fixture['tests_dir'], test_assets_folder,
                                                     use_current_root=True, add_scan_folder=False,
                                                     existing_function_name=blackbox_params.asset_folder)
        self.run_ap_debug_skip_atom_output(asset_processor)

        logger.info(f"Validating assets.")
        assetsToValidate = blackbox_params.override_assets if overrideAsset else blackbox_params.assets

        expected_product_list = []
        for expected_source in assetsToValidate:
            for expected_job in expected_source.jobs:
                for expected_product in expected_job.products:
                    expected_product_list.append(expected_product.product_name)

        missing_assets, _ = utils.compare_assets_with_cache(expected_product_list,
                                                            asset_processor.project_test_cache_folder())

        assert not missing_assets, \
            f'The following assets were expected to be in, but not found in cache: {str(missing_assets)}'

        # Load the asset database.
        db_path = os.path.join(asset_processor.temp_asset_root(), "Cache",
                               "assetdb.sqlite")
        cache_root = os.path.dirname(os.path.join(asset_processor.temp_asset_root(), "Cache",
                                                  ASSET_PROCESSOR_PLATFORM_MAP[workspace.asset_processor_platform]))

        if blackbox_params.scene_debug_file:
            scene_debug_file = blackbox_params.override_scene_debug_file if overrideAsset \
                else blackbox_params.scene_debug_file
            self.compare_scene_debug_file(asset_processor, scene_debug_file, blackbox_params.scene_debug_file)

            # Run again for the .dbgsg.xml file
            self.compare_scene_debug_file(asset_processor,
                                          scene_debug_file + ".xml",
                                          blackbox_params.scene_debug_file + ".xml")

        # Check that each given source asset resulted in the expected jobs and products.
        self.populate_asset_info(workspace, project, assetsToValidate)
        for expected_source in assetsToValidate:
            for job in expected_source.jobs:
                for product in job.products:
                    asset_db_utils.compare_expected_asset_to_actual_asset(db_path,
                                                                          expected_source,
                                                                          f"{blackbox_params.asset_folder}/"
                                                                          f"{expected_source.source_file_name}",
                                                                          cache_root)

    def test_FBX_ModifiedFBXFile_ConsistentProductOutput_OutputSucceeds(self, workspace, ap_setup_fixture,
                                                                            asset_processor):
        """
        Test verifies changing an FBX file with a custom .assetinfo file produces an expected output
        The .assetinfo file will remain unchanged.

        Test Steps:
            1. Create test environment with an FBX file and a custom .assetinfo file
            2. Launch Asset Processor
            3. Validate that Asset Processor generates the expected output
            4. Modify the FBX file
            5. Run asset processor
            6. Validate that Asset Processor generates the expected output
        """

        # Copying test assets to project folder
        asset_processor.prepare_test_environment(ap_setup_fixture["tests_dir"], "ModifiedFBXFile_ConsistentProductOutput")
        # Run AP against the FBX file and the .assetinfo file
        self.run_ap_debug_skip_atom_output(asset_processor)

        # Set path to expected dbgsg output, copied from test folder
        scene_debug_expected = os.path.join(asset_processor.project_test_source_folder(), "SceneDebug", "modifiedfbxfile.dbgsg")
        assert os.path.exists(scene_debug_expected), "Expected scene file missing in SceneDebug/modifiedfbxfile.dbgsg - Check test assets"

        # Set path to actual dbgsg output, obtained when running AP
        scene_debug_actual = os.path.join(asset_processor.temp_project_cache(asset_platform=ASSET_PROCESSOR_PLATFORM_MAP[workspace.asset_processor_platform]), "ModifiedFBXFile_ConsistentProductOutput","modifiedfbxfile.dbgsg")
        assert os.path.exists(scene_debug_actual)

        # Compare the dbgsg files to ensure expected outputs
        self.compare_scene_debug_file(asset_processor, scene_debug_expected, scene_debug_actual)

        # Run again for the .dbgsg.xml files
        self.compare_scene_debug_file(asset_processor, scene_debug_expected + ".xml", scene_debug_actual + ".xml")

        # Remove the files to be replaced from the source test asset folder
        filestoremove = [
            os.path.join(asset_processor.project_test_source_folder(),"ModifiedFBXFile.fbx"),
            scene_debug_expected,
            scene_debug_expected + ".xml"
        ]
        for file in filestoremove:
            os.remove(file)
            assert not os.path.exists(file), f"File failed to be removed: {file}"

        # Add the replacement FBX and expected dbgsg files into the test project
        source = os.path.join(ap_setup_fixture["tests_dir"], "Assets",
                              "Override_ModifiedFBXFile_ConsistentProductOutput")
        destination = asset_processor.project_test_source_folder()
        # Note: Replace distutils for shutil.copytree("src", "dst", dirs_exist_ok=True) once updated to Python 3.8
        distutils.dir_util.copy_tree(source, destination)
        assert os.path.exists(scene_debug_expected), \
            "Expected scene file missing in SceneDebug/modifiedfbxfile.dbgsg - Check test assets"

        # Run AP again to regenerate the .dbgsg files
        self.run_ap_debug_skip_atom_output(asset_processor)

        # Compare the new .dbgsg files with their expected outputs
        self.compare_scene_debug_file(asset_processor, scene_debug_expected, scene_debug_actual)

        # Run again for the .dbgsg.xml file
        self.compare_scene_debug_file(asset_processor, scene_debug_expected + ".xml", scene_debug_actual + ".xml")

    def test_FBX_MixedCaseFileExtension_OutputSucceeds(self, workspace, ap_setup_fixture, asset_processor):
        """
        Test verifies FBX file with any combination of mixed casing in its file extension produces the
        expected output.

        Test Steps:
            1. Create test environment with an FBX file
            2. Change the .fbx file extension casing
            2. Launch Asset Processor
            3. Validate that Asset Processor generates the expected output
            4. Modify the FBX file's extension to a different casing
            5. Run asset processor
            6. Validate that Asset Processor generates the expected output
        """

        extensionlist = [
            "OneMeshOneMaterial.Fbx",
            "OneMeshOneMaterial.fBX",
            "OneMeshOneMaterial.FBX",
        ]
        original_extension = "OneMeshOneMaterial.fbx"

        for extension in extensionlist:
            asset_processor.prepare_test_environment(ap_setup_fixture["tests_dir"], "OneMeshOneMaterial")
            rename_src = os.path.join(asset_processor.project_test_source_folder(), original_extension)
            rename_dst = os.path.join(asset_processor.project_test_source_folder(), extension)
            os.rename(rename_src, rename_dst)
            assert os.path.exists(rename_dst), "Expected test file missing"

            # Run AP while generating debug output and skipping atom output
            self.run_ap_debug_skip_atom_output(asset_processor)

            expectedassets = [
                'onemeshonematerial/onemeshonematerial.assetinfo.dbg',
                'onemeshonematerial/onemeshonematerial.dbgsg',
                'onemeshonematerial/onemeshonematerial.dbgsg.xml',
                'onemeshonematerial/onemeshonematerial_fbx.procprefab',
                'onemeshonematerial/onemeshonematerial_fbx.procprefab.json'
                ]

            missing_assets, _ = utils.compare_assets_with_cache(expectedassets,
                                                                asset_processor.project_test_cache_folder())

            assert not missing_assets, \
                f'The following assets were expected to be in when processing {extension}, but not found in cache: ' \
                f'{str(missing_assets)}'

            scene_debug_expected = os.path.join(asset_processor.project_test_source_folder(), "SceneDebug",
                                                "onemeshonematerial.dbgsg")
            assert os.path.exists(scene_debug_expected), \
                "Expected scene file missing in SceneDebug/onemeshonematerial.dbgsg - Check test assets"

            # Set path to actual dbgsg output, obtained when running AP
            scene_debug_actual = os.path.join(asset_processor.temp_project_cache(
                asset_platform=ASSET_PROCESSOR_PLATFORM_MAP[workspace.asset_processor_platform]),
                                              "onemeshonematerial", "onemeshonematerial.dbgsg")
            assert os.path.exists(scene_debug_actual), f"Scene debug output missing after running AP on {extension}."

            self.compare_scene_debug_file(asset_processor, scene_debug_expected, scene_debug_actual)

            # Run again for the .dbgsg.xml file
            self.compare_scene_debug_file(asset_processor,
                                          scene_debug_expected + ".xml",
                                          scene_debug_actual + ".xml")