Add tests

src/EditorFeatures/CSharpTest/Wrapping/SortingTests.cs

+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis.Wrapping;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Wrapping
+{
+    public class SortingTests
+    {
+        [Fact]
+        public void FirstNotInMruSecondNotInMru()
+        {
+            var items = ImmutableArray.Create("Action1", "Action2");
+
+            var sorted = WrapItemsAction.SortByMostRecentlyUsed(
+                items, ImmutableArray<string>.Empty, a => a);
+
+            // Shouldn't change order
+            Assert.Equal((IEnumerable<string>)items, sorted);
+        }
+
+        [Fact]
+        public void FirstInMruSecondNotInMru()
+        {
+            var items = ImmutableArray.Create("Action1", "Action2");
+
+            var sorted = WrapItemsAction.SortByMostRecentlyUsed(
+                items, ImmutableArray.Create("Action1"), a => a);
+
+            // Shouldn't change order
+            Assert.Equal((IEnumerable<string>)items, sorted);
+        }
+
+        [Fact]
+        public void FirstNotInMruSecondInMru()
+        {
+            var items = ImmutableArray.Create("Action1", "Action2");
+
+            var sorted = WrapItemsAction.SortByMostRecentlyUsed(
+                items, ImmutableArray.Create("Action2"), a => a);
+
+            // Should swap order.
+            Assert.Equal((IEnumerable<string>)ImmutableArray.Create("Action2", "Action1"), sorted);
+        }
+
+        [Fact]
+        public void FirstInMruSecondInMru1()
+        {
+            var items = ImmutableArray.Create("Action1", "Action2");
+
+            var sorted = WrapItemsAction.SortByMostRecentlyUsed(
+                items, ImmutableArray.Create("Action1", "Action2"), a => a);
+
+            // Shouldn't change order
+            Assert.Equal((IEnumerable<string>)items, sorted);
+        }
+
+        [Fact]
+        public void FirstInMruSecondInMru2()
+        {
+            var items = ImmutableArray.Create("Action1", "Action2");
+
+            var sorted = WrapItemsAction.SortByMostRecentlyUsed(
+                items, ImmutableArray.Create("Action2", "Action1"), a => a);
+
+            // Should swap order.
+            Assert.Equal((IEnumerable<string>)ImmutableArray.Create("Action2", "Action1"), sorted);
+        }
+    }
+}

src/Features/Core/Portable/Wrapping/WrapItemsAction.cs

@@ -63,15 +63,15 @@ protected override async Task<IEnumerable<CodeActionOperation>> ComputeOperation
         }
 
         public static ImmutableArray<CodeAction> SortActionsByMostRecentlyUsed(ImmutableArray<CodeAction> codeActions)
-            => SortActionsByMostRecentlyUsed(codeActions, s_mruTitles);
+            => SortByMostRecentlyUsed(codeActions, s_mruTitles, a => GetSortTitle(a));
 
-        public static ImmutableArray<CodeAction> SortActionsByMostRecentlyUsed(
-            ImmutableArray<CodeAction> codeActions, ImmutableArray<string> mruTitles)
+        public static ImmutableArray<T> SortByMostRecentlyUsed<T>(
+            ImmutableArray<T> items, ImmutableArray<string> mostRecentlyUsedKeys, Func<T, string> getKey)
         {
-            return codeActions.Sort((d1, d2) =>
+            return items.Sort((d1, d2) =>
             {
-                var mruIndex1 = mruTitles.IndexOf(GetSortTitle(d1));
-                var mruIndex2 = mruTitles.IndexOf(GetSortTitle(d2));
+                var mruIndex1 = mostRecentlyUsedKeys.IndexOf(getKey(d1));
+                var mruIndex2 = mostRecentlyUsedKeys.IndexOf(getKey(d2));
 
                 // If both are in the mru, prefer the one earlier on.
                 if (mruIndex1 >= 0 && mruIndex2 >= 0)
@@ -85,8 +85,8 @@ public static ImmutableArray<CodeAction> SortActionsByMostRecentlyUsed(Immutable
                     return 1;
 
                 // Neither are in the mru.  Sort them based on their original locations.
-                var index1 = codeActions.IndexOf(d1);
-                var index2 = codeActions.IndexOf(d2);
+                var index1 = items.IndexOf(d1);
+                var index2 = items.IndexOf(d2);
 
                 // Note: we don't return 0 here as ImmutableArray.Sort is not stable.
                 return index1 - index2;