public void ResourcesEntry_AddsCorrectTreeViewItem_ForSubobjects()
{
using (new HideResourceFoldersScope())
{
//Setup
string assetPath = "SubFolder/Cube.prefab";
int builtInPackagesResourcesCount = ResourcesTestUtility.GetResourcesEntryCount(Settings, true);
CreatePrefabInResourcesSubFolder(assetPath);
AddressableAssetEntryTreeView treeView = new AddressableAssetEntryTreeView(
new TreeViewState(),
new MultiColumnHeaderState(new MultiColumnHeaderState.Column[1]),
new AddressableAssetsSettingsGroupEditor(new AddressableAssetsWindow()));
//Test
AddressableAssetEntry entry = Settings.FindAssetEntry("Resources");
AssetEntryTreeViewItem treeViewItem = new AssetEntryTreeViewItem(entry, 0);
treeView.RecurseEntryChildren(entry, treeViewItem, 0);
//Assert
Assert.AreEqual(1 + builtInPackagesResourcesCount, treeViewItem.children.Count);
Assert.AreEqual(assetPath.Replace(".prefab", ""), treeViewItem.children[0].displayName);
//Cleanup
AssetDatabase.DeleteAsset("Assets/Resources/");
}
}
public void WhenFileTypeIsInvalid_AndContentCatalogsAreCreated_BuildFails()
{
var context = new AddressablesDataBuilderInput(Settings);
string path = GetAssetPath("fake.file");
FileStream fs = File.Create(path);
fs.Close();
AssetDatabase.ImportAsset(path);
string guid = AssetDatabase.AssetPathToGUID(path);
AddressableAssetEntry entry = Settings.CreateOrMoveEntry(guid, Settings.DefaultGroup);
foreach (IDataBuilder db in Settings.DataBuilders)
{
if (db.GetType() == typeof(BuildScriptFastMode) ||
db.GetType() == typeof(BuildScriptPackedPlayMode))
{
continue;
}
if (db.CanBuildData <AddressablesPlayerBuildResult>())
{
db.BuildData <AddressablesPlayerBuildResult>(context);
}
else if (db.CanBuildData <AddressablesPlayModeBuildResult>())
{
db.BuildData <AddressablesPlayModeBuildResult>(context);
}
LogAssert.Expect(LogType.Error, "Cannot recognize file type for entry located at 'Assets/UnityEditor.AddressableAssets.Tests.BuildScriptTests_Tests/fake.file'. Asset import failed for using an unsupported file type.");
}
Settings.RemoveAssetEntry(guid, false);
AssetDatabase.DeleteAsset(path);
}
public void AssignAddressableInformation()
{
List <AssetItem> SerializedItems = UMAAssetIndexer.Instance.UpdateSerializedList();
foreach (AssetItem ai in SerializedItems)
{
AddressableAssetEntry ae = AddressableUtility.GetAddressableAssetEntry(ai._Path);
if (ae != null)
{
ai.AddressableAddress = ae.address;
ai.IsAddressable = true;
ai.AddressableGroup = ae.parentGroup.Name;
ai._SerializedItem = null;
ai.AddressableLabels = "";
foreach (string s in ae.labels)
{
ai.AddressableLabels += s + ";";
}
}
else
{
ai.AddressableAddress = "";
ai.AddressableGroup = "";
ai.IsAddressable = false;
ai.AddressableLabels = "";
}
}
}
public void CanConvertEntryCollectionToEntries()
{
Settings.DenyEntryCollectionPermission = true;
var collectionPath = Path.Combine(TestFolder, "collection.asset").Replace('\\', '/');
var collection = ScriptableObject.CreateInstance <AddressableAssetEntryCollection>();
var assetPath = GetAssetPath("test.prefab");
var assetGuid = AssetDatabase.AssetPathToGUID(assetPath);
var collectionEntry = new AddressableAssetEntry(assetGuid, "TestAssetEntry", null, false);
collectionEntry.m_cachedAssetPath = "TestPath";
collection.Entries.Add(collectionEntry);
AssetDatabase.CreateAsset(collection, collectionPath);
Settings.DenyEntryCollectionPermission = false;
bool converted = this.Settings.ConvertAssetEntryCollections(new List <string>()
{
collectionPath
});
Assert.IsTrue(converted, "Failed to convert AssetEntryCollection to standard Group Entries");
var addedEntry = Settings.DefaultGroup.GetAssetEntry(assetGuid);
Assert.IsNotNull(addedEntry, "Could not find entry in default Group.");
}
public void GetRuntimeProviderType_ReturnsProviderTypeForNonAtlas(Type testProviderType)
{
AddressableAssetEntry entry = new AddressableAssetEntry("12345698655", "Entry", null, false);
Type providerType = entry.GetRuntimeProviderType(testProviderType.FullName, typeof(GameObject));
Assert.AreEqual(testProviderType, providerType);
}
public static void SetCachedPath(this AddressableAssetEntry entry, string newCachedPath)
{
var type = typeof(AddressableAssetEntry);
var methodInfo = type.GetMethod(nameof(SetCachedPath), BindingFlags.Instance | BindingFlags.NonPublic);
methodInfo.Invoke(entry, new object[] { newCachedPath });
}
public void GatherAllAssetReferenceDrawableEntries_AddsAllEntries_FromAddressableAssetEntryCollection()
{
//Setup
string testAssetFolder = k_TestConfigFolder + "/TestFolder";
string collectionPath = Path.Combine(testAssetFolder, "collection.asset").Replace('\\', '/');
Directory.CreateDirectory(testAssetFolder);
var collection = ScriptableObject.CreateInstance <AddressableAssetEntryCollection>();
AddressableAssetEntry entry = new AddressableAssetEntry("12345698655", "Entry", null, false);
entry.m_cachedAssetPath = "TestPath";
collection.Entries.Add(entry);
AssetDatabase.CreateAsset(collection, collectionPath);
AddressableAssetEntry collectionEntry = new AddressableAssetEntry("", "collection", null, false);
collectionEntry.m_cachedMainAssetType = typeof(AddressableAssetEntryCollection);
collectionEntry.m_cachedAssetPath = collectionPath;
//Test
List <IReferenceEntryData> results = new List <IReferenceEntryData>();
collectionEntry.GatherAllAssetReferenceDrawableEntries(results);
//Assert
Assert.AreEqual(1, results.Count);
Assert.AreEqual(entry.AssetPath, results[0].AssetPath);
//Cleanup
Directory.Delete(testAssetFolder, true);
}
public void DedupeEntries_WhenGroupsHaveOverlappingAssetEntries_RemovesEntries()
{
const string guid = "0000";
const string address = "not/a/real/address";
AddressableAssetGroup group1 = m_Settings.CreateGroup("group1", false, false, true, null, new Type[] { });
AddressableAssetGroup group2 = m_Settings.CreateGroup("group2", false, false, true, null, new Type[] { });
//We're making 2 identical enteries. This is to simulate each group having it's own copy of an AA Entry that references the same object.
//If we use the same object the call to AddAssetEntry won't give us the state we're looking for.
AddressableAssetEntry entry = new AddressableAssetEntry(guid, address, group1, false);
AddressableAssetEntry entry2 = new AddressableAssetEntry(guid, address, group2, false);
group1.AddAssetEntry(entry);
group2.AddAssetEntry(entry2);
//Ensuring our setup is correct
Assert.IsNotNull(group1.GetAssetEntry(guid));
Assert.IsNotNull(group2.GetAssetEntry(guid));
group1.DedupeEnteries(); //We setup our entry with group1 so it should retain its reference
group2.DedupeEnteries(); //The entry was added to group2 afterwards and should lose its reference
Assert.IsNotNull(group1.GetAssetEntry(guid));
Assert.IsNull(group2.GetAssetEntry(guid));
//Cleanup
m_Settings.RemoveGroup(group1);
m_Settings.RemoveGroup(group2);
}
public void GatherAllAssetReferenceDrawableEntries_ReturnsFolderSubAssets()
{
//Setup
string testAssetFolder = k_TestConfigFolder + "/TestFolder";
string testAssetSubFolder = Path.Combine(testAssetFolder, "SubFolder");
string mainPrefabPath = Path.Combine(testAssetFolder, "mainFolder.prefab").Replace('\\', '/');
string subPrefabPath = Path.Combine(testAssetSubFolder, "subFolder.prefab").Replace('\\', '/');
Directory.CreateDirectory(testAssetFolder);
PrefabUtility.SaveAsPrefabAsset(new GameObject("mainFolderAsset"), mainPrefabPath);
Directory.CreateDirectory(testAssetSubFolder);
PrefabUtility.SaveAsPrefabAsset(new GameObject("subFolderAsset"), subPrefabPath);
//Test
AddressableAssetEntry entry = new AddressableAssetEntry(AssetDatabase.AssetPathToGUID(testAssetFolder), "Folder", null, false);
List <IReferenceEntryData> results = new List <IReferenceEntryData>();
entry.GatherAllAssetReferenceDrawableEntries(results);
//Assert
Assert.AreEqual(2, results.Count);
Assert.AreEqual(mainPrefabPath, results[0].AssetPath);
Assert.AreEqual(subPrefabPath, results[1].AssetPath);
//Cleanup
Directory.Delete(testAssetFolder, true);
}
public void WhenFileTypeIsInvalid_AndContentCatalogsAreCreated_BuildFails()
{
var context = new AddressablesDataBuilderInput(Settings);
string path = GetAssetPath("fake.file");
FileStream fs = File.Create(path);
fs.Close();
AssetDatabase.ImportAsset(path);
string guid = AssetDatabase.AssetPathToGUID(path);
AddressableAssetEntry entry = Settings.CreateOrMoveEntry(guid, Settings.DefaultGroup);
foreach (IDataBuilder db in Settings.DataBuilders)
{
if (db.GetType() == typeof(BuildScriptFastMode) || db.GetType() == typeof(BuildScriptPackedPlayMode))
{
continue;
}
if (db.CanBuildData <AddressablesPlayerBuildResult>())
{
db.BuildData <AddressablesPlayerBuildResult>(context);
}
else if (db.CanBuildData <AddressablesPlayModeBuildResult>())
{
db.BuildData <AddressablesPlayModeBuildResult>(context);
}
LogAssert.Expect(LogType.Error, new Regex($".*{path}.*import failed.*"));
}
Settings.RemoveAssetEntry(guid, false);
AssetDatabase.DeleteAsset(path);
}
internal override void Setup(AddressableAssetSettings settings, string tempAssetFolder)
{
AddressableAssetGroup regGroup = settings.CreateGroup("localNoUWRGroup", false, false, true,
new List <AddressableAssetGroupSchema>(), typeof(BundledAssetGroupSchema));
regGroup.GetSchema <BundledAssetGroupSchema>().BundleNaming = BundledAssetGroupSchema.BundleNamingStyle.OnlyHash;
AddressableAssetGroup forceUWRGroup = settings.CreateGroup("ForceUWRGroup", false, false, true,
new List <AddressableAssetGroupSchema>(), typeof(BundledAssetGroupSchema));
forceUWRGroup.GetSchema <BundledAssetGroupSchema>().UseUnityWebRequestForLocalBundles = true;
forceUWRGroup.GetSchema <BundledAssetGroupSchema>().BundleMode = BundledAssetGroupSchema.BundlePackingMode.PackSeparately;
forceUWRGroup.GetSchema <BundledAssetGroupSchema>().BundleNaming = BundledAssetGroupSchema.BundleNamingStyle.OnlyHash;
settings.MaxConcurrentWebRequests = kMaxConcurrentRequests;
for (int i = 0; i < kForceUWRBundleCount; i++)
{
string s = GetForceUWRAddrName(i);
string guid = CreatePrefab(tempAssetFolder + $"/{s}.prefab");
AddressableAssetEntry entry = settings.CreateOrMoveEntry(guid, forceUWRGroup);
entry.address = s;
}
{
string guid = CreatePrefab(tempAssetFolder + $"/testprefab.prefab");
AddressableAssetEntry entry = settings.CreateOrMoveEntry(guid, regGroup);
entry.address = "testprefab";
}
}
private static void OnPrefabStageOpened(PrefabStage stage)
{
Preview p = stage.prefabContentsRoot.GetComponentInChildren <Preview>();
if (p)
{
p.GenerateIcon();
Debug.Log("Creating preview for weapon " + stage.prefabContentsRoot.name);
AddressableAssetSettings settings = AddressableAssetSettingsDefaultObject.Settings;
if (settings != null)
{
string prefabGuid = AssetDatabase.AssetPathToGUID(stage.prefabAssetPath);
AddressableAssetEntry prefabEntry = settings.FindAssetEntry(prefabGuid);
if (prefabEntry == null)
{
Debug.LogError("Prefab entry not found for prefab " + stage.prefabAssetPath);
return;
}
}
}
else
{
Debug.LogError("Preview component not found on weapon " + stage.prefabContentsRoot.name + ". Please make sure your prefab contains a Preview Script on a children GameObject.");
}
stage.ClearDirtiness();
PrefabStage.prefabStageOpened -= OnPrefabStageOpened;
}
public AssetEntryTreeViewItem(AddressableAssetGroup g, int d) : base(g.Guid.GetHashCode(), d, g.Name)
{
entry = null;
group = g;
assetIcon = null;
isRenaming = false;
}
public void GatherAllAssetReferenceDrawableEntries_DoesNotReturnResources()
{
//Setup
string scenePath = "TestScenePath";
var savedCache = BuiltinSceneCache.scenes;
BuiltinSceneCache.scenes = new EditorBuildSettingsScene[]
{
new EditorBuildSettingsScene(scenePath, true)
};
AddressableAssetEntry entry = Settings.CreateOrMoveEntry(AddressableAssetEntry.ResourcesName, m_testGroup, false);
//Test
List <IReferenceEntryData> results = new List <IReferenceEntryData>();
entry.GatherAllAssetReferenceDrawableEntries(results, Settings);
//Assert
Assert.AreEqual(0, results.Count);
//Cleanup
BuiltinSceneCache.scenes = savedCache;
Settings.RemoveAssetEntry(AddressableAssetEntry.ResourcesName, false);
}
public void GetRuntimeProviderType_ReturnsAtlasProviderForSpriteAtlas()
{
AddressableAssetEntry entry = new AddressableAssetEntry("12345698655", "Entry", null, false);
Type providerType = entry.GetRuntimeProviderType(typeof(AssetDatabaseProvider).FullName, typeof(SpriteAtlas));
Assert.AreEqual(typeof(AtlasSpriteProvider), providerType);
}
internal override void Setup(AddressableAssetSettings settings, string tempAssetFolder)
{
GameObject testObject = new GameObject("TestObject");
GameObject testObject2 = new GameObject("TestObject2");
string path = tempAssetFolder + "/test.prefab";
string path2 = tempAssetFolder + "/test2.prefab";
PrefabUtility.SaveAsPrefabAsset(testObject, path);
PrefabUtility.SaveAsPrefabAsset(testObject2, path2);
string guid = AssetDatabase.AssetPathToGUID(path);
string guid2 = AssetDatabase.AssetPathToGUID(path2);
AddressableAssetEntry entry = settings.CreateOrMoveEntry(guid, settings.DefaultGroup);
entry.address = k_ValidKey;
entry = settings.CreateOrMoveEntry(guid2, settings.DefaultGroup);
entry.address = k_InvalidKey;
bool currentIgnoreState = LogAssert.ignoreFailingMessages;
LogAssert.ignoreFailingMessages = false;
LogAssert.Expect(LogType.Error, $"Address '{entry.address}' cannot contain '[ ]'.");
LogAssert.ignoreFailingMessages = currentIgnoreState;
}
internal override void Setup(AddressableAssetSettings settings, string tempAssetFolder)
{
AddressableAssetGroup group = settings.CreateGroup("SceneGroup", true, false, false, null, typeof(BundledAssetGroupSchema));
group.GetSchema <BundledAssetGroupSchema>().BundleNaming = BundledAssetGroupSchema.BundleNamingStyle.OnlyHash;
// Create prefab
string prefabPath = CreateAssetPath(tempAssetFolder, prefabKey, ".prefab");
string prefabGuid = CreatePrefab(prefabPath);
AddressableAssetEntry prefabEntry = settings.CreateOrMoveEntry(prefabGuid, group, false, false);
prefabEntry.address = Path.GetFileNameWithoutExtension(prefabEntry.AssetPath);
// Create scenes
for (int i = 0; i < numScenes; i++)
{
string scenePath = CreateAssetPath(tempAssetFolder, sceneKeys[i], ".unity");
string sceneGuid = CreateScene(scenePath);
AddressableAssetEntry sceneEntry = settings.CreateOrMoveEntry(sceneGuid, group, false, false);
sceneEntry.address = Path.GetFileNameWithoutExtension(sceneEntry.AssetPath);
}
{
string scenePath = CreateAssetPath(tempAssetFolder, kEmbeddedSceneName, ".unity");
var scene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Additive);
new GameObject("EmbededMeshGameObject").AddComponent <MeshFilter>().mesh = new Mesh();
EditorSceneManager.SaveScene(scene, scenePath);
string sceneGuid = AssetDatabase.AssetPathToGUID(scene.path);
AddressableAssetEntry sceneEntry = settings.CreateOrMoveEntry(sceneGuid, group, false, false);
sceneEntry.address = Path.GetFileNameWithoutExtension(sceneEntry.AssetPath);
}
}
/// <summary>
/// 设置label
/// </summary>
/// <param name="entry"></param>
/// <param name="listLabel"></param>
public static void SetLabel(AddressableAssetEntry entry, List <string> listLabel)
{
for (int i = 0; i < listLabel.Count; i++)
{
entry.SetLabel(listLabel[i], true);
}
}
public void EditorInitialization_DoesNotDeleteFoldersThatAreStillOnDisk()
{
//Setup
string folderPath = "Assets/Temp/FakeAddressablesFolder/";
Directory.CreateDirectory(folderPath);
AssetDatabase.ImportAsset(folderPath);
AddressableAssetEntry entry = new AddressableAssetEntry(AssetDatabase.AssetPathToGUID(folderPath),
folderPath, m_testGroup, false);
m_testGroup.AddAssetEntry(entry);
entry.m_cachedAssetPath = folderPath;
Assert.IsTrue(m_testGroup.entries.Contains(entry), "Folder entry is no longer in Addressable group before purge.");
//Test
AddressableEditorInitialization.PurgeInvalidAssetEntries(Settings);
//Assert
Assert.IsTrue(m_testGroup.entries.Contains(entry), "Folder entry is no longer in Addressable group after purge.");
//Cleanup
m_testGroup.RemoveAssetEntry(entry);
AssetDatabase.DeleteAsset(folderPath);
}
public void DefaultTypeAssetEntry_ResetsCachedTypeData()
{
//Setup
var path = GetAssetPath("entry.prefab");
PrefabUtility.SaveAsPrefabAsset(new GameObject(), path);
string guid = AssetDatabase.AssetPathToGUID(path);
AddressableAssetEntry entry = new AddressableAssetEntry(guid, "testaddress", Settings.DefaultGroup, false);
entry.m_cachedMainAssetType = typeof(DefaultAsset);
//Test
entry.CreateCatalogEntriesInternal(new List <ContentCatalogDataEntry>(), false, "fakeProvider", new List <object>(), null, new Dictionary <GUID, AssetLoadInfo>()
{
{ new GUID(guid), new AssetLoadInfo()
{
includedObjects = new List <ObjectIdentifier>()
} }
},
new HashSet <Type>(), true, false, false, new HashSet <string>());
//Assert
Assert.AreEqual(typeof(GameObject), entry.m_cachedMainAssetType);
//Cleanup
AssetDatabase.DeleteAsset(path);
}
public void ContentUpdateScenes_PackedTogetherByLabel_MarksAllScenesModifiedWithSharedLabel()
{
AddressableAssetGroup group = Settings.CreateGroup("SceneGroup", false, false, false, null, typeof(BundledAssetGroupSchema));
group.GetSchema <BundledAssetGroupSchema>().BundleMode = BundledAssetGroupSchema.BundlePackingMode.PackTogetherByLabel;
AddressableAssetEntry scene1 = new AddressableAssetEntry(m_SceneGuids[0], "scene1", group, false);
AddressableAssetEntry scene2 = new AddressableAssetEntry(m_SceneGuids[1], "scene2", group, false);
AddressableAssetEntry scene3 = new AddressableAssetEntry(m_SceneGuids[2], "scene3", group, false);
group.AddAssetEntry(scene1, false);
group.AddAssetEntry(scene2, false);
group.AddAssetEntry(scene3, false);
scene1.SetLabel("label", true);
scene3.SetLabel("label", true);
List <AddressableAssetEntry> modifedEnteries = new List <AddressableAssetEntry>()
{
scene1
};
ContentUpdateScript.AddAllDependentScenesFromModifiedEnteries(modifedEnteries);
Assert.AreEqual(2, modifedEnteries.Count);
Assert.AreEqual(scene1, modifedEnteries[0]);
Assert.AreEqual(scene3, modifedEnteries[1]);
Settings.RemoveGroup(group);
}
public void WhenGatherFolderEntries_ReturnsCorrectAssetObjects(bool includeSubObjects)
{
AddressableAssetEntry addrFolderEntry = null;
string addressableFolderPath = GetAssetPath("TestFolder");
try
{
//Setup
string folderGuid = CreateFolderDeep(addressableFolderPath);
addrFolderEntry = Settings.CreateOrMoveEntry(folderGuid, m_testGroup, false);
string testAssetPath = Path.Combine(addressableFolderPath, "testObject.asset").Replace('\\', '/');
var testAsset = TestObject.Create("testObject", testAssetPath);
testAsset.AddTestSubObject();
//Test
List <AddressableAssetEntry> entries = new List <AddressableAssetEntry>();
addrFolderEntry.GatherFolderEntries(entries, true, includeSubObjects, null);
if (includeSubObjects)
{
Assert.AreEqual(entries.Count, 2, "GatherFolder entries was expected to return the Asset added and its subObject");
}
else
{
Assert.AreEqual(entries.Count, 1, "GatherFolder entries was expected to only return the Asset added and not its subObject");
}
}
finally
{
//Cleanup
Settings.RemoveAssetEntry(addrFolderEntry, false);
AssetDatabase.DeleteAsset(addressableFolderPath);
}
}
public void ContentUpdateScenes_PackedSeperately_MarksNoAdditionalScenes()
{
AddressableAssetGroup group = Settings.CreateGroup("SceneGroup", false, false, false, null, typeof(BundledAssetGroupSchema));
group.GetSchema <BundledAssetGroupSchema>().BundleMode = BundledAssetGroupSchema.BundlePackingMode.PackSeparately;
AddressableAssetEntry scene1 = new AddressableAssetEntry(m_SceneGuids[0], "scene1", group, false);
AddressableAssetEntry scene2 = new AddressableAssetEntry(m_SceneGuids[1], "scene2", group, false);
AddressableAssetEntry scene3 = new AddressableAssetEntry(m_SceneGuids[2], "scene3", group, false);
group.AddAssetEntry(scene1, false);
group.AddAssetEntry(scene2, false);
group.AddAssetEntry(scene3, false);
List <AddressableAssetEntry> modifedEnteries = new List <AddressableAssetEntry>()
{
scene1
};
ContentUpdateScript.AddAllDependentScenesFromModifiedEnteries(modifedEnteries);
Assert.AreEqual(1, modifedEnteries.Count);
Assert.AreEqual(scene1, modifedEnteries[0]);
Settings.RemoveGroup(group);
}
public void GetRuntimeProviderType_HandlesInvalidProviderString()
{
AddressableAssetEntry entry = new AddressableAssetEntry("12345698655", "Entry", null, false);
Type providerType = entry.GetRuntimeProviderType("NotARealProvider", typeof(GameObject));
Assert.IsNull(providerType);
}
public AssetEntryTreeViewItem(AddressableAssetEntry e, int d) : base((e.address + e.guid).GetHashCode(), d, e.address)
{
entry = e;
group = null;
assetIcon = AssetDatabase.GetCachedIcon(e.AssetPath) as Texture2D;
isRenaming = false;
}
public void GetRuntimeProviderType_HandlesNullAssetType(Type testProviderType)
{
AddressableAssetEntry entry = new AddressableAssetEntry("12345698655", "Entry", null, false);
Type providerType = entry.GetRuntimeProviderType(testProviderType.FullName, null);
Assert.AreEqual(testProviderType, providerType);
}
public void WhenAddressHasSquareBrackets_AndContentCatalogsAreCreated_BuildFails()
{
var context = new AddressablesDataBuilderInput(Settings);
AddressableAssetEntry entry = Settings.CreateOrMoveEntry(m_AssetGUID, Settings.DefaultGroup);
entry.address = "[test]";
LogAssert.Expect(LogType.Error, $"Address '{entry.address}' cannot contain '[ ]'.");
foreach (IDataBuilder db in Settings.DataBuilders)
{
if (db.GetType() == typeof(BuildScriptFastMode) || db.GetType() == typeof(BuildScriptPackedPlayMode))
{
continue;
}
if (db.CanBuildData <AddressablesPlayerBuildResult>())
{
db.BuildData <AddressablesPlayerBuildResult>(context);
}
else if (db.CanBuildData <AddressablesPlayModeBuildResult>())
{
db.BuildData <AddressablesPlayModeBuildResult>(context);
}
LogAssert.Expect(LogType.Error, new Regex(@"Address \'\[test\]\' cannot contain \'\[ \]\'"));
}
Settings.RemoveAssetEntry(m_AssetGUID, false);
}
public void WhenAddressHasSquareBracketsAndGuidIsNotEmptyString_SettingTheAddressOnExistingEntry_ThrowsError()
{
AddressableAssetEntry entry = new AddressableAssetEntry("12345698655", "Entry", null, false);
entry.SetAddress("[Entry]");
LogAssert.Expect(LogType.Error, $"Address '{entry.address}' cannot contain '[ ]'.");
}
AddressableAssetEntry MakeAddressable(AddressableAssetGroup group, string guid, string address = null)
{
AddressableAssetEntry entry = m_Settings.CreateOrMoveEntry(guid, group, false, false);
entry.address = address == null?Path.GetFileNameWithoutExtension(entry.AssetPath) : address;
return(entry);
}
public void CheckForEditorAssembly_TestCorrectTypeConversion()
{
foreach (Type key in _editorToRuntimeTypeConversion.Keys)
{
Type type = key;
AddressableAssetEntry.CheckForEditorAssembly(ref type, "", false);
Assert.AreEqual(type, _editorToRuntimeTypeConversion[key]);
}
}
