dependabot-nuget 0.250.0 → 0.252.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Utilities/AssertEx.cs

@@ -0,0 +1,272 @@
+using System.Collections;
+using System.Collections.Immutable;
+using System.Reflection;
+using System.Text;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Utilities;
+
+/// <summary>
+/// Assert style type to deal with the lack of features in xUnit's Assert type
+/// </summary>
+public static class AssertEx
+{
+    public static void Equal<T>(
+        ImmutableArray<T>? expected,
+        ImmutableArray<T>? actual,
+        IEqualityComparer<T>? comparer = null,
+        string? message = null)
+    {
+        if (actual is null || actual.Value.IsDefault)
+        {
+            Assert.True(expected is null || expected.Value.IsDefault, message);
+        }
+        else
+        {
+            Equal(expected, (IEnumerable<T>)actual.Value, comparer, message);
+        }
+    }
+
+    public static void Equal<T>(
+        ImmutableArray<T> expected,
+        ImmutableArray<T> actual,
+        IEqualityComparer<T>? comparer = null,
+        string? message = null)
+    {
+        if (actual.IsDefault)
+        {
+            Assert.True(expected.IsDefault, message);
+        }
+        else
+        {
+            Equal(expected, (IEnumerable<T>)actual, comparer, message);
+        }
+    }
+
+    public static void Equal<T>(
+        ImmutableArray<T>? expected,
+        IEnumerable<T>? actual,
+        IEqualityComparer<T>? comparer = null,
+        string? message = null)
+    {
+        if (expected is null || expected.Value.IsDefault)
+        {
+            Assert.True(actual is null, message);
+        }
+        else
+        {
+            Equal((IEnumerable<T>?)expected, actual, comparer, message);
+        }
+    }
+
+    public static void Equal<T>(
+        IEnumerable<T>? expected,
+        ImmutableArray<T>? actual,
+        IEqualityComparer<T>? comparer = null,
+        string? message = null)
+    {
+        if (actual is null || actual.Value.IsDefault)
+        {
+            Assert.True(expected is null, message);
+        }
+        else
+        {
+            Equal(expected, (IEnumerable<T>)actual, comparer, message);
+        }
+    }
+
+    public static void Equal<T>(
+        IEnumerable<T>? expected,
+        IEnumerable<T>? actual,
+        IEqualityComparer<T>? comparer = null,
+        string? message = null)
+    {
+        if (expected == null)
+        {
+            Assert.True(actual is null, message);
+            return;
+        }
+        else
+        {
+            Assert.True(actual is not null, message);
+        }
+
+        if (SequenceEqual(expected, actual, comparer))
+        {
+            return;
+        }
+
+        Assert.True(false, GetAssertMessage(expected, actual, comparer, message));
+    }
+
+    private static bool SequenceEqual<T>(
+        IEnumerable<T> expected,
+        IEnumerable<T> actual,
+        IEqualityComparer<T>? comparer = null)
+    {
+        if (ReferenceEquals(expected, actual))
+        {
+            return true;
+        }
+
+        var enumerator1 = expected.GetEnumerator();
+        var enumerator2 = actual.GetEnumerator();
+
+        while (true)
+        {
+            var hasNext1 = enumerator1.MoveNext();
+            var hasNext2 = enumerator2.MoveNext();
+
+            if (hasNext1 != hasNext2)
+            {
+                return false;
+            }
+
+            if (!hasNext1)
+            {
+                break;
+            }
+
+            var value1 = enumerator1.Current;
+            var value2 = enumerator2.Current;
+
+            var areEqual = comparer != null
+                ? comparer.Equals(value1, value2)
+                : AssertEqualityComparer<T>.Equals(value1, value2);
+            if (!areEqual)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public static string GetAssertMessage<T>(
+        IEnumerable<T> expected,
+        IEnumerable<T> actual,
+        IEqualityComparer<T>? comparer = null,
+        string? prefix = null)
+    {
+        Func<T, string> itemInspector = typeof(T) == typeof(byte)
+            ? b => $"0x{b:X2}"
+            : new Func<T, string>(obj => obj?.ToString() ?? "<null>");
+
+        var itemSeparator = typeof(T) == typeof(byte)
+            ? ", "
+            : "," + Environment.NewLine;
+
+        var expectedString = string.Join(itemSeparator, expected.Take(10).Select(itemInspector));
+        var actualString = string.Join(itemSeparator, actual.Select(itemInspector));
+
+        var message = new StringBuilder();
+
+        if (!string.IsNullOrEmpty(prefix))
+        {
+            message.AppendLine(prefix);
+            message.AppendLine();
+        }
+
+        message.AppendLine("Expected:");
+        message.AppendLine(expectedString);
+        if (expected.Count() > 10)
+        {
+            message.AppendLine("... truncated ...");
+        }
+
+        message.AppendLine("Actual:");
+        message.AppendLine(actualString);
+        message.AppendLine("Differences:");
+        message.AppendLine(DiffUtil.DiffReport(expected, actual, itemSeparator, comparer, itemInspector));
+
+        return message.ToString();
+    }
+
+    private class AssertEqualityComparer<T> : IEqualityComparer<T>
+    {
+        public static readonly IEqualityComparer<T> Instance = new AssertEqualityComparer<T>();
+
+        private static bool CanBeNull()
+        {
+            var type = typeof(T);
+            return !type.GetTypeInfo().IsValueType ||
+                (type.GetTypeInfo().IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>));
+        }
+
+        public static bool IsNull(T @object)
+        {
+            if (!CanBeNull())
+            {
+                return false;
+            }
+
+            return object.Equals(@object, default(T));
+        }
+
+        public static bool Equals(T left, T right)
+        {
+            return Instance.Equals(left, right);
+        }
+
+        bool IEqualityComparer<T>.Equals(T? x, T? y)
+        {
+            if (CanBeNull())
+            {
+                if (object.Equals(x, default(T)))
+                {
+                    return object.Equals(y, default(T));
+                }
+
+                if (object.Equals(y, default(T)))
+                {
+                    return false;
+                }
+            }
+
+            if (x is IEquatable<T> equatable)
+            {
+                return equatable.Equals(y);
+            }
+
+            if (x is IComparable<T> comparableT)
+            {
+                return comparableT.CompareTo(y) == 0;
+            }
+
+            if (x is IComparable comparable)
+            {
+                return comparable.CompareTo(y) == 0;
+            }
+
+            if (x is IEnumerable enumerableX && y is IEnumerable enumerableY)
+            {
+                var enumeratorX = enumerableX.GetEnumerator();
+                var enumeratorY = enumerableY.GetEnumerator();
+
+                while (true)
+                {
+                    bool hasNextX = enumeratorX.MoveNext();
+                    bool hasNextY = enumeratorY.MoveNext();
+
+                    if (!hasNextX || !hasNextY)
+                    {
+                        return hasNextX == hasNextY;
+                    }
+
+                    if (!Equals(enumeratorX.Current, enumeratorY.Current))
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return object.Equals(x, y);
+        }
+
+        int IEqualityComparer<T>.GetHashCode(T obj)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Utilities/DiffUtil.cs

@@ -0,0 +1,266 @@
+#nullable disable
+
+using System.Diagnostics;
+
+namespace NuGetUpdater.Core.Test.Utilities;
+
+public class DiffUtil
+{
+    private enum EditKind
+    {
+        /// <summary>
+        /// No change.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Node value was updated.
+        /// </summary>
+        Update = 1,
+
+        /// <summary>
+        /// Node was inserted.
+        /// </summary>
+        Insert = 2,
+
+        /// <summary>
+        /// Node was deleted.
+        /// </summary>
+        Delete = 3,
+    }
+
+    private class LCS<T> : LongestCommonSubsequence<IList<T>>
+    {
+        public static readonly LCS<T> Default = new LCS<T>(EqualityComparer<T>.Default);
+
+        private readonly IEqualityComparer<T> _comparer;
+
+        public LCS(IEqualityComparer<T> comparer)
+        {
+            _comparer = comparer;
+        }
+
+        protected override bool ItemsEqual(IList<T> sequenceA, int indexA, IList<T> sequenceB, int indexB)
+        {
+            return _comparer.Equals(sequenceA[indexA], sequenceB[indexB]);
+        }
+
+        public IEnumerable<string> CalculateDiff(IList<T> sequenceA, IList<T> sequenceB, Func<T, string> toString)
+        {
+            foreach (var edit in GetEdits(sequenceA, sequenceA.Count, sequenceB, sequenceB.Count).Reverse())
+            {
+                switch (edit.Kind)
+                {
+                    case EditKind.Delete:
+                        yield return "--> " + toString(sequenceA[edit.IndexA]);
+                        break;
+
+                    case EditKind.Insert:
+                        yield return "++> " + toString(sequenceB[edit.IndexB]);
+                        break;
+
+                    case EditKind.Update:
+                        yield return "    " + toString(sequenceB[edit.IndexB]);
+                        break;
+                }
+            }
+        }
+    }
+
+    public static string DiffReport<T>(IEnumerable<T> expected, IEnumerable<T> actual, string separator, IEqualityComparer<T> comparer = null, Func<T, string> toString = null)
+    {
+        var lcs = (comparer != null) ? new LCS<T>(comparer) : LCS<T>.Default;
+        toString = toString ?? new Func<T, string>(obj => obj.ToString());
+
+        IList<T> expectedList = expected as IList<T> ?? new List<T>(expected);
+        IList<T> actualList = actual as IList<T> ?? new List<T>(actual);
+
+        return string.Join(separator, lcs.CalculateDiff(expectedList, actualList, toString));
+    }
+
+    private static readonly char[] s_lineSplitChars = new[] { '\r', '\n' };
+
+    public static string[] Lines(string s)
+    {
+        return s.Split(s_lineSplitChars, StringSplitOptions.RemoveEmptyEntries);
+    }
+
+    public static string DiffReport(string expected, string actual)
+    {
+        var exlines = Lines(expected);
+        var aclines = Lines(actual);
+        return DiffReport(exlines, aclines, separator: Environment.NewLine);
+    }
+
+    /// <summary>
+    /// Calculates Longest Common Subsequence.
+    /// </summary>
+    private abstract class LongestCommonSubsequence<TSequence>
+    {
+        protected readonly struct Edit
+        {
+            public readonly EditKind Kind;
+            public readonly int IndexA;
+            public readonly int IndexB;
+
+            internal Edit(EditKind kind, int indexA, int indexB)
+            {
+                this.Kind = kind;
+                this.IndexA = indexA;
+                this.IndexB = indexB;
+            }
+        }
+
+        private const int DeleteCost = 1;
+        private const int InsertCost = 1;
+        private const int UpdateCost = 2;
+
+        protected abstract bool ItemsEqual(TSequence sequenceA, int indexA, TSequence sequenceB, int indexB);
+
+        protected IEnumerable<KeyValuePair<int, int>> GetMatchingPairs(TSequence sequenceA, int lengthA, TSequence sequenceB, int lengthB)
+        {
+            int[,] d = ComputeCostMatrix(sequenceA, lengthA, sequenceB, lengthB);
+            int i = lengthA;
+            int j = lengthB;
+
+            while (i != 0 && j != 0)
+            {
+                if (d[i, j] == d[i - 1, j] + DeleteCost)
+                {
+                    i--;
+                }
+                else if (d[i, j] == d[i, j - 1] + InsertCost)
+                {
+                    j--;
+                }
+                else
+                {
+                    i--;
+                    j--;
+                    yield return new KeyValuePair<int, int>(i, j);
+                }
+            }
+        }
+
+        protected IEnumerable<Edit> GetEdits(TSequence sequenceA, int lengthA, TSequence sequenceB, int lengthB)
+        {
+            int[,] d = ComputeCostMatrix(sequenceA, lengthA, sequenceB, lengthB);
+            int i = lengthA;
+            int j = lengthB;
+
+            while (i != 0 && j != 0)
+            {
+                if (d[i, j] == d[i - 1, j] + DeleteCost)
+                {
+                    i--;
+                    yield return new Edit(EditKind.Delete, i, -1);
+                }
+                else if (d[i, j] == d[i, j - 1] + InsertCost)
+                {
+                    j--;
+                    yield return new Edit(EditKind.Insert, -1, j);
+                }
+                else
+                {
+                    i--;
+                    j--;
+                    yield return new Edit(EditKind.Update, i, j);
+                }
+            }
+
+            while (i > 0)
+            {
+                i--;
+                yield return new Edit(EditKind.Delete, i, -1);
+            }
+
+            while (j > 0)
+            {
+                j--;
+                yield return new Edit(EditKind.Insert, -1, j);
+            }
+        }
+
+        /// <summary>
+        /// Returns a distance [0..1] of the specified sequences.
+        /// The smaller distance the more of their elements match.
+        /// </summary>
+        /// <summary>
+        /// Returns a distance [0..1] of the specified sequences.
+        /// The smaller distance the more of their elements match.
+        /// </summary>
+        protected double ComputeDistance(TSequence sequenceA, int lengthA, TSequence sequenceB, int lengthB)
+        {
+            Debug.Assert(lengthA >= 0 && lengthB >= 0);
+
+            if (lengthA == 0 || lengthB == 0)
+            {
+                return (lengthA == lengthB) ? 0.0 : 1.0;
+            }
+
+            int lcsLength = 0;
+            foreach (var pair in GetMatchingPairs(sequenceA, lengthA, sequenceB, lengthB))
+            {
+                lcsLength++;
+            }
+
+            int max = Math.Max(lengthA, lengthB);
+            Debug.Assert(lcsLength <= max);
+            return 1.0 - (double)lcsLength / (double)max;
+        }
+
+        /// <summary>
+        /// Calculates costs of all paths in an edit graph starting from vertex (0,0) and ending in vertex (lengthA, lengthB).
+        /// </summary>
+        /// <remarks>
+        /// The edit graph for A and B has a vertex at each point in the grid (i,j), i in [0, lengthA] and j in [0, lengthB].
+        ///
+        /// The vertices of the edit graph are connected by horizontal, vertical, and diagonal directed edges to form a directed acyclic graph.
+        /// Horizontal edges connect each vertex to its right neighbor.
+        /// Vertical edges connect each vertex to the neighbor below it.
+        /// Diagonal edges connect vertex (i,j) to vertex (i-1,j-1) if <see cref="ItemsEqual"/>(sequenceA[i-1],sequenceB[j-1]) is true.
+        ///
+        /// Editing starts with S = [].
+        /// Move along horizontal edge (i-1,j)-(i,j) represents the fact that sequenceA[i-1] is not added to S.
+        /// Move along vertical edge (i,j-1)-(i,j) represents an insert of sequenceB[j-1] to S.
+        /// Move along diagonal edge (i-1,j-1)-(i,j) represents an addition of sequenceB[j-1] to S via an acceptable
+        /// change of sequenceA[i-1] to sequenceB[j-1].
+        ///
+        /// In every vertex the cheapest outgoing edge is selected.
+        /// The number of diagonal edges on the path from (0,0) to (lengthA, lengthB) is the length of the longest common subsequence.
+        /// </remarks>
+        private int[,] ComputeCostMatrix(TSequence sequenceA, int lengthA, TSequence sequenceB, int lengthB)
+        {
+            var la = lengthA + 1;
+            var lb = lengthB + 1;
+
+            // TODO: Optimization possible: O(ND) time, O(N) space
+            // EUGENE W. MYERS: An O(ND) Difference Algorithm and Its Variations
+            var d = new int[la, lb];
+
+            d[0, 0] = 0;
+            for (int i = 1; i <= lengthA; i++)
+            {
+                d[i, 0] = d[i - 1, 0] + DeleteCost;
+            }
+
+            for (int j = 1; j <= lengthB; j++)
+            {
+                d[0, j] = d[0, j - 1] + InsertCost;
+            }
+
+            for (int i = 1; i <= lengthA; i++)
+            {
+                for (int j = 1; j <= lengthB; j++)
+                {
+                    int m1 = d[i - 1, j - 1] + (ItemsEqual(sequenceA, i - 1, sequenceB, j - 1) ? 0 : UpdateCost);
+                    int m2 = d[i - 1, j] + DeleteCost;
+                    int m3 = d[i, j - 1] + InsertCost;
+                    d[i, j] = Math.Min(Math.Min(m1, m2), m3);
+                }
+            }
+
+            return d;
+        }
+    }
+}