first commit

Library/PackageCache/com.unity.settings-manager@2.0.1/Tests/Editor/FileRepositoryTests.cs

@@ -0,0 +1,58 @@
+using System.IO;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEditor.SettingsManagement;
+
+namespace UnityEngine.SettingsManagement.EditorTests
+{
+	public class FileRepositoryTests : SettingsTestBase
+	{
+		Settings m_Settings;
+		FileSettingsRepository m_Repository;
+
+		[SetUp]
+		public void SetUp()
+		{
+			m_Settings = new Settings(new [] { m_Repository = new ProjectUserSettings(k_PackageName) } );
+		}
+
+		[TearDown]
+		public void TearDown()
+		{
+			if (File.Exists(m_Repository.path))
+				File.Delete(m_Repository.path);
+		}
+
+		[Test]
+		public void CallingSaveMultipleTimes_OnlySavesWhenContentsChange()
+		{
+			m_Settings.Set<int, FileSettingsRepository>("save-int", 42);
+			m_Settings.Save();
+			var write = File.GetLastWriteTime(m_Repository.path);
+
+			// verify that setting was serialized
+			Assume.That(File.Exists(m_Repository.path));
+			var readback = new Settings(new [] { new ProjectUserSettings(k_PackageName) } );
+			Assume.That(readback.Get<int, FileSettingsRepository>("save-int"), Is.EqualTo(42));
+
+			// set the same value and save
+			m_Settings.Set<int, FileSettingsRepository>("save-int", 42);
+			m_Settings.Save();
+
+			// save file should not be touched since nothing change
+			Assert.That(write, Is.EqualTo(File.GetLastWriteTime(m_Repository.path)));
+		}
+
+		[Test]
+		public void SaveFileSettingsRepository_WritesFile()
+		{
+			m_Settings.Set<int, FileSettingsRepository>("save-int", 42);
+			m_Settings.Save();
+
+			Assume.That(File.Exists(m_Repository.path));
+
+			var readback = new Settings(new [] { new ProjectUserSettings(k_PackageName) } );
+			Assert.That(readback.Get<int, FileSettingsRepository>("save-int"), Is.EqualTo(42));
+		}
+	}
+}

Library/PackageCache/com.unity.settings-manager@2.0.1/Tests/Editor/FileRepositoryTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 11aab40bae0d491c94ca2df97f155bac
+timeCreated: 1604872266

Library/PackageCache/com.unity.settings-manager@2.0.1/Tests/Editor/MultipleProjectSettings.cs

@@ -0,0 +1,85 @@
+using System.IO;
+using NUnit.Framework;
+using UnityEditor.SettingsManagement;
+
+namespace UnityEngine.SettingsManagement.EditorTests
+{
+	class MultipleProjectSettings : SettingsTestBase
+	{
+		const string k_SettingsFileA = "FileA";
+		const string k_SettingsFileB = "FileB";
+
+		[TearDown]
+		public void Teardown()
+		{
+			var expectedPath = PackageSettingsRepository.GetSettingsPath(k_PackageName);
+			var expectedPathA = PackageSettingsRepository.GetSettingsPath(k_PackageName, k_SettingsFileA);
+			var expectedPathB = PackageSettingsRepository.GetSettingsPath(k_PackageName, k_SettingsFileB);
+
+			if(File.Exists(expectedPath))
+				File.Delete(expectedPath);
+
+			if(File.Exists(expectedPathA))
+				File.Delete(expectedPathA);
+
+			if(File.Exists(expectedPathB))
+				File.Delete(expectedPathB);
+		}
+
+		[Test]
+		public void NewSettingsInstance_CreatesUserAndProjectSettings()
+		{
+			var expectedPath = PackageSettingsRepository.GetSettingsPath(k_PackageName);
+
+			Assume.That(File.Exists(expectedPath), Is.False);
+
+			var settings = new Settings(k_PackageName);
+			settings.Save();
+
+			Assert.That(File.Exists(expectedPath), Is.True);
+		}
+
+		[Test]
+		public void NewSettingsInstance_SupportsMultipleProjectRepositories()
+		{
+			var expectedPathA = PackageSettingsRepository.GetSettingsPath(k_PackageName, "FileA");
+			var expectedPathB = PackageSettingsRepository.GetSettingsPath(k_PackageName, "FileB");
+
+			Assume.That(File.Exists(expectedPathA), Is.False);
+			Assume.That(File.Exists(expectedPathB), Is.False);
+
+			var settings = new Settings(new ISettingsRepository[]
+			{
+				new PackageSettingsRepository(k_PackageName, "FileA"),
+				new PackageSettingsRepository(k_PackageName, "FileB")
+			});
+
+			settings.Save();
+
+			Assert.That(File.Exists(expectedPathA), Is.True);
+			Assert.That(File.Exists(expectedPathB), Is.True);
+		}
+
+		[Test]
+		public void MultipleNamedProjectSettings_StoreSettingsSeparately()
+		{
+			var expectedPathA = PackageSettingsRepository.GetSettingsPath(k_PackageName, "FileA");
+			var expectedPathB = PackageSettingsRepository.GetSettingsPath(k_PackageName, "FileB");
+
+			Assume.That(File.Exists(expectedPathA), Is.False);
+			Assume.That(File.Exists(expectedPathB), Is.False);
+
+			var settings = new Settings(new ISettingsRepository[]
+			{
+				new PackageSettingsRepository(k_PackageName, "FileA"),
+				new PackageSettingsRepository(k_PackageName, "FileB")
+			});
+
+			settings.Set<int>("value_a", 32, "FileA");
+			settings.Set<int>("value_a", 64, "FileB");
+
+			Assert.That(settings.Get<int>("value_a", "FileA"), Is.EqualTo(32));
+			Assert.That(settings.Get<int>("value_a", "FileB"), Is.EqualTo(64));
+		}
+	}
+}

Library/PackageCache/com.unity.settings-manager@2.0.1/Tests/Editor/MultipleProjectSettings.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 018f1adb8258a4133b73805294498947
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.settings-manager@2.0.1/Tests/Editor/SettingsTestBase.cs

@@ -0,0 +1,7 @@
+namespace UnityEngine.SettingsManagement.EditorTests
+{
+	public class SettingsTestBase
+	{
+		public const string k_PackageName = "com.unity.settings-manager.tests";
+	}
+}

Library/PackageCache/com.unity.settings-manager@2.0.1/Tests/Editor/SettingsTestBase.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f7e6fc076c9242b19d42a4b2cc9d0507
+timeCreated: 1604857156

Library/PackageCache/com.unity.settings-manager@2.0.1/Tests/Editor/SettingsTests.cs

@@ -0,0 +1,385 @@
+using System;
+using System.IO;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEditor.SettingsManagement;
+using UnityEngine.TestTools;
+
+namespace UnityEngine.SettingsManagement.EditorTests
+{
+	class SettingsTests : SettingsTestBase, IPrebuildSetup, IPostBuildCleanup
+	{
+		static Settings s_Settings;
+
+		static string projectSettingsPath
+		{
+			get { return PackageSettingsRepository.GetSettingsPath(k_PackageName); }
+		}
+
+		static Settings settings
+		{
+			get
+			{
+				if (s_Settings == null)
+					s_Settings = new Settings(k_PackageName);
+				return s_Settings;
+			}
+		}
+
+		public void Setup()
+		{
+		}
+
+		public void Cleanup()
+		{
+			foreach (var v in s_AllPreferences)
+				v.Delete();
+
+			if (File.Exists(projectSettingsPath))
+				File.Delete(projectSettingsPath);
+		}
+
+		[Serializable]
+		struct DummyStruct : IEquatable<DummyStruct>
+		{
+			public string stringValue;
+			public int intValue;
+
+			public DummyStruct(string s, int i)
+			{
+				stringValue = s;
+				intValue = i;
+			}
+
+			public static DummyStruct defaultValue
+			{
+				get { return new DummyStruct("I'm a string!", 42); }
+			}
+
+			public bool Equals(DummyStruct other)
+			{
+				return string.Equals(stringValue, other.stringValue) && intValue == other.intValue;
+			}
+
+			public override bool Equals(object obj)
+			{
+				if (ReferenceEquals(null, obj))
+					return false;
+				return obj is DummyStruct && Equals((DummyStruct)obj);
+			}
+
+			public override int GetHashCode()
+			{
+				unchecked
+				{
+					return ((stringValue != null ? stringValue.GetHashCode() : 0) * 397) ^ intValue;
+				}
+			}
+
+			public static bool operator ==(DummyStruct left, DummyStruct right)
+			{
+				return left.Equals(right);
+			}
+
+			public static bool operator !=(DummyStruct left, DummyStruct right)
+			{
+				return !left.Equals(right);
+			}
+
+			public override string ToString()
+			{
+				return stringValue + "  " + intValue;
+			}
+		}
+
+		[Serializable]
+		class DummyClass : IEquatable<DummyClass>
+		{
+			public string stringValue;
+			public int intValue;
+
+			public DummyClass(string s, int i)
+			{
+				stringValue = s;
+				intValue = i;
+			}
+
+			public static DummyClass defaultValue
+			{
+				get { return new DummyClass("I'm a string!", 42); }
+			}
+
+			public bool Equals(DummyClass other)
+			{
+				return string.Equals(stringValue, other.stringValue) && intValue == other.intValue;
+			}
+
+			public override bool Equals(object obj)
+			{
+				if (ReferenceEquals(null, obj))
+					return false;
+				return obj is DummyClass && Equals((DummyClass)obj);
+			}
+
+			public override int GetHashCode()
+			{
+				unchecked
+				{
+					return ((stringValue != null ? stringValue.GetHashCode() : 0) * 397) ^ intValue;
+				}
+			}
+
+			public static bool operator ==(DummyClass left, DummyClass right)
+			{
+				return left.Equals(right);
+			}
+
+			public static bool operator !=(DummyClass left, DummyClass right)
+			{
+				return !left.Equals(right);
+			}
+
+			public override string ToString()
+			{
+				return stringValue + "  " + intValue;
+			}
+		}
+
+		static UserSetting<bool> s_StaticBoolUser = new UserSetting<bool>(settings, "tests.user.static.bool", true, SettingsScope.User);
+		static UserSetting<bool> s_StaticBoolProject = new UserSetting<bool>(settings, "tests.project.static.bool", true, SettingsScope.Project);
+
+		static UserSetting<string> s_StaticStringUser = new UserSetting<string>(settings, "tests.user.static.string", "Hello, world!", SettingsScope.User);
+		static UserSetting<string> s_StaticStringProject = new UserSetting<string>(settings, "tests.project.static.string", "Goodbye, world!", SettingsScope.Project);
+
+		static UserSetting<DummyStruct> s_StaticStructUser = new UserSetting<DummyStruct>(settings, "tests.user.static.struct", DummyStruct.defaultValue, SettingsScope.User);
+		static UserSetting<DummyStruct> s_StaticStructProject = new UserSetting<DummyStruct>(settings, "tests.project.static.struct", DummyStruct.defaultValue, SettingsScope.Project);
+
+		static UserSetting<DummyClass> s_StaticClassUser = new UserSetting<DummyClass>(settings, "tests.user.static.class", DummyClass.defaultValue, SettingsScope.User);
+		static UserSetting<DummyClass> s_StaticClassProject = new UserSetting<DummyClass>(settings, "tests.project.static.class", DummyClass.defaultValue, SettingsScope.Project);
+
+		static IUserSetting[] s_AllPreferences = new IUserSetting[]
+		{
+			s_StaticBoolUser,
+			s_StaticBoolProject,
+			s_StaticStringUser,
+			s_StaticStringProject,
+			s_StaticStructUser,
+			s_StaticStructProject,
+			s_StaticClassUser,
+			s_StaticClassProject
+		};
+
+		[Test]
+		public static void DefaultsAreCorrect()
+		{
+			foreach (var pref in s_AllPreferences)
+				pref.Reset();
+
+			Assert.IsTrue((bool)s_StaticBoolUser, s_StaticBoolUser.ToString());
+			Assert.IsTrue((bool)s_StaticBoolProject, s_StaticBoolProject.ToString());
+
+			Assert.AreEqual("Hello, world!", (string)s_StaticStringUser, s_StaticStringUser.ToString());
+			Assert.AreEqual("Goodbye, world!", (string)s_StaticStringProject, s_StaticStringProject.ToString());
+
+			Assert.AreEqual(DummyStruct.defaultValue, (DummyStruct)s_StaticStructUser, s_StaticStructUser.ToString());
+			Assert.AreEqual(DummyStruct.defaultValue, (DummyStruct)s_StaticStructProject, s_StaticStructProject.ToString());
+
+			Assert.AreEqual(DummyClass.defaultValue, (DummyClass)s_StaticClassUser, s_StaticClassUser.ToString());
+			Assert.AreEqual(DummyClass.defaultValue, (DummyClass)s_StaticClassProject, s_StaticClassProject.ToString());
+		}
+
+		[Test]
+		public static void SetValue()
+		{
+			// BOOl
+			s_StaticBoolUser.value = false;
+			s_StaticBoolProject.value = false;
+
+			Assert.IsFalse((bool)s_StaticBoolUser);
+			Assert.IsFalse((bool)s_StaticBoolProject);
+
+			// STRING
+			s_StaticStringUser.value = "Some more text";
+			s_StaticStringProject.value = "Some text here";
+
+			Assert.AreEqual("Some more text", (string)s_StaticStringUser);
+			Assert.AreEqual("Some text here", (string)s_StaticStringProject);
+
+			// STRUCT
+			var userStruct = new DummyStruct("Changed text", 23);
+			var projectStruct = new DummyStruct("Slightly different text", -9825);
+
+			s_StaticStructUser.SetValue(userStruct);
+			s_StaticStructProject.SetValue(projectStruct);
+
+			Assert.AreEqual(userStruct, (DummyStruct)s_StaticStructUser);
+			Assert.AreEqual(projectStruct, (DummyStruct)s_StaticStructProject);
+
+			// CLASS
+			var userClass = new DummyClass("Changed text", 23);
+			var projectClass = new DummyClass("Slightly different text", -9825);
+
+			s_StaticClassUser.SetValue(userClass);
+			s_StaticClassProject.SetValue(projectClass);
+
+			Assert.AreEqual(userClass, (DummyClass)s_StaticClassUser);
+			Assert.AreEqual(projectClass, (DummyClass)s_StaticClassProject);
+		}
+
+		[Test]
+		public static void SetAndReset()
+		{
+			// BOOL
+			s_StaticBoolUser.value = false;
+			s_StaticBoolProject.value = false;
+
+			// STRING
+			s_StaticStringUser.value = "Some more text";
+			s_StaticStringProject.value = "Some text here";
+
+			// STRUCT
+			s_StaticStructUser.SetValue(new DummyStruct("Changed text", 23));
+			s_StaticStructProject.SetValue(new DummyStruct("Slightly different text", -9825));
+
+			// CLASS
+			s_StaticClassUser.SetValue(new DummyClass("Changed text", 23));
+			s_StaticClassProject.SetValue(new DummyClass("Slightly different text", -9825));
+
+			Assert.IsFalse((bool)s_StaticBoolUser);
+			Assert.IsFalse((bool)s_StaticBoolProject);
+
+			Assert.AreNotEqual("Hello, world!", (string)s_StaticStringUser);
+			Assert.AreNotEqual("Goodbye, world!", (string)s_StaticStringProject);
+
+			Assert.AreNotEqual(DummyStruct.defaultValue, (DummyStruct)s_StaticStructUser);
+			Assert.AreNotEqual(DummyStruct.defaultValue, (DummyStruct)s_StaticStructProject);
+
+			Assert.AreNotEqual(DummyClass.defaultValue, (DummyClass)s_StaticClassUser);
+			Assert.AreNotEqual(DummyClass.defaultValue, (DummyClass)s_StaticClassProject);
+
+			foreach (var pref in s_AllPreferences)
+				pref.Reset();
+
+			Assert.IsTrue((bool)s_StaticBoolUser);
+			Assert.IsTrue((bool)s_StaticBoolProject);
+
+			Assert.AreEqual("Hello, world!", (string)s_StaticStringUser);
+			Assert.AreEqual("Goodbye, world!", (string)s_StaticStringProject);
+
+			Assert.AreEqual(DummyStruct.defaultValue, (DummyStruct)s_StaticStructUser);
+			Assert.AreEqual(DummyStruct.defaultValue, (DummyStruct)s_StaticStructProject);
+
+			Assert.AreEqual(DummyClass.defaultValue, (DummyClass)s_StaticClassUser);
+			Assert.AreEqual(DummyClass.defaultValue, (DummyClass)s_StaticClassProject);
+			}
+
+		[Test]
+		public static void SerializeAndLoad()
+		{
+			foreach (var pref in s_AllPreferences)
+				pref.Reset();
+			settings.Save();
+
+			var instance = new Settings(k_PackageName);
+
+			Assert.AreEqual((bool)s_StaticBoolUser, instance.Get<bool>(s_StaticBoolUser.key, s_StaticBoolUser.scope));
+			Assert.AreEqual((bool)s_StaticBoolProject, instance.Get<bool>(s_StaticBoolProject.key, s_StaticBoolProject.scope));
+			Assert.AreEqual((string)s_StaticStringUser, instance.Get<string>(s_StaticStringUser.key, s_StaticStringUser.scope));
+			Assert.AreEqual((string)s_StaticStringProject, instance.Get<string>(s_StaticStringProject.key, s_StaticStringProject.scope));
+			Assert.AreEqual((DummyStruct)s_StaticStructUser, instance.Get<DummyStruct>(s_StaticStructUser.key, s_StaticStructUser.scope));
+			Assert.AreEqual((DummyStruct)s_StaticStructProject, instance.Get<DummyStruct>(s_StaticStructProject.key, s_StaticStructProject.scope));
+			Assert.AreEqual((DummyClass)s_StaticClassUser, instance.Get<DummyClass>(s_StaticClassUser.key, s_StaticClassUser.scope));
+			Assert.AreEqual((DummyClass)s_StaticClassProject, instance.Get<DummyClass>(s_StaticClassProject.key, s_StaticClassProject.scope));
+		}
+
+		[Test]
+		public static void DeleteKeys()
+		{
+			foreach (var pref in s_AllPreferences)
+				pref.Delete();
+
+			settings.Save();
+
+			var instance = new Settings(k_PackageName);
+
+			Assert.IsFalse(instance.ContainsKey<bool>("tests.user.static.bool", SettingsScope.User), "tests.user.static.bool");
+			Assert.IsFalse(instance.ContainsKey<bool>("tests.project.static.bool", SettingsScope.Project), "tests.project.static.bool");
+			Assert.IsFalse(instance.ContainsKey<string>("tests.user.static.string", SettingsScope.User), "tests.user.static.string");
+			Assert.IsFalse(instance.ContainsKey<string>("tests.project.static.string", SettingsScope.Project), "tests.project.static.string");
+			Assert.IsFalse(instance.ContainsKey<DummyStruct>("tests.user.static.struct", SettingsScope.User), "tests.user.static.struct");
+			Assert.IsFalse(instance.ContainsKey<DummyStruct>("tests.project.static.struct", SettingsScope.Project), "tests.project.static.struct");
+			Assert.IsFalse(instance.ContainsKey<DummyClass>("tests.user.static.class", SettingsScope.User), "tests.user.static.class");
+			Assert.IsFalse(instance.ContainsKey<DummyClass>("tests.project.static.class", SettingsScope.Project), "tests.project.static.class");
+		}
+
+		[Test]
+		public static void KeysExistInSettingsInstance()
+		{
+			foreach (var pref in s_AllPreferences)
+				pref.Reset();
+
+			settings.Save();
+
+			Assert.IsTrue(settings.ContainsKey<bool>("tests.user.static.bool", SettingsScope.User), "tests.user.static.bool");
+			Assert.IsTrue(settings.ContainsKey<bool>("tests.project.static.bool", SettingsScope.Project), "tests.project.static.bool");
+			Assert.IsTrue(settings.ContainsKey<string>("tests.user.static.string", SettingsScope.User), "tests.user.static.string");
+			Assert.IsTrue(settings.ContainsKey<string>("tests.project.static.string", SettingsScope.Project), "tests.project.static.string");
+			Assert.IsTrue(settings.ContainsKey<DummyStruct>("tests.user.static.struct", SettingsScope.User), "tests.user.static.struct");
+			Assert.IsTrue(settings.ContainsKey<DummyStruct>("tests.project.static.struct", SettingsScope.Project), "tests.project.static.struct");
+			Assert.IsTrue(settings.ContainsKey<DummyClass>("tests.user.static.class", SettingsScope.User), "tests.user.static.class");
+			Assert.IsTrue(settings.ContainsKey<DummyClass>("tests.project.static.class", SettingsScope.Project), "tests.project.static.class");
+		}
+
+		[Test]
+		public static void KeysExistInSerializedForm()
+		{
+			foreach (var pref in s_AllPreferences)
+				pref.Reset();
+
+			settings.Save();
+
+			var instance = new Settings(k_PackageName);
+
+			Assert.IsTrue(instance.ContainsKey<bool>("tests.user.static.bool", SettingsScope.User), "tests.user.static.bool");
+			Assert.IsTrue(instance.ContainsKey<bool>("tests.project.static.bool", SettingsScope.Project), "tests.project.static.bool");
+			Assert.IsTrue(instance.ContainsKey<string>("tests.user.static.string", SettingsScope.User), "tests.user.static.string");
+			Assert.IsTrue(instance.ContainsKey<string>("tests.project.static.string", SettingsScope.Project), "tests.project.static.string");
+			Assert.IsTrue(instance.ContainsKey<DummyStruct>("tests.user.static.struct", SettingsScope.User), "tests.user.static.struct");
+			Assert.IsTrue(instance.ContainsKey<DummyStruct>("tests.project.static.struct", SettingsScope.Project), "tests.project.static.struct");
+			Assert.IsTrue(instance.ContainsKey<DummyClass>("tests.user.static.class", SettingsScope.User), "tests.user.static.class");
+			Assert.IsTrue(instance.ContainsKey<DummyClass>("tests.project.static.class", SettingsScope.Project), "tests.project.static.class");
+		}
+
+		[Test]
+		public static void ChangingClassValuesSaves()
+		{
+			s_StaticClassUser.Reset();
+			s_StaticClassProject.Reset();
+
+			Assert.AreEqual(DummyClass.defaultValue, (DummyClass)s_StaticClassUser);
+			Assert.AreEqual(DummyClass.defaultValue, (DummyClass)s_StaticClassProject);
+
+			var userReference = s_StaticClassUser.value;
+			var projectReference = s_StaticClassProject.value;
+
+			userReference.intValue = 200;
+			projectReference.intValue = 200;
+
+			s_StaticClassProject.ApplyModifiedProperties();
+			s_StaticClassUser.ApplyModifiedProperties();
+
+			Assert.IsTrue(ReferenceEquals(s_StaticClassProject.value, projectReference));
+			Assert.IsTrue(ReferenceEquals(s_StaticClassUser.value, userReference));
+
+			Assert.AreEqual(200, s_StaticClassUser.value.intValue, "After ApplyModifiedProperties");
+			Assert.AreEqual(200, s_StaticClassProject.value.intValue, "After ApplyModifiedProperties");
+
+			settings.Save();
+
+			var instance = new Settings(k_PackageName);
+
+			Assert.AreEqual(200, instance.Get<DummyClass>(s_StaticClassUser.key, s_StaticClassUser.scope).intValue, "Reload Settings Instance");
+			Assert.AreEqual(200, instance.Get<DummyClass>(s_StaticClassProject.key, s_StaticClassProject.scope).intValue, "Reload Settings Instance");
+		}
+	}
+}

Library/PackageCache/com.unity.settings-manager@2.0.1/Tests/Editor/SettingsTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 767365db77168f744af8685807ad7f4b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.settings-manager@2.0.1/Tests/Editor/TestProjectUserSettings.cs

@@ -0,0 +1,36 @@
+using System.IO;
+using NUnit.Framework;
+using UnityEditor.SettingsManagement;
+using Directory = UnityEngine.Windows.Directory;
+
+namespace UnityEngine.SettingsManagement.EditorTests
+{
+	public class TestProjectUserSettings : SettingsTestBase
+	{
+		Settings m_Settings;
+		ISettingsRepository m_UserSettingsRepo;
+
+		[SetUp]
+		public void Setup()
+		{
+			m_Settings = new Settings(new [] { m_UserSettingsRepo = new ProjectUserSettings(k_PackageName) });
+			m_Settings.Save();
+		}
+
+		[TearDown]
+		public void Cleanup()
+		{
+			var dir = Path.GetDirectoryName(m_UserSettingsRepo.path);
+			if(Directory.Exists(dir))
+				Directory.Delete(dir);
+		}
+
+		[Test]
+		public void ProjectUserSettings_IsCreatedAtCorrectPath()
+		{
+			var expectedPath = $"UserSettings/Packages/{k_PackageName}/Settings.json";
+			Assert.That(m_UserSettingsRepo.path, Is.EqualTo(expectedPath));
+			Assert.That(File.Exists(expectedPath));
+		}
+	}
+}

Library/PackageCache/com.unity.settings-manager@2.0.1/Tests/Editor/TestProjectUserSettings.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ad34571c1c8d47f69e48865ba5a256d9
+timeCreated: 1604857103

Library/PackageCache/com.unity.settings-manager@2.0.1/Tests/Editor/Unity.Settings.Editor.Tests.asmdef

@@ -0,0 +1,22 @@
+{
+    "name": "Unity.Settings.Tests",
+    "references": [
+        "Unity.Settings.Editor"
+    ],
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "optionalUnityReferences": [
+        "TestAssemblies"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": []
+}

Library/PackageCache/com.unity.settings-manager@2.0.1/Tests/Editor/Unity.Settings.Editor.Tests.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: b8c9b6a82a342504c8e4a2747471d23c
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: