birkeh
/
o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
development
monroegm-disable-blank-issue-2
main
2111.2
2111.1
2107.1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'f1b688f435'
${ noResults }
o3de/Code/Framework/AzToolsFramework/Tests/AssetSeedManager.cpp

1032 lines
46 KiB
C++
Raw Blame History

/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#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>
namespace // anonymous
{
static const int s_totalAssets = 12;
static const int s_totalTestPlatforms = 2;
const char* s_catalogFile = "AssetCatalog.xml";
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;
m_application = new ToolsTestApplication("AssetSeedManagerTest");
m_assetSeedManager = new AzToolsFramework::AssetSeedManager();
m_assetRegistry = new AzFramework::AssetRegistry();
AZ::SettingsRegistryInterface* registry = AZ::SettingsRegistry::Get();
auto projectPathKey =
AZ::SettingsRegistryInterface::FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
registry->Set(projectPathKey, "AutomatedTesting");
AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*registry);
m_application->Start(AzFramework::Application::Descriptor());
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)
{
AZStd::string assetRoot = AzToolsFramework::PlatformAddressedAssetCatalog::GetAssetRootForPlatform(thisPlatform);
for (int idx = 0; idx < s_totalAssets; idx++)
{
AzFramework::StringFunc::Path::Join(assetRoot.c_str(), m_assetsPath[idx].c_str(), m_assetsPathFull[platformCount][idx]);
if (m_fileStreams[platformCount][idx].Open(m_assetsPathFull[platformCount][idx].c_str(), AZ::IO::OpenMode::ModeWrite | AZ::IO::OpenMode::ModeBinary | AZ::IO::OpenMode::ModeCreatePath))
{
m_fileStreams[platformCount][idx].Write(m_assetsPath[idx].size(), m_assetsPath[idx].data());
m_fileStreams[platformCount][idx].Close();
}
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::IO::FileIOStream dynamicSliceFileIOStream(TestDynamicSliceAssetPath, AZ::IO::OpenMode::ModeWrite | AZ::IO::OpenMode::ModeText);
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::IO::FileIOStream sliceFileIOStream(TestSliceAssetPath, AZ::IO::OpenMode::ModeWrite | AZ::IO::OpenMode::ModeText);
// 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
{
AZ::IO::FileIOBase* fileIO = AZ::IO::FileIOBase::GetInstance();
if (fileIO->Exists(s_catalogFile))
{
fileIO->Remove(s_catalogFile);
}
for (size_t platformCount = 0; platformCount < s_totalTestPlatforms; ++platformCount)
{
// Deleting all the temporary files
for (int idx = 0; idx < s_totalAssets; idx++)
{
// we need to close the handle before we try to remove the file
if (fileIO->Exists(m_assetsPathFull[platformCount][idx].c_str()))
{
fileIO->Remove(m_assetsPathFull[platformCount][idx].c_str());
}
}
}
if (fileIO->Exists(TestSliceAssetPath))
{
fileIO->Remove(TestSliceAssetPath);
}
if (fileIO->Exists(TestDynamicSliceAssetPath))
{
fileIO->Remove(TestDynamicSliceAssetPath);
}
auto pcCatalogFile = AzToolsFramework::PlatformAddressedAssetCatalog::GetCatalogRegistryPathForPlatform(AzFramework::PlatformId::PC);
auto androidCatalogFile = AzToolsFramework::PlatformAddressedAssetCatalog::GetCatalogRegistryPathForPlatform(AzFramework::PlatformId::ANDROID_ID);
if (fileIO->Exists(pcCatalogFile.c_str()))
{
fileIO->Remove(pcCatalogFile.c_str());
}
if (fileIO->Exists(androidCatalogFile.c_str()))
{
fileIO->Remove(androidCatalogFile.c_str());
}
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.
EXPECT_FALSE(m_assetSeedManager->Save(filePath));
// 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.
EXPECT_FALSE(m_assetSeedManager->SaveAssetFileInfo(filePath, AzFramework::PlatformFlags::Platform_PC, {}));
// 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
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())
{
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]));
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);
m_fileStreams[0][fileIndex].Write(fileContent.size(), fileContent.c_str());
m_fileStreams[0][fileIndex].Close();
}
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]));
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
m_fileStreams[0][fileIndex].Write(fileContent.size(), fileContent.c_str());
m_fileStreams[0][fileIndex].Close();
}
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;
AzFramework::AssetRegistry* m_assetRegistry;
ToolsTestApplication* m_application;
AzToolsFramework::PlatformAddressedAssetCatalog* m_pcCatalog;
AzToolsFramework::PlatformAddressedAssetCatalog* m_androidCatalog;
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;
};
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