birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
659e486cd791f7da4d1cf12fdd08fa2048bdb8b2
o3de/Code/Framework/AzToolsFramework/Tests/AssetSeedManager.cpp
T
moraaar 9e0b8c564d Fixed AzToolsFramework tests (#2887) 
* Fixed AzToolsFramework unit tests.

Signed-off-by: moraaar <moraaar@amazon.com>

* Include missing header.

Signed-off-by: moraaar <moraaar@amazon.com>

* Using util's class to generate temp directory, instead of qt.

Signed-off-by: moraaar <moraaar@amazon.com>

* Added empty line

Signed-off-by: moraaar <moraaar@amazon.com>

* Fixed warning in MessageTest fixture that CacheProjectRootFolder was not set

Signed-off-by: moraaar <moraaar@amazon.com>

* Additional checks in CreateDefaultEditorEntity helper function.

Signed-off-by: moraaar <moraaar@amazon.com>

* Updated the AzToolsFrameworkTest logic to set the project cache path

The Project Cache Path and Project Path is set through the CommandLine functionality of the ComponentApplication.
This allows those Project Cache Path and Project Path to be set within the Settings Registry during the ComponentApplication constructor

Removed the explicitly calls to delete the temporary directory and fixed the ScopedTemporaryDirectory class to recursively delete the temporary directory

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

* Setup correctly @assets@ alias for PlatformAddressedAssetCatalogManagerTest and AssetSeedManagerTest fixtures.

- These 2 test fixtures need to manually set the @asset@ alias to not include the platform at the end (which it does by default), because they are looping over platforms in their setup.
- Also initializing pointers to nullptr, so if setup fail in the future the teardown doesn't crash trying to delete garbage.

Signed-off-by: moraaar <moraaar@amazon.com>

Co-authored-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>
2021-08-06 11:07:15 -05:00

1018 lines
47 KiB
C++
Raw Blame History

/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#include <Asset/AssetDebugInfo.h>
#include <AzCore/UnitTest/TestTypes.h>
#include <AzToolsFramework/Asset/AssetSeedManager.h>
#include <AzFramework/Asset/AssetRegistry.h>
#include <AzCore/IO/FileIO.h>
#include <AzCore/Settings/SettingsRegistryMergeUtils.h>
#include <AzFramework/IO/LocalFileIO.h>
#include <AzFramework/Asset/AssetCatalog.h>
#include <AzFramework/StringFunc/StringFunc.h>
#include <Tests/AZTestShared/Utils/Utils.h>
#include <AzToolsFramework/Application/ToolsApplication.h>
#include <AzFramework/Platform/PlatformDefaults.h>
#include <AzToolsFramework/AssetCatalog/PlatformAddressedAssetCatalog.h>
#include <AzToolsFramework/UnitTest/ToolsTestApplication.h>
#include <AzCore/UserSettings/UserSettingsComponent.h>
#include <AzCore/Utils/Utils.h>
#include <AzTest/Utils.h>
#include <Utils/Utils.h>
namespace // anonymous
{
static const int s_totalAssets = 12;
static const int s_totalTestPlatforms = 2;
AZ::Data::AssetId assets[s_totalAssets];
const char TestSliceAssetPath[] = "test.slice";
const char SecondTestSliceAssetPath[] = "secondTest.slice";
const char TestDynamicSliceAssetPath[] = "test.dynamicslice";
bool Search(const AzToolsFramework::AssetFileInfoList& assetList, const AZ::Data::AssetId& assetId)
{
return AZStd::find_if(assetList.m_fileInfoList.begin(), assetList.m_fileInfoList.end(),
[&](AzToolsFramework::AssetFileInfo fileInfo)
{
return fileInfo.m_assetId == assetId;
});
}
}
namespace UnitTest
{
class AssetSeedManagerTest
: public AllocatorsFixture
, public AZ::Data::AssetCatalogRequestBus::Handler
{
public:
void SetUp() override
{
using namespace AZ::Data;
constexpr size_t MaxCommandArgsCount = 128;
using FixedValueString = AZ::SettingsRegistryInterface::FixedValueString;
using ArgumentContainer = AZStd::fixed_vector<char*, MaxCommandArgsCount>;
// The first command line argument is assumed to be the executable name so add a blank entry for it
ArgumentContainer argContainer{ {} };
// Append Command Line override for the Project Cache Path
AZ::IO::Path cacheProjectRootFolder{ m_tempDir.GetDirectory() };
auto projectCachePathOverride = FixedValueString::format(R"(--project-cache-path="%s")", cacheProjectRootFolder.c_str());
auto projectPathOverride = FixedValueString{ R"(--project-path=AutomatedTesting)" };
argContainer.push_back(projectCachePathOverride.data());
argContainer.push_back(projectPathOverride.data());
m_application = new ToolsTestApplication("AssetSeedManagerTest", aznumeric_caster(argContainer.size()), argContainer.data());
m_assetSeedManager = new AzToolsFramework::AssetSeedManager();
m_assetRegistry = new AzFramework::AssetRegistry();
m_application->Start(AzFramework::Application::Descriptor());
// By default @assets@ is setup to include the platform at the end. But this test is going to
// loop over platforms and it will be included as part of the relative path of the file.
// So the asset folder for these tests have to point to the cache project root folder, which
// doesn't include the platform.
AZ::IO::FileIOBase::GetInstance()->SetAlias("@assets@", cacheProjectRootFolder.c_str());
for (int idx = 0; idx < s_totalAssets; idx++)
{
assets[idx] = AssetId(AZ::Uuid::CreateRandom(), 0);
AZ::Data::AssetInfo info;
info.m_relativePath = AZStd::string::format("asset%d.txt", idx);
m_assetsPath[idx] = info.m_relativePath;
info.m_assetId = assets[idx];
m_assetRegistry->RegisterAsset(assets[idx], info);
}
m_testPlatforms[0] = AzFramework::PlatformId::PC;
m_testPlatforms[1] = AzFramework::PlatformId::ANDROID_ID;
int platformCount = 0;
for(auto thisPlatform : m_testPlatforms)
{
AZ::IO::Path assetRoot = AzToolsFramework::PlatformAddressedAssetCatalog::GetAssetRootForPlatform(thisPlatform);
for (int idx = 0; idx < s_totalAssets; idx++)
{
m_assetsPathFull[platformCount][idx] = (assetRoot / m_assetsPath[idx]).Native();
AZ_TEST_START_TRACE_SUPPRESSION;
if (m_fileStreams[platformCount][idx].Open(m_assetsPathFull[platformCount][idx].c_str(), AZ::IO::OpenMode::ModeWrite | AZ::IO::OpenMode::ModeBinary | AZ::IO::OpenMode::ModeCreatePath))
{
AZ::IO::SizeType bytesWritten = m_fileStreams[platformCount][idx].Write(m_assetsPath[idx].size(), m_assetsPath[idx].data());
EXPECT_EQ(bytesWritten, m_assetsPath[idx].size());
m_fileStreams[platformCount][idx].Close();
AZ_TEST_STOP_TRACE_SUPPRESSION(1); // writing to asset cache folder
}
else
{
GTEST_FATAL_FAILURE_(AZStd::string::format("Unable to create temporary file ( %s ) in AssetSeedManager unit tests.\n", m_assetsPath[idx].c_str()).c_str());
}
}
++platformCount;
}
AZ::Uuid sourceUUid = AZ::Uuid::CreateRandom();
AZ::Data::AssetId testSliceAsset = AZ::Data::AssetId(sourceUUid, 0);
AZ::Data::AssetId testDynamicSliceAsset = AZ::Data::AssetId(sourceUUid, 1);
AZ::Data::AssetId secondTestSliceAsset = AZ::Data::AssetId(AZ::Uuid::CreateRandom(), 0);
AZ::Data::AssetInfo dynamicSliceAssetInfo;
dynamicSliceAssetInfo.m_relativePath = TestDynamicSliceAssetPath;
dynamicSliceAssetInfo.m_assetId = testDynamicSliceAsset;
m_testDynamicSliceAssetId = testDynamicSliceAsset;
m_assetRegistry->RegisterAsset(testDynamicSliceAsset, dynamicSliceAssetInfo);
AZ_TEST_START_TRACE_SUPPRESSION;
AZ::IO::FileIOStream dynamicSliceFileIOStream(TestDynamicSliceAssetPath, AZ::IO::OpenMode::ModeWrite | AZ::IO::OpenMode::ModeText);
AZ_TEST_STOP_TRACE_SUPPRESSION(1); // writing to asset cache folder
AZ::Data::AssetInfo sliceAssetInfo;
sliceAssetInfo.m_relativePath = TestSliceAssetPath;
sliceAssetInfo.m_assetId = testSliceAsset;
m_assetRegistry->RegisterAsset(testSliceAsset, sliceAssetInfo);
AZ::Data::AssetInfo secondSliceAssetInfo;
secondSliceAssetInfo.m_relativePath = SecondTestSliceAssetPath;
secondSliceAssetInfo.m_assetId = secondTestSliceAsset;
m_assetRegistry->RegisterAsset(secondTestSliceAsset, secondSliceAssetInfo);
AZ_TEST_START_TRACE_SUPPRESSION;
AZ::IO::FileIOStream sliceFileIOStream(TestSliceAssetPath, AZ::IO::OpenMode::ModeWrite | AZ::IO::OpenMode::ModeText);
AZ_TEST_STOP_TRACE_SUPPRESSION(1); // writing to asset cache folder
// asset0 -> asset1 -> asset2 -> asset4
// --> asset3
m_assetRegistry->RegisterAssetDependency(assets[0], AZ::Data::ProductDependency(assets[1], 0));
m_assetRegistry->RegisterAssetDependency(assets[1], AZ::Data::ProductDependency(assets[2], 0));
m_assetRegistry->RegisterAssetDependency(assets[1], AZ::Data::ProductDependency(assets[3], 0));
m_assetRegistry->RegisterAssetDependency(assets[2], AZ::Data::ProductDependency(assets[4], 0));
// asset5 -> asset6 -> asset7
m_assetRegistry->RegisterAssetDependency(assets[5], AZ::Data::ProductDependency(assets[6], 0));
m_assetRegistry->RegisterAssetDependency(assets[6], AZ::Data::ProductDependency(assets[7], 0));
// asset8 -> asset6
m_assetRegistry->RegisterAssetDependency(assets[8], AZ::Data::ProductDependency(assets[6], 0));
// asset10 -> asset11
m_assetRegistry->RegisterAssetDependency(assets[10], AZ::Data::ProductDependency(assets[11], 0));
// asset11 -> asset10
m_assetRegistry->RegisterAssetDependency(assets[11], AZ::Data::ProductDependency(assets[10], 0));
// Without this, the user settings component would attempt to save on finalize/shutdown. Since the file is
// shared across the whole engine, if multiple tests are run in parallel, the saving could cause a crash
// in the unit tests.
AZ::UserSettingsComponentRequestBus::Broadcast(&AZ::UserSettingsComponentRequests::DisableSaveOnFinalize);
AZ::SerializeContext* context;
AZ::ComponentApplicationBus::BroadcastResult(context, &AZ::ComponentApplicationBus::Events::GetSerializeContext);
ASSERT_TRUE(context) << "No serialize context.\n";
AzToolsFramework::AssetSeedManager::Reflect(context);
// Asset Catalog does not exposes its internal asset registry and the only way to set it is through LoadCatalog API
// Currently i am serializing the asset registry to disk
// and invoking the LoadCatalog API to populate the asset catalog created by the azframework app.
bool useRequestBus = false;
AzFramework::AssetCatalog assetCatalog(useRequestBus);
AZStd::string pcCatalogFile = AzToolsFramework::PlatformAddressedAssetCatalog::GetCatalogRegistryPathForPlatform(AzFramework::PlatformId::PC);
AZStd::string androidCatalogFile = AzToolsFramework::PlatformAddressedAssetCatalog::GetCatalogRegistryPathForPlatform(AzFramework::PlatformId::ANDROID_ID);
if (!assetCatalog.SaveCatalog(pcCatalogFile.c_str(), m_assetRegistry))
{
GTEST_FATAL_FAILURE_(AZStd::string::format("Unable to save the asset catalog (PC) file.\n").c_str());
}
if (!assetCatalog.SaveCatalog(androidCatalogFile.c_str(), m_assetRegistry))
{
GTEST_FATAL_FAILURE_(AZStd::string::format("Unable to save the asset catalog (ANDROID) file.\n").c_str());
}
m_pcCatalog = new AzToolsFramework::PlatformAddressedAssetCatalog(AzFramework::PlatformId::PC);
m_androidCatalog = new AzToolsFramework::PlatformAddressedAssetCatalog(AzFramework::PlatformId::ANDROID_ID);
const AZStd::string engroot = AZ::Test::GetEngineRootPath();
AZ::IO::FileIOBase::GetInstance()->SetAlias("@engroot@", engroot.c_str());
AZ::IO::Path assetRoot(AZ::Utils::GetProjectPath());
assetRoot /= "Cache";
AZ::IO::FileIOBase::GetInstance()->SetAlias("@root@", assetRoot.c_str());
}
void TearDown() override
{
delete m_assetSeedManager;
delete m_assetRegistry;
delete m_pcCatalog;
delete m_androidCatalog;
m_application->Stop();
delete m_application;
}
AZ::Data::AssetInfo GetAssetInfoById(const AZ::Data::AssetId& id)
{
auto foundIter = m_assetRegistry->m_assetIdToInfo.find(id);
if (foundIter != m_assetRegistry->m_assetIdToInfo.end())
{
return foundIter->second;
}
return AZ::Data::AssetInfo();
}
void AssetSeedManager_SaveSeedListFile_FileIsReadOnly()
{
AZ::Test::ScopedAutoTempDirectory tempDir;
constexpr const char fileName[] = "ReadOnlyTestFile.seed";
AZStd::string filePath = tempDir.Resolve(fileName);
// Create the file
EXPECT_TRUE(m_assetSeedManager->Save(filePath));
// Mark the file Read-Only
AZ::IO::SystemFile::SetWritable(filePath.c_str(), false);
// Attempt to save to the same file. Should not be allowed.
AZ_TEST_START_TRACE_SUPPRESSION;
EXPECT_FALSE(m_assetSeedManager->Save(filePath));
AZ_TEST_STOP_TRACE_SUPPRESSION(1); // One error expected
// Clean up the test environment
AZ::IO::SystemFile::SetWritable(filePath.c_str(), true);
AZ::IO::SystemFile::Delete(filePath.c_str());
}
void AssetSeedManager_SaveAssetInfoFile_FileIsReadOnly()
{
AZ::Test::ScopedAutoTempDirectory tempDir;
constexpr const char fileName[] = "ReadOnlyTestFile.assetlist";
AZStd::string filePath = tempDir.Resolve(fileName);
// Add a single asset - empty asset list files don't save
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
// Create the file
EXPECT_TRUE(m_assetSeedManager->SaveAssetFileInfo(filePath, AzFramework::PlatformFlags::Platform_PC, {}));
// Mark the file Read-Only
AZ::IO::SystemFile::SetWritable(filePath.c_str(), false);
// Attempt to save to the same file. Should not be allowed.
AZ_TEST_START_TRACE_SUPPRESSION;
EXPECT_FALSE(m_assetSeedManager->SaveAssetFileInfo(filePath, AzFramework::PlatformFlags::Platform_PC, {}));
AZ_TEST_STOP_TRACE_SUPPRESSION(1); // One error expected
// Clean up the test environment
AZ::IO::SystemFile::SetWritable(filePath.c_str(), true);
AZ::IO::SystemFile::Delete(filePath.c_str());
}
void ValidateSeedFileExtension_CorrectFileExtension_ExpectSuccess()
{
AZStd::string path("some/test/path/file.seed");
AZ::Outcome<void, AZStd::string> validationOutcome = AzToolsFramework::AssetSeedManager::ValidateSeedFileExtension(path);
EXPECT_TRUE(validationOutcome.IsSuccess());
}
void ValidateSeedFileExtension_IncorrectFileExtension_ExpectFailure()
{
AZStd::string path("some/test/path/file.xml");
AZ::Outcome<void, AZStd::string> validationOutcome = AzToolsFramework::AssetSeedManager::ValidateSeedFileExtension(path);
EXPECT_FALSE(validationOutcome.IsSuccess());
}
void ValidateAssetListFileExtension_CorrectFileExtension_ExpectSuccess()
{
AZStd::string path("some/test/path/file.assetlist");
AZ::Outcome<void, AZStd::string> validationOutcome = AzToolsFramework::AssetFileInfoList::ValidateAssetListFileExtension(path);
EXPECT_TRUE(validationOutcome.IsSuccess());
}
void ValidateAssetListFileExtension_IncorrectFileExtension_ExpectFailure()
{
AZStd::string path("some/test/path/file.xml");
AZ::Outcome<void, AZStd::string> validationOutcome = AzToolsFramework::AssetFileInfoList::ValidateAssetListFileExtension(path);
EXPECT_FALSE(validationOutcome.IsSuccess());
}
void AddPlatformToAllSeeds_SeedsAreValidForPlatform_AllSeedsUpdated()
{
// Setup
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
m_assetSeedManager->AddSeedAsset(assets[1], AzFramework::PlatformFlags::Platform_PC);
m_assetSeedManager->AddSeedAsset(assets[2], AzFramework::PlatformFlags::Platform_PC);
// Step we are testing
m_assetSeedManager->AddPlatformToAllSeeds(AzFramework::PlatformId::ANDROID_ID);
// Verification
AzFramework::PlatformFlags expectedPlatformFlags = AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ANDROID;
for (const auto& seedInfo : m_assetSeedManager->GetAssetSeedList())
{
EXPECT_EQ(seedInfo.m_platformFlags, expectedPlatformFlags);
}
}
void AddPlatformToAllSeeds_NotAllSeedsAreValidForPlatform_InvalidSeedsNotChanged()
{
// Setup
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
m_assetSeedManager->AddSeedAsset(assets[1], AzFramework::PlatformFlags::Platform_PC);
m_androidCatalog->UnregisterAsset(assets[2]);
m_assetSeedManager->AddSeedAsset(assets[2], AzFramework::PlatformFlags::Platform_PC);
// Step we are testing
AZ_TEST_START_TRACE_SUPPRESSION;
m_assetSeedManager->AddPlatformToAllSeeds(AzFramework::PlatformId::ANDROID_ID);
AZ_TEST_STOP_TRACE_SUPPRESSION(1); // One error expected
// Verification
AzFramework::PlatformFlags expectedPlatformFlags = AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ANDROID;
for (const auto& seedInfo : m_assetSeedManager->GetAssetSeedList())
{
if (seedInfo.m_assetId == assets[2])
{
EXPECT_EQ(seedInfo.m_platformFlags, AzFramework::PlatformFlags::Platform_PC);
}
else
{
EXPECT_EQ(seedInfo.m_platformFlags, expectedPlatformFlags);
}
}
}
void RemovePlatformFromAllSeeds_PlatformIsPresentInAllSeeds_PlatformIsRemoved()
{
// Setup
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_ANDROID);
m_assetSeedManager->AddSeedAsset(assets[1], AzFramework::PlatformFlags::Platform_PC);
m_assetSeedManager->AddSeedAsset(assets[1], AzFramework::PlatformFlags::Platform_ANDROID);
m_assetSeedManager->AddSeedAsset(assets[2], AzFramework::PlatformFlags::Platform_PC);
m_assetSeedManager->AddSeedAsset(assets[2], AzFramework::PlatformFlags::Platform_ANDROID);
// Step we are testing
m_assetSeedManager->RemovePlatformFromAllSeeds(AzFramework::PlatformId::ANDROID_ID);
// Verification
for (const auto& seedInfo : m_assetSeedManager->GetAssetSeedList())
{
EXPECT_EQ(seedInfo.m_platformFlags, AzFramework::PlatformFlags::Platform_PC);
}
}
void RemovePlatformFromAllSeeds_SeedsOnlyHaveOnePlatform_SeedsAreNotChanged()
{
// Setup
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
m_assetSeedManager->AddSeedAsset(assets[1], AzFramework::PlatformFlags::Platform_PC);
m_assetSeedManager->AddSeedAsset(assets[2], AzFramework::PlatformFlags::Platform_PC);
// Step we are testing
m_assetSeedManager->RemovePlatformFromAllSeeds(AzFramework::PlatformId::PC);
// Verification
for (const auto& seedInfo : m_assetSeedManager->GetAssetSeedList())
{
EXPECT_EQ(seedInfo.m_platformFlags, AzFramework::PlatformFlags::Platform_PC);
}
}
void DependencyValidation_SingleAssetSeed_ListValid()
{
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
AzToolsFramework::AssetFileInfoList assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList.m_fileInfoList.size(), 5);
EXPECT_TRUE(Search(assetList, assets[0]));
EXPECT_TRUE(Search(assetList, assets[1]));
EXPECT_TRUE(Search(assetList, assets[2]));
EXPECT_TRUE(Search(assetList, assets[3]));
EXPECT_TRUE(Search(assetList, assets[4]));
m_assetSeedManager->RemoveSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
m_assetSeedManager->AddSeedAsset(assets[5], AzFramework::PlatformFlags::Platform_PC);
assetList.m_fileInfoList.clear();
assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList.m_fileInfoList.size(), 3);
EXPECT_TRUE(Search(assetList, assets[5]));
EXPECT_TRUE(Search(assetList, assets[6]));
EXPECT_TRUE(Search(assetList, assets[7]));
m_assetSeedManager->RemoveSeedAsset(assets[5], AzFramework::PlatformFlags::Platform_PC);
m_assetSeedManager->AddSeedAsset(assets[8], AzFramework::PlatformFlags::Platform_PC);
assetList.m_fileInfoList.clear();
assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList.m_fileInfoList.size(), 3);
EXPECT_TRUE(Search(assetList, assets[6]));
EXPECT_TRUE(Search(assetList, assets[7]));
EXPECT_TRUE(Search(assetList, assets[8]));
assetList.m_fileInfoList.clear();
m_assetSeedManager->RemoveSeedAsset(assets[8], AzFramework::PlatformFlags::Platform_PC);
m_assetSeedManager->AddSeedAsset(assets[9], AzFramework::PlatformFlags::Platform_PC);
assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList.m_fileInfoList.size(), 1);
}
void DependencyValidation_MultipleAssetSeed_ListValid()
{
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
m_assetSeedManager->AddSeedAsset(assets[5], AzFramework::PlatformFlags::Platform_PC);
AzToolsFramework::AssetFileInfoList assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList.m_fileInfoList.size(), 8);
EXPECT_TRUE(Search(assetList, assets[0]));
EXPECT_TRUE(Search(assetList, assets[1]));
EXPECT_TRUE(Search(assetList, assets[2]));
EXPECT_TRUE(Search(assetList, assets[3]));
EXPECT_TRUE(Search(assetList, assets[4]));
EXPECT_TRUE(Search(assetList, assets[5]));
EXPECT_TRUE(Search(assetList, assets[6]));
EXPECT_TRUE(Search(assetList, assets[7]));
assetList.m_fileInfoList.clear();
m_assetSeedManager->AddSeedAsset(assets[8], AzFramework::PlatformFlags::Platform_PC);
assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList.m_fileInfoList.size(), 9);
EXPECT_TRUE(Search(assetList, assets[0]));
EXPECT_TRUE(Search(assetList, assets[1]));
EXPECT_TRUE(Search(assetList, assets[2]));
EXPECT_TRUE(Search(assetList, assets[3]));
EXPECT_TRUE(Search(assetList, assets[4]));
EXPECT_TRUE(Search(assetList, assets[5]));
EXPECT_TRUE(Search(assetList, assets[6]));
EXPECT_TRUE(Search(assetList, assets[7]));
EXPECT_TRUE(Search(assetList, assets[8]));
assetList.m_fileInfoList.clear();
m_assetSeedManager->RemoveSeedAsset(assets[5], AzFramework::PlatformFlags::Platform_PC);
assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList.m_fileInfoList.size(), 8);
EXPECT_TRUE(Search(assetList, assets[0]));
EXPECT_TRUE(Search(assetList, assets[1]));
EXPECT_TRUE(Search(assetList, assets[2]));
EXPECT_TRUE(Search(assetList, assets[3]));
EXPECT_TRUE(Search(assetList, assets[4]));
EXPECT_TRUE(Search(assetList, assets[6]));
EXPECT_TRUE(Search(assetList, assets[7]));
EXPECT_TRUE(Search(assetList, assets[8]));
}
void DependencyValidation_MultipleAssetSeeds_MultiplePlatformFlags_ListValid()
{
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ANDROID);
m_assetSeedManager->AddSeedAsset(assets[5], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ANDROID);
AzToolsFramework::AssetFileInfoList assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList.m_fileInfoList.size(), 8);
EXPECT_TRUE(Search(assetList, assets[0]));
EXPECT_TRUE(Search(assetList, assets[1]));
EXPECT_TRUE(Search(assetList, assets[2]));
EXPECT_TRUE(Search(assetList, assets[3]));
EXPECT_TRUE(Search(assetList, assets[4]));
EXPECT_TRUE(Search(assetList, assets[5]));
EXPECT_TRUE(Search(assetList, assets[6]));
EXPECT_TRUE(Search(assetList, assets[7]));
assetList.m_fileInfoList.clear();
m_assetSeedManager->AddSeedAsset(assets[8], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ANDROID);
assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList.m_fileInfoList.size(), 9);
EXPECT_TRUE(Search(assetList, assets[0]));
EXPECT_TRUE(Search(assetList, assets[1]));
EXPECT_TRUE(Search(assetList, assets[2]));
EXPECT_TRUE(Search(assetList, assets[3]));
EXPECT_TRUE(Search(assetList, assets[4]));
EXPECT_TRUE(Search(assetList, assets[5]));
EXPECT_TRUE(Search(assetList, assets[6]));
EXPECT_TRUE(Search(assetList, assets[7]));
EXPECT_TRUE(Search(assetList, assets[8]));
assetList.m_fileInfoList.clear();
m_assetSeedManager->RemoveSeedAsset(assets[5], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ANDROID);
assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList.m_fileInfoList.size(), 8);
EXPECT_TRUE(Search(assetList, assets[0]));
EXPECT_TRUE(Search(assetList, assets[1]));
EXPECT_TRUE(Search(assetList, assets[2]));
EXPECT_TRUE(Search(assetList, assets[3]));
EXPECT_TRUE(Search(assetList, assets[4]));
EXPECT_TRUE(Search(assetList, assets[6]));
EXPECT_TRUE(Search(assetList, assets[7]));
EXPECT_TRUE(Search(assetList, assets[8]));
// Removing the android flag from the asset should still produce the same result
m_assetSeedManager->RemoveSeedAsset(assets[8], AzFramework::PlatformFlags::Platform_ANDROID);
assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList.m_fileInfoList.size(), 8);
EXPECT_TRUE(Search(assetList, assets[0]));
EXPECT_TRUE(Search(assetList, assets[1]));
EXPECT_TRUE(Search(assetList, assets[2]));
EXPECT_TRUE(Search(assetList, assets[3]));
EXPECT_TRUE(Search(assetList, assets[4]));
EXPECT_TRUE(Search(assetList, assets[6]));
EXPECT_TRUE(Search(assetList, assets[7]));
EXPECT_TRUE(Search(assetList, assets[8]));
assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::ANDROID_ID);
EXPECT_EQ(assetList.m_fileInfoList.size(), 5);
EXPECT_TRUE(Search(assetList, assets[0]));
EXPECT_TRUE(Search(assetList, assets[1]));
EXPECT_TRUE(Search(assetList, assets[2]));
EXPECT_TRUE(Search(assetList, assets[3]));
EXPECT_TRUE(Search(assetList, assets[4]));
// Adding the android flag again to the asset
m_assetSeedManager->AddSeedAsset(assets[8], AzFramework::PlatformFlags::Platform_ANDROID);
assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::ANDROID_ID);
EXPECT_EQ(assetList.m_fileInfoList.size(), 8);
EXPECT_TRUE(Search(assetList, assets[0]));
EXPECT_TRUE(Search(assetList, assets[1]));
EXPECT_TRUE(Search(assetList, assets[2]));
EXPECT_TRUE(Search(assetList, assets[3]));
EXPECT_TRUE(Search(assetList, assets[4]));
EXPECT_TRUE(Search(assetList, assets[6]));
EXPECT_TRUE(Search(assetList, assets[7]));
EXPECT_TRUE(Search(assetList, assets[8]));
}
void DependencyValidation_EmptyAssetSeed_ListValid()
{
AzToolsFramework::AssetFileInfoList assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList.m_fileInfoList.size(), 0);
}
void DependencyValidation_CyclicAssetSeedDependency_ListValid()
{
m_assetSeedManager->AddSeedAsset(assets[10], AzFramework::PlatformFlags::Platform_PC);
m_assetSeedManager->AddSeedAsset(assets[11], AzFramework::PlatformFlags::Platform_PC);
AzToolsFramework::AssetFileInfoList assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList.m_fileInfoList.size(), 2);
EXPECT_TRUE(Search(assetList, assets[10]));
EXPECT_TRUE(Search(assetList, assets[11]));
}
void FileModTimeValidation_SingleAssetSeed_ModTimeChanged()
{
int fileIndex = 4;
m_assetSeedManager->AddSeedAsset(assets[fileIndex], AzFramework::PlatformFlags::Platform_PC);
AzToolsFramework::AssetFileInfoList assetList1 = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList1.m_fileInfoList.size(), 1);
EXPECT_TRUE(Search(assetList1, assets[fileIndex]));
AZ_TEST_START_TRACE_SUPPRESSION;
if (m_fileStreams[0][fileIndex].Open(m_assetsPathFull[0][fileIndex].c_str(), AZ::IO::OpenMode::ModeWrite | AZ::IO::OpenMode::ModeBinary | AZ::IO::OpenMode::ModeCreatePath))
{
AZStd::string fileContent = AZStd::string::format("asset%d.txt", fileIndex);
AZ::IO::SizeType bytesWritten = m_fileStreams[0][fileIndex].Write(fileContent.size(), fileContent.c_str());
EXPECT_EQ(bytesWritten, fileContent.size());
m_fileStreams[0][fileIndex].Close();
AZ_TEST_STOP_TRACE_SUPPRESSION(1); // writing to asset cache folder
}
AzToolsFramework::AssetFileInfoList assetList2 = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList2.m_fileInfoList.size(), 1);
EXPECT_TRUE(Search(assetList2, assets[fileIndex]));
EXPECT_EQ(assetList1.m_fileInfoList[0].m_assetId, assetList2.m_fileInfoList[0].m_assetId);
EXPECT_GE(assetList2.m_fileInfoList[0].m_modificationTime, assetList1.m_fileInfoList[0].m_modificationTime); // file mod time should change
// file hash should not change
for (int idx = 0; idx < 5; idx++)
{
EXPECT_EQ(assetList1.m_fileInfoList[0].m_hash[idx], assetList2.m_fileInfoList[0].m_hash[idx]);
}
}
void FileHashValidation_SingleAssetSeed_FileHashChanged()
{
int fileIndex = 4;
m_assetSeedManager->AddSeedAsset(assets[fileIndex], AzFramework::PlatformFlags::Platform_PC);
AzToolsFramework::AssetFileInfoList assetList1 = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList1.m_fileInfoList.size(), 1);
EXPECT_TRUE(Search(assetList1, assets[fileIndex]));
AZ_TEST_START_TRACE_SUPPRESSION;
if (m_fileStreams[0][fileIndex].Open(m_assetsPathFull[0][fileIndex].c_str(), AZ::IO::OpenMode::ModeWrite | AZ::IO::OpenMode::ModeBinary | AZ::IO::OpenMode::ModeCreatePath))
{
AZStd::string fileContent = AZStd::string::format("asset%d.txt", fileIndex + 1);// changing file content
AZ::IO::SizeType bytesWritten = m_fileStreams[0][fileIndex].Write(fileContent.size(), fileContent.c_str());
EXPECT_EQ(bytesWritten, fileContent.size());
m_fileStreams[0][fileIndex].Close();
AZ_TEST_STOP_TRACE_SUPPRESSION(1); // writing to asset cache folder
}
AzToolsFramework::AssetFileInfoList assetList2 = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
EXPECT_EQ(assetList2.m_fileInfoList.size(), 1);
EXPECT_TRUE(Search(assetList2, assets[fileIndex]));
EXPECT_EQ(assetList1.m_fileInfoList[0].m_assetId, assetList2.m_fileInfoList[0].m_assetId);
EXPECT_GE(assetList2.m_fileInfoList[0].m_modificationTime, assetList1.m_fileInfoList[0].m_modificationTime);
bool fileHashDifferent = false;
// file hash should change since we have modified the file content.
for (int idx = 0; idx < 5; idx++)
{
if (assetList1.m_fileInfoList[0].m_hash[idx] != assetList2.m_fileInfoList[0].m_hash[idx])
{
fileHashDifferent = true;
break;
}
}
EXPECT_TRUE(fileHashDifferent);
}
void SeedFilePath_UpdatePath_Valid()
{
int validFileIndex = 4;
int invalidFileIndex = 5;
m_assetSeedManager->AddSeedAsset(assets[validFileIndex], AzFramework::PlatformFlags::Platform_PC, m_assetsPath[invalidFileIndex]);
const AzFramework::AssetSeedList& oldSeedList = m_assetSeedManager->GetAssetSeedList();
for (const auto& seedInfo : oldSeedList)
{
if (seedInfo.m_assetId == assets[validFileIndex])
{
EXPECT_EQ(seedInfo.m_assetRelativePath, m_assetsPath[invalidFileIndex]);
}
}
m_assetSeedManager->UpdateSeedPath();
const AzFramework::AssetSeedList& newSeedList = m_assetSeedManager->GetAssetSeedList();
for (const auto& seedInfo : newSeedList)
{
if (seedInfo.m_assetId == assets[validFileIndex])
{
EXPECT_EQ(seedInfo.m_assetRelativePath, m_assetsPath[validFileIndex]);
}
}
}
void SeedFilePath_RemovePath_Valid()
{
m_assetSeedManager->RemoveSeedPath();
const AzFramework::AssetSeedList& seedList = m_assetSeedManager->GetAssetSeedList();
for (const auto& seedInfo : seedList)
{
EXPECT_TRUE(seedInfo.m_assetRelativePath.empty());
}
}
void RemoveSeed_ByAssetId_Valid()
{
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
m_assetSeedManager->RemoveSeedAsset(assets[0].ToString<AZStd::string>(), AzFramework::PlatformFlags::Platform_PC);
const AzFramework::AssetSeedList& seedList = m_assetSeedManager->GetAssetSeedList();
EXPECT_EQ(seedList.size(), 0);
}
void RemoveSeed_ByAssetHint_Valid()
{
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
m_pcCatalog->UnregisterAsset(assets[0]); // Unregister the asset from the asset catalog
m_assetSeedManager->RemoveSeedAsset(m_assetsPath[0], AzFramework::PlatformFlags::Platform_PC);
const AzFramework::AssetSeedList& seedList = m_assetSeedManager->GetAssetSeedList();
EXPECT_EQ(seedList.size(), 0);
}
void AddSourceAsset_AddRuntimeAsset_Valid()
{
m_assetSeedManager->AddSeedAsset(TestSliceAssetPath, AzFramework::PlatformFlags::Platform_PC);
const AzFramework::AssetSeedList& seedList = m_assetSeedManager->GetAssetSeedList();
EXPECT_EQ(seedList.size(), 1);
EXPECT_EQ(seedList[0].m_assetRelativePath, TestDynamicSliceAssetPath);
}
void AddSourceAsset_NoRuntimeSlice_Valid()
{
m_assetSeedManager->AddSeedAsset(SecondTestSliceAssetPath, AzFramework::PlatformFlags::Platform_PC);
const AzFramework::AssetSeedList& seedList = m_assetSeedManager->GetAssetSeedList();
EXPECT_EQ(seedList.size(), 0);
}
AzToolsFramework::AssetSeedManager* m_assetSeedManager = nullptr;
AzFramework::AssetRegistry* m_assetRegistry = nullptr;
ToolsTestApplication* m_application = nullptr;
AzToolsFramework::PlatformAddressedAssetCatalog* m_pcCatalog = nullptr;
AzToolsFramework::PlatformAddressedAssetCatalog* m_androidCatalog = nullptr;
AZ::IO::FileIOStream m_fileStreams[s_totalTestPlatforms][s_totalAssets];
AzFramework::PlatformId m_testPlatforms[s_totalTestPlatforms];
AZStd::string m_assetsPath[s_totalAssets];
AZStd::string m_assetsPathFull[s_totalTestPlatforms][s_totalAssets];
AZ::Data::AssetId m_testDynamicSliceAssetId;
UnitTest::ScopedTemporaryDirectory m_tempDir;
};
TEST_F(AssetSeedManagerTest, AssetSeedManager_SaveSeedListFile_FileIsReadOnly)
{
AssetSeedManager_SaveSeedListFile_FileIsReadOnly();
}
TEST_F(AssetSeedManagerTest, AssetSeedManager_SaveAssetInfoFile_FileIsReadOnly)
{
AssetSeedManager_SaveAssetInfoFile_FileIsReadOnly();
}
TEST_F(AssetSeedManagerTest, ValidateSeedFileExtension_CorrectFileExtension_ExpectSuccess)
{
ValidateSeedFileExtension_CorrectFileExtension_ExpectSuccess();
}
TEST_F(AssetSeedManagerTest, ValidateSeedFileExtension_IncorrectFileExtension_ExpectFailure)
{
ValidateSeedFileExtension_IncorrectFileExtension_ExpectFailure();
}
TEST_F(AssetSeedManagerTest, ValidateAssetListFileExtension_CorrectFileExtension_ExpectSuccess)
{
ValidateAssetListFileExtension_CorrectFileExtension_ExpectSuccess();
}
TEST_F(AssetSeedManagerTest, ValidateAssetListFileExtension_IncorrectFileExtension_ExpectFailure)
{
ValidateAssetListFileExtension_IncorrectFileExtension_ExpectFailure();
}
TEST_F(AssetSeedManagerTest, AddPlatformToAllSeeds_SeedsAreValidForPlatform_AllSeedsUpdated)
{
AddPlatformToAllSeeds_SeedsAreValidForPlatform_AllSeedsUpdated();
}
TEST_F(AssetSeedManagerTest, AddPlatformToAllSeeds_NotAllSeedsAreValidForPlatform_InvalidSeedsNotChanged)
{
AddPlatformToAllSeeds_NotAllSeedsAreValidForPlatform_InvalidSeedsNotChanged();
}
TEST_F(AssetSeedManagerTest, RemovePlatformFromAllSeeds_PlatformIsPresentInAllSeeds_PlatformIsRemoved)
{
RemovePlatformFromAllSeeds_PlatformIsPresentInAllSeeds_PlatformIsRemoved();
}
TEST_F(AssetSeedManagerTest, RemovePlatformFromAllSeeds_SeedsOnlyHaveOnePlatform_SeedsAreNotChanged)
{
RemovePlatformFromAllSeeds_SeedsOnlyHaveOnePlatform_SeedsAreNotChanged();
}
TEST_F(AssetSeedManagerTest, DependencyValidation_EmptyAssetSeed_ListValid)
{
DependencyValidation_EmptyAssetSeed_ListValid();
}
TEST_F(AssetSeedManagerTest, DependencyValidation_SingleAssetSeed_ListValid)
{
DependencyValidation_SingleAssetSeed_ListValid();
}
TEST_F(AssetSeedManagerTest, DependencyValidation_MultipleAssetSeeds_MultiplePlatformFlags_ListValid)
{
DependencyValidation_MultipleAssetSeeds_MultiplePlatformFlags_ListValid();
}
TEST_F(AssetSeedManagerTest, DependencyValidation_MultipleAssetSeed_ListValid)
{
DependencyValidation_MultipleAssetSeed_ListValid();
}
TEST_F(AssetSeedManagerTest, FileModTimeValidation_SingleAssetSeed_ModTimeChanged)
{
FileModTimeValidation_SingleAssetSeed_ModTimeChanged();
}
TEST_F(AssetSeedManagerTest, FileHashValidation_SingleAssetSeed_FileHashChanged)
{
FileHashValidation_SingleAssetSeed_FileHashChanged();
}
TEST_F(AssetSeedManagerTest, SeedFilePath_UpdatePath_Valid)
{
SeedFilePath_UpdatePath_Valid();
}
TEST_F(AssetSeedManagerTest, SeedFilePath_RemovePath_Valid)
{
SeedFilePath_RemovePath_Valid();
}
TEST_F(AssetSeedManagerTest, RemoveSeed_ByAssetId_Valid)
{
RemoveSeed_ByAssetId_Valid();
}
TEST_F(AssetSeedManagerTest, RemoveSeed_ByAssetHint_Valid)
{
RemoveSeed_ByAssetHint_Valid();
}
TEST_F(AssetSeedManagerTest, AddSourceAsset_AddRuntimeAsset_Valid)
{
AddSourceAsset_AddRuntimeAsset_Valid();
}
TEST_F(AssetSeedManagerTest, AddSourceAsset_NoRuntimeSlice_Valid)
{
AddSourceAsset_NoRuntimeSlice_Valid();
}
TEST_F(AssetSeedManagerTest, GetDependencyList_ExcludeAsset_IncludesOnlyExpected)
{
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
AzToolsFramework::AssetFileInfoList assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC, {assets[1]});
ASSERT_EQ(assetList.m_fileInfoList.size(), 1);
EXPECT_TRUE(Search(assetList, assets[0]));
}
TEST_F(AssetSeedManagerTest, GetDependencyList_ExcludeAssetDebugList_IncludesOnlyExpected)
{
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
AzToolsFramework::AssetFileDebugInfoList debugList;
AzToolsFramework::AssetFileInfoList assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC, { assets[1] }, &debugList);
ASSERT_EQ(assetList.m_fileInfoList.size(), 1);
EXPECT_TRUE(Search(assetList, assets[0]));
}
TEST_F(AssetSeedManagerTest, GetDependencyList_ExcludeSeed_ExcludesEverything)
{
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
AzToolsFramework::AssetFileInfoList assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC, { assets[0] });
ASSERT_EQ(assetList.m_fileInfoList.size(), 0);
}
TEST_F(AssetSeedManagerTest, GetDependencyList_ExcludeSeedDebugList_ExcludesEverything)
{
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
AzToolsFramework::AssetFileDebugInfoList debugList;
AzToolsFramework::AssetFileInfoList assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC, { assets[0] }, &debugList);
ASSERT_EQ(assetList.m_fileInfoList.size(), 0);
}
TEST_F(AssetSeedManagerTest, AddSeedAssetForValidPlatforms_AllPlatformsValid_SeedAddedForEveryInputPlatform)
{
using namespace AzFramework;
PlatformFlags validPlatforms = PlatformFlags::Platform_PC | PlatformFlags::Platform_ANDROID;
AZStd::pair<AZ::Data::AssetId, PlatformFlags> result = m_assetSeedManager->AddSeedAssetForValidPlatforms(TestDynamicSliceAssetPath, validPlatforms);
// Verify the function outputs
EXPECT_EQ(m_testDynamicSliceAssetId, result.first);
EXPECT_EQ(validPlatforms, result.second);
// Verify the Seed List
const AssetSeedList& seedList = m_assetSeedManager->GetAssetSeedList();
ASSERT_FALSE(seedList.empty());
EXPECT_EQ(m_testDynamicSliceAssetId, seedList.at(0).m_assetId);
EXPECT_EQ(validPlatforms, seedList.at(0).m_platformFlags);
}
TEST_F(AssetSeedManagerTest, AddSeedAssetForValidPlatforms_SomePlatformsValid_SeedAddedForEveryValidPlatform)
{
using namespace AzFramework;
PlatformFlags validPlatforms = PlatformFlags::Platform_PC | PlatformFlags::Platform_ANDROID;
PlatformFlags inputPlatforms = validPlatforms | PlatformFlags::Platform_MAC;
AZStd::pair<AZ::Data::AssetId, PlatformFlags> result = m_assetSeedManager->AddSeedAssetForValidPlatforms(TestDynamicSliceAssetPath, inputPlatforms);
// Verify the function outputs
EXPECT_EQ(m_testDynamicSliceAssetId, result.first);
EXPECT_EQ(validPlatforms, result.second);
// Verify the Seed List
const AssetSeedList& seedList = m_assetSeedManager->GetAssetSeedList();
ASSERT_FALSE(seedList.empty());
EXPECT_EQ(m_testDynamicSliceAssetId, seedList.at(0).m_assetId);
EXPECT_EQ(validPlatforms, seedList.at(0).m_platformFlags);
}
TEST_F(AssetSeedManagerTest, AddSeedAssetForValidPlatforms_NoPlatformsValid_NoSeedAdded)
{
using namespace AzFramework;
PlatformFlags inputPlatforms = PlatformFlags::Platform_MAC;
AZStd::pair<AZ::Data::AssetId, PlatformFlags> result = m_assetSeedManager->AddSeedAssetForValidPlatforms(TestDynamicSliceAssetPath, inputPlatforms);
// Verify the function outputs
EXPECT_FALSE(result.first.IsValid());
EXPECT_EQ(PlatformFlags::Platform_NONE, result.second);
// Verify the Seed List
const AssetSeedList& seedList = m_assetSeedManager->GetAssetSeedList();
EXPECT_TRUE(seedList.empty());
}
TEST_F(AssetSeedManagerTest, Valid_Seed_Remove_ForAllPlatform_OK)
{
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
m_assetSeedManager->RemoveSeedAsset(assets[0].ToString<AZStd::string>(), AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
const AzFramework::AssetSeedList& seedList = m_assetSeedManager->GetAssetSeedList();
EXPECT_EQ(seedList.size(), 0);
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
m_assetSeedManager->RemoveSeedAsset("asset0.txt", AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
const AzFramework::AssetSeedList& secondSeedList = m_assetSeedManager->GetAssetSeedList();
EXPECT_EQ(secondSeedList.size(), 0);
}
TEST_F(AssetSeedManagerTest, Valid_Seed_Remove_ForSpecificPlatform_OK)
{
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
m_assetSeedManager->RemoveSeedAsset(assets[0].ToString<AZStd::string>(), AzFramework::PlatformFlags::Platform_MAC);
const AzFramework::AssetSeedList& seedList = m_assetSeedManager->GetAssetSeedList();
EXPECT_EQ(seedList.size(), 1);
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
m_assetSeedManager->RemoveSeedAsset("asset0.txt", AzFramework::PlatformFlags::Platform_PC);
const AzFramework::AssetSeedList& secondSeedList = m_assetSeedManager->GetAssetSeedList();
EXPECT_EQ(secondSeedList.size(), 1);
}
TEST_F(AssetSeedManagerTest, Invalid_NotRemove_SeedForAllPlatform_Ok)
{
m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
m_assetSeedManager->RemoveSeedAsset(assets[1].ToString<AZStd::string>(), AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
const AzFramework::AssetSeedList& seedList = m_assetSeedManager->GetAssetSeedList();
EXPECT_EQ(seedList.size(), 1);
m_assetSeedManager->RemoveSeedAsset("asset1.txt", AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
const AzFramework::AssetSeedList& secondSeedList = m_assetSeedManager->GetAssetSeedList();
EXPECT_EQ(secondSeedList.size(), 1);
}
}
Reference in New Issue View Git Blame Copy Permalink