sample

2026-10-16 00:18:44 +00:00 · 2019-08-20 19:20:22 +09:00
parent 354a84e7d8
commit 7aa14adaf7
2259 changed files with 0 additions and 0 deletions
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f851ca8f9604f442aafccf60a6713ce9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,58 @@
+using System;
+using System.Linq;
+
+namespace UnityEditor.PackageManager.UI.Tests
+{
+    internal class MockAddOperation : MockOperation, IAddOperation
+    {
+        public new event Action<Error> OnOperationError = delegate { };
+        public new event Action OnOperationFinalized = delegate { };
+        public event Action<PackageInfo> OnOperationSuccess = delegate { };
+
+        public PackageInfo PackageInfo { get; set; }
+
+        public MockAddOperation(MockOperationFactory factory, PackageInfo packageInfo = null) : base(factory)
+        {
+            PackageInfo = packageInfo;
+        }
+
+        public void AddPackageAsync(PackageInfo packageInfo, Action<PackageInfo> doneCallbackAction = null,
+                                    Action<Error> errorCallbackAction = null)
+        {
+            if (ForceError != null)
+            {
+                if (errorCallbackAction != null)
+                    errorCallbackAction(ForceError);
+
+                IsCompleted = true;
+                OnOperationError(ForceError);
+            }
+            else
+            {
+                // on add package success, add the package to the list and set it to current
+                var list = Factory.Packages.ToList();
+                list.RemoveAll(p => p.PackageId.ToLower() == packageInfo.PackageId.ToLower());
+                list.Add(packageInfo);
+                Factory.Packages = list;
+
+                Factory.Packages.ByName(packageInfo.Name).SetCurrent(false);
+                packageInfo.IsCurrent = true;
+
+                if (doneCallbackAction != null)
+                    doneCallbackAction(PackageInfo);
+
+                IsCompleted = true;
+                OnOperationSuccess(PackageInfo);
+            }
+
+            OnOperationFinalized();
+        }
+
+        internal void ResetEvents()
+        {
+            OnOperationError = delegate { };
+            OnOperationFinalized = delegate { };
+            OnOperationSuccess = delegate { };
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e426a33061f184a9785cd5d82f9fb486
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+
+namespace UnityEditor.PackageManager.UI.Tests
+{
+    internal class MockListOperation : MockOperation, IListOperation
+    {
+        public new event Action<Error> OnOperationError = delegate { };
+        public new event Action OnOperationFinalized = delegate { };
+
+        public bool OfflineMode { get; set; }
+
+        public MockListOperation(MockOperationFactory factory) : base(factory)
+        {
+        }
+
+        public void GetPackageListAsync(Action<IEnumerable<PackageInfo>> doneCallbackAction,
+            Action<Error> errorCallbackAction = null)
+        {
+            if (ForceError != null)
+            {
+                if (errorCallbackAction != null)
+                    errorCallbackAction(ForceError);
+
+                IsCompleted = true;
+                OnOperationError(ForceError);
+            }
+            else
+            {
+                if (doneCallbackAction != null)
+                    doneCallbackAction(Factory.Packages);
+
+                IsCompleted = true;
+            }
+
+            OnOperationFinalized();
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fea24dc53b50441a9b2a8f9473fede33
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,28 @@
+using System;
+
+namespace UnityEditor.PackageManager.UI.Tests
+{
+    internal class MockOperation : IBaseOperation
+    {
+        public event Action<Error> OnOperationError { add { } remove { } }
+        public event Action OnOperationFinalized { add { } remove { } }
+        public event Action<string> OnOperationFailure { add { } remove { } }
+        
+        public bool IsCompleted { get; protected set; }
+        public bool RequireNetwork { get; set; }
+
+        public Error ForceError { protected get; set; } // Allow external component to force an error on the requests (eg: testing)
+
+        protected readonly MockOperationFactory Factory;
+
+        protected MockOperation(MockOperationFactory factory)
+        {
+            RequireNetwork = false;
+            Factory = factory;
+        }
+
+        public void Cancel()
+        {
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4fc12201ddc4b4d45b9bdecdf7f00ea5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,50 @@
+using System;
+using System.Linq;
+
+namespace UnityEditor.PackageManager.UI.Tests
+{
+    internal class MockRemoveOperation : MockOperation, IRemoveOperation
+    {
+        public new event Action<Error> OnOperationError = delegate { };
+        public new event Action OnOperationFinalized = delegate { };
+        public event Action<PackageInfo> OnOperationSuccess = delegate { };
+
+        public PackageInfo PackageInfo { get; set; }
+
+        public MockRemoveOperation(MockOperationFactory factory) : base(factory)
+        {
+        }
+
+        public void RemovePackageAsync(PackageInfo packageInfo, Action<PackageInfo> doneCallbackAction, Action<Error> errorCallbackAction = null)
+        {
+            if (ForceError != null)
+            {
+                if (errorCallbackAction != null)
+                    errorCallbackAction(ForceError);
+
+                IsCompleted = true;
+                OnOperationError(ForceError);
+                OnOperationFinalized();
+                return;
+            }
+
+            Factory.Packages = (from package in Factory.Packages
+                where package.PackageId.ToLower() != packageInfo.PackageId.ToLower()
+                select package);
+
+            if (doneCallbackAction != null)
+                doneCallbackAction(packageInfo);
+
+            IsCompleted = true;
+            OnOperationSuccess(packageInfo);
+            OnOperationFinalized();
+        }
+        
+        internal void ResetEvents()
+        {
+            OnOperationError = delegate { };
+            OnOperationFinalized = delegate { };
+            OnOperationSuccess = delegate { };
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fd382b8abbd6145c29e32af0e2a26d88
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+
+namespace UnityEditor.PackageManager.UI.Tests
+{
+    internal class MockSearchOperation : MockOperation, ISearchOperation
+    {
+        public new event Action<Error> OnOperationError = delegate { };
+        public new event Action OnOperationFinalized = delegate { };
+
+        public IEnumerable<PackageInfo> Packages { get; set; }
+
+        public MockSearchOperation(MockOperationFactory factory, IEnumerable<PackageInfo> packages) : base(factory)
+        {
+            Packages = packages;
+        }
+
+        public void GetAllPackageAsync(Action<IEnumerable<PackageInfo>> doneCallbackAction = null,  Action<Error> errorCallbackAction = null)
+        {
+            if (ForceError != null)
+            {
+                if (errorCallbackAction != null)
+                    errorCallbackAction(ForceError);
+                IsCompleted = true;
+                OnOperationError(ForceError);
+            }
+            else
+            {
+                if (doneCallbackAction != null)
+                    doneCallbackAction(Packages);
+
+                IsCompleted = true;
+            }
+
+            OnOperationFinalized();
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0a2c7bcbdfe0a438999cb0653789cdf4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace UnityEditor.PackageManager.UI.Tests
+{
+    internal class MockOperationFactory : IOperationFactory
+    {
+        public IEnumerable<PackageInfo> Packages { get; set; }
+        public MockAddOperation AddOperation { get; set; }
+        public MockSearchOperation SearchOperation { private get; set; }
+        public MockRemoveOperation RemoveOperation { private get; set; }
+
+        public MockOperationFactory()
+        {
+            Packages = Enumerable.Empty<PackageInfo>();
+        }
+
+        public void ResetOperations()
+        {
+            if (AddOperation != null) 
+                AddOperation.ResetEvents();
+            AddOperation = null;
+            
+            if (RemoveOperation != null) 
+                RemoveOperation.ResetEvents();
+            RemoveOperation = null;
+
+            SearchOperation = null;
+        }
+
+        public IListOperation CreateListOperation(bool offlineMode = false)
+        {          
+            return new MockListOperation(this);
+        }
+
+        public ISearchOperation CreateSearchOperation()
+        {          
+            return SearchOperation ?? new MockSearchOperation(this, Packages);
+        }
+
+        public IAddOperation CreateAddOperation()
+        {
+            return AddOperation ?? new MockAddOperation(this, Packages.First());
+        }
+
+        public IRemoveOperation CreateRemoveOperation()
+        {
+            return RemoveOperation ?? new MockRemoveOperation(this);
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 75938f72739584ed9925bf4ae8989079
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f68d88b9933cd4204925b22192bf15b4
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,24 @@
+using NUnit.Framework;
+
+namespace UnityEditor.PackageManager.UI.Tests
+{
+    internal class PackageBaseTests
+    {
+        protected MockOperationFactory Factory;
+        protected const string kPackageTestName = "com.unity.test";
+
+
+        [OneTimeSetUp]
+        public void OneTimeSetup()
+        {
+            Factory = new MockOperationFactory();
+            OperationFactory.Instance = Factory;
+        }
+
+        [OneTimeTearDown]
+        public void OneTimeTearDown()
+        {
+            OperationFactory.Reset();
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 983d491088dbb4db8b83c926939a08c5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,157 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+
+namespace UnityEditor.PackageManager.UI.Tests
+{
+    internal class PackageCollectionTests : PackageBaseTests
+    {
+        private Action<PackageFilter> OnFilterChangeEvent;
+        private Action<IEnumerable<Package>> OnPackagesChangeEvent;
+
+        [SetUp]
+        public void Setup()
+        {
+            PackageCollection.Instance.SetFilter(PackageFilter.Local);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            PackageCollection.Instance.OnFilterChanged -= OnFilterChangeEvent;
+            PackageCollection.Instance.OnPackagesChanged -= OnPackagesChangeEvent;
+        }
+
+        [Test]
+        public void Constructor_Instance_FilterIsLocal()
+        {
+            Assert.AreEqual(PackageFilter.Local, PackageCollection.Instance.Filter);
+        }
+
+        [Test]
+        public void SetFilter_WhenFilterChange_FilterChangeEventIsPropagated()
+        {
+            var wasCalled = false;
+            OnFilterChangeEvent = filter =>
+            {
+                wasCalled = true;
+            };
+
+            PackageCollection.Instance.OnFilterChanged += OnFilterChangeEvent;
+            PackageCollection.Instance.SetFilter(PackageFilter.All, false);
+            Assert.IsTrue(wasCalled);
+        }
+
+        [Test]
+        public void SetFilter_WhenNoFilterChange_FilterChangeEventIsNotPropagated()
+        {
+            var wasCalled = false;
+            OnFilterChangeEvent = filter =>
+            {
+                wasCalled = true;
+            };
+
+            PackageCollection.Instance.OnFilterChanged += OnFilterChangeEvent;
+            PackageCollection.Instance.SetFilter(PackageFilter.Local, false);
+            Assert.IsFalse(wasCalled);
+        }
+
+        [Test]
+        public void SetFilter_WhenFilterChange_FilterIsChanged()
+        {
+            PackageCollection.Instance.SetFilter(PackageFilter.All, false);
+            Assert.AreEqual(PackageFilter.All, PackageCollection.Instance.Filter);
+        }
+
+        [Test]
+        public void SetFilter_WhenNoFilterChangeRefresh_PackagesChangeEventIsNotPropagated()
+        {
+            var wasCalled = false;
+            OnPackagesChangeEvent = packages =>
+            {
+                wasCalled = true;
+            };
+
+            PackageCollection.Instance.OnPackagesChanged += OnPackagesChangeEvent;
+            PackageCollection.Instance.SetFilter(PackageFilter.Local);
+            Assert.IsFalse(wasCalled);
+        }
+
+        [Test]
+        public void SetFilter_WhenFilterChangeNoRefresh_PackagesChangeEventIsNotPropagated()
+        {
+            var wasCalled = false;
+            OnPackagesChangeEvent = packages =>
+            {
+                wasCalled = true;
+            };
+
+            PackageCollection.Instance.OnPackagesChanged += OnPackagesChangeEvent;
+            PackageCollection.Instance.SetFilter(PackageFilter.All, false);
+            Assert.IsFalse(wasCalled);
+        }
+
+        [Test]
+        public void SetFilter_WhenNoFilterChangeNoRefresh_PackagesChangeEventIsNotPropagated()
+        {
+            var wasCalled = false;
+            OnPackagesChangeEvent = packages =>
+            {
+                wasCalled = true;
+            };
+
+            PackageCollection.Instance.OnPackagesChanged += OnPackagesChangeEvent;
+            PackageCollection.Instance.SetFilter(PackageFilter.Local, false);
+            Assert.IsFalse(wasCalled);
+        }
+
+        [Test]
+        public void FetchListCache_PackagesChangeEventIsPropagated()
+        {
+            var wasCalled = false;
+            OnPackagesChangeEvent = packages =>
+            {
+                wasCalled = true;
+            };
+
+            PackageCollection.Instance.OnPackagesChanged += OnPackagesChangeEvent;
+            Factory.Packages = PackageSets.Instance.Many(5);
+            PackageCollection.Instance.FetchListCache(true);
+
+            Assert.IsTrue(wasCalled);
+        }
+
+
+        [Test]
+        public void FetchListOfflineCache_PackagesChangeEventIsPropagated()
+        {
+            var wasCalled = false;
+            OnPackagesChangeEvent = packages =>
+            {
+                wasCalled = true;
+            };
+            PackageCollection.Instance.OnPackagesChanged += OnPackagesChangeEvent;
+
+            Factory.Packages = PackageSets.Instance.Many(5);
+            PackageCollection.Instance.FetchListOfflineCache(true);
+
+            Assert.IsTrue(wasCalled);
+        }
+
+        [Test]
+        public void FetchSearchCache_PackagesChangeEventIsPropagated()
+        {
+            var wasCalled = false;
+            OnPackagesChangeEvent = packages =>
+            {
+                wasCalled = true;
+            };
+            PackageCollection.Instance.OnPackagesChanged += OnPackagesChangeEvent;
+
+            Factory.SearchOperation = new MockSearchOperation(Factory, PackageSets.Instance.Many(5));
+            PackageCollection.Instance.FetchSearchCache(true);
+
+            Assert.IsTrue(wasCalled);
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 01cd264c206ae482393dc9d04b26eca0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,60 @@
+using NUnit.Framework;
+using Semver;
+
+namespace UnityEditor.PackageManager.UI.Tests
+{
+    internal class PackageInfoTests : PackageBaseTests
+    {
+        [Test]
+        public void HasTag_WhenPreReleasePackageVersionTagWithPreReleaseName_ReturnsTrue()
+        {
+            var tag = PackageTag.preview.ToString();
+            
+            var info = new PackageInfo()
+            {
+                PackageId = kPackageTestName,
+                Version = new SemVersion(1, 0, 0, tag)
+            };
+            
+            Assert.IsTrue(info.HasVersionTag(tag));
+        }
+        
+        [Test]
+        public void HasTag_WhenPackageVersionTagIsAnyCase_ReturnsTrue()
+        {
+            var tag = "pREview";
+            
+            var info = new PackageInfo()
+            {
+                PackageId = kPackageTestName,
+                Version = new SemVersion(1, 0, 0, tag)
+            };
+            
+            Assert.IsTrue(info.HasVersionTag(tag));
+        }
+        
+        [Test]
+        public void VersionWithoutTag_WhenVersionContainsTag_ReturnsVersionOnly()
+        {
+            var info = new PackageInfo()
+            {
+                PackageId = kPackageTestName,
+                Version = new SemVersion(1, 0, 0, PackageTag.preview.ToString())
+            };
+            
+            Assert.AreEqual("1.0.0", info.VersionWithoutTag);
+        }
+        
+        [Test]
+        public void VersionWithoutTag_WhenVersionDoesNotContainTag_ReturnsVersionOnly()
+        {
+            var info = new PackageInfo()
+            {
+                PackageId = kPackageTestName,
+                Version = new SemVersion(1)
+            };
+            
+            Assert.AreEqual("1.0.0", info.VersionWithoutTag);
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2f1d33abb004b44cb90ec83a2bfe872e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,146 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+
+namespace UnityEditor.PackageManager.UI.Tests
+{
+    internal class PackageSearchTests : PackageBaseTests
+    {
+        private const string kName = "Test-Package";
+
+        private const string kCurrentVersion = "3.0.0";
+        private const string kPrerelease = "preview";
+        private const string kUpperPrerelease = "PREVIEW";
+        private const string kMixedPrerelease = "pReViEw";
+
+        private Package testPackage;
+
+        [SetUp]
+        public void Setup()
+        {
+            testPackage = new Package(kName, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, kName, kCurrentVersion + "-" + kPrerelease, true, true)
+            });
+        }
+
+        [TestCase(null)]
+        [TestCase("")]
+        [TestCase("\t")]
+        [TestCase(" ")]
+        [TestCase("  ")]
+        public void MatchCriteria_NullOrEmptyCriteria_ReturnsTrue(string criteria)
+        {
+            Assert.IsTrue(PackageFiltering.FilterByText(testPackage, criteria));
+        }
+
+        [TestCaseSource("GetAllPartialName")]
+        public void MatchCriteria_CriteriaMatchDisplayNamePartially_ReturnsTrue(string criteria)
+        {
+            Assert.IsTrue(PackageFiltering.FilterByText(testPackage, criteria));
+        }
+
+        [TestCaseSource("GetAllPartialVersions")]
+        public void MatchCriteria_CriteriaMatchCurrentVersion_ReturnsTrue(string criteria)
+        {
+            Assert.IsTrue(PackageFiltering.FilterByText(testPackage, criteria));
+        }
+        
+        [TestCase(kPrerelease)]
+        [TestCase(kUpperPrerelease)]
+        [TestCase(kMixedPrerelease)]
+        public void MatchCriteria_CriteriaMatchCurrentVersionPreRelease_ReturnsTrue(string criteria)
+        {
+            Assert.IsTrue(PackageFiltering.FilterByText(testPackage, criteria));
+        }
+
+        [TestCase("p")]
+        [TestCase("pr")]
+        [TestCase("pre")]
+        [TestCase("prev")]
+        [TestCase("view")]
+        [TestCase("vie")]
+        [TestCase("vi")]
+        public void MatchCriteria_CriteriaPartialMatchCurrentVersionPreRelease_ReturnsTrue(string criteria)
+        {
+            Assert.IsTrue(PackageFiltering.FilterByText(testPackage, criteria));
+        }
+
+        [TestCase("-p")]
+        [TestCase("-pr")]
+        [TestCase("-pre")]
+        [TestCase("-prev")]
+        [TestCase("-previ")]
+        [TestCase("-previe")]
+        [TestCase("-preview")]
+        public void MatchCriteria_CriteriaPartialMatchCurrentVersionPreReleaseLeadingDash_ReturnsTrue(string criteria)
+        {
+            Assert.IsTrue(PackageFiltering.FilterByText(testPackage, criteria));
+        }
+
+        [TestCase("veri")]
+        [TestCase("verif")]
+        [TestCase("verifie")]
+        [TestCase("verified")]
+        [TestCase("erified")]
+        [TestCase("rified")]
+        [TestCase("ified")]
+        public void MatchCriteria_CriteriaPartialMatchVerified_ReturnsTrue(string criteria)
+        {
+            Assert.IsTrue(PackageFiltering.FilterByText(testPackage, criteria));
+        }
+
+        [TestCase("Test Package")]
+        [TestCase("Test -Package")]
+        [TestCase("Test - Package")]
+        [TestCase("Test- Package")]
+        [TestCase("NotFound")]
+        [TestCase("1.0.0-preview")]
+        [TestCase("5.0.0")]
+        [TestCase("beta")]
+        [TestCase("previewed")]
+        [TestCase("verify")]
+        [TestCase("experimental")]
+        public void MatchCriteria_CriteriaDoesntMatch_ReturnsFalse(string criteria)
+        {
+            Assert.IsFalse(PackageFiltering.FilterByText(testPackage, criteria));
+        }
+
+        private static IEnumerable<string> GetAllPartialVersions()
+        {
+            var versions = new List<string>();
+            for (var i = 1; i <= kCurrentVersion.Length; i++)
+            {
+                versions.Add(kCurrentVersion.Substring(0, i));
+            }
+            return versions;
+        }
+        
+        private static IEnumerable<string> GetAllPartial(string str)
+        {
+            var names = new List<string>();
+            for (var i = 0; i < str.Length; i++)
+            {
+                var s1 = str.Substring(0, i + 1);
+                var s2 = str.Substring(i, str.Length - i);
+                names.Add(s1);
+                names.Add(s1.ToLower());
+                names.Add(s1.ToUpper());
+                names.Add(" " + s1);
+                names.Add(s1 + " ");
+                names.Add(" " + s1 + " ");
+                names.Add(s2);
+                names.Add(s2.ToLower());
+                names.Add(s2.ToUpper());
+                names.Add(" " + s2);
+                names.Add(s2 + " ");
+                names.Add(" " + s2 + " ");
+            }
+            return names;
+        }
+
+        private static IEnumerable<string> GetAllPartialName()
+        {
+            return GetAllPartial(kName);
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 448aaa781aea44811a5d66e3edac37e4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,521 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Semver;
+
+namespace UnityEditor.PackageManager.UI.Tests
+{
+    internal class PackageTests : PackageBaseTests
+    {
+        private Action<IAddOperation> OnAddOperation;
+        private Action<IRemoveOperation> OnRemoveOperation;
+
+        // Package version to display
+        public PackageInfo Display(Package package)
+        {
+            return PackageCollection.Instance.Filter == PackageFilter.All || package.Current == null ? package.Latest : package.Current;
+        }
+
+        [SetUp]
+        public void Setup()
+        {
+            PackageCollection.Instance.SetFilter(PackageFilter.Local);
+        }
+        
+        [TearDown]
+        public void TearDown()
+        {
+            Factory.ResetOperations();
+            Factory.Packages = Enumerable.Empty<PackageInfo>();
+        }
+
+        [Test]
+        public void Constructor_WithNullPackageName_ThrowsException()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 1, true);
+            Assert.Throws<ArgumentException>(() => 
+            {
+                new Package(null, packages);
+            });
+        }
+
+        [Test]
+        public void Constructor_WithEmptyPackageName_ThrowsException()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 1, true);
+            Assert.Throws<ArgumentException>(() => 
+            {
+                new Package("", packages);
+            });
+        }
+
+        [Test]
+        public void Constructor_WithNullPackageInfos_ThrowsException()
+        {
+            Assert.Throws<ArgumentNullException>(() => 
+            {
+                new Package(kPackageTestName, null);
+            });
+        }
+
+        [Test]
+        public void Constructor_WithEmptyPackageInfos_ThrowsException()
+        {
+            var packages = Enumerable.Empty<PackageInfo>();
+            Assert.Throws<ArgumentException>(() => 
+            {
+                new Package(kPackageTestName, packages);
+            });
+        }
+        
+        [Test]
+        public void Constructor_WithOnePackageInfo_CurrentIsFirstVersion()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 1, true);
+            var package = new Package(kPackageTestName, packages);
+            
+            Assert.AreEqual(package.Current, package.Versions.First());
+            Assert.IsTrue(package.Current.IsCurrent);
+        }
+        
+        [Test]
+        public void Constructor_WithOnePackageInfo_LatestIsLastVersion()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 1, true);
+            var package = new Package(kPackageTestName, packages);
+            
+            Assert.AreEqual(package.Latest, package.Versions.Last());
+            Assert.IsTrue(package.Latest.IsCurrent);
+        }
+        
+        [Test]
+        public void Constructor_WithOnePackageInfo_LatestAndCurrentAreEqual()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 1, true);
+            var package = new Package(kPackageTestName, packages);
+            
+            Assert.AreEqual(package.Current, package.Latest);
+        }
+        
+        [Test]
+        public void Constructor_WithTwoPackageInfos_CurrentIsFirstVersion()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 2, true);
+            var package = new Package(kPackageTestName, packages);
+            
+            Assert.AreEqual(package.Current, package.Versions.First());
+            Assert.IsTrue(package.Current.IsCurrent);
+        }
+        
+        [Test]
+        public void Constructor_WithTwoPackageInfos_LatestIsLastVersion()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 2, true);
+            var package = new Package(kPackageTestName, packages);
+            
+            Assert.AreEqual(package.Latest, package.Versions.Last());
+            Assert.IsFalse(package.Latest.IsCurrent);
+        }
+        
+        [Test]
+        public void Constructor_WithTwoPackagesInfo_LatestAndCurrentAreNotEqual()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 2, true);
+            var package = new Package(kPackageTestName, packages);
+            
+            Assert.AreNotEqual(package.Current, package.Latest);
+        }
+
+        [Test]
+        public void Constructor_WithMultiplePackagesInfo_VersionsCorrespond()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 5, true);
+            var package = new Package(kPackageTestName, packages);
+
+            Assert.AreEqual(packages, package.Versions);
+        }
+        
+        [Test]
+        public void Add_WhenPackageInfoIsCurrent_AddOperationIsNotCalled()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 3, true);
+            Factory.Packages = packages;
+            var package = new Package(kPackageTestName, packages);
+            var addOperationCalled = false;
+
+            OnAddOperation = operation =>
+            {
+                addOperationCalled = true;
+            };
+            
+            package.AddSignal.OnOperation += OnAddOperation;
+            package.Add(packages.First());
+            package.AddSignal.OnOperation -= OnAddOperation;
+            
+            Assert.IsFalse(addOperationCalled);
+        }
+
+        [Test]
+        public void Add_WhenPackageInfoIsNotCurrent_AddOperationIsCalled()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 3, true);
+            Factory.Packages = packages;
+            Factory.AddOperation = new MockAddOperation(Factory, packages[1]);
+            var package = new Package(kPackageTestName, packages);
+            var addOperationCalled = false;
+
+            OnAddOperation = operation =>
+            {
+                addOperationCalled = true;
+            };
+            
+            package.AddSignal.OnOperation += OnAddOperation;
+            package.Add(packages[1]);
+            package.AddSignal.OnOperation -= OnAddOperation;
+            
+            Assert.IsTrue(addOperationCalled);
+        }
+        [Test]
+        public void Update_WhenCurrentIsLatest_AddOperationIsNotCalled()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 1, true);
+            Factory.Packages = packages;
+            var package = new Package(kPackageTestName, packages);
+            var addOperationCalled = false;
+
+            OnAddOperation = operation =>
+            {
+                addOperationCalled = true;
+            };
+            
+            package.AddSignal.OnOperation += OnAddOperation;
+            package.Update();
+            package.AddSignal.OnOperation -= OnAddOperation;
+            
+            Assert.IsFalse(addOperationCalled);
+        }
+        
+        [Test]
+        public void Update_WhenCurrentIsNotLatest_AddOperationIsCalled()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 2, true);
+            Factory.Packages = packages;
+            Factory.AddOperation = new MockAddOperation(Factory, packages.Last());
+            var package = new Package(kPackageTestName, packages);
+            var addOperationCalled = false;
+
+            OnAddOperation = operation =>
+            {
+                addOperationCalled = true;
+            };
+            
+            package.AddSignal.OnOperation += OnAddOperation;
+            package.Update();
+            package.AddSignal.OnOperation -= OnAddOperation;
+            
+            Assert.IsTrue(addOperationCalled);
+        }
+        
+        [Test]
+        public void Remove_RemoveOperationIsCalled()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 1, true);
+            Factory.Packages = packages;
+            var package = new Package(kPackageTestName, packages);
+            var removeOperationCalled = false;
+
+            OnRemoveOperation = operation =>
+            {
+                removeOperationCalled = true;
+            };
+            
+            package.RemoveSignal.OnOperation += OnRemoveOperation;
+            package.Remove();
+            package.RemoveSignal.OnOperation -= OnRemoveOperation;
+            
+            Assert.IsTrue(removeOperationCalled);
+        }
+
+        [Test]
+        public void IsPackageManagerUI_WhenPackageManagerUIPackage_ReturnsTrue()
+        {
+            var packages = new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Unknown, Package.packageManagerUIName, "1.0.0")
+            };
+            var package = new Package(Package.packageManagerUIName, packages);
+            
+            Assert.IsTrue(package.IsPackageManagerUI);
+        }
+        
+        [Test]
+        public void IsPackageManagerUI_WhenNotPackageManagerUIPackage_ReturnsFalse()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 1, true);
+            var package = new Package(kPackageTestName, packages);
+            
+            Assert.IsFalse(package.IsPackageManagerUI);
+        }
+        
+        [Test]
+        public void Name_ReturnsExpectedValue()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 1, true);
+            var package = new Package(kPackageTestName, packages);
+            
+            Assert.AreEqual(kPackageTestName, package.Name);
+        }
+        
+        [Test]
+        public void Display_WhenCurrentIsNotNull_ReturnsCurrent()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 2, true);
+            var package = new Package(kPackageTestName, packages);
+            
+            Assert.AreEqual(package.Current, Display(package));
+        }
+        
+        [Test]
+        public void Display_WhenCurrentIsNull_ReturnsLatest()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 2, true);
+            packages[0].IsCurrent = false;
+            var package = new Package(kPackageTestName, packages);
+            
+            Assert.AreEqual(package.Latest, Display(package));
+        }
+        
+        [Test]
+        public void Display_WhenCurrentAndLatest_ReturnsLatest()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 2, true);
+            packages[0].IsCurrent = false;
+            var package = new Package(kPackageTestName, packages);
+            var answer = packages.Max(x => x.Version);
+
+            Assert.AreEqual(Display(package).Version, answer);
+        }
+        
+        [Test]
+        public void Versions_WhenOrderedPackageInfo_ReturnsOrderedValues()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 5, true);
+            var package = new Package(kPackageTestName, packages);
+            
+            Assert.AreEqual(packages, package.Versions);
+        }
+        
+        [Test]
+        public void Versions_WhenUnorderedPackageInfo_ReturnsOrderedValues()
+        {
+            var packages = PackageSets.Instance.Many(kPackageTestName, 5, true);
+            packages[0].Version = new SemVersion(1);
+            packages[1].Version = new SemVersion(4);
+            packages[2].Version = new SemVersion(2);
+            packages[3].Version = new SemVersion(5);
+            packages[4].Version = new SemVersion(3);
+
+            var orderPackages = packages.OrderBy(p => p.Version);
+            
+            var package = new Package(kPackageTestName, packages);
+            
+            Assert.AreEqual(orderPackages, package.Versions);
+        }
+
+        //
+        // Version Comparison tests
+        //
+        private static string name = "test";
+
+        [Test]
+        public void VersionUpdate_Current_lessthen_Verified()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, name, "1.0.0", true), 
+                PackageSets.Instance.Single(PackageSource.Registry, name, "2.0.0", false, true),        // Verified
+                PackageSets.Instance.Single(PackageSource.Registry, name, "3.0.0", false)
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "2.0.0");
+        }
+
+        [Test]
+        public void VersionUpdate_Current_equalto_Verified()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, name, "2.0.0", true, true),         // Verified
+                PackageSets.Instance.Single(PackageSource.Registry, name, "3.0.0", false)
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "2.0.0");
+        }
+
+        [Test]
+        public void VersionUpdate_Current_greaterthen_Verified()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, name, "3.0.0", true), 
+                PackageSets.Instance.Single(PackageSource.Registry, name, "2.0.0", false, true),        // Verified
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "3.0.0");
+        }
+
+        [Test]
+        public void VersionUpdate_Current_greaterthen_Verified_WithLatest()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, name, "3.0.0", true), 
+                PackageSets.Instance.Single(PackageSource.Registry, name, "2.0.0", false, true),        // Verified
+                PackageSets.Instance.Single(PackageSource.Registry, name, "4.0.0", false)
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "4.0.0");
+        }
+
+        [Test]
+        public void VersionUpdate_NoVerified_Current_lessthen_Latest()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, name, "1.0.0", true), 
+                PackageSets.Instance.Single(PackageSource.Registry, name, "2.0.0", false),
+                PackageSets.Instance.Single(PackageSource.Registry, name, "3.0.0", false)
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "3.0.0");
+        }
+
+        [Test]
+        public void VersionUpdate_NoVerified_Current_equalto_Latest()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, name, "0.0.0", false), 
+                PackageSets.Instance.Single(PackageSource.Registry, name, "1.0.0", true) 
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "1.0.0");
+        }
+        
+        [Test]
+        public void VersionUpdate_NoCurrent_WithVerified()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, name, "1.0.0", false, true),    // verified 
+                PackageSets.Instance.Single(PackageSource.Registry, name, "2.0.0", false)
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "1.0.0");
+        }
+
+        [Test]
+        public void VersionUpdate_NoCurrent_Latest()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, name, "1.0.0", false), 
+                PackageSets.Instance.Single(PackageSource.Registry, name, "2.0.0", false)
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "2.0.0");
+        }
+
+        [Test]
+        public void VersionUpdate_NoCurrent_Latest_WithPreview()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, name, "1.0.0", false), 
+                PackageSets.Instance.Single(PackageSource.Registry, name, "2.0.0", false),
+                PackageSets.Instance.Single(PackageSource.Registry, name, "3.0.0-preview", false)
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "2.0.0");
+        }
+
+        [Test]
+        public void VersionUpdate_NoCurrent_Verified_WithPreview()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, name, "1.0.0", false, true),    // verified 
+                PackageSets.Instance.Single(PackageSource.Registry, name, "2.0.0", false),
+                PackageSets.Instance.Single(PackageSource.Registry, name, "3.0.0-preview", false)
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "1.0.0");
+        }
+
+        [Test]
+        public void VersionUpdate_NoCurrent_OnlyPreviews()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, name, "1.0.0-preview", false), 
+                PackageSets.Instance.Single(PackageSource.Registry, name, "2.0.0-preview", false)
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "2.0.0-preview");
+        }
+
+        [Test]
+        public void VersionUpdate_CurrentPreview_WithVerified()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, name, "1.0.0", false, true),    // verified 
+                PackageSets.Instance.Single(PackageSource.Registry, name, "2.0.0", false),
+                PackageSets.Instance.Single(PackageSource.Registry, name, "3.0.0-preview", true)    // current
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "3.0.0-preview");
+        }
+        
+        [Test]
+        public void VersionUpdate_CurrentPreview_WithLatestPreview()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, name, "1.0.0", false, true),    // verified 
+                PackageSets.Instance.Single(PackageSource.Registry, name, "2.0.0", false),
+                PackageSets.Instance.Single(PackageSource.Registry, name, "3.0.0-preview", true),    // current
+                PackageSets.Instance.Single(PackageSource.Registry, name, "4.0.0-preview", false)
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "4.0.0-preview");
+        }
+
+        [Test]
+        public void VersionUpdate_CurrentPreview_WithLatestPreviewNoVerified()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Registry, name, "1.0.0", false),
+                PackageSets.Instance.Single(PackageSource.Registry, name, "2.0.0", false),
+                PackageSets.Instance.Single(PackageSource.Registry, name, "3.0.0-preview", true),    // current
+                PackageSets.Instance.Single(PackageSource.Registry, name, "4.0.0-preview", false)
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "4.0.0-preview");
+        }
+
+        [Test]
+        public void VersionUpdate_CurrentEmbedded()
+        {
+            var package = new Package(name, new List<PackageInfo>
+            {
+                PackageSets.Instance.Single(PackageSource.Embedded, name, "1.0.0", true), 
+                PackageSets.Instance.Single(PackageSource.Registry, name, "2.0.0", false, true),    // verified
+            });
+
+            Assert.IsTrue(package.LatestUpdate.Version == "1.0.0");
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 78e267bad6d564d49803ba3e9c13ff2e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: