Equal

XmlSerializerFormatTest.cs (6)

185Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 233Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 281Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 334Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 391Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 448Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams));

src\System.Private.ServiceModel\tests\Scenarios\Contract\XmlSerializer\XmlSerializerFormatTest.cs (6)

185Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 233Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 281Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 334Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 391Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 448Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams));

src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (2)

133Assert.Equal( 151Assert.Equal(

src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (2)

133Assert.Equal( 151Assert.Equal(

BadHttpRequestTests.cs (1)

270Assert.Equal(Http1Connection.Http2GoAwayHttp11RequiredBytes.ToArray(), data);

Http2\Http2ConnectionTests.cs (3)

2271Assert.Equal(new byte[] { 0x08, 0x03, (byte)'1', (byte)'0', (byte)'0' }, frame.PayloadSequence.ToArray()); 5694Assert.Equal(streamPayload, streamResponse); 5865Assert.Equal(Http2Connection.InvalidHttp1xErrorResponseBytes, data);

Http2\Http2StreamTests.cs (2)

4006Assert.Equal(Encoding.ASCII.GetBytes(new string('a', 4102)), dataFrame.PayloadSequence.ToArray()); 4059Assert.Equal(Encoding.ASCII.GetBytes(new string('a', 4102)), dataFrame.PayloadSequence.ToArray());

Http3\Http3ConnectionTests.cs (1)

106Assert.Equal(continueBytesQpackEncoded, frame.PayloadSequence.ToArray());

Http3\Http3StreamTests.cs (1)

2882Assert.Equal(sourceData.AsMemory(0, 100).ToArray(), data.ToArray());

Http3\WebTransport\WebTransportStreamTests.cs (1)

50Assert.Equal(input.ToArray(), memoryOut.ToArray());

Http2\Http2RequestTests.cs (1)

283Assert.Equal(randomBytes, readData);

Http3\Http3RequestTests.cs (1)

2168Assert.Equal(TestData, data);

BinaryBlobTest.cs (1)

53Assert.Equal(expectedData, blob.GetData());

Circuits\HybridCacheCircuitPersistenceProviderTest.cs (2)

38Assert.Equal(persistedState.RootComponents, result.RootComponents); 84Assert.Equal(persistedState.RootComponents, result1.RootComponents);

Circuits\RemoteJSDataStreamTest.cs (2)

65Assert.Equal(chunk, memoryStream.ToArray()); 93Assert.Equal(chunk, memoryStream.ToArray());

src\SignalR\common\SignalR.Common\test\Internal\Protocol\MessagePackHubProtocolTestBase.cs (1)

481Assert.Equal(expectedOutput, message.ToArray());

PersistentState\ComponentApplicationStateTest.cs (5)

25Assert.Equal(new byte[] { 1, 2, 3, 4 }, existing); 73Assert.Equal(new byte[] { 1, 2, 3, 4 }, existing); 93Assert.Equal(myState, JsonSerializer.Deserialize<byte[]>(stored)); 129Assert.Equal(myState, JsonSerializer.Deserialize<byte[]>(stored)); 165Assert.Equal(myState, stored);

PersistentState\ComponentStatePersistenceManagerTest.cs (2)

59Assert.Equal(data, retrieved); 158Assert.Equal(data, JsonSerializer.Deserialize<byte[]>(persisted.ToArray()));

PullFromJSDataStreamTest.cs (2)

46Assert.Equal(expectedChunks[i], buffer); 60Assert.Equal(Data, mem.ToArray());

DataProtectionAdvancedExtensionsTests.cs (1)

75Assert.Equal(new byte[] { 0x01, 0x02 }, protectedPayload);

TimeLimitedDataProtectorTests.cs (4)

38Assert.Equal(new byte[] { 0x10, 0x11 }, protectedPayload); 61Assert.Equal(new byte[] { 0x10, 0x11 }, protectedPayload); 85Assert.Equal(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05 }, retVal); 164Assert.Equal(

AuthenticatedEncryption\ConfigurationModel\AuthenticatedEncryptorDescriptorDeserializerTests.cs (1)

41Assert.Equal(plaintext, roundTripPlaintext);

AuthenticatedEncryption\ConfigurationModel\AuthenticatedEncryptorDescriptorTests.cs (4)

49Assert.Equal(plaintext, roundTripPlaintext); 75Assert.Equal(plaintext, roundTripPlaintext); 101Assert.Equal(plaintext, roundTripPlaintext); 139Assert.Equal(plaintext, roundTripPlaintext);

AuthenticatedEncryption\ConfigurationModel\CngCbcAuthenticatedEncryptorDescriptorDeserializerTests.cs (1)

48Assert.Equal(plaintext, roundTripPlaintext);

AuthenticatedEncryption\ConfigurationModel\CngGcmAuthenticatedEncryptorDescriptorDeserializerTests.cs (1)

45Assert.Equal(plaintext, roundTripPlaintext);

AuthenticatedEncryption\ConfigurationModel\ManagedAuthenticatedEncryptorDescriptorDeserializerTests.cs (2)

49Assert.Equal(plaintext, roundTripPlaintext); 83Assert.Equal(plaintext, roundTripPlaintext);

Cng\CngAuthenticatedEncryptorBaseTests.cs (3)

32Assert.Equal(new byte[] { 0x20, 0x21, 0x22 }, retVal); 57Assert.Equal(new byte[] { 0x20, 0x21, 0x22 }, retVal); 82Assert.Equal(new byte[] { 0x20, 0x21, 0x22 }, retVal);

EphemeralDataProtectionProviderTests.cs (1)

60Assert.Equal(bytes, unprotectedBytes);

KeyManagement\KeyRingBasedDataProtectorTests.cs (9)

70Assert.Equal(expectedProtectedData, retVal); 108Assert.Equal(expectedProtectedData, retVal); 454Assert.Equal(expectedPlaintext, retVal); 495Assert.Equal(expectedPlaintext, retVal); 502Assert.Equal(expectedPlaintext, retVal); 545Assert.Equal(expectedPlaintext, retVal); 552Assert.Equal(expectedPlaintext, retVal); 581Assert.Equal(plaintext, roundTrippedPlaintext); 619Assert.Equal(expectedProtectedData, retVal);

SecretTests.cs (6)

36Assert.Equal(new byte[] { 0x20, 0x30, 0x40 }, outputSegment.AsStandaloneArray()); 44Assert.Equal(new byte[] { 0x20, 0x30, 0x40 }, outputBuffer); 63Assert.Equal(new byte[] { 0x20, 0x30, 0x40 }, outputSegment.AsStandaloneArray()); 71Assert.Equal(new byte[] { 0x20, 0x30, 0x40 }, outputBuffer); 145Assert.Equal(new byte[] { 0x20, 0x30, 0x40 }, outputSegment.AsStandaloneArray()); 153Assert.Equal(new byte[] { 0x20, 0x30, 0x40 }, outputBuffer);

JsonTranscodingServerCallContextTests.cs (1)

56Assert.Equal(new byte[] { 1, 2, 3 }, headers[1].ValueBytes);

UnaryServerCallHandlerTests.cs (3)

1203Assert.Equal(requestContent, requestData); 1561Assert.Equal(new byte[] { 1, 2, 3 }, request!.Data.SingleBytes.ToByteArray()); 1691Assert.Equal(new byte[] { 1, 2, 3 }, request!.Wrappers.BytesValue.ToByteArray());

HttpResponseWritingExtensionsTests.cs (2)

47Assert.Equal(expected, actual); 68Assert.Equal(expected, actualShortened);

HttpConnectionDispatcherTests.cs (9)

2407Assert.Equal(firstMsg, webSocketMessage.Buffer); 2437Assert.Equal(secondMsg, webSocketMessage.Buffer); 2481Assert.Equal(firstMsg, webSocketMessage.Buffer); 2512Assert.Equal(secondMsg, webSocketMessage.Buffer); 2983Assert.Equal(new byte[] { 1, 2, 3 }, memory.Slice(0, 3).ToArray()); 2995Assert.Equal(new byte[] { 1, 2, 3 }, memory.Slice(0, 3).ToArray()); 3040Assert.Equal(new byte[] { 2, 3, 4 }, memory.Slice(0, 3).ToArray()); 3050Assert.Equal(new byte[] { 2, 3, 4 }, memory.Slice(0, 3).ToArray()); 3172Assert.Equal(new byte[] { 1 }, memory.Slice(0, 1).ToArray());

RequestDelegateGenerator\RequestDelegateCreationTests.Arrays.cs (3)

774Assert.Equal(new[] { 1, 2, 3 }, (int[])httpContext.Items["query"]!); 775Assert.Equal(new[] { 4, 5, 6 }, (int[])httpContext.Items["headers"]!); 776Assert.Equal(new[] { 7, 8, 9 }, (int[])httpContext.Items["form"]!);

RequestDelegateGenerator\RequestDelegateCreationTests.cs (3)

598Assert.Equal(new[] { 1, 2, 3 }, (int[])httpContext.Items["query"]!); 599Assert.Equal(new[] { 4, 5, 6 }, (int[])httpContext.Items["headers"]!); 600Assert.Equal(new[] { 7, 8, 9 }, (int[])httpContext.Items["form"]!);

RequestDelegateGenerator\RequestDelegateCreationTests.JsonBody.cs (8)

246Assert.Equal(requestBodyBytes, data); 251Assert.Equal(requestBodyBytes, result.Buffer.ToArray()); 256Assert.Equal(requestBodyBytes, (byte[])rawRequestBody!); 287Assert.Equal(requestBodyBytes, data); 292Assert.Equal(requestBodyBytes, result.Buffer.ToArray()); 297Assert.Equal(requestBodyBytes, (byte[])rawRequestBody!); 338Assert.Equal(requestBodyBytes, (byte[])rawRequestBody!); 379Assert.Equal(requestBodyBytes, (byte[])rawRequestBody!);

ContentResultTests.cs (1)

122Assert.Equal(expectedContentData, memoryStream.ToArray());

ResultsTests.cs (2)

1618Assert.Equal(content, result.ResponseContent.ToArray()); 1635Assert.Equal(content, result.ResponseContent.ToArray());

src\Shared\ResultsTests\FileContentResultTestBase.cs (2)

41Assert.Equal(buffer, outStream.ToArray()); 349Assert.Equal(buffer, outStream.ToArray());

TypedResultsTests.cs (2)

1397Assert.Equal(content, result.ResponseContent.ToArray()); 1414Assert.Equal(content, result.ResponseContent.ToArray());

Utf8ContentResultTests.cs (3)

25Assert.Equal(data, result.ResponseContent.ToArray()); 43Assert.Equal(data, ms.ToArray()); 61Assert.Equal(data, ms.ToArray());

Base32Test.cs (3)

14Assert.Equal<byte>(data, Base32.FromBase32(Base32.ToBase32(data))); 22Assert.Equal<byte>(data, Base32.FromBase32(Base32.ToBase32(data))); 26Assert.Equal<byte>(data, Base32.FromBase32(Base32.ToBase32(data)));

ContentResultTest.cs (1)

139Assert.Equal(expectedContentData, memoryStream.ToArray());

Formatters\JsonInputFormatterTestBase.cs (1)

272Assert.Equal(new int[] { 0, 23, 300 }, integers);

Formatters\SystemTextJsonOutputFormatterTest.cs (1)

113Assert.Equal(expected.ToArray(), body.ToArray());

Infrastructure\JsonResultExecutorTestBase.cs (10)

38Assert.Equal(expected, written); 59Assert.Equal(expected, written); 83Assert.Equal(expected, written); 103Assert.Equal(expected, written); 127Assert.Equal(expected, written); 149Assert.Equal(expected, written); 174Assert.Equal(expected, written); 198Assert.Equal(expected, written); 324Assert.Equal(expected, written); 360Assert.Equal(expected, written);

ModelBinding\Binders\ArrayModelBinderTest.cs (1)

39Assert.Equal(new[] { 42, 84 }, array);

ModelBinding\Binders\ByteArrayModelBinderTests.cs (1)

54Assert.Equal(new byte[] { 23, 43, 53 }, bytes);

ModelBinding\Binders\CollectionModelBinderTest.cs (7)

33Assert.Equal(new[] { 42, 0, 200 }, collectionResult.Model.ToArray()); 57Assert.Equal(new[] { 42, 100 }, boundCollection.Model.ToArray()); 87Assert.Equal(new[] { 42, 100, 200 }, list.ToArray()); 118Assert.Equal(new[] { 42, 100, 200 }, list.ToArray()); 144Assert.Equal(new[] { 42, 100, 200 }, list.ToArray()); 170Assert.Equal(new[] { 42, 100, 200 }, list.ToArray()); 473Assert.Equal(new[] { 42 }, boundCollection.Model.ToArray());

src\Shared\ResultsTests\FileContentResultTestBase.cs (2)

41Assert.Equal(buffer, outStream.ToArray()); 349Assert.Equal(buffer, outStream.ToArray());

XmlDataContractSerializerInputFormatterTest.cs (1)

557Assert.Equal(expectedBytes, Encoding.UTF8.GetBytes(model.SampleString));

XmlSerializerInputFormatterTest.cs (1)

577Assert.Equal(expectedBytes, Encoding.UTF8.GetBytes(model.SampleString));

ArrayModelBinderIntegrationTest.cs (3)

38Assert.Equal(new int[] { 10, 11 }, model); 82Assert.Equal(new int[] { 10, 11 }, model); 122Assert.Equal(new int[] { 10, 11 }, model);

ByteArrayModelBinderIntegrationTest.cs (2)

56Assert.Equal(expectedValue, boundPerson.Token); 138Assert.Equal(expectedValue, model);

ComplexRecordIntegrationTest.cs (5)

371Assert.Equal(ByteArrayContent, model.Customer.Token); 423Assert.Equal(ByteArrayContent, model.Customer.Token); 795Assert.Equal(new int[] { 10, 11 }, model.ProductIds); 850Assert.Equal(new int[] { 10, 11 }, model.ProductIds); 2508Assert.Equal(new[] { 123 }, model.OrderIds.ToArray());

ComplexTypeIntegrationTestBase.cs (5)

364Assert.Equal(ByteArrayContent, model.Customer.Token); 416Assert.Equal(ByteArrayContent, model.Customer.Token); 803Assert.Equal(new int[] { 10, 11 }, model.ProductIds); 858Assert.Equal(new int[] { 10, 11 }, model.ProductIds); 2678Assert.Equal(new[] { 123 }, model.OrderIds.ToArray());

ValidationIntegrationTests.cs (1)

2000Assert.Equal(input.OrderFile, model.OrderFile);

ValidationWithRecordIntegrationTests.cs (1)

1795Assert.Equal(input.OrderFile, model.OrderFile);

BsonTempDataSerializerTest.cs (1)

108Assert.Equal(value, roundTripValue);

JsonResultTest.cs (1)

35Assert.Equal(expected, written);

src\Mvc\Mvc.Core\test\Formatters\JsonInputFormatterTestBase.cs (1)

272Assert.Equal(new int[] { 0, 23, 300 }, integers);

src\Mvc\Mvc.Core\test\Infrastructure\JsonResultExecutorTestBase.cs (10)

38Assert.Equal(expected, written); 59Assert.Equal(expected, written); 83Assert.Equal(expected, written); 103Assert.Equal(expected, written); 127Assert.Equal(expected, written); 149Assert.Equal(expected, written); 174Assert.Equal(expected, written); 198Assert.Equal(expected, written); 324Assert.Equal(expected, written); 360Assert.Equal(expected, written);

src\Mvc\Mvc.ViewFeatures\test\Infrastructure\TempDataSerializerTestBase.cs (1)

258Assert.Equal(value, roundTripValue);

Buffers\PagedBufferedTextWriterTest.cs (7)

39Assert.Equal<char>(Content, inner.ToString().ToCharArray()); 96Assert.Equal<char>(Content, inner.ToString().ToCharArray()); 136Assert.Equal<char>(Content, inner.ToString().ToCharArray()); 182Assert.Equal<char>(Content, inner.ToString().ToCharArray()); 280Assert.Equal<char>(Content, inner.ToString().ToCharArray()); 300Assert.Equal<char>(Content, inner.ToString().ToCharArray()); 320Assert.Equal<char>(Content, inner.ToString().ToCharArray());

Buffers\PagedCharBufferTest.cs (2)

40page => Assert.Equal(stringToAppend.ToCharArray(), page), 103page => Assert.Equal(stringToAppend.ToCharArray(), page),

CookieTempDataProviderTest.cs (5)

110Assert.Equal(expectedDataToUnprotect, dataProtector.DataToUnprotect); 137Assert.Equal(expectedDataToProtect, dataProtector.PlainTextToProtect); 173Assert.Equal(expectedDataToProtect, dataProtector.PlainTextToProtect); 208Assert.Equal(expectedDataToProtect, dataProtector.PlainTextToProtect); 257Assert.Equal(expectedDataToProtect, dataProtector.PlainTextToProtect);

Infrastructure\TempDataSerializerTestBase.cs (1)

258Assert.Equal(value, roundTripValue);

CachedResponseBodyTests.cs (1)

89Assert.Equal(new byte[] { 1, 2, 3 }, receivedSegments.SelectMany(x => x).ToArray());

MemoryOutputCacheStoreTests.cs (1)

22Assert.Equal(value, result);

RequestDecompressionMiddlewareTests.cs (12)

CachedResponseBodyTests.cs (1)

94Assert.Equal(new byte[] { 1, 2, 3 }, receivedSegments.SelectMany(x => x).ToArray());

ResponseCompressionBodyTest.cs (4)

42Assert.Equal(buffer, memoryStream.ToArray()); 58Assert.Equal(buffer, memoryStream.ToArray()); 73Assert.Equal(File.ReadAllBytes(path), memoryStream.ToArray()); 90Assert.Equal(buffer, memoryStream.ToArray());

Listener\ResponseBodyTests.cs (4)

48Assert.Equal(new byte[10], await response.Content.ReadAsByteArrayAsync()); 97Assert.Equal(new byte[0], await response.Content.ReadAsByteArrayAsync()); 118Assert.Equal(new byte[20], await response.Content.ReadAsByteArrayAsync()); 140Assert.Equal(new byte[20], await response.Content.ReadAsByteArrayAsync());

ResponseBodyTests.cs (7)

125Assert.Equal(new byte[20], await response.Content.ReadAsByteArrayAsync()); 182Assert.Equal(new byte[20], await response.Content.ReadAsByteArrayAsync()); 229Assert.Equal(new byte[30], await response.Content.ReadAsByteArrayAsync()); 309Assert.Equal(new byte[10], await response.Content.ReadAsByteArrayAsync()); 340Assert.Equal(new byte[10], await response.Content.ReadAsByteArrayAsync()); 368Assert.Equal(new byte[10], await response.Content.ReadAsByteArrayAsync()); 395Assert.Equal(new byte[10], await response.Content.ReadAsByteArrayAsync());

ResponseCachingTests.cs (1)

478Assert.Equal(new byte[10], await response.Content.ReadAsByteArrayAsync());

BitShifterTests.cs (3)

21Assert.Equal(new byte[] { 0x80, 0x00, 0x00, 0x01 }, dirtySpan.ToArray()); 33Assert.Equal(new byte[] { 0x80, 0x00, 0x00, 0x01 }, dirtySpan.ToArray()); 45Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x01 }, dirtySpan.ToArray());

BufferWriterTests.cs (10)

67Assert.Equal(array, Read()); 87Assert.Equal(array.Skip(offset).Take(length).ToArray(), Read()); 102Assert.Equal(array, Read()); 114Assert.Equal(new byte[] { 1, 2, 3 }, Read()); 128Assert.Equal(new byte[] { 1, 2, 3 }, Read()); 144Assert.Equal(expectedBytes, Read()); 154Assert.Equal(new byte[] { }, Read()); 163Assert.Equal(new byte[] { }, Read()); 179Assert.Equal(new byte[] { 1, 2, 3 }, Read()); 226Assert.Equal(data, Read());

ChunkWriterTests.cs (1)

44Assert.Equal(Encoding.ASCII.GetBytes(expected), span.Slice(0, count).ToArray());

Http2\Http2FrameWriterTests.cs (3)

47Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x01 }, payload.Skip(Http2FrameReader.HeaderLength).Take(4).ToArray()); 69Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x01 }, payload.Skip(Http2FrameReader.HeaderLength).Take(4).ToArray()); 87Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00 }, payload.Skip(5).Take(4).ToArray());

Http2\Http2HPackEncoderTests.cs (5)

489Assert.Equal(expectedPayload, new ArraySegment<byte>(payload, 0, length).ToArray()); 544Assert.Equal(expectedStatusCodePayload, payload.Slice(0, length).ToArray()); 551Assert.Equal(expectedDateHeaderPayload, payload.Slice(offset, length).ToArray()); 558Assert.Equal(expectedContentTypeHeaderPayload, payload.Slice(offset, length).ToArray()); 565Assert.Equal(expectedServerHeaderPayload, payload.Slice(offset, length).ToArray());

Http3\Http3FrameWriterTests.cs (3)

49Assert.Equal(new byte[] { 0x04, 0x00 }, payload.ToArray()); 68Assert.Equal(new byte[] { 0x04, 0x05, 0x06, 0x80, 0x00 }, payload.ToArray()); 86Assert.Equal(new byte[] { 0x04, 0x08, 0x01, 0x44, 0xD2, 0x06, 0x80, 0x08, 0xAA, 0x52 }, payload.ToArray());

src\Shared\test\Shared.Tests\runtime\Http2\DynamicTableTest.cs (2)

265Assert.Equal(entries[i].Name, headerField.Name); 268Assert.Equal(entries[i].Value, headerField.Value);

src\Shared\test\Shared.Tests\runtime\Http2\HuffmanDecodingTests.cs (2)

251Assert.Equal(expected, dst); 347Assert.Equal(new byte[] { (byte)'B', (byte)'\n' }, decodedBytes);

src\Shared\test\Shared.Tests\runtime\Http3\VariableLengthIntegerHelperTests.cs (3)

288Assert.Equal(expected, span.ToArray()); 316Assert.Equal(expected, span.ToArray()); 344Assert.Equal(expected, span.ToArray());

QuicConnectionContextTests.cs (4)

110Assert.Equal(TestData, read.Buffer.ToArray()); 175Assert.Equal(TestData, read.Buffer.ToArray()); 218Assert.Equal(TestData, read.Buffer.ToArray()); 224Assert.Equal(TestData, data);

QuicStreamContextTests.cs (5)

209Assert.Equal(testData, data); 394Assert.Equal(TestData, completeReadResult.Buffer.ToArray()); 420Assert.Equal(TestData, data); 461Assert.Equal(TestData, data); 519Assert.Equal(TestData, data);

runtime\Http2\DynamicTableTest.cs (2)

265Assert.Equal(entries[i].Name, headerField.Name); 268Assert.Equal(entries[i].Value, headerField.Value);

runtime\Http2\HuffmanDecodingTests.cs (2)

251Assert.Equal(expected, dst); 347Assert.Equal(new byte[] { (byte)'B', (byte)'\n' }, decodedBytes);

runtime\Http3\VariableLengthIntegerHelperTests.cs (3)

288Assert.Equal(expected, span.ToArray()); 316Assert.Equal(expected, span.ToArray()); 344Assert.Equal(expected, span.ToArray());

HubConnectionTests.cs (1)

772Assert.Equal(new[] { 0, 1, 2, 3, 4 }, results.ToArray());

HttpConnectionTests.Transport.cs (1)

248Assert.Equal(data, await sendTcs.Task.DefaultTimeout());

LongPollingTransportTests.cs (3)

145Assert.Equal(Encoding.UTF8.GetBytes("HelloWorld"), data); 445Assert.Equal(message1Payload, message); 511Assert.Equal(new[] { (byte)'H', (byte)'e', (byte)'l', (byte)'l', (byte)'o', (byte)'W', (byte)'o', (byte)'r', (byte)'l', (byte)'d'

Internal\Formatters\BinaryMessageFormatterTests.cs (4)

44Assert.Equal(expectedEncoding, writer.ToArray()); 88Assert.Equal(encoded, writer.ToArray()); 110Assert.Equal(encoded, writer.ToArray()); 129Assert.Equal(payload, roundtripped.ToArray());

Internal\Formatters\BinaryMessageParserTests.cs (4)

25Assert.Equal(Encoding.UTF8.GetBytes(payload), message.ToArray()); 59Assert.Equal(payload, message.ToArray()); 108Assert.Equal(new byte[0], messages[0]); 109Assert.Equal(Encoding.UTF8.GetBytes("Hello,\r\nWorld!"), messages[1]);

Internal\Protocol\MemoryBufferWriterTests.cs (13)

173Assert.Equal(input, data); 191Assert.Equal(input, data); 207Assert.Equal(input, data); 224Assert.Equal(input, data); 242Assert.Equal(input, data); 261Assert.Equal(input, data); 280Assert.Equal(input, data); 302Assert.Equal(input, data); 307Assert.Equal(input, data); 327Assert.Equal(input, data); 349Assert.Equal(input, data); 354Assert.Equal(input, data); 422Assert.Equal(expectedOutput, bufferWriter.ToArray());

Internal\Protocol\MessagePackHubProtocolTestBase.cs (1)

481Assert.Equal(expectedOutput, message.ToArray());

Internal\Protocol\Utf8BufferTextWriterTests.cs (10)

RedisProtocolTests.cs (7)

54Assert.Equal(testData.Encoded, encoded); 90Assert.Equal(testData.Encoded, encoded); 157Assert.Equal( 184Assert.Equal(testData.Encoded, encoded); 200Assert.Equal(testData.Encoded, encoded); 259Assert.Equal(testData.Decoded.CompletionMessage.ToArray(), completionMessage.CompletionMessage.ToArray()); 274Assert.Equal(testData.Encoded, encoded);

EndToEndTests.cs (3)

111Assert.Equal(bytes, buffer.Array.AsSpan(0, result.Count).ToArray()); 150Assert.Equal(bytes, buffer.Array.AsSpan(0, result.Count).ToArray()); 196Assert.Equal(message, receivedData);

HubConnectionHandlerTests.cs (1)

1431Assert.Equal(new[] { 1, 2, 3 }, values);

SerializedHubMessageTests.cs (3)

24Assert.Equal(DummyHubProtocol.DummySerialization, serialized.ToArray()); 42Assert.Equal(DummyHubProtocol.DummySerialization, serialized.ToArray()); 88Assert.Equal(DummyHubProtocol.DummySerialization, serializedMessage.Serialized.ToArray());

WebSocketsTransportTests.cs (1)

187Assert.Equal(new byte[] { 0x42 }, result.Buffer.ToArray());

ResponseBodyTests.cs (2)

81Assert.Equal(contentBytes, responseBytes); 120Assert.Equal(contentBytes, responseBytes);

SendReceiveTests.cs (2)

57Assert.Equal(sendBuffer, receiveBuffer.Take(result.Count).ToArray()); 72Assert.Equal(sendBuffer, receiveBuffer.Take(result.Count).ToArray());

WebSocketMiddlewareTests.cs (8)

100Assert.Equal(originalData, serverBuffer); 125Assert.Equal(originalData, serverBuffer); 151Assert.Equal(originalData, serverBuffer); 200Assert.Equal(originalData, serverBuffer); 237Assert.Equal(originalData, clientBuffer); 262Assert.Equal(originalData, clientBuffer); 295Assert.Equal(originalData, clientBuffer); 338Assert.Equal(originalData, clientBuffer);

FileBufferingReadStreamTests.cs (14)

FileBufferingWriteStreamTests.cs (14)

34Assert.Equal(input, ReadBufferedContent(pagedByteBuffer)); 61Assert.Equal(input, ReadBufferedContent(pageBuffer)); 82Assert.Equal(input, fileBytes); 105Assert.Equal(input, fileBytes); 129Assert.Equal(new byte[] { 1, 2, 3, 4, 5, }, fileBytes); 131Assert.Equal(new byte[] { 6, 7 }, ReadBufferedContent(pageBuffer)); 147Assert.Equal(input, ReadBufferedContent(pagedByteBuffer)); 172Assert.Equal(input, ReadBufferedContent(pageBuffer)); 193Assert.Equal(input, fileBytes); 216Assert.Equal(input, fileBytes); 243Assert.Equal(new byte[] { 1, 2, 3, 4, 5, }, fileBytes); 244Assert.Equal(new byte[] { 6, 7 }, ReadBufferedContent(pageBuffer)); 348Assert.Equal(input, memoryStream.ToArray()); 365Assert.Equal(input, memoryStream.ToArray());

FormPipeReaderTests.cs (5)

114Assert.Equal(Encoding.UTF8.GetBytes(content), readResult.Buffer.ToArray()); 129Assert.Equal(Encoding.UTF8.GetBytes(content), readResult.Buffer.ToArray()); 157Assert.Equal(Encoding.UTF8.GetBytes(content), readResult.Buffer.ToArray()); 185Assert.Equal(Encoding.UTF8.GetBytes(content), readResult.Buffer.ToArray()); 210Assert.Equal(Encoding.UTF8.GetBytes("baz=12345678901"), readResult.Buffer.ToArray());

HttpResponseStreamWriterTest.cs (4)

30Assert.Equal(expectedData, memoryStream.ToArray()); 640Assert.Equal(expectedBytes, stream.ToArray()); 675Assert.Equal(expectedBytes, stream.ToArray()); 703Assert.Equal(expectedBytes, stream.ToArray());

PagedByteBufferTest.cs (12)

25Assert.Equal(input, ReadBufferedContent(buffer)); 43Assert.Equal(Enumerable.Concat(input1, input2).ToArray(), ReadBufferedContent(buffer)); 59Assert.Equal(new byte[] { 2, 3, 4 }, ReadBufferedContent(buffer)); 77Assert.Equal(Enumerable.Concat(input1, input2).ToArray(), ReadBufferedContent(buffer)); 93Assert.Equal(input.ToArray(), ReadBufferedContent(buffer)); 109Assert.Equal(input, stream.ToArray()); 118Assert.Equal(newInput, stream.ToArray()); 134Assert.Equal(input, stream.ToArray()); 142Assert.Equal(newInput, stream.ToArray()); 158Assert.Equal(input, stream.ToArray()); 185Assert.Equal(input, memoryStream.ToArray()); 210Assert.Equal(input, memoryStream.ToArray());

BuildEventArgsSerialization_Tests.cs (1)

51Assert.Equal(bytes, binaryReader.ReadBytes(bytes.Length));

TextFieldParserTests.cs (2)

110Assert.Equal(new[] { 1, 2, int.MaxValue }, parser.FieldWidths); 112Assert.Equal(new[] { int.MaxValue, 3 }, parser.FieldWidths);

CollectionAssertsTests.cs (2)

801 var ex = Record.Exception(() => Assert.Equal(expected, actual)); 869 var ex = Record.Exception(() => Assert.Equal(expected, actual));

EqualityAssertsTests.cs (1)

1018 assertFailure(() => Assert.Equal(expected, actual));

ChatCompletion\ChatResponseUpdateTests.cs (1)

152Assert.Equal("data"u8.ToArray(), ((DataContent)result.Contents[3]).Data.ToArray());

Contents\DataContentTests.cs (1)

249Assert.Equal(data, content.Data.ToArray());

Embeddings\EmbeddingTests.cs (6)

29Assert.Equal(floats, e.Vector.ToArray()); 48Assert.Equal(e.Vector.ToArray(), result.Vector.ToArray()); 61Assert.Equal(e.Vector.ToArray(), result.Vector.ToArray()); 75Assert.Equal(e.Vector.ToArray(), result.Vector.ToArray()); 89Assert.Equal(e.Vector.ToArray(), result.Vector.ToArray()); 102Assert.Equal(e.Vector.ToArray(), result.Vector.ToArray());

Embeddings\DistributedCachingEmbeddingGeneratorTest.cs (1)

406Assert.Equal(expected.Vector.ToArray(), actual.Vector.ToArray());

SerializerTests.cs (2)

36Assert.Equal(value, serializer.Deserialize(target.AsSequence())); 39Assert.Equal(value, serializer.Deserialize(Split(target.AsSequence())));

ResourceMonitoringServiceTests.cs (1)

585Assert.Equal(expectedCpuValues, cpuValuesWithNoHighSpikes);

TimerTests.cs (2)

284Assert.Equal(new[] { timeProvider.Start }, value1); 285Assert.Equal(new[]

Infrastructure\ByteArrayJsonConverterTest.cs (3)

79Assert.Equal(expected, deserialized); 108Assert.Equal(byteArray, deserialized); 191Assert.Equal(byteArray, deserialized);

Infrastructure\DotNetDispatcherTest.cs (2)

428Assert.Equal(new[] { 1, 2, 3 }, task.Result); 886Assert.Equal(byteArray, jsRuntime.ByteArraysToBeRevived.Buffer[0]);

JSRuntimeTest.cs (3)

332Assert.Equal(byteArray, runtime.ByteArraysToBeRevived.Buffer[0]); 359Assert.Equal(byteArrays[i], runtime.ByteArraysToBeRevived.Buffer[i]); 378Assert.Equal(byteArray, runtime.ByteArraysToBeRevived.Buffer[0]);

UnitTests\TestVBuffer.cs (2)

291Assert.Equal(expectedIndices, a.GetIndices().ToArray()); 317Assert.Equal(values, a.GetValues().ToArray());

Debugging.cs (1)

92Assert.Equal(expectedFeatures[i++], rowFeatures);

OnnxTransformTests.cs (2)

946Assert.Equal(transformedDataPoints[i].argmax, expectedResults[i]); 1110Assert.Equal(transformedDataPoints[i].argmax, expectedResults[i]);

TensorflowTests.cs (1)

1047Assert.Equal(buffer.DenseValues().ToArray(),

ImagesTests.cs (6)

1244Assert.Equal(image1.Pixels.ToArray(), image2.Pixels.ToArray()); 1258Assert.Equal(image1.Pixels.ToArray(), image3.Pixels.ToArray()); 1339Assert.Equal(image1.Pixels.ToArray(), image2.Pixels.ToArray()); 1346Assert.Equal(image1.Pixels.ToArray(), image2.Pixels.ToArray()); 1348Assert.Equal(image1.Pixels.ToArray(), image2.Pixels.ToArray()); 1373Assert.Equal(image1.Pixels.ToArray(), image2.Pixels.ToArray());

Scenarios\WordBagTest.cs (2)

41Assert.Equal(prediction.Text, new float[] { 47Assert.Equal(prediction.Text2, new float[] { 2, 2, 2, 2, 2, 2, 1, 1 });

TrainerEstimators\TreeEstimators.cs (4)

832Assert.Equal(row.CategoricalSplitFeatures, tree.GetCategoricalSplitFeaturesAt(nodeId).ToArray()); 836Assert.Equal(row.CategoricalCategoricalSplitFeatureRange, tree.GetCategoricalCategoricalSplitFeatureRangeAt(nodeId).ToArray()); 861Assert.Equal(row.LeafSamples, tree.GetLeafSamplesAt(nodeId).ToArray()); 865Assert.Equal(row.LeafSampleWeights, tree.GetLeafSampleWeightsAt(nodeId).ToArray());

Transformers\LineParserTests.cs (1)

39Assert.Equal(expectedValues, result.values);

Transformers\TextFeaturizerTests.cs (4)

129Assert.Equal(expected[0], transformed[0]); 130Assert.Equal(expected[1], transformed[1]); 171Assert.Equal(expected[0], transformed[0]); 172Assert.Equal(expected[1], transformed[1]);

Transformers\WordBagTransformerTests.cs (3)

48Assert.Equal(expected, ((VBuffer<float>)pred.ColumnView[4].Values[0]).DenseValues().ToArray()); 76Assert.Equal(expected, ((VBuffer<float>)pred.ColumnView[4].Values[0]).DenseValues().ToArray()); 116Assert.Equal(((VBuffer<float>)predDefault.ColumnView[4].Values[0]).DenseValues().ToArray(), ((VBuffer<float>)predNonDefault.ColumnView[4].Values[0]).DenseValues().ToArray());

TimeSeriesDirectApi.cs (4)

467Assert.Equal(new float[] { -1.02245092f, 0.08333033f, 2.6073704f, 5.397318f, 7.5008316f, -5.1881413f, -4.82533741f, 485Assert.Equal(new float[] { 4.310586f, 6.397167f, 7.73934f, 8.029469f, 0.14489543f, 512Assert.Equal(new float[] { 6.006588f, 7.506871f, 7.964249f, 7.1751432f, 523Assert.Equal(result.Forecast, resultCopy.Forecast);

BertTokenizerTests.cs (10)

387Assert.Equal(new int[] { bertTokenizer.ClassificationTokenId, bertTokenizer.ClassificationTokenId, 8, 6, 10, 11, 12, 7, bertTokenizer.SeparatorTokenId, bertTokenizer.SeparatorTokenId }, ids1Span.ToArray()); 402Assert.Equal( 425Assert.Equal( 442Assert.Equal( 487Assert.Equal(new int[] { 1, 0, 0, 0, 0, 0, 0, 1 }, ids1Span.ToArray()); 502Assert.Equal(new int[] { 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1 }, ids1Span.ToArray()); 522Assert.Equal(new int[] { 1, 0, 0, 0, 0, 0, 0, 1 }, ids1Span.ToArray()); 537Assert.Equal(new int[] { 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 }, ids1Span.ToArray()); 580Assert.Equal(new int[] { 0, 0, 0, 0, 0, 0, 0, 0 }, ids1Span.ToArray()); 595Assert.Equal(new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1 }, ids1Span.ToArray());

BpeTests.cs (6)

466Assert.Equal(expectedOffsets, encoding.Select(t => (t.Offset.Start.Value, t.Offset.End.Value - t.Offset.Start.Value)).ToArray()); 467Assert.Equal(expectedIds, encoding.Select(t => t.Id).ToArray()); 470Assert.Equal(expectedOffsets, encoding1.Select(t => (t.Offset.Start.Value, t.Offset.End.Value - t.Offset.Start.Value)).ToArray()); 471Assert.Equal(expectedIds, encoding1.Select(t => t.Id).ToArray()); 810Assert.Equal(ids, encoding.Select(t => t.Id).ToArray()); 812Assert.Equal(offsets, encoding.Select(t => (t.Offset.Start.Value, t.Offset.End.Value)).ToArray());

CodeGenTests.cs (16)

EnglishRobertaTests.cs (4)

185Assert.Equal(expectedOffsets, encoding.Select(t => (t.Offset.Start.Value, t.Offset.End.Value - t.Offset.Start.Value)).ToArray()); 186Assert.Equal(expectedIds, encoding.Select(t => t.Id).ToArray()); 189Assert.Equal(expectedOffsets, encoding1.Select(t => (t.Offset.Start.Value, t.Offset.End.Value - t.Offset.Start.Value)).ToArray()); 190Assert.Equal(expectedIds, encoding1.Select(t => t.Id).ToArray());

LlamaTests.cs (9)

245Assert.Equal(ids, result.Select(t => t.Id).ToArray()); 247Assert.Equal(offsets, result.Select(t => (t.Offset.Start.Value, t.Offset.End.Value - t.Offset.Start.Value)).ToArray()); 504Assert.Equal(expectedOffsets, encoding.Select(t => (t.Offset.Start.Value, t.Offset.End.Value - t.Offset.Start.Value)).ToArray()); 505Assert.Equal(expectedIds, encoding.Select(t => t.Id).ToArray()); 508Assert.Equal(expectedOffsets, encoding1.Select(t => (t.Offset.Start.Value, t.Offset.End.Value - t.Offset.Start.Value)).ToArray()); 509Assert.Equal(expectedIds, encoding1.Select(t => t.Id).ToArray()); 542Assert.Equal(expectedOffsets1, encoding.Select(t => (t.Offset.Start.Value, t.Offset.End.Value - t.Offset.Start.Value)).ToArray()); 543Assert.Equal(expectedIds1, encoding.Select(t => t.Id).ToArray()); 666Assert.Equal(new[] { tokenizer.BeginningOfSentenceId, kvp.Value }, encodedTokens.Select(et => et.Id).ToArray());

PreTokenizerTests.cs (1)

61Assert.Equal(splits, splitParts);

TiktokenTests.cs (6)

591Assert.Equal(expectedOffsets, encoding.Select(t => (t.Offset.Start.Value, t.Offset.End.Value - t.Offset.Start.Value)).ToArray()); 592Assert.Equal(expectedIds, encoding.Select(t => t.Id).ToArray()); 595Assert.Equal(expectedOffsets, encoding1.Select(t => (t.Offset.Start.Value, t.Offset.End.Value - t.Offset.Start.Value)).ToArray()); 596Assert.Equal(expectedIds, encoding1.Select(t => t.Id).ToArray()); 706Assert.Equal(expectedIds, ids); 707Assert.Equal(expectedOffsets, offsets);

src\Servers\Kestrel\test\FunctionalTests\UnixDomainSocketsTests.cs (1)

116Assert.Equal(data, buffer);

IdentityModel\SymmetricSecurityKeyTest.cs (1)

19Assert.Equal(gsk, mgsakey.GetSymmetricKey());

Security\securityKeyTest.cs (1)

26Assert.Equal(keyData, msk.EncryptKey(algorithm, keyData));