Use explicit AsSpan

am11 · am11 · commit 3a7a63bba543 · 2024-12-03T17:01:29.000+02:00
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ReachabilityInstrumentationFilter.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ReachabilityInstrumentationFilter.cs
@@ -44,7 +44,7 @@ public ReachabilityInstrumentationFilter(string profileDataFileName, ILProvider
                 int numTokens = reader.ReadInt32();
 
                 bool[] tokenStates = new bool[numTokens];
-                if (reader.Read(MemoryMarshal.Cast<bool, byte>(tokenStates)) != numTokens)
+                if (reader.Read(MemoryMarshal.Cast<bool, byte>(tokenStates.AsSpan())) != numTokens)
                     throw new IOException("Unexpected end of file");
 
                 _reachabilityInfo.Add(new Guid(guidBytes), tokenStates);
diff --git a/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs b/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs
@@ -1915,7 +1915,7 @@ public virtual async Task ReadWrite_MessagesSmallerThanReadBuffer_Success(ReadWr
                         }
 
                         Assert.Equal(writerBytes.Length, n);
-                        AssertExtensions.SequenceEqual(writerBytes, readerBytes.AsSpan(0, writerBytes.Length));
+                        AssertExtensions.SequenceEqual(writerBytes.AsSpan(), readerBytes.AsSpan(0, writerBytes.Length));
 
                         await writes;
                     }
@@ -3069,7 +3069,7 @@ public virtual async Task ZeroByteRead_PerformsZeroByteReadOnUnderlyingStreamWhe
 
                 if (FlushGuaranteesAllDataWritten)
                 {
-                    AssertExtensions.SequenceEqual(data, buffer.AsSpan(0, bytesRead));
+                    AssertExtensions.SequenceEqual(data.AsSpan(), buffer.AsSpan(0, bytesRead));
                 }
             }
         }
diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySinglePrimitiveRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySinglePrimitiveRecord.cs
@@ -161,7 +161,7 @@ internal static IReadOnlyList<T> DecodePrimitiveTypes(BinaryReader reader, int c
         {
             if (typeof(T) == typeof(short) || typeof(T) == typeof(ushort))
             {
-                Span<short> span = MemoryMarshal.Cast<T, short>(result);
+                Span<short> span = MemoryMarshal.Cast<T, short>(result.AsSpan());
 #if NET
                 BinaryPrimitives.ReverseEndianness(span, span);
 #else
@@ -173,7 +173,7 @@ internal static IReadOnlyList<T> DecodePrimitiveTypes(BinaryReader reader, int c
             }
             else if (typeof(T) == typeof(int) || typeof(T) == typeof(uint) || typeof(T) == typeof(float))
             {
-                Span<int> span = MemoryMarshal.Cast<T, int>(result);
+                Span<int> span = MemoryMarshal.Cast<T, int>(result.AsSpan());
 #if NET
                 BinaryPrimitives.ReverseEndianness(span, span);
 #else
@@ -185,7 +185,7 @@ internal static IReadOnlyList<T> DecodePrimitiveTypes(BinaryReader reader, int c
             }
             else if (typeof(T) == typeof(long) || typeof(T) == typeof(ulong) || typeof(T) == typeof(double))
             {
-                Span<long> span = MemoryMarshal.Cast<T, long>(result);
+                Span<long> span = MemoryMarshal.Cast<T, long>(result.AsSpan());
 #if NET
                 BinaryPrimitives.ReverseEndianness(span, span);
 #else
@@ -201,7 +201,7 @@ internal static IReadOnlyList<T> DecodePrimitiveTypes(BinaryReader reader, int c
         {
             // See DontCastBytesToBooleans test to see what could go wrong.
             bool[] booleans = (bool[])(object)result;
-            Span<byte> resultAsBytes = MemoryMarshal.AsBytes<T>(result);
+            Span<byte> resultAsBytes = MemoryMarshal.AsBytes<T>(result.AsSpan());
             for (int i = 0; i < booleans.Length; i++)
             {
                 // We don't use the bool array to get the value, as an optimizing compiler or JIT could elide this.
diff --git a/src/libraries/System.Linq/tests/RangeTests.cs b/src/libraries/System.Linq/tests/RangeTests.cs
@@ -270,7 +270,7 @@ static void Validate(IEnumerable<int> e, int[] expected)
                 list.CopyTo(actual, 1);
                 Assert.Equal(0, actual[0]);
                 Assert.Equal(0, actual[^1]);
-                AssertExtensions.SequenceEqual(expected, actual.AsSpan(1, expected.Length));
+                AssertExtensions.SequenceEqual(expected.AsSpan(), actual.AsSpan(1, expected.Length));
             }
         }
     }
diff --git a/src/libraries/System.Linq/tests/RepeatTests.cs b/src/libraries/System.Linq/tests/RepeatTests.cs
@@ -282,7 +282,7 @@ static void Validate(IEnumerable<int> e, int[] expected)
                 list.CopyTo(actual, 1);
                 Assert.Equal(0, actual[0]);
                 Assert.Equal(0, actual[^1]);
-                AssertExtensions.SequenceEqual(expected, actual.AsSpan(1, expected.Length));
+                AssertExtensions.SequenceEqual(expected.AsSpan(), actual.AsSpan(1, expected.Length));
             }
         }
     }
diff --git a/src/libraries/System.Memory/tests/Base64Url/Base64UrlUnicodeAPIsUnitTests.cs b/src/libraries/System.Memory/tests/Base64Url/Base64UrlUnicodeAPIsUnitTests.cs
@@ -438,7 +438,7 @@ public static void Base64_AllMethodsRoundtripConsistently()
                 Span<byte> decodedBytes = new byte[original.Length];
                 int decoded = Base64Url.DecodeFromChars(encodedArray, decodedBytes);
                 Assert.Equal(original.Length, decoded);
-                AssertExtensions.SequenceEqual(original, decodedBytes);
+                AssertExtensions.SequenceEqual(original.AsSpan(), decodedBytes);
 
                 byte[] actualBytes = new byte[original.Length];
                 Assert.True(Base64Url.TryDecodeFromChars(encodedSpan, actualBytes, out int bytesWritten));
diff --git a/src/libraries/System.Memory/tests/Span/SearchValues.cs b/src/libraries/System.Memory/tests/Span/SearchValues.cs
@@ -465,7 +465,7 @@ static SearchValuesTestHelper()
                     s_randomLatin1Chars[i] = (char)rng.Next(0, 256);
                 }
 
-                rng.NextBytes(MemoryMarshal.Cast<char, byte>(s_randomChars));
+                rng.NextBytes(MemoryMarshal.Cast<char, byte>(s_randomChars.AsSpan()));
 
                 s_randomAsciiBytes = Encoding.ASCII.GetBytes(s_randomAsciiChars);
 
diff --git a/src/libraries/System.Memory/tests/Span/StringSearchValues.cs b/src/libraries/System.Memory/tests/Span/StringSearchValues.cs
@@ -620,7 +620,7 @@ public StringSearchValuesTestHelper(IndexOfAnySearchDelegate expected, SearchVal
                     }));
                 }
 
-                rng.NextBytes(MemoryMarshal.Cast<char, byte>(_randomChars));
+                rng.NextBytes(MemoryMarshal.Cast<char, byte>(_randomChars.AsSpan()));
             }
 
             public void StressRandomInputs(TimeSpan duration)
diff --git a/src/libraries/System.Net.Sockets/tests/FunctionalTests/SocketAsyncEventArgsTest.cs b/src/libraries/System.Net.Sockets/tests/FunctionalTests/SocketAsyncEventArgsTest.cs
@@ -728,7 +728,7 @@ public void AcceptAsync_WithReceiveBuffer_Success()
 
                 Assert.Equal(acceptBufferDataSize, acceptArgs.BytesTransferred);
 
-                AssertExtensions.SequenceEqual(sendBuffer, acceptArgs.Buffer.AsSpan(0, acceptArgs.BytesTransferred));
+                AssertExtensions.SequenceEqual(sendBuffer.AsSpan(), acceptArgs.Buffer.AsSpan(0, acceptArgs.BytesTransferred));
             }
         }
 
diff --git a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/CollectionsMarshalTests.cs b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/CollectionsMarshalTests.cs
@@ -527,32 +527,32 @@ public void ListSetCount()
             CollectionsMarshal.SetCount(list, 3);
             Assert.Equal(3, list.Count);
             Assert.Throws<ArgumentOutOfRangeException>(() => list[3]);
-            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(list), new int[] { 1, 2, 3 });
+            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(list), new int[] { 1, 2, 3 }.AsSpan());
             Assert.True(Unsafe.AreSame(ref intRef, ref MemoryMarshal.GetReference(CollectionsMarshal.AsSpan(list))));
 
             // make sure that size increase preserves content and doesn't clear
             CollectionsMarshal.SetCount(list, 5);
-            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(list), new int[] { 1, 2, 3, 4, 5 });
+            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(list), new int[] { 1, 2, 3, 4, 5 }.AsSpan());
             Assert.True(Unsafe.AreSame(ref intRef, ref MemoryMarshal.GetReference(CollectionsMarshal.AsSpan(list))));
 
             // make sure that reallocations preserve content
             int newCount = list.Capacity * 2;
             CollectionsMarshal.SetCount(list, newCount);
             Assert.Equal(newCount, list.Count);
-            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(list)[..3], new int[] { 1, 2, 3 });
+            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(list)[..3], new int[] { 1, 2, 3 }.AsSpan());
             Assert.True(!Unsafe.AreSame(ref intRef, ref MemoryMarshal.GetReference(CollectionsMarshal.AsSpan(list))));
 
             List<string> listReference = new() { "a", "b", "c", "d", "e" };
             ref string stringRef = ref MemoryMarshal.GetReference(CollectionsMarshal.AsSpan(listReference));
             CollectionsMarshal.SetCount(listReference, 3);
 
             // verify that reference types aren't cleared
-            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(listReference), new string[] { "a", "b", "c" });
+            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(listReference), new string[] { "a", "b", "c" }.AsSpan());
             Assert.True(Unsafe.AreSame(ref stringRef, ref MemoryMarshal.GetReference(CollectionsMarshal.AsSpan(listReference))));
             CollectionsMarshal.SetCount(listReference, 5);
 
             // verify that removed reference types are cleared
-            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(listReference), new string[] { "a", "b", "c", null, null });
+            AssertExtensions.SequenceEqual(CollectionsMarshal.AsSpan(listReference), new string[] { "a", "b", "c", null, null }.AsSpan());
             Assert.True(Unsafe.AreSame(ref stringRef, ref MemoryMarshal.GetReference(CollectionsMarshal.AsSpan(listReference))));
         }
     }
diff --git a/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigInteger.cs b/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigInteger.cs
@@ -384,7 +384,7 @@ public BigInteger(ReadOnlySpan<byte> value, bool isUnsigned = false, bool isBigE
                     // The bytes parameter is in little-endian byte order.
                     // We can just copy the bytes directly into the uint array.
 
-                    value.Slice(0, wholeUInt32Count * 4).CopyTo(MemoryMarshal.AsBytes<uint>(val));
+                    value.Slice(0, wholeUInt32Count * 4).CopyTo(MemoryMarshal.AsBytes<uint>(val.AsSpan()));
                 }
 
                 // In both of the above cases on big-endian architecture, we need to perform
diff --git a/src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/FileStream/ReadAsync.cs b/src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/FileStream/ReadAsync.cs
@@ -123,7 +123,7 @@ public async Task IncompleteReadCantSetPositionBeyondEndOfFile(FileShare fileSha
                 await Task.WhenAll(reads);
                 // but when they are finished, the first buffer should contain valid data:
                 Assert.Equal(fileSize, reads.First().Result);
-                AssertExtensions.SequenceEqual(content, buffers.First().AsSpan(0, fileSize));
+                AssertExtensions.SequenceEqual(content.AsSpan(), buffers.First().AsSpan(0, fileSize));
                 // and other reads should return 0:
                 Assert.All(reads.Skip(1), read => Assert.Equal(0, read.Result));
                 // and the Position must be correct:
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Convert.FromHexString.cs b/src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Convert.FromHexString.cs
@@ -42,7 +42,7 @@ private static void TestSequence(byte[] expected, string actual)
             Assert.Equal(OperationStatus.Done, Convert.FromHexString(actual, tryResult, out int consumed, out int written));
             Assert.Equal(fromResult.Length, written);
             Assert.Equal(actual.Length, consumed);
-            AssertExtensions.SequenceEqual(expected, tryResult);
+            AssertExtensions.SequenceEqual(expected.AsSpan(), tryResult);
         }
 
         [Fact]
diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Random.cs b/src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Random.cs
@@ -713,9 +713,9 @@ public static void Shuffle_Array_Seeded(bool emptyShuffle)
             Random random = new Random(0x70636A61);
             int[] items = new int[] { 1, 2, 3, 4 };
             random.Shuffle(items);
-            AssertExtensions.SequenceEqual(stackalloc int[] { 4, 2, 1, 3 }, items);
+            AssertExtensions.SequenceEqual(stackalloc int[] { 4, 2, 1, 3 }, items.AsSpan());
             random.Shuffle(items);
-            AssertExtensions.SequenceEqual(stackalloc int[] { 2, 3, 4, 1 }, items);
+            AssertExtensions.SequenceEqual(stackalloc int[] { 2, 3, 4, 1 }, items.AsSpan());
 
             if (emptyShuffle)
             {
@@ -724,7 +724,7 @@ public static void Shuffle_Array_Seeded(bool emptyShuffle)
             }
 
             random.Shuffle(items);
-            AssertExtensions.SequenceEqual(stackalloc int[] { 1, 4, 3, 2 }, items);
+            AssertExtensions.SequenceEqual(stackalloc int[] { 1, 4, 3, 2 }, items.AsSpan());
         }
 
         [Fact]
@@ -831,13 +831,13 @@ public static void GetItems_Buffer_Seeded_NonPower2()
 
             Span<byte> buffer = stackalloc byte[7];
             random.GetItems(items, buffer);
-            AssertExtensions.SequenceEqual(new byte[] { 3, 1, 3, 2, 3, 3, 3 }, buffer);
+            AssertExtensions.SequenceEqual(new byte[] { 3, 1, 3, 2, 3, 3, 3 }.AsSpan(), buffer);
 
             random.GetItems(items, buffer);
-            AssertExtensions.SequenceEqual(new byte[] { 2, 1, 2, 1, 2, 3, 1 }, buffer);
+            AssertExtensions.SequenceEqual(new byte[] { 2, 1, 2, 1, 2, 3, 1 }.AsSpan(), buffer);
 
             random.GetItems(items, buffer);
-            AssertExtensions.SequenceEqual(new byte[] { 1, 1, 3, 1, 3, 2, 2 }, buffer);
+            AssertExtensions.SequenceEqual(new byte[] { 1, 1, 3, 1, 3, 2, 2 }.AsSpan(), buffer);
         }
 
         [Fact]
@@ -880,13 +880,13 @@ public static void GetItems_Buffer_Seeded_Power2()
 
             Span<byte> buffer = stackalloc byte[7];
             random.GetItems(items, buffer);
-            AssertExtensions.SequenceEqual(new byte[] { 4, 1, 4, 2, 4, 4, 4 }, buffer);
+            AssertExtensions.SequenceEqual(new byte[] { 4, 1, 4, 2, 4, 4, 4 }.AsSpan(), buffer);
 
             random.GetItems(items, buffer);
-            AssertExtensions.SequenceEqual(new byte[] { 2, 2, 3, 1, 3, 3, 1 }, buffer);
+            AssertExtensions.SequenceEqual(new byte[] { 2, 2, 3, 1, 3, 3, 1 }.AsSpan(), buffer);
 
             random.GetItems(items, buffer);
-            AssertExtensions.SequenceEqual(new byte[] { 2, 1, 4, 2, 4, 2, 2 }, buffer);
+            AssertExtensions.SequenceEqual(new byte[] { 2, 1, 4, 2, 4, 2, 2 }.AsSpan(), buffer);
         }
 
         [Theory]
diff --git a/src/libraries/System.Runtime/tests/System.Text.Encoding.Tests/Ascii/CaseConversionTests.cs b/src/libraries/System.Runtime/tests/System.Text.Encoding.Tests/Ascii/CaseConversionTests.cs
@@ -25,20 +25,20 @@ public static void OverlappingBuffers_Throws()
             Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(byteBuffer, byteBuffer, out _));
             Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(byteBuffer.AsSpan(1, 3), byteBuffer.AsSpan(3, 5), out _));
             // byte -> char
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer), out _));
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer).Slice(1, 3), out _));
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer), out _));
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer).Slice(1, 3), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer.AsSpan()), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer.AsSpan()).Slice(1, 3), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer.AsSpan()), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(byteBuffer, MemoryMarshal.Cast<byte, char>(byteBuffer.AsSpan()).Slice(1, 3), out _));
             // char -> char
             Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(charBuffer, charBuffer, out _));
             Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(charBuffer.AsSpan(1, 3), charBuffer.AsSpan(3, 5), out _));
             Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(charBuffer, charBuffer, out _));
             Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(charBuffer.AsSpan(1, 3), charBuffer.AsSpan(3, 5), out _));
             // char -> byte
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer), out _));
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer).Slice(1, 3), out _));
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer), out _));
-            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer).Slice(1, 3), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer.AsSpan()), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToLower(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer.AsSpan()).Slice(1, 3), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer.AsSpan()), out _));
+            Assert.Throws<InvalidOperationException>(() => Ascii.ToUpper(charBuffer, MemoryMarshal.Cast<char, byte>(charBuffer.AsSpan()).Slice(1, 3), out _));
         }
 
         private static void VerifySingleChar<T>(OperationStatus status, int value, T expected, T actual, int written)
diff --git a/src/libraries/System.Security.Cryptography.Cose/tests/CoseHeaderValueTests.cs b/src/libraries/System.Security.Cryptography.Cose/tests/CoseHeaderValueTests.cs
@@ -97,7 +97,7 @@ public void GetValueAsBytesSucceeds(ContentTestCase @case)
             Span<byte> buffer = new byte[content.Length];
             int length = headerValue.GetValueAsBytes(buffer);
             Assert.Equal(content.Length, length);
-            AssertExtensions.SequenceEqual(content, buffer);
+            AssertExtensions.SequenceEqual(content.AsSpan(), buffer);
         }
 
         [Theory]
@@ -138,7 +138,7 @@ void Verify(int repetitions)
 
                 for (int i = 0; i < expectedLength; i+= content.Length)
                 {
-                    AssertExtensions.SequenceEqual(content, buffer.Slice(i, content.Length));
+                    AssertExtensions.SequenceEqual(content.AsSpan(), buffer.Slice(i, content.Length));
                 }
             }
         }
@@ -244,7 +244,7 @@ public void FromBytesSucceeds(ContentTestCase @case)
 
             Span<byte> buffer = new byte[content.Length];
             int length = headerValue.GetValueAsBytes(buffer);
-            AssertExtensions.SequenceEqual(content, buffer);
+            AssertExtensions.SequenceEqual(content.AsSpan(), buffer);
             Assert.Equal(content.Length, length);
         }
 
diff --git a/src/libraries/System.Security.Cryptography.ProtectedData/tests/SpanProtectedDataTests.cs b/src/libraries/System.Security.Cryptography.ProtectedData/tests/SpanProtectedDataTests.cs
@@ -42,7 +42,7 @@ public void ZeroBufferThrows()
         public void NearCorrectSizeBufferTests(int delta, bool success)
         {
             byte[] buffer = new byte[DefaultProtectedBufferSize];
-            int original = ProtectedData.Protect([1, 2, 3], DataProtectionScope.CurrentUser, buffer);
+            int original = ProtectedData.Protect([1, 2, 3], DataProtectionScope.CurrentUser, buffer.AsSpan());
 
             if (success)
             {
diff --git a/src/libraries/System.Security.Cryptography/tests/HashAlgorithmTestDriver.cs b/src/libraries/System.Security.Cryptography/tests/HashAlgorithmTestDriver.cs
@@ -66,7 +66,7 @@ private void VerifyOneShotStream(Stream input, string output)
             Span<byte> buffer = stackalloc byte[512 / 8];
 
             int written = HashData(input, buffer);
-            AssertExtensions.SequenceEqual(expected, buffer.Slice(0, written));
+            AssertExtensions.SequenceEqual(expected.AsSpan(), buffer.Slice(0, written));
         }
 
         private async Task VerifyOneShotStreamAsync(Stream input, string output)
@@ -75,7 +75,7 @@ private async Task VerifyOneShotStreamAsync(Stream input, string output)
             Memory<byte> buffer = new byte[512 / 8];
 
             int written = await HashDataAsync(input, buffer, cancellationToken: default);
-            AssertExtensions.SequenceEqual(expected, buffer.Slice(0, written).Span);
+            AssertExtensions.SequenceEqual(expected.AsSpan(), buffer.Slice(0, written).Span);
         }
 
         private void VerifyOneShotAllocatingStream(Stream input, string output)
@@ -100,7 +100,7 @@ private void VerifyOneShotStream_CryptographicOperations(Stream input, string ou
             Span<byte> buffer = stackalloc byte[512 / 8];
 
             int written = CryptographicOperations.HashData(HashAlgorithm, input, buffer);
-            AssertExtensions.SequenceEqual(expected, buffer.Slice(0, written));
+            AssertExtensions.SequenceEqual(expected.AsSpan(), buffer.Slice(0, written));
         }
 
         private async Task VerifyOneShotStreamAsync_CryptographicOperations(Stream input, string output)
@@ -114,7 +114,7 @@ private async Task VerifyOneShotStreamAsync_CryptographicOperations(Stream input
                 buffer,
                 cancellationToken: default);
 
-            AssertExtensions.SequenceEqual(expected, buffer.Slice(0, written).Span);
+            AssertExtensions.SequenceEqual(expected.AsSpan(), buffer.Slice(0, written).Span);
         }
 
         private void VerifyOneShotAllocatingStream_CryptographicOperations(Stream input, string output)
diff --git a/src/libraries/System.Security.Cryptography/tests/HmacTests.cs b/src/libraries/System.Security.Cryptography/tests/HmacTests.cs
diff --git a/src/libraries/System.Security.Cryptography/tests/KmacTestDriver.cs b/src/libraries/System.Security.Cryptography/tests/KmacTestDriver.cs
diff --git a/src/libraries/System.Security.Cryptography/tests/X509Certificates/ExtensionsTests/AuthorityKeyIdentifierTests.cs b/src/libraries/System.Security.Cryptography/tests/X509Certificates/ExtensionsTests/AuthorityKeyIdentifierTests.cs
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonDocument.MetadataDb.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonDocument.MetadataDb.cs
diff --git a/src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Memory.cs b/src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Memory.cs

Original file line number	Diff line number	Diff line change
`@@ -1915,7 +1915,7 @@ public virtual async Task ReadWrite_MessagesSmallerThanReadBuffer_Success(ReadWr`
`1915`	`1915`	`}`
`1916`	`1916`
`1917`	`1917`	`Assert.Equal(writerBytes.Length, n);`
`1918`		`- AssertExtensions.SequenceEqual(writerBytes, readerBytes.AsSpan(0, writerBytes.Length));`
	`1918`	`+ AssertExtensions.SequenceEqual(writerBytes.AsSpan(), readerBytes.AsSpan(0, writerBytes.Length));`
`1919`	`1919`
`1920`	`1920`	`await writes;`
`1921`	`1921`	`}`
`@@ -3069,7 +3069,7 @@ public virtual async Task ZeroByteRead_PerformsZeroByteReadOnUnderlyingStreamWhe`
`3069`	`3069`
`3070`	`3070`	`if (FlushGuaranteesAllDataWritten)`
`3071`	`3071`	`{`
`3072`		`- AssertExtensions.SequenceEqual(data, buffer.AsSpan(0, bytesRead));`
	`3072`	`+ AssertExtensions.SequenceEqual(data.AsSpan(), buffer.AsSpan(0, bytesRead));`
`3073`	`3073`	`}`
`3074`	`3074`	`}`
`3075`	`3075`	`}`
Original file line number	Diff line number	Diff line change
`@@ -161,7 +161,7 @@ internal static IReadOnlyList<T> DecodePrimitiveTypes(BinaryReader reader, int c`
`161`	`161`	`{`
`162`	`162`	`if (typeof(T) == typeof(short) \|\| typeof(T) == typeof(ushort))`
`163`	`163`	`{`
`164`		`- Span<short> span = MemoryMarshal.Cast<T, short>(result);`
	`164`	`+ Span<short> span = MemoryMarshal.Cast<T, short>(result.AsSpan());`
`165`	`165`	`#if NET`
`166`	`166`	`BinaryPrimitives.ReverseEndianness(span, span);`
`167`	`167`	`#else`
`@@ -173,7 +173,7 @@ internal static IReadOnlyList<T> DecodePrimitiveTypes(BinaryReader reader, int c`
`173`	`173`	`}`
`174`	`174`	`else if (typeof(T) == typeof(int) \|\| typeof(T) == typeof(uint) \|\| typeof(T) == typeof(float))`
`175`	`175`	`{`
`176`		`- Span<int> span = MemoryMarshal.Cast<T, int>(result);`
	`176`	`+ Span<int> span = MemoryMarshal.Cast<T, int>(result.AsSpan());`
`177`	`177`	`#if NET`
`178`	`178`	`BinaryPrimitives.ReverseEndianness(span, span);`
`179`	`179`	`#else`
`@@ -185,7 +185,7 @@ internal static IReadOnlyList<T> DecodePrimitiveTypes(BinaryReader reader, int c`
`185`	`185`	`}`
`186`	`186`	`else if (typeof(T) == typeof(long) \|\| typeof(T) == typeof(ulong) \|\| typeof(T) == typeof(double))`
`187`	`187`	`{`
`188`		`- Span<long> span = MemoryMarshal.Cast<T, long>(result);`
	`188`	`+ Span<long> span = MemoryMarshal.Cast<T, long>(result.AsSpan());`
`189`	`189`	`#if NET`
`190`	`190`	`BinaryPrimitives.ReverseEndianness(span, span);`
`191`	`191`	`#else`
`@@ -201,7 +201,7 @@ internal static IReadOnlyList<T> DecodePrimitiveTypes(BinaryReader reader, int c`
`201`	`201`	`{`
`202`	`202`	`// See DontCastBytesToBooleans test to see what could go wrong.`
`203`	`203`	`bool[] booleans = (bool[])(object)result;`
`204`		`- Span<byte> resultAsBytes = MemoryMarshal.AsBytes<T>(result);`
	`204`	`+ Span<byte> resultAsBytes = MemoryMarshal.AsBytes<T>(result.AsSpan());`
`205`	`205`	`for (int i = 0; i < booleans.Length; i++)`
`206`	`206`	`{`
`207`	`207`	`// We don't use the bool array to get the value, as an optimizing compiler or JIT could elide this.`
Original file line number	Diff line number	Diff line change
`@@ -270,7 +270,7 @@ static void Validate(IEnumerable<int> e, int[] expected)`
`270`	`270`	`list.CopyTo(actual, 1);`
`271`	`271`	`Assert.Equal(0, actual[0]);`
`272`	`272`	`Assert.Equal(0, actual[^1]);`
`273`		`- AssertExtensions.SequenceEqual(expected, actual.AsSpan(1, expected.Length));`
	`273`	`+ AssertExtensions.SequenceEqual(expected.AsSpan(), actual.AsSpan(1, expected.Length));`
`274`	`274`	`}`
`275`	`275`	`}`
`276`	`276`	`}`
Original file line number	Diff line number	Diff line change
`@@ -282,7 +282,7 @@ static void Validate(IEnumerable<int> e, int[] expected)`
`282`	`282`	`list.CopyTo(actual, 1);`
`283`	`283`	`Assert.Equal(0, actual[0]);`
`284`	`284`	`Assert.Equal(0, actual[^1]);`
`285`		`- AssertExtensions.SequenceEqual(expected, actual.AsSpan(1, expected.Length));`
	`285`	`+ AssertExtensions.SequenceEqual(expected.AsSpan(), actual.AsSpan(1, expected.Length));`
`286`	`286`	`}`
`287`	`287`	`}`
`288`	`288`	`}`
Original file line number	Diff line number	Diff line change
`@@ -465,7 +465,7 @@ static SearchValuesTestHelper()`
`465`	`465`	`s_randomLatin1Chars[i] = (char)rng.Next(0, 256);`
`466`	`466`	`}`
`467`	`467`
`468`		`- rng.NextBytes(MemoryMarshal.Cast<char, byte>(s_randomChars));`
	`468`	`+ rng.NextBytes(MemoryMarshal.Cast<char, byte>(s_randomChars.AsSpan()));`
`469`	`469`
`470`	`470`	`s_randomAsciiBytes = Encoding.ASCII.GetBytes(s_randomAsciiChars);`
`471`	`471`
Original file line number	Diff line number	Diff line change
`@@ -620,7 +620,7 @@ public StringSearchValuesTestHelper(IndexOfAnySearchDelegate expected, SearchVal`
`620`	`620`	`}));`
`621`	`621`	`}`
`622`	`622`
`623`		`- rng.NextBytes(MemoryMarshal.Cast<char, byte>(_randomChars));`
	`623`	`+ rng.NextBytes(MemoryMarshal.Cast<char, byte>(_randomChars.AsSpan()));`
`624`	`624`	`}`
`625`	`625`
`626`	`626`	`public void StressRandomInputs(TimeSpan duration)`
Original file line number	Diff line number	Diff line change
`@@ -728,7 +728,7 @@ public void AcceptAsync_WithReceiveBuffer_Success()`
`728`	`728`
`729`	`729`	`Assert.Equal(acceptBufferDataSize, acceptArgs.BytesTransferred);`
`730`	`730`
`731`		`- AssertExtensions.SequenceEqual(sendBuffer, acceptArgs.Buffer.AsSpan(0, acceptArgs.BytesTransferred));`
	`731`	`+ AssertExtensions.SequenceEqual(sendBuffer.AsSpan(), acceptArgs.Buffer.AsSpan(0, acceptArgs.BytesTransferred));`
`732`	`732`	`}`
`733`	`733`	`}`
`734`	`734`