496 references to Equal
Contract.XmlSerializer.IntegrationTests (6)
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));
dotnet-svcutil.xmlserializer.IntegrationTests (6)
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));
IIS.FunctionalTests (2)
src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (2)
133Assert.Equal( 151Assert.Equal(
IISExpress.FunctionalTests (2)
src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (2)
133Assert.Equal( 151Assert.Equal(
InMemory.FunctionalTests (9)
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());
Interop.FunctionalTests (2)
Http2\Http2RequestTests.cs (1)
283Assert.Equal(randomBytes, readData);
Http3\Http3RequestTests.cs (1)
2168Assert.Equal(TestData, data);
Microsoft.AspNetCore.Antiforgery.Test (1)
BinaryBlobTest.cs (1)
53Assert.Equal(expectedData, blob.GetData());
Microsoft.AspNetCore.Components.Server.Tests (5)
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());
Microsoft.AspNetCore.Components.Tests (7)
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()));
Microsoft.AspNetCore.Components.WebAssembly.Tests (2)
PullFromJSDataStreamTest.cs (2)
46Assert.Equal(expectedChunks[i], buffer); 60Assert.Equal(Data, mem.ToArray());
Microsoft.AspNetCore.DataProtection.Tests (28)
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);
Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests (4)
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());
Microsoft.AspNetCore.Http.Abstractions.Tests (2)
HttpResponseWritingExtensionsTests.cs (2)
47Assert.Equal(expected, actual); 68Assert.Equal(expected, actualShortened);
Microsoft.AspNetCore.Http.Connections.Tests (9)
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());
Microsoft.AspNetCore.Http.Extensions.Tests (14)
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!);
Microsoft.AspNetCore.Http.Results.Tests (10)
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());
Microsoft.AspNetCore.Identity.Test (3)
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)));
Microsoft.AspNetCore.Mvc.Core.Test (24)
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());
Microsoft.AspNetCore.Mvc.Formatters.Xml.Test (2)
XmlDataContractSerializerInputFormatterTest.cs (1)
557Assert.Equal(expectedBytes, Encoding.UTF8.GetBytes(model.SampleString));
XmlSerializerInputFormatterTest.cs (1)
577Assert.Equal(expectedBytes, Encoding.UTF8.GetBytes(model.SampleString));
Microsoft.AspNetCore.Mvc.IntegrationTests (17)
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);
Microsoft.AspNetCore.Mvc.NewtonsoftJson.Test (14)
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);
Microsoft.AspNetCore.Mvc.ViewFeatures.Test (15)
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);
Microsoft.AspNetCore.OutputCaching.Tests (2)
CachedResponseBodyTests.cs (1)
89Assert.Equal(new byte[] { 1, 2, 3 }, receivedSegments.SelectMany(x => x).ToArray());
MemoryOutputCacheStoreTests.cs (1)
22Assert.Equal(value, result);
Microsoft.AspNetCore.RequestDecompression.Tests (12)
RequestDecompressionMiddlewareTests.cs (12)
91Assert.Equal(uncompressedBytes, decompressedBytes); 107Assert.Equal(uncompressedBytes, decompressedBytes); 139Assert.Equal(uncompressedBytes, decompressedBytes); 154Assert.Equal(uncompressedBytes, outputBytes); 170Assert.Equal(compressedBytes, outputBytes); 187Assert.Equal(inputBytes, outputBytes); 253Assert.Equal(uncompressedBytes, decompressedBytes); 325Assert.Equal(uncompressedBytes, outputBytes); 332Assert.Equal(compressedBytes, outputBytes); 422Assert.Equal(uncompressedBytes, decompressedBytes); 508Assert.Equal(uncompressedBytes, decompressedBytes); 592Assert.Equal(uncompressedBytes, decompressedBytes);
Microsoft.AspNetCore.ResponseCaching.Tests (1)
CachedResponseBodyTests.cs (1)
94Assert.Equal(new byte[] { 1, 2, 3 }, receivedSegments.SelectMany(x => x).ToArray());
Microsoft.AspNetCore.ResponseCompression.Tests (4)
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());
Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (12)
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());
Microsoft.AspNetCore.Server.Kestrel.Core.Tests (32)
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());
Microsoft.AspNetCore.Server.Kestrel.Transport.Quic.Tests (9)
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);
Microsoft.AspNetCore.Shared.Tests (7)
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());
Microsoft.AspNetCore.SignalR.Client.FunctionalTests (1)
HubConnectionTests.cs (1)
772Assert.Equal(new[] { 0, 1, 2, 3, 4 }, results.ToArray());
Microsoft.AspNetCore.SignalR.Client.Tests (4)
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'
Microsoft.AspNetCore.SignalR.Common.Tests (32)
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)
146Assert.Equal(expectedData, actualData); 175Assert.Equal(expectedData, actualData); 283seg => Assert.Equal(new byte[] { 0x61, 0xE3, 0x81, 0x84, 0x62 }, seg), // "aいb" 284seg => Assert.Equal(new byte[] { 0xE3, 0x82, 0x8D, 0x63, 0x64 }, seg), // "ろcd" 285seg => Assert.Equal(new byte[] { 0xE3, 0x81, 0xAF }, seg), // "は" 286seg => Assert.Equal(new byte[] { 0xE3, 0x81, 0xAB, 0x65 }, seg), // "にe" 287seg => Assert.Equal(new byte[] { 0xE3, 0x81, 0xBB, 0x66 }, seg), // "ほf" 288seg => Assert.Equal(new byte[] { 0xE3, 0x81, 0xB8 }, seg), // "へ" 289seg => Assert.Equal(new byte[] { 0xE3, 0x81, 0xA9, 0x67, 0x68 }, seg), // "どgh" 290seg => Assert.Equal(new byte[] { 0x69, 0xF0, 0x90, 0x80, 0x80 }, seg)); // "i\uD800\uDC00"
Microsoft.AspNetCore.SignalR.StackExchangeRedis.Tests (7)
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);
Microsoft.AspNetCore.SignalR.Tests (8)
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());
Microsoft.AspNetCore.TestHost.Tests (2)
ResponseBodyTests.cs (2)
81Assert.Equal(contentBytes, responseBytes); 120Assert.Equal(contentBytes, responseBytes);
Microsoft.AspNetCore.WebSockets.Tests (10)
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);
Microsoft.AspNetCore.WebUtilities.Tests (49)
FileBufferingReadStreamTests.cs (14)
479Assert.Equal(data, withoutBufferMs.ToArray()); 481Assert.Equal(data, withBufferMs.ToArray()); 503Assert.Equal(data, withoutBufferMs.ToArray()); 505Assert.Equal(data, withBufferMs.ToArray()); 522Assert.Equal(data.AsMemory(0, 100).ToArray(), buffer); 523Assert.Equal(data.AsMemory(100).ToArray(), withoutBufferMs.ToArray()); 540Assert.Equal(data.AsMemory(0, read).ToArray(), buffer); 541Assert.Equal(data.AsMemory(read).ToArray(), withoutBufferMs.ToArray()); 559Assert.Equal(data.AsMemory(0, read).ToArray(), buffer); 560Assert.Equal(data.ToArray(), withoutBufferMs.ToArray()); 579Assert.Equal(data.AsMemory(0, read1).ToArray(), buffer); 580Assert.Equal(data.AsMemory(0, read2).ToArray(), buffer2.AsMemory(0, read2).ToArray()); 599Assert.Equal(data.AsMemory(0, read1).ToArray(), buffer); 600Assert.Equal(data.AsMemory(0, read2).ToArray(), buffer2.AsMemory(0, read2).ToArray());
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());
Microsoft.Build.Engine.UnitTests (1)
BuildEventArgsSerialization_Tests.cs (1)
51Assert.Equal(bytes, binaryReader.ReadBytes(bytes.Length));
Microsoft.CodeAnalysis.Rebuild.UnitTests (2)
RoundTripUtil.cs (2)
59Assert.Equal(peStream.ToArray(), rebuildPeStream.ToArray()); 60Assert.Equal(pdbStream?.ToArray(), rebuildPdbStream?.ToArray());
Microsoft.Data.Analysis.Tests (2)
TextFieldParserTests.cs (2)
110Assert.Equal(new[] { 1, 2, int.MaxValue }, parser.FieldWidths); 112Assert.Equal(new[] { int.MaxValue, 3 }, parser.FieldWidths);
Microsoft.DotNet.XUnitAssert.Tests (3)
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));
Microsoft.Extensions.AI.Abstractions.Tests (8)
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());
Microsoft.Extensions.AI.Tests (1)
Embeddings\DistributedCachingEmbeddingGeneratorTest.cs (1)
345Assert.Equal(expected.Vector.ToArray(), actual.Vector.ToArray());
Microsoft.Extensions.Caching.Hybrid.Tests (2)
SerializerTests.cs (2)
36Assert.Equal(value, serializer.Deserialize(target.AsSequence())); 39Assert.Equal(value, serializer.Deserialize(Split(target.AsSequence())));
Microsoft.Extensions.Caching.SqlServer.Tests (6)
SqlServerCacheWithDatabaseTest.cs (6)
109Assert.Equal(expectedValue, cacheItem.Value); 149Assert.Equal(expectedValue, cacheItem.Value); 190Assert.Equal(expectedValue, cacheItem.Value); 589Assert.Equal(expectedValue, value); 664Assert.Equal(expectedValue, value); 719Assert.Equal(expectedValue, value);
Microsoft.Extensions.TimeProvider.Testing.Tests (2)
TimerTests.cs (2)
284Assert.Equal(new[] { timeProvider.Start }, value1); 285Assert.Equal(new[]
Microsoft.JSInterop.Tests (8)
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]);
Microsoft.ML.Core.Tests (2)
UnitTests\TestVBuffer.cs (2)
291Assert.Equal(expectedIndices, a.GetIndices().ToArray()); 317Assert.Equal(values, a.GetValues().ToArray());
Microsoft.ML.IntegrationTests (1)
Debugging.cs (1)
92Assert.Equal(expectedFeatures[i++], rowFeatures);
Microsoft.ML.OnnxTransformerTest (2)
OnnxTransformTests.cs (2)
946Assert.Equal(transformedDataPoints[i].argmax, expectedResults[i]); 1110Assert.Equal(transformedDataPoints[i].argmax, expectedResults[i]);
Microsoft.ML.TensorFlow.Tests (1)
TensorflowTests.cs (1)
1047Assert.Equal(buffer.DenseValues().ToArray(),
Microsoft.ML.Tests (20)
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());
Microsoft.ML.TimeSeries.Tests (4)
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);
Microsoft.ML.Tokenizers.Tests (52)
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)
236Assert.Equal(expectedIdsWithSpace, encoding.Select(t => t.Id).ToArray()); 238Assert.Equal(expectedOffsetsWithSpace, encoding.Select(t => (t.Offset.Start.Value, t.Offset.End.Value - t.Offset.Start.Value)).ToArray()); 242Assert.Equal(expectedIds, encoding.Select(t => t.Id).ToArray()); 244Assert.Equal(expectedOffsets, encoding.Select(t => (t.Offset.Start.Value, t.Offset.End.Value - t.Offset.Start.Value)).ToArray()); 590Assert.Equal(expectedIds, encoding.Select(t => t.Id).ToArray()); 595Assert.Equal(expectedIds, encoding.Select(t => t.Id).ToArray()); 600Assert.Equal(expectedIdsWithSpace, encoding.Select(t => t.Id).ToArray()); 605Assert.Equal(expectedIdsWithSpace, encoding.Select(t => t.Id).ToArray()); 723Assert.Equal(expectedIds, encoding.Select(t => t.Id).ToArray()); 728Assert.Equal(expectedIds, encoding.Select(t => t.Id).ToArray()); 733Assert.Equal(expectedIdsWithSpace, encoding.Select(t => t.Id).ToArray()); 738Assert.Equal(expectedIdsWithSpace, encoding.Select(t => t.Id).ToArray()); 866Assert.Equal(expectedIds, encoding.Select(t => t.Id).ToArray()); 872Assert.Equal(expectedIds, encoding.Select(t => t.Id).ToArray()); 878Assert.Equal(expectedIdsWithSpace, encoding.Select(t => t.Id).ToArray()); 884Assert.Equal(expectedIdsWithSpace, encoding.Select(t => t.Id).ToArray());
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);
Sockets.FunctionalTests (1)
src\Servers\Kestrel\test\FunctionalTests\UnixDomainSocketsTests.cs (1)
116Assert.Equal(data, buffer);
System.ServiceModel.Primitives.Tests (2)
IdentityModel\SymmetricSecurityKeyTest.cs (1)
19Assert.Equal(gsk, mgsakey.GetSymmetricKey());
Security\securityKeyTest.cs (1)
26Assert.Equal(keyData, msk.EncryptKey(algorithm, keyData));