Add null checks to SequenceEqual in System.Memory

src/System.Memory/tests/ReadOnlySpan/IndexOf.T.cs

@@ -184,5 +184,12 @@ public static void TestMultipleMatchIndexOf_String()
                 Assert.Equal(length - 2, idx);
             }
         }
+
+        [Theory]
+        [MemberData(nameof(TestHelpers.IndexOfNullData), MemberType = typeof(TestHelpers))]
+        public static void IndexOfNull_String(string[] spanInput, int expected)
+        {
+            Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOf((string)null));
+        }
     }
 }

src/System.Memory/tests/ReadOnlySpan/IndexOfAny.T.cs

@@ -962,5 +962,26 @@ public static void MakeSureNoChecksGoOutOfRangeIndexOfAny_ManyString()
                 Assert.Equal(-1, index);
             }
         }
+
+        [Theory]
+        [MemberData(nameof(TestHelpers.IndexOfAnyNullSequenceData), MemberType = typeof(TestHelpers))]
+        public static void IndexOfAnyNullSequence_String(string[] spanInput, string[] searchInput, int expected)
+        {
+            Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOfAny(searchInput));
+            Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOfAny((ReadOnlySpan<string>)searchInput));
+
+            if (searchInput != null)
+            {
+                if (searchInput.Length >= 3)
+                {
+                    Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOfAny(searchInput[0], searchInput[1], searchInput[2]));
+                }
+
+                if (searchInput.Length >= 2)
+                {
+                    Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOfAny(searchInput[0], searchInput[1]));
+                }
+            }
+        }
     }
 }

src/System.Memory/tests/ReadOnlySpan/IndexOfSequence.T.cs

@@ -230,5 +230,12 @@ public static void IndexOfSequenceLengthOneValueJustPasttVeryEnd_String()
             int index = span.IndexOf(value);
             Assert.Equal(-1, index);
         }
+
+        [Theory]
+        [MemberData(nameof(TestHelpers.IndexOfNullSequenceData), MemberType = typeof(TestHelpers))]
+        public static void IndexOfNullSequence_String(string[] source, string[] target, int expected)
+        {
+            Assert.Equal(expected, new ReadOnlySpan<string>(source).IndexOf(target));
+        }
     }
 }

src/System.Memory/tests/ReadOnlySpan/LastIndexOf.T.cs

@@ -184,5 +184,12 @@ public static void TestMultipleMatchLastIndexOf_String()
                 Assert.Equal(length - 1, idx);
             }
         }
+
+        [Theory]
+        [MemberData(nameof(TestHelpers.LastIndexOfNullData), MemberType = typeof(TestHelpers))]
+        public static void LastIndexOfNull_String(string[] spanInput, int expected)
+        {
+            Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOf((string)null));
+        }
     }
 }

src/System.Memory/tests/ReadOnlySpan/LastIndexOfAny.T.cs

@@ -932,5 +932,26 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOfAny_String_ManyByte()
                 Assert.Equal(-1, index);
             }
         }
+
+        [Theory]
+        [MemberData(nameof(TestHelpers.LastIndexOfAnyNullSequenceData), MemberType = typeof(TestHelpers))]
+        public static void LastIndexOfAnyNullSequence_String(string[] spanInput, string[] searchInput, int expected)
+        {
+            Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOfAny(searchInput));
+            Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOfAny((ReadOnlySpan<string>)searchInput));
+
+            if (searchInput != null)
+            {
+                if (searchInput.Length >= 3)
+                {
+                    Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOfAny(searchInput[0], searchInput[1], searchInput[2]));
+                }
+
+                if (searchInput.Length >= 2)
+                {
+                    Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOfAny(searchInput[0], searchInput[1]));
+                }
+            }
+        }
     }
 }

src/System.Memory/tests/ReadOnlySpan/LastIndexOfSequence.T.cs

@@ -240,5 +240,12 @@ public static void LastIndexOfSequenceLengthOneValueJustPasttVeryEnd_String()
             int index = span.LastIndexOf(value);
             Assert.Equal(-1, index);
         }
+
+        [Theory]
+        [MemberData(nameof(TestHelpers.LastIndexOfNullSequenceData), MemberType = typeof(TestHelpers))]
+        public static void LastIndexOfNullSequence_String(string[] source, string[] target, int expected)
+        {
+            Assert.Equal(expected, new ReadOnlySpan<string>(source).LastIndexOf(target));
+        }
     }
 }

src/System.Memory/tests/ReadOnlySpan/SequenceEqual.T.cs

@@ -129,5 +129,14 @@ public static void MakeSureNoSequenceEqualChecksGoOutOfRange()
                 Assert.True(b);
             }
         }
+
+        [Theory]
+        [MemberData(nameof(TestHelpers.SequenceEqualNullData), MemberType = typeof(TestHelpers))]
+        public static void SequenceEqual_NullData_String(string[] firstInput, string[] secondInput, bool expected)
+        {
+            ReadOnlySpan<string> theStrings = firstInput;
+
+            Assert.Equal(expected, theStrings.SequenceEqual(secondInput));
+        }
     }
 }

src/System.Memory/tests/Span/SequenceEqual.T.cs

@@ -7,6 +7,15 @@ namespace System.SpanTests
 {
     public static partial class SpanTests
     {
+        [Fact]
+        public static void NullReferenceSequenceEqual()
+        {
+            Span<string> first = new Span<string>(new string[] { "a", "b", null, null });
+            Span<string> second = new Span<string>(new string[] { "a", "b", null, null });
+            bool b = first.SequenceEqual(second);
+            Assert.True(b);
+        }
+
         [Fact]
         public static void ZeroLengthSequenceEqual()
         {

src/System.Memory/tests/TestHelpers.cs

@@ -409,5 +409,135 @@ public static Memory<T> DangerousCreateMemory<T>(object obj, int offset, int len
         /// <summary>Creates a <see cref="ReadOnlyMemory{T}"/> with the specified values in its backing field.</summary>
         public static ReadOnlyMemory<T> DangerousCreateReadOnlyMemory<T>(object obj, int offset, int length) =>
             DangerousCreateMemory<T>(obj, offset, length);
+
+        public static TheoryData<string[], string[], bool> SequenceEqualNullData => new TheoryData<string[], string[], bool>()
+        {
+            { new string[] { "1", null, "2" }, new string[] { "1", null, "2" } , true},
+            { new string[] { "1", null, "2" }, new string[] { "1", "3", "2" } , false},
+            { new string[] { "1", null, "2" }, new string[] { null, "3", "2" } , false},
+            { new string[] { "1", null, "2" }, new string[] { null } , false},
+            { new string[] { "1", null, "2" }, null , false},
+
+            { new string[] { null, "2", "1" }, new string[] { null, "2" } , false},
+
+            { null, new string[] { null }, false},
+            { null, null , true},
+            { null, new string[] { "1", "3", "2" } , false},
+            { null, new string[] { "1", null, "2" } , false},
+
+            { new string[] { "1", null, null }, new string[] { "1", null, null }, true},
+            { new string[] { null, null, null }, new string[] { null, null, null }, true},
+        };
+
+        public static TheoryData<string[], int> IndexOfNullData => new TheoryData<string[], int>()
+        {
+            { new string[] { "1", null, "2" }, 1},
+            { new string[] { "1", "3", "2" }, -1},
+            { null, -1},
+            { new string[] { "1", null, null }, 1},
+            { new string[] { null, null, null }, 0},
+        };
+
+        public static TheoryData<string[], string[], int> IndexOfNullSequenceData => new TheoryData<string[], string[], int>()
+        {
+            { new string[] { "1", null, "2" }, new string[] { "1", null, "2" }, 0},
+            { new string[] { "1", null, "2" }, new string[] { null }, 1},
+            { new string[] { "1", null, "2" }, (string[])null, 0},
+
+            { new string[] { "1", "3", "2" }, new string[] { "1", null, "2" }, -1},
+            { new string[] { "1", "3", "2" }, new string[] { null }, -1},
+            { new string[] { "1", "3", "2" }, (string[])null, 0},
+
+            { null, new string[] { "1", null, "2" }, -1},
+
+            { new string[] { "1", null, null }, new string[] { null, null, "2" }, -1},
+            { new string[] { null, null, null }, new string[] { null, null }, 0},
+        };
+
+        public static TheoryData<string[], string[], int> IndexOfAnyNullSequenceData => new TheoryData<string[], string[], int>()
+        {
+            { new string[] { "1", null, "2" }, new string[] { "1", null, "2" }, 0},
+            { new string[] { "1", null, "2" }, new string[] { null, null }, 1},
+
+            { new string[] { "1", null, "2" }, new string[] { "3", null }, 1},
+            { new string[] { "1", null, "2" }, new string[] { "1", "2" }, 0},
+            { new string[] { "1", null, "2" }, new string[] { "3", "4" }, -1},
+
+            { new string[] { null, null, "2" }, new string[] { "3", null }, 0},
+            { new string[] { null, null, "2" }, new string[] { null, "1" }, 0},
+            { new string[] { null, null, "2" }, new string[] { null, "1" }, 0},
+
+            { new string[] { "1", "3", "2" }, new string[] { "1", null, "2" }, 0},
+            { new string[] { "1", "3", "2" }, new string[] { null, null }, -1},
+
+            { new string[] { "1", "3", "2" }, new string[] { null, "1" }, 0},
+
+            { null, new string[] { "1", null, "2" }, -1},
+
+            { new string[] { "1", null, null }, new string[] { null, null, "2" }, 1},
+            { new string[] { null, null, null }, new string[] { null, null }, 0},
+
+            { new string[] { "1", "3", "2" }, null, 0},
+            { new string[] { "1", null, "2" }, null, 0},
+        };
+
+        public static TheoryData<string[], int> LastIndexOfNullData => new TheoryData<string[], int>()
+        {
+            { new string[] { "1", null, "2" }, 1},
+            { new string[] { "1", "3", "2" }, -1},
+            { null, -1},
+            { new string[] { "1", null, null }, 2},
+            { new string[] { null, null, null }, 2},
+            { new string[] { null, null, "3" }, 1},
+        };
+
+        public static TheoryData<string[], string[], int> LastIndexOfNullSequenceData => new TheoryData<string[], string[], int>()
+        {
+            { new string[] { "1", null, "2" }, new string[] { "1", null, "2" }, 0},
+            { new string[] { "1", null, "2" }, new string[] { null }, 1},
+            { new string[] { "1", null, "2" }, (string[])null, 0},
+
+            { new string[] { "1", "3", "1" }, new string[] { "1", null, "2" }, -1},
+            { new string[] { "1", "3", "1" }, new string[] { "1" }, 2},
+            { new string[] { "1", "3", "1" }, null, 0},
+            { new string[] { "1", "3", "1" }, (string[])null, 0},
+
+            { null, new string[] { "1", null, "2" }, -1},
+
+            { new string[] { "1", null, null }, new string[] { null, null, "2" }, -1},
+            { new string[] { null, null, null }, new string[] { null, null }, 1},
+        };
+
+        public static TheoryData<string[], string[], int> LastIndexOfAnyNullSequenceData => new TheoryData<string[], string[], int>()
+        {
+            { new string[] { "1", null, "2" }, new string[] { "1", null, "3" }, 1},
+            { new string[] { "1", null, "2" }, new string[] { null, null }, 1},
+            { new string[] { "1", null, "2" }, new string[] { "3", "4" }, -1},
+            { new string[] { "1", null, "2" }, new string[] { "3", null }, 1},
+            { new string[] { "1", null, "2" }, new string[] { "1", null }, 1},
+            { new string[] { "1", null, "2" }, new string[] { null, null }, 1},
+            { new string[] { "1", null, "2" }, new string[] { "1", "2" }, 2},
+            { null, new string[] { "1", null, "2" }, -1},
+
+            { new string[] { null, null, "2" }, new string[] { "3", null }, 1},
+            { new string[] { null, null, "2" }, new string[] { null, "1" }, 1},
+            { new string[] { null, null, "2" }, new string[] { null, "1" }, 1},
+
+            { new string[] { "1", "3", "2" }, new string[] { null, "1" }, 0},
+            { new string[] { "1", "3", "2" }, new string[] { "1", "2", null }, 2},
+            { new string[] { "1", "3", "2" }, new string[] { "4", "5", null }, -1},
+            { new string[] { "1", "3", "2" }, new string[] { null, null }, -1},
+            { new string[] { "1", "3", "2" }, new string[] { null, null, null }, -1},
+            { new string[] { "1", "3", "2" }, new string[] { null, null, null, null }, -1},
+            { new string[] { "1", "3", "2" }, new string[] { null, null, null, null, null }, -1},
+
+            { null, new string[] { null, "1" }, -1},
+
+            { new string[] { "1", null, null }, new string[] { null, null, "2" }, 2},
+            { new string[] { null, null, null }, new string[] { null, null }, 2},
+
+            { new string[] { "1", null, "2" }, null, 0},
+            { new string[] { "1", "3", "2" }, null, 0},
+        };
     }
 }