using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection.Emit;
using NUnit.Framework;
using UnityEditor.AddressableAssets.Build;
using UnityEditor.AddressableAssets.Build.DataBuilders;
using UnityEditor.AddressableAssets.Build.Layout;
using UnityEditor.AddressableAssets.Settings;
using UnityEditor.AddressableAssets.Settings.GroupSchemas;
using UnityEditor.Build.Pipeline.Utilities;
using UnityEditor.VersionControl;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.ResourceManagement.Util;
using UnityEngine.TestTools;
using static UnityEditor.AddressableAssets.Settings.AddressableAssetSettings;

namespace UnityEditor.AddressableAssets.Tests
{
    public class AddressableAssetSettingsTests : AddressableAssetTestBase
    {
        internal class InitializeScriptable : ScriptableObject, IObjectInitializationDataProvider
        {
            public string Name { get; }

            public ObjectInitializationData CreateObjectInitializationData()
            {
                return new ObjectInitializationData();
            }
        }

        internal class GroupTemplateTestObj : IGroupTemplate
        {
            public string Name { get; }
            public string Description { get; }
        }

        internal class InitializationObejctTest : IObjectInitializationDataProvider
        {
            public string Name { get; }

            public ObjectInitializationData CreateObjectInitializationData()
            {
                return new ObjectInitializationData();
            }
        }

        internal class DataBuilderTest : IDataBuilder
        {
            public string Name { get; set; }
            public bool CacheCleared = false;

            public bool CanBuildData<T>() where T : IDataBuilderResult
            {
                return true;
            }

            public TResult BuildData<TResult>(AddressablesDataBuilderInput builderInput) where TResult : IDataBuilderResult
            {
                return default(TResult);
            }

            public void ClearCachedData()
            {
                CacheCleared = true;
            }

            public string Description { get; }
        }

        public void SetupEntries(ref List<AddressableAssetEntry> entries, int numEntries)
        {
            var testObject = new GameObject("TestObjectSetLabel");
            PrefabUtility.SaveAsPrefabAsset(testObject, ConfigFolder + "/testasset.prefab");
            var testAssetGUID = AssetDatabase.AssetPathToGUID(ConfigFolder + "/testasset.prefab");
            entries.Add(Settings.CreateOrMoveEntry(m_AssetGUID, Settings.FindGroup(AddressableAssetSettings.PlayerDataGroupName)));
            for (int i = 0; i <= numEntries; i++)
                entries.Add(Settings.CreateOrMoveEntry(testAssetGUID, Settings.FindGroup(AddressableAssetSettings.PlayerDataGroupName)));
        }

        [Test]
        public void SettingsCache_FindsEntry()
        {
            AddressableAssetSettings.Cache<string, int> cache = new AddressableAssetSettings.Cache<string, int>(Settings);
            int result = 10;
            string key = "testKey";
            Assert.IsFalse(cache.TryGetCached(key, out result));
            cache.Add(key, 20);
            Assert.IsTrue(cache.TryGetCached(key, out result));
            Assert.AreEqual(result, 20);
        }
#if !UNITY_2020_3_OR_NEWER
        [Test]
        public void Hash128AppendExtensionTests()
        {
            var h1 = new Hash128(2351235, 3457345734, 457845683, 213451235);
            var h2 = h1;
            h2.Append("string");
            Assert.AreNotEqual(h1, h2);
            h2 = h1;
            h2.Append(462346);
            Assert.AreNotEqual(h1, h2);
            h2 = h1;
            Hash128 v = new Hash128(45346,4568234,213,35454);
            h2.Append(ref v);
            Assert.AreNotEqual(h1, h2);
        }
#endif
        [Test]
        public void SettingsCache_CacheClearedOnSettingsChanged()
        {
            AddressableAssetSettings.Cache<string, int> cache = new AddressableAssetSettings.Cache<string, int>(Settings);
            int result;
            string key = "testKey";
            cache.Add(key, 20);
            Assert.IsTrue(cache.TryGetCached(key, out result));
            Assert.AreEqual(result, 20);

            Settings.AddLabel("SettingsCache_CacheClearedOnSettingsChanged.testLabel", false);
            try
            {
                Assert.IsFalse(cache.TryGetCached(key, out result));
            }
            finally
            {
                Settings.RemoveLabel("SettingsCache_CacheClearedOnSettingsChanged.testLabel", false);
            }
        }

        [Test]
        public void GetDefaultGroupDoesNotThrowNullExceptionWhenGroupsNull()
        {
            Settings.groups.Insert(0, null);
            Assert.IsNotNull(Settings.DefaultGroup);
            Settings.groups.RemoveAt(0);
        }

        [Test]
        public void HasDefaultInitialGroups()
        {
            Assert.IsNotNull(Settings.FindGroup(AddressableAssetSettings.PlayerDataGroupName));
            Assert.IsNotNull(Settings.FindGroup(AddressableAssetSettings.DefaultLocalGroupName));
        }

        [Test]
        public void HasDefaultVersionOverride()
        {
            Assert.AreEqual(kDefaultPlayerVersion, Settings.OverridePlayerVersion);
        }

        [Test]
        public void AddRemovelabel()
        {
            var initialValue = Settings.currentHash;
            const string labelName = "Newlabel";
            Settings.AddLabel(labelName);
            Assert.Contains(labelName, Settings.labelTable.labelNames);
            Assert.AreNotEqual(initialValue, Settings.currentHash);
            Settings.RemoveLabel(labelName);
            Assert.False(Settings.labelTable.labelNames.Contains(labelName));
            Assert.AreEqual(initialValue, Settings.currentHash);
        }

        [Test]
        public void RenameLabel_KeepsIndexTheSame_ForNewTableEntry()
        {
            string dummyLabel1, dummyLabel2, dummyLabel3;
            dummyLabel3 = dummyLabel2 = dummyLabel1 = "dummylabel";
            string replaceMe = "replaceme";
            string useMeToReplace = "usemetoreplace";
            Settings.AddLabel(dummyLabel1);
            Settings.AddLabel(dummyLabel2);
            Settings.AddLabel(replaceMe);
            Settings.AddLabel(dummyLabel3);

            int startIndex = Settings.labelTable.GetIndexOfLabel(replaceMe);

            Settings.RenameLabel(replaceMe, useMeToReplace);

            int endIndex = Settings.labelTable.GetIndexOfLabel(useMeToReplace);

            Assert.AreEqual(startIndex, endIndex);

            Settings.RemoveLabel(dummyLabel1);
            Settings.RemoveLabel(dummyLabel2);
            Settings.RemoveLabel(dummyLabel3);
            Settings.RemoveLabel(useMeToReplace);
        }

        [Test]
        public void RenameLabel_UpdatesLabelList_WithCorrectLabels()
        {
            string replaceMe = "replaceme";
            string useMeToReplace = "usemetoreplace";
            Settings.AddLabel(replaceMe);

            Settings.RenameLabel(replaceMe, useMeToReplace);

            Assert.IsFalse(Settings.GetLabels().Contains(replaceMe));
            Assert.IsTrue(Settings.GetLabels().Contains(useMeToReplace));

            Settings.RemoveLabel(useMeToReplace);
        }

        [Test]
        public void RenameLabel_UpdatesAssetEntries_ThatContainUsesOfTheOldLabels()
        {
            string replaceMe = "replaceme";
            string useMeToReplace = "usemetoreplace";
            Settings.AddLabel(replaceMe);
            var assetEntry = Settings.CreateOrMoveEntry(m_AssetGUID, Settings.DefaultGroup);
            assetEntry.SetLabel(replaceMe, true);

            Settings.RenameLabel(replaceMe, useMeToReplace);

            Assert.IsTrue(assetEntry.labels.Contains(useMeToReplace));
            Assert.IsFalse(assetEntry.labels.Contains(replaceMe));

            Settings.RemoveAssetEntry(assetEntry);
            Settings.RemoveLabel(useMeToReplace);
        }

        [Test]
        public void GetLabels_ShouldReturnCopy()
        {
            const string labelName = "Newlabel";
            Settings.AddLabel("label_1");
            Settings.AddLabel("label_2");

            var labels = Settings.GetLabels();
            labels.Add(labelName);

            Assert.AreEqual(3, labels.Count);
            Assert.AreEqual(2, Settings.labelTable.labelNames.Count);
            Assert.IsFalse(Settings.labelTable.labelNames.Contains(labelName));
        }

        [Test]
        public void WhenLabelNameHasSquareBrackets_AddingNewLabel_ThrowsError()
        {
            string name = "[label]";
            Settings.AddLabel(name);
            LogAssert.Expect(LogType.Error, $"Label name '{name}' cannot contain '[ ]'.");
        }

        [Test]
        public void AddRemoveUnusedLabels()
        {
            var group = Settings.CreateGroup("NewGroupForUnusedLabelsTest", false, false, false, null);
            Assert.IsNotNull(group);
            var entry = Settings.CreateOrMoveEntry(m_AssetGUID, group);
            Assert.IsNotNull(entry);

            const string labelName = "LabelInUse";
            const string labelName2 = "LabelNotInUse";

            try
            {
                Settings.AddLabel(labelName);
                entry.SetLabel(labelName, true, false, false);
                Settings.AddLabel(labelName2);

                Assert.Contains(labelName, Settings.labelTable.labelNames);
                Assert.Contains(labelName2, Settings.labelTable.labelNames);

                Settings.RemoveUnusedLabels();
                Assert.Contains(labelName, Settings.labelTable.labelNames);
                Assert.False(Settings.labelTable.labelNames.Contains(labelName2));
            }
            finally
            {
                Settings.RemoveAssetEntry(entry);
                Settings.RemoveGroup(group);
                Settings.RemoveLabel(labelName, false);
            }
        }

        [Test]
        public void AddRemoveGroup()
        {
            const string groupName = "NewGroup";
            var group = Settings.CreateGroup(groupName, false, false, false, null);
            Assert.IsNotNull(group);
            Settings.RemoveGroup(group);
            Assert.IsNull(Settings.FindGroup(groupName));
        }

        [Test]
        public void RemoveMissingGroupsReferences_CheckGroupCount()
        {
            var size = Settings.groups.Count;
            var x = Settings.groups[size - 1];
            Settings.groups[size - 1] = null;
            bool b = Settings.RemoveMissingGroupReferences();
            Assert.AreEqual(Settings.groups.Count + 1, size);
            Settings.groups.Add(x);
            LogAssert.Expect(LogType.Log, "Addressable settings contains 1 group reference(s) that are no longer there. Removing reference(s).");
        }

        [Test]
        public void CanCreateAssetReference()
        {
            AssetReference testReference = Settings.CreateAssetReference(m_AssetGUID);
            Assert.NotNull(testReference);
            var entry = Settings.FindGroup(AddressableAssetSettings.DefaultLocalGroupName).GetAssetEntry(m_AssetGUID);
            Assert.AreSame(testReference.AssetGUID, entry.guid);
        }

        [Test]
        public void CreateUpdateNewEntry()
        {
            var group = Settings.CreateGroup("NewGroupForCreateOrMoveEntryTest", false, false, false, null);
            Assert.IsNotNull(group);
            var entry = Settings.CreateOrMoveEntry(m_AssetGUID, group);
            Assert.IsNotNull(entry);
            Assert.AreSame(group, entry.parentGroup);
            var localDataGroup = Settings.FindGroup(AddressableAssetSettings.DefaultLocalGroupName);
            Assert.IsNotNull(localDataGroup);
            entry = Settings.CreateOrMoveEntry(m_AssetGUID, localDataGroup);
            Assert.IsNotNull(entry);
            Assert.AreNotSame(group, entry.parentGroup);
            Assert.AreSame(localDataGroup, entry.parentGroup);
            Settings.RemoveGroup(group);
            localDataGroup.RemoveAssetEntry(entry);
            var tmp = Settings.FindAssetEntry(entry.guid);
            Assert.IsNull(Settings.FindAssetEntry(entry.guid));
        }

        [Test]
        public void CreateOrMoveEntries_CreatesNewEntries()
        {
            string guid1 = "guid1";
            string guid2 = "guid2";
            string guid3 = "guid3";

            Settings.CreateOrMoveEntries(new List<string>() {guid1, guid2, guid3}, Settings.DefaultGroup,
                new List<AddressableAssetEntry>(),
                new List<AddressableAssetEntry>());

            Assert.IsNotNull(Settings.FindAssetEntry(guid1));
            Assert.IsNotNull(Settings.FindAssetEntry(guid2));
            Assert.IsNotNull(Settings.FindAssetEntry(guid3));

            Settings.RemoveAssetEntry(guid1);
            Settings.RemoveAssetEntry(guid2);
            Settings.RemoveAssetEntry(guid3);
        }

        [Test]
        public void CreateOrMoveEntries_MovesEntriesThatAlreadyExist()
        {
            string guid1 = "guid1";
            string guid2 = "guid2";
            string guid3 = "guid3";
            var group = Settings.CreateGroup("SeparateGroup", false, false, true, new List<AddressableAssetGroupSchema>());
            group.AddAssetEntry(Settings.CreateEntry(guid1, "addr1", group, false));
            group.AddAssetEntry(Settings.CreateEntry(guid2, "addr2", group, false));
            group.AddAssetEntry(Settings.CreateEntry(guid3, "addr3", group, false));

            Settings.CreateOrMoveEntries(new List<string>() {guid1, guid2, guid3}, Settings.DefaultGroup,
                new List<AddressableAssetEntry>(),
                new List<AddressableAssetEntry>());

            Assert.IsNull(group.GetAssetEntry(guid1));
            Assert.IsNull(group.GetAssetEntry(guid2));
            Assert.IsNull(group.GetAssetEntry(guid3));

            Assert.IsNotNull(Settings.DefaultGroup.GetAssetEntry(guid1));
            Assert.IsNotNull(Settings.DefaultGroup.GetAssetEntry(guid2));
            Assert.IsNotNull(Settings.DefaultGroup.GetAssetEntry(guid3));

            Settings.RemoveGroup(group);
        }

        [Test]
        public void CreateOrMoveEntries_Creates_AndMovesExistingEntries_InMixedLists()
        {
            string guid1 = "guid1";
            string guid2 = "guid2";
            string guid3 = "guid3";
            var group = Settings.CreateGroup("SeparateGroup", false, false, true, new List<AddressableAssetGroupSchema>());
            group.AddAssetEntry(Settings.CreateEntry(guid1, "addr1", group, false));
            group.AddAssetEntry(Settings.CreateEntry(guid3, "addr3", group, false));

            Settings.CreateOrMoveEntries(new List<string>() {guid1, guid2, guid3}, Settings.DefaultGroup,
                new List<AddressableAssetEntry>(),
                new List<AddressableAssetEntry>());

            Assert.IsNull(group.GetAssetEntry(guid1));
            Assert.IsNull(group.GetAssetEntry(guid3));

            Assert.IsNotNull(Settings.DefaultGroup.GetAssetEntry(guid1));
            Assert.IsNotNull(Settings.DefaultGroup.GetAssetEntry(guid2));
            Assert.IsNotNull(Settings.DefaultGroup.GetAssetEntry(guid3));

            Settings.RemoveGroup(group);
        }

        [Test]
        public void CannotCreateOrMoveWithoutGuid()
        {
            Assert.IsNull(Settings.CreateOrMoveEntry(null, Settings.DefaultGroup));
            Assert.IsNull(Settings.CreateSubEntryIfUnique(null, "", null));
        }

        [Test]
        public void FindAssetEntry()
        {
            var localDataGroup = Settings.FindGroup(AddressableAssetSettings.DefaultLocalGroupName);
            Assert.IsNotNull(localDataGroup);
            var entry = Settings.CreateOrMoveEntry(m_AssetGUID, localDataGroup);
            var foundEntry = Settings.FindAssetEntry(m_AssetGUID);
            Assert.AreSame(entry, foundEntry);
        }

        [Test]
        public void FindAssetEntry_IncludeImplicitIsTrue_ReturnsImplicitEntries()
        {
            var folderPath = GetAssetPath("aaFolder");
            Directory.CreateDirectory(folderPath);
            AssetDatabase.Refresh();
            var folderGuid = AssetDatabase.AssetPathToGUID(folderPath);
            Assert.IsFalse(string.IsNullOrEmpty(folderGuid));

            var asset1GUID = CreateAsset(Path.Combine(folderPath, "asset1.prefab").Replace('\\', '/'));
            var folderEntry = Settings.CreateOrMoveEntry(folderGuid, Settings.DefaultGroup);
            Assert.IsNotNull(folderEntry);

            var foundEntry = Settings.FindAssetEntry(asset1GUID, false);
            Assert.IsNull(foundEntry);

            foundEntry = Settings.FindAssetEntry(asset1GUID, true);
            Assert.AreEqual(AssetDatabase.GUIDToAssetPath(asset1GUID), foundEntry.AssetPath);

            Directory.Delete(folderPath, true);
            Settings.RemoveAssetEntry(folderEntry, false);
        }

        [Test]
        public void AddressablesClearCachedData_DoesNotThrowError()
        {
            //individual clean paths
            foreach (ScriptableObject so in Settings.DataBuilders)
            {
                BuildScriptBase db = so as BuildScriptBase;
                Assert.DoesNotThrow(() => Settings.CleanPlayerContentImpl(db));
            }

            //Clean all path
            Assert.DoesNotThrow(() => Settings.CleanPlayerContentImpl());

            //Cleanup
            Settings.BuildPlayerContentImpl();
        }

        [Test]
        public void AddressablesCleanCachedData_ClearsData()
        {
            //Setup
            Settings.BuildPlayerContentImpl();

            //Check after each clean that the data is not built
            foreach (ScriptableObject so in Settings.DataBuilders)
            {
                BuildScriptBase db = so as BuildScriptBase;
                Settings.CleanPlayerContentImpl(db);
                Assert.IsFalse(db.IsDataBuilt());
            }
        }

        [Test]
        public void AddressablesCleanAllCachedData_ClearsAllData()
        {
            //Setup
            Settings.BuildPlayerContentImpl();

            //Clean ALL data builders
            Settings.CleanPlayerContentImpl();

            //Check none have data built
            foreach (ScriptableObject so in Settings.DataBuilders)
            {
                BuildScriptBase db = so as BuildScriptBase;
                Assert.IsFalse(db.IsDataBuilt());
            }
        }

        [Test]
        public void DeletingAsset_DoesNotDeleteGroupWithSimilarName()
        {
            //Setup
            const string groupName = "NewAsset.mat";
            string assetPath = GetAssetPath(groupName);


            var mat = new Material(Shader.Find("Unlit/Color"));
            AssetDatabase.CreateAsset(mat, assetPath);

            var group = Settings.CreateGroup(groupName, false, false, false, null);
            Assert.IsNotNull(group);

            //Test
            AssetDatabase.DeleteAsset(assetPath);

            //Assert
            Settings.CheckForGroupDataDeletion(groupName);
            Assert.IsNotNull(Settings.FindGroup(groupName));

            //Clean up
            Settings.RemoveGroup(group);
            Assert.IsNull(Settings.FindGroup(groupName));
        }

        [Test]
        public void Settings_WhenActivePlayerDataBuilderIndexSetWithSameValue_DoesNotDirtyAsset()
        {
            var prevDC = EditorUtility.GetDirtyCount(Settings);
            Settings.ActivePlayerDataBuilderIndex = Settings.ActivePlayerDataBuilderIndex;
            var dc = EditorUtility.GetDirtyCount(Settings);
            Assert.AreEqual(prevDC, dc);
        }

        [Test]
        public void Settings_WhenActivePlayerDataBuilderIndexSetWithDifferentValue_DoesDirtyAsset()
        {
            var prevDC = EditorUtility.GetDirtyCount(Settings);
            Settings.ActivePlayerDataBuilderIndex = Settings.ActivePlayerDataBuilderIndex + 1;
            var dc = EditorUtility.GetDirtyCount(Settings);
            Assert.AreEqual(prevDC + 1, dc);
        }

        [Test]
        public void AddressableAssetSettings_OnPostprocessAllAssets_AddDeleteGroupTriggersSettingsSave()
        {
            // Setup
            var importedAssets = new string[1];
            var deletedAssets = new string[0];
            var movedAssets = new string[0];
            var movedFromAssetPaths = new string[0];
            var newGroup = ScriptableObject.CreateInstance<AddressableAssetGroup>();
            newGroup.Name = "testGroup";
            var groupPath = ConfigFolder + "/AssetGroups/" + newGroup.Name + ".asset";
            AssetDatabase.CreateAsset(newGroup, groupPath);
            newGroup.Initialize(ScriptableObject.CreateInstance<AddressableAssetSettings>(), "testGroup", AssetDatabase.AssetPathToGUID(groupPath), false);
            importedAssets[0] = groupPath;
            EditorUtility.ClearDirty(Settings);
            var prevDC = EditorUtility.GetDirtyCount(Settings);

            // Test
            Settings.OnPostprocessAllAssets(importedAssets, deletedAssets, movedAssets, movedFromAssetPaths);
            Assert.AreEqual(prevDC + 1, EditorUtility.GetDirtyCount(Settings));
            Assert.IsTrue(EditorUtility.IsDirty(Settings));

            deletedAssets = new string[1];
            importedAssets = new string[0];
            deletedAssets[0] = groupPath;
            EditorUtility.ClearDirty(Settings);
            prevDC = EditorUtility.GetDirtyCount(Settings);
            Settings.OnPostprocessAllAssets(importedAssets, deletedAssets, movedAssets, movedFromAssetPaths);
            Assert.AreEqual(prevDC + 2, EditorUtility.GetDirtyCount(Settings));
            Assert.IsTrue(EditorUtility.IsDirty(Settings));
        }

        [Test]
        public void AddressableAssetSettings_OnPostprocessAllAssets_DeleteAssetToNullNotTriggerSettingsSave()
        {
            // Setup
            var importedAssets = new string[0];
            var deletedAssets = new string[1];
            var movedAssets = new string[0];
            var movedFromAssetPaths = new string[0];
            Settings.groups.Add(null);
            Settings.DataBuilders.Add(null);
            Settings.GroupTemplateObjects.Add(null);
            Settings.InitializationObjects.Add(null);
            deletedAssets[0] = "";
            EditorUtility.ClearDirty(Settings);
            var prevDC = EditorUtility.GetDirtyCount(Settings);

            // Test
            Settings.OnPostprocessAllAssets(importedAssets, deletedAssets, movedAssets, movedFromAssetPaths);
            Settings.OnPostprocessAllAssets(importedAssets, deletedAssets, movedAssets, movedFromAssetPaths);
            Settings.OnPostprocessAllAssets(importedAssets, deletedAssets, movedAssets, movedFromAssetPaths);
            Settings.OnPostprocessAllAssets(importedAssets, deletedAssets, movedAssets, movedFromAssetPaths);
            Assert.AreEqual(prevDC, EditorUtility.GetDirtyCount(Settings));
            Assert.IsFalse(EditorUtility.IsDirty(Settings));
        }

        [Test]
        public void AddressableAssetSettings_OnPostprocessAllAssets_ChangeImportedAssetsDoesNotTriggerSettingsSave()
        {
            var importedAssets = new string[1];
            var deletedAssets = new string[0];
            var movedAssets = new string[0];
            var movedFromAssetPaths = new string[0];
            var entry = Settings.CreateOrMoveEntry(m_AssetGUID, Settings.groups[0]);
            var prevTestObjName = entry.MainAsset.name;
            entry.MainAsset.name = "test";
            importedAssets[0] = TestFolder + "/test.prefab";
            EditorUtility.ClearDirty(Settings);
            var prevDC = EditorUtility.GetDirtyCount(Settings);
            Settings.OnPostprocessAllAssets(importedAssets, deletedAssets, movedAssets, movedFromAssetPaths);
            Assert.AreEqual(prevDC, EditorUtility.GetDirtyCount(Settings));
            Assert.IsFalse(EditorUtility.IsDirty(Settings));
            entry.MainAsset.name = prevTestObjName;
        }

        [Test]
        public void AddressableAssetSettings_OnPostprocessAllAssets_MovedGroupNotTriggerSettingsSave()
        {
            // Setup
            var importedAssets = new string[0];
            var deletedAssets = new string[0];
            var movedAssets = new string[1];
            var movedFromAssetPaths = new string[1];
            var newGroup = ScriptableObject.CreateInstance<AddressableAssetGroup>();
            newGroup.Name = "testGroup";
            var groupPath = ConfigFolder + "/AssetGroups/" + newGroup.Name + ".asset";
            AssetDatabase.CreateAsset(newGroup, groupPath);
            newGroup.Initialize(ScriptableObject.CreateInstance<AddressableAssetSettings>(), "testGroup", AssetDatabase.AssetPathToGUID(groupPath), false);
            EditorUtility.ClearDirty(Settings);
            var prevDC = EditorUtility.GetDirtyCount(Settings);
            Settings.groups.Add(newGroup);
            string newGroupPath = ConfigFolder + "/AssetGroups/changeGroup.asset";
            AssetDatabase.MoveAsset(groupPath, newGroupPath);
            movedAssets[0] = newGroupPath;
            movedFromAssetPaths[0] = groupPath;

            // Test
            Settings.OnPostprocessAllAssets(importedAssets, deletedAssets, movedAssets, movedFromAssetPaths);
            Assert.AreEqual(prevDC, EditorUtility.GetDirtyCount(Settings));
            Assert.IsFalse(EditorUtility.IsDirty(Settings));

            //Cleanup
            Settings.RemoveGroup(newGroup);
        }

        [Test]
        public void AddressableAssetSettings_OnPostprocessAllAssets_MovedAssetToResourcesNotTriggerSettingsSave()
        {
            // Setup
            var importedAssets = new string[0];
            var deletedAssets = new string[0];
            var movedAssets = new string[1];
            var movedFromAssetPaths = new string[1];
            var assetPath = TestFolder + "/test.prefab";
            var newAssetPath = TestFolder + "/resources/test.prefab";
            if (!Directory.Exists(TestFolder + "/resources"))
            {
                Directory.CreateDirectory(TestFolder + "/resources");
                AssetDatabase.Refresh();
            }

            Settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(newAssetPath), Settings.groups[0]);
            movedAssets[0] = newAssetPath;
            movedFromAssetPaths[0] = assetPath;
            EditorUtility.ClearDirty(Settings);
            var prevDC = EditorUtility.GetDirtyCount(Settings);
            Settings.OnPostprocessAllAssets(importedAssets, deletedAssets, movedAssets, movedFromAssetPaths);
            Assert.AreEqual(prevDC, EditorUtility.GetDirtyCount(Settings));
            Assert.IsFalse(EditorUtility.IsDirty(Settings));

            // Cleanup
            AssetDatabase.MoveAsset(newAssetPath, assetPath);
            Settings.CreateOrMoveEntry(AssetDatabase.AssetPathToGUID(assetPath), Settings.groups[0]);
            Directory.Delete(TestFolder + "/resources");
        }

        [Test]
        public void AddressableAssetSettings_ActivePlayerDataBuilderIndex_CanGetActivePlayModeDataBuilderIndex()
        {
            Assert.NotNull(Settings.ActivePlayerDataBuilderIndex);
        }

        [Test]
        public void AddressableAssetSettings_ActivePlayerDataBuilderIndex_CanSetActivePlayModeDataBuilderIndex()
        {
            var prevActivePlayModeDataBuilderIndex = Settings.ActivePlayerDataBuilderIndex;
            Settings.ActivePlayerDataBuilderIndex = 1;
            Assert.AreNotEqual(prevActivePlayModeDataBuilderIndex, Settings.ActivePlayerDataBuilderIndex);
            Settings.ActivePlayerDataBuilderIndex = prevActivePlayModeDataBuilderIndex;
        }

#pragma warning disable 618
        [Test]
        public void AddressableAssetSettings_RemoveSchemaTemplate_CannotRemoveGroupSchemaTemplate()
        {
            LogAssert.Expect(LogType.Error, "GroupSchemaTemplates are deprecated, use GroupTemplateObjects");
            Settings.RemoveSchemaTemplate(0);
        }

#pragma warning restore 618

        [Test]
        public void AddressableAssetSettings_GetGroupTemplateObject_CanGetGroupTemplateObject()
        {
            var groupTemplate = Settings.GetGroupTemplateObject(Settings.GroupTemplateObjects.Count - 1);
            Assert.NotNull(groupTemplate);
        }

        [Test]
        public void AddressableAssetSettings_AddGroupTemplateObject_CanAddGroupTemplateObject()
        {
            var template = ScriptableObject.CreateInstance<AddressableAssetGroupTemplate>();
            template.name = "testGroup";
            Settings.AddGroupTemplateObject(template);
            var groupTemplate = Settings.GetGroupTemplateObject(Settings.GroupTemplateObjects.Count - 1);
            Assert.NotNull(groupTemplate);
            Assert.Greater(Settings.GroupTemplateObjects.Count, 1);
            Assert.AreEqual(groupTemplate.Name, template.name);
            Assert.AreSame(groupTemplate, template);

            Assert.IsTrue(Settings.CreateAndAddGroupTemplate("testCreatAndAdd", "test template function", typeof(BundledAssetGroupSchema)));
        }

        [Test]
        public void AddressableAssetSettings_SetGroupTemplateObjectAtIndex_CanSetGroupTemplateObject()
        {
            // Setup
            var testTemplate1 = ScriptableObject.CreateInstance<AddressableAssetGroupTemplate>();
            var testTemplate2 = ScriptableObject.CreateInstance<AddressableAssetGroupTemplate>();
            var template = ScriptableObject.CreateInstance<AddressableAssetGroupTemplate>();
            testTemplate1.name = "test1";
            testTemplate2.name = "test2";
            template.name = "testGroupIndex";
            var restoredObjects = new List<ScriptableObject>(Settings.GroupTemplateObjects);
            Settings.AddGroupTemplateObject(testTemplate1);
            Settings.AddGroupTemplateObject(testTemplate2);
            var saveTemplate = Settings.GetGroupTemplateObject(0);
            var checkUnchangedTemplate = Settings.GetGroupTemplateObject(1);

            // Test
            Settings.SetGroupTemplateObjectAtIndex((Settings.GroupTemplateObjects.Count - 1), template, true);
            Settings.SetGroupTemplateObjectAtIndex(0, template, true);
            var groupTemplate = Settings.GetGroupTemplateObject(Settings.GroupTemplateObjects.Count - 1);
            Assert.NotNull(groupTemplate);
            Assert.AreSame(template, groupTemplate);
            groupTemplate = Settings.GetGroupTemplateObject(0);
            Assert.NotNull(groupTemplate);
            Assert.AreSame(template, groupTemplate);
            groupTemplate = Settings.GetGroupTemplateObject(1);
            Assert.NotNull(groupTemplate);
            Assert.AreSame(checkUnchangedTemplate, groupTemplate);

            /* Cleanup
             * Restore GroupTemplateObjects
             */
            Settings.RemoveGroupTemplateObject(2, true);
            Settings.RemoveGroupTemplateObject(1, true);
            Settings.SetGroupTemplateObjectAtIndex(0, saveTemplate, true);
            Assert.AreEqual(restoredObjects.Count, Settings.GroupTemplateObjects.Count);
            Assert.AreSame(restoredObjects[0], Settings.GroupTemplateObjects[0]);
        }

        [Test]
        public void AddressableAssetSettings_AddGroupTemplateObject_CannotAddInvalidGroupTemplateObject()
        {
            int currentGroupTemplateCount = Settings.GroupTemplateObjects.Count;
            var unchangedGroupTemplate = Settings.GetGroupTemplateObject(Settings.GroupTemplateObjects.Count - 1);
            ScriptableObject groupTemplate = null;
            Assert.IsFalse(Settings.AddGroupTemplateObject(groupTemplate as IGroupTemplate));
            Assert.AreSame(unchangedGroupTemplate, Settings.GetGroupTemplateObject(Settings.GroupTemplateObjects.Count - 1));

            var groupTemplateTest = new GroupTemplateTestObj();
            Assert.IsFalse(Settings.AddGroupTemplateObject(groupTemplateTest as IGroupTemplate));
            Assert.AreEqual(currentGroupTemplateCount, Settings.GroupTemplateObjects.Count);
            Assert.AreSame(unchangedGroupTemplate, Settings.GetGroupTemplateObject(Settings.GroupTemplateObjects.Count - 1));
        }

        [Test]
        public void AddressableAssetSettings_CreateAndAddGroupTemplate_CannotAddInvalidGroupTemplateObject()
        {
            Assert.IsFalse(Settings.CreateAndAddGroupTemplate(null, "test template function", null));
            Assert.IsFalse(Settings.CreateAndAddGroupTemplate("testCreatAndAdd", "test template function", new Type[0]));
            var testParams = new Type[1];
            testParams[0] = null;
            Assert.IsFalse(Settings.CreateAndAddGroupTemplate("testCreatAndAdd", "test template function", testParams));
            testParams[0] = typeof(ScriptableObject);
            Assert.IsFalse(Settings.CreateAndAddGroupTemplate("testCreatAndAdd", "test template function", testParams));
        }

        [Test]
        public void AddressableAssetSettings_SetGroupTemplateObjectAtIndex_CannotSetInvalidGroupTemplateObject()
        {
            int currentGroupTemplateCount = Settings.GroupTemplateObjects.Count;
            var unchangedGroupTemplate = Settings.GetGroupTemplateObject(Settings.GroupTemplateObjects.Count - 1);
            ScriptableObject groupTemplate = null;
            Assert.IsFalse(Settings.SetGroupTemplateObjectAtIndex(Settings.GroupTemplateObjects.Count - 1, groupTemplate as IGroupTemplate));
            Assert.AreSame(unchangedGroupTemplate, Settings.GetGroupTemplateObject(Settings.GroupTemplateObjects.Count - 1));

            var groupTemplateTest = new GroupTemplateTestObj();
            Assert.IsFalse(Settings.SetGroupTemplateObjectAtIndex(Settings.GroupTemplateObjects.Count - 1, groupTemplateTest as IGroupTemplate));
            Assert.AreEqual(currentGroupTemplateCount, Settings.GroupTemplateObjects.Count);
            Assert.AreSame(unchangedGroupTemplate, Settings.GetGroupTemplateObject(Settings.GroupTemplateObjects.Count - 1));
        }

        [Test]
        public void AddressableAssetSettings_RemoveGroupTemplateObject_CannotRemoveNonExistentGroupTemplateObject()
        {
            Assert.IsFalse(Settings.RemoveGroupTemplateObject(Settings.GroupTemplateObjects.Count));
        }

        [Test]
        public void AddressableAssetSettings_GetGroupTemplateObject_CannotGetNonExistentGroupTemplateObject()
        {
            Assert.IsNull(Settings.GetGroupTemplateObject(Settings.GroupTemplateObjects.Count));
        }

        internal static bool IsNullOrEmpty<T>(ICollection<T> collection)
        {
            return collection == null || collection.Count == 0;
        }

        [Test]
        public void AddressableAssetSettings_GetGroupTemplateObject_CannotGetFromEmptyGroupTemplateObjectList()
        {
            var testSettings = new AddressableAssetSettings();
            while (!IsNullOrEmpty(testSettings.GroupTemplateObjects))
            {
                testSettings.RemoveGroupTemplateObject(0);
            }

            Assert.AreEqual(0, testSettings.GroupTemplateObjects.Count);
            Assert.IsNull(testSettings.GetGroupTemplateObject(1));
        }

        [Test]
        public void AddressableAssetSettings_AddDataBuilder_CanAddDataBuilder()
        {
            var testBuilder = Settings.GetDataBuilder(0);
            var testBuilderTwo = Settings.GetDataBuilder(1);
            var lastBuilder = Settings.GetDataBuilder(Settings.DataBuilders.Count - 1);
            int buildersCount = Settings.DataBuilders.Count;

            // Test
            Assert.IsTrue(Settings.AddDataBuilder(testBuilder as IDataBuilder));
            Assert.AreEqual(buildersCount + 1, Settings.DataBuilders.Count);
            Assert.AreEqual(Settings.DataBuilders[Settings.DataBuilders.Count - 1], testBuilder);
        }

        [Test]
        public void AddressableAssetSettings_RemoveDataBuilder_CanRemoveDataBuilder()
        {
            var testBuilder = Settings.GetDataBuilder(0);
            var testBuilderTwo = Settings.GetDataBuilder(1);
            var lastBuilder = Settings.GetDataBuilder(Settings.DataBuilders.Count - 1);
            int buildersCount = Settings.DataBuilders.Count;
            Settings.AddDataBuilder(testBuilder as IDataBuilder);

            // Test
            Assert.IsTrue(Settings.RemoveDataBuilder(Settings.DataBuilders.Count - 1));
            Assert.AreEqual(buildersCount, Settings.DataBuilders.Count);
            Assert.AreEqual(lastBuilder, Settings.GetDataBuilder(Settings.DataBuilders.Count - 1));
        }

        [Test]
        public void AddressableAssetSettings_SetDataBuilder_CanSetDataBuilder()
        {
            var testBuilder = Settings.GetDataBuilder(0);
            var testBuilderTwo = Settings.GetDataBuilder(1);
            var lastBuilder = Settings.GetDataBuilder(Settings.DataBuilders.Count - 1);
            int buildersCount = Settings.DataBuilders.Count;
            Settings.AddDataBuilder(testBuilder as IDataBuilder);

            // Test
            Assert.IsTrue(Settings.SetDataBuilderAtIndex(Settings.DataBuilders.Count - 1, testBuilderTwo));
            Assert.AreEqual(Settings.GetDataBuilder(Settings.DataBuilders.Count - 1), testBuilderTwo);

            //Cleanup
            Assert.IsTrue(Settings.RemoveDataBuilder(Settings.DataBuilders.Count - 1));
            Assert.AreEqual(buildersCount, Settings.DataBuilders.Count);
            Assert.AreEqual(lastBuilder, Settings.GetDataBuilder(Settings.DataBuilders.Count - 1));
        }

        [Test]
        public void AddressableAssetSettings_AddDataBuilder_CannotAddInvalidDataBuilders()
        {
            int currentDataBuildersCount = Settings.DataBuilders.Count;
            var unchangedDataBuilder = Settings.GetDataBuilder(Settings.DataBuilders.Count - 1);
            ScriptableObject testBuilder = null;
            Assert.IsFalse(Settings.AddDataBuilder(testBuilder as IDataBuilder));
            Assert.AreSame(unchangedDataBuilder, Settings.GetDataBuilder(Settings.DataBuilders.Count - 1));

            var testDataBuilder = new DataBuilderTest();
            Assert.IsFalse(Settings.AddDataBuilder(testDataBuilder as IDataBuilder));
            Assert.AreEqual(currentDataBuildersCount, Settings.DataBuilders.Count);
            Assert.AreSame(unchangedDataBuilder, Settings.GetDataBuilder(Settings.DataBuilders.Count - 1));
        }

        [Test]
        public void AddressableAssetSettings_SetDataBuilderAtIndex_CannotSetInvalidDataBuilders()
        {
            int currentDataBuildersCount = Settings.DataBuilders.Count;
            var unchangedDataBuilder = Settings.GetDataBuilder(Settings.DataBuilders.Count - 1);
            ScriptableObject testBuilder = null;
            Assert.IsFalse(Settings.SetDataBuilderAtIndex(Settings.DataBuilders.Count - 1, testBuilder as IDataBuilder));
            Assert.AreSame(unchangedDataBuilder, Settings.GetDataBuilder(Settings.DataBuilders.Count - 1));

            var testDataBuilder = new DataBuilderTest();
            Assert.IsFalse(Settings.SetDataBuilderAtIndex(Settings.DataBuilders.Count - 1, testDataBuilder as IDataBuilder));
            Assert.AreEqual(currentDataBuildersCount, Settings.DataBuilders.Count);
            Assert.AreSame(unchangedDataBuilder, Settings.GetDataBuilder(Settings.DataBuilders.Count - 1));
            Assert.IsFalse(Settings.SetDataBuilderAtIndex(5, testDataBuilder));
        }

        [Test]
        public void AddressableAssetSettings_GetDataBuilder_CannotGetNonExistentDataBuilder()
        {
            Assert.IsNull(Settings.GetDataBuilder(Settings.DataBuilders.Count));
        }

        [Test]
        public void AddressableAssetSettings_RemoveDataBuilder_CannotRemoveNonExistentDataBuilder()
        {
            Assert.IsFalse(Settings.RemoveDataBuilder(Settings.DataBuilders.Count));
        }

        [Test]
        public void AddressableAssetSettings_GetDataBuilder_CannotGetDataBuilderFromEmpty()
        {
            var testSettings = new AddressableAssetSettings();
            while (!IsNullOrEmpty(testSettings.DataBuilders))
            {
                testSettings.RemoveDataBuilder(0);
            }

            Assert.AreEqual(0, testSettings.DataBuilders.Count);
            Assert.IsNull(testSettings.GetDataBuilder(1));
        }

        [Test]
        public void AddressableAssetSettings_AddInitializationObject_CanAddInitializationObject()
        {
            var testInitObject = ScriptableObject.CreateInstance<InitializeScriptable>();
            testInitObject.name = "testObj";
            var testInitObjectTwo = ScriptableObject.CreateInstance<InitializeScriptable>();
            testInitObjectTwo.name = "testObjTwo";
            var lastInitObject = Settings.GetInitializationObject(Settings.InitializationObjects.Count - 1);
            int initObjectsCount = Settings.InitializationObjects.Count;

            // Test
            Assert.IsTrue(Settings.AddInitializationObject(testInitObject as IObjectInitializationDataProvider));
            Assert.AreEqual(initObjectsCount + 1, Settings.InitializationObjects.Count);
            Assert.AreEqual(Settings.InitializationObjects[Settings.InitializationObjects.Count - 1], testInitObject);

            // Cleanup
            Settings.RemoveInitializationObject(Settings.InitializationObjects.Count - 1);
        }

        [Test]
        public void AddressableAssetSettings_SetInitializationObject_CanSetInitializationObject()
        {
            var testInitObject = ScriptableObject.CreateInstance<InitializeScriptable>();
            testInitObject.name = "testObj";
            var testInitObjectTwo = ScriptableObject.CreateInstance<InitializeScriptable>();
            testInitObjectTwo.name = "testObjTwo";
            var lastInitObject = Settings.GetInitializationObject(Settings.InitializationObjects.Count - 1);
            int initObjectsCount = Settings.InitializationObjects.Count;
            Settings.AddInitializationObject(testInitObject as IObjectInitializationDataProvider);

            // Test
            Assert.IsTrue(Settings.SetInitializationObjectAtIndex(Settings.InitializationObjects.Count - 1, testInitObjectTwo as IObjectInitializationDataProvider));
            Assert.AreEqual(Settings.GetInitializationObject(Settings.InitializationObjects.Count - 1), testInitObjectTwo);

            // Cleanup
            Settings.RemoveInitializationObject(Settings.InitializationObjects.Count - 1);
        }

        [Test]
        public void AddressableAssetSettings_RemoveInitializationObject_CanRemoveInitializationObject()
        {
            var testInitObject = ScriptableObject.CreateInstance<InitializeScriptable>();
            testInitObject.name = "testObj";
            var testInitObjectTwo = ScriptableObject.CreateInstance<InitializeScriptable>();
            testInitObjectTwo.name = "testObjTwo";
            var lastInitObject = Settings.GetInitializationObject(Settings.InitializationObjects.Count - 1);
            int initObjectsCount = Settings.InitializationObjects.Count;
            Settings.AddInitializationObject(testInitObject as IObjectInitializationDataProvider);

            /* Cleanup */
            Assert.IsTrue(Settings.RemoveInitializationObject(Settings.InitializationObjects.Count - 1));
            Assert.AreEqual(initObjectsCount, Settings.InitializationObjects.Count);
            Assert.AreEqual(lastInitObject, Settings.GetInitializationObject(Settings.InitializationObjects.Count - 1));
        }

        [Test]
        public void AddressableAssetSettings_AddInitializationObject_CannotAddInvalidInitializationObject()
        {
            int currentInitObjectsCount = Settings.InitializationObjects.Count;
            ScriptableObject initObject = null;
            Assert.IsFalse(Settings.AddInitializationObject(initObject as IObjectInitializationDataProvider));
            Assert.IsNull(Settings.GetInitializationObject(Settings.InitializationObjects.Count - 1));

            var initTestObject = new InitializationObejctTest();
            Assert.IsFalse(Settings.AddInitializationObject(initTestObject as IObjectInitializationDataProvider));
            Assert.AreEqual(currentInitObjectsCount, Settings.InitializationObjects.Count);
            Assert.IsNull(Settings.GetDataBuilder(Settings.InitializationObjects.Count - 1));
        }

        [Test]
        public void AddressableAssetSettings_SetInitializationObjectAtIndex_CannotSetInvalidInitializationObject()
        {
            int currentInitObjectsCount = Settings.InitializationObjects.Count;
            ScriptableObject initObject = null;
            Assert.IsFalse(Settings.SetInitializationObjectAtIndex(Settings.InitializationObjects.Count - 1, initObject as IObjectInitializationDataProvider));
            Assert.IsNull(Settings.GetInitializationObject(Settings.InitializationObjects.Count - 1));

            var initTestObject = new InitializationObejctTest();
            Assert.IsFalse(Settings.SetInitializationObjectAtIndex(Settings.InitializationObjects.Count - 1, initTestObject as IObjectInitializationDataProvider));

            var testInitObject = ScriptableObject.CreateInstance<InitializeScriptable>();
            testInitObject.name = "testObj";
            Settings.AddInitializationObject(testInitObject as IObjectInitializationDataProvider);
            Assert.IsFalse(Settings.SetInitializationObjectAtIndex(2, testInitObject));
        }

        [Test]
        public void AddressableAssetSettings_GetInitializationObject_CannotGetInvalidInitializationObject()
        {
            int currentInitObjectsCount = Settings.InitializationObjects.Count;
            Assert.IsNull(Settings.GetInitializationObject(Settings.InitializationObjects.Count - 1));
            Assert.IsNull(Settings.GetInitializationObject(-1));
        }

        [Test]
        public void AddressableAssetSettings_RemoveInitializationObject_CannotRemoveNonExistentInitializationObject()
        {
            Assert.IsFalse(Settings.RemoveInitializationObject(Settings.InitializationObjects.Count));
        }

        [Test]
        public void AddressableAssetSettings_GetInitializationObject_CannotGetNonExistentInitializationObject()
        {
            Assert.IsNull(Settings.GetInitializationObject(Settings.InitializationObjects.Count));
        }

        [Test]
        public void AddressableAssetSettings_GetInitializationObject_CannotGetInitializationObjectFromEmptyList()
        {
            var testSettings = new AddressableAssetSettings();
            while (!IsNullOrEmpty(testSettings.InitializationObjects))
            {
                testSettings.RemoveInitializationObject(0);
            }

            Assert.AreEqual(0, testSettings.InitializationObjects.Count);
            Assert.IsNull(testSettings.GetInitializationObject(1));
        }

        [Test]
        public void AddressableAssetSettings_MoveAssetsFromResources_CanMoveAssetsFromResources()
        {
            // Setup
            var testGuidsToPaths = new Dictionary<string, string>();
            var testObject = new GameObject("TestObjectMoveAssets");
            PrefabUtility.SaveAsPrefabAsset(testObject, ConfigFolder + "/testasset.prefab");
            var testAssetGUID = AssetDatabase.AssetPathToGUID(ConfigFolder + "/testasset.prefab");
            Settings.CreateOrMoveEntry(testAssetGUID, Settings.FindGroup(AddressableAssetSettings.PlayerDataGroupName));
            var originalAssetEntry = Settings.CreateOrMoveEntry(m_AssetGUID, Settings.FindGroup(AddressableAssetSettings.PlayerDataGroupName));
            var prevAddress = originalAssetEntry.address;
            var prevDC = EditorUtility.GetDirtyCount(Settings);
            var prevGroup = originalAssetEntry.parentGroup;
            var prevPath = AssetDatabase.GUIDToAssetPath(m_AssetGUID);
            var prevPathTwo = AssetDatabase.GUIDToAssetPath(testAssetGUID);
            var testGroup = Settings.FindGroup(AddressableAssetSettings.DefaultLocalGroupName);
            var testAssetPath = TestFolder + "/testMoveAssets";
            testGuidsToPaths[m_AssetGUID] = testAssetPath + "/resources/test.prefab";
            testGuidsToPaths[testAssetGUID] = testAssetPath + "/resources/testasset.prefab";

            // Test
            Settings.MoveAssetsFromResources(testGuidsToPaths, testGroup);
            var dc = EditorUtility.GetDirtyCount(Settings);
            Assert.AreNotEqual(prevPath, AssetDatabase.GUIDToAssetPath(m_AssetGUID));
            Assert.AreNotEqual(prevPathTwo, AssetDatabase.GUIDToAssetPath(testAssetGUID));
            Assert.AreNotEqual(prevGroup, Settings.FindAssetEntry(m_AssetGUID).parentGroup);
            Assert.AreNotEqual(prevGroup, Settings.FindAssetEntry(testAssetGUID).parentGroup);
            Assert.AreEqual(prevDC + 1, dc);

            testGuidsToPaths[m_AssetGUID] = TestFolder + "/test.prefab";
            testGuidsToPaths[testAssetGUID] = TestFolder + "/testasset.prefab";
            Settings.MoveAssetsFromResources(testGuidsToPaths, prevGroup);
            originalAssetEntry = Settings.FindAssetEntry(m_AssetGUID);
            Assert.AreEqual(originalAssetEntry.address, "test");

            //Cleanup
            originalAssetEntry.address = prevAddress;
            if (Directory.Exists(testAssetPath))
                AssetDatabase.DeleteAsset(testAssetPath);
            EditorBuildSettings.RemoveConfigObject(testAssetPath);
        }

        [Test]
        public void AddressableAssetSettings_MoveAssetsFromResources_AddressRespectFolderHierarchy()
        {
            // Setup
            var guidsToPaths = new Dictionary<string, string>();
            var obj = new GameObject("TestObjectMoveAssets");

            var objFolder = TestFolder + "/Resources/subfolder/subsubfolder";
            if (!Directory.Exists(objFolder))
            {
                Directory.CreateDirectory(objFolder);
            }

            var objPath = objFolder + "/testasset.prefab";
            PrefabUtility.SaveAsPrefabAsset(obj, objPath);

            var guid = AssetDatabase.AssetPathToGUID(objPath);
            var playerDataGroup = Settings.FindGroup(AddressableAssetSettings.PlayerDataGroupName);
            Settings.CreateOrMoveEntry(guid, playerDataGroup);

            var destinationFolder = TestFolder + "/testMoveAssets";
            guidsToPaths[guid] = destinationFolder + "/testasset.prefab";

            // Test
            var defaultLocalGroup = Settings.FindGroup(AddressableAssetSettings.DefaultLocalGroupName);
            Settings.MoveAssetsFromResources(guidsToPaths, defaultLocalGroup);

            var idx = objPath.ToLower().LastIndexOf("resources/");
            var expectedAddress = objPath.Substring(idx + 10).Replace(Path.GetExtension(objPath), "");
            var entry = Settings.FindAssetEntry(guid);
            Assert.AreEqual(expectedAddress, entry.address);
            Assert.AreEqual(guidsToPaths[guid], AssetDatabase.GUIDToAssetPath(guid));
            Assert.AreEqual(defaultLocalGroup, entry.parentGroup);

            //Cleanup
            if (Directory.Exists(TestFolder + "/Resources"))
                AssetDatabase.DeleteAsset(TestFolder + "/Resources");
            EditorBuildSettings.RemoveConfigObject(TestFolder + "/Resources");

            Settings.RemoveAssetEntry(guid);
            AssetDatabase.DeleteAsset(guidsToPaths[guid]);
            if (Directory.Exists(destinationFolder))
                AssetDatabase.DeleteAsset(destinationFolder);
            EditorBuildSettings.RemoveConfigObject(destinationFolder);
        }

        [Test]
        public void AddressableAssetSettings_MoveAssetsFromResources_CannotMoveNullOrInvalidAsset()
        {
            Settings.MoveAssetsFromResources(null, null);
            var testAssetEntry = Settings.CreateOrMoveEntry(m_AssetGUID, Settings.FindGroup(AddressableAssetSettings.PlayerDataGroupName));
            var currentGroup = testAssetEntry.parentGroup;
            var testGuidsToPaths = new Dictionary<string, string>();
            var currentPath = AssetDatabase.GUIDToAssetPath(m_AssetGUID);
            var newAssetPath = TestFolder + "/testMoveAssets";
            testGuidsToPaths[m_AssetGUID] = newAssetPath + "/test.prefab";
            Settings.MoveAssetsFromResources(testGuidsToPaths, null);
            Settings.MoveEntry(testAssetEntry, null);
            Assert.AreEqual(currentPath, AssetDatabase.GUIDToAssetPath(m_AssetGUID));
            Assert.AreEqual(currentGroup, Settings.FindAssetEntry(m_AssetGUID).parentGroup);
        }

        [Test]
        public void AddressableAssetSettings_SetMaxConcurrentWebRequests_CanSet()
        {
            Settings.MaxConcurrentWebRequests = 100;
            Assert.AreEqual(100, Settings.MaxConcurrentWebRequests);
        }

        [Test]
        public void AddressableAssetSettings_SetMaxConcurrentWebRequestsWithValueOutsideOfBounds_IsClamped()
        {
            Settings.MaxConcurrentWebRequests = 0;
            Assert.AreEqual(1, Settings.MaxConcurrentWebRequests);
            Settings.MaxConcurrentWebRequests = 2000;
            Assert.AreEqual(1024, Settings.MaxConcurrentWebRequests);
        }

        [TestCase(1)]
        [TestCase(5)]
        public void AddressableAssetSettings_SetLabelValueForEntries_CanSet(int numEntries)
        {
            // Setup
            List<AddressableAssetEntry> entries = new List<AddressableAssetEntry>();
            var newLabel = "testSetLabelValueForEntries";
            SetupEntries(ref entries, numEntries);
            var prevDC = EditorUtility.GetDirtyCount(Settings);

            // Test
            Settings.SetLabelValueForEntries(entries, newLabel, true, true);
            foreach (var e in entries)
                Assert.IsTrue(e.labels.Contains(newLabel));
            Assert.AreEqual(prevDC + 1, EditorUtility.GetDirtyCount(Settings));

            // Cleanup
            Settings.RemoveLabel(newLabel);
        }

        [TestCase(1, 2)]
        [TestCase(5, 8)]
        public void AddressableAssetSettings_RemoveLabel_RemoveLabelShouldRemoveDeletedLabelFromEntries(int numEntries, int numLabels)
        {
            // Setup
            List<AddressableAssetEntry> entries = new List<AddressableAssetEntry>();
            SetupEntries(ref entries, numEntries);
            List<string> testLabels = new List<string>();
            for (int i = 1; i <= numLabels; i++)
            {
                var newLabel = "testSetLabelValueForEntries" + i;
                testLabels.Add(newLabel);
                Settings.SetLabelValueForEntries(entries, newLabel, true, true);
            }

            // Test
            // Remove half the labels
            for (int i = 0; i < numLabels / 2; i++)
                Settings.RemoveLabel(testLabels[i]);

            foreach (var e in entries)
            foreach (var l in testLabels)
                Assert.IsTrue(e.labels.Contains(l));

            // Check that each of the first half of labels were removed
            foreach (var e in entries)
            {
                e.CreateKeyList();
                for (int i = 0; i < numLabels; i++)
                {
                    if (i < numLabels / 2)
                        Assert.IsFalse(e.labels.Contains(testLabels[i]));
                    else
                        Assert.IsTrue(e.labels.Contains(testLabels[i]));
                }
            }

            // Cleanup
            for (int i = numLabels / 2; i < numLabels; i++)
            {
                Settings.RemoveLabel(testLabels[i]);
            }
        }

        [Test]
        public void AddressableAssetSettings_HashChanges_WhenGroupIsAdded()
        {
            var prevHash = Settings.currentHash;
            var newGroup = Settings.CreateGroup("doesnt matter", true, false, false, null, typeof(ContentUpdateGroupSchema), typeof(BundledAssetGroupSchema));
            Assert.AreNotEqual(Settings.currentHash, prevHash);
            Settings.RemoveGroup(newGroup);
            Assert.AreEqual(Settings.currentHash, prevHash);
        }

        [Test]
        public void AddressableAssetSettings_HashChanges_WhenBuildSettingsChange()
        {
            var initialSetting = Settings.buildSettings.LogResourceManagerExceptions;
            var initialHash = Settings.currentHash;
            Settings.buildSettings.LogResourceManagerExceptions = !initialSetting;
            Assert.AreNotEqual(Settings.currentHash, initialHash);
            Settings.buildSettings.LogResourceManagerExceptions = initialSetting;
            Assert.AreEqual(Settings.currentHash, initialHash);
        }

        [Test]
        public void AddressableAssetSettings_HashChanges_HandleNullGroups()
        {
            var prevHash = Settings.currentHash;
            var newGroup = Settings.CreateGroup("doesnt matter", true, false, false, null, typeof(ContentUpdateGroupSchema), typeof(BundledAssetGroupSchema));
            Assert.AreNotEqual(Settings.currentHash, prevHash);

            var groupAddedHash = Settings.currentHash;

            // so delete the file, then we should be able to iterate through groups and ensure we find a null reference
            var groupFile = Settings.ConfigFolder + "/AssetGroups/doesnt matter.asset";
            Assert.True(File.Exists(groupFile));
            AssetDatabase.DeleteAsset(groupFile);

            // SetDirty hasn't been called so the hash stays the same
            Assert.AreEqual(Settings.currentHash, groupAddedHash);

            // add a real null group, does not call SetDirty
            Settings.groups.Add(null);
            Assert.AreEqual(Settings.currentHash, groupAddedHash);

            // calling SetDirty manually ignores both the deleted and null groups and we return to the initial hash
            Settings.SetDirty(ModificationEvent.GroupAdded, null, true);
            Assert.AreEqual(Settings.currentHash, prevHash);

            // count does not count null groups so equal, SetDirty is called and reverts to original
            Settings.RemoveGroup(newGroup);
            Assert.AreEqual(Settings.currentHash, prevHash);

            // count is the same, should be equal
            Settings.RemoveGroup(null);
            Assert.AreEqual(Settings.currentHash, prevHash);
        }

        [Test]
        public void CustomEntryCommand_WhenRegistered_InvokeIsCalled()
        {
            string notSet = null;
            AddressableAssetSettings.RegisterCustomAssetEntryCommand("cmd1", s => notSet = "set");
            Assert.IsTrue(AddressableAssetSettings.InvokeAssetEntryCommand("cmd1", new AddressableAssetEntry[] { }));
            Assert.AreEqual("set", notSet);
            AddressableAssetSettings.UnregisterCustomAssetEntryCommand("cmd1");
        }

        [Test]
        public void CustomEntryCommand_WhenCommandThrows_InvokeDoesNotThrow()
        {
            AddressableAssetSettings.RegisterCustomAssetEntryCommand("cmd1", s => throw new Exception());
            Assert.DoesNotThrow(() =>
            {
                LogAssert.Expect(LogType.Error, $"Encountered exception when running Asset Entry Command 'cmd1': Exception of type 'System.Exception' was thrown.");
                Assert.IsFalse(AddressableAssetSettings.InvokeAssetEntryCommand("cmd1", new AddressableAssetEntry[] { }));
            });
            AddressableAssetSettings.UnregisterCustomAssetEntryCommand("cmd1");
        }

        [Test]
        public void CustomEntryCommand_WhenCommandHasNullEntries_ReturnsFalseAndLogsError()
        {
            AddressableAssetSettings.RegisterCustomAssetEntryCommand("cmd1", s => { });
            Assert.DoesNotThrow(() =>
            {
                LogAssert.Expect(LogType.Error, $"Asset Entry Command 'cmd1' called with null entry collection.");
                Assert.IsFalse(AddressableAssetSettings.InvokeAssetEntryCommand("cmd1", null));
            });
            AddressableAssetSettings.UnregisterCustomAssetEntryCommand("cmd1");
        }

        [Test]
        public void CustomEntryCommand_WhenCommandDoesNotExist_ReturnsFalseAndLogsError()
        {
            Assert.DoesNotThrow(() =>
            {
                LogAssert.Expect(LogType.Error, $"Asset Entry Command 'cmd' not found.  Ensure that it is registered by calling RegisterCustomAssetEntryCommand.");
                Assert.IsFalse(AddressableAssetSettings.InvokeAssetEntryCommand("cmd", new AddressableAssetEntry[] { }));
            });
        }

        [Test]
        public void CustomEntryCommand_RegisterWithValidIdAndFunc_Succeeds()
        {
            AddressableAssetSettings.RegisterCustomAssetEntryCommand("cmd1", s => { });
            CollectionAssert.Contains(AddressableAssetSettings.CustomAssetEntryCommands, "cmd1");
            AddressableAssetSettings.UnregisterCustomAssetEntryCommand("cmd1");
        }

        [Test]
        public void CustomEntryCommand_UnregisterWithInvalidIdParameters_Fails()
        {
            LogAssert.Expect(LogType.Error, "UnregisterCustomAssetEntryCommand - invalid command id.");
            Assert.IsFalse(AddressableAssetSettings.UnregisterCustomAssetEntryCommand(""));
            LogAssert.Expect(LogType.Error, "UnregisterCustomAssetEntryCommand - invalid command id.");
            Assert.IsFalse(AddressableAssetSettings.UnregisterCustomAssetEntryCommand(null));
            LogAssert.Expect(LogType.Error, $"UnregisterCustomAssetEntryCommand - command id 'doesntexist' is not registered.");
            Assert.IsFalse(AddressableAssetSettings.UnregisterCustomAssetEntryCommand("doesntexist"));
            CollectionAssert.IsEmpty(AddressableAssetSettings.CustomAssetEntryCommands);
        }

        [Test]
        public void CustomEntryCommand_RegisterWithInvalidParameters_Fails()
        {
            LogAssert.Expect(LogType.Error, "RegisterCustomAssetEntryCommand - invalid command id.");
            Assert.IsFalse(AddressableAssetSettings.RegisterCustomAssetEntryCommand("", s => { }));
            LogAssert.Expect(LogType.Error, "RegisterCustomAssetEntryCommand - invalid command id.");
            Assert.IsFalse(AddressableAssetSettings.RegisterCustomAssetEntryCommand(null, s => { }));
            LogAssert.Expect(LogType.Error, $"RegisterCustomAssetEntryCommand - command functor for id 'valid'.");
            Assert.IsFalse(AddressableAssetSettings.RegisterCustomAssetEntryCommand("valid", null));
            CollectionAssert.IsEmpty(AddressableAssetSettings.CustomAssetEntryCommands);
        }

        [Test]
        public void CustomGroupCommand_WhenRegistered_InvokeIsCalled()
        {
            string notSet = null;
            AddressableAssetSettings.RegisterCustomAssetGroupCommand("cmd1", s => notSet = "set");
            AddressableAssetSettings.InvokeAssetGroupCommand("cmd1", new AddressableAssetGroup[] { });
            Assert.AreEqual("set", notSet);
            AddressableAssetSettings.UnregisterCustomAssetGroupCommand("cmd1");
        }

        [Test]
        public void CustomGroupCommand_RegisterWithValidIdAndFunc_Succeeds()
        {
            AddressableAssetSettings.RegisterCustomAssetGroupCommand("cmd1", s => { });
            CollectionAssert.Contains(AddressableAssetSettings.CustomAssetGroupCommands, "cmd1");
            AddressableAssetSettings.UnregisterCustomAssetGroupCommand("cmd1");
        }

        [Test]
        public void CustomGroupCommand_UnregisterWithInvalidIdParameters_Fails()
        {
            LogAssert.Expect(LogType.Error, "UnregisterCustomAssetGroupCommand - invalid command id.");
            Assert.IsFalse(AddressableAssetSettings.UnregisterCustomAssetGroupCommand(""));
            LogAssert.Expect(LogType.Error, "UnregisterCustomAssetGroupCommand - invalid command id.");
            Assert.IsFalse(AddressableAssetSettings.UnregisterCustomAssetGroupCommand(null));
            LogAssert.Expect(LogType.Error, $"UnregisterCustomAssetGroupCommand - command id 'doesntexist' is not registered.");
            Assert.IsFalse(AddressableAssetSettings.UnregisterCustomAssetGroupCommand("doesntexist"));
            CollectionAssert.IsEmpty(AddressableAssetSettings.CustomAssetGroupCommands);
        }

        [Test]
        public void CustomGroupCommand_RegisterWithInvalidParameters_Fails()
        {
            LogAssert.Expect(LogType.Error, "RegisterCustomAssetGroupCommand - invalid command id.");
            Assert.IsFalse(AddressableAssetSettings.RegisterCustomAssetGroupCommand("", s => { }));
            LogAssert.Expect(LogType.Error, "RegisterCustomAssetGroupCommand - invalid command id.");
            Assert.IsFalse(AddressableAssetSettings.RegisterCustomAssetGroupCommand(null, s => { }));
            LogAssert.Expect(LogType.Error, $"RegisterCustomAssetGroupCommand - command functor for id 'valid'.");
            Assert.IsFalse(AddressableAssetSettings.RegisterCustomAssetGroupCommand("valid", null));
            CollectionAssert.IsEmpty(AddressableAssetSettings.CustomAssetGroupCommands);
        }

        [Test]
        public void CustomGroupCommand_WhenCommandThrows_InvokeDoesNotThrow()
        {
            AddressableAssetSettings.RegisterCustomAssetGroupCommand("cmd1", s => throw new Exception());
            Assert.DoesNotThrow(() =>
            {
                LogAssert.Expect(LogType.Error, $"Encountered exception when running Asset Group Command 'cmd1': Exception of type 'System.Exception' was thrown.");
                Assert.IsFalse(AddressableAssetSettings.InvokeAssetGroupCommand("cmd1", new AddressableAssetGroup[] { }));
            });
            AddressableAssetSettings.UnregisterCustomAssetGroupCommand("cmd1");
        }

        [Test]
        public void CustomGroupCommand_WhenCommandHasNullGroups_ReturnsFalseAndLogsError()
        {
            AddressableAssetSettings.RegisterCustomAssetGroupCommand("cmd1", s => { });
            Assert.DoesNotThrow(() =>
            {
                LogAssert.Expect(LogType.Error, $"Asset Group Command 'cmd1' called with null group collection.");
                Assert.IsFalse(AddressableAssetSettings.InvokeAssetGroupCommand("cmd1", null));
            });
            AddressableAssetSettings.UnregisterCustomAssetGroupCommand("cmd1");
        }

        [Test]
        public void CustomGroupCommand_WhenCommandDoesNotExist_ReturnsFalseAndLogsError()
        {
            Assert.DoesNotThrow(() =>
            {
                LogAssert.Expect(LogType.Error, $"Asset Group Command 'cmd' not found.  Ensure that it is registered by calling RegisterCustomAssetGroupCommand.");
                Assert.IsFalse(AddressableAssetSettings.InvokeAssetGroupCommand("cmd", new AddressableAssetGroup[] { }));
            });
        }

        [Test]
        public void AssetGroupSchemaTemplate_CreateTemplate()
        {
            string description = "This is a Test Schema";
            string groupName = "testGroup";
            var testSchemaTemplate = AddressableAssetGroupSchemaTemplate.Create(
                groupName, description, typeof(CustomTestSchema));
            Assert.AreEqual(testSchemaTemplate.Description, description);
            Assert.AreEqual(testSchemaTemplate.DisplayName, groupName);
            Assert.IsNotNull(testSchemaTemplate.GetTypes());
        }

        [Test]
        public void NullifyBundleFileIds_SetsBundleFileIdsToNull()
        {
            AddressableAssetSettings.NullifyBundleFileIds(Settings);
            foreach (var group in Settings.groups)
            {
                foreach (var entry in group.entries)
                {
                    Assert.IsNull(entry.BundleFileId);
                }
            }
        }

        [Test]
        public void ReloadSettings_ClearVersionOverride()
        {
            Settings.OverridePlayerVersion = "";
            ReloadSettings();
            Assert.AreEqual("", Settings.OverridePlayerVersion);
        }
    }
}