Equal

ClaimsTransformTests.cs (2)

29Assert.Equal(HttpStatusCode.OK, response.StatusCode); 40Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);

CookiesTests.cs (6)

28Assert.Equal(HttpStatusCode.OK, response.StatusCode); 39Assert.Equal(HttpStatusCode.OK, response.StatusCode); 60Assert.Equal(HttpStatusCode.OK, response.StatusCode); 66Assert.Equal(HttpStatusCode.OK, response.StatusCode); 74Assert.Equal(HttpStatusCode.OK, response.StatusCode); 91Assert.Equal(HttpStatusCode.OK, signIn.StatusCode);

CustomAuthorizationFailureResponseTests.cs (2)

27Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); 37Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);

CustomPolicyProviderTests.cs (11)

DynamicSchemeTests.cs (6)

30Assert.Equal(HttpStatusCode.OK, response.StatusCode); 39Assert.Equal(HttpStatusCode.OK, response.StatusCode); 45Assert.Equal(HttpStatusCode.OK, response.StatusCode); 53Assert.Equal(HttpStatusCode.OK, response.StatusCode); 63Assert.Equal(HttpStatusCode.OK, response.StatusCode); 72Assert.Equal(HttpStatusCode.OK, response.StatusCode);

IdentityExternalClaimsTests.cs (2)

29Assert.Equal(HttpStatusCode.OK, response.StatusCode); 40Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);

PathSchemeSelectionTests.cs (8)

30Assert.Equal(HttpStatusCode.OK, response.StatusCode); 41Assert.Equal(HttpStatusCode.OK, response.StatusCode); 52Assert.Equal(HttpStatusCode.OK, response.StatusCode); 64Assert.Equal(HttpStatusCode.OK, response.StatusCode); 86Assert.Equal(HttpStatusCode.OK, response.StatusCode); 92Assert.Equal(HttpStatusCode.OK, response.StatusCode); 100Assert.Equal(HttpStatusCode.OK, response.StatusCode); 117Assert.Equal(HttpStatusCode.OK, signIn.StatusCode);

StaticFilesAuthTests.cs (2)

27Assert.Equal(HttpStatusCode.OK, response.StatusCode); 38Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);

TestAssert.cs (3)

69Assert.Equal(HttpStatusCode.Redirect, responseMessage.StatusCode); 75Assert.Equal(HttpStatusCode.OK, response.StatusCode); 107=> Assert.Equal(HttpStatusCode.OK, download.StatusCode);

BasicHttpBindingTests.4.0.0.cs (1)

353Assert.Equal(result, decompressionEnabled);

NetHttpBindingTests.cs (10)

160Assert.Equal(1, result1); 161Assert.Equal(2, result2); 163Assert.Equal(3, callCount); 234Assert.Equal(2, httpRequestCount); 241Assert.Equal(4, httpRequestCount); 245Assert.Equal(CommunicationState.Faulted, ((ICommunicationObject)serviceProxy).State); 330Assert.Equal(1, result1); 331Assert.Equal(2, result2); 385Assert.Equal(1, result1); 386Assert.Equal(1, httpRequestCountAfterInactivity); // Captured before releasing the first request

WSHttpBindingTests.cs (10)

160Assert.Equal(1, result1); 161Assert.Equal(2, result2); 163Assert.Equal(3, callCount); 234Assert.Equal(2, httpRequestCount); 241Assert.Equal(4, httpRequestCount); 245Assert.Equal(CommunicationState.Faulted, ((ICommunicationObject)serviceProxy).State); 330Assert.Equal(1, result1); 331Assert.Equal(2, result2); 385Assert.Equal(1, result1); 386Assert.Equal(1, httpRequestCountAfterInactivity); // Captured before releasing the first request

OperationContextAsyncFlowTests.cs (5)

38Assert.Equal(currentContext, OperationContext.Current); 73Assert.Equal(firstContext, OperationContext.Current); 81Assert.Equal(secondContext, OperationContext.Current); 83Assert.Equal(firstContext, OperationContext.Current); 164Assert.Equal(opContext, OperationContext.Current);

DuplexChannelShapeTests.4.0.0.cs (2)

156Assert.Equal(1, imp.Counter); 185Assert.Equal(2, imp.Counter);

DuplexChannelWithSynchronizationContext.cs (3)

61Assert.Equal(guid, returnedGuid); 125Assert.Equal(guid, returnedGuid); 196Assert.Equal(guid, returnedGuid);

ClientBaseTests.4.0.0.cs (5)

167Assert.Equal(CommunicationState.Created, client.State); 171Assert.Equal(CommunicationState.Opened, client.State); 176Assert.Equal(CommunicationState.Opened, client.State); 182Assert.Equal(CommunicationState.Closed, client.State); 191Assert.Equal(CommunicationState.Closed, client.State);

SessionTests.cs (19)

35Assert.Equal(A, dataC.MethodAValue); 36Assert.Equal(B, dataC.MethodBValue); 74Assert.Equal(A1, dataC1.MethodAValue); 75Assert.Equal(B1, dataC1.MethodBValue); 76Assert.Equal(A2, dataC2.MethodAValue); 77Assert.Equal(B2, dataC2.MethodBValue); 83Assert.Equal(0, dataA1 | dataB1 | dataA2 | dataB2); 251Assert.Equal(s_channel.GetHashCode(), c.GetHashCode()); 252Assert.Equal(s_channel.GetHashCode(), channel.GetHashCode()); 309Assert.Equal(3, result); 331Assert.Equal(7, result); 351Assert.Equal(3, result); 379Assert.Equal(3, result); 403Assert.Equal(2, result); 426Assert.Equal(4, result); 542Assert.Equal(1, result2); 558Assert.Equal(cbClosedCalled, s_duplexCallback.ClosedCalled); 559Assert.Equal(cbClosingCalled, s_duplexCallback.ClosingCalled); 560Assert.Equal(cbFaultedCalled, s_duplexCallback.FaultedCalled);

TypedProxyDuplexTests.4.1.0.cs (2)

43Assert.Equal(guid, returnedGuid); 78Assert.Equal(guid, returnedGuid);

FaultExceptionTests.4.0.0.cs (1)

107Assert.Equal(expectedFaultCode, thrownException.Detail);

MessageTests.4.0.0.cs (2)

43Assert.Equal(MessageState.Created, replyMessage.State); 44Assert.Equal(MessageVersion.Soap11, replyMessage.Version);

XmlSerializerFormatSoapTest.cs (2)

42Assert.Equal(value.BoolValue, response.BoolValue); 76Assert.Equal(intValue, response.@Return);

XmlSerializerFormatTest.4.0.0.cs (1)

174Assert.Equal(complex.Id, response.Id);

XmlSerializerFormatTest.cs (31)

DatabaseErrorPageMiddlewareTest.cs (8)

45Assert.Equal(HttpStatusCode.OK, response.StatusCode); 140Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 201Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 240Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 285Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 302Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); 363Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 486Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);

MigrationsEndPointMiddlewareTest.cs (6)

43Assert.Equal(HttpStatusCode.OK, response.StatusCode); 128Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); 134Assert.Equal(2, appliedMigrations.Count); 164Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 196Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 225Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);

DatabaseErrorPageSampleTest.cs (1)

32Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);

DeveloperExceptionPageSampleTest.cs (3)

33Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 49Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 51Assert.Equal(500, body.Status);

ExceptionHandlerSampleTest.cs (1)

29Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);

MiddlewareAnalysisSampleTest.cs (1)

29Assert.Equal(HttpStatusCode.OK, response.StatusCode);

ProblemDetailsExceptionHandlerSampleTest.cs (2)

33Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 35Assert.Equal(500, body.Status);

StatusCodeSampleTest.cs (7)

34Assert.Equal(HttpStatusCode.OK, response.StatusCode); 51Assert.Equal((HttpStatusCode)httpStatusCode, response.StatusCode); 71Assert.Equal((HttpStatusCode)httpStatusCode, response.StatusCode); 89Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 91Assert.Equal(400, body.Status); 106Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 108Assert.Equal(400, body.Status);

WelcomePageSampleTest.cs (1)

30Assert.Equal(HttpStatusCode.OK, response.StatusCode);

src\System.Private.ServiceModel\tests\Scenarios\Contract\XmlSerializer\XmlSerializerFormatSoapTest.cs (2)

42Assert.Equal(value.BoolValue, response.BoolValue); 76Assert.Equal(intValue, response.@Return);

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

174Assert.Equal(complex.Id, response.Id);

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

Http2TrailersResetTests.cs (10)

Http3Tests.cs (10)

53Assert.Equal(HttpVersion.Version30, response.Version); 77Assert.Equal(HttpVersion.Version30, response3.Version); 125Assert.Equal(QuicError.StreamAborted, qex.QuicError); 126Assert.Equal(0x010b, qex.ApplicationErrorCode.Value); 141Assert.Equal(QuicError.StreamAborted, qex.QuicError); 142Assert.Equal(0x010c, qex.ApplicationErrorCode.Value); // H3_REQUEST_CANCELLED 158Assert.Equal(QuicError.StreamAborted, qex.QuicError); 159Assert.Equal(0x0102, qex.ApplicationErrorCode.Value); // H3_INTERNAL_ERROR 172Assert.Equal(QuicError.StreamAborted, qex.QuicError); 173Assert.Equal(0x010c, qex.ApplicationErrorCode.Value); // H3_REQUEST_CANCELLED

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

66Assert.Equal(port, new Uri(responseText).Port); 97Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\GlobalVersionTests.cs (1)

201Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Http2Tests.cs (18)

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

164Assert.Equal(0, hostProcess.ExitCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Inprocess\HttpSysRequestInfoTests.cs (1)

37Assert.Equal(HttpStatusCode.OK, response.StatusCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Inprocess\MaxRequestBodySizeTests.cs (4)

45Assert.Equal(HttpStatusCode.RequestEntityTooLarge, result.StatusCode); 89Assert.Equal(HttpStatusCode.OK, result.StatusCode); 110Assert.Equal(HttpStatusCode.OK, result.StatusCode); 155Assert.Equal(HttpStatusCode.OK, result.StatusCode);

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

52Assert.Equal(HttpStatusCode.OK, result.StatusCode); 70Assert.Equal(HttpStatusCode.OK, result.StatusCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\LoggingTests.cs (1)

362Assert.Equal(processId, prefixProcessId);

src\Servers\IIS\IIS\test\Common.FunctionalTests\MaxRequestBodySizeTests.cs (4)

46Assert.Equal(HttpStatusCode.RequestEntityTooLarge, result.StatusCode); 90Assert.Equal(HttpStatusCode.OK, result.StatusCode); 111Assert.Equal(HttpStatusCode.OK, result.StatusCode); 156Assert.Equal(HttpStatusCode.OK, result.StatusCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\MultiApplicationTests.cs (4)

61Assert.Equal(200, (int)result1.StatusCode); 62Assert.Equal(500, (int)result2.StatusCode); 88Assert.Equal(200, (int)result1.StatusCode); 89Assert.Equal(500, (int)result2.StatusCode);

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

51Assert.Equal(200, status); 81Assert.Equal(200, status);

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

60Assert.Equal(200, response.Status); 71Assert.Equal(200, response.Status); 82Assert.Equal(200, response.Status); 93Assert.Equal(200, response.Status); 133Assert.Equal( 151Assert.Equal( 168Assert.Equal(expected: 110000, actual: responseText.Length); 202Assert.Equal(requestBody.Length * 2, responseText.Length); 375Assert.Equal(10, (await _fixture.Client.GetByteArrayAsync($"/UnflushedResponsePipe")).Length); 382Assert.Equal(20, (await _fixture.Client.GetByteArrayAsync($"/FlushedPipeAndThenUnflushedPipe")).Length); 518Assert.Equal(HttpStatusCode.OK, response.StatusCode); 527Assert.Equal(HttpStatusCode.OK, response.StatusCode); 537Assert.Equal(2, headerValues.Count()); 546Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 569Assert.Equal((HttpStatusCode)code, response.StatusCode); 584Assert.Equal((HttpStatusCode)code, response.StatusCode); 649Assert.Equal(200000000, (await _fixture.Client.GetStringAsync($"/LargeResponseFile")).Length);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

164Assert.Equal(0, hostProcess.ExitCode);

src\Servers\IIS\IIS\test\Common.LongTests\ShutdownTests.cs (8)

145Assert.Equal(500, (int)result.StatusCode); 164Assert.Equal(502, (int)result.StatusCode); 182Assert.Equal(500, (int)result.StatusCode); 278Assert.Equal(HttpStatusCode.OK, result.StatusCode); 290Assert.Equal(HttpStatusCode.OK, res.StatusCode); 315Assert.Equal(HttpStatusCode.OK, result.StatusCode); 327Assert.Equal(HttpStatusCode.OK, res.StatusCode); 616Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode);

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (22)

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

164Assert.Equal(0, hostProcess.ExitCode);

src\Servers\IIS\IIS\test\Common.LongTests\ShutdownTests.cs (8)

145Assert.Equal(500, (int)result.StatusCode); 164Assert.Equal(502, (int)result.StatusCode); 182Assert.Equal(500, (int)result.StatusCode); 278Assert.Equal(HttpStatusCode.OK, result.StatusCode); 290Assert.Equal(HttpStatusCode.OK, res.StatusCode); 315Assert.Equal(HttpStatusCode.OK, result.StatusCode); 327Assert.Equal(HttpStatusCode.OK, res.StatusCode); 616Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode);

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (22)

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

164Assert.Equal(0, hostProcess.ExitCode);

src\Servers\IIS\IIS\test\Common.LongTests\ShutdownTests.cs (8)

145Assert.Equal(500, (int)result.StatusCode); 164Assert.Equal(502, (int)result.StatusCode); 182Assert.Equal(500, (int)result.StatusCode); 278Assert.Equal(HttpStatusCode.OK, result.StatusCode); 290Assert.Equal(HttpStatusCode.OK, res.StatusCode); 315Assert.Equal(HttpStatusCode.OK, result.StatusCode); 327Assert.Equal(HttpStatusCode.OK, res.StatusCode); 616Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode);

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (22)

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

164Assert.Equal(0, hostProcess.ExitCode);

MaxRequestBodySizeTests.cs (6)

75Assert.Equal(maxRequestSize, feature.MaxRequestBodySize); 111Assert.Equal(0, feature.MaxRequestBodySize); 138Assert.Equal(0, feature.MaxRequestBodySize); 246Assert.Equal(1, await ctx.Request.Body.ReadAsync(buffer, 0, 1)); 360Assert.Equal(new EventId(2, "ApplicationError"), appErrorLog.EventId); 361Assert.Equal(LogLevel.Error, appErrorLog.LogLevel);

ResponseAbortTests.cs (1)

159Assert.Equal(token, originalRegistration.Token);

ResponseBodySizeTests.cs (1)

30Assert.Equal(bufferSize, content.Length);

InProcess\AuthenticationTests.cs (6)

34Assert.Equal(HttpStatusCode.OK, response.StatusCode); 39Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); 45Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); 52Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); 59Assert.Equal(HttpStatusCode.OK, response.StatusCode); 64Assert.Equal(HttpStatusCode.OK, response.StatusCode);

OutOfProcess\MultipleAppTests.cs (1)

55Assert.Equal(HttpStatusCode.OK, response.StatusCode);

OutOfProcess\NtlmAuthentationTest.cs (7)

48Assert.Equal(HttpStatusCode.OK, response.StatusCode); 54Assert.Equal(HttpStatusCode.OK, response.StatusCode); 58Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); 63Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); 69Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); 76Assert.Equal(HttpStatusCode.OK, response.StatusCode); 81Assert.Equal(HttpStatusCode.OK, response.StatusCode);

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

66Assert.Equal(port, new Uri(responseText).Port); 97Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\GlobalVersionTests.cs (1)

201Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Http2Tests.cs (18)

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

164Assert.Equal(0, hostProcess.ExitCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Inprocess\HttpSysRequestInfoTests.cs (1)

37Assert.Equal(HttpStatusCode.OK, response.StatusCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Inprocess\MaxRequestBodySizeTests.cs (4)

45Assert.Equal(HttpStatusCode.RequestEntityTooLarge, result.StatusCode); 89Assert.Equal(HttpStatusCode.OK, result.StatusCode); 110Assert.Equal(HttpStatusCode.OK, result.StatusCode); 155Assert.Equal(HttpStatusCode.OK, result.StatusCode);

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

52Assert.Equal(HttpStatusCode.OK, result.StatusCode); 70Assert.Equal(HttpStatusCode.OK, result.StatusCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\LoggingTests.cs (1)

362Assert.Equal(processId, prefixProcessId);

src\Servers\IIS\IIS\test\Common.FunctionalTests\MaxRequestBodySizeTests.cs (4)

46Assert.Equal(HttpStatusCode.RequestEntityTooLarge, result.StatusCode); 90Assert.Equal(HttpStatusCode.OK, result.StatusCode); 111Assert.Equal(HttpStatusCode.OK, result.StatusCode); 156Assert.Equal(HttpStatusCode.OK, result.StatusCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\MultiApplicationTests.cs (4)

61Assert.Equal(200, (int)result1.StatusCode); 62Assert.Equal(500, (int)result2.StatusCode); 88Assert.Equal(200, (int)result1.StatusCode); 89Assert.Equal(500, (int)result2.StatusCode);

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

51Assert.Equal(200, status); 81Assert.Equal(200, status);

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

60Assert.Equal(200, response.Status); 71Assert.Equal(200, response.Status); 82Assert.Equal(200, response.Status); 93Assert.Equal(200, response.Status); 133Assert.Equal( 151Assert.Equal( 168Assert.Equal(expected: 110000, actual: responseText.Length); 202Assert.Equal(requestBody.Length * 2, responseText.Length); 375Assert.Equal(10, (await _fixture.Client.GetByteArrayAsync($"/UnflushedResponsePipe")).Length); 382Assert.Equal(20, (await _fixture.Client.GetByteArrayAsync($"/FlushedPipeAndThenUnflushedPipe")).Length); 518Assert.Equal(HttpStatusCode.OK, response.StatusCode); 527Assert.Equal(HttpStatusCode.OK, response.StatusCode); 537Assert.Equal(2, headerValues.Count()); 546Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 569Assert.Equal((HttpStatusCode)code, response.StatusCode); 584Assert.Equal((HttpStatusCode)code, response.StatusCode); 649Assert.Equal(200000000, (await _fixture.Client.GetStringAsync($"/LargeResponseFile")).Length);

src\Servers\IIS\IIS\test\Common.LongTests\ShutdownTests.cs (8)

145Assert.Equal(500, (int)result.StatusCode); 164Assert.Equal(502, (int)result.StatusCode); 182Assert.Equal(500, (int)result.StatusCode); 278Assert.Equal(HttpStatusCode.OK, result.StatusCode); 290Assert.Equal(HttpStatusCode.OK, res.StatusCode); 315Assert.Equal(HttpStatusCode.OK, result.StatusCode); 327Assert.Equal(HttpStatusCode.OK, res.StatusCode); 616Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode);

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (22)

BadHttpRequestTests.cs (1)

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

CertificateLoaderTests.cs (1)

65Assert.Equal(hasSan, CertificateLoader.DoesCertificateHaveASubjectAlternativeName(cert));

ChunkedResponseTests.cs (3)

1006Assert.Equal(4005, memory.Length); 1009Assert.Equal(4005, memory.Length); 1042Assert.Equal(4096, memory.Length);

ConnectionLimitTests.cs (3)

152static void AssertCounter(CollectedMeasurement<long> measurement) => Assert.Equal(1, measurement.Value); 205Assert.Equal(count, opened); 206Assert.Equal(count, closed);

ConnectionMiddlewareTests.cs (1)

63Assert.Equal(sendString.Length, middleware.BytesRead);

EventSourceTests.cs (53)

Http2\Http2ConnectionTests.cs (16)

38Assert.Equal(0, LogMessages.Count(m => m.EventId.Name == "Http2MaxConcurrentStreamsReached")); 42Assert.Equal(1, LogMessages.Count(m => m.EventId.Name == "Http2MaxConcurrentStreamsReached")); 47Assert.Equal(1, LogMessages.Count(m => m.EventId.Name == "Http2MaxConcurrentStreamsReached")); 273Assert.Equal(StringValues.Empty, contentTypeValue2); 542Assert.Equal(1, (int)persistedState); 1372Assert.Equal(readResult.Buffer.Length, _maxData.Length * 5); 1627Assert.Equal((uint)100, _connection.MaxTrackedStreams); 1639Assert.Equal((uint)200, _connection.MaxTrackedStreams); 1651Assert.Equal((uint)int.MaxValue * 2, _connection.MaxTrackedStreams); 1662Assert.Equal(100u, _connection.MaxTrackedStreams); 2282Assert.Equal(0, result); 3830Assert.Equal(40000, result); 4699Assert.Equal(11, _decodedHeaders.Count); 5002Assert.Equal(LogLevel.Warning, logMessage.LogLevel); 5339Assert.Equal(streamPayload, streamResponse); 5491Assert.Equal(Http2Connection.InvalidHttp1xErrorResponseBytes, data);

Http2\Http2StreamTests.cs (125)

Http2\Http2TestBase.cs (4)

1265Assert.Equal(8, frame.PayloadLength); 1266Assert.Equal(0, frame.Flags); 1267Assert.Equal(0, frame.StreamId); 1268Assert.Equal(expectedLastStreamId, frame.GoAwayLastStreamId);

Http2\Http2WebSocketTests.cs (17)

35Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1])); 71Assert.Equal(2, _decodedHeaders.Count); 97Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1])); 100Assert.Equal(0, await stream.ReadAsync(new byte[1])); 136Assert.Equal(2, _decodedHeaders.Count); 173Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1])); 177Assert.Equal(0, await stream.ReadAsync(new byte[1])); 227Assert.Equal(2, _decodedHeaders.Count); 263Assert.Equal(2, _decodedHeaders.Count); 334Assert.Equal(0, await stream.ReadAsync(new byte[1])); 366Assert.Equal(2, _decodedHeaders.Count); 430Assert.Equal(2, _decodedHeaders.Count); 455Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1])); 464Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1])); 471Assert.Equal(1, await stream.ReadAsync(new byte[1])); 498Assert.Equal(2, _decodedHeaders.Count); 553Assert.Equal(3, _decodedHeaders.Count);

Http2\TlsTests.cs (1)

40Assert.Equal(tlsFeature.ApplicationProtocol, SslApplicationProtocol.Http2.Protocol);

Http3\Http3ConnectionTests.cs (4)

369Assert.Equal((long)Http3SettingType.MaxFieldSectionSize, kvp.Key); 370Assert.Equal(defaultLimits.MaxRequestHeadersTotalSize, kvp.Value); 382Assert.Equal(100, maxFieldSetting.Value); 480Assert.Equal(StringValues.Empty, contentTypeValue2);

Http3\Http3StreamTests.cs (51)

Http3\Http3TimeoutTests.cs (1)

475Assert.Equal(_helloWorldBytes.Length, data.Length);

Http3\WebTransport\WebTransportHandshakeTests.cs (3)

64Assert.Equal(1, response1[(long)Http3SettingType.EnableWebTransport]); 79Assert.Equal((int)HttpStatusCode.OK, Convert.ToInt32(response2[InternalHeaderNames.Status], null)); 130Assert.Equal(1, response1[(long)Http3SettingType.EnableWebTransport]);

Http3\WebTransport\WebTransportStreamTests.cs (4)

24Assert.Equal(canRead, streamDirectionFeature.CanRead); 25Assert.Equal(canWrite, streamDirectionFeature.CanWrite); 49Assert.Equal(5, length); 50Assert.Equal(input.ToArray(), memoryOut.ToArray());

HttpsConnectionMiddlewareTests.cs (13)

322Assert.Equal(1, selectorCalled); 355Assert.Equal(1, selectorCalled); 390Assert.Equal(1, selectorCalled); 397Assert.Equal(2, selectorCalled); 427Assert.Equal(1, selectorCalled); 459Assert.Equal(1, selectorCalled); 489Assert.Equal(1, selectorCalled); 939Assert.Equal(SslApplicationProtocol.Http2, stream.NegotiatedApplicationProtocol); 972Assert.Equal(SslApplicationProtocol.Http2, stream.NegotiatedApplicationProtocol); 1005Assert.Equal(default, stream.NegotiatedApplicationProtocol); 1402Assert.Equal( 1420Assert.Equal(HttpProtocols.Http1, middleware._httpProtocols); 1434Assert.Equal(HttpProtocols.Http1AndHttp2, middleware._httpProtocols);

HttpsTests.cs (21)

122Assert.Equal(_x509Certificate2, opt.ServerCertificate); 123Assert.Equal(ClientCertificateMode.RequireCertificate, opt.ClientCertificateMode); 156Assert.Equal(ClientCertificateMode.RequireCertificate, opt.ClientCertificateMode); 190Assert.Equal(1, loggerProvider.FilterLogger.LastEventId.Id); 191Assert.Equal(LogLevel.Debug, loggerProvider.FilterLogger.LastLogLevel); 219Assert.Equal(1, loggerProvider.FilterLogger.LastEventId.Id); 220Assert.Equal(LogLevel.Debug, loggerProvider.FilterLogger.LastLogLevel); 383Assert.Equal(0, await connection.Stream.ReadAsync(new byte[1], 0, 1).DefaultTimeout()); 388Assert.Equal(2, loggerProvider.FilterLogger.LastEventId); 389Assert.Equal(LogLevel.Debug, loggerProvider.FilterLogger.LastLogLevel); 417Assert.Equal(0, await connection.Stream.ReadAsync(new byte[1], 0, 1).DefaultTimeout()); 422Assert.Equal(2, loggerProvider.FilterLogger.LastEventId); 423Assert.Equal(LogLevel.Debug, loggerProvider.FilterLogger.LastLogLevel); 464Assert.Equal(_x509Certificate2, sslServerAuthenticationOptions.ServerCertificate); 508Assert.Equal(_x509Certificate2, sslServerAuthenticationOptions.ServerCertificate); 622Assert.Collection(tlsOptions.ApplicationProtocols, p => Assert.Equal(SslApplicationProtocol.Http3, p)); 624Assert.Equal(testState, tlsOptions.OnConnectionState); 670Assert.Collection(tlsOptions.ApplicationProtocols, p => Assert.Equal(SslApplicationProtocol.Http3, p)); 673Assert.Equal(testState, tlsOptions.OnConnectionState); 706Assert.Equal(1, loggerProvider.FilterLogger.LastEventId); 707Assert.Equal(LogLevel.Debug, loggerProvider.FilterLogger.LastLogLevel);

KestrelMetricsTests.cs (9)

308Assert.Collection(currentUpgradedRequests.GetMeasurementSnapshot(), m => Assert.Equal(1, m.Value), m => Assert.Equal(-1, m.Value)); 392Assert.Equal(2, requestsReceived); 409Assert.Collection(activeTlsHandshakes.GetMeasurementSnapshot(), m => Assert.Equal(1, m.Value), m => Assert.Equal(-1, m.Value)); 413Assert.Equal(expectedValue, measurement.Value); 439Assert.Equal(localPort, (int)measurement.Tags["server.port"]); 475Assert.Equal(expectedValue, measurement.Value); 480Assert.Equal(localPort, (int)measurement.Tags["server.port"]);

MaxRequestBodySizeTests.cs (9)

165Assert.Equal(globalMaxRequestBodySize, feature.MaxRequestBodySize); 207Assert.Equal(0, feature.MaxRequestBodySize); 214Assert.Equal(1, await context.Request.Body.ReadAsync(buffer, 0, 1)); 215Assert.Equal((byte)'A', buffer[0]); 216Assert.Equal(0, await context.Request.Body.ReadAsync(buffer, 0, 1)); 284Assert.Equal(1, await context.Request.Body.ReadAsync(buffer, 0, 1)); 287Assert.Equal(new KestrelServerLimits().MaxRequestBodySize, feature.MaxRequestBodySize); 327Assert.Equal(new KestrelServerLimits().MaxRequestBodySize, feature.MaxRequestBodySize); 504Assert.Equal(globalMaxRequestBodySize, feature.MaxRequestBodySize);

RequestTests.cs (43)

97Assert.Equal(2, bufferLengths.Count); 98Assert.Equal(0, bufferLengths[0]); 99Assert.Equal(4096, bufferLengths[1]); 266Assert.Equal(new PathString(expectedPath), pathTcs.Task.Result); 321Assert.Equal(0, value); 358Assert.Equal(0, value); 393Assert.Equal(0, value); 398Assert.Equal(1, local.Value); 404Assert.Equal(1, local.Value); 425Assert.Equal(0, value); 430Assert.Equal(2, local.Value); 436Assert.Equal(2, local.Value); 440Assert.Equal(1, local.Value); 446Assert.Equal(2, local.Value); 466Assert.Equal(0, value); // Start 471Assert.Equal(2, local.Value.Value); // Second 477Assert.Equal(4, local.Value.Value); // Fourth 481Assert.Equal(1, local.Value.Value); // First 487Assert.Equal(3, local.Value.Value); // Third 505Assert.Equal(0, value); 510Assert.Equal(2, local.Value); 518Assert.Equal(2, local.Value); 524Assert.Equal(1, local.Value); 530Assert.Equal(2, local.Value); 593Assert.Equal(identifierLength, Encoding.ASCII.GetByteCount(context.TraceIdentifier)); 637Assert.Equal(identifierLength, offset); 924Assert.Equal(0, await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1).DefaultTimeout()); 1018Assert.Equal(5, readResult.Buffer.Length); 1050Assert.Equal(5, readResult.Buffer.Length); 1053Assert.Equal(5, readResult.Buffer.Length); 1085Assert.Equal(5, readResult.Buffer.Length); 1091Assert.Equal(5, readResult.Buffer.Length); 1129Assert.Equal(22, ms1.ToArray().Length); 1181Assert.Equal(3, readResult.Buffer.Length); 1193Assert.Equal(5, readResult.Buffer.Length); 1448Assert.Equal(1, streamCount); 1449Assert.Equal(1, requestHeadersCount); 1450Assert.Equal(1, responseHeadersCount); 1703Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1], 0, 1)); 1746Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1], 0, 1)); 1794Assert.Equal(5, length); 1836Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[1], 0, 1)); 2181Assert.Equal(1, secondRequestState);

ResponseTests.cs (16)

1275Assert.Equal(2, error.Count()); 2240Assert.Equal(0, await httpContext.Request.Body.ReadAsync(new byte[1], 0, 1).DefaultTimeout()); 2442Assert.Equal(2, LogMessages.Where(message => message.LogLevel == LogLevel.Error).Count()); 2499Assert.Equal(2, callback2CallCount); 2500Assert.Equal(2, LogMessages.Where(message => message.LogLevel == LogLevel.Error).Count()); 2638Assert.Equal(2, LogMessages.Where(message => message.LogLevel == LogLevel.Error).Count()); 3318Assert.Equal(1, callOrder.Pop()); 3319Assert.Equal(2, callOrder.Pop()); 3369Assert.Equal(1, callOrder.Pop()); 3370Assert.Equal(2, callOrder.Pop()); 4107Assert.Equal(4096, memory.Length); 4138Assert.Equal(4096, memory.Length); 4166Assert.Equal(4096, memory.Length); 4303Assert.Equal(2, httpContext.Response.Body.Length); 4569Assert.Equal(expectedClientStatusCode, GetStatus(response)); 4612Assert.Equal(expectedServerStatusCode, (HttpStatusCode)disposedStatusCode);

src\Servers\Kestrel\shared\test\CertificateAuthority.cs (1)

576Assert.Equal(CertStatus.Unknown, status);

src\Servers\Kestrel\shared\test\StreamExtensions.cs (1)

28Assert.Equal(0, await stream.ReadAsync(new byte[1], 0, 1, cancellationToken));

UpgradeTests.cs (7)

78Assert.Equal(0, read); 168Assert.Equal(1, context.Request.ContentLength); 169Assert.Equal(1, await context.Request.Body.ReadAsync(new byte[10], 0, 10)); 202Assert.Equal(0, context.Request.ContentLength); 204Assert.Equal(0, await context.Request.Body.ReadAsync(new byte[10], 0, 10)); 242Assert.Equal(11, length); 409Assert.Equal(0, await duplexStream.ReadAsync(new byte[1]));

src\Servers\IIS\IIS\test\testassets\InProcessWebSite\Startup.cs (4)

330Assert.Equal(200, ctx.Response.StatusCode); 332Assert.Equal(404, ctx.Response.StatusCode); 368Assert.Equal(IPAddress.IPv6Any, ctx.Connection.LocalIpAddress); 372Assert.Equal(IPAddress.IPv6Any, ctx.Connection.RemoteIpAddress);

src\Servers\IIS\IIS\test\testassets\InProcessWebSite\Startup.WebSockets.cs (1)

49Assert.Equal(0, await context.Request.Body.ReadAsync(singleByteArray, 0, 1));

Http2\Http2RequestTests.cs (3)

84Assert.Equal(host.GetPort(), (int)m.Tags["server.port"]); 151Assert.Equal(HttpStatusCode.BadRequest, responseMessage.StatusCode); 218Assert.Equal(randomBytes, readData);

Http2WebSocketInteropTests.cs (3)

67Assert.Equal(WebSocketMessageType.Text, result.MessageType); 84Assert.Equal(expectedVersion == "HTTP/2" ? HttpStatusCode.OK : HttpStatusCode.SwitchingProtocols, wsClient.HttpStatusCode); 91Assert.Equal(WebSocketMessageType.Text, result.MessageType);

Http3\Http3RequestTests.cs (18)

110Assert.Equal(host.GetPort(), (int)m.Tags["server.port"]); 159Assert.Equal(connectionIdFromFeature, mockScopeLoggerProvider.LogScope[0].Value); 258Assert.Equal(GetProtocol(protocol), response.Version); 309Assert.Equal(GetProtocol(protocol), response.Version); 437Assert.Equal(HttpVersion.Version30, response.Version); 576Assert.Equal(Http3ErrorCode.InternalError, (Http3ErrorCode)innerEx.ErrorCode); 638Assert.Equal((long)Http3ErrorCode.InternalError, protocolException.ErrorCode); 685Assert.Equal(Http3ErrorCode.InternalError, (Http3ErrorCode)innerEx.ErrorCode); 737Assert.Equal(HttpVersion.Version30, response.Version); 788Assert.Equal(1000, calls); 789Assert.Equal(1000, requestCount); 873Assert.Equal(1, secondRequestState); 918Assert.Equal(HttpVersion.Version20, response1.Version); 931Assert.Equal(HttpVersion.Version30, response2.Version); 947Assert.Equal(HttpVersion.Version30, response3.Version); 1843Assert.Equal(port, localPort); 2025Assert.Equal(TestData, data); 2058Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);

Http3\Http3TlsTests.cs (6)

64Assert.Equal(HttpVersion.Version30, response.Version); 110Assert.Equal(HttpVersion.Version30, response.Version); 152Assert.Equal(HttpVersion.Version30, response.Version); 330Assert.Equal(HttpVersion.Version30, response.Version); 333Assert.Equal(configuredState, callbackState); 495Assert.Equal(HttpVersion.Version30, response.Version);

HttpClientHttp2InteropTests.cs (19)

src\Servers\Kestrel\shared\test\StreamExtensions.cs (1)

28Assert.Equal(0, await stream.ReadAsync(new byte[1], 0, 1, cancellationToken));

InteropTests.cs (1)

107Assert.Equal(0, clientProcess.ExitCode);

AssertEx.cs (1)

391Assert.Equal(typeof(T), type);

ConfigureMethodVisitorTest.cs (1)

89Assert.Equal(expected, actual);

AntiforgeryOptionsSetupTest.cs (1)

69Assert.Equal(CookieSecurePolicy.None, options.Cookie.SecurePolicy);

AntiforgeryTokenTest.cs (2)

92Assert.Equal(AntiforgeryToken.SecurityTokenBitLength, securityToken!.BitLength); 124Assert.Equal(AntiforgeryToken.SecurityTokenBitLength, securityToken!.BitLength);

BinaryBlobTest.cs (6)

16Assert.Equal(64, blob.BitLength); 17Assert.Equal(64 / 8, data.Length); 52Assert.Equal(32, blob.BitLength); 53Assert.Equal(expectedData, blob.GetData()); 107Assert.Equal(blobA, blobB); 123Assert.Equal(expectedHashCode, actualHashCode);

DefaultAntiforgeryTokenSerializerTest.cs (1)

180Assert.Equal(expected.IsCookieToken, actual.IsCookieToken);

DefaultAntiforgeryTokenStoreTest.cs (5)

385Assert.Equal(1, cookies.Count); 390Assert.Equal(defaultCookieSecureValue, cookies.Options.Secure); 424Assert.Equal(1, cookies.Count); 464Assert.Equal(1, cookies.Count); 503Assert.Equal(1, cookies.Count);

DefaultClaimUidExtractorTest.cs (8)

91Assert.Equal(new string[] 112Assert.Equal(new string[] 132Assert.Equal(new string[] 152Assert.Equal(new string[] 173Assert.Equal(new string[] 199Assert.Equal(new List<string> 227Assert.Equal(new string[] 249Assert.Equal(new string[]

Infrastructure\AmbiguousRoutePatternComparerTests.cs (1)

53Assert.Equal(hashCode1, hashCode2);

RouteEmbeddedLanguage\FrameworkParametersCompletionProviderTests.cs (10)

RouteEmbeddedLanguage\Infrastructure\CompletionTestHelpers.cs (3)

22Assert.Equal(textSpans.Single(), results.CompletionListSpan); 26Assert.Equal(cursorPosition, results.CompletionListSpan.Start); 27Assert.Equal(cursorPosition, results.CompletionListSpan.End);

RouteEmbeddedLanguage\RoutePatternClassifierTests.cs (1)

35Assert.Equal(expected, actualFormatted);

RouteEmbeddedLanguage\RoutePatternCompletionProviderTests.cs (3)

124Assert.Equal(result.CompletionListSpan, change.TextChange.Span); 153Assert.Equal(result.CompletionListSpan, change.TextChange.Span); 182Assert.Equal(result.CompletionListSpan, change.TextChange.Span);

RouteEmbeddedLanguage\RoutePatternParserTests.cs (1)

326Assert.Equal(allChars.Length, position);

WebApplicationBuilder\UseTopLevelRouteRegistrationInsteadOfUseEndpointsTest.cs (2)

157Assert.Equal(4, diagnostics.Length); 259Assert.Equal(2, diagnostics.Length);

PackageTests.cs (9)

103Assert.Equal(expectedVersion.Major, assemblyVersion.Major); 104Assert.Equal(expectedVersion.Minor, assemblyVersion.Minor); 107Assert.Equal(expectedVersion.Build, assemblyVersion.Build); 111Assert.Equal(0, assemblyVersion.Build); 113Assert.Equal(0, assemblyVersion.Revision); 131Assert.Equal(expectedVersion.Major, assemblyVersion.Major); 132Assert.Equal(expectedVersion.Minor, assemblyVersion.Minor); 133Assert.Equal(0, assemblyVersion.Build); 134Assert.Equal(0, assemblyVersion.Revision);

SharedFxTests.cs (7)

196Assert.Equal(expectedVersion.Major, assemblyDefinition.Version.Major); 207Assert.Equal(expectedVersion.Minor, assemblyDefinition.Version.Minor); 208Assert.Equal(0, assemblyDefinition.Version.Build); 209Assert.Equal(0, assemblyDefinition.Version.Revision); 241Assert.Equal(0, reference.Version.Build); 242Assert.Equal(0, reference.Version.Revision); 253Assert.Equal(2, lines.Length);

TargetingPackTests.cs (7)

93Assert.Equal(expectedVersion.Major, assemblyDefinition.Version.Major); 104Assert.Equal(expectedVersion.Minor, assemblyDefinition.Version.Minor); 105Assert.Equal(0, assemblyDefinition.Version.Build); 106Assert.Equal(0, assemblyDefinition.Version.Revision); 147Assert.Equal(packageOverrideFileLines.Length, runtimeDependencies.Count + aspnetcoreDependencies.Count); 171Assert.Equal(2, packageOverrideParts.Length); 278Assert.Equal(4, parts.Length);

AuthenticationPropertiesTests.cs (30)

AuthenticationSchemeProviderTests.cs (5)

249Assert.Equal(await provider.GetDefaultForbidSchemeAsync(), expected); 250Assert.Equal(await provider.GetDefaultAuthenticateSchemeAsync(), expected); 251Assert.Equal(await provider.GetDefaultChallengeSchemeAsync(), expected); 252Assert.Equal(await provider.GetDefaultSignInSchemeAsync(), expected); 253Assert.Equal(await provider.GetDefaultSignOutSchemeAsync(), expected);

AuthenticationServiceTests.cs (3)

42Assert.Equal(1, transform.Ran); 45Assert.Equal(2, transform.Ran); 48Assert.Equal(3, transform.Ran);

AuthenticationTicketTests.cs (2)

34Assert.Equal(ticket.Properties.Items, copy.Properties.Items); 35Assert.Equal(ticket.Properties.Parameters, copy.Properties.Parameters);

TokenExtensionTests.cs (4)

28Assert.Equal(3, props.GetTokens().Count()); 75Assert.Equal(3, props.GetTokens().Count()); 98Assert.Equal(3, props.GetTokens().Count()); 119Assert.Equal(3, props.GetTokens().Count());

UserJwtsTests.cs (8)

432Assert.Equal(32, signingKey["Length"].GetValue<int>()); 460Assert.Equal(32, signingKey["Length"].GetValue<int>()); 499Assert.Equal(32, signingKey["Length"].GetValue<int>()); 521Assert.Equal(2, signingKeys.Count); 543Assert.Equal(32, signingKey1["Length"].GetValue<int>()); 547Assert.Equal(32, signingKey2["Length"].GetValue<int>()); 599Assert.Equal(32, bytesParsed); 719Assert.Equal(UnixFileMode.UserRead | UnixFileMode.UserWrite, File.GetUnixFileMode(app.UserJwtsFilePath));

EventTests.cs (26)

LdapAdapterTests.cs (4)

13Assert.Equal(new[] { "Testing group - City" }, parts); 21Assert.Equal(new[] { @"Testing group\,City" }, parts); 29Assert.Equal(new[] { "Testing group", "City" }, parts); 37Assert.Equal(new[] { @"Testing group\\", "City" }, parts);

NegotiateHandlerTests.cs (16)

AuthenticationMiddlewareTests.cs (1)

57Assert.Equal(607, (int)response.StatusCode);

Base64UrlTextEncoderTests.cs (1)

23Assert.Equal(data[index], result[index]);

CertificateTests.cs (31)

ClaimActionTests.cs (4)

37Assert.Equal(2, roleClaims.Count); 69Assert.Equal(2, roleClaims.Count); 102Assert.Equal(2, identity.FindAll("name0").Count()); 103Assert.Equal(2, identity.FindAll("name1").Count());

CookieTests.cs (29)

DynamicSchemeTests.cs (6)

32Assert.Equal(HttpStatusCode.OK, response.StatusCode); 44Assert.Equal(HttpStatusCode.OK, response.StatusCode); 67Assert.Equal(HttpStatusCode.OK, response.StatusCode); 73Assert.Equal(HttpStatusCode.OK, response.StatusCode); 79Assert.Equal(HttpStatusCode.OK, response.StatusCode); 86Assert.Equal(HttpStatusCode.OK, response.StatusCode);

FacebookTests.cs (14)

GoogleTests.cs (50)

JwtBearerTests.cs (35)

JwtBearerTests_Handler.cs (37)

MicrosoftAccountTests.cs (15)

OAuthChallengePropertiesTest.cs (14)

OAuthTests.cs (13)

OpenIdConnect\OpenIdConnectAuthenticateTests.cs (4)

84Assert.Equal("itfailed", ex.Data["error"]); 85Assert.Equal("whyitfailed", ex.Data["error_description"]); 86Assert.Equal("https://example.com/fail", ex.Data["error_uri"]); 99Assert.Equal(HttpStatusCode.Redirect, transaction.Response.StatusCode);

OpenIdConnect\OpenIdConnectChallengeTests.cs (28)

OpenIdConnect\OpenIdConnectConfigurationTests.cs (92)

OpenIdConnect\OpenIdConnectEventTests.cs (47)

OpenIdConnect\OpenIdConnectEventTests_Handler.cs (47)

OpenIdConnect\OpenIdConnectTests.cs (28)

OpenIdConnect\TestSettings.cs (1)

273Assert.Equal(TimeSpan.FromMinutes(20), _options.MaxAge.Value);

PolicyTests.cs (100)

SharedAuthenticationTests.cs (107)

TicketSerializerTests.cs (1)

50Assert.Equal("bootstrap", readTicket.Principal.Identities.First().BootstrapContext);

TokenExtensionTests.cs (4)

24Assert.Equal(3, props.GetTokens().Count()); 71Assert.Equal(3, props.GetTokens().Count()); 94Assert.Equal(3, props.GetTokens().Count()); 115Assert.Equal(3, props.GetTokens().Count());

TwitterTests.cs (17)

WsFederation\WsFederationTest.cs (2)

131Assert.Equal(HttpStatusCode.Found, response.StatusCode); 158Assert.Equal(HttpStatusCode.Found, response.StatusCode);

WsFederation\WsFederationTest_Handler.cs (2)

129Assert.Equal(HttpStatusCode.Found, response.StatusCode); 156Assert.Equal(HttpStatusCode.Found, response.StatusCode);

AuthorizationBuilderTests.cs (5)

24Assert.Equal(policy, options.FallbackPolicy); 55Assert.Equal(policy, options.DefaultPolicy); 71Assert.Equal(invoke, options.InvokeHandlersAfterFailure); 86Assert.Equal(policy, options.GetPolicy("name")); 102Assert.Equal(1, policy.Requirements.Count);

AuthorizationEndpointConventionBuilderExtensionsTests.cs (13)

AuthorizationMiddlewareTests.cs (55)

AuthorizationPolicyFacts.cs (11)

37Assert.Equal(2, combined.AuthenticationSchemes.Count()); 40Assert.Equal(4, combined.Requirements.Count()); 42Assert.Equal(2, combined.Requirements.OfType<ClaimsAuthorizationRequirement>().Count()); 65Assert.Equal(1, combined.Requirements.Count); 87Assert.Equal(2, combined.AuthenticationSchemes.Count()); 90Assert.Equal(2, combined.Requirements.Count()); 92Assert.Equal(2, combined.Requirements.OfType<ClaimsAuthorizationRequirement>().Count()); 111Assert.Equal(2, rolesAuthorizationRequirement.AllowedRoles.Count()); 131Assert.Equal(2, combined.AuthenticationSchemes.Count()); 151Assert.Equal(2, combined.AuthenticationSchemes.Count()); 172Assert.Equal(2, rolesAuthorizationRequirement.AllowedRoles.Count());

DefaultAuthorizationServiceTests.cs (9)

139Assert.Equal(invokeAllHandlers, handler2.Invoked); 190Assert.Equal(2, allowed.Failure.FailureReasons.Count()); 193Assert.Equal(handler1, first.Handler); 196Assert.Equal(handler3, second.Handler); 714Assert.Equal(shouldSucceed, allowed.Succeeded); 1190Assert.Equal(LogLevel.Information, level); 1191Assert.Equal(2, eventId.Id); 1223Assert.Equal(LogLevel.Information, level); 1224Assert.Equal(2, eventId.Id);

PassThroughAuthorizationHandlerTests.cs (1)

46Assert.Equal(invokeAllHandlers, afterHandler.Invoked);

PolicyEvaluatorTests.cs (2)

45Assert.Equal(3, result.Principal.Identities.Count()); 65Assert.Equal(auth.Principal, result.Principal);

TransformTest.cs (4)

24Assert.Equal(2, doc.ChildNodes.Count); 29Assert.Equal(3, envNode.ChildNodes.Count); 54Assert.Equal(2, doc.ChildNodes.Count); 59Assert.Equal(3, envNode.ChildNodes.Count);

AuthorizeRouteViewTest.cs (11)

67Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 104Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 236Assert.Equal(layoutDiff.ComponentId, nonEmptyDiff.ComponentId); 239Assert.Equal(RenderTreeEditType.UpdateText, edit.Type); 240Assert.Equal(1, edit.SiblingIndex); 351Assert.Equal(2, _renderer.Batches.Count); 358Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 359Assert.Equal(1, edit.SiblingIndex); 365Assert.Equal(RenderTreeEditType.RemoveFrame, edit.Type); 366Assert.Equal(2, edit.SiblingIndex); 372Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type);

AuthorizeViewTest.cs (15)

69Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 133Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 169Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 211Assert.Equal(2, renderer.Batches.Count); 216Assert.Equal(RenderTreeEditType.UpdateText, edit.Type); 278Assert.Equal(2, renderer.Batches.Count); 283Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 314Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 327Assert.Equal(2, renderer.Batches.Count); 332Assert.Equal(RenderTreeEditType.UpdateText, edit.Type); 333Assert.Equal(0, edit.SiblingIndex); 372Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 385Assert.Equal(2, renderer.Batches.Count); 390Assert.Equal(RenderTreeEditType.UpdateText, edit.Type); 391Assert.Equal(0, edit.SiblingIndex);

CascadingAuthenticationStateTest.cs (6)

57Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 92Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 105Assert.Equal(2, renderer.Batches.Count); 110Assert.Equal(RenderTreeEditType.UpdateText, edit.Type); 141Assert.Equal(2, renderer.Batches.Count); 146Assert.Equal(RenderTreeEditType.UpdateText, edit.Type);

src\Components\Shared\test\AssertFrame.cs (23)

Binding\FormDataMapperTests.cs (29)

Discovery\ComponentApplicationBuilderTests.cs (70)

EndpointHtmlRendererTest.cs (29)

311Assert.Equal(0, marker.Sequence); 318Assert.Equal(0, serverComponent.Sequence); 344Assert.Equal(0, preambleMarker.Sequence); 352Assert.Equal(0, serverComponent.Sequence); 409Assert.Equal(0, preambleMarker.Sequence); 414Assert.Equal(0, firstServerComponent.Sequence); 420Assert.Equal(1, markerMarker.Sequence); 425Assert.Equal(1, secondServerComponent.Sequence); 427Assert.Equal(firstServerComponent.InvocationId, secondServerComponent.InvocationId); 462Assert.Equal(0, marker.Sequence); 469Assert.Equal(0, serverComponent.Sequence); 501Assert.Equal(0, marker.Sequence); 508Assert.Equal(0, serverComponent.Sequence); 541Assert.Equal(0, preambleMarker.Sequence); 549Assert.Equal(0, serverComponent.Sequence); 592Assert.Equal(0, preambleMarker.Sequence); 600Assert.Equal(0, serverComponent.Sequence); 807Assert.Equal(302, ctx.Response.StatusCode); 902Assert.Equal(400, httpContext.Response.StatusCode); 931Assert.Equal(400, httpContext.Response.StatusCode); 994Assert.Equal(1, eventReceivedCount); 1036Assert.Equal(1, eventReceivedCount); 1040Assert.Equal(1, eventReceivedCount); 1042Assert.Equal(400, httpContext.Response.StatusCode); 1075Assert.Equal(0, marker.Sequence); 1082Assert.Equal(0, serverComponent.Sequence); 1104Assert.Equal(1, marker.Sequence); 1111Assert.Equal(1, serverComponent.Sequence); 1168Assert.Equal(2, numMarkers); // A start and an end marker

HotReloadServiceTests.cs (1)

62Assert.Equal(2, endpointDataSource.Endpoints.Count);

HttpContextFormValueMapperTest.cs (1)

43Assert.Equal(expectedResult, canMap);

RazorComponentEndpointDataSourceTest.cs (1)

25Assert.Equal(2, endpoints.Count);

RazorComponentEndpointFactoryTest.cs (2)

35Assert.Equal(0, routeEndpoint.Order); 132Assert.Equal(0, routeEndpoint.Order);

RazorComponentEndpointInvokerTest.cs (1)

51Assert.Equal(StatusCodes.Status400BadRequest, context.Response.StatusCode);

RazorComponentResultTest.cs (7)

37Assert.Equal(1, result.Parameters.Count); 38Assert.Equal(123, result.Parameters["First"]); 46Assert.Equal(2, result.Parameters.Count); 47Assert.Equal(123, result.Parameters["Param1"]); 48Assert.Equal("Another", result.Parameters["Param2"]); 66Assert.Equal(200, httpContext.Response.StatusCode); 88Assert.Equal(123, httpContext.Response.StatusCode);

TypeNameHashTest.cs (4)

25Assert.Equal(ExpectedHashLength, hash.Length); 35Assert.Equal(ExpectedHashLength, hash.Length); 48Assert.Equal(ExpectedHashLength, hash.Length); 65Assert.Equal(ExpectedHashLength, hash.Length);

EditContextDataAnnotationsExtensionsTest.cs (8)

90Assert.Equal(1, onValidationStateChangedCount); 96Assert.Equal(2, onValidationStateChangedCount); 102Assert.Equal(3, onValidationStateChangedCount); 121Assert.Equal(1, onValidationStateChangedCount); 128Assert.Equal(2, onValidationStateChangedCount); 138Assert.Equal(3, onValidationStateChangedCount); 158Assert.Equal(0, onValidationStateChangedCount); 162Assert.Equal(1, onValidationStateChangedCount);

EditContextTest.cs (1)

114Assert.Equal(field1, eventArgs.FieldIdentifier);

FieldIdentifierTest.cs (4)

87Assert.Equal(fieldIdentifier1.GetHashCode(), fieldIdentifier2.GetHashCode()); 100Assert.Equal(fieldIdentifier1.GetHashCode(), fieldIdentifier2.GetHashCode()); 114Assert.Equal(fieldIdentifier1.GetHashCode(), fieldIdentifier2.GetHashCode()); 158Assert.Equal(models, result);

ReverseStringBuilderTest.cs (7)

20Assert.Equal(0, builder.SequenceSegmentCount); 34Assert.Equal(0, builder.SequenceSegmentCount); 53Assert.Equal(0, builder.SequenceSegmentCount); 73Assert.Equal(0, builder.SequenceSegmentCount); 92Assert.Equal(1, builder.SequenceSegmentCount); 113Assert.Equal(2, builder.SequenceSegmentCount); 143Assert.Equal(segmentCount, builder.SequenceSegmentCount);

src\Components\Shared\test\AssertFrame.cs (23)

CircuitDisconnectMiddlewareTest.cs (7)

41Assert.Equal(StatusCodes.Status405MethodNotAllowed, context.Response.StatusCode); 70Assert.Equal(StatusCodes.Status400BadRequest, context.Response.StatusCode); 97Assert.Equal(StatusCodes.Status400BadRequest, context.Response.StatusCode); 129Assert.Equal(StatusCodes.Status400BadRequest, context.Response.StatusCode); 162Assert.Equal(StatusCodes.Status200OK, context.Response.StatusCode); 199Assert.Equal(StatusCodes.Status200OK, context.Response.StatusCode); 237Assert.Equal(StatusCodes.Status200OK, context.Response.StatusCode);

Circuits\CircuitIdFactoryTest.cs (1)

35Assert.Equal(100, secrets.Distinct(StringComparer.Ordinal).Count());

Circuits\RemoteJSDataStreamTest.cs (2)

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

Circuits\RenderBatchWriterTest.cs (9)

39Assert.Equal(36, bytes.Length); // No other data 66Assert.Equal(48, bytes.Length); // No other data 93Assert.Equal(60, bytes.Length); // No other data 135Assert.Equal(60, bytes.Length); // No other data 189Assert.Equal(new[] { "Some removed attribute" }, ReadStringTable(bytes)); 256Assert.Equal(new[] 326Assert.Equal(expectedInt, reader.ReadInt32()); 330Assert.Equal(expectedUlong, reader.ReadUInt64()); 340Assert.Equal(-1, indexIntoStringTable);

Circuits\RevalidatingServerAuthenticationStateProviderTest.cs (5)

49Assert.Equal(10, provider.RevalidationCallLog.Count); 160Assert.Equal(0, authenticationStateChangedCount); 172Assert.Equal(1, authenticationStateChangedCount); 201Assert.Equal(0, authenticationStateChangedCount); 210Assert.Equal(1, authenticationStateChangedCount);

ComponentEndpointRouteBuilderExtensionsTest.cs (2)

88Assert.Equal(5, buildersAffected.Count); 123Assert.Equal(new[] { "first-in", "last-in" }, populatedMetadata);

DependencyInjection\ComponentServiceCollectionExtensionsTest.cs (4)

47Assert.Equal(TimeSpan.FromMinutes(10), options.Value.HandshakeTimeout); 57Assert.Equal(TimeSpan.FromMinutes(10), options.HandshakeTimeout); 74Assert.Equal(TimeSpan.FromMinutes(5), options.Value.HandshakeTimeout); 77Assert.Equal(TimeSpan.FromMinutes(10), globalOptions.Value.HandshakeTimeout);

ProtectedBrowserStorageTest.cs (13)

37arg => Assert.Equal(keyName, arg), 63arg => Assert.Equal(keyName, arg), 87arg => Assert.Equal("testKey", arg), 113Assert.Equal(123, result.Value.IntProperty); 117Assert.Collection(invocation.Args, arg => Assert.Equal(keyName, arg)); 140Assert.Equal(123, result.Value.IntProperty); 144Assert.Collection(invocation.Args, arg => Assert.Equal(keyName, arg)); 253Assert.Collection(invocation.Args, arg => Assert.Equal("testKey", arg)); 279Assert.Equal(expectedPurposes, dataProtectionProvider.ProtectorsCreated.ToArray()); 282invocation => Assert.Equal(TestDataProtectionProvider.Protect(expectedPurposes[0], "null"), invocation.Args[1]), 283invocation => Assert.Equal(TestDataProtectionProvider.Protect(expectedPurposes[1], "null"), invocation.Args[1]), 284invocation => Assert.Equal(TestDataProtectionProvider.Protect(expectedPurposes[0], "null"), invocation.Args[1]), 285invocation => Assert.Equal(TestDataProtectionProvider.Protect(expectedPurposes[2], "null"), invocation.Args[1]));

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

444Assert.Equal(testData.Size, Write(testData.Message).Length); 481Assert.Equal(expectedOutput, message.ToArray());

BindConverterTest.cs (14)

CascadingParameterTest.cs (43)

ComponentBaseTest.cs (14)

31Assert.Equal(1, onInitRuns); 54Assert.Equal(1, onInitAsyncRuns); 78Assert.Equal(1, onInitAsyncRuns); 97Assert.Equal(1, onParametersSetRuns); 121Assert.Equal(1, onParametersSetAsyncRuns); 145Assert.Equal(1, onParametersSetAsyncRuns); 175Assert.Equal(2, renderer.Batches.Count); 217Assert.Equal(2, renderer.Batches.Count); 228Assert.Equal(3, renderer.Batches.Count); 256Assert.Equal(2, renderer.Batches.Count); 290Assert.Equal(2, renderer.Batches.Count); 298Assert.Equal(2, renderer.Batches.Count); 337Assert.Equal(2, renderer.Batches.Count); 348Assert.Equal(2, renderer.Batches.Count);

ComponentFactoryTest.cs (4)

154Assert.Equal(componentType, renderer.RequestedComponentType); 155Assert.Equal(1234, renderer.SuppliedParentComponentId); 204Assert.Equal(componentType, renderer.RequestedComponentType); 207Assert.Equal(1234, renderer.SuppliedParentComponentId);

DynamicComponentTest.cs (1)

125Assert.Equal(123, ((TestComponent)instance.Instance).IntProp);

EventCallbackFactoryBinderExtensionsTest.cs (62)

EventCallbackTest.cs (40)

LayoutViewTest.cs (16)

179Assert.Equal(2, _renderer.Batches.Count); 181Assert.Equal(0, batch.DisposedComponentIDs.Count); 190Assert.Equal(RenderTreeEditType.UpdateText, edit.Type); 191Assert.Equal(1, edit.SiblingIndex); 221Assert.Equal(2, _renderer.Batches.Count); 223Assert.Equal(1, batch.DisposedComponentIDs.Count); // Disposes NestedLayout 232Assert.Equal(RenderTreeEditType.RemoveFrame, edit.Type); 233Assert.Equal(1, edit.SiblingIndex); 237Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 238Assert.Equal(1, edit.SiblingIndex); 250Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 251Assert.Equal(0, edit.SiblingIndex); 258Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 259Assert.Equal(1, edit.SiblingIndex); 266Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); 267Assert.Equal(2, edit.SiblingIndex);

Lifetime\ComponentApplicationStateTest.cs (5)

25Assert.Equal(new byte[] { 1, 2, 3, 4 }, existing); 59Assert.Equal(new byte[] { 1, 2, 3, 4 }, existing); 79Assert.Equal(myState, JsonSerializer.Deserialize<byte[]>(stored)); 115Assert.Equal(myState, JsonSerializer.Deserialize<byte[]>(stored)); 151Assert.Equal(myState, stored);

Lifetime\ComponentStatePersistenceManagerTest.cs (4)

36Assert.Equal(data, retrieved); 100Assert.Equal(data, JsonSerializer.Deserialize<byte[]>(persisted.ToArray())); 205Assert.Equal(LogLevel.Error, log.LogLevel); 234Assert.Equal(LogLevel.Error, log.LogLevel);

NavigationManagerTest.cs (6)

254Assert.Equal(initialHandlerCount, completedHandlerCount); 308Assert.Equal(initialHandlerCount, completedHandlerCount); 361Assert.Equal(expectedInvokedHandlerCount, invokedHandlerCount); 507Assert.Equal(blockNavigationHandlerCount, canceledBlockNavigationHandlerCount); 627Assert.Equal(expectedCanceledHandlerCount, canceledHandlerCount); 628Assert.Equal(0, completedHandlerCount);

OwningComponentBaseTest.cs (4)

24Assert.Equal(1, counter.CreatedCount); 25Assert.Equal(0, counter.DisposedCount); 28Assert.Equal(1, counter.CreatedCount); 29Assert.Equal(1, counter.DisposedCount);

ParameterViewTest.Assignment.cs (13)

30Assert.Equal(123, target.IntProp); 49Assert.Equal(123, target.IntProp); 67Assert.Equal(123, target.IntProp); 68Assert.Equal(456, target.DerivedClassIntProp); 86Assert.Equal(123, target.VirtualProp); 107Assert.Equal(456, target.IntProp); 183Assert.Equal(default, target.IntProp); 205Assert.Equal(default, target.IntProp); 359Assert.Equal(123, kvp.Value); 364Assert.Equal(456, kvp.Value); 476Assert.Equal("hi", kvp.Value); 599Assert.Equal(0, target.IntProp); 624Assert.Equal(5, target.IntProp);

ParameterViewTest.cs (5)

200Assert.Equal(default, result); 218Assert.Equal(explicitDefaultValue, result); 265Assert.Equal(dictionary, collection.ToDictionary()); 288Assert.Equal("value 1", entry.Value); 577Assert.Equal(expectedIsCascading, parameter.Cascading);

RendererTest.cs (188)

Rendering\ArrayBuilderTest.cs (3)

313buffer => Assert.Equal(2, buffer.Length), 314buffer => Assert.Equal(4, buffer.Length), 315buffer => Assert.Equal(8, buffer.Length));

Rendering\RendererSynchronizationContextTest.cs (2)

576Assert.Equal(TaskStatus.Canceled, task.Status); 758Assert.Equal(TaskStatus.Canceled, task.Status);

Rendering\RenderTreeBuilderTest.cs (3)

167Assert.Equal(2, frames.Count); 186Assert.Equal(4, frames.Count); 2099Assert.Equal(default, frame.ComponentFrameFlags);

Rendering\SimplifiedStringHashComparerTest.cs (1)

19Assert.Equal(hash1, hash2);

RenderTreeDiffBuilderTest.cs (73)

RouteViewTest.cs (1)

92Assert.Equal(4, batch.DiffsInOrder.Count);

Routing\QueryParameterValueSupplierTest.cs (3)

253Assert.Equal(string.Empty, _supplier.GetQueryParameterValue(typeof(string), "StringVal")); 266Assert.Equal(new[] { "a", string.Empty, string.Empty, "b" }, _supplier.GetQueryParameterValue(typeof(string[]), "StringVals")); 350Assert.Equal(expectedValue, actualValue);

Routing\RouteKeyTest.cs (5)

16Assert.Equal(key1.GetHashCode(), key2.GetHashCode()); 28Assert.Equal(key1.GetHashCode(), key2.GetHashCode()); 64Assert.Equal(key1.GetHashCode(), key2.GetHashCode()); 76Assert.Equal(key1.GetHashCode(), key2.GetHashCode()); 100Assert.Equal(key1.GetHashCode(), key2.GetHashCode());

Routing\RouterTest.cs (6)

87Assert.Equal(2, onNavigateInvoked); 88Assert.Equal(2, refreshCalled); 198Assert.Equal(RenderTreeFrameType.Text, renderedFrame.FrameType); 224Assert.Equal(1, refreshCalled); 244Assert.Equal(RenderTreeFrameType.Text, renderedFrame.FrameType); 264Assert.Equal(RenderTreeFrameType.Text, renderedFrame.FrameType);

Routing\RouteTableFactoryTests.cs (13)

75Assert.Equal(routes.GroupBy(x => x.Handler).Count(), routes.Count); 346Assert.Equal(expectedParameters, context.Parameters); 368Assert.Equal(expectedParameters, context.Parameters); 403Assert.Equal(new Dictionary<string, object> 472Assert.Equal(handler, context.Handler); 676Assert.Equal(new Dictionary<string, object> 706Assert.Equal(new Dictionary<string, object> 732Assert.Equal(new Dictionary<string, object> 757Assert.Equal(new Dictionary<string, object> 921Assert.Equal(typeof(TestHandler1), context.Handler); 952Assert.Equal(context.Parameters, new Dictionary<string, object> 973Assert.Equal(typeof(TestHandler2), context.Handler); 1093Assert.Equal(new Dictionary<string, object>

src\Components\Shared\test\AssertFrame.cs (23)

StackObjectPoolTest.cs (2)

74Assert.Equal(3, new[] { instance1, instance2, instance3 }.Distinct().Count()); 86Assert.Equal(4, new[] { instance1, instance2, instance3, instance2b }.Distinct().Count());

Forms\EditFormTest.cs (2)

203Assert.Equal("my method", editFormAttributes["method"]); 204Assert.Equal("some value", editFormAttributes["custom attribute"]);

Forms\InputBaseTest.cs (16)

91Assert.Equal(FieldIdentifier.Create(() => model.StringProperty), inputComponent.FieldIdentifier); 297Assert.Equal(1991, receivedParsedValue.Year); 298Assert.Equal(11, receivedParsedValue.Month); 299Assert.Equal(20, receivedParsedValue.Day); 302Assert.Equal(0, numValidationStateChanges); 327Assert.Equal(1, numValidationStateChanges); 332Assert.Equal(1991, receivedParsedValue.Year); 333Assert.Equal(11, receivedParsedValue.Month); 334Assert.Equal(20, receivedParsedValue.Day); 337Assert.Equal(2, numValidationStateChanges); 394Assert.Equal(inputComponentId, batch2.DiffsByComponentId.Keys.Single()); 454Assert.Equal(1, component.AdditionalAttributes.Count); 456Assert.Equal("true", component.AdditionalAttributes["aria-invalid"]); 489Assert.Equal(1, component.AdditionalAttributes.Count); 490Assert.Equal("userSpecifiedValue", component.AdditionalAttributes["aria-invalid"]); 525Assert.Equal(inputComponentId, batch2.DiffsByComponentId.Keys.Single());

Forms\InputFileChangeEventArgsTest.cs (2)

12Assert.Equal(0, emptySet.FileCount); 15Assert.Equal(2, twoItemSet.FileCount);

Forms\InputSelectTest.cs (7)

24Assert.Equal(TestEnum.Two, inputSelectComponent.CurrentValue); 43Assert.Equal(default, inputSelectComponent.CurrentValue); 62Assert.Equal(TestEnum.Two, inputSelectComponent.Value); 102Assert.Equal(guid, inputSelectComponent.CurrentValue); 123Assert.Equal(guid, inputSelectComponent.CurrentValue); 143Assert.Equal(42, inputSelectComponent.CurrentValue); 163Assert.Equal(42, inputSelectComponent.CurrentValue);

src\Components\Shared\test\AssertFrame.cs (23)

WebEventData\ChangeEventArgsReaderTest.cs (3)

26Assert.Equal(args.Value, result.Value); 43Assert.Equal(args.Value, result.Value); 60Assert.Equal(args.Value, result.Value);

WebEventData\DragEventArgsReaderTest.cs (3)

66Assert.Equal(expected.Files, actual.Files); 68Assert.Equal(expected.Types, actual.Types); 73Assert.Equal(expected.Length, actual.Length);

WebEventData\ErrorEventArgsReaderTest.cs (2)

29Assert.Equal(args.Colno, result.Colno); 31Assert.Equal(args.Lineno, result.Lineno);

WebEventData\KeyboardEventArgsReaderTest.cs (7)

34Assert.Equal(args.AltKey, result.AltKey); 36Assert.Equal(args.CtrlKey, result.CtrlKey); 38Assert.Equal(args.Location, result.Location); 39Assert.Equal(args.MetaKey, result.MetaKey); 40Assert.Equal(args.Repeat, result.Repeat); 41Assert.Equal(args.ShiftKey, result.ShiftKey); 43Assert.Equal(args.IsComposing, result.IsComposing);

WebEventData\MouseEventArgsReaderTest.cs (17)

WebEventData\PointerEventArgsReaderTest.cs (7)

48Assert.Equal(args.PointerId, result.PointerId); 50Assert.Equal(args.Width, result.Width); 51Assert.Equal(args.Height, result.Height); 52Assert.Equal(args.IsPrimary, result.IsPrimary); 53Assert.Equal(args.Pressure, result.Pressure); 54Assert.Equal(args.TiltX, result.TiltX); 55Assert.Equal(args.TiltY, result.TiltY);

WebEventData\ProgressEventArgsReaderTest.cs (3)

27Assert.Equal(args.LengthComputable, result.LengthComputable); 28Assert.Equal(args.Loaded, result.Loaded); 29Assert.Equal(args.Total, result.Total);

WebEventData\TouchEventArgsReaderTest.cs (13)

WebEventData\WebEventDescriptorReaderTest.cs (6)

31Assert.Equal(args.EventHandlerId, result.EventHandlerId); 33Assert.Equal(args.EventFieldInfo.ComponentId, result.EventFieldInfo.ComponentId); 34Assert.Equal(args.EventFieldInfo.FieldValue, result.EventFieldInfo.FieldValue); 59Assert.Equal(args.EventHandlerId, result.EventHandlerId); 61Assert.Equal(args.EventFieldInfo.ComponentId, result.EventFieldInfo.ComponentId); 62Assert.Equal(args.EventFieldInfo.FieldValue, result.EventFieldInfo.FieldValue);

WebEventData\WheelEventArgsReaderTest.cs (4)

45Assert.Equal(args.DeltaMode, result.DeltaMode); 46Assert.Equal(args.DeltaX, result.DeltaX); 47Assert.Equal(args.DeltaY, result.DeltaY); 48Assert.Equal(args.DeltaZ, result.DeltaZ);

Hosting\WebAssemblyCultureProviderTest.cs (1)

24Assert.Equal(expected, actual);

Hosting\WebAssemblyHostBuilderTest.cs (1)

248Assert.Equal<ILoggerProvider>(provider.Object, loggerProvider);

Hosting\WebAssemblyHostConfigurationTest.cs (4)

99Assert.Equal(4, section.Count); 162Assert.Equal(3, dict.Count); 168Assert.Equal(3, dict2.Count); 174Assert.Equal(5, dict3.Count);

Hosting\WebAssemblyHostTest.cs (1)

83Assert.Equal(1, disposable.DisposeCount);

PullFromJSDataStreamTest.cs (4)

45Assert.Equal(3, await pullFromJSDataStream.ReadAsync(buffer)); 46Assert.Equal(expectedChunks[i], buffer); 48Assert.Equal(pullFromJSDataStream.Position, Data.Length); 60Assert.Equal(Data, mem.ToArray());

Infrastructure\AssertHelpers.cs (5)

14Assert.Equal(5, args.Count); 22Assert.Equal(2, args.Count); 23Assert.Equal(componentId, args[0].GetInt32()); 31Assert.Equal(2, args.Count); 32Assert.Equal(1, args[0].GetInt64()); // Batch ID

StaticContentProviderTests.cs (1)

37Assert.Equal(200, statusCode);

WebViewManagerTests.cs (1)

76Assert.Equal(2, singleton.Services.Count);

ConcurrencyLimiterEventSourceTests.cs (3)

18Assert.Equal(Guid.Parse("a605548a-6963-55cf-f000-99a6013deb01", CultureInfo.InvariantCulture), eventSource.Guid); 36Assert.Equal(expectedId, eventData.EventId); 37Assert.Equal(EventLevel.Warning, eventData.Level);

MiddlewareTests.cs (18)

CookieChunkingTests.cs (8)

54Assert.Equal(4, values.Count); 55Assert.Equal<string[]>(new[] 73Assert.Equal(4, values.Count); 74Assert.Equal<string[]>(new[] 215Assert.Equal(8, cookies.Count); 237Assert.Equal(3, cookies.Count); 255Assert.Equal(3, cookies.Count); 303Assert.Equal(8, httpContext.Response.Headers[HeaderNames.SetCookie].Count);

CookieConsentTests.cs (52)

CookiePolicyTests.cs (12)

314Assert.Equal(1, transaction.SetCookie.Count); 399Assert.Equal(1, transaction.SetCookie.Count); 401Assert.Equal("TestCookie", cookie.Name); 404Assert.Equal("/", cookie.Path); 450Assert.Equal(3, transaction.SetCookie.Count); 453Assert.Equal("TestCookie", cookie.Name); 454Assert.Equal("chunks-2", cookie.Value); 457Assert.Equal("/", cookie.Path); 461Assert.Equal("TestCookieC1", cookie.Name); 464Assert.Equal("/", cookie.Path); 468Assert.Equal("TestCookieC2", cookie.Name); 471Assert.Equal("/", cookie.Path);

CorsMiddlewareTests.cs (6)

99Assert.Equal(2, response.Headers.Count()); 327Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); 369Assert.Equal(HttpStatusCode.OK, response.StatusCode); 427Assert.Equal(200, httpContext.Response.StatusCode); 619Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 765Assert.Equal(StatusCodes.Status204NoContent, httpContext.Response.StatusCode);

CorsPolicyBuilderTests.cs (16)

33Assert.Equal(originalPolicy.Headers, corsPolicy.Headers); 35Assert.Equal(originalPolicy.Methods, corsPolicy.Methods); 37Assert.Equal(originalPolicy.Origins, corsPolicy.Origins); 39Assert.Equal(originalPolicy.ExposedHeaders, corsPolicy.ExposedHeaders); 40Assert.Equal(TimeSpan.FromSeconds(12), corsPolicy.PreflightMaxAge); 62Assert.Equal(originalPolicy.Origins, corsPolicy.Origins); 107Assert.Equal(origins.ToList(), corsPolicy.Origins); 123Assert.Equal(new List<string>() { "http://example.com", "http://example2.com" }, corsPolicy.Origins); 134Assert.Equal(new List<string>() { "http://www.example.com", "https://example2.com" }, corsPolicy.Origins); 171Assert.Equal(new List<string>() { "*" }, corsPolicy.Origins); 229Assert.Equal(new List<string>() { "PUT", "GET" }, corsPolicy.Methods); 244Assert.Equal(new List<string>() { "*" }, corsPolicy.Methods); 259Assert.Equal(new List<string>() { "example1", "example2" }, corsPolicy.Headers); 274Assert.Equal(new List<string>() { "*" }, corsPolicy.Headers); 288Assert.Equal(new List<string>() { "exposed1", "exposed2" }, corsPolicy.ExposedHeaders); 302Assert.Equal(TimeSpan.FromSeconds(12), corsPolicy.PreflightMaxAge);

CorsServiceTests.cs (13)

Cng\BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO_Tests.cs (13)

18Assert.Equal((uint)sizeof(BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO), cipherModeInfo.cbSize); 19Assert.Equal(1U, cipherModeInfo.dwInfoVersion); 20Assert.Equal(IntPtr.Zero, (IntPtr)cipherModeInfo.pbNonce); 21Assert.Equal(0U, cipherModeInfo.cbNonce); 22Assert.Equal(IntPtr.Zero, (IntPtr)cipherModeInfo.pbAuthData); 23Assert.Equal(0U, cipherModeInfo.cbAuthData); 24Assert.Equal(IntPtr.Zero, (IntPtr)cipherModeInfo.pbTag); 25Assert.Equal(0U, cipherModeInfo.cbTag); 26Assert.Equal(IntPtr.Zero, (IntPtr)cipherModeInfo.pbMacContext); 27Assert.Equal(0U, cipherModeInfo.cbMacContext); 28Assert.Equal(0U, cipherModeInfo.cbAAD); 29Assert.Equal(0UL, cipherModeInfo.cbData); 30Assert.Equal(0U, cipherModeInfo.dwFlags);

Cng\BCryptUtilTests.cs (6)

35Assert.Equal(0x04, bytes[0]); 36Assert.Equal(0x10, bytes[1]); 37Assert.Equal(0xE4, bytes[2]); 38Assert.Equal(0xEA, bytes[sizeof(Guid) + 3]); 39Assert.Equal(0xF2, bytes[sizeof(Guid) + 4]); 40Assert.Equal(0x6A, bytes[sizeof(Guid) + 5]);

Cng\CachedAlgorithmHandlesTests.cs (8)

117Assert.Equal((uint)(128 / 8), algorithmHandle.GetCipherBlockLength()); 119Assert.Equal(128U, supportedKeyLengths.dwMinLength); 120Assert.Equal(256U, supportedKeyLengths.dwMaxLength); 121Assert.Equal(64U, supportedKeyLengths.dwIncrement); 139Assert.Equal(expectedBlockSizeInBytes, algorithmHandle.GetHashBlockLength()); 140Assert.Equal(expectedDigestSizeInBytes, algorithmHandle.GetHashDigestLength()); 170Assert.Equal(expectedBlockSizeInBytes, algorithmHandle.GetHashBlockLength()); 171Assert.Equal(expectedDigestSizeInBytes, algorithmHandle.GetHashDigestLength());

UnsafeBufferUtilTests.cs (6)

23Assert.Equal(x, y); 37Assert.Equal(x, y); 113Assert.Equal(0, x); 126Assert.Equal(0, x); 139Assert.Equal(0, x); 152Assert.Equal(0, x);

Pbkdf2Tests.cs (1)

205Assert.Equal(numBytesRequested, derivedKey.Length);

DataProtectionAdvancedExtensionsTests.cs (2)

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

TimeLimitedDataProtectorTests.cs (6)

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

AuthenticatedEncryption\ConfigurationModel\AuthenticatedEncryptorDescriptorDeserializerTests.cs (1)

41Assert.Equal(plaintext, roundTripPlaintext);

AuthenticatedEncryption\ConfigurationModel\AuthenticatedEncryptorDescriptorTests.cs (6)

49Assert.Equal(plaintext, roundTripPlaintext); 75Assert.Equal(plaintext, roundTripPlaintext); 101Assert.Equal(plaintext, roundTripPlaintext); 139Assert.Equal(plaintext, roundTripPlaintext); 153Assert.Equal(typeof(AuthenticatedEncryptorDescriptorDeserializer), retVal.DeserializerType); 176Assert.Equal(typeof(AuthenticatedEncryptorDescriptorDeserializer), retVal.DeserializerType);

AuthenticatedEncryption\ConfigurationModel\CngCbcAuthenticatedEncryptorConfigurationTests.cs (1)

34Assert.Equal(configuration, descriptor.Configuration);

AuthenticatedEncryption\ConfigurationModel\CngCbcAuthenticatedEncryptorDescriptorDeserializerTests.cs (1)

48Assert.Equal(plaintext, roundTripPlaintext);

AuthenticatedEncryption\ConfigurationModel\CngCbcAuthenticatedEncryptorDescriptorTests.cs (2)

28Assert.Equal(typeof(CngCbcAuthenticatedEncryptorDescriptorDeserializer), retVal.DeserializerType); 56Assert.Equal(typeof(CngCbcAuthenticatedEncryptorDescriptorDeserializer), retVal.DeserializerType);

AuthenticatedEncryption\ConfigurationModel\CngGcmAuthenticatedEncryptorConfigurationTests.cs (1)

34Assert.Equal(configuration, descriptor.Configuration);

AuthenticatedEncryption\ConfigurationModel\CngGcmAuthenticatedEncryptorDescriptorDeserializerTests.cs (1)

45Assert.Equal(plaintext, roundTripPlaintext);

AuthenticatedEncryption\ConfigurationModel\CngGcmAuthenticatedEncryptorDescriptorTests.cs (2)

26Assert.Equal(typeof(CngGcmAuthenticatedEncryptorDescriptorDeserializer), retVal.DeserializerType); 52Assert.Equal(typeof(CngGcmAuthenticatedEncryptorDescriptorDeserializer), retVal.DeserializerType);

AuthenticatedEncryption\ConfigurationModel\ManagedAuthenticatedEncryptorConfigurationTests.cs (1)

34Assert.Equal(configuration, descriptor.Configuration);

AuthenticatedEncryption\ConfigurationModel\ManagedAuthenticatedEncryptorDescriptorDeserializerTests.cs (2)

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

AuthenticatedEncryption\ConfigurationModel\ManagedAuthenticatedEncryptorDescriptorTests.cs (2)

27Assert.Equal(typeof(ManagedAuthenticatedEncryptorDescriptorDeserializer), retVal.DeserializerType); 59Assert.Equal(typeof(ManagedAuthenticatedEncryptorDescriptorDeserializer), retVal.DeserializerType);

Cng\CbcAuthenticatedEncryptorTests.cs (1)

32Assert.Equal(plaintext, decipheredtext);

Cng\CngAuthenticatedEncryptorBaseTests.cs (4)

23Assert.Equal((byte)0x03, *(byte*)pbCiphertext); 24Assert.Equal((byte)0x11, *(byte*)pbAdditionalAuthenticatedData); 48Assert.Equal((byte)0x03, *(byte*)pbCiphertext); 74Assert.Equal((byte)0x11, *(byte*)pbAdditionalAuthenticatedData);

Cng\GcmAuthenticatedEncryptorTests.cs (1)

29Assert.Equal(plaintext, decipheredtext);

EphemeralDataProtectionProviderTests.cs (1)

60Assert.Equal(bytes, unprotectedBytes);

Internal\KeyManagementOptionsSetupTest.cs (1)

66Assert.Equal(TimeSpan.FromDays(1024), options.NewKeyLifetime);

KeyManagement\DefaultKeyResolverTests.cs (4)

326Assert.Equal(0, descriptorFactoryCalls); // Not retried 405Assert.Equal(1, descriptorFactoryCalls1); // 1 try 406Assert.Equal(1 + maxRetries, descriptorFactoryCalls2); // 1 try plus max retries 463Assert.Equal(2, descriptorFactoryCalls); // 1 try plus 1 retry

KeyManagement\DeferredKeyTests.cs (5)

37Assert.Equal(keyId, key.KeyId); 38Assert.Equal(creationDate, key.CreationDate); 39Assert.Equal(activationDate, key.ActivationDate); 40Assert.Equal(expirationDate, key.ExpirationDate); 78Assert.Equal(1, numTimesCalled);

KeyManagement\KeyRingBasedDataProtectorTests.cs (21)

KeyManagement\KeyRingProviderTests.cs (5)

91Assert.Equal(StringToDateTime("2016-03-01 00:00:00Z"), cacheableKeyRing.ExpirationTimeUtc); 513Assert.Equal(expectedCallSequence, actualCallSequence); 785Assert.Equal(createNewKeyCallbacksEnumerator.Current.Item1, activationDate); 786Assert.Equal(createNewKeyCallbacksEnumerator.Current.Item2, expirationDate); 799Assert.Equal(current.Item1, now);

KeyManagement\KeyRingTests.cs (13)

25Assert.Equal(0, key1.NumTimesCreateEncryptorInstanceCalled); 27Assert.Equal(1, key1.NumTimesCreateEncryptorInstanceCalled); 29Assert.Equal(1, key1.NumTimesCreateEncryptorInstanceCalled); // should've been cached 43Assert.Equal(key2.KeyId, keyRing.DefaultKeyId); 58Assert.Equal(key3.KeyId, keyRing.DefaultKeyId); 59Assert.Equal(key3.CreateEncryptor(), keyRing.GetAuthenticatedEncryptorByKeyId(key3.KeyId, out var _)); 76Assert.Equal(0, key1.NumTimesCreateEncryptorInstanceCalled); 79Assert.Equal(1, key1.NumTimesCreateEncryptorInstanceCalled); 82Assert.Equal(1, key1.NumTimesCreateEncryptorInstanceCalled); 83Assert.Equal(0, key2.NumTimesCreateEncryptorInstanceCalled); 86Assert.Equal(1, key2.NumTimesCreateEncryptorInstanceCalled); 89Assert.Equal(1, key2.NumTimesCreateEncryptorInstanceCalled); 91Assert.Equal(1, key2.NumTimesCreateEncryptorInstanceCalled);

KeyManagement\KeyTests.cs (4)

27Assert.Equal(keyId, key.KeyId); 28Assert.Equal(creationDate, key.CreationDate); 29Assert.Equal(activationDate, key.ActivationDate); 30Assert.Equal(expirationDate, key.ExpirationDate);

KeyManagement\XmlKeyManagerTests.cs (36)

129Assert.Equal(keyId, newKey.KeyId); 130Assert.Equal(creationDate, newKey.CreationDate); 131Assert.Equal(activationDate, newKey.ActivationDate); 132Assert.Equal(expirationDate, newKey.ExpirationDate); 227Assert.Equal(keyId, newKey.KeyId); 228Assert.Equal(creationDate, newKey.CreationDate); 229Assert.Equal(activationDate, newKey.ActivationDate); 230Assert.Equal(expirationDate, newKey.ExpirationDate); 257Assert.Equal(keyId, keyIdStoredInEscrow.Value); 331Assert.Equal(0, keys.Count); 371Assert.Equal(2, keys.Length); 372Assert.Equal(new Guid("62a72ad9-42d7-4e97-b3fa-05bad5d53d33"), keys[0].KeyId); 373Assert.Equal(XmlConvert.ToDateTimeOffset("2015-01-01T00:00:00Z"), keys[0].CreationDate); 374Assert.Equal(XmlConvert.ToDateTimeOffset("2015-02-01T00:00:00Z"), keys[0].ActivationDate); 375Assert.Equal(XmlConvert.ToDateTimeOffset("2015-03-01T00:00:00Z"), keys[0].ExpirationDate); 378Assert.Equal(new Guid("041be4c0-52d7-48b4-8d32-f8c0ff315459"), keys[1].KeyId); 379Assert.Equal(XmlConvert.ToDateTimeOffset("2015-04-01T00:00:00Z"), keys[1].CreationDate); 380Assert.Equal(XmlConvert.ToDateTimeOffset("2015-05-01T00:00:00Z"), keys[1].ActivationDate); 381Assert.Equal(XmlConvert.ToDateTimeOffset("2015-06-01T00:00:00Z"), keys[1].ExpirationDate); 448Assert.Equal(4, keys.Length); 449Assert.Equal(new Guid("67f9cdea-83ba-41ed-b160-2b1d0ea30251"), keys[0].KeyId); 451Assert.Equal(new Guid("0cf83742-d175-42a8-94b5-1ec049b354c3"), keys[1].KeyId); 453Assert.Equal(new Guid("21580ac4-c83a-493c-bde6-29a1cc97ca0f"), keys[2].KeyId); 455Assert.Equal(new Guid("6bd14f12-0bb8-4822-91d7-04b360de0497"), keys[3].KeyId); 487Assert.Equal(new Guid("09712588-ba68-438a-a5ee-fe842b3453b2"), keys[0].KeyId); 526Assert.Equal(new Guid("49c0cda9-0232-4d8c-a541-de20cc5a73d6"), keys[0].KeyId); 815Assert.Equal(0, decryptionCount); 823Assert.Equal(createdKey.KeyId, fetchedKey.KeyId); // But it should be equivalent 826Assert.Equal(0, decryptionCount); 830Assert.Equal(0, decryptionCount); 837Assert.Equal(createdKey.KeyId, fetchedKey2.KeyId); // But it should be equivalent 841Assert.Equal(0, decryptionCount); 914Assert.Equal(0, decryptionCount); 918Assert.Equal(1, decryptionCount); 924Assert.Equal(fetchedKey.KeyId, fetchedKey2.KeyId); // But it should be equivalent 928Assert.Equal(1, decryptionCount); // Still 1 (i.e. no change)

Managed\ManagedAuthenticatedEncryptorTests.cs (1)

28Assert.Equal(plaintext, decipheredtext);

RegistryPolicyResolverTests.cs (11)

Repositories\FileSystemXmlRepositoryTests.cs (3)

42Assert.Equal(dirInfo, retVal); 58Assert.Equal(0, allElements.Count); 173Assert.Equal(UnixFileMode.UserRead | UnixFileMode.UserWrite, fileInfo.UnixFileMode);

Repositories\RegistryXmlRepositoryTests.cs (2)

28Assert.Equal(regKey, retVal); 45Assert.Equal(0, allElements.Count);

SecretAssert.cs (1)

24Assert.Equal(expectedLengthInBits, checked(secret.Length * 8));

SecretTests.cs (12)

31Assert.Equal(3, secret.Length); 44Assert.Equal(new byte[] { 0x20, 0x30, 0x40 }, outputBuffer); 58Assert.Equal(3, secret.Length); 71Assert.Equal(new byte[] { 0x20, 0x30, 0x40 }, outputBuffer); 81Assert.Equal(0, secret.Length); 120Assert.Equal(0, secret.Length); 140Assert.Equal(3, secret.Length); 153Assert.Equal(new byte[] { 0x20, 0x30, 0x40 }, outputBuffer); 163Assert.Equal(0, secret.Length); 173Assert.Equal(32, secret.Length); 188Assert.Equal(31, secret.Length); 194Assert.Equal(0, ((byte*)pGuids)[31]); // last byte shouldn't have been overwritten

ServiceCollectionTests.cs (1)

44Assert.Equal(

XmlEncryption\CertificateXmlEncryptionTests.cs (2)

49Assert.Equal(typeof(EncryptedXmlDecryptor), encryptedXmlInfo.DecryptorType); 50Assert.Equal(XName.Get("EncryptedData", "http://www.w3.org/2001/04/xmlenc#"), encryptedXmlInfo.EncryptedElement.Name);

XmlEncryption\DpapiNGXmlEncryptionTests.cs (1)

24Assert.Equal(typeof(DpapiNGXmlDecryptor), encryptedXmlInfo.DecryptorType);

XmlEncryption\DpapiXmlEncryptionTests.cs (1)

26Assert.Equal(typeof(DpapiXmlDecryptor), encryptedXmlInfo.DecryptorType);

XmlEncryption\EncryptedXmlDecryptorTests.cs (1)

84Assert.Equal("SampleData", decrypted.Name);

XmlEncryption\NullXmlEncryptionTests.cs (1)

33Assert.Equal(typeof(NullXmlDecryptor), retVal.DecryptorType);

CertificateManagerTests.cs (5)

64Assert.Equal(now.LocalDateTime, httpsCertificate.NotBefore); 65Assert.Equal(now.AddYears(1).LocalDateTime, httpsCertificate.NotAfter); 404Assert.Equal(2, httpsCertificateList.Count); 442Assert.Equal(UnixFileMode.UserRead | UnixFileMode.UserWrite, File.GetUnixFileMode(CertificateName)); 445Assert.Equal(UnixFileMode.UserRead | UnixFileMode.UserWrite, File.GetUnixFileMode(KeyName));

DatabaseDeveloperPageExceptionFilterTests.cs (4)

61Assert.Equal(1, sink.Writes.Count); 63Assert.Equal(LogLevel.Error, message.LogLevel); 87Assert.Equal(1, sink.Writes.Count); 89Assert.Equal(LogLevel.Error, message.LogLevel);

DatabaseErrorPageOptionsTest.cs (1)

15Assert.Equal(MigrationsEndPointOptions.DefaultPath, options.MigrationsEndPointPath);

HealthCheckEndpointRouteBuilderExtensionsTest.cs (2)

80Assert.Equal(HttpStatusCode.OK, response.StatusCode); 125Assert.Equal(HttpStatusCode.OK, response.StatusCode);

HealthCheckMiddlewareSampleTest.cs (4)

30Assert.Equal(HttpStatusCode.OK, response.StatusCode); 52Assert.Equal(HttpStatusCode.OK, response.StatusCode); 75Assert.Equal(HttpStatusCode.OK, response.StatusCode); 97Assert.Equal(HttpStatusCode.ServiceUnavailable, response.StatusCode);

HealthCheckMiddlewareTests.cs (30)

DeveloperExceptionPageMiddlewareTest.cs (6)

258Assert.Equal(StatusCodes.Status500InternalServerError, (int)response.StatusCode); 293Assert.Equal(StatusCodes.Status500InternalServerError, (int)response.StatusCode); 366Assert.Equal(statusCode, (int)response.StatusCode); 607Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 617Assert.Equal(500, (int)m.Tags["http.response.status_code"]); 626Assert.Equal(1, measurement.Value);

ExceptionHandlerMiddlewareTest.cs (7)

114Assert.Equal(endpoint, feature.Endpoint); 115Assert.Equal("Doe", feature.RouteValues["John"]); 339Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 349Assert.Equal(500, (int)m.Tags["http.response.status_code"]); 406Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 416Assert.Equal(500, (int)m.Tags["http.response.status_code"]); 450Assert.Equal(1, measurement.Value);

ExceptionHandlerTest.cs (14)

StatusCodeMiddlewareTest.cs (4)

62Assert.Equal(HttpStatusCode.Found, response.StatusCode); 89Assert.Equal(beforeNext, afterNext); 226Assert.Equal(endpoint, statusCodeReExecuteFeature.Endpoint); 227Assert.Equal("Doe", statusCodeReExecuteFeature.RouteValues["John"]);

RouteTests.cs (3)

172Assert.Equal(HttpStatusCode.NotFound, response3.StatusCode); 216Assert.Equal(HttpStatusCode.NotFound, response3.StatusCode); 264Assert.Equal(HttpStatusCode.NotFound, response3.StatusCode);

ConverterTests\JsonConverterReadTests.cs (8)

408Assert.Equal(DateTimeOffset.UnixEpoch, timestamp.ToDateTimeOffset()); 421Assert.Equal(2147483647, value.Value); 615Assert.Equal(10, m.A); 616Assert.Equal(20, m.B); 617Assert.Equal(30, m.C); 628Assert.Equal(10, m.A); 629Assert.Equal(20, m.B); 630Assert.Equal(30, m.C);

GrpcJsonTranscodingServiceExtensionsTests.cs (2)

28Assert.Equal(options1, options2); 49Assert.Equal(settings, options.JsonSettings);

JsonTranscodingRouteAdapterTests.cs (8)

JsonTranscodingServerCallContextTests.cs (3)

32Assert.Equal(cts.Token, ct); 51Assert.Equal(2, headers.Count); 56Assert.Equal(new byte[] { 1, 2, 3 }, headers[1].ValueBytes);

JsonTranscodingServiceMethodProviderTests.cs (2)

32Assert.Equal(1, endpoint.RoutePattern.Parameters.Count); 58Assert.Equal(2, matchedEndpoints.Count);

ServerStreamingServerCallHandlerTests.cs (6)

63Assert.Equal(200, httpContext.Response.StatusCode); 117Assert.Equal(2, responseJson2.RootElement.GetProperty("code").GetInt32()); 159Assert.Equal((int)StatusCode.Aborted, responseJson2.RootElement.GetProperty("code").GetInt32()); 163Assert.Equal(debugException, exceptionWrite.Exception); 196Assert.Equal(2, responseJson.RootElement.GetProperty("code").GetInt32()); 244Assert.Equal(200, httpContext.Response.StatusCode);

UnaryServerCallHandlerTests.cs (73)

Binding\ParametersTests.cs (31)

Binding\ResponseBodyTests.cs (1)

65Assert.Equal(5, enumSchema.Enum.Count);

GrpcSwaggerServiceExtensionsTests.cs (1)

86Assert.Equal(2, swagger.Paths.Count);

SchemaGeneratorIntegrationTests.cs (11)

XmlComments\XmlCommentsDocumentFilterTests.cs (1)

43Assert.Equal(1, document.Tags.Count);

XmlComments\XmlDocumentationIntegrationTests.cs (2)

122Assert.Equal(ParameterLocation.Path, p.In); 128Assert.Equal(ParameterLocation.Query, p.In);

HeaderPropagationIntegrationTest.cs (4)

67Assert.Equal(HttpStatusCode.OK, response.StatusCode); 116Assert.Equal(HttpStatusCode.OK, response.StatusCode); 143Assert.Equal(HttpStatusCode.OK, response.StatusCode); 189Assert.Equal(HttpStatusCode.OK, response.StatusCode);

HeaderPropagationMiddlewareTest.cs (1)

137Assert.Equal(new StringValues("value"), receivedValue);

HostFilteringMiddlewareTests.cs (6)

75Assert.Equal(status, (int)response.StatusCode); 118Assert.Equal(status, (int)response.StatusCode); 169Assert.Equal(200, (int)response.StatusCode); 221Assert.Equal(400, (int)response.StatusCode); 260Assert.Equal(400, (int)response.StatusCode); 265Assert.Equal(200, (int)response.StatusCode);

MiddlewareConfigurationManagerTests.cs (7)

32Assert.Equal(configurationBeforeChange.AllowAnyNonEmptyHost, configurationBeforeChange.AllowedHosts is null); 33Assert.Equal(options.AllowEmptyHosts, configurationBeforeChange.AllowEmptyHosts); 34Assert.Equal(options.IncludeFailureMessage, configurationBeforeChange.IncludeFailureMessage); 56Assert.Equal(newOption.AllowEmptyHosts, configurationAfterChange.AllowEmptyHosts); 57Assert.Equal(newOption.IncludeFailureMessage, configurationAfterChange.IncludeFailureMessage); 86Assert.Equal(options.AllowEmptyHosts, result1.AllowEmptyHosts); 87Assert.Equal(options.IncludeFailureMessage, result1.IncludeFailureMessage);

ShutdownTests.cs (1)

143Assert.Equal(0, process.ExitCode);

HostingApplicationDiagnosticsTests.cs (39)

HostingApplicationTests.cs (1)

118Assert.Equal(Activity.Current, dummyActivity);

HostingMetricsTests.cs (18)

Internal\HostingEventSourceTests.cs (29)

StartupManagerTests.cs (1)

304Assert.Equal(2, callbackStartup.MethodsCalled);

StaticWebAssets\ManifestStaticWebAssetsFileProviderTests.cs (9)

50Assert.Equal(expectedResult, file.Exists); 118Assert.Equal(exists, file.Exists); 195Assert.Equal(exists, file.Exists); 271Assert.Equal(exists, file.Exists); 439Assert.Equal(new[] { (true, "_content") }, contents.Select(e => (e.IsDirectory, e.Name)).OrderBy(e => e.Name).ToArray()); 469Assert.Equal(new[]{ 487Assert.Equal(new[]{ 603Assert.Equal(new[]{ 646Assert.Equal(expectedResult, directory.Exists);

WebHostBuilderTests.cs (13)

273Assert.Equal(0, callCount++); 277Assert.Equal(1, callCount++); 284Assert.Equal(2, callCount); 467Assert.Equal(0, callCount++); 472Assert.Equal(1, callCount++); 479Assert.Equal(2, callCount); 880Assert.Equal(factory, factoryFromHost); 991Assert.Equal(2, containerFactory.ServiceProviders.Count); 992Assert.Equal(2, disposables.Count); 1282Assert.Equal(TimeSpan.FromSeconds(102), options.ShutdownTimeout); 1409Assert.Equal(2, ordering.Order); 1434Assert.Equal(0, Ordering.Order); 1458Assert.Equal(1, Ordering.Order);

WebHostConfigurationsTests.cs (1)

53Assert.Equal(expected, config.DetailedErrors);

WebHostTests.AsyncDisposable.cs (1)

24Assert.Equal(2, providerFactory.Providers.Count);

WebHostTests.cs (38)

146Assert.Equal(1, server.StartInstances.Count); 147Assert.Equal(0, server.StartInstances[0].DisposeCalls); 151Assert.Equal(1, server.StartInstances[0].DisposeCalls); 177Assert.Equal(1, server.StartInstances.Count); 178Assert.Equal(0, server.StartInstances[0].DisposeCalls); 189Assert.Equal(1, server.StartInstances[0].DisposeCalls); 228Assert.Equal(task, await Task.WhenAny(task, Task.Delay(TimeSpan.FromSeconds(10)))); 264Assert.Equal(task, await Task.WhenAny(task, Task.Delay(TimeSpan.FromSeconds(10)))); 303Assert.Equal(task, await Task.WhenAny(task, Task.Delay(TimeSpan.FromSeconds(8)))); 513Assert.Equal(0, stoppingCalls); 514Assert.Equal(0, disposingCalls); 516Assert.Equal(1, stoppingCalls); 517Assert.Equal(1, disposingCalls); 600Assert.Equal(0, startedCalls); 603Assert.Equal(1, startedCalls); 604Assert.Equal(0, stoppingCalls); 605Assert.Equal(0, disposingCalls); 609Assert.Equal(1, startedCalls); 610Assert.Equal(1, stoppingCalls); 611Assert.Equal(0, disposingCalls); 615Assert.Equal(1, startedCalls); 616Assert.Equal(1, stoppingCalls); 617Assert.Equal(1, disposingCalls); 653Assert.Equal(0, startedCalls); 655Assert.Equal(1, startedCalls); 656Assert.Equal(0, stoppingCalls); 657Assert.Equal(0, disposingCalls); 660Assert.Equal(1, stoppingCalls); 661Assert.Equal(1, disposingCalls); 756() => Assert.Equal(1, configureOrder++), 757() => Assert.Equal(2, configureOrder++), 758() => Assert.Equal(5, configureOrder++))); 760() => Assert.Equal(0, configureOrder++), 761() => Assert.Equal(3, configureOrder++), 762() => Assert.Equal(4, configureOrder++))); 767Assert.Equal(6, configureOrder); 932Assert.Equal(1, CountStartup.ConfigureCount); 933Assert.Equal(1, CountStartup.ConfigureServicesCount);

HtmlContentBuilderTest.cs (20)

22Assert.Equal(1, content.Count); 70Assert.Equal(1, content.Count); 88Assert.Equal(2, content.Count); 92entry => Assert.Equal("Test", entry)); 107Assert.Equal(0, content.Count); 126Assert.Equal(2, source.Count); 127Assert.Equal(3, destination.Count); 131entry => Assert.Equal(new TestHtmlContent("hello"), Assert.IsType<TestHtmlContent>(entry)), 153Assert.Equal(2, source.Count); 154Assert.Equal(1, nested.Count); 155Assert.Equal(3, destination.Count); 159entry => Assert.Equal(new TestHtmlContent("hello"), Assert.IsType<TestHtmlContent>(entry)), 178Assert.Equal(0, source.Count); 179Assert.Equal(3, destination.Count); 183entry => Assert.Equal(new TestHtmlContent("hello"), Assert.IsType<TestHtmlContent>(entry)), 205Assert.Equal(0, source.Count); 206Assert.Equal(0, nested.Count); 207Assert.Equal(3, destination.Count); 211entry => Assert.Equal(new TestHtmlContent("hello"), Assert.IsType<TestHtmlContent>(entry)), 228Assert.Equal(2, content.Count);

CookieBuilderTests.cs (7)

25Assert.Equal(secure, options.Secure); 35Assert.Equal(now.AddHours(1), options.Expires); 45Assert.Equal(now, options.MaxAge); 62Assert.Equal(2, options.Extensions.Count); 67Assert.Equal("name", cookie.Name); 68Assert.Equal("value", cookie.Value); 69Assert.Equal(2, cookie.Extensions.Count);

EndpointFilterInvocationContextOfTTests.cs (3)

56Assert.Equal(4, enumeratedCount); 67Assert.Equal(2, context.IndexOf(42)); 68Assert.Equal(-1, context.IndexOf(21));

EndpointHttpContextExtensionsTests.cs (6)

55Assert.Equal(initial, endpoint); 84Assert.Equal(endpoint, context.GetEndpoint()); 105Assert.Equal(initialFeature, feature); 106Assert.Equal(endpoint, context.GetEndpoint()); 126Assert.Equal(initialFeature, feature); 142Assert.Equal(initialEndpoint, endpoint);

EndpointMetadataCollectionTests.cs (9)

22Assert.Equal(3, metadata.Count); 25value => Assert.Equal(1, value), 26value => Assert.Equal(2, value), 27value => Assert.Equal(3, value)); 37Assert.Equal(3, metadata.Count); 40value => Assert.Equal(1, value), 41value => Assert.Equal(2, value), 42value => Assert.Equal(3, value)); 68Assert.Equal(new string[] { "1", "2" }, ordered1);

FragmentStringTests.cs (2)

12Assert.Equal(default(FragmentString), FragmentString.Empty); 13Assert.Equal(default(FragmentString), FragmentString.Empty);

HostStringTest.cs (4)

60Assert.Equal(expectedPort, result); 94Assert.Equal(expectedPort, port); 101Assert.Equal(default(HostString), new HostString(string.Empty)); 102Assert.Equal(default(HostString), new HostString(string.Empty));

HttpProtocolTests.cs (5)

24Assert.Equal(match, HttpProtocol.IsHttp3(protocol)); 43Assert.Equal(match, HttpProtocol.IsHttp2(protocol)); 62Assert.Equal(match, HttpProtocol.IsHttp11(protocol)); 81Assert.Equal(match, HttpProtocol.IsHttp10(protocol)); 100Assert.Equal(match, HttpProtocol.IsHttp09(protocol));

HttpResponseWritingExtensionsTests.cs (6)

16Assert.Equal(11, context.Response.Body.Length); 26Assert.Equal(22, context.Response.Body.Length); 46Assert.Equal(expected.Length, length); 47Assert.Equal(expected, actual); 67Assert.Equal(expected.Length, length); 68Assert.Equal(expected, actualShortened);

HttpValidationProblemDetailsJsonConverterTest.cs (10)

37Assert.Equal(problemDetails.Status, document.RootElement.GetProperty("status").GetInt32()); 68Assert.Equal(status, problemDetails.Status); 83Assert.Equal(new[] { "error0" }, kvp.Value); 88Assert.Equal(new[] { "error1", "error2" }, kvp.Value); 111Assert.Equal(status, problemDetails.Status); 124Assert.Equal(new[] { "error0" }, kvp.Value); 129Assert.Equal(new[] { "error1", "error2" }, kvp.Value); 150Assert.Equal(status, problemDetails.Status); 163Assert.Equal(new[] { "error0" }, kvp.Value); 168Assert.Equal(new[] { "error1", "error2" }, kvp.Value);

MapPathMiddlewareTests.cs (12)

MapPredicateMiddlewareTests.cs (4)

68Assert.Equal(200, context.Response.StatusCode); 80Assert.Equal(200, context.Response.StatusCode); 93Assert.Equal(200, context.Response.StatusCode); 110Assert.Equal(200, context.Response.StatusCode);

PathStringTests.cs (13)

ProblemDetailsContextTests.cs (1)

22Assert.Equal(problemDetails, context.ProblemDetails);

ProblemDetailsJsonConverterTest.cs (4)

52Assert.Equal(status, problemDetails.Status); 83Assert.Equal(status, problemDetails.Status); 115Assert.Equal(status, problemDetails.Status); 147Assert.Equal(status, problemDetails.Status);

QueryStringTests.cs (2)

134Assert.Equal(default(QueryString), QueryString.Empty); 135Assert.Equal(default(QueryString), QueryString.Empty);

RouteValueDictionaryTests.cs (101)

UseWhenExtensionsTests.cs (8)

48Assert.Equal(1, Count(context, "parent")); 49Assert.Equal(1, Count(context, "child")); 50Assert.Equal(1, Count(context, "grandchild")); 76Assert.Equal(0, Count(context, "parent")); 77Assert.Equal(0, Count(context, "child")); 78Assert.Equal(1, Count(context, "grandchild")); 99Assert.Equal(1, Count(context, "parent")); 100Assert.Equal(0, Count(context, "child"));

HttpConnectionDispatcherTests.cs (70)

HttpConnectionManagerTests.cs (4)

27Assert.Equal(TimeSpan.FromSeconds(10), options.TransportSendTimeout); 28Assert.Equal(65536, options.TransportMaxBufferSize); 29Assert.Equal(65536, options.ApplicationMaxBufferSize); 30Assert.Equal(HttpTransports.All, options.Transports);

Internal\HttpConnectionsEventSourceTests.cs (10)

24Assert.Equal(Guid.Parse("c26fe4b6-8790-5d41-5900-0f2b6b74efaa", CultureInfo.InvariantCulture), eventSource.Guid); 42Assert.Equal(expectedEventId, eventData.EventId); 44Assert.Equal(EventLevel.Informational, eventData.Level); 50Assert.Equal("1", arg); 69Assert.Equal(expectedEventId, eventData.EventId); 71Assert.Equal(EventLevel.Informational, eventData.Level); 77Assert.Equal("1", arg); 96Assert.Equal(expectedEventId, eventData.EventId); 98Assert.Equal(EventLevel.Informational, eventData.Level); 104Assert.Equal("1", arg);

LongPollingTests.cs (6)

36Assert.Equal(204, context.Response.StatusCode); 56Assert.Equal(0, context.Response.ContentLength); 57Assert.Equal(200, context.Response.StatusCode); 80Assert.Equal(200, context.Response.StatusCode); 106Assert.Equal(200, context.Response.StatusCode); 117Assert.Equal(options.LongPolling.PollTimeout, TimeSpan.FromSeconds(90));

MapConnectionHandlerTests.cs (25)

53Assert.Equal(2, policies.Count); 54Assert.Equal(policy1, policies[0]); 55Assert.Equal(1, policies[1].Requirements.Count); 56Assert.Equal(req, policies[1].Requirements.First()); 63Assert.Equal(2, policies.Count); 64Assert.Equal(policy1, policies[0]); 65Assert.Equal(1, policies[1].Requirements.Count); 66Assert.Equal(req, policies[1].Requirements.First()); 70Assert.Equal(0, authCount); 97Assert.Equal(0, authCount); 124Assert.Equal(0, authCount); 143Assert.Equal(2, endpoint.Metadata.GetOrderedMetadata<IAuthorizeData>().Count); 148Assert.Equal(2, endpoint.Metadata.GetOrderedMetadata<IAuthorizeData>().Count); 152Assert.Equal(0, authCount); 174Assert.Equal(2, endpoint.Metadata.GetOrderedMetadata<IAuthorizeData>().Count); 179Assert.Equal(2, endpoint.Metadata.GetOrderedMetadata<IAuthorizeData>().Count); 183Assert.Equal(0, authCount); 212Assert.Equal(0, authCount); 233Assert.Equal(2, endpoint.Metadata.GetOrderedMetadata<IAuthorizeData>().Count); 238Assert.Equal(2, endpoint.Metadata.GetOrderedMetadata<IAuthorizeData>().Count); 242Assert.Equal(0, authCount); 343Assert.Equal(HttpTransportType.ServerSentEvents, optionsMetaData.Transports); 344Assert.Equal(2, optionsMetaData.ApplicationMaxBufferSize); 390Assert.Equal(new[] { "protocol1", "protocol2" }, subprotocols.ToArray()); 406Assert.Equal(WebSocketMessageType.Close, result.MessageType);

NegotiateProtocolTests.cs (2)

35Assert.Equal(availableTransports?.Length, response.AvailableTransports?.Count); 38Assert.Equal(version, response.Version);

WebSocketsTests.cs (12)

67Assert.Equal(WebSocketCloseStatus.NormalClosure, clientSummary.CloseResult.CloseStatus); 103Assert.Equal(1, clientSummary.Received.Count); 105Assert.Equal((WebSocketMessageType)Enum.Parse(typeof(WebSocketMessageType), expectedMessageType), clientSummary.Received[0].MessageType); 190Assert.Equal(WebSocketCloseStatus.InternalServerError, clientSummary.CloseResult.CloseStatus); 227Assert.Equal(WebSocketState.Aborted, serverSocket.State); 263Assert.Equal(WebSocketState.Aborted, serverSocket.State); 302Assert.Equal(WebSocketCloseStatus.NormalClosure, serverSocket.CloseStatus); 341Assert.Equal(WebSocketCloseStatus.NormalClosure, serverSocket.CloseStatus); 365Assert.Equal(providedSubProtocols, protocols.ToArray()); 415Assert.Equal(2, messages.Received.Count); 419Assert.Equal(1, messages.Received[0].Buffer[0]); 424Assert.Equal(15, messages.Received[1].Buffer[0]);

HeaderDictionaryTypeExtensionsTest.cs (14)

HttpRequestJsonExtensionsTests.cs (13)

31Assert.Equal(hasJsonContentType, request.HasJsonContentType()); 76Assert.Equal(1, result); 96i => Assert.Equal(1, i), 97i => Assert.Equal(2, i)); 114i => Assert.Equal(1, i), 115i => Assert.Equal(2, i)); 179Assert.Equal(1, result); 228i => Assert.Equal(1, i), 229i => Assert.Equal(2, i)); 250i => Assert.Equal(1, i), 251i => Assert.Equal(2, i)); 273i => Assert.Equal(1, i), 274i => Assert.Equal(2, i));

HttpResponseJsonExtensionsTests.cs (12)

ParameterBindingMethodCacheTests.cs (30)

37Assert.Equal(4, parameters.Length); 38Assert.Equal(typeof(string), parameters[0].ParameterType); 39Assert.Equal(typeof(NumberStyles), parameters[1].ParameterType); 40Assert.Equal(typeof(IFormatProvider), parameters[2].ParameterType); 55Assert.Equal(3, parameters.Length); 56Assert.Equal(typeof(string), parameters[0].ParameterType); 57Assert.Equal(typeof(UriKind), parameters[1].ParameterType); 79Assert.Equal(3, parameters.Length); 80Assert.Equal(typeof(string), parameters[0].ParameterType); 81Assert.Equal(typeof(IFormatProvider), parameters[1].ParameterType); 86Assert.Equal(4, parameters.Length); 87Assert.Equal(typeof(string), parameters[0].ParameterType); 88Assert.Equal(typeof(IFormatProvider), parameters[1].ParameterType); 89Assert.Equal(typeof(DateTimeStyles), parameters[2].ParameterType); 109Assert.Equal(3, parameters.Length); 110Assert.Equal(typeof(string), parameters[0].ParameterType); 111Assert.Equal(typeof(IFormatProvider), parameters[1].ParameterType); 133Assert.Equal(2, parameters.Length); 134Assert.Equal(typeof(string), parameters[0].ParameterType); 190Assert.Equal(2, parameters.Length); 191Assert.Equal(typeof(string), parameters[0].ParameterType); 207Assert.Equal(typeof(bool), block!.Type); 213Assert.Equal(Choice.One, parseEnum("One")); 214Assert.Equal(Choice.Two, parseEnum("Two")); 215Assert.Equal(Choice.Three, parseEnum("Three")); 246Assert.Equal(new BindAsyncRecord(42), await parseHttpContext(httpContext)); 277Assert.Equal(new BindAsyncSingleArgStruct(42), await parseHttpContext(httpContext)); 464Assert.Equal(BindAsyncSource.InterfaceStaticAbstractImplicit, ((BindAsyncFromStaticAbstractInterfaceAndBindAsync)result).BoundFrom); 1079Assert.Equal(typeof(BindAsyncRecord), parameter.ParameterType); 1095Assert.Equal(typeof(BindAsyncStruct), parameter.ParameterType);

ProblemDetailsDefaultWriterTest.cs (16)

ProblemDetailsServiceCollectionExtensionsTest.cs (1)

234Assert.Equal(3, jsonOptions.Value.SerializerOptions.TypeInfoResolverChain.Count);

PropertyAsParameterInfoTests.cs (2)

19Assert.Equal(propertyInfo.PropertyType, parameterInfo.ParameterType); 32Assert.Equal(propertyInfo.PropertyType, parameterInfo.ParameterType);

RequestDelegateFactoryTests.cs (52)

RequestDelegateFactoryTests.FormMapping.cs (6)

201Assert.Equal(StatusCodes.Status200OK, httpContext.Response.StatusCode); 202Assert.Equal(1, capturedTodo.Id); 234Assert.Equal(StatusCodes.Status200OK, httpContext.Response.StatusCode); 304Assert.Equal(formFiles["file"], capturedArgument.File); 305Assert.Equal(formFiles.GetFiles("formFiles"), capturedArgument.FormFiles); 306Assert.Equal(formFiles, capturedArgument.FormFileCollection);

RequestDelegateGenerator\CompileTimeCreationTests.cs (12)

200Assert.Equal(DiagnosticSeverity.Warning, diagnostic.Severity); 250Assert.Equal(DiagnosticSeverity.Warning, diagnostic.Severity); 304Assert.Equal(DiagnosticSeverity.Warning, diagnostic.Severity); 350Assert.Equal(DiagnosticSeverity.Warning, diagnostic.Severity); 384Assert.Equal(400, httpContext.Response.StatusCode); 559Assert.Equal(400, httpContext1.Response.StatusCode); 562Assert.Equal(LogLevel.Debug, log1.LogLevel); 563Assert.Equal(new EventId(5, "ImplicitBodyNotProvided"), log1.EventId); 567Assert.Equal(400, httpContext2.Response.StatusCode); 570Assert.Equal(LogLevel.Debug, log2.LogLevel); 571Assert.Equal(new EventId(5, "ImplicitBodyNotProvided"), log2.EventId); 757Assert.Equal(DiagnosticSeverity.Warning, diagnostic.Severity);

RequestDelegateGenerator\CompileTimeIncrementalityTests.cs (8)

RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (3)

248Assert.Equal(expectedStatusCode, httpContext.Response.StatusCode); 258Assert.Equal(expectedStatusCode, httpContext.Response.StatusCode); 265Assert.Equal(expectedStatusCode, httpContext.Response.StatusCode);

RequestDelegateGenerator\RequestDelegateCreationTests.Arrays.cs (4)

179Assert.Equal(expectedParameterValue, httpContext.Items["tryParsable"]); 515Assert.Equal(new[] { 1, 2, 3 }, (int[])httpContext.Items["query"]!); 516Assert.Equal(new[] { 4, 5, 6 }, (int[])httpContext.Items["headers"]!); 517Assert.Equal(new[] { 7, 8, 9 }, (int[])httpContext.Items["form"]!);

RequestDelegateGenerator\RequestDelegateCreationTests.AsParameters.cs (21)

32Assert.Equal(originalRouteParam, httpContext.Items["input"]); 72Assert.Equal(originalQueryParam, httpContext.Items["input"]); 73Assert.Equal(originalCustomQueryParam, httpContext.Items["customInput"]); 74Assert.Equal(originalAnotherCustomQueryParam, httpContext.Items["anotherCustomInput"]); 100Assert.Equal(originalHeaderParam, httpContext.Items["input"]); 204Assert.Equal(originalRouteParam, httpContext.Items["input"]); 225Assert.Equal(expectedValue, httpContext.Items["input"]); 288Assert.Equal(expectedInput.Value, input.Value); 289Assert.Equal(expectedInput.ConstantValue, input.ConstantValue); 290Assert.Equal(expectedInput.ReadOnlyValue, input.ReadOnlyValue); 291Assert.Equal(expectedInput.PrivateSetValue, input.PrivateSetValue); 318Assert.Equal(foo, httpContext.Items["foo"]); 319Assert.Equal(bar, httpContext.Items["bar"]); 387Assert.Equal(400, httpContext.Response.StatusCode); 391Assert.Equal(3, logs.Length); 393Assert.Equal(new EventId(4, "RequiredParameterNotProvided"), logs[0].EventId); 394Assert.Equal(LogLevel.Debug, logs[0].LogLevel); 397Assert.Equal(new EventId(4, "RequiredParameterNotProvided"), logs[1].EventId); 398Assert.Equal(LogLevel.Debug, logs[1].LogLevel); 401Assert.Equal(new EventId(4, "RequiredParameterNotProvided"), logs[2].EventId); 402Assert.Equal(LogLevel.Debug, logs[2].LogLevel);

RequestDelegateGenerator\RequestDelegateCreationTests.BindAsync.cs (10)

60Assert.Equal(new Uri("https://example.org"), httpContext.Items["uri"]); 61Assert.Equal(200, httpContext.Response.StatusCode); 81Assert.Equal(new Uri("https://example.org"), httpContext.Items["uri"]); 82Assert.Equal(200, httpContext.Response.StatusCode); 111Assert.Equal(200, httpContext.Response.StatusCode); 140Assert.Equal(400, httpContext.Response.StatusCode); 141Assert.Equal(400, httpContext.Response.StatusCode); 143Assert.Equal(LogLevel.Debug, log.LogLevel); 144Assert.Equal(new EventId(4, "RequiredParameterNotProvided"), log.EventId); 172Assert.Equal(BindAsyncUriTypesAndOptionalitySupport.Length * 2, endpoints.Length);

RequestDelegateGenerator\RequestDelegateCreationTests.cs (16)

157Assert.Equal(3, endpoints.Length); 310Assert.Equal(3, endpoints.Length); 439Assert.Equal(42, httpContext.Items["id"]); 440Assert.Equal(200, httpContext.Response.StatusCode); 465Assert.Equal(42, httpContext.Items["id"]); 466Assert.Equal(200, httpContext.Response.StatusCode); 488Assert.Equal(400, httpContext.Response.StatusCode); 512Assert.Equal(42, httpContext.Items["id"]); 513Assert.Equal(200, httpContext.Response.StatusCode); 537Assert.Equal(42, httpContext.Items["id"]); 538Assert.Equal(200, httpContext.Response.StatusCode); 562Assert.Equal(42, httpContext.Items["id"]); 563Assert.Equal(200, httpContext.Response.StatusCode); 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.Filters.cs (1)

152Assert.Equal(2, httpContext.Items["loggerInvoked"]);

RequestDelegateGenerator\RequestDelegateCreationTests.Forms.cs (45)

RequestDelegateGenerator\RequestDelegateCreationTests.JsonBody.cs (24)

RequestDelegateGenerator\RequestDelegateCreationTests.JsonBodyOrService.cs (3)

130Assert.Equal(400, httpContext.Response.StatusCode); 132Assert.Equal(LogLevel.Debug, log.LogLevel); 133Assert.Equal(new EventId(5, "ImplicitBodyNotProvided"), log.EventId);

RequestDelegateGenerator\RequestDelegateCreationTests.KeyServices.cs (1)

143Assert.Equal(StatusCodes.Status200OK, httpContext.Response.StatusCode);

RequestDelegateGenerator\RequestDelegateCreationTests.Logging.cs (92)

RequestDelegateGenerator\RequestDelegateCreationTests.Metadata.cs (9)

34Assert.Equal(200, metadata.StatusCode); 50Assert.Equal(200, metadata.StatusCode); 52Assert.Equal(typeof(Todo), metadata.Type); 80Assert.Equal(200, metadata.StatusCode); 106Assert.Equal(200, metadata.StatusCode); 133Assert.Equal(400, metadata.StatusCode); 164Assert.Equal(24, metadata.Value); 178Assert.Equal(typeof(object), responseMetadata.Type); 530m => Assert.Equal(typeof(CountsDefaultEndpointMetadataPoco), ((IProducesResponseTypeMetadata)m).Type),

RequestDelegateGenerator\RequestDelegateCreationTests.QueryParameters.cs (4)

66Assert.Equal(400, httpContext.Response.StatusCode); 68Assert.Equal(LogLevel.Debug, log.LogLevel); 69Assert.Equal(new EventId(4, "RequiredParameterNotProvided"), log.EventId); 76Assert.Equal(200, httpContext.Response.StatusCode);

RequestDelegateGenerator\RequestDelegateCreationTests.Responses.cs (2)

490Assert.Equal(42, todo.Id); 493Assert.Equal(TodoStatus.Done, todo.Status);

RequestDelegateGenerator\RequestDelegateCreationTests.RouteParameter.cs (2)

208Assert.Equal(400, httpContext.Response.StatusCode); 232Assert.Equal(originalRouteParam, httpContext.Items["input"]);

RequestDelegateGenerator\RequestDelegateCreationTests.SpecialTypes.cs (7)

63Assert.Equal(httpContext.RequestAborted, httpContext.Items["arg"]); 103Assert.Equal(httpContext.Request, httpContext.Items["arg"]); 122Assert.Equal(httpContext.Response, httpContext.Items["arg"]); 251Assert.Equal(expectedValue, httpContext.Items["parameterWithDefault"]); 254Assert.Equal(expectedValue, httpContext.Items["parameterWithConst"]); 283Assert.Equal(2.15m, httpContext.Items["parameterWithDefault"]); 284Assert.Equal(3.15m, httpContext.Items["parameterWithConst"]);

RequestDelegateGenerator\RequestDelegateCreationTests.TryParse.cs (3)

82Assert.Equal(200, httpContext.Response.StatusCode); 83Assert.Equal(expectedParameterValue, httpContext.Items["tryParsable"]); 262Assert.Equal(expectedParameterValue, httpContext.Items["tryParsable"]);

RequestDelegateGenerator\RuntimeCreationTests.ComplexFormBinding.cs (17)

40Assert.Equal(1, todo.Id); 76Assert.Equal(1, todo.Id); 108Assert.Equal(3, elements.Count); 145Assert.Equal(3, elements.Count); 177Assert.Equal(StatusCodes.Status400BadRequest, httpContext.Response.StatusCode); 183Assert.Equal(new EventId(10, "FormMappingFailed"), log.EventId); 184Assert.Equal(LogLevel.Debug, log.LogLevel); 187Assert.Equal("Dictionary<string, bool>", log1Values[0].Value); 188Assert.Equal("elements", log1Values[1].Value); 217Assert.Equal(3, elements.Count); 218Assert.Equal(1, elements[0]); 219Assert.Equal(3, elements[1]); 220Assert.Equal(5, elements[2]); 254Assert.Equal(3, elements.Count); 255Assert.Equal(1, elements[0]); 256Assert.Equal(3, elements[1]); 257Assert.Equal(5, elements[2]);

RequestDelegateGenerator\SharedTypes.cs (1)

204Assert.Equal(typeof(CustomTodo), parameter.ParameterType);

ResponseExtensionTests.cs (3)

20Assert.Equal(200, context.Response.StatusCode); 22Assert.Equal(0, context.Response.Body.Length); 48Assert.Equal(expectedStatusCode, context.Response.StatusCode);

SendFileResponseExtensionsTests.cs (7)

29Assert.Equal(1, fakeFeature.Offset); 30Assert.Equal(3, fakeFeature.Length); 31Assert.Equal(CancellationToken.None, fakeFeature.Token); 44Assert.Equal(3, body.Length); 58Assert.Equal(0, body.Length); 84Assert.Equal(0, body.Length); 99Assert.Equal(token, fakeFeature.Token);

UriHelperTests.cs (8)

143Assert.Equal(host, new HostString(expectedHost)); 144Assert.Equal(path, new PathString(expectedPath)); 145Assert.Equal(query, new QueryString(expectedQuery)); 146Assert.Equal(fragment, new FragmentString(expectedFragment)); 167Assert.Equal(host, resHost); 168Assert.Equal(path, resPath); 169Assert.Equal(query, resQuery); 170Assert.Equal(fragment, resFragment);

src\Http\Http.Extensions\test\RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (3)

248Assert.Equal(expectedStatusCode, httpContext.Response.StatusCode); 258Assert.Equal(expectedStatusCode, httpContext.Response.StatusCode); 265Assert.Equal(expectedStatusCode, httpContext.Response.StatusCode);

src\Http\Http.Extensions\test\RequestDelegateGenerator\SharedTypes.cs (1)

204Assert.Equal(typeof(CustomTodo), parameter.ParameterType);

AcceptedAtRouteOfTResultTests.cs (9)

30Assert.Equal(StatusCodes.Status202Accepted, result.StatusCode); 31Assert.Equal(StatusCodes.Status202Accepted, obj.Status); 32Assert.Equal(obj, result.Value); 98Assert.Equal(StatusCodes.Status202Accepted, httpContext.Response.StatusCode); 100Assert.Equal(new RouteValueDictionary(values), linkGenerator.RouteValuesAddress.ExplicitValues); 134Assert.Equal(StatusCodes.Status202Accepted, producesResponseTypeMetadata.StatusCode); 135Assert.Equal(typeof(Todo), producesResponseTypeMetadata.Type); 170Assert.Equal(StatusCodes.Status202Accepted, result.StatusCode); 187Assert.Equal(value, result.Value);

AcceptedAtRouteResultTests.cs (5)

52Assert.Equal(StatusCodes.Status202Accepted, httpContext.Response.StatusCode); 54Assert.Equal(new RouteValueDictionary(values), linkGenerator.RouteValuesAddress.ExplicitValues); 88Assert.Equal(StatusCodes.Status202Accepted, producesResponseTypeMetadata.StatusCode); 89Assert.Equal(typeof(void), producesResponseTypeMetadata.Type); 116Assert.Equal(StatusCodes.Status202Accepted, result.StatusCode);

AcceptedOfTResultTests.cs (8)

44Assert.Equal(StatusCodes.Status202Accepted, httpContext.Response.StatusCode); 57Assert.Equal(StatusCodes.Status202Accepted, result.StatusCode); 58Assert.Equal(StatusCodes.Status202Accepted, obj.Status); 59Assert.Equal(obj, result.Value); 75Assert.Equal(StatusCodes.Status202Accepted, producesResponseTypeMetadata.StatusCode); 76Assert.Equal(typeof(Todo), producesResponseTypeMetadata.Type); 104Assert.Equal(StatusCodes.Status202Accepted, result.StatusCode); 116Assert.Equal(value, result.Value);

AcceptedResultTests.cs (4)

28Assert.Equal(StatusCodes.Status202Accepted, httpContext.Response.StatusCode); 45Assert.Equal(StatusCodes.Status202Accepted, producesResponseTypeMetadata.StatusCode); 46Assert.Equal(typeof(void), producesResponseTypeMetadata.Type); 73Assert.Equal(StatusCodes.Status202Accepted, result.StatusCode);

BadRequestOfTResultTests.cs (13)

BadRequestResultTests.cs (5)

25Assert.Equal(StatusCodes.Status400BadRequest, badRequestResult.StatusCode); 42Assert.Equal(StatusCodes.Status400BadRequest, httpContext.Response.StatusCode); 58Assert.Equal(StatusCodes.Status400BadRequest, producesResponseTypeMetadata.StatusCode); 59Assert.Equal(typeof(void), producesResponseTypeMetadata.Type); 86Assert.Equal(StatusCodes.Status400BadRequest, result.StatusCode);

ConflictOfTResultTests.cs (10)

27Assert.Equal(StatusCodes.Status409Conflict, conflictObjectResult.StatusCode); 28Assert.Equal(obj, conflictObjectResult.Value); 39Assert.Equal(StatusCodes.Status409Conflict, conflictObjectResult.StatusCode); 40Assert.Equal(StatusCodes.Status409Conflict, obj.Status); 41Assert.Equal(obj, conflictObjectResult.Value); 58Assert.Equal(StatusCodes.Status409Conflict, httpContext.Response.StatusCode); 96Assert.Equal(StatusCodes.Status409Conflict, producesResponseTypeMetadata.StatusCode); 97Assert.Equal(typeof(Todo), producesResponseTypeMetadata.Type); 125Assert.Equal(StatusCodes.Status409Conflict, result.StatusCode); 137Assert.Equal(value, result.Value);

ConflictResultTests.cs (5)

26Assert.Equal(StatusCodes.Status409Conflict, conflictObjectResult.StatusCode); 43Assert.Equal(StatusCodes.Status409Conflict, httpContext.Response.StatusCode); 59Assert.Equal(StatusCodes.Status409Conflict, producesResponseTypeMetadata.StatusCode); 60Assert.Equal(typeof(void), producesResponseTypeMetadata.Type); 87Assert.Equal(StatusCodes.Status409Conflict, result.StatusCode);

ContentResultTests.cs (3)

122Assert.Equal(expectedContentData, memoryStream.ToArray()); 123Assert.Equal(expectedContentData.Length, httpContext.Response.ContentLength); 156Assert.Equal(StatusCodes.Status202Accepted, result.StatusCode);

CreatedAtRouteOfTResultTests.cs (9)

31Assert.Equal(StatusCodes.Status201Created, result.StatusCode); 32Assert.Equal(StatusCodes.Status201Created, obj.Status); 33Assert.Equal(obj, result.Value); 68Assert.Equal(StatusCodes.Status201Created, httpContext.Response.StatusCode); 70Assert.Equal(new RouteValueDictionary(values), linkGenerator.RouteValuesAddress.ExplicitValues); 104Assert.Equal(StatusCodes.Status201Created, producesResponseTypeMetadata.StatusCode); 105Assert.Equal(typeof(Todo), producesResponseTypeMetadata.Type); 139Assert.Equal(StatusCodes.Status201Created, result.StatusCode); 155Assert.Equal(value, result.Value);

CreatedAtRouteResultTests.cs (5)

51Assert.Equal(StatusCodes.Status201Created, httpContext.Response.StatusCode); 53Assert.Equal(new RouteValueDictionary(values), linkGenerator.RouteValuesAddress.ExplicitValues); 86Assert.Equal(StatusCodes.Status201Created, producesResponseTypeMetadata.StatusCode); 87Assert.Equal(typeof(void), producesResponseTypeMetadata.Type); 119Assert.Equal(StatusCodes.Status201Created, result.StatusCode);

CreatedOfTResultTests.cs (9)

27Assert.Equal(StatusCodes.Status201Created, result.StatusCode); 28Assert.Equal(StatusCodes.Status201Created, obj.Status); 29Assert.Equal(obj, result.Value); 57Assert.Equal(StatusCodes.Status201Created, httpContext.Response.StatusCode); 74Assert.Equal(StatusCodes.Status201Created, httpContext.Response.StatusCode); 110Assert.Equal(StatusCodes.Status201Created, producesResponseTypeMetadata.StatusCode); 111Assert.Equal(typeof(Todo), producesResponseTypeMetadata.Type); 142Assert.Equal(StatusCodes.Status201Created, result.StatusCode); 155Assert.Equal(value, result.Value);

CreatedResultTests.cs (5)

42Assert.Equal(StatusCodes.Status201Created, httpContext.Response.StatusCode); 59Assert.Equal(StatusCodes.Status201Created, httpContext.Response.StatusCode); 76Assert.Equal(StatusCodes.Status201Created, producesResponseTypeMetadata.StatusCode); 77Assert.Equal(typeof(void), producesResponseTypeMetadata.Type); 107Assert.Equal(StatusCodes.Status201Created, result.StatusCode);

EmptyResultTests.cs (2)

22Assert.Equal(StatusCodes.Status200OK, httpContext.Response.StatusCode); 23Assert.Equal(0, memoryStream.Length);

HttpFileStreamResultTests.cs (4)

39Assert.Equal(stream, result.FileStream); 54Assert.Equal(stream, result.FileStream); 76Assert.Equal(lastModified, result.LastModified); 77Assert.Equal(entityTag, result.EntityTag);

HttpResultsHelperTests.cs (4)

202Assert.Equal(3, body.Length); 205Assert.Equal(1, one.Id); 210Assert.Equal(2, two.Id); 215Assert.Equal(3, three.Id);

InternalServerErrorOfTResultTests.cs (13)

InternalServerErrorResultTests.cs (5)

25Assert.Equal(StatusCodes.Status500InternalServerError, internalServerErrorResult.StatusCode); 42Assert.Equal(StatusCodes.Status500InternalServerError, httpContext.Response.StatusCode); 58Assert.Equal(StatusCodes.Status500InternalServerError, producesResponseTypeMetadata.StatusCode); 59Assert.Equal(typeof(void), producesResponseTypeMetadata.Type); 86Assert.Equal(StatusCodes.Status500InternalServerError, result.StatusCode);

JsonResultTests.cs (16)

LocalRedirectResultTests.cs (1)

73Assert.Equal(StatusCodes.Status302Found, httpContext.Response.StatusCode);

NoContentResultTests.cs (5)

24Assert.Equal(StatusCodes.Status204NoContent, result.StatusCode); 39Assert.Equal(StatusCodes.Status204NoContent, httpContext.Response.StatusCode); 55Assert.Equal(StatusCodes.Status204NoContent, producesResponseTypeMetadata.StatusCode); 56Assert.Equal(typeof(void), producesResponseTypeMetadata.Type); 83Assert.Equal(StatusCodes.Status204NoContent, result.StatusCode);

NotFoundOfTResultTests.cs (10)

25Assert.Equal(StatusCodes.Status404NotFound, result.StatusCode); 26Assert.Equal(StatusCodes.Status404NotFound, obj.Status); 27Assert.Equal(obj, result.Value); 37Assert.Equal(StatusCodes.Status404NotFound, notFound.StatusCode); 47Assert.Equal(StatusCodes.Status404NotFound, notFound.StatusCode); 62Assert.Equal(StatusCodes.Status404NotFound, httpContext.Response.StatusCode); 78Assert.Equal(StatusCodes.Status404NotFound, producesResponseTypeMetadata.StatusCode); 79Assert.Equal(typeof(Todo), producesResponseTypeMetadata.Type); 107Assert.Equal(StatusCodes.Status404NotFound, result.StatusCode); 119Assert.Equal(value, result.Value);

NotFoundResultTests.cs (5)

24Assert.Equal(StatusCodes.Status404NotFound, notFound.StatusCode); 38Assert.Equal(StatusCodes.Status404NotFound, httpContext.Response.StatusCode); 54Assert.Equal(StatusCodes.Status404NotFound, producesResponseTypeMetadata.StatusCode); 55Assert.Equal(typeof(void), producesResponseTypeMetadata.Type); 82Assert.Equal(StatusCodes.Status404NotFound, result.StatusCode);

OkOfTResultTests.cs (9)

26Assert.Equal(StatusCodes.Status200OK, result.StatusCode); 38Assert.Equal(StatusCodes.Status200OK, result.StatusCode); 39Assert.Equal(StatusCodes.Status200OK, obj.Status); 40Assert.Equal(obj, result.Value); 79Assert.Equal(StatusCodes.Status200OK, httpContext.Response.StatusCode); 95Assert.Equal(StatusCodes.Status200OK, producesResponseTypeMetadata.StatusCode); 96Assert.Equal(typeof(Todo), producesResponseTypeMetadata.Type); 124Assert.Equal(StatusCodes.Status200OK, result.StatusCode); 136Assert.Equal(value, result.Value);

OkResultTests.cs (5)

24Assert.Equal(StatusCodes.Status200OK, result.StatusCode); 41Assert.Equal(StatusCodes.Status200OK, httpContext.Response.StatusCode); 57Assert.Equal(StatusCodes.Status200OK, producesResponseTypeMetadata.StatusCode); 58Assert.Equal(typeof(void), producesResponseTypeMetadata.Type); 85Assert.Equal(StatusCodes.Status200OK, result.StatusCode);

ProblemResultTests.cs (17)

PushStreamResultTests.cs (2)

65Assert.Equal(lastModified, result.LastModified); 66Assert.Equal(entityTag, result.EntityTag);

RedirectToRouteResultTests.cs (2)

65Assert.Equal(expectedStatusCode, httpContext.Response.StatusCode); 83Assert.Equal(expectedStatusCode, httpContext.Response.StatusCode);

ResultsOfTTests.Generated.cs (45)

ResultsTests.cs (137)

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

src\Shared\ResultsTests\FileStreamResultTestBase.cs (15)

src\Shared\ResultsTests\PhysicalFileResultTestBase.cs (27)

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

35Assert.Equal(StatusCodes.Status302Found, httpContext.Response.StatusCode); 58Assert.Equal(StatusCodes.Status302Found, httpContext.Response.StatusCode);

src\Shared\ResultsTests\VirtualFileResultTestBase.cs (23)

StatusCodeResultTests.cs (2)

24Assert.Equal(StatusCodes.Status404NotFound, httpContext.Response.StatusCode); 43Assert.Equal(StatusCodes.Status406NotAcceptable, result.StatusCode);

TypedResultsTests.cs (109)

UnauthorizedResultTests.cs (3)

19Assert.Equal(StatusCodes.Status401Unauthorized, result.StatusCode); 34Assert.Equal(StatusCodes.Status401Unauthorized, httpContext.Response.StatusCode); 53Assert.Equal(StatusCodes.Status401Unauthorized, result.StatusCode);

UnprocessableEntityOfTResultTests.cs (10)

26Assert.Equal(StatusCodes.Status422UnprocessableEntity, result.StatusCode); 27Assert.Equal(StatusCodes.Status422UnprocessableEntity, obj.Status); 28Assert.Equal(obj, result.Value); 39Assert.Equal(StatusCodes.Status422UnprocessableEntity, result.StatusCode); 40Assert.Equal(obj, result.Value); 57Assert.Equal(StatusCodes.Status422UnprocessableEntity, httpContext.Response.StatusCode); 95Assert.Equal(StatusCodes.Status422UnprocessableEntity, producesResponseTypeMetadata.StatusCode); 96Assert.Equal(typeof(Todo), producesResponseTypeMetadata.Type); 124Assert.Equal(StatusCodes.Status422UnprocessableEntity, result.StatusCode); 136Assert.Equal(value, result.Value);

UnprocessableEntityResultTests.cs (5)

25Assert.Equal(StatusCodes.Status422UnprocessableEntity, result.StatusCode); 42Assert.Equal(StatusCodes.Status422UnprocessableEntity, httpContext.Response.StatusCode); 58Assert.Equal(StatusCodes.Status422UnprocessableEntity, producesResponseTypeMetadata.StatusCode); 59Assert.Equal(typeof(void), producesResponseTypeMetadata.Type); 86Assert.Equal(StatusCodes.Status422UnprocessableEntity, result.StatusCode);

Utf8ContentResultTests.cs (4)

27Assert.Equal(401, result.StatusCode); 44Assert.Equal(data.Length, context.Response.ContentLength); 62Assert.Equal(data.Length, context.Response.ContentLength); 85Assert.Equal(StatusCodes.Status202Accepted, result.StatusCode);

ValidationProblemResultTests.cs (8)

39Assert.Equal(StatusCodes.Status400BadRequest, httpContext.Response.StatusCode); 40Assert.Equal(details, result.ProblemDetails); 45Assert.Equal(StatusCodes.Status400BadRequest, responseDetails.Status); 74Assert.Equal(StatusCodes.Status400BadRequest, producesResponseTypeMetadata.StatusCode); 75Assert.Equal(typeof(HttpValidationProblemDetails), producesResponseTypeMetadata.Type); 103Assert.Equal(StatusCodes.Status400BadRequest, result.StatusCode); 115Assert.Equal(value, result.Value); 127Assert.Equal(value, result.Value);

ApplicationBuilderTests.cs (5)

22Assert.Equal(404, httpContext.Response.StatusCode); 39Assert.Equal(200, httpContext.Response.StatusCode); 100Assert.Equal(404, httpContext.Response.StatusCode); 123Assert.Equal(StatusCodes.Status204NoContent, httpContext.Response.StatusCode); 165Assert.Equal("value1", builder1.Properties["test"]);

BindingAddressTests.cs (3)

67Assert.Equal(port, serverAddress.Port); 86Assert.Equal(port, serverAddress.Port); 104Assert.Equal(port, serverAddress.Port);

CookieOptionsTests.cs (2)

46Assert.Equal(property.GetValue(original), property.GetValue(copy)); 57Assert.Equal(original.Extensions.Count, copy.Extensions.Count);

DefaultHttpContextTests.cs (4)

42Assert.Equal(3, context.Session.Keys.Count()); 161Assert.Equal(4, features.Count()); 181Assert.Equal(4, newFeatures.Count()); 349Assert.Equal(boxedExpectedStruct, boxedActualStruct);

Features\FormFeatureTests.cs (19)

Features\QueryFeatureTests.cs (7)

36Assert.Equal(2, queryCollection.Count); 73Assert.Equal(0, queryCollection.Count); 100Assert.Equal(2, queryCollection.Count); 115Assert.Equal(2, queryCollection.Count); 130Assert.Equal(2, queryCollection.Count); 236Assert.Equal(12, queryCollection.Count); 251Assert.Equal(1, queryCollection.Count);

Features\RequestBodyPipeFeatureTests.cs (3)

60Assert.Equal(2, bufferLengths.Count); 61Assert.Equal(0, bufferLengths[0]); 62Assert.Equal(4096, bufferLengths[1]);

Features\StreamResponseBodyFeatureTests.cs (2)

19Assert.Equal(1, streamResponseBodyFeature.StartCalled); 34Assert.Equal(1, streamResponseBodyFeature.StartCalled);

HeaderDictionaryTests.cs (4)

34Assert.Equal(new[] { "Value1" }, headers["header1"].ToArray()); 65Assert.Equal(new[] { "Value1", "Value2" }, result); 84Assert.Equal(new[] { "Value1" }, headers["header1"].ToArray()); 113Assert.Equal(new[] { "value " }, result);

HttpServiceCollectionExtensionsTests.cs (2)

21Assert.Equal(ServiceLifetime.Singleton, descriptor.Lifetime); 22Assert.Equal(typeof(HttpContextAccessor), descriptor.ImplementationType);

Internal\DefaultHttpRequestTests.cs (11)

24Assert.Equal(value, request.ContentLength); 140Assert.Equal(QueryString.Empty, request.QueryString); 143Assert.Equal(0, query0.Count); 148Assert.Equal(2, query1.Count); 160Assert.Equal(new QueryString("?name2=value2"), request.QueryString); 179Assert.Equal(cookies0, cookies1); 180Assert.Equal(2, cookies1.Count); 211Assert.Equal("setvalue", request.RouteValues["new"]); 220Assert.Equal("value", request.RouteValues["key"]); 223Assert.Equal(routeValuesFeature.RouteValues, request.RouteValues); 235Assert.Equal(customRouteValuesFeature.RouteValues, request.RouteValues);

Internal\DefaultHttpResponseTests.cs (1)

22Assert.Equal(value, response.ContentLength);

ResponseCookiesTest.cs (2)

138Assert.Equal(testCookies.Length, deletedCookies.Length); 169Assert.Equal(2, deletedCookies.Length);

Timeouts\RequestTimeoutOptionsTests.cs (3)

17Assert.Equal(TimeSpan.FromSeconds(47), policy.Timeout); 32Assert.Equal(TimeSpan.FromSeconds(47), policy.Timeout); 42Assert.Equal(TimeSpan.FromSeconds(47), options.Policies["policy1"].Timeout);

Timeouts\RequestTimeoutsMiddlewareTests.cs (25)

FileLoggerProcessorTests.cs (9)

191Assert.Equal(4, actualFiles.Length); 236Assert.Equal(0, testSink.Writes.Count); 242Assert.Equal(10000, new DirectoryInfo(path) 251Assert.Equal(0, testSink2.Writes.Count); 314Assert.Equal(6, actualFiles1.Length); 338Assert.Equal(5, actualFiles2.Length); 398Assert.Equal(3, actualFiles.Length); 464Assert.Equal(2, actualFiles.Length); 534Assert.Equal(2, actualFiles.Length);

HttpLoggingEndpointConventionBuilderTests.cs (3)

32Assert.Equal(requestBodyLogLimit, metadata.RequestBodyLogLimit); 33Assert.Equal(responseBodyLogLimit, metadata.ResponseBodyLogLimit); 34Assert.Equal(loggingFields, metadata.LoggingFields);

HttpLoggingMiddlewareTests.cs (10)

416Assert.Equal(15, count); 452Assert.Equal(63000, count); 582Assert.Equal(1000, count); 621Assert.Equal(2000, count); 659Assert.Equal(1000, count); 698Assert.Equal(4000, count); 1293Assert.Equal(lines.Length, i); 1454Assert.Equal(1, writeCount); 1566Assert.Equal(lines.Length, i); 1606Assert.Equal(lines.Length, i);

W3CLoggingMiddlewareTests.cs (1)

266Assert.Equal(19, lines[3].Split(' ').Length);

CertificateForwardingTest.cs (3)

59Assert.Equal(context.Connection.ClientCertificate, Certificates.SelfSignedValidWithNoEku); 98Assert.Equal(context.Connection.ClientCertificate, Certificates.SelfSignedValidWithNoEku); 136Assert.Equal(context.Connection.ClientCertificate, Certificates.SelfSignedValidWithNoEku);

ForwardedHeadersMiddlewareTest.cs (10)

44Assert.Equal(9090, context.Connection.RemotePort); 82Assert.Equal(expectedPort, context.Connection.RemotePort); 140Assert.Equal(expectedPort, context.Connection.RemotePort); 180Assert.Equal(1234, context.Connection.RemotePort); 188Assert.Equal(99, context.Connection.RemotePort); 251Assert.Equal(expectedPort, context.Connection.RemotePort); 890Assert.Equal(1, options.ForwardLimit); 962Assert.Equal(PathString.Empty, context.Request.PathBase); 1238Assert.Equal(PathString.Empty, context.Request.PathBase); 1285Assert.Equal(PathString.Empty, context.Request.PathBase);

IPNetworkTest.cs (3)

58Assert.Equal(prefixLength, network.PrefixLength); 87Assert.Equal(expectedPrefixLength, network.PrefixLength); 120Assert.Equal(expectedPrefixLength, network.PrefixLength);

HstsMiddlewareTests.cs (13)

HttpsPolicyTests.cs (1)

69Assert.Equal(statusCode, (int)response.StatusCode);

HttpsRedirectionMiddlewareTests.cs (16)

CustomPocoTest.cs (6)

43Assert.Equal(user, db.Users.Single(u => u.UserName == newName)); 65Assert.Equal(user, db.Users.Single(u => u.UserName == newName)); 85Assert.Equal(user, fetch); 106Assert.Equal(user, fetch); 128Assert.Equal(user, db.Users.Single(u => u.UserName == newName)); 150Assert.Equal(user, db.Set<User<int>>().Single(u => u.UserName == newName));

SqlStoreOnlyUsersTestBase.cs (12)

SqlStoreTestBase.cs (12)

UserStoreEncryptPersonalDataTest.cs (4)

84Assert.Equal(user, await manager.FindByEmailAsync("hao@hao.com")); 85Assert.Equal(user, await manager.FindByLoginAsync(login.LoginProvider, login.ProviderKey)); 93Assert.Equal(user, await manager.FindByEmailAsync("hao@hao.com")); 94Assert.Equal(user, await manager.FindByLoginAsync(login.LoginProvider, login.ProviderKey));

UserStoreWithGenericsTest.cs (12)

Extensions\ResponseAssert.cs (3)

17Assert.Equal(HttpStatusCode.Redirect, responseMessage.StatusCode); 23Assert.Equal(HttpStatusCode.OK, response.StatusCode); 56Assert.Equal(HttpStatusCode.OK, download.StatusCode);

LoginTests.cs (3)

251Assert.Equal(2, emailSender.SentEmails.Count); 351Assert.Equal(2, emailSender.SentEmails.Count); 381Assert.Equal(2, emailSender.SentEmails.Count);

ManagementTests.cs (4)

75Assert.Equal(2, emails.SentEmails.Count); 102Assert.Equal(2, emails.SentEmails.Count); 312Assert.Equal(twoFactor, (bool)jsonData["TwoFactorEnabled"]); 346Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);

MapIdentityApiTests.cs (25)

122Assert.Equal(3600, expiresIn); 154Assert.Equal(3600, expiresIn); 186Assert.Equal(expireTimeSpan.TotalSeconds, expiresIn); 556Assert.Equal(2, emailSender.Emails.Count); 748Assert.Equal(10, recoveryCodes.Length); 845Assert.Equal(10, enable2faContent.GetProperty("recoveryCodesLeft").GetInt32()); 846Assert.Equal(10, recoveryCodes.Length); 867Assert.Equal(8, updated2faContent.GetProperty("recoveryCodesLeft").GetInt32()); 876Assert.Equal(10, resetRecoveryContent.GetProperty("recoveryCodesLeft").GetInt32()); 877Assert.Equal(10, resetRecoveryCodes.Length); 972Assert.Equal(2, emailSender.Emails.Count); 980Assert.Equal(3, emailSender.Emails.Count); 1075Assert.Equal(2, emailSender.Emails.Count); 1160Assert.Equal(2, emailSender.Emails.Count); 1363Assert.Equal(2, confirmationMatch.Groups.Count); 1375Assert.Equal(2, confirmationMatch.Groups.Count); 1425Assert.Equal(HttpStatusCode.OK, response.StatusCode); 1430Assert.Equal(HttpStatusCode.OK, response.StatusCode); 1431Assert.Equal(0, response.Content.Headers.ContentLength); 1436Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 1437Assert.Equal(0, response.Content.Headers.ContentLength); 1442Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); 1443Assert.Equal(0, response.Content.Headers.ContentLength); 1448Assert.Equal(status, response.StatusCode); 1458Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);

NoIdentityAddedTests.cs (1)

34Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);

FunctionalTest.cs (19)

IdentitySpecificationTestBase.cs (16)

190Assert.Equal(2, result.Errors.Count()); 247Assert.Equal(3, roleClaims.Count); 248Assert.Equal(3, safeRoleClaims.Count); 252Assert.Equal(2, roleClaims.Count); 253Assert.Equal(3, safeRoleClaims.Count); 257Assert.Equal(1, roleClaims.Count); 258Assert.Equal(3, safeRoleClaims.Count); 262Assert.Equal(0, roleClaims.Count); 263Assert.Equal(3, safeRoleClaims.Count); 277Assert.Equal(role, await manager.FindByIdAsync(await manager.GetRoleIdAsync(role))); 293Assert.Equal(role, await manager.FindByNameAsync(roleName)); 312Assert.Equal(role, await manager.FindByNameAsync("Changed")); 331Assert.Equal(roles.Count, manager.Roles.Count(func)); 409Assert.Equal(roles.Count, rs.Count); 592Assert.Equal(3, (await manager.GetUsersInRoleAsync(await roleManager.GetRoleNameAsync(role))).Count); 595Assert.Equal(0, (await manager.GetUsersInRoleAsync("123456")).Count);

UserManagerSpecificationTests.cs (39)

Base32Test.cs (1)

33Assert.Equal(20, output.Length);

IdentityBuilderTest.cs (1)

247Assert.Equal(4, tokenProviders.Count());

IdentityOptionsTest.cs (6)

18Assert.Equal(TimeSpan.FromMinutes(5), options.Lockout.DefaultLockoutTimeSpan); 19Assert.Equal(5, options.Lockout.MaxFailedAccessAttempts); 25Assert.Equal(6, options.Password.RequiredLength); 26Assert.Equal(1, options.Password.RequiredUniqueChars); 53Assert.Equal(1, myOptions.Password.RequiredUniqueChars); 54Assert.Equal(-1, myOptions.Password.RequiredLength);

PasswordHasherTest.cs (5)

60Assert.Equal(PasswordVerificationResult.Success, successResult); 64Assert.Equal(PasswordVerificationResult.Failed, failedResult); 124Assert.Equal(PasswordVerificationResult.Failed, result); 143Assert.Equal(PasswordVerificationResult.Success, result); 165Assert.Equal(expectedResult, actualResult);

RoleManagerTest.cs (2)

72Assert.Equal(role, result); 90Assert.Equal(role, result);

SecurityStampValidatorTest.cs (3)

315Assert.Equal(now, context.Properties.IssuedUtc); 316Assert.Equal(now + TimeSpan.FromDays(1), context.Properties.ExpiresUtc); 355Assert.Equal(validationSuccess, context.Principal != null);

SignInManagerTest.cs (5)

336Assert.Equal(bypass, result.Succeeded); 337Assert.Equal(!bypass, result.RequiresTwoFactor); 503Assert.Equal(expected, result); 958Assert.Equal(confirmed, result.Succeeded); 1012Assert.Equal(confirmed, result.Succeeded);

UserClaimsPrincipalFactoryTest.cs (6)

99Assert.Equal(supportsUserEmail, claims.Any(c => c.Type == manager.Options.ClaimsIdentity.EmailClaimType && c.Value == user.Email)); 100Assert.Equal(supportRoles, claims.Any(c => c.Type == manager.Options.ClaimsIdentity.RoleClaimType && c.Value == "Admin")); 101Assert.Equal(supportRoles, claims.Any(c => c.Type == manager.Options.ClaimsIdentity.RoleClaimType && c.Value == "Local")); 104Assert.Equal(supportClaims, claims.Any(c => c.Type == cl.Type && c.Value == cl.Value)); 108Assert.Equal(supportRoleClaims, claims.Any(c => c.Type == cl.Type && c.Value == cl.Value)); 112Assert.Equal(supportRoleClaims, claims.Any(c => c.Type == cl.Type && c.Value == cl.Value));

UserManagerTest.cs (7)

216Assert.Equal(user, result); 234Assert.Equal(user, result); 252Assert.Equal(user, result); 270Assert.Equal(user, result); 288Assert.Equal(user, result); 312Assert.Equal(user, result); 330Assert.Equal(user, result);

ExceptionAssertions.cs (1)

212Assert.Equal(actualValue, ex.ActualValue);

Tracing\EventAssert.cs (3)

38public EventAssert Payload(string name, object expectedValue) => Payload(name, actualValue => Assert.Equal(expectedValue, actualValue)); 50Assert.Equal(_expectedId, evt.EventId); 52Assert.Equal(_expectedLevel, evt.Level);

AspNetTestAssemblyRunnerTest.cs (22)

53Assert.Equal(0, runSummary.Failed); 54Assert.Equal(0, runSummary.Skipped); 55Assert.Equal(1, runSummary.Total); 60Assert.Equal(NotCalled, fixture.ReportTestFailureCalledAt); 61Assert.Equal(0, fixture.DisposeCalledAt); 74Assert.Equal(1, runSummary.Failed); 75Assert.Equal(0, runSummary.Skipped); 76Assert.Equal(1, runSummary.Total); 81Assert.Equal(0, fixture.ReportTestFailureCalledAt); 82Assert.Equal(1, fixture.DisposeCalledAt); 93Assert.Equal(0, runSummary.Failed); 94Assert.Equal(0, runSummary.Skipped); 95Assert.Equal(1, runSummary.Total); 100Assert.Equal(0, fixture.InitializeAsyncCalledAt); 101Assert.Equal(NotCalled, fixture.ReportTestFailureCalledAt); 102Assert.Equal(1, fixture.AsyncDisposeCalledAt); 115Assert.Equal(1, runSummary.Failed); 116Assert.Equal(0, runSummary.Skipped); 117Assert.Equal(1, runSummary.Total); 122Assert.Equal(0, fixture.InitializeAsyncCalledAt); 123Assert.Equal(1, fixture.ReportTestFailureCalledAt); 124Assert.Equal(2, fixture.AsyncDisposeCalledAt);

AssemblyFixtureTest.cs (4)

28Assert.Equal(0, AssemblyFixture.Count); 31Assert.Equal(0, CollectionFixture.Count); 40Assert.Equal(1, AssemblyFixture.Count); 41Assert.Equal(1, CollectionFixture.Count);

ConditionalTheoryTest.cs (1)

132Assert.Equal(1, skippable.Data);

LoggedTestXunitTests.cs (6)

74Assert.Equal(LogLevel.Information, message.LogLevel); 85Assert.Equal(LogLevel.Debug, message.LogLevel); 98Assert.Equal(LogLevel.Information, message.LogLevel); 140Assert.Equal(TestSink.Writes.Single(), context); 149Assert.Equal(TestSink.Scopes.Single(), context); 161Assert.Equal(LogLevel.Trace, message.LogLevel);

RepeatTest.cs (4)

17Assert.Equal(5, RepeatContext.Current.Limit); 24Assert.Equal(RepeatContext.Current.CurrentIteration, _runCount); 31Assert.Equal(10, RepeatContext.Current.Limit); 40Assert.Equal(1, RepeatContext.Current.Limit);

ReplaceCultureAttributeTest.cs (8)

22Assert.Equal(culture, replaceCulture.Culture); 23Assert.Equal(uiCulture, replaceCulture.UICulture); 37Assert.Equal(new CultureInfo(culture), replaceCulture.Culture); 38Assert.Equal(new CultureInfo(uiCulture), replaceCulture.UICulture); 55Assert.Equal(new CultureInfo(culture), CultureInfo.CurrentCulture); 56Assert.Equal(new CultureInfo(uiCulture), CultureInfo.CurrentUICulture); 62Assert.Equal(originalCulture, CultureInfo.CurrentCulture); 63Assert.Equal(originalUICulture, CultureInfo.CurrentUICulture);

XunitLoggerProviderTest.cs (1)

79Assert.Equal(0, testTestOutputHelper.Output.Length);

Adapters\AdapterFactoryTests.cs (4)

28Assert.Equal(typeof(ListAdapter), adapter.GetType()); 41Assert.Equal(typeof(DictionaryAdapter<string, string>), adapter.GetType()); 57Assert.Equal(typeof(PocoAdapter), adapter.GetType()); 70Assert.Equal(typeof(DynamicObjectAdapter), adapter.GetType());

CustomNamingStrategyTests.cs (1)

112Assert.Equal(0, valueFromDictionary);

IntegrationTests\DictionaryIntegrationTest.cs (20)

IntegrationTests\ListIntegrationTest.cs (15)

72Assert.Equal(new List<int>() { 4, 1, 2, 3 }, targetObject.SimpleObject.IntegerIList); 123Assert.Equal(new List<int>() { 1, 2, 3, 4 }, targetObject.SimpleObject.IntegerList); 142Assert.Equal(new List<int>() { 1, 2 }, targetObject.IntegerList); 188Assert.Equal(new List<int>() { 1, 2 }, targetObject.SimpleObject.IntegerList); 207Assert.Equal(new List<int>() { 4, 5, 6 }, targetObject.IntegerList); 229Assert.Equal(new List<int>() { 1, 2, 5 }, targetObject.SimpleObject.IntegerList); 270Assert.Equal(new List<int>() { 1, 2, 3, 1 }, targetObject.IntegerList); 289Assert.Equal(1, targetObject.IntegerValue); 309Assert.Equal(0, targetObject.IntegerValue); 310Assert.Equal(new List<int>() { 1, 2, 3, 5 }, targetObject.IntegerList); 336Assert.Equal(new List<SimpleObject>() { simpleObject2, simpleObject1, simpleObject3 }, targetObject.SimpleObjectList); 337Assert.Equal(2, targetObject.SimpleObjectList[0].IntegerValue); 338Assert.Equal(1, targetObject.SimpleObjectList[1].IntegerValue); 362Assert.Equal(new List<int>() { 2, 3 }, targetObject.SimpleObject.IntegerList); 363Assert.Equal(1, targetObject.IntegerValue);

IntegrationTests\NestedObjectIntegrationTest.cs (3)

253Assert.Equal(typeof(InheritedObject), targetObject.SimpleObject.GetType()); 296Assert.Equal(2, targetObject.SimpleObject.AnotherIntegerValue); 297Assert.Equal(0, targetObject.SimpleObject.IntegerValue);

IntegrationTests\SimpleObjectIntegrationTest.cs (5)

86Assert.Equal(2, targetObject.AnotherIntegerValue); 87Assert.Equal(0, targetObject.IntegerValue); 106Assert.Equal(0, targetObject.DecimalValue); 126Assert.Equal(newGuid, targetObject.GuidValue); 146Assert.Equal(newGuid, targetObject.GuidValue);

Internal\DictionaryAdapterTest.cs (8)

34Assert.Equal(200, dictionary[key]); 54Assert.Equal("James", dictionary[intKey]); 73Assert.Equal("James", dictionary[key]); 101Assert.Equal("James", dictionary[nameKey]); 128Assert.Equal("James", dictionary[nameKey]); 156Assert.Equal("James", dictionary[nameKey]); 176Assert.Equal("James", dictionary[guidKey]); 195Assert.Equal(5, dictionary[guidKey]);

Internal\ListAdapterTest.cs (17)

63Assert.Equal(3, targetObject.Count); 64Assert.Equal(new List<string>() { "James", "Mike", "Rob" }, targetObject); 136Assert.Equal(expected.Count, targetObject.Count); 137Assert.Equal(expected, targetObject); 154Assert.Equal(3, targetObject.Count); 155Assert.Equal(new List<string>() { "James", "Mike", null }, targetObject); 174Assert.Equal(2, targetObject.Count); 175Assert.Equal(new List<SimpleObject>() { sDto, iDto }, targetObject); 242Assert.Equal(expected.Count, targetObject.Count); 243Assert.Equal(expected, targetObject); 297Assert.Equal(expected.Count, targetObject.Count); 298Assert.Equal(expected, targetObject); 336Assert.Equal(expected, value); 337Assert.Equal(new List<int>(input), targetObject); 375Assert.Equal(new List<int>(expected), targetObject); 408Assert.Equal(new List<int>() { 10, 30 }, targetObject); 444Assert.Equal(expected, targetObject);

Internal\ObjectVisitorTest.cs (1)

90Assert.Equal(typeof(DictionaryAdapter<string, string>), adapter.GetType());

Internal\ParsedPathTests.cs (1)

25Assert.Equal(expected, parsedPath.Segments);

Internal\PocoAdapterTest.cs (2)

73Assert.Equal("Joana", value); 176Assert.Equal(25, model.Age);

JsonPatchDocumentJObjectTest.cs (2)

141Assert.Equal(JTokenType.Null, model.CustomData["Name"].Type); 173Assert.Equal(JTokenType.Null, model.CustomData["Email"].Type);

OperationBaseTests.cs (2)

24Assert.Equal(operationType, operationBase.OperationType); 38Assert.Equal(operationType, operationBase.OperationType);

LocalizationSampleTest.cs (1)

40Assert.Equal(HttpStatusCode.OK, response.StatusCode);

LocalizationTest.cs (1)

117Assert.Equal(HttpStatusCode.OK, response.StatusCode);

RouteDataRequestCultureProviderTest.cs (3)

86Assert.Equal(HttpStatusCode.OK, response.StatusCode); 132Assert.Equal(HttpStatusCode.OK, response.StatusCode); 208Assert.Equal(HttpStatusCode.OK, response.StatusCode);

AcceptLanguageHeaderRequestCultureProviderTest.cs (3)

52Assert.Equal(3, count); 133Assert.Equal(3, count); 179Assert.Equal(3, count);

CookieRequestCultureProviderTest.cs (2)

224Assert.Equal(LogLevel.Debug, write.LogLevel); 283Assert.Equal(LogLevel.Debug, write.LogLevel);

RequestLocalizationOptionsTest.cs (8)

28Assert.Equal(CultureInfo.CurrentCulture, options.DefaultRequestCulture.Culture); 29Assert.Equal(CultureInfo.CurrentUICulture, options.DefaultRequestCulture.UICulture); 44Assert.Equal(explicitCulture, options.DefaultRequestCulture.Culture); 45Assert.Equal(explicitCulture, options.DefaultRequestCulture.UICulture); 65Assert.Collection(options.SupportedCultures, item => Assert.Equal(CultureInfo.CurrentCulture, item)); 66Assert.Collection(options.SupportedUICultures, item => Assert.Equal(CultureInfo.CurrentUICulture, item)); 81Assert.Collection(options.SupportedCultures, item => Assert.Equal(explicitCulture, item)); 82Assert.Collection(options.SupportedUICultures, item => Assert.Equal(explicitCulture, item));

MiddlewareAnalysisTests.cs (3)

49Assert.Equal(2, listener.MiddlewareStarting.Count); 52Assert.Equal(1, listener.MiddlewareException.Count); 55Assert.Equal(1, listener.MiddlewareFinished.Count);

ModelBinding\BindingInfoTest.cs (4)

62Assert.Equal(EmptyBodyBehavior.Allow, bindingInfo.EmptyBodyBehavior); 140Assert.Equal(EmptyBodyBehavior.Disallow, bindingInfo.EmptyBodyBehavior); 266Assert.Equal(EmptyBodyBehavior.Allow, bindingInfo.EmptyBodyBehavior); 288Assert.Equal(EmptyBodyBehavior.Default, bindingInfo.EmptyBodyBehavior);

ModelBinding\ModelMetadataTest.cs (5)

160Assert.Equal(expected, modelMetadata.IsNullableValueType); 179Assert.Equal(expected, modelMetadata.IsReferenceOrNullableType); 198Assert.Equal(expected, modelMetadata.UnderlyingOrModelType); 239Assert.Equal(expected, elementType); 274Assert.Equal(typeof(string), metadata.ContainerType);

ModelBinding\ModelStateDictionaryTest.cs (96)

ModelBinding\ValueProviderResultTest.cs (12)

17Assert.Equal(0, result.Length); 20Assert.Equal(ValueProviderResult.None, result); 32Assert.Equal(0, result.Length); 35Assert.Equal(ValueProviderResult.None, result); 47Assert.Equal(0, result.Length); 50Assert.Equal(ValueProviderResult.None, result); 51Assert.Equal(ValueProviderResult.None, new ValueProviderResult(new StringValues())); 63Assert.Equal(1, result.Length); 68Assert.Equal(new string[] { "Hi There" }, (string[])result); 78Assert.Equal(2, result.Length); 83Assert.Equal(new string[] { "Hi", "There" }, (string[])result); 179Assert.Equal(expected, result);

ApiResponseTypeProviderTest.cs (73)

DefaultApiDescriptionProviderTest.cs (140)

EndpointMetadataApiDescriptionProviderTest.cs (139)

AcceptedAtActionResultTests.cs (3)

70Assert.Equal(expectedRouteValuesCount, result.RouteValues.Count); 102Assert.Equal(StatusCodes.Status202Accepted, result.StatusCode); 167Assert.Equal(StatusCodes.Status202Accepted, httpContext.Response.StatusCode);

AcceptedAtRouteResultTests.cs (2)

43Assert.Equal(StatusCodes.Status202Accepted, result.StatusCode); 118Assert.Equal(StatusCodes.Status202Accepted, httpContext.Response.StatusCode);

AcceptedResultTests.cs (3)

39Assert.Equal(StatusCodes.Status202Accepted, result.StatusCode); 80Assert.Equal(StatusCodes.Status202Accepted, httpContext.Response.StatusCode); 99Assert.Equal(StatusCodes.Status202Accepted, httpContext.Response.StatusCode);

ActionResultOfTTest.cs (6)

73Assert.Equal(typeof(BaseItem), objectResult.DeclaredType); 74Assert.Equal(StatusCodes.Status200OK, objectResult.StatusCode); 91Assert.Equal(typeof(ProblemDetails), objectResult.DeclaredType); 92Assert.Equal(StatusCodes.Status400BadRequest, objectResult.StatusCode); 109Assert.Equal(typeof(BaseItem), objectResult.DeclaredType); 110Assert.Equal(StatusCodes.Status200OK, objectResult.StatusCode);

ApiExplorer\ApiConventionMatcherTest.cs (6)

440Assert.Equal(expected, result); 455Assert.Equal(expected, result); 475Assert.Equal(expected, result); 490Assert.Equal(expected, result); 505Assert.Equal(expected, result); 525Assert.Equal(expected, result);

ApiExplorer\ApiConventionResultTest.cs (17)

ApplicationModels\ActionModelTest.cs (4)

108Assert.Equal(value1, value2); 115Assert.Equal(value1, value2); 123Assert.Equal(value1, value2); 131Assert.Equal(value1, value2);

ApplicationModels\ApiBehaviorApplicationModelProviderTest.cs (3)

78Assert.Equal(BindingSource.Body, parameterModel.BindingInfo.BindingSource); 121Assert.Equal(BindingSource.Body, parameterModel.BindingInfo.BindingSource); 142Assert.Equal(typeof(ProblemDetails), convention.DefaultErrorResponseType.Type);

ApplicationModels\ApiConventionApplicationModelConventionTest.cs (5)

78Assert.Equal(expected, attribute.Type); 94Assert.Equal(expected, attribute.Type); 112Assert.Equal(expected, attribute.Type); 131Assert.Equal(expected, attribute.Type); 147Assert.Equal(expected, attribute.Type);

ApplicationModels\AttributeRouteModelTests.cs (3)

41Assert.Equal(value1, value2); 216Assert.Equal(expected, combined.Order); 262Assert.Equal(combined.Order, right.Order);

ApplicationModels\AuthorizationApplicationModelProviderTest.cs (1)

99Assert.Equal(3, authorizeFilters.First().Policy.Requirements.Count()); // Basic + Basic2 + Derived authorize

ApplicationModels\ControllerActionDescriptorBuilderTest.cs (6)

54Assert.Equal(propertyInfo, property.PropertyInfo); 55Assert.Equal(typeof(string), property.ParameterType); 56Assert.Equal(BindingSource.Query, property.BindingInfo.BindingSource); 81Assert.Equal("application", descriptors.Single().Properties["test"]); 107Assert.Equal("controller", descriptors.Single().Properties["test"]); 134Assert.Equal("action", descriptors.Single().Properties["test"]);

ApplicationModels\ControllerActionDescriptorProviderTests.cs (56)

66Assert.Equal(3, descriptor.FilterDescriptors.Count); 70Assert.Equal(FilterScope.Global, filter1.Scope); 73Assert.Equal(2, Assert.IsType<MyFilterAttribute>(filter2.Filter).Value); 74Assert.Equal(FilterScope.Controller, filter2.Scope); 77Assert.Equal(3, Assert.IsType<MyFilterAttribute>(filter3.Filter).Value); 78Assert.Equal(FilterScope.Action, filter3.Scope); 131Assert.Equal(typeof(int), id.ParameterType); 150Assert.Equal(typeof(int), id.ParameterType); 155Assert.Equal(entity.BindingInfo.BindingSource, BindingSource.Body); 156Assert.Equal(typeof(TestActionParameter), entity.ParameterType); 175Assert.Equal(typeof(int), id.ParameterType); 181Assert.Equal(typeof(int), upperCaseId.ParameterType); 187Assert.Equal(typeof(int), pascalCaseId.ParameterType); 207Assert.Equal(entity.BindingInfo.BindingSource, BindingSource.Body); 208Assert.Equal(typeof(TestActionParameter), entity.ParameterType); 229Assert.Equal(typeof(TestActionParameter), entity.ParameterType); 259Assert.Equal(2, descriptors.Count()); 369Assert.Equal(2, descriptors.Length); 371Assert.Equal(3, descriptorWithValue.RouteValues.Count); 388Assert.Equal(2, descriptorWithoutValue.RouteValues.Count); 454Assert.Equal(4, actions.Count()); 479Assert.Equal(2, actions.Count()); 531Assert.Equal(4, actions.Count()); 542Assert.Equal(4, constrainedActions.Count()); 547Assert.Equal(2, putActions.Count()); 554Assert.Equal(2, routeActions.Count()); 570Assert.Equal(6, actions.Count()); 581Assert.Equal(4, constrainedActions.Count()); 586Assert.Equal(2, postActions.Count()); 593Assert.Equal(2, putActions.Count()); 599Assert.Equal(2, unconstrainedActions.Count()); 640Assert.Equal(5, actions.Count()); 812Assert.Equal(2, getActions.Count()); 840Assert.Equal(2, getActions.Count()); 899Assert.Equal(4, actionDescriptors.Count()); 903Assert.Equal(3, indexAction.RouteValues.Count); 968Assert.Equal(2, actions.Count()); 1048Assert.Equal(2, actions.Count()); 1133.Callback(() => { Assert.Equal(0, sequence++); }); 1138.Callback(() => { Assert.Equal(1, sequence++); }); 1143.Callback(() => { Assert.Equal(2, sequence++); }); 1148.Callback(() => { Assert.Equal(3, sequence++); }); 1175Assert.Equal(4, sequence); 1188Assert.Equal(2, actions.Count()); 1192Assert.Equal(2, action.ActionConstraints.Count); 1198Assert.Equal(2, action.ActionConstraints.Count); 1214Assert.Equal(2, actions.Count()); 1217Assert.Equal(3, action.ActionConstraints.Count); 1223Assert.Equal(3, action.ActionConstraints.Count); 1241Assert.Equal(4, actions.Count()); 1244Assert.Equal(3, action.ActionConstraints.Count); 1250Assert.Equal(3, action.ActionConstraints.Count); 1256Assert.Equal(3, action.ActionConstraints.Count); 1262Assert.Equal(3, action.ActionConstraints.Count); 1283Assert.Equal(2, action.ActionConstraints.Count); 1436Assert.Equal(expectedLines.Length, actualLines.Length);

ApplicationModels\ControllerModelTest.cs (4)

110Assert.Equal(value1, value2); 117Assert.Equal(value1, value2); 125Assert.Equal(value1, value2); 133Assert.Equal(value1, value2);

ApplicationModels\DefaultApplicationModelProviderTest.cs (26)

ApplicationModels\InferParameterBindingInfoConventionTest.cs (5)

130Assert.Equal(EmptyBodyBehavior.Default, bindingInfo.EmptyBodyBehavior); 139Assert.Equal(BindingSource.Special, bindingInfo.BindingSource); 164Assert.Equal(EmptyBodyBehavior.Default, bindingInfo.EmptyBodyBehavior); 190Assert.Equal(EmptyBodyBehavior.Allow, bindingInfo.EmptyBodyBehavior); 216Assert.Equal(EmptyBodyBehavior.Allow, bindingInfo.EmptyBodyBehavior);

ApplicationModels\ParameterModelTest.cs (3)

51Assert.Equal(value1, value2); 59Assert.Equal(value1, value2); 67Assert.Equal(value1, value2);

ApplicationModels\PropertyModelTest.cs (2)

47Assert.Equal(value1, value2); 55Assert.Equal(value1, value2);

ApplicationParts\ApplicationPartManagerTest.cs (2)

34Assert.Equal(expectedResults, feature.Values.ToArray()); 55Assert.Equal(expectedResults, feature.Values.ToArray());

ApplicationParts\AssemblyPartTest.cs (1)

44Assert.Equal(part.Assembly, assembly);

ApplicationParts\RelatedAssemblyPartTest.cs (1)

77Assert.Equal(new[] { relatedAssembly }, result);

Authorization\AuthorizeFilterTest.cs (7)

113Assert.Equal(1, getPolicyCount); 117Assert.Equal(2, getPolicyCount); 121Assert.Equal(3, getPolicyCount); 299Assert.Equal(2, testProvider1.GetPolicyCalls); 300Assert.Equal(1, testProvider2.GetPolicyCalls); 307Assert.Equal(4, testProvider1.GetPolicyCalls); 308Assert.Equal(2, testProvider2.GetPolicyCalls);

BadRequestObjectResultTests.cs (3)

19Assert.Equal(StatusCodes.Status400BadRequest, badRequestObjectResult.StatusCode); 20Assert.Equal(obj, badRequestObjectResult.Value); 30Assert.Equal(StatusCodes.Status400BadRequest, badRequestObjectResult.StatusCode);

BadRequestResultTests.cs (1)

17Assert.Equal(StatusCodes.Status400BadRequest, badRequest.StatusCode);

BindAttributeTest.cs (1)

36Assert.Equal(isIncluded, propertyFilter(context.ModelMetadata));

Builder\MvcAreaRouteBuilderExtensionsTest.cs (11)

41Assert.Equal("admin", kvp.Value); 76Assert.Equal("Home", kvp.Value); 81Assert.Equal("admin", kvp.Value); 122Assert.Equal("Home", kvp.Value); 127Assert.Equal("admin", kvp.Value); 168Assert.Equal("hello", kvp.Value); 175Assert.Equal("Home", kvp.Value); 180Assert.Equal("admin", kvp.Value); 216Assert.Equal("hello", kvp.Value); 223Assert.Equal("Home", kvp.Value); 265Assert.Equal(kvp.Value, areaName);

ConflictObjectResultTest.cs (3)

19Assert.Equal(StatusCodes.Status409Conflict, conflictObjectResult.StatusCode); 20Assert.Equal(obj, conflictObjectResult.Value); 30Assert.Equal(StatusCodes.Status409Conflict, conflictObjectResult.StatusCode);

ConflictResultTest.cs (1)

17Assert.Equal(StatusCodes.Status409Conflict, conflictResult.StatusCode);

ContentResultTest.cs (2)

139Assert.Equal(expectedContentData, memoryStream.ToArray()); 140Assert.Equal(expectedContentData.Length, httpContext.Response.ContentLength);

ControllerBaseTest.cs (85)

Controllers\ControllerBinderDelegateProviderTest.cs (12)

271Assert.Equal(value, arguments["foo"]); 649Assert.Equal(new List<string> { "goodbye" }, controller.CollectionProperty); 688Assert.Equal(expected, controller.CollectionProperty); 731Assert.Equal(-1, controller.NonNullableProperty); 834Assert.Equal(-1, controller.NullableProperty); 981Assert.Equal(expectedValue, propertyAccessor(controller)); 1056Assert.Equal(new string[] { "goodbye" }, controller.ArrayProperty); // Skipped 1057Assert.Equal(new List<string> { "hello", "world" }, controller.CollectionProperty); 1058Assert.Equal(new Person { Name = "Ginger" }, controller.NonCollectionProperty); // Skipped 1193Assert.Equal(10, accountId); 1197Assert.Equal(40, transferInfo.AccountId); 1198Assert.Equal(250.0, transferInfo.Amount);

Controllers\ControllerFeatureProviderTest.cs (11)

CreatedAtActionResultTests.cs (1)

40Assert.Equal(StatusCodes.Status201Created, httpContext.Response.StatusCode);

CreatedAtRouteResultTests.cs (1)

54Assert.Equal(StatusCodes.Status201Created, httpContext.Response.StatusCode);

CreatedResultTests.cs (4)

25Assert.Equal(StatusCodes.Status201Created, result.StatusCode); 74Assert.Equal(StatusCodes.Status201Created, httpContext.Response.StatusCode); 90Assert.Equal(StatusCodes.Status201Created, httpContext.Response.StatusCode); 108Assert.Equal(StatusCodes.Status201Created, httpContext.Response.StatusCode);

DependencyInjection\ApiBehaviorOptionsSetupTest.cs (7)

27Assert.Equal(expected, options.ClientErrorMapping.Keys); 45Assert.Equal(400, problemDetails.Status); 67Assert.Equal(400, problemDetails.Status); 87Assert.Equal(422, objectResult.StatusCode); 91Assert.Equal(422, problemDetails.Status); 110Assert.Equal(Activity.Current.Id, problemDetails.Extensions["traceId"]); 127Assert.Equal("42", problemDetails.Extensions["traceId"]);

DependencyInjection\ApplicationModelConventionExtensionsTest.cs (14)

DependencyInjection\MvcBuilderExtensionsTest.cs (12)

33Assert.Equal(assembly, assemblyPart.Assembly); 97Assert.Equal(3, services.Count); 98Assert.Equal(typeof(ControllerTypeA), services[0].ServiceType); 99Assert.Equal(typeof(ControllerTypeA), services[0].ImplementationType); 100Assert.Equal(ServiceLifetime.Transient, services[0].Lifetime); 102Assert.Equal(typeof(TypeBController), services[1].ServiceType); 103Assert.Equal(typeof(TypeBController), services[1].ImplementationType); 104Assert.Equal(ServiceLifetime.Transient, services[1].Lifetime); 106Assert.Equal(typeof(IControllerActivator), services[2].ServiceType); 107Assert.Equal(typeof(ServiceBasedControllerActivator), services[2].ImplementationType); 108Assert.Equal(ServiceLifetime.Transient, services[2].Lifetime); 128Assert.Equal(3, collection.Count);

DependencyInjection\MvcCoreBuilderExtensionsTest.cs (1)

30Assert.Equal(assembly, assemblyPart.Assembly);

FileResultHelperTest.cs (4)

96Assert.Equal(Stream.Null, httpContext.Response.Body); 379Assert.Equal(expected, ifRangeIsValid); 419Assert.Equal(expectedStatusCode, httpContext.Response.StatusCode); 457Assert.Equal(expectedStatusCode, httpContext.Response.StatusCode);

FileStreamResultTest.cs (4)

50Assert.Equal(stream, result.FileStream); 65Assert.Equal(stream, result.FileStream); 87Assert.Equal(lastModified, result.LastModified); 88Assert.Equal(entityTag, result.EntityTag);

Filters\DisableRequestSizeLimitFilterTest.cs (1)

50Assert.Equal(1, httpMaxRequestBodySize.Count);

Filters\FilterCollectionTest.cs (8)

21Assert.Equal(typeof(MyFilter), typeFilter.ImplementationType); 36Assert.Equal(typeof(MyFilter), typeFilter.ImplementationType); 50Assert.Equal(17, Assert.IsAssignableFrom<IOrderedFilter>(added).Order); 63Assert.Equal(17, Assert.IsAssignableFrom<IOrderedFilter>(added).Order); 92Assert.Equal(typeof(MyFilter), serviceFilter.ServiceType); 107Assert.Equal(typeof(MyFilter), serviceFilter.ServiceType); 121Assert.Equal(17, Assert.IsAssignableFrom<IOrderedFilter>(added).Order); 134Assert.Equal(17, Assert.IsAssignableFrom<IOrderedFilter>(added).Order);

Filters\FilterFactoryTest.cs (3)

161Assert.Equal(2, filters.Length); 236Assert.Equal(3, filters.Length); 247Assert.Equal(3, filters.Length);

Filters\FilterProviderTest.cs (4)

36Assert.Equal(0, item.Descriptor.Order); 67Assert.Equal(0, item.Descriptor.Order); 99Assert.Equal(17, item.Descriptor.Order); 131Assert.Equal(0, item.Descriptor.Order);

Filters\MiddlewareFilterAttributeTest.cs (1)

37Assert.Equal(1, configureCallCount);

Filters\MiddlewareFilterBuilderTest.cs (3)

39Assert.Equal(1, configureCount); 64Assert.Equal(1, configureCount); 72Assert.Equal(1, configureCount);

Filters\MiddlewareFilterTest.cs (1)

212Assert.Equal(500, response.StatusCode);

Filters\RequestFormLimitsFilterTest.cs (3)

73Assert.Equal(LogLevel.Warning, write.LogLevel); 98Assert.Equal(LogLevel.Debug, write.LogLevel); 124Assert.Equal(LogLevel.Debug, write.LogLevel);

Filters\RequestSizeLimitFilterTest.cs (3)

30Assert.Equal(12345, httpMaxRequestBodySize.MaxRequestBodySize); 52Assert.Equal(0, httpMaxRequestBodySize.MaxRequestBodySize); 53Assert.Equal(1, httpMaxRequestBodySize.Count);

Filters\ResponseCacheFilterExecutorTest.cs (1)

408Assert.Equal(varyOutput, context.HttpContext.Features.Get<IResponseCachingFeature>().VaryByQueryKeys);

Formatters\FormatterMappingsTest.cs (1)

124Assert.Equal(expected, cleared);

Formatters\InputFormatterTest.cs (1)

429Assert.Equal(expectedIsModelSet, result.IsModelSet);

Formatters\JsonInputFormatterTestBase.cs (6)

47Assert.Equal(expectedCanRead, result); 81Assert.Equal(100, intValue); 229Assert.Equal(expected, dateValue); 251Assert.Equal(30, userModel.Age); 272Assert.Equal(new int[] { 0, 23, 300 }, integers); 463Assert.Equal(expectedIsModelSet, result.IsModelSet);

Formatters\JsonOutputFormatterTestBase.cs (2)

55Assert.Equal(expectedResult != null, actualCanWriteValue); 56Assert.Equal(new StringSegment(expectedContentType), outputFormatterContext.ContentType);

Formatters\MediaTypeTest.cs (17)

Formatters\NoContentFormatterTests.cs (4)

56Assert.Equal(expected, result); 111Assert.Equal(expected, result); 130Assert.Equal(StatusCodes.Status204NoContent, context.HttpContext.Response.StatusCode); 172Assert.Equal(StatusCodes.Status201Created, httpContext.Response.StatusCode);

Formatters\OutputFormatterTests.cs (2)

100Assert.Equal(shouldMatchWildcards, result); 122Assert.Equal(2, contentTypes.Count);

Formatters\StringOutputFormatterTests.cs (5)

57Assert.Equal(expectedContentType, context.ContentType); 76Assert.Equal(new StringSegment("text/plain"), context.ContentType); 103Assert.Equal(expectedContentType, context.ContentType); 125Assert.Equal(expectedContentType, context.ContentType); 151Assert.Equal(0, memoryStream.Length);

Formatters\SystemTextJsonOutputFormatterTest.cs (1)

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

Formatters\TextInputFormatterTest.cs (4)

106Assert.Equal(Encoding.UTF8, result); 132Assert.Equal(Encoding.UTF8, result); 166Assert.Equal(Encoding.ASCII, result); 200Assert.Equal(Encoding.UTF8, result);

Formatters\TextOutputFormatterTests.cs (6)

66Assert.Equal(Encoding.GetEncoding(expectedEncoding), actualEncoding); 92Assert.Equal(new StringSegment(expectedContentType), formatterContext.ContentType); 148Assert.Equal(new StringSegment("application/json; charset=utf-8"), formatterContext.ContentType); 203Assert.Equal(testContentType, context.ContentType); 206Assert.Equal(MediaTypeHeaderValue.Parse(testContentType.Value), context.HttpContext.Response.GetTypedHeaders().ContentType); 231Assert.Equal(StatusCodes.Status406NotAcceptable, context.HttpContext.Response.StatusCode);

HttpActionResultTests.cs (1)

24Assert.Equal(httpResult, result.Result);

HttpNotFoundObjectResultTest.cs (4)

22Assert.Equal(StatusCodes.Status404NotFound, notFound.StatusCode); 32Assert.Equal(StatusCodes.Status404NotFound, notFound.StatusCode); 33Assert.Equal("Test Content", notFound.Value); 52Assert.Equal(StatusCodes.Status404NotFound, httpContext.Response.StatusCode);

HttpNotFoundResultTests.cs (1)

17Assert.Equal(StatusCodes.Status404NotFound, notFound.StatusCode);

HttpOkObjectResultTest.cs (2)

42Assert.Equal(StatusCodes.Status200OK, result.StatusCode); 63Assert.Equal(StatusCodes.Status200OK, httpContext.Response.StatusCode);

HttpOkResultTest.cs (2)

22Assert.Equal(StatusCodes.Status200OK, result.StatusCode); 39Assert.Equal(StatusCodes.Status200OK, context.HttpContext.Response.StatusCode);

HttpStatusCodeResultTests.cs (2)

32Assert.Equal(StatusCodes.Status404NotFound, httpContext.Response.StatusCode); 45Assert.Equal(StatusCodes.Status404NotFound, statusResult?.StatusCode);

HttpUnauthorizedResultTests.cs (1)

17Assert.Equal(StatusCodes.Status401Unauthorized, result.StatusCode);

Infrastructure\ActionMethodExecutorTest.cs (6)

115Assert.Equal(typeof(TestModel), result.DeclaredType); 144Assert.Equal(typeof(TestModel), result.DeclaredType); 173Assert.Equal(typeof(object), result.DeclaredType); 330Assert.Equal(typeof(TestModel), result.DeclaredType); 359Assert.Equal(typeof(object), result.DeclaredType); 413Assert.Equal(typeof(TestModel), result.DeclaredType);

Infrastructure\ActionResultTypeMapperTest.cs (3)

72Assert.Equal(typeof(string), objectResult.DeclaredType); 87Assert.Equal(typeof(string), result); 102Assert.Equal(typeof(string), result);

Infrastructure\ActionSelectorTest.cs (3)

143Assert.Equal(actions.ToArray(), candidates.ToArray()); 266Assert.Equal(expected, candidates); 318Assert.Equal(expected, candidates);

Infrastructure\AsyncEnumerableReaderTest.cs (8)

44Assert.Equal(new[] { "0", "1", "2", }, collection); 62Assert.Equal(new[] { 0, 1, 2, }, collection); 113Assert.Equal(expected, await reader(asyncEnumerable1, default)); 114Assert.Equal(expected, await reader(asyncEnumerable2, default)); 130Assert.Equal(new[] { "0", "1", "2" }, await reader(asyncEnumerable1, default)); 131Assert.Equal(new[] { "0", "1", "2", "3" }, await reader(asyncEnumerable2, default)); 167Assert.Equal(new[] { "0", "1", "2", }, collection); 217Assert.Equal(cts.Token, token);

Infrastructure\ControllerActionInvokerCacheTest.cs (1)

37Assert.Equal(filters, filters2);

Infrastructure\ControllerActionInvokerTest.cs (17)

Infrastructure\DefaultActionDescriptorCollectionProviderTest.cs (5)

33Assert.Equal(0, collection.Version); 56Assert.Equal(0, collection1.Version); 114Assert.Equal(0, collection1.Version); 136Assert.Equal(1, collection2.Version); 153Assert.Equal(2, collection3.Version);

Infrastructure\DefaultApiProblemDetailsWriterTest.cs (8)

47Assert.Equal(expectedProblem.Status, problemDetails.Status); 86Assert.Equal(expectedProblem.Status, problemDetails.Status); 163Assert.Equal(0, stream.Position); 164Assert.Equal(0, stream.Length); 179Assert.Equal(0, stream.Position); 180Assert.Equal(0, stream.Length); 197Assert.Equal(0, stream.Position); 198Assert.Equal(0, stream.Length);

Infrastructure\DefaultOutputFormatterSelectorTest.cs (7)

43Assert.Equal(new StringSegment("application/json"), context.ContentType); 73Assert.Equal(new StringSegment("application/json"), context.ContentType); 173Assert.Equal(new StringSegment(expectedContentType), context.ContentType); 202Assert.Equal(new StringSegment("application/json"), context.ContentType); 232Assert.Equal(new StringSegment("application/xml"), context.ContentType); 329Assert.Equal(new StringSegment("text/custom2"), context.ContentType); 360Assert.Equal(new StringSegment("text/custom"), context.ContentType);

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);

Infrastructure\ObjectResultExecutorTest.cs (2)

109Assert.Equal(406, httpContext.Response.StatusCode); 276Assert.Equal(StatusCodes.Status406NotAcceptable, actionContext.HttpContext.Response.StatusCode);

Infrastructure\ParameterDefaultValuesTest.cs (2)

24Assert.Equal(expectedValues, actualValues); 37Assert.Equal(

Infrastructure\ProblemDetailsFactoryTest.cs (15)

22Assert.Equal(500, problemDetails.Status); 32Assert.Equal("some-trace", kvp.Value); 43Assert.Equal(406, problemDetails.Status); 53Assert.Equal("some-trace", kvp.Value); 66Assert.Equal(406, problemDetails.Status); 76Assert.Equal("some-trace", kvp.Value); 89Assert.Equal(400, problemDetails.Status); 99Assert.Equal("some-trace", kvp.Value); 106Assert.Equal(new[] { "some-value" }, kvp.Value); 119Assert.Equal(422, problemDetails.Status); 129Assert.Equal("some-trace", kvp.Value); 136Assert.Equal(new[] { "some-value" }, kvp.Value); 151Assert.Equal(400, problemDetails.Status); 161Assert.Equal("some-trace", kvp.Value); 168Assert.Equal(new[] { "some-value" }, kvp.Value);

Infrastructure\ProblemDetalsClientErrorFactoryTest.cs (4)

33Assert.Equal(415, problemDetails.Status); 60Assert.Equal(415, problemDetails.Status); 91Assert.Equal(Activity.Current.Id, problemDetails.Extensions["traceId"]); 117Assert.Equal("42", problemDetails.Extensions["traceId"]);

Infrastructure\ValidationProblemDetailsJsonConverterTest.cs (9)

34Assert.Equal(status, problemDetails.Status); 49Assert.Equal(new[] { "error0" }, kvp.Value); 54Assert.Equal(new[] { "error1", "error2" }, kvp.Value); 76Assert.Equal(status, problemDetails.Status); 89Assert.Equal(new[] { "error0" }, kvp.Value); 94Assert.Equal(new[] { "error1", "error2" }, kvp.Value); 114Assert.Equal(status, problemDetails.Status); 127Assert.Equal(new[] { "error0" }, kvp.Value); 132Assert.Equal(new[] { "error1", "error2" }, kvp.Value);

LocalRedirectResultTest.cs (1)

79Assert.Equal(StatusCodes.Status302Found, httpContext.Response.StatusCode);

MediaTypeCollectionTest.cs (1)

39Assert.Equal(1, collection.IndexOf("application/json; charset=utf-16"));

ModelBinding\Binders\ArrayModelBinderProviderTest.cs (3)

40Assert.Equal(modelType.GetElementType(), m.ModelType); 60Assert.Equal(typeof(int), m.ModelType); 90Assert.Equal(typeof(int), m.ModelType);

ModelBinding\Binders\ArrayModelBinderTest.cs (4)

39Assert.Equal(new[] { 42, 84 }, array); 83Assert.Equal(expectedErrorCount, bindingContext.ModelState.ErrorCount); 162Assert.Equal(0, bindingContext.ModelState.ErrorCount); 216Assert.Equal(357, model[i]);

ModelBinding\Binders\BinderTypeModelBinderTest.cs (1)

48Assert.Equal(model.Age, person.Age);

ModelBinding\Binders\ByteArrayModelBinderTests.cs (2)

33Assert.Equal(string.Empty, modelState.Value.RawValue); 54Assert.Equal(new byte[] { 23, 43, 53 }, bytes);

ModelBinding\Binders\CancellationTokenModelBinderTests.cs (1)

23Assert.Equal(bindingContext.HttpContext.RequestAborted, bindingContext.Result.Model);

ModelBinding\Binders\CollectionModelBinderProviderTest.cs (2)

53Assert.Equal(typeof(int), m.ModelType); 75Assert.Equal(typeof(int), m.ModelType);

ModelBinding\Binders\CollectionModelBinderTest.cs (8)

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()); 269Assert.Equal(0, bindingContext.ModelState.ErrorCount); 344Assert.Equal(0, bindingContext.ModelState.ErrorCount); 418Assert.Equal(0, bindingContext.ModelState.ErrorCount); 449Assert.Equal(expectedResult, result);

ModelBinding\Binders\ComplexObjectModelBinderTest.cs (21)

37Assert.Equal(expectedCanCreate, canCreate); 54Assert.Equal(ComplexObjectModelBinder.NoDataAvailable, canCreate); 69Assert.Equal(ComplexObjectModelBinder.ValueProviderDataAvailable, canCreate); 86Assert.Equal(expectedCanCreate, canCreate); 114Assert.Equal(valueAvailable, canCreate); 130Assert.Equal(ComplexObjectModelBinder.NoDataAvailable, canCreate); 146Assert.Equal(ComplexObjectModelBinder.ValueProviderDataAvailable, canCreate); 172Assert.Equal(valueProviderProvidesValue, canCreate); 200Assert.Equal(expectedCanCreate, canCreate); 235Assert.Equal(expectedCanCreate, canCreate); 269Assert.Equal(expectedCanCreate, canCreate); 426Assert.Equal(expected, canUpdate); 561Assert.Equal(expected, result); 587Assert.Equal(expected, result); 725Assert.Equal(ModelValidationState.Invalid, entry.ValidationState); 800Assert.Equal(0, model.ValueTypeRequired); 825Assert.Equal(57, model.ValueTypeRequired); 857Assert.Equal(dob, model.DateOfBirth); 879Assert.Equal(0m, person.PropertyWithDefaultValue); 990Assert.Equal("Joe", propertyAccessor(model)); 1034Assert.Equal(new DateTime(2001, 1, 1), model.DateOfBirth);

ModelBinding\Binders\ComplexTypeModelBinderTest.cs (23)

ModelBinding\Binders\DateTimeModelBinderTest.cs (6)

87Assert.Equal(ModelBindingResult.Failed(), bindingContext.Result); 102Assert.Equal(ModelBindingResult.Failed(), bindingContext.Result); 174Assert.Equal(expected, model); 175Assert.Equal(DateTimeKind.Utc, model.Kind); 197Assert.Equal(expected, model); 198Assert.Equal(DateTimeKind.Local, model.Kind);

ModelBinding\Binders\DictionaryModelBinderTest.cs (11)

47Assert.Equal(2, dictionary.Count); 88Assert.Equal(2, dictionary.Count); 154Assert.Equal(dictionary, resultDictionary); 188Assert.Equal(dictionary, resultDictionary); 312Assert.Equal(dictionary, resultDictionary); 362Assert.Equal(dictionary, resultDictionary); 409Assert.Equal(expectedDictionary, resultDictionary); 454Assert.Equal(expectedErrorCount, bindingContext.ModelState.ErrorCount); 538Assert.Equal(expectedErrorCount, bindingContext.ModelState.ErrorCount); 582Assert.Equal(0, bindingContext.ModelState.ErrorCount); 617Assert.Equal(expectedResult, result);

ModelBinding\Binders\EnumTypeModelBinderTest.cs (1)

64Assert.Equal(IntEnum.Value1, boundModel);

ModelBinding\Binders\FloatingPointTypeModelBinderTestOfT.cs (7)

183Assert.Equal(ModelBindingResult.Failed(), bindingContext.Result); 252Assert.Equal(Twelve, bindingContext.Result.Model); 274Assert.Equal(TwelvePointFive, bindingContext.Result.Model); 295Assert.Equal(TwelvePointFive, bindingContext.Result.Model); 316Assert.Equal(ThirtyTwoThousand, bindingContext.Result.Model); 337Assert.Equal(ThirtyTwoThousandPointOne, bindingContext.Result.Model); 358Assert.Equal(ThirtyTwoThousandPointOne, bindingContext.Result.Model);

ModelBinding\Binders\FormCollectionModelBinderTest.cs (1)

35Assert.Equal(2, form.Count);

ModelBinding\Binders\FormFileModelBinderTest.cs (1)

244Assert.Equal(2, files.Count);

ModelBinding\Binders\HeaderModelBinderTests.cs (7)

35Assert.Equal(headerValue.Split(','), bindingContext.Result.Model); 57Assert.Equal(headerValue, bindingContext.Result.Model); 103Assert.Equal(headerValue.Split(','), bindingContext.Result.Model); 154Assert.Equal(expectedModel, bindingContext.Result.Model); 247Assert.Equal("application/json,text/json", bindingContext.Result.Model); 271Assert.Equal("application/json,text/json", bindingContext.Result.Model); 318Assert.Equal(2, entry.Errors.Count);

ModelBinding\Binders\KeyValuePairModelBinderTest.cs (3)

81Assert.Equal(0, bindingContext.ModelState.ErrorCount); 101Assert.Equal(new KeyValuePair<int, string>(42, "some-value"), bindingContext.Result.Model); 167Assert.Equal(default(KeyValuePair<string, string>), model);

ModelBinding\Binders\ServicesModelBinderProviderTest.cs (1)

70Assert.Equal(isOptional, binder.IsOptional);

ModelBinding\Binders\SimpleTypeModelBinderTest.cs (12)

191Assert.Equal(ModelBindingResult.Failed(), bindingContext.Result); 193Assert.Equal(3, sink.Writes.Count()); 235Assert.Equal(12, bindingContext.Result.Model); 256Assert.Equal(12.5, bindingContext.Result.Model); 281Assert.Equal(42, bindingContext.Result.Model); 283Assert.Equal(2, sink.Writes.Count()); 328Assert.Equal(ModelValidationState.Invalid, entry.Value.ValidationState); 352Assert.Equal(12.5M, bindingContext.Result.Model); 398Assert.Equal(IntEnum.Value1, boundModel); 419Assert.Equal(IntEnum.Value1, boundModel); 460Assert.Equal((IntEnum)expected, boundModel); 483Assert.Equal((FlagsEnum)expected, boundModel);

ModelBinding\Binders\TryParseTypeModelBinderTest.cs (13)

140Assert.Equal(ModelBindingResult.Failed(), bindingContext.Result); 142Assert.Equal(3, sink.Writes.Count()); 162Assert.Equal(12, bindingContext.Result.Model); 183Assert.Equal(12.5, bindingContext.Result.Model); 208Assert.Equal(42, bindingContext.Result.Model); 210Assert.Equal(2, sink.Writes.Count()); 254Assert.Equal(ModelValidationState.Invalid, entry.Value.ValidationState); 278Assert.Equal(12.5M, bindingContext.Result.Model); 324Assert.Equal(IntEnum.Value1, boundModel); 345Assert.Equal(IntEnum.Value1, boundModel); 382Assert.Equal((IntEnum)expected, boundModel); 432Assert.Equal(expected, boundModel.Id); 481Assert.Equal((FlagsEnum)expected, boundModel);

ModelBinding\DefaultModelBindingContextTest.cs (1)

152Assert.Equal(typeof(int), bindingContext.ModelType);

ModelBinding\ElementalValueProviderTests.cs (2)

65Assert.Equal(ValueProviderResult.None, result); 83Assert.Equal(culture, result.Culture);

ModelBinding\EnumerableValueProviderTest.cs (7)

135Assert.Equal(expected, result); 153Assert.Equal(expected, result); 168Assert.Equal(culture, result.Culture); 184Assert.Equal(culture, result.Culture); 200Assert.Equal(ValueProviderResult.None, result); 231Assert.Equal(ValueProviderResult.None, result); 248Assert.Equal(ValueProviderResult.None, result);

ModelBinding\FormFileValueProviderTest.cs (1)

65Assert.Equal(ValueProviderResult.None, result);

ModelBinding\FormValueProviderFactoryTest.cs (1)

45Assert.Equal(CultureInfo.CurrentCulture, valueProvider.Culture);

ModelBinding\FormValueProviderTest.cs (4)

30Assert.Equal(CultureInfo.InvariantCulture, invariantCultureResult.Culture); 31Assert.Equal(BackingStore[invariantCultureKey], invariantCultureResult.Values); 33Assert.Equal(culture, currentCultureResult.Culture); 34Assert.Equal(BackingStore[currentCultureKey], currentCultureResult.Values);

ModelBinding\JQueryFormValueProviderFactoryTest.cs (2)

69Assert.Equal(CultureInfo.CurrentCulture, valueProvider.Culture); 130Assert.Equal(CultureInfo.CurrentCulture, jqueryFormValueProvider.Culture);

ModelBinding\JQueryFormValueProviderTest.cs (4)

68Assert.Equal(CultureInfo.InvariantCulture, invariantCultureResult.Culture); 69Assert.Equal(BackingStore[invariantCultureKey], invariantCultureResult.Values); 71Assert.Equal(culture, currentCultureResult.Culture); 72Assert.Equal(BackingStore[currentCultureKey], currentCultureResult.Values);

ModelBinding\JQueryQueryStringValueProviderFactoryTest.cs (1)

110Assert.Equal(CultureInfo.InvariantCulture, jqueryQueryStringValueProvider.Culture);

ModelBinding\Metadata\BindingSourceMetadataProviderTests.cs (1)

22Assert.Equal(BindingSource.Special, context.BindingMetadata.BindingSource);

ModelBinding\Metadata\DefaultBindingMetadataProviderTest.cs (9)

ModelBinding\Metadata\DefaultModelMetadataProviderTest.cs (9)

76Assert.Equal(modelType, propertyMetadata.ContainerMetadata.ModelType); 82Assert.Equal(modelType, propertyMetadata.ContainerMetadata.ModelType); 96Assert.Equal(2, metadata.Length); 126Assert.Equal(properties1.Length, properties2.Length); 179Assert.Equal(typeof(string), propertyMetadata.ModelType); 277Assert.Equal(ModelMetadataKind.Parameter, metadata.MetadataKind); 278Assert.Equal(typeof(DerivedModelType), metadata.ModelType); 361Assert.Equal(ModelMetadataKind.Property, metadata.MetadataKind); 362Assert.Equal(typeof(DerivedModelType), metadata.ModelType);

ModelBinding\Metadata\DefaultModelMetadataTest.cs (13)

32Assert.Equal(typeof(string), metadata.ModelType); 66Assert.Equal(10000, ModelMetadata.DefaultOrder); 67Assert.Equal(ModelMetadata.DefaultOrder, metadata.Order); 90Assert.Equal(typeof(Exception), metadata.ModelType); 109Assert.Equal(typeof(string), metadata.ModelType); 111Assert.Equal(typeof(Exception), metadata.ContainerType); 273Assert.Equal(elementType, elementMetadata.ModelType); 495Assert.Equal(expectedProperties.Length, properties.Count); 567Assert.Equal(expectedNames.Count(), properties.Count); 568Assert.Equal(expectedNames.ToArray(), properties.Select(p => p.PropertyName).ToArray()); 679Assert.Equal(expectedNames.Count(), properties.Count); 680Assert.Equal(expectedNames.ToArray(), properties.Select(p => p.PropertyName).ToArray()); 722Assert.Equal(SinglePropertiesEvaluation, secondPropertiesEvaluation);

ModelBinding\Metadata\ExcludeBindingMetadataProviderTest.cs (1)

29Assert.Equal(initialValue, context.BindingMetadata.IsBindingAllowed);

ModelBinding\Metadata\ModelAttributesTest.cs (11)

ModelBinding\Metadata\ModelBinderAttributeTest.cs (1)

65Assert.Equal(BindingSource.Query, source);

ModelBinding\ModelBinderFactoryTest.cs (18)

ModelBinding\ModelBindingHelperTest.cs (22)

ModelBinding\ParameterBinderTest.cs (5)

221Assert.Equal(4, sink.Writes.Count()); 575Assert.Equal(ModelValidationState.Invalid, kvp.Value.ValidationState); 636Assert.Equal(ModelValidationState.Invalid, kvp.Value.ValidationState); 643Assert.Equal(ModelValidationState.Invalid, kvp.Value.ValidationState); 701Assert.Equal(ModelValidationState.Invalid, keyValuePair.Value.ValidationState);

ModelBinding\QueryStringValueProviderFactoryTest.cs (1)

46Assert.Equal(CultureInfo.InvariantCulture, valueProvider.Culture);

ModelBinding\RouteValueProviderTests.cs (4)

26Assert.Equal(ValueProviderResult.None, result); 114Assert.Equal(CultureInfo.InvariantCulture, result.Culture); 132Assert.Equal(new CultureInfo("fr-FR"), result.Culture); 193Assert.Equal(ValueProviderResult.None, result);

ModelBinding\Validation\CompositeModelValidatorProviderTest.cs (1)

42Assert.Equal(

ModelBinding\Validation\DefaultCollectionValidationStrategyTest.cs (9)

28Assert.Equal(2, e.Model); 34Assert.Equal(3, e.Model); 40Assert.Equal(5, e.Model); 68Assert.Equal(new KeyValuePair<int, string>(2, "two"), e.Model); 74Assert.Equal(new KeyValuePair<int, string>(3, "three"), e.Model); 80Assert.Equal(new KeyValuePair<int, string>(5, "five"), e.Model); 103Assert.Equal(2, e.Model); 109Assert.Equal(3, e.Model); 115Assert.Equal(5, e.Model);

ModelBinding\Validation\DefaultComplexObjectValidationStrategyTest.cs (7)

35Assert.Equal(23, entry.Model); 41Assert.Equal(1, entry.Model); 47Assert.Equal("Joey", entry.Model); 75Assert.Equal(23, entry.Model); 81Assert.Equal(1, entry.Model); 87Assert.Equal("Joey", entry.Model); 144Assert.Equal(23, entry.Model);

ModelBinding\Validation\DefaultModelValidatorProviderTest.cs (2)

92Assert.Equal(2, validatorItems.Count); 137Assert.Equal(2, validatorItems.Count);

ModelBinding\Validation\DefaultObjectValidatorTests.cs (76)

ModelBinding\Validation\ExplicitIndexCollectionValidationStrategyTest.cs (13)

28Assert.Equal(3, e.Model); 34Assert.Equal(5, e.Model); 40Assert.Equal(2, e.Model); 68Assert.Equal(new KeyValuePair<int, string>(3, "three"), e.Model); 74Assert.Equal(new KeyValuePair<int, string>(5, "five"), e.Model); 80Assert.Equal(new KeyValuePair<int, string>(2, "two"), e.Model); 103Assert.Equal(3, e.Model); 109Assert.Equal(5, e.Model); 115Assert.Equal(2, e.Model); 139Assert.Equal(3, e.Model); 145Assert.Equal(2, e.Model); 169Assert.Equal(3, e.Model); 175Assert.Equal(2, e.Model);

ModelBinding\Validation\ShortFormDictionaryValidationStrategyTest.cs (7)

39Assert.Equal("two", e.Model); 45Assert.Equal("three", e.Model); 51Assert.Equal("five", e.Model); 86Assert.Equal("two", e.Model); 92Assert.Equal("three", e.Model); 127Assert.Equal("two", e.Model); 133Assert.Equal("three", e.Model);

ObjectResultTests.cs (9)

27Assert.Equal(input, result.Value); 59Assert.Equal(404, actionContext.HttpContext.Response.StatusCode); 91Assert.Equal(StatusCodes.Status422UnprocessableEntity, details.Status.Value); 120Assert.Equal(StatusCodes.Status413RequestEntityTooLarge, details.Status.Value); 121Assert.Equal(StatusCodes.Status413RequestEntityTooLarge, result.StatusCode.Value); 122Assert.Equal(StatusCodes.Status413RequestEntityTooLarge, actionContext.HttpContext.Response.StatusCode); 151Assert.Equal(StatusCodes.Status422UnprocessableEntity, details.Status.Value); 152Assert.Equal(StatusCodes.Status400BadRequest, result.StatusCode.Value); 153Assert.Equal(StatusCodes.Status400BadRequest, actionContext.HttpContext.Response.StatusCode);

ProducesAttributeTests.cs (1)

32Assert.Equal(2, objectResult.ContentTypes.Count);

RedirectToActionResultTest.cs (2)

107Assert.Equal(expectedStatusCode, httpContext.Response.StatusCode); 135Assert.Equal(expectedStatusCode, httpContext.Response.StatusCode);

RedirectToPageResultTest.cs (8)

116Assert.Equal("test-value", value.Value); 121Assert.Equal("/A/Redirecting", value.Value); 126Assert.Equal("page-handler", value.Value); 170Assert.Equal("test-value", value.Value); 175Assert.Equal("/MyPage", value.Value); 180Assert.Equal("page-handler", value.Value); 232Assert.Equal(expected, value.Value); 283Assert.Equal(expected, value.Value);

RedirectToRouteResultTest.cs (2)

136Assert.Equal(expectedStatusCode, httpContext.Response.StatusCode); 161Assert.Equal(expectedStatusCode, httpContext.Response.StatusCode);

RequestFormLimitsAttributeTest.cs (1)

46Assert.Equal(

RequireHttpsAttributeTests.cs (3)

125Assert.Equal(StatusCodes.Status403Forbidden, result.StatusCode); 144Assert.Equal(StatusCodes.Status404NotFound, result.StatusCode); 216Assert.Equal(permanent ?? requireHttpsPermanent, result.Permanent);

ResponseCacheAttributeTest.cs (6)

167Assert.Equal(expectedProfile.Duration, responseCacheFilter.Duration); 168Assert.Equal(expectedProfile.Location, responseCacheFilter.Location); 169Assert.Equal(expectedProfile.NoStore, responseCacheFilter.NoStore); 177Assert.Equal(expectedProfile.VaryByQueryKeys, responseCacheFilter.VaryByQueryKeys); 227Assert.Equal(varyByQueryKeys, context.HttpContext.Features.Get<IResponseCachingFeature>().VaryByQueryKeys); 357Assert.Equal(

Routing\ActionEndpointDataSourceBaseTest.cs (5)

36Assert.Equal("Value", endpoint.RoutePattern.RequiredValues["Name"]); 100Assert.Equal("TestController", routePattern.RequiredValues["controller"]); 101Assert.Equal("TestAction", routePattern.RequiredValues["action"]); 122Assert.Equal("NewTestController", routePattern.RequiredValues["controller"]); 123Assert.Equal("NewTestAction", routePattern.RequiredValues["action"]);

Routing\ActionEndpointFactoryTest.cs (18)

Routing\AttributeRouteTest.cs (26)

Routing\ControllerActionEndpointDataSourceTest.cs (12)

Routing\DynamicControllerEndpointMatcherPolicyTest.cs (9)

195Assert.Equal("Index", kvp.Value); 200Assert.Equal("Home", kvp.Value); 273Assert.Equal("Index", kvp.Value); 278Assert.Equal("Home", kvp.Value); 283Assert.Equal("test", kvp.Value); 373Assert.Equal("Index", kvp.Value); 378Assert.Equal("Home", kvp.Value); 383Assert.Equal("test", kvp.Value); 430Assert.Equal(2, candidates.Count);

Routing\UrlHelperExtensionsTest.cs (28)

45Assert.Equal("/TestPage", value.Value); 93Assert.Equal(10, value.Value); 98Assert.Equal("/TestPage", value.Value); 125Assert.Equal(13, value.Value); 130Assert.Equal("/TestPage", value.Value); 157Assert.Equal(13, value.Value); 162Assert.Equal("/TestPage", value.Value); 189Assert.Equal(13, value.Value); 194Assert.Equal("/TestPage", value.Value); 199Assert.Equal("test-handler", value.Value); 239Assert.Equal(13, value.Value); 244Assert.Equal("ambient-page", value.Value); 288Assert.Equal(13, value.Value); 293Assert.Equal("10/31/New Page", value.Value); 331Assert.Equal(13, value.Value); 336Assert.Equal("ambient-page", value.Value); 379Assert.Equal("exact-handler", value.Value); 384Assert.Equal("ambient-page", value.Value); 422Assert.Equal("route-value-handler", value.Value); 427Assert.Equal("ambient-page", value.Value); 457Assert.Equal(expected, value.Value); 484Assert.Equal(expected, value.Value); 528Assert.Equal(expected, value.Value); 591Assert.Equal("specified-area", value.Value); 596Assert.Equal("ambient-page", value.Value); 747Assert.Equal(expectedPage, value.Value); 795Assert.Equal("ambient-page", value.Value); 843Assert.Equal("ambient-page", value.Value);

Routing\UrlHelperTestBase.cs (2)

636Assert.Equal(2, dictionary.Count); 681Assert.Equal(3, dict.Count);

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

src\Shared\ResultsTests\FileStreamResultTestBase.cs (15)

src\Shared\ResultsTests\PhysicalFileResultTestBase.cs (27)

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

35Assert.Equal(StatusCodes.Status302Found, httpContext.Response.StatusCode); 58Assert.Equal(StatusCodes.Status302Found, httpContext.Response.StatusCode);

src\Shared\ResultsTests\VirtualFileResultTestBase.cs (23)

UnprocessableEntityObjectResultTests.cs (3)

19Assert.Equal(StatusCodes.Status422UnprocessableEntity, result.StatusCode); 20Assert.Equal(obj, result.Value); 30Assert.Equal(StatusCodes.Status422UnprocessableEntity, result.StatusCode);

UnprocessableEntityResultTests.cs (1)

17Assert.Equal(StatusCodes.Status422UnprocessableEntity, result.StatusCode);

ValidationProblemDetailsTest.cs (5)

41Assert.Equal(new[] { "error1" }, item.Value); 46Assert.Equal(new[] { "error2", "error3" }, item.Value); 71Assert.Equal(new[] { "The input was not valid." }, item.Value); 95Assert.Equal(new[] { "error1", "error2" }, item.Value); 100Assert.Equal(new[] { "error3" }, item.Value);

CorsAuthorizationFilterTest.cs (4)

41Assert.Equal(204, response.StatusCode); 69Assert.Equal(204, authorizationContext.HttpContext.Response.StatusCode); 91Assert.Equal(204, response.StatusCode); 112Assert.Equal(200, authorizationContext.HttpContext.Response.StatusCode);

DisableCorsAuthorizationFilterTest.cs (1)

73Assert.Equal(StatusCodes.Status204NoContent, statusCodeResult.StatusCode);

DataAnnotationsMetadataProviderTest.cs (8)

101Assert.Equal(expected, value); 644Assert.Equal(expectedIsEnum, context.DisplayMetadata.IsEnum); 678Assert.Equal(expectedIsFlagsEnum, context.DisplayMetadata.IsFlagsEnum); 811Assert.Equal(expectedDictionary, context.DisplayMetadata.EnumNamesAndValues); 1141Assert.Equal(initialValue, context.ValidationMetadata.IsRequired); 1470Assert.Equal(expected, actual: context.ValidationMetadata.ValidatorMetadata); 1492Assert.Equal(initialValue, context.BindingMetadata.IsBindingRequired); 1514Assert.Equal(initialValue, context.BindingMetadata.IsReadOnly);

DataAnnotationsModelValidatorProviderTest.cs (1)

54Assert.Equal(4, providerContext.Results.Count);

DataAnnotationsModelValidatorTest.cs (1)

413Assert.Equal(service.Object, receivedService);

DataMemberRequiredBindingMetadataProviderTest.cs (4)

61Assert.Equal(initialValue, context.BindingMetadata.IsBindingRequired); 86Assert.Equal(initialValue, context.BindingMetadata.IsBindingRequired); 109Assert.Equal(initialValue, context.BindingMetadata.IsBindingRequired); 137Assert.Equal(initialValue, context.BindingMetadata.IsBindingRequired);

DefaultModelClientValidatorProviderTest.cs (4)

94Assert.Equal(2, validatorItems.Count); 118Assert.Equal(2, validatorItems.Count); 162Assert.Equal(2, validatorItems.Count); 185Assert.Equal(2, validatorItems.Count);

ModelMetadataProviderTest.cs (2)

354Assert.Equal(expectedResult, result); 405Assert.Equal(expectedOrder, result);

ValidatableObjectAdapterTest.cs (1)

136Assert.Equal(model, model.ObjectInstance);

DelegatingEnumerableTest.cs (1)

44Assert.Equal(errors.Length, delegatingEnumerable.Count());

EnumerableWrapperProviderFactoryTest.cs (2)

58Assert.Equal(expectedWrappingType, wrapperProvider.WrappingType); 111Assert.Equal(expectedWrappingType, wrapperProvider.WrappingType);

EnumerableWrapperProviderTest.cs (3)

31Assert.Equal(expectedType, wrappingType); 47Assert.Equal(typeof(DelegatingEnumerable<int, int>), wrapperProvider.WrappingType); 67Assert.Equal(typeof(DelegatingEnumerable<int, int>), wrapperProvider.WrappingType);

ProblemDetailsWrapperTest.cs (4)

35Assert.Equal(403, problemDetails.Status); 42Assert.Equal("Test Value 3", kvp.Value); 47Assert.Equal("Test Value 2", kvp.Value); 52Assert.Equal("Test Value 1", kvp.Value);

SerializableErrorWrapperProviderTest.cs (1)

19Assert.Equal(typeof(SerializableErrorWrapper), wrapperProvider.WrappingType);

SerializableErrorWrapperTests.cs (5)

41Assert.Equal("key1-error", wrapper.SerializableError["key1"]); 76Assert.Equal("Test error 0", kvp.Value); 81Assert.Equal("Test Error 1 Test Error 2", kvp.Value); 86Assert.Equal("Test Error 3", kvp.Value); 91Assert.Equal("Test Error 4", kvp.Value);

SerializableWrapperProviderFactoryTest.cs (1)

22Assert.Equal(typeof(SerializableErrorWrapper), wrapperProvider.WrappingType);

ValidationProblemDetailsWrapperTest.cs (10)

39Assert.Equal(400, problemDetails.Status); 46Assert.Equal("Test Value 2", kvp.Value); 51Assert.Equal("Test Value 1", kvp.Value); 59Assert.Equal(new[] { "Test error 4" }, kvp.Value); 64Assert.Equal(new[] { "Test error 3" }, kvp.Value); 69Assert.Equal(new[] { "Test error 1 Test error 2" }, kvp.Value); 95Assert.Equal(400, problemDetails.Status); 102Assert.Equal("Test Value 1", kvp.Value); 107Assert.Equal("Test Value 2", kvp.Value); 132Assert.Equal(400, problemDetails.Status);

XmlDataContractSerializerInputFormatterTest.cs (15)

XmlDataContractSerializerOutputFormatterTest.cs (7)

132Assert.Equal(1, formatter.createSerializerCalledCount); 390Assert.Equal(expectedOutput, result); 425Assert.Equal(expectedResult != null, actualCanWriteValue); 426Assert.Equal(new StringSegment(expectedContentType), outputFormatterContext.ContentType); 456Assert.Equal(expectedOutput, Assert.Single(result).ToString()); 460Assert.Equal(expectedOutput, result); 666Assert.Equal(LogLevel.Warning, write.LogLevel);

XmlSerializerInputFormatterTest.cs (22)

XmlSerializerOutputFormatterTest.cs (7)

140Assert.Equal(1, formatter.createSerializerCalledCount); 363Assert.Equal(expectedOutput, result); 396Assert.Equal(expectedResult != null, actualCanWriteValue); 397Assert.Equal(new StringSegment(expectedContentType), outputFormatterContext.ContentType); 440Assert.Equal(expectedOutput, Assert.Single(result).ToString()); 444Assert.Equal(expectedOutput, result); 483Assert.Equal(LogLevel.Warning, write.LogLevel);

AntiforgeryAuthTests.cs (4)

26Assert.Equal(HttpStatusCode.Redirect, response.StatusCode); 38Assert.Equal(HttpStatusCode.Redirect, response.StatusCode); 49Assert.Equal(HttpStatusCode.OK, response.StatusCode); 59Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);

AntiforgeryMiddlewareTest.cs (2)

92Assert.Equal(HttpStatusCode.BadRequest, result.StatusCode); 167Assert.Equal(HttpStatusCode.BadRequest, result.StatusCode);

AntiforgeryTests.cs (7)

25Assert.Equal(HttpStatusCode.OK, response.StatusCode); 70Assert.Equal(HttpStatusCode.OK, response.StatusCode); 120Assert.Equal(HttpStatusCode.OK, response.StatusCode); 149Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 159Assert.Equal(HttpStatusCode.OK, response.StatusCode); 184Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 197Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);

ApiBehaviorTest.cs (13)

119Assert.Equal((int)HttpStatusCode.UnsupportedMediaType, problemDetails.Status); 146Assert.Equal(input.ContactId, result.ContactId); 167Assert.Equal(input.ContactId, result.ContactInfo.ContactId); 169Assert.Equal(requestId, result.Id); 184Assert.Equal(id, result.ContactId); 200Assert.Equal(id, result.ContactId); 221Assert.Equal(id, result.ContactId); 242Assert.Equal(id, result.ContactId); 294Assert.Equal(404, problemDetails.Status); 356Assert.Equal(400, validationProblemDetails.Status); 362Assert.Equal("27", kvp.Value); 370Assert.Equal(new[] { "Error Message" }, kvp.Value); 452Assert.Equal(expected, actual);

ApiExplorerTest.cs (63)

ApplicationModelTest.cs (11)

AsyncActionsTests.cs (15)

AsyncDisposalTest.cs (3)

37Assert.Equal(HttpStatusCode.OK, response.StatusCode); 49Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 61Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);

AsyncEnumerableTestBase.cs (2)

39Assert.Equal(10, projects.Count); 78Assert.Equal(10, projects.Count());

AuthMiddlewareAndFilterTestBase.cs (11)

BasicTests.cs (31)

ComponentRenderingFunctionalTests.cs (1)

97Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);

ConsumesAttributeEndpointRoutingTests.cs (1)

23Assert.Equal(HttpStatusCode.OK, response.StatusCode);

ConsumesAttributeTests.cs (1)

23Assert.Equal(HttpStatusCode.OK, response.StatusCode);

ConsumesAttributeTestsBase.cs (8)

43Assert.Equal(HttpStatusCode.OK, response.StatusCode); 60Assert.Equal(HttpStatusCode.OK, response.StatusCode); 76Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 96Assert.Equal(HttpStatusCode.OK, response.StatusCode); 118Assert.Equal(HttpStatusCode.OK, response.StatusCode); 143Assert.Equal(HttpStatusCode.OK, response.StatusCode); 162Assert.Equal(HttpStatusCode.OK, response.StatusCode); 185Assert.Equal(HttpStatusCode.OK, response.StatusCode);

ContentNegotiationTest.cs (32)

ControllerEndpointFiltersTest.cs (4)

36Assert.Equal(HttpStatusCode.OK, response.StatusCode); 49Assert.Equal(HttpStatusCode.OK, response.StatusCode); 62Assert.Equal(HttpStatusCode.OK, response.StatusCode); 74Assert.Equal(HttpStatusCode.OK, response.StatusCode);

ControllerFromServicesTests.cs (1)

103Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);

CorsTests.cs (1)

29Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);

CorsTestsBase.cs (29)

CustomValueProviderTest.cs (4)

38Assert.Equal(HttpStatusCode.OK, response.StatusCode); 55Assert.Equal(HttpStatusCode.OK, response.StatusCode); 72Assert.Equal(HttpStatusCode.OK, response.StatusCode); 89Assert.Equal(HttpStatusCode.OK, response.StatusCode);

DataAnnotationTests.cs (1)

34Assert.Equal(HttpStatusCode.OK, response.StatusCode);

DoNotRespectBrowserAcceptHeaderTests.cs (4)

36Assert.Equal(HttpStatusCode.OK, response.StatusCode); 64Assert.Equal(HttpStatusCode.OK, response.StatusCode); 93Assert.Equal(HttpStatusCode.OK, response.StatusCode); 124Assert.Equal(HttpStatusCode.OK, response.StatusCode);

ErrorPageTests.cs (10)

68Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 69Assert.Equal(expectedMediaType, response.Content.Headers.ContentType); 103Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 104Assert.Equal(expectedMediaType, response.Content.Headers.ContentType); 124Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 125Assert.Equal(expectedMediaType, response.Content.Headers.ContentType); 144Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 145Assert.Equal(expectedMediaType, response.Content.Headers.ContentType); 162Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 163Assert.Equal(expectedMediaType, response.Content.Headers.ContentType);

FileResultTests.cs (48)

FiltersTest.cs (6)

27Assert.Equal(HttpStatusCode.OK, response.StatusCode); 38Assert.Equal(HttpStatusCode.OK, response.StatusCode); 49Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); 64Assert.Equal(HttpStatusCode.OK, response.StatusCode); 84Assert.Equal(422, (int)response.StatusCode); 111Assert.Equal(HttpStatusCode.OK, response.StatusCode);

FormFileUploadTest.cs (4)

34Assert.Equal(HttpStatusCode.OK, response.StatusCode); 38Assert.Equal(23, user.Age); 62Assert.Equal(HttpStatusCode.OK, response.StatusCode); 67Assert.Equal(2, product.Specs.Count);

GlobalAuthorizationFilterTestBase.cs (4)

20Assert.Equal(HttpStatusCode.Redirect, response.StatusCode); 34Assert.Equal(HttpStatusCode.OK, response.StatusCode); 46Assert.Equal(HttpStatusCode.OK, response.StatusCode); 58Assert.Equal(HttpStatusCode.OK, response.StatusCode);

HtmlGenerationTest.cs (11)

108Assert.Equal(HttpStatusCode.OK, response.StatusCode); 109Assert.Equal(expectedMediaType, response.Content.Headers.ContentType); 134Assert.Equal(expectedMediaType, response.Content.Headers.ContentType); 199Assert.Equal(expectedAttributes.Count + 1, imgElement.Attributes.Length); // + 1 for the id-attribute 225Assert.Equal(HttpStatusCode.OK, response.StatusCode); 226Assert.Equal(expectedMediaType, response.Content.Headers.ContentType); 265Assert.Equal(HttpStatusCode.OK, response.StatusCode); 266Assert.Equal(expectedMediaType, response.Content.Headers.ContentType); 304Assert.Equal(HttpStatusCode.OK, response.StatusCode); 305Assert.Equal(expectedMediaType, response.Content.Headers.ContentType); 335Assert.Equal(HttpStatusCode.OK, response.StatusCode);

HttpActionResultTests.cs (1)

32Assert.Equal(id, result.ContactId);

InputFormatterTests.cs (10)

39Assert.Equal(HttpStatusCode.OK, response.StatusCode); 56Assert.Equal(HttpStatusCode.OK, response.StatusCode); 72Assert.Equal(HttpStatusCode.UnsupportedMediaType, response.StatusCode); 102Assert.Equal("The DerivedProperty field is required.", value.First); 134Assert.Equal("The DerivedProperty field is required.", value.First); 166Assert.Equal("The DerivedProperty field is required.", value.First); 216Assert.Equal(0, content.Headers.ContentLength); 261Assert.Equal(0, content.Headers.ContentLength); 276Assert.Equal(0, content.Headers.ContentLength); 291Assert.Equal(0, content.Headers.ContentLength);

InputObjectValidationTests.cs (12)

67Assert.Equal(HttpStatusCode.OK, response.StatusCode); 89Assert.Equal(HttpStatusCode.OK, response.StatusCode); 110Assert.Equal(HttpStatusCode.OK, response.StatusCode); 130Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode); 158Assert.Equal(expectedStatusCode, (int)response.StatusCode); 181Assert.Equal(HttpStatusCode.OK, response.StatusCode); 200Assert.Equal(expected: StatusCodes.Status400BadRequest, actual: (int)response.StatusCode); 220Assert.Equal(expected: StatusCodes.Status400BadRequest, actual: (int)response.StatusCode); 241Assert.Equal(expected: StatusCodes.Status400BadRequest, actual: (int)response.StatusCode); 293Assert.Equal(new[] { "Invalid character after parsing property name. Expected ':' but got: =. Path '', line 1, position 4." }, error.Value); 322Assert.Equal(new[] { "Required property 'isbn' not found in JSON. Path '', line 1, position 44." }, error.Value); 354Assert.Equal(new[] { "An error occurred while deserializing input data." }, error.Value);

InputParentValidationTests.cs (4)

44Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode); 49Assert.Equal(expectedErrors, actualErrors); 63Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode); 68Assert.Equal(expectedErrors, actualErrors);

InputValidationTests.cs (3)

57Assert.Equal(HttpStatusCode.OK, response.StatusCode); 82Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 83Assert.Equal(10, errors.Count);

JsonInputFormatterTestBase.cs (11)

41Assert.Equal(HttpStatusCode.OK, response.StatusCode); 61Assert.Equal(HttpStatusCode.OK, response.StatusCode); 79Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 95Assert.Equal(HttpStatusCode.OK, response.StatusCode); 115Assert.Equal(HttpStatusCode.OK, response.StatusCode); 116Assert.Equal(expected.Id, actual.Id); 132Assert.Equal(HttpStatusCode.OK, response.StatusCode); 133Assert.Equal(expected.Id, actual.Id); 181Assert.Equal(expected.Id, actual.Id); 198Assert.Equal(HttpStatusCode.UnsupportedMediaType, response.StatusCode); 220Assert.Equal(HttpStatusCode.OK, response.StatusCode);

JsonOutputFormatterTestBase.cs (2)

49Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 55Assert.Equal(2, modelStateErrors.Count);

JsonPatchInputFormatterTest.cs (19)

32Assert.Equal(HttpStatusCode.OK, response.StatusCode); 37Assert.Equal(3, product.Reviews.Count); 38Assert.Equal(3.5, product.Reviews[2].Rating); 52Assert.Equal(HttpStatusCode.OK, response.StatusCode); 57Assert.Equal(2, product.Reviews.Count); 58Assert.Equal(5, product.Reviews[0].Rating); 72Assert.Equal(HttpStatusCode.OK, response.StatusCode); 77Assert.Equal(2, product.Reviews.Count); 78Assert.Equal(4, product.Reviews[1].Rating); 79Assert.Equal(4, product.Reviews[0].Rating); 93Assert.Equal(HttpStatusCode.OK, response.StatusCode); 98Assert.Equal(2, product.Reviews.Count); 99Assert.Equal(4, product.Reviews[1].Rating); 100Assert.Equal(0, product.Reviews[0].Rating); 114Assert.Equal(HttpStatusCode.OK, response.StatusCode); 119Assert.Equal(2, product.Reviews.Count); 120Assert.Equal(0, product.Reviews[0].Rating); 134Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 148Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);

JsonResultWithNewtonsoftJsonTest.cs (6)

38Assert.Equal(HttpStatusCode.OK, response.StatusCode); 60Assert.Equal(HttpStatusCode.OK, response.StatusCode); 78Assert.Equal(HttpStatusCode.OK, response.StatusCode); 96Assert.Equal(HttpStatusCode.OK, response.StatusCode); 113Assert.Equal(HttpStatusCode.OK, response.StatusCode); 129Assert.Equal(HttpStatusCode.OK, response.StatusCode);

JsonResultWithSystemTextJsonTest.cs (6)

38Assert.Equal(HttpStatusCode.OK, response.StatusCode); 60Assert.Equal(HttpStatusCode.OK, response.StatusCode); 78Assert.Equal(HttpStatusCode.OK, response.StatusCode); 96Assert.Equal(HttpStatusCode.OK, response.StatusCode); 113Assert.Equal(HttpStatusCode.OK, response.StatusCode); 129Assert.Equal(HttpStatusCode.OK, response.StatusCode);

LinkGenerationTests.cs (4)

52Assert.Equal(HttpStatusCode.Redirect, response.StatusCode); 54Assert.Equal( 74Assert.Equal(HttpStatusCode.OK, response.StatusCode); 75Assert.Equal(expectedMediaType, response.Content.Headers.ContentType);

LinkGeneratorTest.cs (18)

LinkParserTest.cs (2)

33Assert.Equal(HttpStatusCode.OK, response.StatusCode); 63Assert.Equal(HttpStatusCode.OK, response.StatusCode);

NewtonsoftJsonInputFormatterTest.cs (3)

28Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 46Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 63Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);

NewtonsoftJsonOutputFormatterTest.cs (1)

52Assert.Equal(50, response.Content.Headers.ContentLength);

NonNullableReferenceTypesTest.cs (1)

58Assert.Equal(2, errors.Length); // Not validating BCL error messages

OutputFormatterTest.cs (7)

34Assert.Equal(expectedContentType, response.Content.Headers.ContentType); 51Assert.Equal(expectedContentType, response.Content.Headers.ContentType); 67Assert.Equal(HttpStatusCode.OK, response.StatusCode); 68Assert.Equal(0, response.Content.Headers.ContentLength); 85Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); 86Assert.Equal(0, response.Content.Headers.ContentLength); 105Assert.Equal(HttpStatusCode.NotAcceptable, response.StatusCode);

PageAsyncDisposalTest.cs (1)

37Assert.Equal(HttpStatusCode.OK, response.StatusCode);

RazorBuildTest.cs (3)

43Assert.Equal(HttpStatusCode.OK, response.StatusCode); 68Assert.Equal(HttpStatusCode.OK, response.StatusCode); 81Assert.Equal(HttpStatusCode.OK, response.StatusCode);

RazorPageModelTest.cs (7)

42Assert.Equal(HttpStatusCode.OK, response.StatusCode); 67Assert.Equal(HttpStatusCode.OK, response.StatusCode); 92Assert.Equal(HttpStatusCode.OK, response.StatusCode); 118Assert.Equal(HttpStatusCode.OK, response.StatusCode); 143Assert.Equal(HttpStatusCode.OK, response.StatusCode); 168Assert.Equal(HttpStatusCode.OK, response.StatusCode); 178Assert.Equal(HttpStatusCode.OK, getResponse.StatusCode);

RazorPagesTest.cs (56)

RazorPagesWithBasePathTest.cs (22)

RemoteAttributeValidationTest.cs (3)

37Assert.Equal(HttpStatusCode.OK, response.StatusCode); 62Assert.Equal(HttpStatusCode.OK, response.StatusCode); 91Assert.Equal(HttpStatusCode.OK, response.StatusCode);

RequestFormLimitsTest.cs (4)

62Assert.Equal(HttpStatusCode.OK, response.StatusCode); 88Assert.Equal(HttpStatusCode.OK, response.StatusCode); 111Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 158Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);

RequestServicesEndpointRoutingTest.cs (1)

23Assert.Equal(HttpStatusCode.OK, response.StatusCode);

RequestServicesTest.cs (1)

23Assert.Equal(HttpStatusCode.OK, response.StatusCode);

RequestServicesTestBase.cs (1)

97Assert.Equal(HttpStatusCode.NotFound, response2.StatusCode);

RequestSizeLimitTest.cs (3)

39Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 61Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 78Assert.Equal(HttpStatusCode.OK, response.StatusCode);

RespectBrowserAcceptHeaderTests.cs (2)

37Assert.Equal(HttpStatusCode.OK, response.StatusCode); 56Assert.Equal(HttpStatusCode.OK, response.StatusCode);

RoutingAcrossPipelineBranchesTest.cs (12)

RoutingDynamicOrderTest.cs (6)

42Assert.Equal(HttpStatusCode.OK, response.StatusCode); 65Assert.Equal(HttpStatusCode.OK, response.StatusCode); 88Assert.Equal(HttpStatusCode.OK, response.StatusCode); 110Assert.Equal(HttpStatusCode.OK, response.StatusCode); 132Assert.Equal(HttpStatusCode.OK, response.StatusCode); 154Assert.Equal(HttpStatusCode.OK, response.StatusCode);

RoutingDynamicTest.cs (7)

37Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); 52Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); 67Assert.Equal(HttpStatusCode.OK, response.StatusCode); 82Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); 97Assert.Equal(HttpStatusCode.OK, response.StatusCode); 113Assert.Equal(HttpStatusCode.OK, response.StatusCode); 129Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);

RoutingEndpointRoutingTest.cs (29)

RoutingFallbackTest.cs (7)

37Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); 52Assert.Equal(HttpStatusCode.OK, response.StatusCode); 68Assert.Equal(HttpStatusCode.OK, response.StatusCode); 84Assert.Equal(HttpStatusCode.OK, response.StatusCode); 100Assert.Equal(HttpStatusCode.OK, response.StatusCode); 116Assert.Equal(HttpStatusCode.OK, response.StatusCode); 134Assert.Equal(HttpStatusCode.UnsupportedMediaType, response.StatusCode);

RoutingGroupsTest.cs (2)

36Assert.Equal(HttpStatusCode.OK, response.StatusCode); 47Assert.Equal(HttpStatusCode.OK, response.StatusCode);

RoutingGroupsWithMetadataTest.cs (2)

33Assert.Equal(HttpStatusCode.OK, response.StatusCode); 37Assert.Equal(new[] { "A", "C", "B" }, content);

RoutingTests.cs (6)

25Assert.Equal(HttpStatusCode.OK, response.StatusCode); 44Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); 54Assert.Equal(HttpStatusCode.OK, response.StatusCode); 59Assert.Equal( 76Assert.Equal(HttpStatusCode.OK, response.StatusCode); 81Assert.Equal(new string[]

RoutingTestsBase.cs (79)

RoutingWithoutRazorPagesTestsBase.cs (3)

31Assert.Equal(HttpStatusCode.OK, response.StatusCode); 52Assert.Equal(HttpStatusCode.OK, response.StatusCode); 60Assert.Equal("pagevalue", result.RouteValues["page"]);

SerializableErrorTests.cs (4)

46Assert.Equal(HttpStatusCode.OK, response.StatusCode); 70Assert.Equal(HttpStatusCode.OK, response.StatusCode); 116Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 157Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);

TagHelperComponentTagHelperTest.cs (3)

36Assert.Equal(HttpStatusCode.OK, response.StatusCode); 56Assert.Equal(HttpStatusCode.OK, response.StatusCode); 76Assert.Equal(HttpStatusCode.OK, response.StatusCode);

TagHelpersTest.cs (10)

52Assert.Equal(HttpStatusCode.OK, response.StatusCode); 53Assert.Equal(expectedMediaType, response.Content.Headers.ContentType); 89Assert.Equal(HttpStatusCode.OK, response.StatusCode); 90Assert.Equal(expectedMediaType, response.Content.Headers.ContentType); 110Assert.Equal(HttpStatusCode.OK, response.StatusCode); 111Assert.Equal(expectedMediaType, response.Content.Headers.ContentType); 207Assert.Equal(HttpStatusCode.OK, response.StatusCode); 235Assert.Equal(HttpStatusCode.OK, response.StatusCode); 263Assert.Equal(HttpStatusCode.OK, response.StatusCode); 286Assert.Equal(HttpStatusCode.OK, response.StatusCode);

TempDataInCookiesTest.cs (14)

72Assert.Equal(HttpStatusCode.OK, response.StatusCode); 87Assert.Equal("/", cookieTempDataProviderCookie.Path); 96Assert.Equal(HttpStatusCode.OK, response.StatusCode); 104Assert.Equal(string.Empty, setCookieHeaderValue.Value); 105Assert.Equal("/", setCookieHeaderValue.Path); 114Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); 131Assert.Equal(HttpStatusCode.OK, response.StatusCode); 137Assert.Equal("/", setCookieHeader.Path); 146Assert.Equal(HttpStatusCode.Redirect, redirectResponse.StatusCode); 152Assert.Equal(HttpStatusCode.OK, response.StatusCode); 160Assert.Equal(string.Empty, setCookieHeader.Value); 161Assert.Equal("/", setCookieHeader.Path); 184Assert.Equal(HttpStatusCode.OK, response.StatusCode); 190Assert.Equal("/", setCookieHeader.Path);

TempDataInCookiesUsingCookieConsentTest.cs (5)

42Assert.Equal(HttpStatusCode.OK, response.StatusCode); 48Assert.Equal(HttpStatusCode.OK, response.StatusCode); 56Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); 73Assert.Equal(HttpStatusCode.OK, response.StatusCode); 79Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);

TempDataPropertyTest.cs (7)

64Assert.Equal(HttpStatusCode.Redirect, redirectResponse.StatusCode); 70Assert.Equal(HttpStatusCode.OK, response.StatusCode); 93Assert.Equal(HttpStatusCode.OK, response.StatusCode); 99Assert.Equal(HttpStatusCode.OK, response.StatusCode); 107Assert.Equal(HttpStatusCode.OK, response.StatusCode); 130Assert.Equal(HttpStatusCode.OK, response.StatusCode); 136Assert.Equal(HttpStatusCode.OK, response.StatusCode);

TempDataTestBase.cs (19)

TestingInfrastructureInheritanceTests.cs (2)

27Assert.Equal(new[] { "ConfigureWebHost", "Customization", "FurtherCustomization" }, factory.ConfigureWebHostCalled.ToArray()); 47Assert.Equal(new[] { "ConfigureWebHost", "Customization", "FurtherCustomization" }, factory.ConfigureWebHostCalled.ToArray());

TestingInfrastructureTests.cs (16)

VersioningEndpointRoutingTests.cs (3)

24Assert.Equal(HttpStatusCode.OK, response.StatusCode); 44Assert.Equal(HttpStatusCode.OK, response.StatusCode); 64Assert.Equal(HttpStatusCode.OK, response.StatusCode);

VersioningTests.cs (1)

23Assert.Equal(HttpStatusCode.OK, response.StatusCode);

VersioningTestsBase.cs (24)

XmlDataContractSerializerFormattersWrappingTest.cs (8)

42Assert.Equal(HttpStatusCode.OK, response.StatusCode); 66Assert.Equal(HttpStatusCode.OK, response.StatusCode); 90Assert.Equal(HttpStatusCode.OK, response.StatusCode); 113Assert.Equal(HttpStatusCode.OK, response.StatusCode); 136Assert.Equal(HttpStatusCode.OK, response.StatusCode); 161Assert.Equal(HttpStatusCode.OK, response.StatusCode); 184Assert.Equal(HttpStatusCode.OK, response.StatusCode); 205Assert.Equal(HttpStatusCode.OK, response.StatusCode);

XmlDataContractSerializerInputFormatterTest.cs (5)

33Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 58Assert.Equal(10, modelBindingInfo.Store.Id); 60Assert.Equal(98052, modelBindingInfo.Store.Address.Zipcode); 89Assert.Equal(10, modelBindingInfo.Store.Id); 92Assert.Equal(expectedErrorMessages.Count(), modelBindingInfo.ModelStateErrorMessages.Count);

XmlOutputFormatterTests.cs (12)

XmlSerializerFormattersWrappingTest.cs (8)

40Assert.Equal(HttpStatusCode.OK, response.StatusCode); 61Assert.Equal(HttpStatusCode.OK, response.StatusCode); 82Assert.Equal(HttpStatusCode.OK, response.StatusCode); 102Assert.Equal(HttpStatusCode.OK, response.StatusCode); 122Assert.Equal(HttpStatusCode.OK, response.StatusCode); 144Assert.Equal(HttpStatusCode.OK, response.StatusCode); 164Assert.Equal(HttpStatusCode.OK, response.StatusCode); 182Assert.Equal(HttpStatusCode.OK, response.StatusCode);

XmlSerializerInputFormatterTests.cs (2)

35Assert.Equal(HttpStatusCode.OK, response.StatusCode); 52Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);

ActionParametersIntegrationTest.cs (20)

70Assert.Equal("SomeStreet", modelState[key].RawValue); 72Assert.Equal(ModelValidationState.Valid, modelState[key].ValidationState); 116Assert.Equal(ModelValidationState.Valid, state.ValidationState); 117Assert.Equal("SomeStreet", state.RawValue); 164Assert.Equal("SomeStreet", modelState[key].RawValue); 166Assert.Equal(ModelValidationState.Valid, modelState[key].ValidationState); 250Assert.Equal("SomeStreet", modelState[key].RawValue); 252Assert.Equal(ModelValidationState.Valid, modelState[key].ValidationState); 296Assert.Equal(ModelValidationState.Valid, state.ValidationState); 298Assert.Equal("SomeStreet", state.RawValue); 341Assert.Equal("SomeStreet", modelState[key].RawValue); 343Assert.Equal(ModelValidationState.Valid, modelState[key].ValidationState); 444Assert.Equal(23, model.Age); 625Assert.Equal(100, boundModel.Id); 738Assert.Equal(input.HasValue, modelBindingResult.IsModelSet); 739Assert.Equal(isValid, modelState.IsValid); 742Assert.Equal(input.Value, Assert.IsType<int>(modelBindingResult.Model)); 791Assert.Equal(input != null, modelBindingResult.IsModelSet); 792Assert.Equal(isValid, modelState.IsValid); 1076Assert.Equal(typeof(ClassWithNoDefaultConstructor), bindingContext.ModelType);

ArrayModelBinderIntegrationTest.cs (29)

AuthorizeFilterIntegrationTest.cs (4)

49Assert.Equal(2, policyProvider.GetPolicyCount); 77Assert.Equal(2, getPolicyCalled); 116Assert.Equal(4, getPolicyCalled); 152Assert.Equal(4, policyProvider.GetPolicyCount);

BinderTypeBasedModelBinderIntegrationTest.cs (6)

112Assert.Equal("Success", modelBindingResult.Model); 118Assert.Equal(ModelValidationState.Valid, modelState[key].ValidationState); 185Assert.Equal(ModelValidationState.Valid, entry.ValidationState); 237Assert.Equal(ModelValidationState.Valid, entry.ValidationState); 273Assert.Equal(ModelValidationState.Valid, modelState[key].ValidationState); 312Assert.Equal(ModelValidationState.Valid, modelState[key].ValidationState);

BindingSourceMetadataProviderIntegrationTest.cs (1)

56Assert.Equal(token, boundPerson.Token);

BindPropertyIntegrationTest.cs (7)

172Assert.Equal(input.HasValue, result.IsModelSet); 173Assert.Equal(isValid, testContext.ModelState.IsValid); 176Assert.Equal(input.Value, Assert.IsType<int>(result.Model)); 241Assert.Equal(isValid, pageContext.ModelState.IsValid); 244Assert.Equal(input.Value, page.BindRequiredProperty); 291Assert.Equal(input != null, result.IsModelSet); 292Assert.Equal(isValid, testContext.ModelState.IsValid);

BodyValidationIntegrationTests.cs (7)

89Assert.Equal(2, products.Count()); 296Assert.Equal(2, modelStateErrors.Count); 540Assert.Equal(5, boundPerson.Address.Number); 541Assert.Equal(0, boundPerson.Address.RequiredNumber); 585Assert.Equal(1, modelState.ErrorCount); 640Assert.Equal(ModelValidationState.Invalid, street.ValidationState); 737Assert.Equal(ModelValidationState.Invalid, street.ValidationState);

ByteArrayModelBinderIntegrationTest.cs (5)

56Assert.Equal(expectedValue, boundPerson.Token); 64Assert.Equal(ModelValidationState.Valid, entry.Value.ValidationState); 66Assert.Equal(value, entry.Value.RawValue); 138Assert.Equal(expectedValue, model); 146Assert.Equal(value, entry.Value.RawValue);

CollectionModelBinderIntegrationTest.cs (73)

ComplexRecordIntegrationTest.cs (207)

ComplexTypeIntegrationTestBase.cs (183)

DictionaryModelBinderIntegrationTest.cs (71)

FormCollectionModelBindingIntegrationTest.cs (1)

70Assert.Equal(ModelValidationState.Valid, entry.Value.ValidationState);

FormFileModelBindingIntegrationTest.cs (28)

GenericModelBinderIntegrationTest.cs (39)

HeaderModelBinderIntegrationTest.cs (30)

KeyValuePairModelBinderIntegrationTest.cs (52)

ModelPrefixSelectionIntegrationTest.cs (5)

56Assert.Equal(0, modelState.ErrorCount); 105Assert.Equal(0, modelState.ErrorCount); 144Assert.Equal(0, modelState.ErrorCount); 193Assert.Equal(0, modelState.ErrorCount); 239Assert.Equal(0, modelState.ErrorCount);

NullableReferenceTypeIntegrationTest.cs (3)

54Assert.Equal(ModelValidationState.Invalid, kvp.Value.ValidationState); 141Assert.Equal(ModelValidationState.Invalid, kvp.Value.ValidationState); 196Assert.Equal(ModelValidationState.Invalid, kvp.Value.ValidationState);

SimpleTypeModelBinderIntegrationTest.cs (36)

TryUpdateModelIntegrationTest.cs (50)

TryValidateModelIntegrationTest.cs (2)

148Assert.Equal(2, modelStateErrors.Count); 195Assert.Equal(

ValidationIntegrationTests.cs (140)

ValidationWithRecordIntegrationTests.cs (137)

HtmlLocalizerOfTTest.cs (2)

29Assert.Equal(localizedString, actualLocalizedString); 51Assert.Equal(localizedString, actualLocalizedString);

HtmlLocalizerTest.cs (1)

244Assert.Equal(2, allLocalizedStrings.Count);

MvcLocalizationMvcBuilderExtensionsTest.cs (12)

49Assert.Equal(ServiceLifetime.Singleton, service.Lifetime); 50Assert.Equal(typeof(ResourceManagerStringLocalizerFactory), service.ImplementationType); 55Assert.Equal(ServiceLifetime.Transient, service.Lifetime); 56Assert.Equal(typeof(StringLocalizer<>), service.ImplementationType); 62Assert.Equal(ServiceLifetime.Transient, service.Lifetime); 67Assert.Equal(ServiceLifetime.Singleton, service.Lifetime); 71Assert.Equal(typeof(HtmlLocalizerFactory), service.ImplementationType); 72Assert.Equal(ServiceLifetime.Singleton, service.Lifetime); 76Assert.Equal(typeof(HtmlLocalizer<>), service.ImplementationType); 77Assert.Equal(ServiceLifetime.Transient, service.Lifetime); 81Assert.Equal(typeof(ViewLocalizer), service.ImplementationType); 82Assert.Equal(ServiceLifetime.Transient, service.Lifetime);

MvcLocalizationMvcCoreBuilderExtensionsTest.cs (12)

49Assert.Equal(ServiceLifetime.Singleton, service.Lifetime); 50Assert.Equal(typeof(ResourceManagerStringLocalizerFactory), service.ImplementationType); 55Assert.Equal(ServiceLifetime.Transient, service.Lifetime); 56Assert.Equal(typeof(StringLocalizer<>), service.ImplementationType); 62Assert.Equal(ServiceLifetime.Transient, service.Lifetime); 67Assert.Equal(ServiceLifetime.Transient, service.Lifetime); 71Assert.Equal(typeof(HtmlLocalizerFactory), service.ImplementationType); 72Assert.Equal(ServiceLifetime.Singleton, service.Lifetime); 76Assert.Equal(typeof(HtmlLocalizer<>), service.ImplementationType); 77Assert.Equal(ServiceLifetime.Transient, service.Lifetime); 81Assert.Equal(typeof(ViewLocalizer), service.ImplementationType); 82Assert.Equal(ServiceLifetime.Transient, service.Lifetime);

ViewLocalizerTest.cs (3)

79Assert.Equal(localizedString, actualLocalizedString); 111Assert.Equal(localizedString, actualLocalizedString); 160Assert.Equal(2, allLocalizedStrings.Count);

BsonTempDataSerializerTest.cs (5)

108Assert.Equal(value, roundTripValue); 129Assert.Equal(value, roundTripValue); 150Assert.Equal(value, roundTripValue); 172Assert.Equal(value, roundTripValue); 193Assert.Equal(value, roundTripValue);

JsonPatchExtensionsTest.cs (2)

61Assert.Equal(0, modelState.ErrorCount); 86Assert.Equal(1, modelState.ErrorCount);

JsonPatchOperationsArrayProviderTests.cs (3)

45Assert.Equal(typeof(Operation[]), description.Type); 46Assert.Equal(typeof(Operation[]), description.ModelMetadata.ModelType); 50Assert.Equal(typeof(string), description.Type);

JsonResultTest.cs (1)

35Assert.Equal(expected, written);

NewtonsoftJsonInputFormatterTest.cs (8)

54Assert.Equal(30, userModel.Age); 90Assert.Equal(30, userModel.Age); 128Assert.Equal(30, userModel.Age); 193Assert.Equal(settings.MaxDepth, actual.MaxDepth); 194Assert.Equal(settings.DateTimeZoneHandling, actual.DateTimeZoneHandling); 466Assert.Equal("Hello world", result.Model); 517Assert.Equal(new DateTime(2019, 05, 15, 00, 00, 00, DateTimeKind.Unspecified), userModel.DateValue); 559Assert.Equal(0, location?.Id);

NewtonsoftJsonOutputFormatterTest.cs (2)

85Assert.Equal(1, ((FileBufferingWriteStream)writeStream).MemoryThreshold); 117Assert.Equal(2, ((FileBufferingWriteStream)writeStream).MemoryThreshold);

NewtonsoftJsonPatchInputFormatterTest.cs (5)

53Assert.Equal("John", patchDocument.Operations[0].value); 93Assert.Equal("John", patchDocument.Operations[0].value); 123Assert.Equal("John", patchDocument.Operations[0].value); 147Assert.Equal("John", patchDocument.Operations[0].value); 172Assert.Equal(expectedCanRead, result);

NewtonsoftJsonResultExecutorTest.cs (1)

52Assert.Equal(cts.Token, token);

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

47Assert.Equal(expectedCanRead, result); 81Assert.Equal(100, intValue); 229Assert.Equal(expected, dateValue); 251Assert.Equal(30, userModel.Age); 272Assert.Equal(new int[] { 0, 23, 300 }, integers); 463Assert.Equal(expectedIsModelSet, result.IsModelSet);

src\Mvc\Mvc.Core\test\Formatters\JsonOutputFormatterTestBase.cs (2)

55Assert.Equal(expectedResult != null, actualCanWriteValue); 56Assert.Equal(new StringSegment(expectedContentType), outputFormatterContext.ContentType);

src\Mvc\Mvc.Core\test\Infrastructure\AsyncEnumerableReaderTest.cs (8)

44Assert.Equal(new[] { "0", "1", "2", }, collection); 62Assert.Equal(new[] { 0, 1, 2, }, collection); 113Assert.Equal(expected, await reader(asyncEnumerable1, default)); 114Assert.Equal(expected, await reader(asyncEnumerable2, default)); 130Assert.Equal(new[] { "0", "1", "2" }, await reader(asyncEnumerable1, default)); 131Assert.Equal(new[] { "0", "1", "2", "3" }, await reader(asyncEnumerable2, default)); 167Assert.Equal(new[] { "0", "1", "2", }, collection); 217Assert.Equal(cts.Token, token);

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 (10)

65Assert.Equal(value, roundTripValue); 87Assert.Equal(value, roundTripValue); 129Assert.Equal(value, roundTripValue); 150Assert.Equal(value, roundTripValue); 171Assert.Equal(value, roundTripValue); 237Assert.Equal(value, roundTripValue); 258Assert.Equal(value, roundTripValue); 279Assert.Equal(value, roundTripValue); 325Assert.Equal(value, roundTripValue); 350Assert.Equal(value, roundTripValue);

CompilerFailedExceptionFactoryTest.cs (28)

186Assert.Equal(3, message.StartLine); 187Assert.Equal(17, message.StartColumn); 188Assert.Equal(3, message.EndLine); 189Assert.Equal(18, message.EndColumn); 195Assert.Equal(5, message.StartLine); 196Assert.Equal(6, message.StartColumn); 197Assert.Equal(5, message.EndLine); 198Assert.Equal(13, message.EndColumn); 204Assert.Equal(0, message.StartLine); 205Assert.Equal(-1, message.StartColumn); 206Assert.Equal(0, message.EndLine); 207Assert.Equal(-2, message.EndColumn); 219Assert.Equal(4, message.StartLine); 220Assert.Equal(8, message.StartColumn); 221Assert.Equal(4, message.EndLine); 222Assert.Equal(12, message.EndColumn); 276Assert.Equal(11, message.StartLine); 277Assert.Equal(2, message.StartColumn); 278Assert.Equal(11, message.EndLine); 279Assert.Equal(3, message.EndColumn); 285Assert.Equal(31, message.StartLine); 286Assert.Equal(6, message.StartColumn); 287Assert.Equal(41, message.EndLine); 288Assert.Equal(13, message.EndColumn); 300Assert.Equal(2, message.StartLine); 301Assert.Equal(3, message.StartColumn); 302Assert.Equal(4, message.EndLine); 303Assert.Equal(5, message.EndColumn);

CSharpCompilerTest.cs (7)

65Assert.Equal(expected, compilationOptions.OptimizationLevel); 96Assert.Equal(ReportDiagnostic.Default, compilationOptions.GeneralDiagnosticOption); 97Assert.Equal(OptimizationLevel.Debug, compilationOptions.OptimizationLevel); 102Assert.Equal(ReportDiagnostic.Suppress, item.Value); 107Assert.Equal(ReportDiagnostic.Suppress, item.Value); 112Assert.Equal(ReportDiagnostic.Suppress, item.Value); 125Assert.Equal(LanguageVersion.CSharp8, parseOptions.LanguageVersion);

DependencyInjection\RazorRuntimeCompilationMvcCoreBuilderExtensionsTest.cs (3)

26Assert.Equal(typeof(RuntimeViewCompilerProvider), serviceDescriptor.ImplementationType); 41Assert.Equal(typeof(PageActionDescriptorProvider), serviceDescriptor.ImplementationType); 44Assert.Equal(typeof(PageLoaderMatcherPolicy), serviceDescriptor.ImplementationType);

Compilation\DefaultRazorPageFactoryProviderTest.cs (1)

70Assert.Equal(expirationTokens, descriptor.ExpirationTokens);

Compilation\RazorPagePropertyActivatorTest.cs (4)

76Assert.Equal("test-value", viewDataDictionary["test-key"]); 105Assert.Equal("test-value", viewDataDictionary["test-key"]); 134Assert.Equal("test-value", viewDataDictionary["test-key"]); 163Assert.Equal("test-value", viewDataDictionary["test-key"]);

DefaultTagHelperFactoryTest.cs (4)

45Assert.Equal(number, helper.Number); 92Assert.Equal(200, helper.Number); 131Assert.Equal(100, testTagHelper.Number); 133Assert.Equal(102, anotherTestTagHelper.Number);

DependencyInjection\MvcRazorMvcBuilderExtensionsTest.cs (8)

29Assert.Equal(typeof(ServiceBasedTagHelperActivator), activatorDescriptor.ImplementationType); 52Assert.Equal(3, collection.Count); 55Assert.Equal(typeof(TestTagHelperOne), tagHelperOne.ImplementationType); 56Assert.Equal(ServiceLifetime.Transient, tagHelperOne.Lifetime); 59Assert.Equal(typeof(TestTagHelperTwo), tagHelperTwo.ImplementationType); 60Assert.Equal(ServiceLifetime.Transient, tagHelperTwo.Lifetime); 63Assert.Equal(typeof(ServiceBasedTagHelperActivator), activator.ImplementationType); 64Assert.Equal(ServiceLifetime.Transient, activator.Lifetime);

DependencyInjection\MvcRazorMvcCoreBuilderExtensionsTest.cs (8)

69Assert.Equal(typeof(ServiceBasedTagHelperActivator), activatorDescriptor.ImplementationType); 92Assert.Equal(3, collection.Count); 95Assert.Equal(typeof(TestTagHelperOne), tagHelperOne.ImplementationType); 96Assert.Equal(ServiceLifetime.Transient, tagHelperOne.Lifetime); 99Assert.Equal(typeof(TestTagHelperTwo), tagHelperTwo.ImplementationType); 100Assert.Equal(ServiceLifetime.Transient, tagHelperTwo.Lifetime); 103Assert.Equal(typeof(ServiceBasedTagHelperActivator), activator.ImplementationType); 104Assert.Equal(ServiceLifetime.Transient, activator.Lifetime);

RazorPageActivatorTest.cs (2)

137Assert.Equal("value", viewData["key"]); 190Assert.Equal("value", viewContext.ViewData["key"]);

RazorPageCreateModelExpressionTest.cs (10)

RazorPageTest.cs (47)

RazorViewEngineTest.cs (1)

329Assert.Equal(new[] { viewStart1, viewStart2 }, view.ViewStartPages);

RazorViewTest.cs (2)

1776Assert.Equal(3, onAfterPageActivatedCalled); 1782Assert.Equal(expected, activated);

TagHelpers\TagHelperComponentTagHelperTest.cs (9)

35Assert.Equal(1, incrementer); 43Assert.Equal(2, incrementer); 51Assert.Equal(0, incrementer); 63Assert.Equal(3, incrementer); 91Assert.Equal(1, incrementer); 99Assert.Equal(2, incrementer); 107Assert.Equal(0, incrementer); 119Assert.Equal(3, incrementer); 150Assert.Equal("Value", tagHelperContext.Items["Key"]);

TagHelpers\UrlResolutionTagHelperTest.cs (5)

105Assert.Equal(HtmlAttributeValueStyle.DoubleQuotes, attribute.ValueStyle); 162Assert.Equal(HtmlAttributeValueStyle.DoubleQuotes, attribute.ValueStyle); 220Assert.Equal(HtmlAttributeValueStyle.DoubleQuotes, attribute.ValueStyle); 276Assert.Equal(HtmlAttributeValueStyle.DoubleQuotes, attribute.ValueStyle); 306Assert.Equal(HtmlAttributeValueStyle.DoubleQuotes, attribute.ValueStyle);

ApplicationModels\AuthorizationPageApplicationModelProviderTest.cs (1)

131Assert.Equal(3, authorizeFilter.Policy.Requirements.Count);

ApplicationModels\CompiledPageActionDescriptorBuilderTest.cs (8)

175Assert.Equal(FilterScope.Global, filterDescriptor.Scope); 180Assert.Equal(FilterScope.Action, filterDescriptor.Scope); 235Assert.Equal(handlerModel.MethodInfo, d.MethodInfo); 288Assert.Equal(parameters[0], p.ParameterInfo); 289Assert.Equal(typeof(string), p.ParameterType); 294Assert.Equal(parameters[1], p.ParameterInfo); 295Assert.Equal(typeof(int), p.ParameterType); 423Assert.Equal(new[] { metadata1, metadata2, metadata3, metadata4, metadata5, metadata6 }, actual.EndpointMetadata);

ApplicationModels\DefaultPageApplicationModelProviderTest.cs (29)

ApplicationModels\ResponseCacheFilterApplicationModelProviderTest.cs (3)

74Assert.Equal(12, filter.Duration); 120Assert.Equal(new[] { "A" }, filter.VaryByQueryKeys); 121Assert.Equal(14, filter.Duration);

ApplicationModels\TempDataFilterPageApplicationModelProviderTest.cs (1)

95Assert.Equal(type.GetProperty(nameof(TestPageModel_OneTempDataProperty.Test2)), property.PropertyInfo);

DependencyInjection\RazorPagesRazorViewEngineOptionsSetupTest.cs (6)

35Assert.Equal(expected, viewEngineOptions.PageViewLocationFormats); 58Assert.Equal(expected, viewEngineOptions.PageViewLocationFormats); 83Assert.Equal(expected, viewEngineOptions.AreaPageViewLocationFormats); 111Assert.Equal(expected, viewEngineOptions.AreaPageViewLocationFormats); 137Assert.Equal(expected, viewEngineOptions.ViewLocationFormats); 164Assert.Equal(expected, viewEngineOptions.AreaViewLocationFormats);

Filters\PageSaveTempDataPropertyFilterTest.cs (2)

38Assert.Equal("TestString", tempData["TempDataProperty-Test"]); 186Assert.Equal("New-Value", item.Value);

Filters\PageViewDataAttributeFilterTest.cs (2)

83Assert.Equal("New-Value", kvp.Value); 88Assert.Equal("Test", kvp.Value);

Infrastructure\DefaultPageFactoryProviderTest.cs (1)

243Assert.Equal("test-value", testPage.ViewData["test-key"]);

Infrastructure\DefaultPageLoaderTest.cs (8)

50Assert.Equal(0, sequence++); 59Assert.Equal(1, sequence++); 68Assert.Equal(3, sequence++); 76Assert.Equal(2, sequence++); 172Assert.Equal(1, sequence++); 180Assert.Equal(0, sequence++); 187Assert.Equal(2, sequence++); 194Assert.Equal(3, sequence++);

Infrastructure\DynamicPageEndpointMatcherPolicyTest.cs (7)

211Assert.Equal("/Index", kvp.Value); 252Assert.Equal("/Index", kvp.Value); 257Assert.Equal("test", kvp.Value); 373Assert.Equal(1, candidates.Count); 379Assert.Equal("/Index", kvp.Value); 384Assert.Equal("test", kvp.Value); 430Assert.Equal(2, candidates.Count);

Infrastructure\PageActionEndpointDataSourceTest.cs (4)

159Assert.Equal(new[] { "group", "A", "Hi there" }, e.Metadata.GetOrderedMetadata<string>()); 166Assert.Equal(new[] { "group", "B", "Hi there" }, e.Metadata.GetOrderedMetadata<string>()); 209Assert.Equal(new[] { "A1", "A2" }, e.Metadata.GetOrderedMetadata<string>()); 257Assert.Equal(new[] { "initial-metadata", "initial-metadata-observed" }, e.Metadata.GetOrderedMetadata<string>());

Infrastructure\PageActionInvokerProviderTest.cs (1)

195Assert.Equal(new[] { factory2, factory1 }, entry.ViewStartFactories);

Infrastructure\PageActionInvokerTest.cs (3)

54Assert.Equal(1, routeValues.Count); 111Assert.Equal(2, pageContext.ValueProviderFactories.Count); 145Assert.Equal(1, pageContext.ValueProviderFactories.Count);

Infrastructure\PageBinderFactoryTest.cs (4)

229Assert.Equal(10, page.Id); 292Assert.Equal(default, page.Id); 295Assert.Equal(10, model.Id); 614Assert.Equal("value", kvp.Value);

Infrastructure\PageViewLocationExpanderTest.cs (4)

108Assert.Equal(expected, actual.ToArray()); 139Assert.Equal(expected, actual.ToArray()); 160Assert.Equal(expected, actual.ToArray()); 198Assert.Equal(expected, actual.ToArray());

PageLoggerExtensionsTest.cs (1)

179Assert.Equal(2, testSink.Writes.Count);

PageModelTest.cs (21)

PageTest.cs (21)

src\Mvc\Mvc.Core\test\Routing\ActionEndpointDataSourceBaseTest.cs (5)

36Assert.Equal("Value", endpoint.RoutePattern.RequiredValues["Name"]); 100Assert.Equal("TestController", routePattern.RequiredValues["controller"]); 101Assert.Equal("TestAction", routePattern.RequiredValues["action"]); 122Assert.Equal("NewTestController", routePattern.RequiredValues["controller"]); 123Assert.Equal("NewTestAction", routePattern.RequiredValues["action"]);

RouteDataTest.cs (13)

VirtualPathDataTests.cs (1)

43Assert.Equal("TestValue", pathData.DataTokens["TestKey"]);

AnchorTagHelperTest.cs (4)

78Assert.Equal(2, output.Attributes.Count); 80Assert.Equal("myanchor", attribute.Value); 82Assert.Equal("home/index", attribute.Value); 455Assert.Equal("test-area", item.Value);

AttributeMatcherTest.cs (2)

61Assert.Equal(Mode.B, result); 90Assert.Equal(Mode.D, result);

CacheTagHelperTest.cs (13)

205Assert.Equal(expiresOn, cacheEntryOptions.AbsoluteExpiration); 265Assert.Equal(slidingExpiresIn, cacheEntryOptions.SlidingExpiration); 283Assert.Equal(expiresAfter, cacheEntryOptions.AbsoluteExpirationRelativeToNow); 301Assert.Equal(expiresSliding, cacheEntryOptions.SlidingExpiration); 319Assert.Equal(priority, cacheEntryOptions.Priority); 619Assert.Equal(1, calls); 702Assert.Equal(2, calls); 755Assert.Equal(1, counter); 767Assert.Equal(2, counter); 779Assert.Equal(3, counter); 791Assert.Equal(3, counter); 880Assert.Equal(1, invokeCount); 923Assert.Equal(1, invokeCount); // We expect getChildContentAsync to be invoked exactly once.

CacheTagKeyTest.cs (3)

65Assert.Equal(cacheTagKey1, cacheTagKey2); 116Assert.Equal(hashcode1, hashcode2); 535Assert.Equal(hashCode1, hashCode2);

DefaultFileVersionProviderTest.cs (2)

281Assert.Equal(expected, cacheEntry.Value); 282Assert.Equal(expectedSize, cacheEntry.Size);

DistributedCacheTagHelperTest.cs (6)

267Assert.Equal(expiresOn, cacheEntryOptions.AbsoluteExpiration); 290Assert.Equal(slidingExpiresIn, cacheEntryOptions.SlidingExpiration); 316Assert.Equal(expiresAfter, cacheEntryOptions.AbsoluteExpirationRelativeToNow); 342Assert.Equal(expiresSliding, cacheEntryOptions.SlidingExpiration); 622Assert.Equal(1, calls); 714Assert.Equal(2, calls);

FormActionTagHelperTest.cs (8)

86Assert.Equal(TagMode.StartTagAndEndTag, output.TagMode); 160Assert.Equal(TagMode.StartTagAndEndTag, output.TagMode); 250Assert.Equal("home/index", attribute.Value); 308Assert.Equal("home/index", attribute.Value); 381Assert.Equal("admin/dashboard/index", attribute.Value); 434Assert.Equal("admin/dashboard/index", attribute.Value); 466Assert.Equal("test-area", item.Value); 471Assert.Equal("/my-page", item.Value);

FormTagHelperTest.cs (29)

GlobbingUrlBuilderTest.cs (1)

425Assert.Equal(38, cacheEntry.Size);

ImageTagHelperTest.cs (7)

119Assert.Equal(4, output.Attributes.Count); 158Assert.Equal(2, output.Attributes.Count); 160Assert.Equal("/images/test-image.png?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", srcAttribute.Value); 190Assert.Equal(2, output.Attributes.Count); 192Assert.Equal("/images/test-image.png", srcAttribute.Value); 222Assert.Equal(2, output.Attributes.Count); 224Assert.Equal("/bar/images/image.jpg?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", srcAttribute.Value);

InputTagHelperTest.cs (33)

JavaScriptResourcesTest.cs (1)

68Assert.Equal(1, callCount);

LabelTagHelperTest.cs (3)

218Assert.Equal(expectedAttributes, output.Attributes); 224Assert.Equal(TagMode.StartTagAndEndTag, output.TagMode); 327Assert.Equal(expectedAttributes, output.Attributes);

LinkTagHelperTest.cs (10)

168Assert.Equal(expectedAttributes, output.Attributes); 600Assert.Equal("/css/site.css", output.Attributes["href"].Value); 641Assert.Equal("/css/site.css", output.Attributes["href"].Value); 694Assert.Equal("/css/site.css", output.Attributes["href"].Value); 725Assert.Equal("/css/site.css?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", output.Attributes["href"].Value); 755Assert.Equal("/bar/css/site.css?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", output.Attributes["href"].Value); 808Assert.Equal("/css/site.css?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", output.Attributes["href"].Value); 878Assert.Equal("/css/site.css?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", output.Attributes["href"].Value); 918Assert.Equal("/css/site.css?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", output.Attributes["href"].Value); 1097Assert.Equal(CultureInfo.InvariantCulture, provider);

OptionTagHelperTest.cs (1)

438Assert.Equal(expectedTagHelperOutput.Attributes.Count, output.Attributes.Count);

ScriptTagHelperTest.cs (8)

113Assert.Equal(expectedAttributes, output.Attributes); 559Assert.Equal("/js/site.js", output.Attributes["src"].Value); 612Assert.Equal("/js/site.js", output.Attributes["src"].Value); 638Assert.Equal("/js/site.js?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", output.Attributes["src"].Value); 663Assert.Equal("/bar/js/site.js?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", output.Attributes["src"].Value); 691Assert.Equal("/js/site.js?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", output.Attributes["src"].Value); 744Assert.Equal("/js/site.js?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", output.Attributes["src"].Value); 782Assert.Equal("/js/site.js?v=f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk", output.Attributes["src"].Value);

SelectTagHelperTest.cs (11)

239Assert.Equal(TagMode.SelfClosing, output.TagMode); 240Assert.Equal(expectedAttributes, output.Attributes); 338Assert.Equal(TagMode.SelfClosing, output.TagMode); 339Assert.Equal(expectedAttributes, output.Attributes); 419Assert.Equal(TagMode.SelfClosing, output.TagMode); 420Assert.Equal(expectedAttributes, output.Attributes); 427Assert.Equal(typeof(SelectTagHelper), kvp.Key); 518Assert.Equal(TagMode.SelfClosing, output.TagMode); 519Assert.Equal(expectedAttributes, output.Attributes); 776Assert.Equal(expectedAttributeValue, attribute.Value); 825Assert.Equal(expectedAttributeValue, attribute.Value);

TagHelperOutputExtensionsTest.cs (14)

TextAreaTagHelperTest.cs (3)

151Assert.Equal(TagMode.SelfClosing, output.TagMode); 152Assert.Equal(expectedAttributes, output.Attributes); 232Assert.Equal(expectedAttributeValue, attribute.Value);

ValidationMessageTagHelperTest.cs (15)

ValidationSummaryTagHelperTest.cs (3)

447Assert.Equal("something", attribute.Value); 452Assert.Equal("bar", attribute.Value); 457Assert.Equal("world", attribute.Value);

MvcOptionsSetupTest.cs (22)

MvcServiceCollectionExtensionsTest.cs (6)

311Assert.Equal(ServiceLifetime.Singleton, descriptor.Lifetime); 315Assert.Equal(2, manager.ApplicationParts.Count); 339Assert.Equal(ServiceLifetime.Singleton, descriptor.Lifetime); 343Assert.Equal(2, manager.ApplicationParts.Count); 365Assert.Equal(ServiceLifetime.Singleton, descriptor.Lifetime); 437Assert.Equal(typeof(CookieTempDataProvider), descriptor.ImplementationType);

AttributeDictionaryTest.cs (41)

Buffers\PagedBufferedTextWriterTest.cs (5)

70Assert.Equal(4096, Content.Length); // Update these numbers if this changes. 93Assert.Equal(Content[i], array[i]); 122Assert.Equal(4096, Content.Length); // Update these numbers if this changes. 167Assert.Equal(4096, Content.Length); // Update these numbers if this changes. 260Assert.Equal(3, pool.Returned.Count);

Buffers\PagedCharBufferTest.cs (26)

22Assert.Equal(1, buffer.Length); 23Assert.Equal(charToAppend, page[buffer.Length - 1]); 40page => Assert.Equal(stringToAppend.ToCharArray(), page), 41page => Assert.Equal(charToAppend, page[0])); 60Assert.Equal(4, buffer.Length); 76Assert.Equal(PagedCharBuffer.PageSize, buffer.Length); 79Assert.Equal('t', page[PagedCharBuffer.PageSize - 1]); 103page => Assert.Equal(stringToAppend.ToCharArray(), page), 104page => Assert.Equal(charToAppend, page[0])); 129Assert.Equal('t', page[2 * PagedCharBuffer.PageSize - 1]); 143Assert.Equal(3, buffer.Length); 166page => Assert.Equal('d', page[0])); 227page => Assert.Equal('d', page[0])); 256page => Assert.Equal('d', page[0])); 272Assert.Equal(6, buffer.Length); 288Assert.Equal(3, buffer.Length); 313Assert.Equal(ch, page[0]); 314Assert.Equal(ch, page[1]); 315Assert.Equal(ch, page[2]); 377page => Assert.Equal('d', page[0])); 406page => Assert.Equal('d', page[0])); 421Assert.Equal(5, buffer.Length); 436Assert.Equal(0, buffer.Length); 453Assert.Equal(0, buffer.Length); 469Assert.Equal(0, buffer.Length); 476Assert.Equal(4, buffer.Length);

Buffers\ViewBufferTextWriterTest.cs (2)

32Assert.Equal(expected, GetValues(buffer)); 56Assert.Equal(expected, GetValues(buffer));

ControllerTest.cs (3)

52Assert.Equal("property", controller.ViewData["Another"]); 383Assert.Equal(input, result); 425Assert.Equal(expectedType, controller.ViewData.ModelMetadata.ModelType);

ControllerUnitTestabilityTests.cs (30)

CookieTempDataProviderTest.cs (12)

110Assert.Equal(expectedDataToUnprotect, dataProtector.DataToUnprotect); 133Assert.Equal(1, responseCookies.Count); 137Assert.Equal(expectedDataToProtect, dataProtector.PlainTextToProtect); 169Assert.Equal(1, responseCookies.Count); 173Assert.Equal(expectedDataToProtect, dataProtector.PlainTextToProtect); 175Assert.Equal(expectedSecureFlag, cookieInfo.Options.Secure); 204Assert.Equal(1, responseCookies.Count); 208Assert.Equal(expectedDataToProtect, dataProtector.PlainTextToProtect); 253Assert.Equal(1, responseCookies.Count); 257Assert.Equal(expectedDataToProtect, dataProtector.PlainTextToProtect); 287Assert.Equal(CookieTempDataProvider.CookieName, cookie.Name); 288Assert.Equal(string.Empty, cookie.Value);

DefaultHtmlGeneratorTest.cs (5)

211Assert.Equal(expectedValue, int.Parse(attribute.Value, CultureInfo.InvariantCulture)); 235Assert.Equal(expectedValue, int.Parse(attribute.Value, CultureInfo.InvariantCulture)); 259Assert.Equal(expectedValue, int.Parse(attribute.Value, CultureInfo.InvariantCulture)); 281Assert.Equal(Math.Min(ModelWithMaxLengthMetadata.MaxLengthAttributeValue, ModelWithMaxLengthMetadata.StringLengthAttributeValue), int.Parse(attribute.Value, CultureInfo.InvariantCulture)); 327Assert.Equal(expectedValue, int.Parse(attribute.Value, CultureInfo.InvariantCulture));

DependencyInjection\MvcViewFeaturesMvcBuilderExtensionsTest.cs (14)

DependencyInjection\MvcViewFeaturesMvcCoreBuilderExtensionsTest.cs (9)

ExpressionMetadataProviderTest.cs (16)

30Assert.Equal(ModelMetadataKind.Type, explorer.Metadata.MetadataKind); 31Assert.Equal(typeof(TestModel), explorer.ModelType); 48Assert.Equal(ModelMetadataKind.Property, explorer.Metadata.MetadataKind); 49Assert.Equal(typeof(Category), explorer.ModelType); 66Assert.Equal(ModelMetadataKind.Type, explorer.Metadata.MetadataKind); 67Assert.Equal(typeof(TestModel), explorer.ModelType); 88Assert.Equal(ModelMetadataKind.Property, explorer.Metadata.MetadataKind); 89Assert.Equal(typeof(int), explorer.ModelType); 132Assert.Equal(expectedKind, explorer.Metadata.MetadataKind); 133Assert.Equal(expectedType, explorer.ModelType); 173Assert.Equal(ModelMetadataKind.Type, explorer.Metadata.MetadataKind); 174Assert.Equal(typeof(string), explorer.ModelType); 195Assert.Equal(ModelMetadataKind.Type, explorer.Metadata.MetadataKind); 196Assert.Equal(typeof(string), explorer.ModelType); 217Assert.Equal(ModelMetadataKind.Type, explorer.Metadata.MetadataKind); 218Assert.Equal(typeof(string), explorer.ModelType);

Filters\ControllerSaveTempDataPropertyFilterTest.cs (6)

56Assert.Equal("SecondValue", tempData["TempDataProperty-Test"]); 57Assert.Equal(0, controller.Test2); 100Assert.Equal(0, controller.Test2); 143Assert.Equal(0, controller.Test2); 190Assert.Equal("New-Value", item.Value); 195Assert.Equal(42, item.Value);

Filters\ControllerViewDataAttributeFilterTest.cs (2)

78Assert.Equal("New-Value", kvp.Value); 83Assert.Equal("Test", kvp.Value);

Filters\LifecyclePropertyTest.cs (2)

20Assert.Equal("test-value", value); 65Assert.Equal(42, subject.ValueTypeProperty);

HtmlAttributePropertyHelperTest.cs (2)

53Assert.Equal("baz", helper.GetValue(anonymous)); 68Assert.Equal(32, helper.GetValue(anonymous));

Infrastructure\TempDataSerializerTestBase.cs (10)

65Assert.Equal(value, roundTripValue); 87Assert.Equal(value, roundTripValue); 129Assert.Equal(value, roundTripValue); 150Assert.Equal(value, roundTripValue); 171Assert.Equal(value, roundTripValue); 237Assert.Equal(value, roundTripValue); 258Assert.Equal(value, roundTripValue); 279Assert.Equal(value, roundTripValue); 325Assert.Equal(value, roundTripValue); 350Assert.Equal(value, roundTripValue);

MemberExpressionCacheKeyComparerTest.cs (2)

161Assert.Equal(hashCode1, hashCode2); 169Assert.Equal(hashCode1, cachedKeyHashCode1);

MemberExpressionCacheKeyTest.cs (3)

28Assert.Equal(expected, actual); 48Assert.Equal(expected, actual); 67Assert.Equal(expected, actual);

ModelExplorerTest.cs (10)

PageRemoteAttributeTest.cs (1)

56Assert.Equal(2, routeDictionary.Count);

PartialViewResultExecutorTest.cs (1)

330Assert.Equal(404, context.HttpContext.Response.StatusCode);

RemoteAttributeTest.cs (8)

93Assert.Equal(2, attribute.RouteData.Count); 99Assert.Equal(action, resultName); 111Assert.Equal(2, attribute.RouteData.Count); 117Assert.Equal(controller, resultName); 130Assert.Equal(3, attribute.RouteData.Count); 137Assert.Equal(areaName, resultName); 189Assert.Equal(2, routeDictionary.Count); 210Assert.Equal(3, routeDictionary.Count);

Rendering\HtmlHelperSelectTest.cs (3)

1336Assert.Equal(metadata.ModelType, htmlHelper.Metadata.ModelType); 1396Assert.Equal(metadata.ModelType, htmlHelper.Metadata.ModelType); 1556Assert.Equal(expected.Count(), actual.Count());

Rendering\HtmlHelperTest.cs (1)

146Assert.Equal(expectedEntry, entry);

Rendering\HtmlHelperValidationSummaryTest.cs (3)

170Assert.Equal(HtmlString.Empty, result); 194Assert.Equal(HtmlString.Empty, result); 519Assert.Equal(HtmlString.Empty, validationSummaryResult);

Rendering\TagBuilderTest.cs (5)

38Assert.Equal(new KeyValuePair<string, string>(expectedKey, expectedValue), attribute); 53Assert.Equal(new KeyValuePair<string, string>("class", "btn btn-success"), attribute); 68Assert.Equal(new KeyValuePair<string, string>("ID", "something"), attribute); 291Assert.Equal(originalTagBuilder.TagRenderMode, clonedTagBuilder.TagRenderMode); 321Assert.Equal(originalTagBuilder.Attributes, clonedTagBuilder.Attributes);

Rendering\ViewContextTests.cs (3)

41Assert.Equal("property", context.ViewData["Another"]); 65Assert.Equal(originalContext.ClientValidationEnabled, context.ClientValidationEnabled); 68Assert.Equal(originalContext.Html5DateRenderingMode, context.Html5DateRenderingMode);

TempDataDictionaryTest.cs (1)

124Assert.Equal("barValue", value);

ViewComponentResultTest.cs (1)

506Assert.Equal(404, actionContext.HttpContext.Response.StatusCode);

ViewComponents\DefaultViewComponentHelperTest.cs (6)

25Assert.Equal(0, argumentDictionary.Count); 45Assert.Equal(0, item.Value); 65Assert.Equal(0, item.Value); 85Assert.Equal(0, item1.Value); 91Assert.Equal("foo", item2.Value); 136Assert.Equal(10, item.Value);

ViewComponents\ViewComponentContextTest.cs (1)

108Assert.Equal(expectedType, viewComponentContext.ViewData.ModelMetadata.ModelType);

ViewComponents\ViewComponentConventionsTest.cs (1)

52Assert.Equal(expected, result);

ViewComponents\ViewComponentFeatureProviderTest.cs (2)

27Assert.Equal(new[] { typeof(ConventionsViewComponent).GetTypeInfo() }, feature.ViewComponents.ToArray()); 44Assert.Equal(new[] { typeof(AttributeViewComponent).GetTypeInfo() }, feature.ViewComponents.ToArray());

ViewComponentTests.cs (12)

ViewDataDictionaryOfTModelTest.cs (34)

53Assert.Equal(typeof(TestModel), viewData1.ModelMetadata.ModelType); 55Assert.Equal(source.Count, viewData1.Count); 56Assert.Equal("bar", viewData1["foo"]); 65Assert.Equal(typeof(TestModel), viewData2.ModelMetadata.ModelType); 67Assert.Equal(source.Count, viewData2.Count); 68Assert.Equal("bar", viewData2["foo"]); 92Assert.Equal(typeof(TestModel), viewData1.ModelMetadata.ModelType); 94Assert.Equal(source.Count, viewData1.Count); 95Assert.Equal("bar", viewData1["foo"]); 104Assert.Equal(typeof(TestModel), viewData2.ModelMetadata.ModelType); 106Assert.Equal(source.Count, viewData2.Count); 107Assert.Equal("bar", viewData2["foo"]); 128Assert.Equal(typeof(SupremeTestModel), viewData.ModelMetadata.ModelType); 149Assert.Equal(typeof(SupremeTestModel), viewData.ModelMetadata.ModelType); 170Assert.Equal(0, viewData.Model); 172Assert.Equal(typeof(int), viewData.ModelMetadata.ModelType); 174Assert.Equal(source.Count, viewData.Count); 175Assert.Equal("value1", viewData["key1"]); 194Assert.Equal(expectedType, viewData1.ModelMetadata.ModelType); 195Assert.Equal(expectedType, viewData1.ModelExplorer.ModelType); 199Assert.Equal(expectedType, viewData2.ModelMetadata.ModelType); 200Assert.Equal(expectedType, viewData2.ModelExplorer.ModelType); 258Assert.Equal(expectedType, viewData.ModelMetadata.ModelType); 280Assert.Equal(typeof(int?), viewData.ModelMetadata.ModelType); 281Assert.Equal(viewData.Model, viewData.ModelExplorer.Model); 282Assert.Equal(model, viewData.Model); 300Assert.Equal(typeof(int?), viewData.ModelMetadata.ModelType); 321Assert.Equal(typeof(TestModel), viewData.ModelMetadata.ModelType); 322Assert.Equal(viewData.Model, viewData.ModelExplorer.Model); 323Assert.Equal(model, viewData.Model); 343Assert.Equal(23, viewData1.Model); 344Assert.Equal(24, viewData2.Model); 345Assert.Equal(25, viewData3.Model); 346Assert.Equal(26, viewData4.Model);

ViewDataDictionaryTest.cs (26)

207Assert.Equal(typeof(TestModel), viewData.ModelMetadata.ModelType); 209Assert.Equal(source.Count, viewData.Count); 210Assert.Equal("bar", viewData["foo"]); 264Assert.Equal(typeof(object), viewData.ModelMetadata.ModelType); 292Assert.Equal(expectedType, viewData.ModelMetadata.ModelType); 336Assert.Equal(5, viewData.Model); 337Assert.Equal(5, viewData.ModelExplorer.Model); 363Assert.Equal(typeof(bool), viewData.ModelMetadata.ModelType); 389Assert.Equal(viewData.Model, viewData.ModelExplorer.Model); 428Assert.Equal(3, viewData.Model); 429Assert.Equal(3, viewData.ModelExplorer.Model); 454Assert.Equal("Hello", viewData.Model); 495Assert.Equal(expected, result); 524Assert.Equal("Bar", result); 538Assert.Equal("Blah", result); 552Assert.Equal("Baz", result); 566Assert.Equal("Baz", result); 580Assert.Equal("Quux", result); 594Assert.Equal("Quux", result); 612Assert.Equal("Baz", result); 630Assert.Equal("Quux", result); 648Assert.Equal("Quux", result); 679Assert.Equal("Baz", result); 714Assert.Equal("Quux", result); 776Assert.Equal("The Model", result); 797Assert.Equal("The Value", result);

ViewDataOfTTest.cs (3)

68Assert.Equal(0, viewData.TemplateInfo.TemplateDepth); 69Assert.Equal(string.Empty, viewData.TemplateInfo.FormattedModelValue); 87Assert.Equal(string.Empty, viewData.TemplateInfo.FormattedModelValue);

ViewEngines\CompositeViewEngineTest.cs (1)

29Assert.Equal(new[] { viewEngine1, viewEngine2 }, result);

ViewExecutorTest.cs (3)

209Assert.Equal(200, context.Response.StatusCode); 246Assert.Equal(500, context.Response.StatusCode); 329Assert.Equal(expectedLength, memoryStream.Length);

ViewResultExecutorTest.cs (1)

320Assert.Equal(404, context.HttpContext.Response.StatusCode);

Extensions\OpenApiEndpointRouteBuilderExtensionsTests.cs (4)

67Assert.Equal(StatusCodes.Status200OK, context.Response.StatusCode); 93Assert.Equal(StatusCodes.Status200OK, context.Response.StatusCode); 120Assert.Equal(StatusCodes.Status404NotFound, context.Response.StatusCode); 146Assert.Equal(StatusCodes.Status200OK, context.Response.StatusCode);

Extensions\OpenApiRouteHandlerBuilderExtensionTests.cs (1)

141Assert.Equal(2, operation.Responses.Count);

Extensions\OpenApiServiceCollectionExtensionsTests.cs (2)

167Assert.Equal(OpenApiSpecVersion.OpenApi3_0, namedOption.OpenApiVersion); 190Assert.Equal(OpenApiSpecVersion.OpenApi2_0, namedOption.OpenApiVersion);

Services\OpenApiDocumentProviderTests.cs (1)

44Assert.Equal(4, documentNames.Count());

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.Parameters.cs (3)

27Assert.Equal(ParameterLocation.Path, pathParameter.In); 31Assert.Equal(ParameterLocation.Query, queryParameter.In); 35Assert.Equal(ParameterLocation.Header, headerParameter.In);

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.Paths.cs (10)

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.RequestBody.cs (4)

34Assert.Equal(ParameterStyle.Form, encoding.Style); 100Assert.Equal(!isOptional, operation.RequestBody.Required); 168Assert.Equal(!isOptional, operation.RequestBody.Required); 314Assert.Equal(!isOptional, operation.RequestBody.Required);

Services\OpenApiGeneratorTests.cs (30)

Services\OpenApiSchemaService\OpenApiComponentService.ParameterSchemas.cs (16)

Transformers\DocumentTransformerTests.cs (2)

141Assert.Equal(1, DisposableTransformer.DisposeCount); 160Assert.Equal(1, AsyncDisposableTransformer.DisposeCount);

Transformers\SchemaTransformerTests.cs (3)

22Assert.Equal(typeof(Todo), context.Type); 40Assert.Equal(typeof(Todo), context.Type); 79Assert.Equal(cts.Token, cancellationToken);

CachedResponseBodyTests.cs (2)

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

OutputCacheAttributeTests.cs (3)

19Assert.Equal(DefaultPolicy.Instance, policy); 31Assert.Equal(42, context.ResponseExpirationTimeSpan?.TotalSeconds); 57Assert.Equal(42, context.ResponseExpirationTimeSpan?.TotalSeconds);

OutputCacheEntryFormatterTests.cs (2)

167Assert.Equal(expected.Created, actual.Created); 168Assert.Equal(expected.StatusCode, actual.StatusCode);

OutputCacheMiddlewareTests.cs (25)

46Assert.Equal(StatusCodes.Status504GatewayTimeout, context.HttpContext.Response.StatusCode); 62Assert.Equal(1, cache.GetCount); 90Assert.Equal(1, cache.GetCount); 120Assert.Equal(1, cache.GetCount); 148Assert.Equal(1, cache.GetCount); 194Assert.Equal(2, sink.Writes.Count); 236Assert.Equal(2, sink.Writes.Count); 380Assert.Equal(timeProvider.GetUtcNow(), context.ResponseTime); 396Assert.Equal(initialTime, context.ResponseTime); 402Assert.Equal(initialTime, context.ResponseTime); 414Assert.Equal(TimeSpan.FromSeconds(60), context.CachedResponseValidFor); 437Assert.Equal(options.DefaultExpirationTimeSpan, context.CachedResponseValidFor); 465Assert.Equal(options.DefaultExpirationTimeSpan, context.CachedResponseValidFor); 491Assert.Equal(options.DefaultExpirationTimeSpan, context.CachedResponseValidFor); 529Assert.Equal(0, cache.SetCount); 622Assert.Equal(1, cache.SetCount); 651Assert.Equal(0, cache.SetCount); 684Assert.Equal(1, cache.SetCount); 709Assert.Equal(1, cache.SetCount); 730Assert.Equal(0, cache.SetCount); 751Assert.Equal(0, cache.SetCount); 850Assert.Equal(1, responseCounter); 908Assert.Equal(2, responseCounter); 959Assert.Equal(2, responseCounter); 984Assert.Equal(1, cache.SetCount);

OutputCachePoliciesTests.cs (2)

86Assert.Equal(duration, context.ResponseExpirationTimeSpan); 145Assert.Equal(expected, context.EnableOutputCaching);

OutputCachePolicyBuilderTests.cs (6)

17Assert.Equal(DefaultPolicy.Instance, policy); 26Assert.Equal(EmptyPolicy.Instance, policy); 40Assert.Equal(duration, context.ResponseExpirationTimeSpan?.TotalSeconds); 70Assert.Equal(duration, context.ResponseExpirationTimeSpan?.TotalSeconds); 88Assert.Equal(duration, context.ResponseExpirationTimeSpan?.TotalSeconds); 345Assert.Equal(expected, context.ResponseExpirationTimeSpan?.TotalSeconds);

OutputCacheTests.cs (10)

TestUtils.cs (3)

259Assert.Equal(expectedMessages.Length, messageList.Count); 263Assert.Equal(expectedMessages[i].EventId, messageList[i].EventId); 264Assert.Equal(expectedMessages[i].LogLevel, messageList[i].LogLevel);

OwinEnvironmentTests.cs (4)

54Assert.Equal(201, Get<int>(env, "owin.ResponseStatusCode")); 95Assert.Equal(201, context.Response.StatusCode); 124Assert.Equal(CancellationToken.None, env["owin.CallCancelled"]); 125Assert.Equal("1.0", env["owin.Version"]);

OwinExtensionTests.cs (2)

83Assert.Equal(expectedServiceProvider, serviceProvider); 149Assert.Equal(context, value);

RateLimitingApplicationBuilderExtensionsTests.cs (1)

62Assert.Equal(429, context.Response.StatusCode);

RateLimitingMetricsTests.cs (6)

48Assert.Equal(StatusCodes.Status503ServiceUnavailable, context.Response.StatusCode); 57Assert.Equal(1, m.Value); 105Assert.Equal(StatusCodes.Status200OK, context.Response.StatusCode); 160Assert.Equal(StatusCodes.Status200OK, context.Response.StatusCode); 313Assert.Equal(value, measurement.Value); 331Assert.Equal(expected, (T)tags[tagName]);

RateLimitingMiddlewareTests.cs (18)

Runtime\TagHelpers\TagHelperExecutionContextTest.cs (9)

131Assert.Equal(updatedTagMode, output.TagMode); 139Assert.Equal(0, callCount); 140Assert.Equal(1, updatedCallCount); 202Assert.Equal(tagMode, output.TagMode); 338Assert.Equal(1, executionCount); 365Assert.Equal(2, executionCount); 395Assert.Equal(2, executionCount); 422Assert.Equal(2, executionCount); 579Assert.Equal(2, tagHelpers.Length);

Runtime\TagHelpers\TagHelperRunnerTest.cs (8)

21Assert.Equal(0, incrementer); 27Assert.Equal(1, incrementer); 37Assert.Equal(2, incrementer); 129Assert.Equal(tagMode, executionContext.Output.TagMode); 167Assert.Equal("somethingelse", output.Attributes["class"].Value); 168Assert.Equal("world", output.Attributes["hello"].Value); 169Assert.Equal(TagMode.SelfClosing, output.TagMode); 186Assert.Equal("True", executionContext.Output.Attributes["foo"].Value);

Runtime\TagHelpers\TagHelperScopeManagerTest.cs (8)

24Assert.Equal(1234, executionContextItem.Value); 41Assert.Equal(1234, executionContextItem.Value); 63Assert.Equal(1234, parentEntry.Value); 81Assert.Equal(2222, executionContextItem.Value); 84Assert.Equal(1234, parentExecutionContextItem.Value); 101Assert.Equal(2222, executionContextItem.Value); 121Assert.Equal(1234, parentExecutionContextItem.Value); 167Assert.Equal(tagMode, output.TagMode);

TagHelpers\DefaultTagHelperContentTest.cs (4)

116Assert.Equal(3, items.Count); 142Assert.Equal(3, items.Count); 166Assert.Equal(3, items.Count); 194Assert.Equal(3, items.Count);

TagHelpers\NullHtmlEncoderTest.cs (1)

18Assert.Equal(1, result);

TagHelpers\ReadOnlyTagHelperAttributeListTest.cs (8)

51Assert.Equal(expectedIndex, index); 202Assert.Equal(3, count); 310Assert.Equal(expected, contains); 386Assert.Equal(expected, contains); 494Assert.Equal(expected, index); 565Assert.Equal(expectedResult, result); 637Assert.Equal(expectedResult, result); 669Assert.Equal(attributes.GetEnumerator(), attributes.PublicAttributes.GetEnumerator());

TagHelpers\TagHelperAttributeListTest.cs (2)

443Assert.Equal(expectedRemoval, removed); 516Assert.Equal(expectedResult, result);

TagHelpers\TagHelperContextTest.cs (2)

65Assert.Equal(1234, item.Value); 88Assert.Equal(1234, item.Value);

TagHelpers\TagHelperOutputTest.cs (4)

47Assert.Equal(expectedTagMode, output.TagMode); 155Assert.Equal(useCachedResult, passedUseCacheResult.Value); 201Assert.Equal(useCachedResult, passedUseCacheResult.Value); 1061Assert.Equal(attributeCount, output.Attributes.Count);

DefaultRequestDecompressionProviderTests.cs (2)

128Assert.Equal(contentEncodings, contentEncodingHeader); 173Assert.Equal(level, log.LogLevel);

RequestDecompressionMiddlewareTests.cs (14)

RequestDecompressionOptionsTests.cs (1)

19Assert.Equal(defaultProviderCount, providers.Count);

CachedResponseBodyTests.cs (3)

29Assert.Equal(42, body.Length); 69Assert.Equal(segments, receivedSegments); 92Assert.Equal(new byte[] { 1, 2, 3 }, receivedSegments.SelectMany(x => x).ToArray());

ResponseCachingMiddlewareTests.cs (27)

ResponseCachingTests.cs (9)

TestUtils.cs (3)

246Assert.Equal(messageList.Count, expectedMessages.Length); 250Assert.Equal(expectedMessages[i].EventId, messageList[i].EventId); 251Assert.Equal(expectedMessages[i].LogLevel, messageList[i].LogLevel);

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());

ResponseCompressionMiddlewareTest.cs (18)

109Assert.Equal(3, logMessages.Count); 193Assert.Equal(2, logMessages.Count); 281Assert.Equal(2, logMessages.Count); 358Assert.Equal(3, logMessages.Count); 383Assert.Equal(3, logMessages.Count); 395Assert.Equal(2, logMessages.Count); 409Assert.Equal(2, logMessages.Count); 426Assert.Equal(50, response.Content.Headers.ContentLength); 427Assert.Equal(2, logMessages.Count); 479Assert.Equal(expectedLength, response.Content.ReadAsByteArrayAsync().Result.Length); 542Assert.Equal(expectedLength, response.Content.ReadAsByteArrayAsync().Result.Length); 605Assert.Equal(expectedLength, response.Content.ReadAsByteArrayAsync().Result.Length); 1015Assert.Equal(1, read); 1016Assert.Equal('a', (char)data[0]); 1303Assert.Equal(expectedBodyLength, response.Content.Headers.ContentLength); 1327Assert.Equal(expectedBodyLength, response.Content.Headers.ContentLength); 1332Assert.Equal(level, log.LogLevel); 1338Assert.Equal(3, logMessages.Count);

ApacheModRewrite\CookieActionFactoryTest.cs (2)

18Assert.Equal(TimeSpan.FromMinutes(1440), cookie.Lifetime); 32Assert.Equal(TimeSpan.FromMinutes(1440), action.Lifetime);

ApacheModRewrite\ModRewriteMiddlewareTest.cs (2)

352Assert.Equal((HttpStatusCode)301, response.StatusCode); 380Assert.Equal(HttpStatusCode.MovedPermanently, response.StatusCode);

ApacheModRewrite\RewriteTokenizerTest.cs (5)

20Assert.Equal(expected, tokens); 33Assert.Equal(expected, tokens); 47Assert.Equal(expected, tokens); 61Assert.Equal(expected, tokens); 75Assert.Equal(expected, tokens);

ApacheModRewrite\RuleBuilderTest.cs (1)

35Assert.Equal(StatusCodes.Status302Found, redirectAction.StatusCode);

IISUrlRewrite\FileParserTests.cs (1)

199Assert.Equal(actual.Count, expected.Count);

IISUrlRewrite\MiddleWareTests.cs (1)

695Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);

IISUrlRewrite\UrlRewriteApplicationTests.cs (3)

28Assert.Equal(RuleResult.SkipRemainingRules, context.Result); 47Assert.Equal(RuleResult.ContinueRules, context.Result); 70Assert.Equal(RuleResult.ContinueRules, context.Result);

MiddlewareTests.cs (12)

UrlActions\AbortActionTests.cs (1)

18Assert.Equal(RuleResult.EndResponse, context.Result);

UrlActions\ForbiddenActionTests.cs (2)

20Assert.Equal(RuleResult.EndResponse, context.Result); 21Assert.Equal(StatusCodes.Status403Forbidden, context.HttpContext.Response.StatusCode);

UrlActions\GoneActionTests.cs (2)

19Assert.Equal(RuleResult.EndResponse, context.Result); 20Assert.Equal(StatusCodes.Status410Gone, context.HttpContext.Response.StatusCode);

UrlMatches\ExactMatchTests.cs (1)

21Assert.Equal(expectedResult, matchResults.Success);

UrlMatches\IntegerMatchTests.cs (1)

33Assert.Equal(expectedResult, matchResult.Success);

UrlMatches\StringMatchTests.cs (1)

24Assert.Equal(expectedResult, matchResult.Success);

Benchmarks\EndpointRoutingBenchmarkTest.cs (1)

49Assert.Equal(HttpStatusCode.OK, response.StatusCode);

Benchmarks\RouterBenchmarkTest.cs (1)

50Assert.Equal(HttpStatusCode.OK, response.StatusCode);

EndpointRoutingIntegrationTest.cs (2)

90Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); 183Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);

EndpointRoutingSampleTest.cs (13)

HostMatchingTests.cs (5)

40Assert.Equal(HttpStatusCode.OK, response.StatusCode); 58Assert.Equal(HttpStatusCode.OK, response.StatusCode); 76Assert.Equal(HttpStatusCode.OK, response.StatusCode); 94Assert.Equal(HttpStatusCode.OK, response.StatusCode); 112Assert.Equal(HttpStatusCode.OK, response.StatusCode);

MapFallbackTest.cs (5)

32Assert.Equal(HttpStatusCode.OK, response.StatusCode); 48Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); 66Assert.Equal(HttpStatusCode.OK, response.StatusCode); 82Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); 100Assert.Equal(HttpStatusCode.OK, response.StatusCode);

MinimalFormTests.cs (10)

71Assert.Equal(DateTime.Today.AddDays(1), result.DueDate); 131Assert.Equal(DateTime.Today.AddDays(1), result.DueDate); 171Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 292Assert.Equal(DateTime.Today.AddDays(1), result.DueDate); 339Assert.Equal(DateTime.Today.AddDays(1), result.DueDate); 499Assert.Equal(DateTime.Today.AddDays(1), result.DueDate); 549Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 653Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 699Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 726Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);

RouteHandlerTest.cs (2)

59Assert.Equal(42, echoedTodo?.Id); 98Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);

RouterSampleTest.cs (4)

40Assert.Equal(HttpStatusCode.OK, response.StatusCode); 54Assert.Equal(HttpStatusCode.OK, response.StatusCode); 68Assert.Equal(HttpStatusCode.OK, response.StatusCode); 90Assert.Equal(HttpStatusCode.OK, response.StatusCode);

ShortCircuitTests.cs (2)

91Assert.Equal(HttpStatusCode.NotFound, response1.StatusCode); 95Assert.Equal(HttpStatusCode.NotFound, response2.StatusCode);

WebHostBuilderExtensionsTest.cs (1)

100Assert.Equal(HttpStatusCode.OK, response.StatusCode);

Builder\EndpointRoutingApplicationBuilderExtensionsTest.cs (3)

210Assert.Equal(2, matcherEndpointDataSources.Count); 276Assert.Equal(2, matcherEndpointDataSources.Count); 324Assert.Equal(mockRouteBuilder.Object.DataSources, routeOptions.Value.EndpointDataSources);

Builder\FallbackEndpointRouteBuilderExtensionsTest.cs (2)

29Assert.Equal(int.MaxValue, ((RouteEndpoint)endpoint).Order); 45Assert.Equal(int.MaxValue, ((RouteEndpoint)endpoint).Order);

Builder\GroupTest.cs (8)

50Assert.Equal(42, httpContext.Items["id"]); 83Assert.Equal("dotnet", httpContext.Items["org"]); 84Assert.Equal(42, httpContext.Items["id"]); 117Assert.Equal("dotnet", httpContext.Items["org"]); 118Assert.Equal(42, httpContext.Items["id"]); 293Assert.Equal(2, mapGetCallCount); 297Assert.Equal(42, routeEndpoint.Order); 331Assert.Equal(new[] { "/outer", "/inner", "/foo" }, endpoint.Metadata.GetOrderedMetadata<string>());

Builder\OpenApiRouteHandlerBuilderExtensionsTest.cs (9)

52Assert.Equal(typeof(TestEndointConventionBuilder), metadata.Type); 53Assert.Equal(StatusCodes.Status200OK, metadata.StatusCode); 66Assert.Equal(typeof(void), metadata.Type); 67Assert.Equal(StatusCodes.Status404NotFound, metadata.StatusCode); 80Assert.Equal(typeof(ProblemDetails), metadata.Type); 81Assert.Equal(StatusCodes.Status400BadRequest, metadata.StatusCode); 94Assert.Equal(typeof(HttpValidationProblemDetails), metadata.Type); 95Assert.Equal(StatusCodes.Status400BadRequest, metadata.StatusCode); 109Assert.Equal(typeof(TestEndointConventionBuilder), metadata.RequestType);

Builder\RequestDelegateEndpointRouteBuilderExtensionsTest.cs (9)

73Assert.Equal(requestDelegate, endpointBuilder1.RequestDelegate); 172Assert.Equal(1, (int)httpContext.Items["First-Order"]!); 173Assert.Equal(2, (int)httpContext.Items["Second-Order"]!); 344Assert.Equal(1, runCount); 360Assert.Equal(requestDelegate, endpointBuilder1.RequestDelegate); 377Assert.Equal(2, endpointBuilder1.Metadata.Count); 414Assert.Equal(4, endpoint.Metadata.Count); 494Assert.Equal(MetadataSource.Parameter, ((CustomEndpointMetadata)m).Source); 499Assert.Equal(MetadataSource.ReturnType, ((CustomEndpointMetadata)m).Source);

Builder\RouteHandlerEndpointRouteBuilderExtensionsTest.cs (16)

84Assert.Equal(3, metadataArray.Length); 207Assert.Equal(41, httpContext.Items["input"]); 542Assert.Equal(13, httpContext.Items["input"]); 620Assert.Equal(42, httpContext.Items["value"]); 645Assert.Equal(StatusCodes.Status400BadRequest, httpContext.Response.StatusCode); 692Assert.Equal(typeof(Todo), endpointMetadata.RequestType); 693Assert.Equal(new[] { "application/xml" }, endpointMetadata.ContentTypes); 749Assert.Equal(int.MaxValue, routeEndpointBuilder.Order); 767Assert.Equal(int.MaxValue, routeEndpointBuilder.Order); 783Assert.Equal(new[] { "Some", "Test", "Tags" }, tagsMetadata?.Tags); 827Assert.Equal(400, ex.StatusCode); 832Assert.Equal(400, httpContext.Response.StatusCode); 852Assert.Equal(400, httpContext.Response.StatusCode); 908Assert.Equal(200, httpContext.Response.StatusCode); 979Assert.Equal(200, httpContext.Response.StatusCode); 1002Assert.Equal(appService, myService);

Builder\RoutingEndpointConventionBuilderExtensionsTest.cs (4)

46Assert.Equal(new[] { "www.example.com", "example.com" }, metadata.Hosts); 117Assert.Equal(new[] { "www.example.com", "example.com" }, hosts.Hosts); 223Assert.Equal(new[] { "test-metadata", "inner-metadata", "inner-metadata-2" }, metadata); 237Assert.Equal(47, endpoint.Order);

CompositeEndpointDataSourceTest.cs (4)

32Assert.Equal(endpoints, dataSource.Endpoints); 58Assert.Equal(groupedEndpoints, resolvedGroupEndpoints); 482Assert.Equal(new[] { "initial-metadata", "saw-last-metadata" }, endpoint.Metadata.GetOrderedMetadata<string>()); 489Assert.Equal(new[] { "initial-metadata", "saw-last-metadata" }, endpoint.Metadata.GetOrderedMetadata<string>());

Constraints\AlphaRouteConstraintTests.cs (1)

28Assert.Equal(expected, actual);

Constraints\BoolRouteConstraintTests.cs (1)

31Assert.Equal(expected, actual);

Constraints\CompositeRouteConstraintTests.cs (1)

32Assert.Equal(expected, actual);

Constraints\DateTimeRouteConstraintTests.cs (1)

47Assert.Equal(expected, actual);

Constraints\DecimalRouteConstraintTests.cs (1)

38Assert.Equal(expected, actual);

Constraints\DoubleRouteConstraintTests.cs (1)

26Assert.Equal(expected, actual);

Constraints\FloatRouteConstraintTests.cs (1)

25Assert.Equal(expected, actual);

Constraints\GuidRouteConstraintTests.cs (1)

32Assert.Equal(expected, actual);

Constraints\IntRouteConstraintsTests.cs (1)

25Assert.Equal(expected, actual);

Constraints\LengthRouteConstraintTests.cs (2)

24Assert.Equal(expected, actual); 42Assert.Equal(expected, actual);

Constraints\LongRouteConstraintTests.cs (1)

27Assert.Equal(expected, actual);

Constraints\MaxLengthRouteConstraintTests.cs (1)

25Assert.Equal(expected, actual);

Constraints\MaxRouteConstraintTests.cs (1)

23Assert.Equal(expected, actual);

Constraints\MinLengthRouteConstraintTests.cs (1)

25Assert.Equal(expected, actual);

Constraints\MinRouteConstraintTests.cs (1)

23Assert.Equal(expected, actual);

Constraints\RangeRouteConstraintTests.cs (1)

29Assert.Equal(expected, actual);

Constraints\RegexInlineRouteConstraintTests.cs (1)

38Assert.Equal(shouldMatch, match);

Constraints\RegexRouteConstraintTests.cs (1)

42Assert.Equal(shouldMatch, match);

Constraints\StringRouteConstraintTest.cs (1)

152Assert.Equal(expected, match);

DataSourceDependentCacheTest.cs (1)

72Assert.Equal(2, count);

DefaultEndpointDataSourceTests.cs (2)

39Assert.Equal(2, dataSource.Endpoints.Count); 83Assert.Equal(2, dataSource.Endpoints.Count);

DefaultInlineConstraintResolverTest.cs (10)

172Assert.Equal(5, ((LengthRouteConstraint)constraint).MinLength); 173Assert.Equal(5, ((LengthRouteConstraint)constraint).MaxLength); 184Assert.Equal(5, lengthConstraint.MinLength); 185Assert.Equal(10, lengthConstraint.MaxLength); 206Assert.Equal(10, ((MaxRouteConstraint)constraint).Max); 217Assert.Equal(10, ((MaxLengthRouteConstraint)constraint).MaxLength); 228Assert.Equal(3, ((MinRouteConstraint)constraint).Min); 239Assert.Equal(3, ((MinLengthRouteConstraint)constraint).MinLength); 251Assert.Equal(5, rangeConstraint.Min); 252Assert.Equal(10, rangeConstraint.Max);

DefaultLinkGeneratorProcessTemplateTest.cs (4)

814Assert.Equal(expectedValues.OrderBy(kvp => kvp.Key), constraint.Values.OrderBy(kvp => kvp.Key)); 847Assert.Equal(expectedValues.OrderBy(kvp => kvp.Key), constraint.Values.OrderBy(kvp => kvp.Key)); 878Assert.Equal(expectedValues, constraint.Values); 913Assert.Equal(expectedValues.OrderBy(kvp => kvp.Key), constraint.Values.OrderBy(kvp => kvp.Key));

DefaultParameterPolicyFactoryTest.cs (7)

173Assert.Equal(1, constraint.Min); 174Assert.Equal(20, constraint.Max); 227Assert.Equal(20, constraint.Count); 248Assert.Equal(20, constraint.First); 249Assert.Equal(-1, constraint.Second); 293Assert.Equal(1, constraint.Count); 315Assert.Equal(1, constraint.Count);

EndpointRoutingMiddlewareFormOptionsTest.cs (10)

EndpointRoutingMiddlewareTest.cs (3)

297Assert.Equal(expectedRequestSizeLimit, actualRequestSizeLimit); 394Assert.Equal(expectedRequestSizeLimit, actualRequestSizeLimit); 450Assert.Equal(level, log.LogLevel);

InlineRouteParameterParserTests.cs (35)

Matching\AcceptsMatcherPolicyTest.cs (28)

181Assert.Equal(string.Empty, e.State); 182Assert.Equal(new[] { endpoints[1], endpoints[4], }, e.Endpoints.ToArray()); 186Assert.Equal("*/*", e.State); 187Assert.Equal(new[] { endpoints[1], endpoints[4], }, e.Endpoints.ToArray()); 191Assert.Equal("application/*", e.State); 192Assert.Equal(new[] { endpoints[1], endpoints[3], endpoints[4], }, e.Endpoints.ToArray()); 196Assert.Equal("application/*+json", e.State); 197Assert.Equal(new[] { endpoints[0], endpoints[1], endpoints[3], endpoints[4], }, e.Endpoints.ToArray()); 201Assert.Equal("application/*+xml", e.State); 202Assert.Equal(new[] { endpoints[1], endpoints[2], endpoints[3], endpoints[4], }, e.Endpoints.ToArray()); 206Assert.Equal("application/json", e.State); 207Assert.Equal(new[] { endpoints[0], endpoints[1], endpoints[3], endpoints[4], }, e.Endpoints.ToArray()); 211Assert.Equal("application/xml", e.State); 212Assert.Equal(new[] { endpoints[1], endpoints[2], endpoints[3], endpoints[4], }, e.Endpoints.ToArray()); 239Assert.Equal(string.Empty, e.State); 240Assert.Equal(new[] { endpoints[0], endpoints[1], endpoints[2], }, e.Endpoints.ToArray()); 244Assert.Equal("*/*", e.State); 249Assert.Equal("application/*", e.State); 250Assert.Equal(new[] { endpoints[2], }, e.Endpoints.ToArray()); 254Assert.Equal("application/*+json", e.State); 255Assert.Equal(new[] { endpoints[0], endpoints[2], }, e.Endpoints.ToArray()); 259Assert.Equal("application/*+xml", e.State); 260Assert.Equal(new[] { endpoints[1], endpoints[2], }, e.Endpoints.ToArray()); 264Assert.Equal("application/json", e.State); 265Assert.Equal(new[] { endpoints[0], endpoints[2], }, e.Endpoints.ToArray()); 269Assert.Equal("application/xml", e.State); 270Assert.Equal(new[] { endpoints[1], endpoints[2], }, e.Endpoints.ToArray()); 310Assert.Equal(expected, actual);

Matching\CandidateSetTest.cs (19)

36Assert.Equal(candidates[i].Score, state.Score); 176Assert.Equal(12, candidateSet.Count); 179Assert.Equal(0, candidateSet[0].Score); 181Assert.Equal(0, candidateSet[1].Score); 183Assert.Equal(1, candidateSet[2].Score); 189Assert.Equal(i - 1, candidateSet[i].Score); 226Assert.Equal(12, candidateSet.Count); 232Assert.Equal(i, candidateSet[i].Score); 236Assert.Equal(5, candidateSet[5].Score); 238Assert.Equal(5, candidateSet[6].Score); 240Assert.Equal(6, candidateSet[7].Score); 246Assert.Equal(i - 1, candidateSet[i].Score); 283Assert.Equal(12, candidateSet.Count); 289Assert.Equal(i, candidateSet[i].Score); 293Assert.Equal(9, candidateSet[9].Score); 295Assert.Equal(9, candidateSet[10].Score); 297Assert.Equal(10, candidateSet[11].Score); 361Assert.Equal(i, state.Score); 363Assert.Equal(i, state.Values["i"]);

Matching\ContentEncodingNegotiationMatcherPolicyTest.cs (10)

455Assert.Equal(1, destination); 473Assert.Equal(2, destination); 491Assert.Equal(2, destination); 509Assert.Equal(2, destination); 527Assert.Equal(2, destination); 545Assert.Equal(1, destination); 563Assert.Equal(3, destination); 581Assert.Equal(2, destination); 599Assert.Equal(3, destination); 616Assert.Equal(3, destination);

Matching\DfaMatcherBuilderTest.cs (42)

Matching\DfaMatcherTest.cs (38)

162Assert.Equal("Index", kvp.Value); 167Assert.Equal("Home", kvp.Value); 227Assert.Equal("Index", kvp.Value); 232Assert.Equal("Home", kvp.Value); 237Assert.Equal("123", kvp.Value); 271Assert.Equal("TestAction", httpContext.Request.RouteValues["action"]); 272Assert.Equal("TestController", httpContext.Request.RouteValues["controller"]); 273Assert.Equal("17", httpContext.Request.RouteValues["id"]); 345Assert.Equal("Index", kvp.Value); 350Assert.Equal("ConventionalTransformer", kvp.Value); 605Assert.Equal("TESTACTION", kvp.Value); 610Assert.Equal("TestController", kvp.Value); 636Assert.Equal(lowerOrderEndpoint, httpContext.GetEndpoint()); 651Assert.Equal(2, cs.Count); 655Assert.Equal(0, cs[0].Score); 660Assert.Equal(1, cs[1].Score); 682Assert.Equal(endpoint2, httpContext.GetEndpoint()); 697Assert.Equal(2, cs.Count); 701Assert.Equal(0, cs[0].Score); 706Assert.Equal(1, cs[1].Score); 728Assert.Equal(endpoint2, httpContext.GetEndpoint()); 744Assert.Equal(2, cs.Count); 748Assert.Equal(0, cs[0].Score); 753Assert.Equal(1, cs[1].Score); 775Assert.Equal(endpoint2, httpContext.GetEndpoint()); 803Assert.Equal(1000, log.EventId); 833Assert.Equal(1001, log.EventId); 838Assert.Equal(1003, log.EventId); 843Assert.Equal(1004, log.EventId); 873Assert.Equal(1001, log.EventId); 878Assert.Equal(1002, log.EventId); 883Assert.Equal(1004, log.EventId); 915Assert.Equal(1001, log.EventId); 920Assert.Equal(1005, log.EventId); 925Assert.Equal(1003, log.EventId); 930Assert.Equal(1004, log.EventId); 935Assert.Equal(1002, log.EventId); 940Assert.Equal(1004, log.EventId);

Matching\EndpointComparerTest.cs (5)

24Assert.Equal(1, result); 40Assert.Equal(1, result); 56Assert.Equal(-1, result); 72Assert.Equal(1, result); 104Assert.Equal(0, result);

Matching\EndpointMetadataComparerTest.cs (4)

21Assert.Equal(-1, result); 35Assert.Equal(1, result); 49Assert.Equal(0, result); 63Assert.Equal(0, result);

Matching\FastPathTokenizerTest.cs (8)

20Assert.Equal(0, count); 33Assert.Equal(0, count); 46Assert.Equal(1, count); 60Assert.Equal(3, count); 76Assert.Equal(3, count); 92Assert.Equal(3, count); 108Assert.Equal(3, count); 124Assert.Equal(3, count);

Matching\HostMatcherPolicyTest.cs (7)

224Assert.Equal(new[] { endpoints[1], endpoints[2], endpoints[7], }, e.Endpoints.ToArray()); 229Assert.Equal(new[] { endpoints[0], endpoints[1], endpoints[2], }, e.Endpoints.ToArray()); 234Assert.Equal(new[] { endpoints[0], endpoints[1], endpoints[2], }, e.Endpoints.ToArray()); 239Assert.Equal(new[] { endpoints[1], endpoints[2], endpoints[3], endpoints[4], }, e.Endpoints.ToArray()); 244Assert.Equal(new[] { endpoints[1], endpoints[2], endpoints[4], }, e.Endpoints.ToArray()); 249Assert.Equal(new[] { endpoints[1], endpoints[2], endpoints[5], }, e.Endpoints.ToArray()); 254Assert.Equal(new[] { endpoints[1], endpoints[2], endpoints[6], }, e.Endpoints.ToArray());

Matching\HttpMethodMatcherPolicyIntegrationTestBase.cs (3)

203Assert.Equal(405, httpContext.Response.StatusCode); 313Assert.Equal(405, httpContext.Response.StatusCode); 318Assert.Equal(405, httpContext.Response.StatusCode);

Matching\HttpMethodMatcherPolicyTest.cs (22)

Matching\ILEmitTrieFactoryTest.cs (1)

27Assert.Equal(expected, actual);

Matching\ILEmitTrieJumpTableTest.cs (7)

84Assert.Equal(entry.Length, length); 96Assert.Equal(1, result); 145Assert.Equal(entry.Length, length); 157Assert.Equal(1, result); 209Assert.Equal(entry.Length, length); 221Assert.Equal(0, result); 246Assert.Equal(destination, result);

Matching\MultipleEntryJumpTableTest.cs (5)

23Assert.Equal(1, result); 36Assert.Equal(0, result); 49Assert.Equal(2, result); 62Assert.Equal(2, result); 75Assert.Equal(3, result);

Matching\SingleEntryJumpTableTestBase.cs (4)

24Assert.Equal(1, result); 37Assert.Equal(0, result); 50Assert.Equal(2, result); 63Assert.Equal(2, result);

Matching\ZeroEntryJumpTableTest.cs (2)

18Assert.Equal(1, result); 31Assert.Equal(0, result);

Patterns\DefaultRoutePatternTransformerTest.cs (26)

Patterns\InlineRouteParameterParserTest.cs (39)

Patterns\RoutePatternFactoryTest.cs (31)

Patterns\RoutePatternMatcherTest.cs (51)

RouteCollectionTest.cs (4)

152Assert.Equal(expectedDataTokens.Count, pathData.DataTokens.Count); 156Assert.Equal(dataToken.Value, pathData.DataTokens[dataToken.Key]); 182Assert.Equal(1, context.RouteData.Routers.Count); 208Assert.Equal(1, context.RouteData.Routers.Count);

RouteConstraintBuilderTest.cs (8)

26Assert.Equal(1, result.Count); 45Assert.Equal(1, result.Count); 64Assert.Equal(1, result.Count); 110Assert.Equal(1, result.Count); 123Assert.Equal(1, result.Count); 138Assert.Equal(1, result.Count); 143Assert.Equal(2, compositeConstraint.Constraints.Count()); 168Assert.Equal(shouldMatch,

RouteEndpointBuilderTest.cs (6)

42Assert.Equal(defaultOrder, endpoint.Order); 43Assert.Equal(requestDelegate, endpoint.RequestDelegate); 70m => Assert.Equal(metadata, m)); 171Assert.Equal(0, endpointFilterCallCount); 172Assert.Equal(0, invocationFilterCallCount); 173Assert.Equal(1, invocationCallCount);

RouteHandlerOptionsTests.cs (1)

30Assert.Equal(expectedThrowOnBadRequest, options.ThrowOnBadRequest);

RouterMiddlewareTest.cs (3)

44Assert.Equal("10", routingFeature.RouteData.Values["id"]); 45Assert.Equal("10", context.Request.RouteValues["id"]); 46Assert.Equal("10", context.GetRouteValue("id"));

RouteTest.cs (53)

RouteValueEqualityComparerTest.cs (1)

36Assert.Equal(expected, actual);

RouteValuesAddressSchemeTest.cs (5)

24Assert.Equal(2, allMatches.Count); 44Assert.Equal(3, allMatches.Count); 64Assert.Equal(3, allMatches.Count); 231e => Assert.Equal(endpoint3, e), 232e => Assert.Equal(endpoint2, e));

RoutingMetricsTests.cs (3)

138Assert.Equal(1, measurement.Value); 144Assert.Equal(1, measurement.Value); 147Assert.Equal(fallback, (bool)measurement.Tags["aspnetcore.routing.is_fallback"]);

RoutingServiceCollectionExtensionsTests.cs (1)

81Assert.Equal(typeof(DummyRegexRouteConstraint), regexRouteConstraintType);

Template\RoutePrecedenceTestsBase.cs (2)

19Assert.Equal(xPrededence, yPrededence); 33Assert.Equal(xPrededence, yPrededence);

Template\TemplateBinderTests.cs (2)

723Assert.Equal(2, templateValuesResult.CombinedValues.Count); 1179Assert.Equal(expectedParts.Parameters.Count, actualParts.Parameters.Count);

Template\TemplateMatcherTests.cs (51)

Template\TemplateSegmentTest.cs (1)

36Assert.Equal(4, routePatternPathSegment.Parts.Count);

TemplateParserDefaultValuesTests.cs (2)

31Assert.Equal("12", defaults["id"]); 50Assert.Equal(value, defaults["p1"]);

Tree\TreeRouterTest.cs (29)

AuthenticationTests.cs (22)

Http2Tests.cs (12)

170Assert.Equal(11, httpContext.Request.ContentLength); 199Assert.Equal(Http2FrameType.WINDOW_UPDATE, windowUpdate.Type); 263Assert.Equal(Http2FrameType.WINDOW_UPDATE, windowUpdate.Type); 687Assert.Equal(0, await appResult.Task.DefaultTimeout()); 726Assert.Equal(0, await appResult.Task.DefaultTimeout()); 773Assert.Equal(0, await appResult.Task.DefaultTimeout()); 825Assert.Equal(0, await appResult.Task.DefaultTimeout()); 879Assert.Equal(0, await appResult.Task.DefaultTimeout()); 903Assert.Equal(10, read); 928Assert.Equal(0, await appResult.Task.DefaultTimeout()); 952Assert.Equal(10, read); 978Assert.Equal(0, await appResult.Task.DefaultTimeout());

Http3Tests.cs (8)

178Assert.Equal(QuicError.StreamAborted, qex.QuicError); 179Assert.Equal(0x010b, qex.ApplicationErrorCode.Value); 211Assert.Equal(QuicError.StreamAborted, qex.QuicError); 212Assert.Equal(0x010c, qex.ApplicationErrorCode.Value); 237Assert.Equal(QuicError.StreamAborted, qex.QuicError); 238Assert.Equal(0x0102, qex.ApplicationErrorCode.Value); // H3_INTERNAL_ERROR 258Assert.Equal(QuicError.StreamAborted, qex.QuicError); 259Assert.Equal(0x010c, qex.ApplicationErrorCode.Value); // H3_REQUEST_CANCELLED

HttpsTests.cs (7)

216Assert.Equal((uint)tlsFeature.CipherAlgorithm, tlsCopy.CipherType); 217Assert.Equal(tlsFeature.CipherStrength, (int)tlsCopy.CipherStrength); 218Assert.Equal((uint)tlsFeature.HashAlgorithm, tlsCopy.HashType); 219Assert.Equal(tlsFeature.HashStrength, (int)tlsCopy.HashStrength); 220Assert.Equal((uint)tlsFeature.KeyExchangeAlgorithm, tlsCopy.KeyExchangeType); 221Assert.Equal(tlsFeature.KeyExchangeStrength, (int)tlsCopy.KeyExchangeStrength); 248Assert.Equal(Stopwatch.GetElapsedTime(headerStart, headerEnd), elapsed);

Listener\AuthenticationOnExistingQueueTests.cs (6)

69Assert.Equal(HttpStatusCode.OK, response.StatusCode); 87Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); 111Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); 136Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); 167Assert.Equal(HttpStatusCode.OK, response.StatusCode); 190Assert.Equal(HttpStatusCode.OK, response.StatusCode);

Listener\RequestBodyTests.cs (6)

82Assert.Equal(5, read); 85Assert.Equal(5, read); 107Assert.Equal(5, read); 110Assert.Equal(5, read); 131Assert.Equal(5, read); 156Assert.Equal(5, read);

Listener\ResponseBodyTests.cs (12)

43Assert.Equal(200, (int)response.StatusCode); 44Assert.Equal(new Version(1, 1), response.Version); 48Assert.Equal(new byte[10], await response.Content.ReadAsByteArrayAsync()); 68Assert.Equal(200, (int)response.StatusCode); 72Assert.Equal(20, (await response.Content.ReadAsByteArrayAsync()).Length); 92Assert.Equal(200, (int)response.StatusCode); 93Assert.Equal(new Version(1, 1), response.Version); 97Assert.Equal(new byte[0], await response.Content.ReadAsByteArrayAsync()); 117Assert.Equal(200, (int)response.StatusCode); 118Assert.Equal(new byte[20], await response.Content.ReadAsByteArrayAsync()); 139Assert.Equal(200, (int)response.StatusCode); 140Assert.Equal(new byte[20], await response.Content.ReadAsByteArrayAsync());

Listener\ResponseHeaderTests.cs (11)

39Assert.Equal(2, response.Headers.Count()); 44Assert.Equal(0, response.Content.Headers.ContentLength); 61Assert.Equal(3, response.Headers.Count()); 67Assert.Equal(0, response.Content.Headers.ContentLength); 84Assert.Equal(2, response.Headers.Count()); 112Assert.Equal(3, response.Headers.Count()); 142Assert.Equal(2, response.Headers.Count()); 147Assert.Equal(20, response.Content.Headers.ContentLength); 171Assert.Equal(2, response.Headers.Count()); 194Assert.Equal(2, response.Headers.Count()); 223Assert.Equal(new Version(1, 1), response.Version);

Listener\ServerTests.cs (1)

139Assert.Equal((int)ErrorCodes.ERROR_ALREADY_EXISTS, exception.ErrorCode);

OpaqueUpgradeTests.cs (7)

40Assert.Equal(200, (int)response.StatusCode); 42Assert.Equal(0, response.Content.Headers.ContentLength); 68Assert.Equal(200, (int)response.StatusCode); 70Assert.Equal(0, response.Content.Headers.ContentLength); 99Assert.Equal(200, (int)response.StatusCode); 147Assert.Equal(15, await stream.ReadAsync(new byte[15], 0, 15)); 241Assert.Equal(49, read);

RequestBodyLimitTests.cs (25)

RequestBodyTests.cs (15)

53Assert.Equal(0, read); 92Assert.Equal(0, read); 153Assert.Equal(5, read); 156Assert.Equal(5, read); 174Assert.Equal(5, read); 177Assert.Equal(5, read); 193Assert.Equal(10, read); 195Assert.Equal(0, read); 202Assert.Equal(13, lines.Length); 216Assert.Equal(newContentLength, httpContext.Request.ContentLength); 226Assert.Equal(1, contentLengthHeadersCount); 255Assert.Equal(expectedCount, headersCount); 263Assert.Equal(123, httpContext.Request.ContentLength); 266Assert.Equal(456, httpContext.Request.ContentLength); 273Assert.Equal(789, httpContext.Request.ContentLength);

RequestHeaderTests.cs (7)

44Assert.Equal(4, requestHeaders.Count); 187Assert.Equal(3, requestHeaders.Count); 188Assert.Equal(requestHeaders.Keys.Count, requestHeaders.Count); 189Assert.Equal(requestHeaders.Count, requestHeaders.Values.Count); 214Assert.Equal(4, requestHeaders.Count); 215Assert.Equal(requestHeaders.Keys.Count, requestHeaders.Count); 216Assert.Equal(requestHeaders.Count, requestHeaders.Values.Count);

RequestTests.cs (7)

39Assert.Equal(Stream.Null, requestInfo.Body); 109Assert.Equal(IPAddress.Broadcast, connectionInfo.RemoteIpAddress); 111Assert.Equal(12345, connectionInfo.RemotePort); 113Assert.Equal(IPAddress.Any, connectionInfo.LocalIpAddress); 115Assert.Equal(54321, connectionInfo.LocalPort); 174Assert.Equal(-1, connectionInfo.RemotePort); 178Assert.Equal(-1, connectionInfo.LocalPort);

ResponseBodyTests.cs (35)

ResponseCachingTests.cs (5)

459Assert.Equal(status, (int)response.StatusCode); 462Assert.Equal(10, response.Content.Headers.ContentLength); 463Assert.Equal(new byte[10], await response.Content.ReadAsByteArrayAsync()); 474Assert.Equal(200, (int)response.StatusCode); 475Assert.Equal(_fileLength, response.Content.Headers.ContentLength);

ResponseHeaderTests.cs (14)

31Assert.Equal(2, response.Headers.Count()); 36Assert.Equal(0, response.Content.Headers.ContentLength); 57Assert.Equal(4, response.Headers.Count); 59Assert.Equal(0, response.ContentLength); 82Assert.Equal(4, response.Headers.Count); 84Assert.Equal(0, response.ContentLength); 107Assert.Equal(4, response.Headers.Count); 109Assert.Equal(0, response.ContentLength); 176Assert.Equal(new Version(1, 1), response.Version); 203Assert.Equal(new Version(1, 1), response.Version); 235Assert.Equal(5, response.Headers.Count()); // Date, Server, Chunked 237Assert.Equal(2, response.Headers.GetValues("Custom1").Count()); 265Assert.Equal(5, response.Headers.Count()); // Date, Server, Chunked 267Assert.Equal(2, response.Headers.GetValues("Custom1").Count());

ResponseSendFileTests.cs (26)

ResponseTests.cs (13)

ResponseTrailersTests.cs (13)

ServerTests.cs (5)

217Assert.Equal(StatusCodes.Status500InternalServerError, (int)ex.StatusCode); 222Assert.Equal(StatusCodes.Status500InternalServerError, (int)ex.StatusCode); 236Assert.Equal(StatusCodes.Status418ImATeapot, (int)ex.StatusCode); 241Assert.Equal(StatusCodes.Status418ImATeapot, (int)ex.StatusCode); 374Assert.Equal(HttpStatusCode.ServiceUnavailable, response.StatusCode);

IISMiddlewareTests.cs (5)

95Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 141Assert.Equal(HttpStatusCode.Accepted, response.StatusCode); 200Assert.Equal(HttpStatusCode.OK, response.StatusCode); 245Assert.Equal(HttpStatusCode.OK, response.StatusCode); 290Assert.Equal(HttpStatusCode.OK, response.StatusCode);

AddressBinderTests.cs (12)

31Assert.Equal(IPAddress.Parse(expectedAddress), endpoint.Address); 32Assert.Equal(expectedPort, endpoint.Port); 59Assert.Equal(IPAddress.IPv6Any, listenOptions.IPEndPoint.Address); 60Assert.Equal(80, listenOptions.IPEndPoint.Port); 70Assert.Equal(IPAddress.Loopback, listenOptions.IPEndPoint.Address); 71Assert.Equal(80, listenOptions.IPEndPoint.Port); 82Assert.Equal(8080, listenOptions.IPEndPoint.Port); 150Assert.Equal(IPAddress.Parse(ip), listenOptions.IPEndPoint.Address); 151Assert.Equal(port, listenOptions.IPEndPoint.Port); 152Assert.Equal(isHttps, https); 194Assert.Equal(LogLevel.Warning, log.LogLevel); 222Assert.Equal(LogLevel.Information, log.LogLevel);

AsciiDecoding.cs (1)

48Assert.Equal(sb, b);

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 (26)

CertificatePathWatcherTests.cs (48)

ChunkWriterTests.cs (3)

44Assert.Equal(Encoding.ASCII.GetBytes(expected), span.Slice(0, count).ToArray()); 82Assert.Equal(prefixLength, actualLength); 83Assert.Equal(expectSlice, actualSliceOneByte);

ConcurrentPipeWriterTests.cs (49)

ConnectionDispatcherTests.cs (3)

47Assert.Equal(connection.ConnectionId, pairs["ConnectionId"]); 91Assert.Equal(stateObject, callbackState); 112Assert.Equal(stateObject, callbackState);

HeartbeatTests.cs (2)

19Assert.Equal(TimeSpan.FromSeconds(1), Heartbeat.Interval); 197Assert.Equal(ex, TestSink.Writes.Single(message => message.LogLevel == LogLevel.Error).Exception);

Http1\Http1ConnectionTests.cs (5)

84Assert.Equal(StatusCodes.Status431RequestHeaderFieldsTooLarge, exception.StatusCode); 101Assert.Equal(StatusCodes.Status431RequestHeaderFieldsTooLarge, exception.StatusCode); 469Assert.Equal(StatusCodes.Status414UriTooLong, exception.StatusCode); 562Assert.Equal(405, exception.StatusCode); 850Assert.Equal(StatusCodes.Status400BadRequest, exception.StatusCode);

Http1\Http1HttpProtocolFeatureCollectionTests.cs (6)

93Assert.Equal(featuresAssigned, featuresReset); 106Assert.Equal(featuresAssigned, featuresReset); 179Assert.Equal(0, _collection.Count(kv => kv.Key == typeof(string))); 182Assert.Equal(1, _collection.Count(kv => kv.Key == typeof(string))); 185Assert.Equal(0, _collection.Count(kv => kv.Key == typeof(string))); 246Assert.Equal(protocolFeaturesCount, featureCount);

Http2\Http2HeadersEnumeratorTests.cs (9)

39Assert.Equal(new[] 72Assert.Equal(new[] 96Assert.Equal(-1, e.HPackStaticTableId); 101Assert.Equal(-1, e.HPackStaticTableId); 106Assert.Equal(-1, e.HPackStaticTableId); 121Assert.Equal(-1, e.HPackStaticTableId); 126Assert.Equal(-1, e.HPackStaticTableId); 131Assert.Equal(-1, e.HPackStaticTableId); 136Assert.Equal(-1, e.HPackStaticTableId);

Http2\Http2HPackEncoderTests.cs (71)

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());

Http3\Http3HeadersEnumeratorTests.cs (9)

39Assert.Equal(new[] 72Assert.Equal(new[] 97Assert.Equal(-1, index); 103Assert.Equal(-1, index); 109Assert.Equal(-1, index); 125Assert.Equal(-1, index); 131Assert.Equal(-1, index); 137Assert.Equal(-1, index); 143Assert.Equal(-1, index);

HttpConnectionManagerTests.cs (2)

34Assert.Equal(0, connectionCount); 55Assert.Equal(1, connectionCount);

HttpHeadersTests.cs (2)

263Assert.Equal(1, httpHeaders.ContentLength); 269Assert.Equal(long.MaxValue, httpHeaders.ContentLength);

HttpParserTests.cs (23)

HttpRequestHeadersTests.cs (16)

25Assert.Equal(0, headers.Count); 63Assert.Equal(3, headers.Count); 146Assert.Equal(StringValues.Empty, methodValue); 316Assert.Equal(3, headers.Count); 323Assert.Equal(0, headers.Count); 338Assert.Equal(3, headers.Count); 346Assert.Equal(2, headers.Count); 353Assert.Equal(1, headers.Count); 361Assert.Equal(0, headers.Count); 379Assert.Equal(new StringValues(), entries[0].Value); 391Assert.Equal(new StringValues(), entries[4].Value); 404Assert.Equal(StatusCodes.Status400BadRequest, exception.StatusCode); 707Assert.Equal(1337, headers.ContentLength); 804Assert.Equal(2, prevHeaderValue.Count); 841Assert.Equal(2, headers.Count()); // NB: enumerable count, not property 843Assert.Equal(3, headers.Count()); // NB: enumerable count, not property

HttpRequestStreamTests.cs (2)

118Assert.Equal(0, await stream.ReadAsync(new byte[1], 0, 1)); 127Assert.Equal(0, stream.Read(new byte[1], 0, 1));

HttpResponseHeadersTests.cs (6)

44Assert.Equal(0, headers.Count); 347Assert.Equal(ParseLong(contentLength), headers.ContentLength); 358Assert.Equal(ParseLong(contentLength), headers.ContentLength); 368Assert.Equal(ParseLong(contentLength), headers.ContentLength); 402Assert.Equal(2, headers.Count()); // NB: enumerable count, not property 404Assert.Equal(3, headers.Count()); // NB: enumerable count, not property

HttpUtilitiesTest.cs (1)

77Assert.Equal(version, knownVersion);

KestrelEventSourceTests.cs (1)

26Assert.Equal(Guid.Parse("bdeb4676-a36e-5442-db99-4764e2326c7d", CultureInfo.InvariantCulture), EventSource.GetGuid(esType));

KestrelServerLimitsTests.cs (27)

15Assert.Equal(64 * 1024, (new KestrelServerLimits()).MaxResponseBufferSize); 38Assert.Equal(value, o.MaxResponseBufferSize); 44Assert.Equal(1024 * 1024, (new KestrelServerLimits()).MaxRequestBufferSize); 65Assert.Equal(value, o.MaxRequestBufferSize); 71Assert.Equal(8 * 1024, (new KestrelServerLimits()).MaxRequestLineSize); 93Assert.Equal(value, o.MaxRequestLineSize); 99Assert.Equal(32 * 1024, (new KestrelServerLimits()).MaxRequestHeadersTotalSize); 119Assert.Equal(value, o.MaxRequestHeadersTotalSize); 125Assert.Equal(100, (new KestrelServerLimits()).MaxRequestHeaderCount); 147Assert.Equal(value, o.MaxRequestHeaderCount); 153Assert.Equal(TimeSpan.FromSeconds(130), new KestrelServerLimits().KeepAliveTimeout); 160Assert.Equal(value, new KestrelServerLimits { KeepAliveTimeout = value }.KeepAliveTimeout); 166Assert.Equal(TimeSpan.MaxValue, new KestrelServerLimits { KeepAliveTimeout = Timeout.InfiniteTimeSpan }.KeepAliveTimeout); 182Assert.Equal(TimeSpan.FromSeconds(30), new KestrelServerLimits().RequestHeadersTimeout); 189Assert.Equal(value, new KestrelServerLimits { RequestHeadersTimeout = value }.RequestHeadersTimeout); 195Assert.Equal(TimeSpan.MaxValue, new KestrelServerLimits { RequestHeadersTimeout = Timeout.InfiniteTimeSpan }.RequestHeadersTimeout); 226Assert.Equal(value, limits.MaxConcurrentConnections); 251Assert.Equal(value, limits.MaxConcurrentUpgradedConnections); 267Assert.Equal(30000000, new KestrelServerLimits().MaxRequestBodySize); 282Assert.Equal(value, limits.MaxRequestBodySize); 298Assert.Equal(240, new KestrelServerLimits().MinRequestBodyDataRate.BytesPerSecond); 299Assert.Equal(TimeSpan.FromSeconds(5), new KestrelServerLimits().MinRequestBodyDataRate.GracePeriod); 306Assert.Equal(240, new KestrelServerLimits().MinResponseDataRate.BytesPerSecond); 307Assert.Equal(TimeSpan.FromSeconds(5), new KestrelServerLimits().MinResponseDataRate.GracePeriod); 313Assert.Equal(1 << 14, new KestrelServerLimits().Http2.MaxFrameSize); 329Assert.Equal(4096, new KestrelServerLimits().Http2.HeaderTableSize); 344Assert.Equal(32 * 1024, new KestrelServerLimits().Http2.MaxRequestHeaderFieldSize);

KestrelServerOptionsTests.cs (6)

31Assert.Equal(ListenOptions.DefaultHttpProtocols, options.CodeBackedListenOptions[0].Protocols); 41Assert.Equal(HttpProtocols.Http1, opt.Protocols); 43Assert.Equal(HttpProtocols.Http1, options.CodeBackedListenOptions[1].Protocols); 47Assert.Equal(HttpProtocols.Http1, opt.Protocols); 50Assert.Equal(HttpProtocols.Http2, options.CodeBackedListenOptions[2].Protocols); 56Assert.Equal(HttpProtocols.Http2, options.CodeBackedListenOptions[3].Protocols);

KestrelServerTests.cs (19)

58Assert.Equal(0, testLogger.CriticalErrorsLogged); 131Assert.Equal(0, testLogger.CriticalErrorsLogged); 174Assert.Equal(2, infos.Count()); // ipv4 and ipv6 182Assert.Equal(2, warnings.Count()); // ipv4 and ipv6 191Assert.Equal(2, warnings.Count()); // ipv4 and ipv6 192Assert.Equal(2, infos.Count()); // ipv4 and ipv6 237Assert.Equal(0, testLogger.CriticalErrorsLogged); 264Assert.Equal(0, testLogger.CriticalErrorsLogged); 372ep => Assert.Equal(endpoint, ep.OriginalEndPoint)); 417ep => Assert.Equal(endpoint, ep.OriginalEndPoint)); 473Assert.Equal(IPAddress.IPv6Any, ((IPEndPoint)transportEndPoint.OriginalEndPoint).Address); 474Assert.Equal(IPAddress.IPv6Any, ((IPEndPoint)multiplexedTransportEndPoint.OriginalEndPoint).Address); 476Assert.Equal(5000, ((IPEndPoint)transportEndPoint.OriginalEndPoint).Port); 477Assert.Equal(5000, ((IPEndPoint)multiplexedTransportEndPoint.OriginalEndPoint).Port); 502Assert.Equal(IPAddress.IPv6Any, ((IPEndPoint)transportEndPoint.OriginalEndPoint).Address); 530Assert.Equal(IPAddress.IPv6Any, ((IPEndPoint)multiplexedTransportEndPoint.OriginalEndPoint).Address); 831Assert.Equal(2, mockTransports.Count); 852Assert.Equal(4, mockTransports.Count); 881Assert.Equal(5, mockTransports.Count);

ListenOptionsTests.cs (3)

19Assert.Equal(ListenOptions.DefaultHttpProtocols, listenOptions.Protocols); 58Assert.Equal(localhostListenOptions.Protocols, clone1.Protocols); 65Assert.Equal(localhostListenOptions.Protocols, clone2.Protocols);

MessageBodyTests.cs (33)

MinDataRateTests.cs (2)

17Assert.Equal(value, new MinDataRate(bytesPerSecond: value, gracePeriod: TimeSpan.MaxValue).BytesPerSecond); 36Assert.Equal(value, new MinDataRate(bytesPerSecond: 1, gracePeriod: value).GracePeriod);

PipelineExtensionTests.cs (3)

106Assert.Equal(0, reader.Buffer.Length); 126Assert.Equal(input.Length, reader.Buffer.Length); 146Assert.Equal(i, data[i]);

PooledStreamStackTests.cs (2)

33Assert.Equal(1, ((Http2Stream)streams._array[0]).StreamId); 72Assert.Equal(2, ((Http2Stream)streams._array[0]).StreamId);

SniOptionsSelectorTests.cs (15)

242Assert.Equal(2, fullChain.Count); 605Assert.Equal(HttpProtocols.None, httpProtocolsFeature.HttpProtocols); 638Assert.Equal(SslApplicationProtocol.Http11, protocol); 668Assert.Equal(HttpProtocols.Http1, httpProtocolsFeature.HttpProtocols); 701Assert.Equal(SslProtocols.Tls13 | SslProtocols.Tls11, options.EnabledSslProtocols); 731Assert.Equal(SslProtocols.Tls13, options.EnabledSslProtocols); 762Assert.Equal(ClientCertificateMode.DelayCertificate, certMode); 797Assert.Equal(ClientCertificateMode.AllowCertificate, certMode); 867Assert.Equal(options.AllowRenegotiation, clonedOptions.AllowRenegotiation); 872Assert.Equal(Assert.Single(options.ApplicationProtocols), Assert.Single(clonedOptions.ApplicationProtocols)); 875Assert.Equal(options.CertificateRevocationCheckMode, clonedOptions.CertificateRevocationCheckMode); 881Assert.Equal(options.ClientCertificateRequired, clonedOptions.ClientCertificateRequired); 884Assert.Equal(options.EnabledSslProtocols, clonedOptions.EnabledSslProtocols); 887Assert.Equal(options.EncryptionPolicy, clonedOptions.EncryptionPolicy); 906Assert.Equal(options.AllowTlsResume, clonedOptions.AllowTlsResume);

src\Servers\Kestrel\shared\test\CertificateAuthority.cs (1)

576Assert.Equal(CertStatus.Unknown, status);

src\Servers\Kestrel\shared\test\StreamExtensions.cs (1)

28Assert.Equal(0, await stream.ReadAsync(new byte[1], 0, 1, cancellationToken));

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

24Assert.Equal(0, dynamicTable.Size); 25Assert.Equal(4096, dynamicTable.MaxSize); 44Assert.Equal(0, dynamicTable.Size); 47Assert.Equal(_header1.Length, dynamicTable.Size); 80Assert.Equal(0, dynamicTable.Size); 94Assert.Equal(0, dynamicTable.Size); 206Assert.Equal(0, dynamicTable.Size); 220Assert.Equal(0, dynamicTable.Size); 247Assert.Equal(entries[i].Name, headerField.Name); 250Assert.Equal(entries[i].Value, headerField.Value);

src\Shared\test\Shared.Tests\runtime\Http2\HPackDecoderTest.cs (10)

507Assert.Equal(DynamicTableInitialMaxSize, _dynamicTable.MaxSize); 511Assert.Equal(30, _dynamicTable.MaxSize); 521Assert.Equal(DynamicTableInitialMaxSize, _dynamicTable.MaxSize); 531Assert.Equal(DynamicTableInitialMaxSize, _dynamicTable.MaxSize); 546Assert.Equal(DynamicTableInitialMaxSize, _dynamicTable.MaxSize); 555Assert.Equal(30, _dynamicTable.MaxSize); 564Assert.Equal(DynamicTableInitialMaxSize, _dynamicTable.MaxSize); 828Assert.Equal(0, dynamicTable.Size); 853Assert.Equal(expectedHeaderName.Length + expectedHeaderValue.Length + 32, dynamicTable.Size); 858Assert.Equal(0, dynamicTable.Size);

src\Shared\test\Shared.Tests\runtime\Http2\HPackIntegerTest.cs (4)

20Assert.Equal(expectedResult.Length, bytesWritten); 49Assert.Equal(encoded.Length, i); 51Assert.Equal(expectedResult, actualResult); 76Assert.Equal(i, intResult);

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

76Assert.Equal(input.Length, decodedByteCount); 123Assert.Equal(prefixBits % 8, encodedBits % 8); 250Assert.Equal(expected.Length, Huffman.Decode(new ReadOnlySpan<byte>(encoded), ref dst)); 251Assert.Equal(expected, dst); 300Assert.Equal(5, decodedCount); 346Assert.Equal(expectedLength, decodedLength); 347Assert.Equal(new byte[] { (byte)'B', (byte)'\n' }, decodedBytes); 355Assert.Equal(expectedEncoded, encoded); 356Assert.Equal(expectedBitLength, bitLength);

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

21Assert.Equal(0, value); 22Assert.Equal(0, bytesRead); 36Assert.Equal(1, value); 37Assert.Equal(1, bytesRead); 52Assert.Equal(1, value); 53Assert.Equal(2, bytesRead); 67Assert.Equal(0, value); 68Assert.Equal(0, bytesRead); 85Assert.Equal(2, value); 86Assert.Equal(4, bytesRead); 100Assert.Equal(0, value); 101Assert.Equal(0, bytesRead); 117Assert.Equal(4, value); 118Assert.Equal(8, bytesRead); 132Assert.Equal(0, value); 133Assert.Equal(0, bytesRead); 148Assert.Equal(1, value); 149Assert.Equal(1, sequenceReader.CurrentSpanIndex); 184Assert.Equal(1, value); 185Assert.Equal(1, sequenceReader.CurrentSpanIndex); 200Assert.Equal(2, value); 201Assert.Equal(7, sequenceReader.CurrentSpanIndex); 216Assert.Equal(0, value); 229Assert.Equal(2, result); 230Assert.Equal(7, consumed.GetInteger()); 231Assert.Equal(7, examined.GetInteger()); 244Assert.Equal(-1, result); 245Assert.Equal(0, consumed.GetInteger()); 246Assert.Equal(6, examined.GetInteger()); 258Assert.Equal(0, bytesWritten); 272Assert.Equal(1, bytesWritten); 273Assert.Equal(longToEncode, span[0]); 288Assert.Equal(2, bytesWritten); 289Assert.Equal(expected, span.ToArray()); 301Assert.Equal(0, bytesWritten); 316Assert.Equal(4, bytesWritten); 317Assert.Equal(expected, span.ToArray()); 329Assert.Equal(0, bytesWritten); 344Assert.Equal(8, bytesWritten); 345Assert.Equal(expected, span.ToArray()); 357Assert.Equal(0, bytesWritten); 369Assert.Equal(expectedLimit, result);

UTF8Decoding.cs (1)

23Assert.Equal(1, s.Length);

VariableIntHelperTests.cs (3)

18Assert.Equal(expected, decoded); 27Assert.Equal(expected.Length, encodedLength); 30Assert.Equal(expected[i], outputBuffer[i]);

ConfigurationReaderTests.cs (6)

174Assert.Equal(4, endpoints.Count()); 332Assert.Equal(HttpProtocols.Http1, config.Protocols); 333Assert.Equal(SslProtocols.Tls12, config.SslProtocols); 336Assert.Equal(ClientCertificateMode.AllowCertificate, config.ClientCertificateMode); 353Assert.Equal(SslProtocols.Tls11, endpoint.SslProtocols); 390Assert.Equal(ClientCertificateMode.AllowCertificate, endpoint.ClientCertificateMode);

HttpsConfigurationTests.cs (1)

71Assert.Equal(new[] { httpAddress, httpsAddress }, host.ServerFeatures.Get<IServerAddressesFeature>().Addresses);

HttpsConnectionAdapterOptionsTest.cs (3)

17Assert.Equal(TimeSpan.FromSeconds(10), new HttpsConnectionAdapterOptions().HandshakeTimeout); 24Assert.Equal(value, new HttpsConnectionAdapterOptions { HandshakeTimeout = value }.HandshakeTimeout); 30Assert.Equal(TimeSpan.MaxValue, new HttpsConnectionAdapterOptions { HandshakeTimeout = Timeout.InfiniteTimeSpan }.HandshakeTimeout);

KestrelConfigurationLoaderTests.cs (60)

QuicConnectionContextTests.cs (12)

110Assert.Equal(TestData, read.Buffer.ToArray()); 140Assert.Equal(QuicError.ConnectionAborted, innerEx.QuicError); 141Assert.Equal(256, innerEx.ApplicationErrorCode.Value); 224Assert.Equal(TestData, data); 280Assert.Equal(0, readCount); 303Assert.Equal(QuicError.ConnectionAborted, innerEx.QuicError); 304Assert.Equal((long)Http3ErrorCode.NoError, innerEx.ApplicationErrorCode.Value); 428Assert.Equal((long)Http3ErrorCode.InternalError, ((QuicException)ex.InnerException).ApplicationErrorCode.Value); 477Assert.Equal((long)Http3ErrorCode.InternalError, ((QuicException)serverEx.InnerException).ApplicationErrorCode.Value); 488Assert.Equal(QuicError.StreamAborted, clientEx.QuicError); 489Assert.Equal((long)Http3ErrorCode.RequestRejected, clientEx.ApplicationErrorCode.Value); 706Assert.Equal(true, state);

QuicConnectionListenerTests.cs (2)

144Assert.Equal(testCert, tlsFeature.ClientCertificate); 325Assert.Equal(SslApplicationProtocol.Http3, clientConnection.NegotiatedApplicationProtocol);

QuicStreamContextTests.cs (13)

208Assert.Equal(testData.Length, data.Length); 209Assert.Equal(testData, data); 281Assert.Equal((long)Http3ErrorCode.InternalError, ((QuicException)ex.InnerException).ApplicationErrorCode.Value); 285Assert.Equal((long)Http3ErrorCode.InternalError, quicStreamContext.Error); 356Assert.Equal((long)Http3ErrorCode.InternalError, ((QuicException)ex.InnerException).ApplicationErrorCode.Value); 419Assert.Equal(TestData, data); 426Assert.Equal(0, readCount); 460Assert.Equal(TestData, data); 469Assert.Equal(QuicError.StreamAborted, ex.QuicError); 470Assert.Equal((long)Http3ErrorCode.InternalError, ex.ApplicationErrorCode.Value); 518Assert.Equal(TestData, data); 522Assert.Equal(QuicError.StreamAborted, clientEx.QuicError); 523Assert.Equal((long)Http3ErrorCode.InternalError, clientEx.ApplicationErrorCode.Value);

src\Servers\Kestrel\shared\test\StreamExtensions.cs (1)

28Assert.Equal(0, await stream.ReadAsync(new byte[1], 0, 1, cancellationToken));

WebHostTests.cs (7)

88Assert.Equal(HttpVersion.Version30, response.Version); 252Assert.Equal(HttpVersion.Version20, response1.Version); 266Assert.Equal(HttpVersion.Version30, response2.Version); 323Assert.Equal(HttpVersion.Version20, response1.Version); 336Assert.Equal(HttpVersion.Version20, response2.Version); 361Assert.Equal(HttpVersion.Version30, response1.Version); 373Assert.Equal(HttpVersion.Version11, response2.Version);

SessionTests.cs (22)

AdaptiveCapacityDictionaryTests.cs (73)

ClosedGenericMatcherTest.cs (3)

174Assert.Equal(expectedResult, result); 188Assert.Equal(typeof(IEnumerable<int>), result); 202Assert.Equal(typeof(IEnumerable<int>), result);

CommandLineApplicationTests.cs (21)

CopyOnWriteDictionaryHolderTest.cs (13)

26Assert.Equal("key2-value", holder["key2"]); 27Assert.Equal(2, holder.Count); 28Assert.Equal(new string[] { "test-key", "key2" }, holder.Keys.ToArray()); 29Assert.Equal(new object[] { "test-value", "key2-value" }, holder.Values.ToArray()); 55Assert.Equal("value2", source["key2"]); 56Assert.Equal(2, holder.Count); 57Assert.Equal("value1", holder["key1"]); 58Assert.Equal("value3", holder["key2"]); 81Assert.Equal(2, source.Count); 82Assert.Equal("value1", source["key1"]); 83Assert.Equal(2, holder.Count); 84Assert.Equal("value2", holder["KeY2"]); 85Assert.Equal("value3", holder["key3"]);

CopyOnWriteDictionaryTest.cs (11)

ObjectMethodExecutorTest.cs (10)

29Assert.Equal(30, (int)result); 88Assert.Equal(30, (int)result); 150Assert.Equal(suppliedDefaultValues[0], executor.GetDefaultValueForParameter(0)); 151Assert.Equal(suppliedDefaultValues[1], executor.GetDefaultValueForParameter(1)); 190Assert.Equal(579, result); 224Assert.Equal(579, (int)result); 289Assert.Equal(123, result); 320Assert.Equal(123, (int)result); 335Assert.Equal("test result", result); 389Assert.Equal("test result", result);

PropertyActivatorTest.cs (5)

32Assert.Equal(123, invokedWith); 48Assert.Equal(124, instance.IntProperty); 71Assert.Equal(expectedPropertyInfo, activator.PropertyInfo); 95Assert.Equal(expectedPropertyInfo, activator.PropertyInfo); 133Assert.Equal(5, propertiesToActivate.Length);

PropertyHelperTest.cs (46)

runtime\Http2\DynamicTableTest.cs (21)

runtime\Http2\HPackDecoderTest.cs (13)

507Assert.Equal(DynamicTableInitialMaxSize, _dynamicTable.MaxSize); 511Assert.Equal(30, _dynamicTable.MaxSize); 521Assert.Equal(DynamicTableInitialMaxSize, _dynamicTable.MaxSize); 531Assert.Equal(DynamicTableInitialMaxSize, _dynamicTable.MaxSize); 546Assert.Equal(DynamicTableInitialMaxSize, _dynamicTable.MaxSize); 555Assert.Equal(30, _dynamicTable.MaxSize); 564Assert.Equal(DynamicTableInitialMaxSize, _dynamicTable.MaxSize); 827Assert.Equal(0, dynamicTable.Count); 828Assert.Equal(0, dynamicTable.Size); 850Assert.Equal(1, dynamicTable.Count); 853Assert.Equal(expectedHeaderName.Length + expectedHeaderValue.Length + 32, dynamicTable.Size); 857Assert.Equal(0, dynamicTable.Count); 858Assert.Equal(0, dynamicTable.Size);

runtime\Http2\HPackIntegerTest.cs (4)

20Assert.Equal(expectedResult.Length, bytesWritten); 49Assert.Equal(encoded.Length, i); 51Assert.Equal(expectedResult, actualResult); 76Assert.Equal(i, intResult);

runtime\Http2\HuffmanDecodingTests.cs (9)

76Assert.Equal(input.Length, decodedByteCount); 123Assert.Equal(prefixBits % 8, encodedBits % 8); 250Assert.Equal(expected.Length, Huffman.Decode(new ReadOnlySpan<byte>(encoded), ref dst)); 251Assert.Equal(expected, dst); 300Assert.Equal(5, decodedCount); 346Assert.Equal(expectedLength, decodedLength); 347Assert.Equal(new byte[] { (byte)'B', (byte)'\n' }, decodedBytes); 355Assert.Equal(expectedEncoded, encoded); 356Assert.Equal(expectedBitLength, bitLength);

runtime\Http3\VariableLengthIntegerHelperTests.cs (42)

21Assert.Equal(0, value); 22Assert.Equal(0, bytesRead); 36Assert.Equal(1, value); 37Assert.Equal(1, bytesRead); 52Assert.Equal(1, value); 53Assert.Equal(2, bytesRead); 67Assert.Equal(0, value); 68Assert.Equal(0, bytesRead); 85Assert.Equal(2, value); 86Assert.Equal(4, bytesRead); 100Assert.Equal(0, value); 101Assert.Equal(0, bytesRead); 117Assert.Equal(4, value); 118Assert.Equal(8, bytesRead); 132Assert.Equal(0, value); 133Assert.Equal(0, bytesRead); 148Assert.Equal(1, value); 149Assert.Equal(1, sequenceReader.CurrentSpanIndex); 184Assert.Equal(1, value); 185Assert.Equal(1, sequenceReader.CurrentSpanIndex); 200Assert.Equal(2, value); 201Assert.Equal(7, sequenceReader.CurrentSpanIndex); 216Assert.Equal(0, value); 229Assert.Equal(2, result); 230Assert.Equal(7, consumed.GetInteger()); 231Assert.Equal(7, examined.GetInteger()); 244Assert.Equal(-1, result); 245Assert.Equal(0, consumed.GetInteger()); 246Assert.Equal(6, examined.GetInteger()); 258Assert.Equal(0, bytesWritten); 272Assert.Equal(1, bytesWritten); 273Assert.Equal(longToEncode, span[0]); 288Assert.Equal(2, bytesWritten); 289Assert.Equal(expected, span.ToArray()); 301Assert.Equal(0, bytesWritten); 316Assert.Equal(4, bytesWritten); 317Assert.Equal(expected, span.ToArray()); 329Assert.Equal(0, bytesWritten); 344Assert.Equal(8, bytesWritten); 345Assert.Equal(expected, span.ToArray()); 357Assert.Equal(0, bytesWritten); 369Assert.Equal(expectedLimit, result);

SecurityHelperTests.cs (10)

44Assert.Equal(3, user.Identities.Count()); 74Assert.Equal(4, user.Identities.Count()); 75Assert.Equal(newEmptyIdentity, user.Identities.Skip(0).First()); 76Assert.Equal(identityTwo, user.Identities.Skip(1).First()); 77Assert.Equal(identityNoAuthTypeWithClaim, user.Identities.Skip(2).First()); 78Assert.Equal(identityEmptyWithAuthType, user.Identities.Skip(3).First()); 86Assert.Equal(4, user.Identities.Count()); 88Assert.Equal(identityTwo, user.Identities.Skip(1).First()); 89Assert.Equal(identityNoAuthTypeWithClaim, user.Identities.Skip(2).First()); 90Assert.Equal(identityEmptyWithAuthType, user.Identities.Skip(3).First());

SegmentWriteStreamTests.cs (6)

55Assert.Equal(WriteData.Length, stream.Length); 56Assert.Equal((WriteData.Length + segmentSize - 1) / segmentSize, segments.Count); 68Assert.Equal(expectedSegmentSize, segment.Length); 88Assert.Equal(WriteData.Length, stream.Length); 89Assert.Equal((WriteData.Length + segmentSize - 1) / segmentSize, segments.Count); 101Assert.Equal(expectedSegmentSize, segment.Length);

StackTraceHelperTest.cs (1)

43Assert.Equal(17, frame.LineNumber);

UrlDecoderTests.cs (7)

72Assert.Equal(4, length); 80Assert.Equal(4, length); 107Assert.Equal(input.Length, length); 121Assert.Equal(source.Length, length); 131Assert.Equal(1, length); 145Assert.Equal(input.Length, length); 159Assert.Equal(source.Length, length);

HubConnectionTests.cs (15)

454Assert.Equal(expectedValue, streamValue); 458Assert.Equal(streamTo, expectedValue); 500Assert.Equal(expectedValue, streamValue); 504Assert.Equal(streamTo, expectedValue); 535Assert.Equal(expectedValue, streamValue); 539Assert.Equal(streamTo, expectedValue); 766Assert.Equal(new[] { 0, 1, 2, 3, 4 }, results.ToArray()); 1386Assert.Equal(LogLevel.Error, errorLog.Write.LogLevel); 1440Assert.Equal(LogLevel.Error, errorLog.Write.LogLevel); 1575Assert.Equal(new[] { "42", "test" }, headerValues); 1953Assert.Equal(1, accessTokenCallCount); 2072Assert.Equal(HttpTransportType.LongPolling, transport); 2780Assert.Equal(HubConnectionState.Disconnected, connection.State); 2781Assert.Equal(1, connectCount); 2901Assert.Equal(HubConnectionState.Disconnected, connection.State);

HttpConnectionFactoryTests.cs (1)

119Assert.Equal(testValues[property.Name], property.GetValue(shallowCopiedOptions));

HttpConnectionTests.ConnectionLifecycle.cs (5)

123Assert.Equal(0, startCounter); 125Assert.Equal(passThreshold, startCounter); 168Assert.Equal(availableTransports, startCounter); 306Assert.Collection(data, i => Assert.Equal(0x42, i)); 448Assert.Equal(3, ex.InnerExceptions.Count);

HttpConnectionTests.cs (7)

34Assert.Equal(1024 * 1024, httpOptions.TransportMaxBufferSize); 35Assert.Equal(1024 * 1024, httpOptions.ApplicationMaxBufferSize); 36Assert.Equal(TimeSpan.FromSeconds(5), httpOptions.CloseTimeout); 37Assert.Equal(TransferFormat.Binary, httpOptions.DefaultTransferFormat); 38Assert.Equal(HttpTransports.All, httpOptions.Transports); 109Assert.Equal(1, httpClientHandler.CookieContainer.Count); 161Assert.Equal(2, writeList.Count);

HttpConnectionTests.Negotiate.cs (3)

304Assert.Equal(5, testHttpHandler.ReceivedRequests.Count); 411Assert.Equal(5, testHttpHandler.ReceivedRequests.Count); 473Assert.Equal(5, testHttpHandler.ReceivedRequests.Count);

HttpConnectionTests.Transport.cs (10)

75Assert.Equal(1, callCount); 99Assert.Equal(expectedValue, feature.HasInherentKeepAlive); 248Assert.Equal(data, await sendTcs.Task.DefaultTimeout()); 311Assert.Equal(TransferFormat.Text, transport.Format); 340Assert.Equal(1, negotiateCount); 341Assert.Equal(1, accessTokenCallCount); 417Assert.Equal(7, accessTokenCallCount); 451Assert.Equal(2, accessTokenCallCount); 513Assert.Equal(3, accessTokenCallCount); 554Assert.Equal(2, accessTokenCallCount);

HubClientProxyGeneratorTests.cs (4)

246Assert.Equal(1, myClient.CallsOfNoArg); 251Assert.Equal(10, myClient.CallsOfSingleArg[0]); 256Assert.Equal((10, 5.5f, null), myClient.CallsOfManyArgs[0]); 260Assert.Equal(1, myClient.CallsOfReturnTask);

HubConnectionBuilderExtensionsTests.cs (3)

29Assert.Equal(new Uri("http://tempuri.org"), value.Url); 42Assert.Equal(HttpTransportType.LongPolling, value.Transports); 56Assert.Equal(HttpTransportType.LongPolling, value.Transports);

HubConnectionBuilderTests.cs (4)

91Assert.Equal(serverTimeout, connection.ServerTimeout); 104Assert.Equal(keepAliveInterval, connection.KeepAliveInterval); 119Assert.Equal(serverTimeout, connection.ServerTimeout); 120Assert.Equal(keepAliveInterval, connection.KeepAliveInterval);

HubConnectionTests.ConnectionLifecycle.cs (24)

HubConnectionTests.cs (30)

HubConnectionTests.Extensions.cs (22)

HubConnectionTests.Protocol.cs (4)

137Assert.Equal(TaskStatus.WaitingForActivation, invokeTask.Status); 288Assert.Equal(42, await invokeTask.DefaultTimeout()); 407Assert.Equal(new[] { "1", "2", "3", }, notifications.ToArray()); 431Assert.Equal(args, await handlerCalled.Task.DefaultTimeout());

HubConnectionTests.Reconnect.cs (66)

HubServerProxyGeneratorTests.cs (6)

93Assert.Equal(10, result); 119Assert.Collection(result, item => Assert.Equal(10, item)); 142Assert.Equal(10, result); 167Assert.Collection(result, item => Assert.Equal(10, item)); 250Assert.Equal(6, result); 334Assert.Equal(10, result);

LongPollingTransportTests.cs (4)

442Assert.Equal(3, sentRequests.Count); 511Assert.Equal(new[] { (byte)'H', (byte)'e', (byte)'l', (byte)'l', (byte)'o', (byte)'W', (byte)'o', (byte)'r', (byte)'l', (byte)'d' 694Assert.Equal(TestUri, deleteRequest.RequestUri); 749Assert.Equal(HttpStatusCode.OK, response.StatusCode);

SendUtilsTests.cs (1)

47Assert.Equal(HttpStatusCode.OK, response.StatusCode);

ServerSentEventsTransportTests.cs (1)

438Assert.Equal(HttpStatusCode.OK, response.StatusCode);

Internal\Formatters\BinaryMessageFormatterTests.cs (1)

129Assert.Equal(payload, roundtripped.ToArray());

Internal\Formatters\BinaryMessageParserTests.cs (9)

23Assert.Equal(0, span.Length); 25Assert.Equal(Encoding.UTF8.GetBytes(payload), message.ToArray()); 58Assert.Equal(0, span.Length); 59Assert.Equal(payload, message.ToArray()); 105Assert.Equal(0, buffer.Length); 107Assert.Equal(2, messages.Count); 108Assert.Equal(new byte[0], messages[0]); 109Assert.Equal(Encoding.UTF8.GetBytes("Hello,\r\nWorld!"), messages[1]); 119Assert.Equal(encoded.Length, buffer.Length);

Internal\Protocol\HandshakeProtocolTests.cs (2)

31Assert.Equal(version, deserializedMessage.Version); 42Assert.Equal(1, deserializedMessage.Version);

Internal\Protocol\JsonHubProtocolTests.cs (4)

107Assert.Equal(expectedMessage, message); 134Assert.Equal(1, invocationMessage.Arguments?.Length); 254Assert.Equal(expected.GetType(), actual.GetType()); 259Assert.Equal(expectedPersonExtended.Age, actualPersonExtended.Age);

Internal\Protocol\JsonHubProtocolTestsBase.cs (4)

285Assert.Equal(DateTimeKind.Utc, dt.Kind); 299Assert.Equal(DateTimeKind.Utc, dt.Kind); 323Assert.Equal(new CustomObject() 458Assert.Equal(testData.Result, completion.Result);

Internal\Protocol\MemoryBufferWriterTests.cs (18)

Internal\Protocol\MessagePackHubProtocolTestBase.cs (2)

444Assert.Equal(testData.Size, Write(testData.Message).Length); 481Assert.Equal(expectedOutput, message.ToArray());

Internal\Protocol\MessagePackHubProtocolTests.cs (3)

49Assert.Equal(expectedUtcDateTime, resultDateTime); 72Assert.Equal(dateTimeOffset, resultDateTimeOffset); 238Assert.Equal(testData.Result, completion.Result);

Internal\Protocol\Utf8BufferTextWriterTests.cs (59)

HubLifetimeManagerTestBase.cs (6)

192Assert.Equal("test", invocation.Arguments[0]); 197Assert.Equal(10L, res); 219Assert.Equal("test", invocation.Arguments[0]); 249Assert.Equal("test", invocation.Arguments[0]); 260Assert.Equal(10L, res); 313Assert.Equal(3, await invoke1.DefaultTimeout());

ScaleoutHubLifetimeManagerTests.cs (6)

488Assert.Equal("test", invocation.Arguments[0]); 494Assert.Equal(10L, res); 519Assert.Equal("test", invocation.Arguments[0]); 609Assert.Equal(2, res); 611Assert.Equal(5, res); 651Assert.Equal("test", invocation.Arguments[0]);

DefaultHubMessageSerializerTests.cs (2)

30Assert.Equal(testData.SerializedCount, serializedHubMessage.Count); 49Assert.Equal(1, serializedHubMessage.Count);

RedisDependencyInjectionExtensionsTests.cs (2)

36Assert.Equal(port, dnsEndpoint.Port); 38Assert.Equal(useSsl, options.Value.Configuration.Ssl);

RedisProtocolTests.cs (8)

42Assert.Equal(testData.Decoded, decoded); 54Assert.Equal(testData.Encoded, encoded); 74Assert.Equal(testData.Decoded.Id, decoded.Id); 90Assert.Equal(testData.Encoded, encoded); 152Assert.Equal(expected.ExcludedConnectionIds, decoded.ExcludedConnectionIds); 184Assert.Equal(testData.Encoded, encoded); 200Assert.Equal(testData.Encoded, encoded); 274Assert.Equal(testData.Encoded, encoded);

AddSignalRTests.cs (17)

EndToEndTests.cs (7)

111Assert.Equal(bytes, buffer.Array.AsSpan(0, result.Count).ToArray()); 117Assert.Equal(WebSocketMessageType.Close, result.MessageType); 118Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus); 150Assert.Equal(bytes, buffer.Array.AsSpan(0, result.Count).ToArray()); 156Assert.Equal(WebSocketMessageType.Close, result.MessageType); 157Assert.Equal(WebSocketCloseStatus.NormalClosure, result.CloseStatus); 196Assert.Equal(message, receivedData);

HubConnectionHandlerTests.Activity.cs (16)

HubConnectionHandlerTests.ClientResult.cs (19)

34Assert.Equal(9L, completion.Result); 152Assert.Equal(1L, invocation.Arguments[0]); 158Assert.Equal(2, result); 186Assert.Equal(1L, invocation.Arguments[0]); 192Assert.Equal(2, result); 224Assert.Equal(new ClientResults(11, 7), completion.Result); 263Assert.Equal(9L, completion.Result); 269Assert.Equal(10L, completion.Result); 275Assert.Equal(11L, completion.Result); 312Assert.Equal(5, await tcsService.EndMethod.Task.DefaultTimeout()); 316Assert.Equal(43L, completionMessage.Result); 379Assert.Equal(1, invocation.Arguments[0]); 393Assert.Equal("test", completion.Result); 424Assert.Equal(1L, invocation.Arguments[0]); 438Assert.Equal("test", completion.Result); 471Assert.Equal(5L, completion.Result); 476Assert.Equal(43L, completionMessage.Result); 506Assert.Equal(5, streamItem.Item); 514Assert.Equal(43, completionMessage.Result);

HubConnectionHandlerTests.cs (103)

HubConnectionHandlerTestUtils\Utils.cs (4)

35Assert.Equal(expectedCompletion.HasResult, actualCompletion.HasResult); 36Assert.Equal(expectedCompletion.Result, actualCompletion.Result); 40Assert.Equal(expectedStreamItem.Item, actualStreamItem.Item); 49Assert.Equal(expectedInvocation.Arguments, actualInvocation.Arguments);

HubFilterTests.cs (23)

HubReflectionHelperTests.cs (2)

26Assert.Equal(3, hubMethods.Count()); 38Assert.Equal(4, hubMethods.Count());

Internal\DefaultHubProtocolResolverTests.cs (1)

98Assert.Equal(1, hubProtocols.Count);

Internal\MessageBufferTests.cs (6)

154Assert.Equal(1, seqMessage.SequenceId); 201Assert.Equal(2, seqMessage.SequenceId); 233Assert.Equal(1, seqMessage.SequenceId); 265Assert.Equal(ackNum + 1, seqMessage.SequenceId); 384Assert.Equal(2, ackMessage.SequenceId); 396Assert.Equal(3, ackMessage.SequenceId);

Internal\TypedClientBuilderTests.cs (19)

25Assert.Equal("foo", send.Arguments[0]); 26Assert.Equal(42, send.Arguments[1]); 27Assert.Equal(CancellationToken.None, send.CancellationToken); 49Assert.Equal("foo", send.Arguments[0]); 50Assert.Equal(42, send.Arguments[1]); 51Assert.Equal(CancellationToken.None, send.CancellationToken); 77arg1 => Assert.Equal("foo", arg1), 78arg2 => Assert.Equal(42, arg2), 80Assert.Equal(CancellationToken.None, send1.CancellationToken); 87arg1 => Assert.Equal("bar", arg1)); 88Assert.Equal(CancellationToken.None, send2.CancellationToken); 115arg1 => Assert.Equal("foo", arg1)); 116Assert.Equal(cts1.Token, send1.CancellationToken); 123Assert.Equal(cts2.Token, send2.CancellationToken); 220arg1 => Assert.Equal(1008, arg1), 223Assert.Equal(CancellationToken.None, send.CancellationToken); 263arg1 => Assert.Equal("foo", arg1)); 264Assert.Equal(cts1.Token, send1.CancellationToken); 271Assert.Equal(cts2.Token, send2.CancellationToken);

MapSignalRTests.cs (30)

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)

53Assert.Equal(1, webSocketsOptions.Cookies.Count);

StaticAssetsIntegrationTests.cs (32)

FallbackStaticFileTest.cs (4)

62Assert.Equal(HttpStatusCode.OK, response.StatusCode); 68Assert.Equal(HttpStatusCode.OK, response.StatusCode); 111Assert.Equal(HttpStatusCode.OK, response.StatusCode); 117Assert.Equal(HttpStatusCode.OK, response.StatusCode);

StaticFileMiddlewareTests.cs (6)

40Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); 85Assert.Equal(HttpStatusCode.OK, response.StatusCode); 113Assert.Equal(response.Content.Headers.LastModified.Value, trimmed); 162Assert.Equal(HttpStatusCode.OK, response.StatusCode); 165Assert.Equal(response.Content.Headers.ContentLength, responseContent.Length); 204Assert.Equal(HttpStatusCode.OK, response.StatusCode);

CacheHeaderTests.cs (23)

DefaultFilesMiddlewareTests.cs (7)

27Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); 75Assert.Equal(HttpStatusCode.OK, response.StatusCode); 118Assert.Equal(HttpStatusCode.OK, response.StatusCode); 160Assert.Equal(HttpStatusCode.OK, response.StatusCode); 224Assert.Equal(HttpStatusCode.OK, response.StatusCode); 265Assert.Equal(HttpStatusCode.Moved, response.StatusCode); 321Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); // Passed through

DirectoryBrowserMiddlewareTests.cs (10)

RangeHeaderTests.cs (45)

RangeHelperTests.cs (6)

43Assert.Equal(normalizedStart, normalizedRange.From); 44Assert.Equal(normalizedEnd, normalizedRange.To); 54Assert.Equal(1, normalizedRange.From); 55Assert.Equal(3, normalizedRange.To); 105Assert.Equal(1, parsedRange.From); 106Assert.Equal(2, parsedRange.To);

StaticFileContextTest.cs (3)

88Assert.Equal(HttpsCompressionMode.Compress, httpsCompressionFeature.Mode); 115Assert.Equal(HttpsCompressionMode.Default, httpsCompressionFeature.Mode); 145Assert.Equal(0, body.Length);

StaticFileMiddlewareTests.cs (20)

ClientHandlerTests.cs (11)

35Assert.Equal(200, features.Get<IHttpResponseFeature>().StatusCode); 60Assert.Equal(200, context.Response.StatusCode); 86Assert.Equal(200, features.Get<IHttpResponseFeature>().StatusCode); 133Assert.Equal(contentBytes.LongLength, context.Request.ContentLength); 228Assert.Equal(11, read); 237Assert.Equal(9, read); 243Assert.Equal(0, read); 247Assert.Equal(0, read); 267Assert.Equal(IPAddress.Parse("1.1.1.1"), features.Get<IHttpConnectionFeature>().RemoteIpAddress); 354Assert.Equal(11, read); 503Assert.Equal(0, requestCount);

HttpContextBuilderTests.cs (2)

43Assert.Equal(404, context.Response.StatusCode); 296Assert.Equal(11, context.Response.Body.Read(new byte[100], 0, 100));

RequestBuilderTests.cs (1)

48Assert.Equal(server, requestBuilder.TestServer);

ResponseBodyTests.cs (9)

29Assert.Equal(length, bytes.Length); 46Assert.Equal(length, bytes.Length); 81Assert.Equal(contentBytes, responseBytes); 120Assert.Equal(contentBytes, responseBytes); 141Assert.Equal(1, read); 142Assert.Equal(contentBytes[0], bytes[0]); 150Assert.Equal(0, read); 153Assert.Equal(1, read); 154Assert.Equal(contentBytes[0], bytes[0]);

ResponseFeatureTests.cs (2)

15Assert.Equal(200, responseInformation.StatusCode); 31Assert.Equal(200, responseInformation.StatusCode);

ResponseResetTests.cs (4)

83Assert.Equal(12345, rex.ErrorCode); 102Assert.Equal(12345, rex.ErrorCode); 128Assert.Equal(12345, rex.ErrorCode); 154Assert.Equal(12345, rex.ErrorCode);

TestClientTests.cs (19)

236Assert.Equal(0, length); 258Assert.Equal(0, requestCount); 399Assert.Equal(0, length); 490Assert.Equal(0, length); 623Assert.Equal(WebSocketState.CloseSent, clientSocket.State); 627Assert.Equal(hello.Length, result.Count); 629Assert.Equal(WebSocketMessageType.Text, result.MessageType); 632Assert.Equal(world.Length, result.Count); 634Assert.Equal(WebSocketMessageType.Binary, result.MessageType); 637Assert.Equal(WebSocketMessageType.Close, result.MessageType); 638Assert.Equal(WebSocketState.Closed, clientSocket.State); 687Assert.Equal(WebSocketMessageType.Close, result.MessageType); 689Assert.Equal(WebSocketState.CloseReceived, clientSocket.State); 817Assert.Equal(buffer.Length, result.Count); 818Assert.Equal(buffer[0], hello[i]); 819Assert.Equal(last, result.EndOfMessage); 960Assert.Equal(new Version(1, 1), message.Version); 987Assert.Equal(new Version(2, 0), message.Version); 1014Assert.Equal(new Version(3, 0), message.Version);

TestServerTests.cs (13)

40Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); 56Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); 72Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); 188Assert.Equal(testService, server.Host.Services.GetRequiredService<TestService>()); 319Assert.Equal(serviceProvider, testServer.Services); 335Assert.Equal(testService, testServer.Services.GetService<TestService>()); 358Assert.Equal(testService, testServer.Services.GetService<TestService>()); 387Assert.Equal(baseAddress, testServer.BaseAddress); 500Assert.Equal(appServices, context.RequestServices); 655Assert.Equal(HttpStatusCode.OK, result.StatusCode); 673Assert.Equal(HttpStatusCode.OK, result.StatusCode); 703Assert.Equal(HttpStatusCode.OK, result.StatusCode); 716Assert.Equal(HttpStatusCode.OK, result.StatusCode);

WebSocketClientTests.cs (1)

87Assert.Equal(10, res.Count);

WebApplicationTests.cs (34)

WebHostTests.cs (1)

124Assert.Equal(typeof(RegexInlineRouteConstraint), routeOptions.Value.ConstraintMap["regex"]);

AddWebSocketsTests.cs (1)

26Assert.Equal(TimeSpan.FromSeconds(1000), socketOptions.KeepAliveInterval);

Http2WebSocketTests.cs (1)

29Assert.Equal(new[] { "p1", "p2" }, httpContext.WebSockets.WebSocketRequestedProtocols);

SendReceiveTests.cs (8)

24Assert.Equal(WebSocketMessageType.Text, result.MessageType); 41Assert.Equal(WebSocketMessageType.Text, result.MessageType); 56Assert.Equal(WebSocketMessageType.Binary, result.MessageType); 57Assert.Equal(sendBuffer, receiveBuffer.Take(result.Count).ToArray()); 71Assert.Equal(WebSocketMessageType.Binary, result.MessageType); 72Assert.Equal(sendBuffer, receiveBuffer.Take(result.Count).ToArray()); 86Assert.Equal(WebSocketMessageType.Binary, result.MessageType); 101Assert.Equal(WebSocketError.ConnectionClosedPrematurely, ex.WebSocketErrorCode);

WebSocketCompressionMiddlewareTests.cs (4)

40Assert.Equal(HttpStatusCode.SwitchingProtocols, response.StatusCode); 68Assert.Equal(HttpStatusCode.SwitchingProtocols, response.StatusCode); 102Assert.Equal(HttpStatusCode.SwitchingProtocols, response.StatusCode); 155Assert.Equal(sendCount, totalRecv);

WebSocketMiddlewareTests.cs (62)

FileBufferingReadStreamTests.cs (119)

FileBufferingWriteStreamTests.cs (26)

FormPipeReaderTests.cs (18)

99Assert.Equal(3, formCollection.Count); 114Assert.Equal(Encoding.UTF8.GetBytes(content), readResult.Buffer.ToArray()); 129Assert.Equal(Encoding.UTF8.GetBytes(content), readResult.Buffer.ToArray()); 142Assert.Equal(3, formCollection.Count); 157Assert.Equal(Encoding.UTF8.GetBytes(content), readResult.Buffer.ToArray()); 170Assert.Equal(3, formCollection.Count); 185Assert.Equal(Encoding.UTF8.GetBytes(content), readResult.Buffer.ToArray()); 210Assert.Equal(Encoding.UTF8.GetBytes("baz=12345678901"), readResult.Buffer.ToArray()); 266Assert.Equal(2, accumulator.KeyCount); 284Assert.Equal(3, accumulator.KeyCount); 306Assert.Equal(3, accumulator.KeyCount); 325Assert.Equal(3, accumulator.KeyCount); 347Assert.Equal(3, accumulator.KeyCount); 366Assert.Equal(2, accumulator.KeyCount); 384Assert.Equal(3, accumulator.KeyCount); 403Assert.Equal(3, accumulator.KeyCount); 422Assert.Equal(2, accumulator.KeyCount); 439Assert.Equal(2, accumulator.KeyCount);

FormReaderTests.cs (3)

73Assert.Equal(3, formCollection.Count); 112Assert.Equal(3, formCollection.Count); 139Assert.Equal(3, formCollection.Count);

HttpRequestStreamReaderTest.cs (16)

49Assert.Equal(5000, result.Length); 78Assert.Equal((int)CharData[i], tmp); 92Assert.Equal((int)CharData[i], peek); 109Assert.Equal(0, read); 123Assert.Equal(chars.Length, read); 126Assert.Equal(CharData[i], chars[i]); 141Assert.Equal(3, read); 144Assert.Equal(CharData[i], chars[i + 4]); 278Assert.Equal(chars.Length, read); 281Assert.Equal(CharData[i], chars[i]); 297Assert.Equal(chars.Length, read); 300Assert.Equal(CharData[i], chars[i]); 316Assert.Equal(chars.Length, read); 319Assert.Equal(CharData[i], chars[i]); 335Assert.Equal(chars.Length, read); 338Assert.Equal(CharData[i], chars[i]);

HttpResponseStreamWriterTest.cs (42)

MultipartReaderTests.cs (5)

200Assert.Equal(2, section.Headers.Count); 226Assert.Equal(2, section.Headers.Count); 252Assert.Equal(2, section.Headers.Count); 261Assert.Equal(2, section.Headers.Count); 299Assert.Equal(2, section.Headers.Count);

PagedByteBufferTest.cs (17)

24Assert.Equal(input.Length, buffer.Length); 25Assert.Equal(input, ReadBufferedContent(buffer)); 42Assert.Equal(10, buffer.Length); 43Assert.Equal(Enumerable.Concat(input1, input2).ToArray(), ReadBufferedContent(buffer)); 58Assert.Equal(3, buffer.Length); 59Assert.Equal(new byte[] { 2, 3, 4 }, ReadBufferedContent(buffer)); 76Assert.Equal(PagedByteBuffer.PageSize, buffer.Length); 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()); 161Assert.Equal(0, buffer.Length); 185Assert.Equal(input, memoryStream.ToArray()); 210Assert.Equal(input, memoryStream.ToArray());

QueryHelpersTests.cs (4)

14Assert.Equal(2, collection.Count); 23Assert.Equal(2, collection.Count); 32Assert.Equal(2, collection.Count); 41Assert.Equal(2, collection.Count);

WebEncodersTests.cs (1)

57Assert.Equal(data[index], result[index]);

EditorConfig_Tests.cs (3)

864Assert.Equal(0, config.NamedSections.Length); 877Assert.Equal(0, config.NamedSections.Length); 993Assert.Equal(0, properties.Count);

CommandLineSwitches_Tests.cs (6)

264Assert.Equal(CommandLineSwitches.ParameterizedSwitch.Project, parameterizedSwitch); 272Assert.Equal(CommandLineSwitches.ParameterizedSwitch.Invalid, parameterizedSwitch); 794Assert.Equal(3, parameters.Length); 838Assert.Equal(2, parameters.Length); 879Assert.Equal(4, parameters.Length); 1072Assert.Equal(3, parameters.Length);

ProjectSchemaValidationHandler_Tests.cs (5)

55Assert.Equal(MSBuildApp.ExitType.InitializationError, MSBuildApp.Execute(@"c:\foo\msbuild.exe " + quotedProjectFilename + " /validate:\"" + msbuildTempXsdFilenames[0] + "\"")); 98Assert.Equal(MSBuildApp.ExitType.InitializationError, MSBuildApp.Execute(@"c:\foo\msbuild.exe " + quotedProjectFile + " /validate:\"" + invalidSchemaFile + "\"")); 158Assert.Equal(MSBuildApp.ExitType.InitializationError, MSBuildApp.Execute(@"c:\foo\msbuild.exe " + quotedProjectFile + " /validate:\"" + invalidSchemaFile + "\"")); 206Assert.Equal(MSBuildApp.ExitType.Success, MSBuildApp.Execute(@"c:\foo\msbuild.exe " + quotedProjectFile + " /validate:\"" + msbuildTempXsdFilenames[0] + "\"")); 259Assert.Equal(MSBuildApp.ExitType.Success, MSBuildApp.Execute(@"c:\foo\msbuild.exe " + quotedProjectFile + " /validate:\"" + msbuildTempXsdFilenames[0] + "\""));

XMake_Tests.cs (3)

933Assert.Equal(enableFeature ? new CultureInfo("ja") : CultureInfo.CurrentUICulture.GetConsoleFallbackUICulture(), thisThread.CurrentUICulture); 936Assert.Equal(65001, Console.OutputEncoding.CodePage); // UTF-8 enabled for correct rendering. 1175Assert.Equal(new CultureInfo("en"), Thread.CurrentThread.CurrentUICulture);

Construction\ConstructionEditing_Tests.cs (57)

41Assert.Equal(1, project.Count); 42Assert.Equal(0, target.Count); 43Assert.Equal(1, Helpers.Count(project.Children)); 44Assert.Equal(0, Helpers.Count(target.Children)); 46Assert.Equal(project, target.Parent); 68Assert.Equal(1, project.Count); 92Assert.Equal(2, project.Count); 94Assert.Equal(2, targets.Count); 95Assert.Equal(target1, targets[0]); 96Assert.Equal(target2, targets[1]); 425Assert.Equal(1, project.Count); 428Assert.Equal(itemGroup, children[0]); 452Assert.Equal(2, project.Count); 454Assert.Equal(2, children.Count); 455Assert.Equal(target, children[0]); 456Assert.Equal(itemGroup, children[1]); 529Assert.Equal(3, project.Count); 531Assert.Equal(3, children.Count); 532Assert.Equal(target1, children[0]); 533Assert.Equal(itemGroup, children[1]); 534Assert.Equal(target2, children[2]); 553Assert.Equal(1, project.Count); 574Assert.Equal(1, project.Count); 1183Assert.Equal(0, Helpers.Count(project.Children)); 1323Assert.Equal(1, Helpers.Count(project.Children)); 1324Assert.Equal(2, Helpers.Count(choose.Children)); 1344Assert.Equal(1, project.Count); 1347Assert.Equal(1, Helpers.Count(project.Children)); 1348Assert.Equal(target1, Helpers.GetFirst(project.Children)); 1368Assert.Equal(1, project.Count); 1371Assert.Equal(1, Helpers.Count(project.Children)); 1372Assert.Equal(target2, Helpers.GetFirst(project.Children)); 1387Assert.Equal(0, project.Count); 1403Assert.Equal(0, target1.Count); 1425Assert.Equal(2, project.Count); 1428Assert.Equal(2, Helpers.Count(project.Children)); 1429Assert.Equal(target2, Helpers.GetFirst(project.Children)); 1451Assert.Equal(2, project.Count); 1473Assert.Equal(1, project.Count); 1539Assert.Equal(3, Helpers.Count(project.Children)); 1540Assert.Equal(propertyGroup, Helpers.GetFirst(project.Children)); 1572Assert.Equal(5, Helpers.Count(project.Children)); 1573Assert.Equal(propertyGroup3, Helpers.GetLast(project.Children)); 1610Assert.Equal(itemGroup2, Helpers.GetLast(project.ItemGroups)); 1652Assert.Equal(itemGroup2, Helpers.GetLast(project.ItemGroups)); 1789Assert.Equal(item, Helpers.GetFirst(Helpers.GetFirst(project.ItemGroups).Items)); 2015Assert.Equal(itemDefinition, Helpers.GetFirst(Helpers.GetFirst(project.ItemDefinitionGroups).ItemDefinitions)); 2085Assert.Equal(last, Helpers.GetLast(Helpers.GetFirst(project.ItemDefinitionGroups).ItemDefinitions)); 2130Assert.Equal(property, Helpers.GetFirst(Helpers.GetFirst(project.PropertyGroups).Properties)); 2329Assert.Equal(1, Helpers.Count(project.Items)); 2333Assert.Equal(0, Helpers.Count(project.Items)); 2386Assert.Equal(0, group1.Count); 2409Assert.Equal(0, group1.Count); 2432Assert.Equal(0, group1.Count); 2455Assert.Equal(0, group1.Count); 2478Assert.Equal(0, group1.Count); 2502Assert.Equal(1, group1.Count);

Construction\ProjectChooseElement_Tests.cs (2)

200Assert.Equal(1, Helpers.Count(choose.WhenElements)); 225Assert.Equal(2, whens.Count);

Construction\ProjectFormatting_Tests.cs (2)

691Assert.Equal(byteOrderMark, EncodingUtilities.FileStartsWithPreamble(file)); 709Assert.Equal(byteOrderMark, EncodingUtilities.FileStartsWithPreamble(file));

Construction\ProjectImportElement_Tests.cs (1)

103Assert.Equal(2, imports.Count);

Construction\ProjectImportGroupElement_Tests.cs (7)

170Assert.Equal(0, Helpers.Count(importGroup.Imports)); 271Assert.Equal(2, importGroups[0].Count); 272Assert.Equal(2, imports.Count); 302Assert.Equal(2, importGroups.Count); 303Assert.Equal(2, importGroups[0].Count); 304Assert.Equal(1, importGroups[1].Count); 307Assert.Equal(3, imports.Count);

Construction\ProjectItemDefinitionElement_Tests.cs (3)

39Assert.Equal(0, Helpers.Count(itemDefinition.Metadata)); 64Assert.Equal(1, Helpers.Count(definition.Metadata)); 114Assert.Equal(3, metadata.Count);

Construction\ProjectItemDefinitionGroupElement_Tests.cs (5)

26Assert.Equal(0, Helpers.Count(project.Children)); 63Assert.Equal(0, Helpers.Count(itemDefinitionGroup.ItemDefinitions)); 88Assert.Equal(2, itemDefinitionGroups.Count); 90Assert.Equal(1, Helpers.Count(itemDefinitionGroups[0].ItemDefinitions)); 91Assert.Equal(2, Helpers.Count(itemDefinitionGroups[1].ItemDefinitions));

Construction\ProjectItemElement_Tests.cs (7)

82Assert.Equal(0, Helpers.Count(item.Metadata)); 99Assert.Equal(2, item.Metadata.Count); 103Assert.Equal(4, metadatum1.Location.Line); 104Assert.Equal(4, metadatum2.Location.Line); 105Assert.Equal(27, metadatum1.Location.Column); 106Assert.Equal(43, metadatum2.Location.Column); 416Assert.Equal(3, metadata.Count);

Construction\ProjectItemGroupElement_tests.cs (3)

26Assert.Equal(0, Helpers.Count(project.Children)); 46Assert.Equal(0, Helpers.Count(group.Items)); 70Assert.Equal(2, items.Count);

Construction\ProjectPropertyGroupElement_Tests.cs (3)

25Assert.Equal(0, Helpers.Count(project.Children)); 45Assert.Equal(0, Helpers.Count(group.Properties)); 68Assert.Equal(2, properties.Count);

Construction\ProjectRootElement_Tests.cs (18)

108Assert.Equal(0, Helpers.Count(project.Children)); 711Assert.Equal(Encoding.Unicode, project.Encoding); 717Assert.Equal(Encoding.UTF8, project.Encoding); 723Assert.Equal(Encoding.ASCII, project.Encoding); 832Assert.Equal(6, properties.Count); 890Assert.Equal(6, items.Count); 1054Assert.Equal(iterations, collection.LoadedProjects.Count); 1336Assert.Equal(initialPreserveFormatting, projectElement.PreserveFormatting); 1339Assert.Equal(expectedFormattingAfterReload, projectElement.PreserveFormatting); 1343Assert.Equal(initialPreserveFormatting, projectElement.PreserveFormatting); 1347Assert.Equal(expectedFormattingAfterReload, projectElement.PreserveFormatting); 1351Assert.Equal(initialPreserveFormatting, projectElement.PreserveFormatting); 1354Assert.Equal(expectedFormattingAfterReload, projectElement.PreserveFormatting); 1905Assert.Equal(version, projectElement.Version); 1914Assert.Equal(childrenCount, projectElement.AllChildren.Count()); 1951Assert.Equal(encoding, project.Encoding); // "Changing an unmodified project's encoding failed to update ProjectRootElement.Encoding." 1958Assert.Equal(encoding, reader.CurrentEncoding); 1969Assert.Equal(encoding.CodePage, project.Encoding.CodePage);

Construction\ProjectTargetElement_Tests.cs (2)

63Assert.Equal(0, Helpers.Count(target.Children)); 204Assert.Equal(2, tasks.Count);

Construction\ProjectTaskElement_Tests.cs (2)

38Assert.Equal(0, Helpers.Count(task.Outputs)); 142Assert.Equal(2, parameters.Count);

Construction\ProjectUsingTaskElement_Tests.cs (1)

424Assert.Equal(2, usingTask.Count);

Construction\SolutionFile_Tests.cs (9)

323Assert.Equal(3, solution.ProjectsInOrder.Count); 397Assert.Equal(5, solution.ProjectsInOrder.Count); 475Assert.Equal(4, solution.ProjectsInOrder.Count); 608Assert.Equal(3, solution.ProjectsInOrder.Count); 618Assert.Equal(2, solution.ProjectsInOrder[1].Dependencies.Count); 685Assert.Equal(7, solution.SolutionConfigurations.Count); 745Assert.Equal(6, solution.SolutionConfigurations.Count); 899Assert.Equal(6, csharpProject.ProjectConfigurations.Count); 919Assert.Equal(6, vcProject.ProjectConfigurations.Count);

Construction\UsingTaskParameterGroup_Tests.cs (2)

67Assert.Equal(0, parameterGroup.Count); 79Assert.Equal(2, parameterGroup.Count);

Construction\WhiteSpacePreservation_Tests.cs (1)

510Assert.Equal(crlfCount, nlCount);

Definition\DefinitionEditing_Tests.cs (9)

293Assert.Equal(2, items.Count); 1239Assert.Equal(2, Helpers.MakeList(itemElement.Metadata).Count); 1241Assert.Equal(2 + 15 /* built-in metadata */, item.MetadataCount); 1283Assert.Equal(2, Helpers.MakeList(itemGroupElement.Items).Count); 1312Assert.Equal(0, Helpers.Count(project.Items)); 1488Assert.Equal(1, Helpers.Count(project.Properties) - environmentPropertyCount); 1513Assert.Equal(1, Helpers.Count(project.Properties) - environmentPropertyCount); 1833Assert.Equal(0, Helpers.Count(project.Properties) - environmentPropertyCount); 2217Assert.Equal(2, items.Count);

Definition\ProjectCollection_Tests.cs (26)

45Assert.Equal(0, ProjectCollection.GlobalProjectCollection.Count); 96Assert.Equal(0, ProjectCollection.GlobalProjectCollection.Count); 302Assert.Equal(0, ProjectCollection.GlobalProjectCollection.Count); 306Assert.Equal(1, ProjectCollection.GlobalProjectCollection.Count); 399Assert.Equal(1, ProjectCollection.GlobalProjectCollection.Count); 430Assert.Equal(2, projects.Count); 431Assert.Equal(2, ProjectCollection.GlobalProjectCollection.Count); 593Assert.Equal(2, project1.GlobalProperties.Count); 621Assert.Equal(2, project1.GlobalProperties.Count); 649Assert.Equal(2, project1.GlobalProperties.Count); 652Assert.Equal(2, project2.GlobalProperties.Count); 700Assert.Equal(1, ProjectCollection.GlobalProjectCollection.Count); 704Assert.Equal(0, ProjectCollection.GlobalProjectCollection.Count); 792Assert.Equal(1, ProjectCollection.GlobalProjectCollection.Count); 798Assert.Equal(0, ProjectCollection.GlobalProjectCollection.Count); 957Assert.Equal(toolset, collection.GetToolset("x")); 962Assert.Equal(toolset, toolsets[0]); 980Assert.Equal(toolset1, collection.GetToolset("x")); 981Assert.Equal(toolset2, collection.GetToolset("y")); 984Assert.Equal(2, toolsets.Count); 1004Assert.Equal(toolset2, collection.GetToolset("x")); 1008Assert.Equal(toolset2, toolsets[0]); 1042Assert.Equal(1, Helpers.MakeList(collection.Toolsets).Count - initial); 1181Assert.Equal(expectedChange, e.Changed); 1489Assert.Equal(expectedChange, e.Changed); 1495Assert.Equal(raisedEvent, expectEventRaised);

Definition\ProjectItem_Tests.cs (26)

128Assert.Equal(2, itemMetadata.Count); 134Assert.Equal(itemMetadata[0], item.GetMetadata("m1")); 135Assert.Equal(itemMetadata[1], item.GetMetadata("m2")); 418Assert.Equal(3, items.Count); 494Assert.Equal(9, items.Count); 522Assert.Equal(7, items.Count); 1532Assert.Equal(2, itemMetadata.Count); 1881Assert.Equal(0, Helpers.Count(item.Xml.Metadata)); 1899Assert.Equal(0, item.DirectMetadataCount); 1900Assert.Equal(0, Helpers.Count(item.DirectMetadata)); 1903Assert.Equal(0, item.Xml.Count); 2220Assert.Equal(4, items.Count); 2228Assert.Equal(2, project.Xml.AllChildren.OfType<ProjectItemElement>().Count()); 2234Assert.Equal(2, metadata.Count); 2247Assert.Equal(2, metadataElements.Count); 2280Assert.Equal(4, items.Count); 2288Assert.Equal(2, project.Xml.AllChildren.OfType<ProjectItemElement>().Count()); 2331Assert.Equal(2, items.Count); 2342Assert.Equal(2, items.Count); 2354Assert.Equal(2, items.Count); 2951Assert.Equal(2, items.Count); 2972Assert.Equal(2, items.Count); 3026Assert.Equal(3, items.Count); 3408Assert.Equal(4, items.Count); 3450Assert.Equal(4, items.Count); 3499Assert.Equal(3, items.Count);

Instance\ProjectInstance_Tests.cs (8)

67Assert.Equal(3, items.Count); 142Assert.Equal(3, metadataOut.Count); 309Assert.Equal(2, Helpers.MakeList(projectInstance.GetItems("i")).Count); 334Assert.Equal(4, Helpers.MakeList(first.GetItems("i")).Count); 335Assert.Equal(3, Helpers.MakeList(second.GetItems("i")).Count); 444Assert.Equal(projAInstanceItem.MetadataCount, projAInstanceItem.MetadataNames.Count); 486Assert.Equal(projAInstanceItem.MetadataCount, projAInstanceItem.MetadataNames.Count); 521Assert.Equal(projAInstanceItem.MetadataCount, projAInstanceItem.MetadataNames.Count);

Instance\ProjectItemInstance_Tests.cs (18)

Instance\ProjectTaskInstance_Tests.cs (1)

33Assert.Equal(2, parameters.Count);

ObjectModelRemoting\Helpers\ViewValidation.construction.cs (24)

ObjectModelRemoting\Helpers\ViewValidation.cs (12)

43Assert.Equal((object)this.View, (object)other.View); 44Assert.Equal((object)this.Real, (object)other.Real); 50Assert.Equal(current, getter(this.View)); 55Assert.Equal(!current, getter(this.View)); 56Assert.Equal(!current, getter(this.Real)); 61Assert.Equal(current, getter(this.View)); 62Assert.Equal(current, getter(this.Real)); 65Assert.Equal(finalValue, getter(this.View)); 66Assert.Equal(finalValue, getter(this.Real)); 308Assert.Equal(realXmlList.Count, viewXmlList.Count); 325Assert.Equal(realCollection.Count, viewCollection.Count); 338Assert.Equal(realXmlList.Count, viewXmlList.Count);

ObjectModelRemoting\Helpers\ViewValidation.evaluation.cs (23)

ObjectModelRemoting\LinkedConstructionModify_Tests.cs (45)

198Assert.Equal(1, newTarget1.View.Tasks.Count); 226Assert.Equal(0, newTask.View.Outputs.Count); 249Assert.Equal(8, newTask.View.Outputs.Count); 259Assert.Equal(0, newTask.View.Parameters.Count); 269Assert.Equal(5, newTask.View.Parameters.Count); 278Assert.Equal(3, newTask.View.Parameters.Count); 292Assert.Equal(0, newTask.View.Parameters.Count); 297Assert.Equal(7, newTask.View.Outputs.Count); 301Assert.Equal(6, newTask.View.Outputs.Count); 304Assert.Equal(5, newTask.View.Outputs.Count); 306Assert.Equal(4, newTask.View.Outputs.Count); 385Assert.Equal(2, choose.View.WhenElements.Count); 398Assert.Equal(1, choose.View.WhenElements.Count); 419Assert.Equal(2, when.View.ChooseElements.Count); 423Assert.Equal(2, when.View.ItemGroups.Count); 427Assert.Equal(2, when.View.PropertyGroups.Count); 432Assert.Equal(1, when.View.ChooseElements.Count); 437Assert.Equal(1, when.View.ItemGroups.Count); 440Assert.Equal(1, when.View.PropertyGroups.Count); 457Assert.Equal(2, otherwise.View.ChooseElements.Count); 461Assert.Equal(2, otherwise.View.ItemGroups.Count); 465Assert.Equal(2, otherwise.View.PropertyGroups.Count); 470Assert.Equal(1, otherwise.View.ChooseElements.Count); 475Assert.Equal(1, otherwise.View.ItemGroups.Count); 478Assert.Equal(1, otherwise.View.PropertyGroups.Count); 545Assert.Equal(2, taskParamGroup.View.Parameters.Count); 547Assert.Equal(4, taskParamGroup.View.Parameters.Count); 603Assert.Equal(2, importGroup.View.Imports.Count); 617Assert.Equal(2, itemDef.View.Metadata.Count); 619Assert.Equal(4, itemDef.View.Metadata.Count); 622Assert.Equal(6, itemDef.View.Metadata.Count); 634Assert.Equal(2, itemDefGrp.View.ItemDefinitions.Count); 673Assert.Equal(2, item.View.Metadata.Count); 675Assert.Equal(4, item.View.Metadata.Count); 677Assert.Equal(6, item.View.Metadata.Count); 698Assert.Equal(2, itemGrp.View.Items.Count); 706Assert.Equal(4, itemGrp.View.Items.Count); 735Assert.Equal(2, propGrp.View.Properties.Count); 736Assert.Equal(2, propGrp.View.PropertiesReversed.Count); 739Assert.Equal(4, propGrp.View.Properties.Count); 740Assert.Equal(4, propGrp.View.PropertiesReversed.Count); 743Assert.Equal(6, propGrp.View.Properties.Count); 744Assert.Equal(6, propGrp.View.PropertiesReversed.Count); 749Assert.Equal(6, propGrp.View.Properties.Count); 750Assert.Equal(6, propGrp.View.PropertiesReversed.Count);

ObjectModelRemoting\LinkedEvaluationModify_Tests.cs (1)

71Assert.Equal(lwtBefore, lwtAfter);

ObjectModelRemoting\LinkedProjectCollection_Tests.cs (25)

AssemblyNameEx_Tests.cs (19)

132Assert.Equal(resultBaseline, result); 167Assert.Equal(0, result); 172Assert.Equal(a1.CompareBaseNameTo(a2), result); 183Assert.Equal(-1, result); 187Assert.Equal(a1.Version.CompareTo(a2.Version), result); 195Assert.Equal(resultBaseline, result); 220Assert.Equal(0, String.Compare(AssemblyNameExtension.EscapeDisplayNameCharacters(displayName), @"Hello\,\""Don\'t\"" eat the \\CAT", StringComparison.OrdinalIgnoreCase)); 256Assert.Equal(resultBaseline, result); 297Assert.Equal(resultBaseline, result); 317Assert.Equal(0, result); 631Assert.Equal(0, AssemblyNameComparer.Comparer.Compare(a, b)); 635Assert.Equal(0, AssemblyNameComparer.ComparerConsiderRetargetable.Compare(a, c)); 654Assert.Equal(-1, reverseComparer.Compare(x, y)); 655Assert.Equal(1, reverseComparer.Compare(y, x)); 656Assert.Equal(0, reverseComparer.Compare(x, z)); 657Assert.Equal(0, reverseComparer.Compare(null, null)); 658Assert.Equal(-1, reverseComparer.Compare(x, null)); 659Assert.Equal(1, reverseComparer.Compare(null, y)); 660Assert.Equal(-1, reverseComparer.Compare(a, x));

BackEnd\AssemblyTaskFactory_Tests.cs (1)

217Assert.Equal(comparisonInfo.Length, propertyInfos.Length);

BackEnd\BatchingEngine_Tests.cs (3)

62Assert.Equal(5, buckets.Count); 115Assert.Equal(1, invalidProjectFileExceptions); 150Assert.Equal(2, buckets.Count);

BackEnd\BinaryTranslator_Tests.cs (27)

BackEnd\BuildEventArgTransportSink_Tests.cs (2)

32Assert.Equal(0, string.Compare(sink.Name, name, StringComparison.OrdinalIgnoreCase)); 74Assert.Equal(messageEventFromPacket, messageEvent);

BackEnd\BuildManager_Tests.cs (81)

BackEnd\BuildRequest_Tests.cs (13)

45Assert.Equal(0, request.ConfigurationId); 48Assert.Equal(1, request2.ConfigurationId); 51Assert.Equal(-1, request3.ConfigurationId); 84Assert.Equal(NodePacketType.BuildRequest, request.Type); 93Assert.Equal(1, request.ConfigurationId); 120Assert.Equal(NodePacketType.BuildRequest, request.Type); 127Assert.Equal(request.BuildEventContext, deserializedRequest.BuildEventContext); 128Assert.Equal(request.ConfigurationId, deserializedRequest.ConfigurationId); 129Assert.Equal(request.GlobalRequestId, deserializedRequest.GlobalRequestId); 130Assert.Equal(request.IsConfigurationResolved, deserializedRequest.IsConfigurationResolved); 131Assert.Equal(request.NodeRequestId, deserializedRequest.NodeRequestId); 132Assert.Equal(request.ParentBuildEventContext, deserializedRequest.ParentBuildEventContext); 133Assert.Equal(request.Targets.Count, deserializedRequest.Targets.Count);

BackEnd\BuildRequestConfiguration_Tests.cs (16)

123Assert.Equal(-1, config1.ConfigurationId); 127Assert.Equal(1, config2.ConfigurationId); 131Assert.Equal(0, config3.ConfigurationId); 149Assert.Equal(0, config1.ConfigurationId); 151Assert.Equal(1, config1.ConfigurationId); 176Assert.Equal(props.Count, Helpers.MakeList((IEnumerable<ProjectPropertyInstance>)(config1.GlobalProperties)).Count); 198Assert.Equal(NodePacketType.BuildRequestConfiguration, config1.Type); 210Assert.Equal(config1.GetHashCode(), config2.GetHashCode()); 220Assert.Equal(config1, config1); 222Assert.Equal(config1, config2); 236Assert.Equal(config1, config2); 250Assert.Equal(NodePacketType.BuildRequestConfiguration, config.Type); 257Assert.Equal(config, deserializedConfig); 386Assert.Equal(fooCount, lookup.GetItems("Foo").Count); 404Assert.Equal(fooCount, instance.ItemsToBuildWith["Foo"].Count); 412Assert.Equal(fooCount, lookup.GetItems("Foo").Count);

BackEnd\BuildRequestConfigurationResponse_Tests.cs (7)

50Assert.Equal(1, response.NodeConfigurationId); 60Assert.Equal(1, response.GlobalConfigurationId); 70Assert.Equal(2, response.ResultsNodeId); 80Assert.Equal(NodePacketType.BuildRequestConfigurationResponse, response.Type); 86Assert.Equal(response.NodeConfigurationId, deserializedResponse.NodeConfigurationId); 87Assert.Equal(response.GlobalConfigurationId, deserializedResponse.GlobalConfigurationId); 88Assert.Equal(response.ResultsNodeId, deserializedResponse.ResultsNodeId);

BackEnd\BuildRequestEngine_Tests.cs (12)

BackEnd\BuildRequestEntry_Tests.cs (39)

BackEnd\BuildResult_Tests.cs (33)

51Assert.Equal(result1.SubmissionId, result2.SubmissionId); 52Assert.Equal(result1.ConfigurationId, result2.ConfigurationId); 53Assert.Equal(result1.GlobalRequestId, result2.GlobalRequestId); 54Assert.Equal(result1.ParentGlobalRequestId, result2.ParentGlobalRequestId); 55Assert.Equal(result1.NodeRequestId, result2.NodeRequestId); 56Assert.Equal(result1.CircularDependency, result2.CircularDependency); 57Assert.Equal(result1.ResultsByTarget["foo"], result2.ResultsByTarget["foo"]); 58Assert.Equal(result1.OverallResult, result2.OverallResult); 74Assert.Equal(-1, result.ConfigurationId); 78Assert.Equal(1, result2.ConfigurationId); 90Assert.Equal(e, result.Exception); 98Assert.Equal(BuildResultCode.Success, result.OverallResult); 101Assert.Equal(BuildResultCode.Success, result.OverallResult); 104Assert.Equal(BuildResultCode.Success, result.OverallResult); 107Assert.Equal(BuildResultCode.Failure, result.OverallResult); 113Assert.Equal(BuildResultCode.Failure, result2.OverallResult); 121Assert.Equal(NodePacketType.BuildResult, ((INodePacket)result).Type); 132Assert.Equal(TargetResultCode.Success, result["foo"].ResultCode); 133Assert.Equal(TargetResultCode.Failure, result["bar"].ResultCode); 202Assert.Equal(TargetResultCode.Success, result["foo"].ResultCode); 203Assert.Equal(TargetResultCode.Failure, result["bar"].ResultCode); 211Assert.Equal(TargetResultCode.Success, result["foo"].ResultCode); 212Assert.Equal(TargetResultCode.Failure, result["bar"].ResultCode); 213Assert.Equal(TargetResultCode.Success, result["xor"].ResultCode); 266Assert.Equal(0, countFound); 279Assert.Equal(1, countFound); 300Assert.Equal(2, countFound); 321Assert.Equal(NodePacketType.BuildResult, (result as INodePacket).Type); 327Assert.Equal(result.ConfigurationId, deserializedResult.ConfigurationId); 331Assert.Equal(result.GlobalRequestId, deserializedResult.GlobalRequestId); 333Assert.Equal(result.NodeRequestId, deserializedResult.NodeRequestId); 334Assert.Equal(result["alpha"].ResultCode, deserializedResult["alpha"].ResultCode); 337Assert.Equal(result["omega"].ResultCode, deserializedResult["omega"].ResultCode);

BackEnd\CentralForwardingLogger_Tests.cs (6)

27Assert.Equal(0, centralLogger.NodeId); 29Assert.Equal(4, centralLogger.NodeId); 37Assert.Equal(LoggerVerbosity.Quiet, centralLogger.Verbosity); // "Expected default to be Quiet" 39Assert.Equal(LoggerVerbosity.Detailed, centralLogger.Verbosity); // "Expected default to be Detailed" 45Assert.Equal(centralLogger.BuildEventRedirector, eventRedirector); // "Expected the BuildEventRedirector to match the passed in eventRedirector" 180Assert.Equal(_expectedEvent, buildEvent); // "Expected the forwarded event to match the expected event"

BackEnd\ConfigCache_Tests.cs (1)

132Assert.Equal(1, ((ConfigCache)obj).GetSmallestConfigId());

BackEnd\ConfigurationMetadata_Tests.cs (1)

95Assert.Equal(metadata1.GetHashCode(), metadata2.GetHashCode());

BackEnd\EventRedirectorToSink_Tests.cs (1)

69Assert.Equal(messageEvent, messageEventFromPacket); // "Expected messageEvent to be forwarded to match actually forwarded event"

BackEnd\EventSourceSink_Tests.cs (10)

31Assert.Equal(0, string.Compare(sink.Name, name, StringComparison.OrdinalIgnoreCase)); 145Assert.Equal(handlerHelper.RaisedEvent, RaiseEventHelper.ProjectStarted); 146Assert.Equal(handlerHelper.RaisedAnyEvent, RaiseEventHelper.ProjectStarted); 147Assert.Equal(handlerHelper.RaisedStatusEvent, RaiseEventHelper.ProjectStarted); 269Assert.Equal(e, exceptionToRaise); // "Expected Logger exception to be raised in event handler and re-thrown by event source" 275Assert.Equal(e, exceptionToRaise); // "Expected Logger exception to be raised in event handler and re-thrown by event source" 299Assert.Equal(testHandlers.RaisedEvent, buildEventToRaise); // "Expected buildevent in handler to match buildevent raised on event source" 300Assert.Equal(testHandlers.RaisedEvent, testHandlers.RaisedAnyEvent); // "Expected RaisedEvent and RaisedAnyEvent to match" 304Assert.Equal(testHandlers.RaisedAnyEvent, buildEventToRaise); // "Expected buildEvent in any event handler to match buildevent raised on event source" 309Assert.Equal(testHandlers.RaisedStatusEvent, buildEventToRaise); // "Expected buildevent in handler to match buildevent raised on event source"

BackEnd\FullyQualifiedBuildRequest_Tests.cs (1)

51Assert.Equal(request.Config, config);

BackEnd\IntrinsicTask_Tests.cs (19)

44Assert.Equal(2, properties.Count); 294Assert.Equal(2, group.Count); 355Assert.Equal(2, group.Count); 376Assert.Equal(2, group.Count); 404Assert.Equal(2, group.Count); 956Assert.Equal(2, properties.Count); 1044Assert.Equal(2, i2Group.Count); 1131Assert.Equal(2, properties.Count); 2128Assert.Equal(3, i0Group.Count); 2252Assert.Equal(4, linkGroup.Count); 2353Assert.Equal(3, p.ItemsToBuildWith["i0"].Count); 2355Assert.Equal(2, p.ItemsToBuildWith.ItemTypes.Count); 2358Assert.Equal(2, p.ItemsToBuildWith["i0"].Count); 2360Assert.Equal(2, p.ItemsToBuildWith.ItemTypes.Count); 2427Assert.Equal(2, p.ItemsToBuildWith["i0"].Count); 2428Assert.Equal(2, p.ItemsToBuildWith["i1"].Count); 2429Assert.Equal(2, p.ItemsToBuildWith.ItemTypes.Count); 3096Assert.Equal(4, i0Group.Count); 3524Assert.Equal(2, instance.Items.Count);

BackEnd\LoggingService_Tests.cs (71)

BackEnd\LoggingServiceFactory_Tests.cs (2)

25Assert.Equal(LoggerMode.Synchronous, loggingService.LoggingMode); // "Expected to create a Synchronous LoggingService" 36Assert.Equal(LoggerMode.Asynchronous, loggingService.LoggingMode); // "Expected to create an Asynchronous LoggingService"

BackEnd\LoggingServicesLogMethod_Tests.cs (2)

1298Assert.Equal(expectedEventArgs.Properties.OrderBy(kvp => kvp.Key, StringComparer.Ordinal), actualEventArgs.Properties.OrderBy(kvp => kvp.Key, StringComparer.OrdinalIgnoreCase)); 1299Assert.Equal(expectedEventArgs.BuildEventContext, actualEventArgs.BuildEventContext);

BackEnd\Lookup_Tests.cs (14)

113Assert.Equal(2, lookup.GetItems("i1").Count); 125Assert.Equal(2, lookup.GetItems("i1").Count); 137Assert.Equal(2, lookup.GetItems("i1").Count); 142Assert.Equal(2, table1["i1"].Count); 175Assert.Equal(3, group.Count); 178Assert.Equal(2, group.Where(item => item.EvaluatedInclude == "a1").Count()); 187Assert.Equal(3, group.Count); 190Assert.Equal(2, group.Where(item => item.EvaluatedInclude == "a1").Count()); 227Assert.Equal(5, group.Count); 230Assert.Equal(4, group.Where(item => item.EvaluatedInclude == "a1").Count()); 240Assert.Equal(5, group.Count); 243Assert.Equal(4, group.Where(item => item.EvaluatedInclude == "a1").Count()); 1215Assert.Equal(property, lookup.GetProperty("p1")); 1219Assert.Equal(property, lookup.GetProperty("p1"));

BackEnd\MSBuild_Tests.cs (21)

BackEnd\NodeEndpointInProc_Tests.cs (12)

266Assert.Equal(LinkStatus.Active, _linkStatusTable[endpoints.NodeEndpoint].status); 267Assert.Equal(LinkStatus.Active, _linkStatusTable[endpoints.ManagerEndpoint].status); 302Assert.Equal(_host.DataReceivedContext.packet, managerPacket); 303Assert.Equal(_host.DataReceivedContext.thread.ManagedThreadId, Thread.CurrentThread.ManagedThreadId); 308Assert.Equal(_host.DataReceivedContext.packet, nodePacket); 309Assert.Equal(_host.DataReceivedContext.thread.ManagedThreadId, Thread.CurrentThread.ManagedThreadId); 335Assert.Equal(_host.DataReceivedContext.packet, managerPacket); 345Assert.Equal(_host.DataReceivedContext.packet, nodePacket); 365Assert.Equal(LinkStatus.Inactive, endpoint.LinkStatus); // "Expected LinkStatus to be Inactive" 370Assert.Equal(LinkStatus.Active, endpoint.LinkStatus); // "Expected LinkStatus to be Active" 416Assert.Equal(LinkStatus.Inactive, _linkStatusTable[endpoints.NodeEndpoint].status); 417Assert.Equal(LinkStatus.Inactive, _linkStatusTable[endpoints.ManagerEndpoint].status);

BackEnd\NodePackets_Tests.cs (2)

351Assert.Equal(logEventType, packet.EventType); 352Assert.Equal(NodePacketType.LogMessage, packet.Type);

BackEnd\OnError_Tests.cs (20)

BackEnd\RequestBuilder_Tests.cs (18)

97Assert.Equal(BuildRequestEntryState.Complete, entry.State); 98Assert.Equal(entry, _buildRequestCompleted_Entry); 99Assert.Equal(BuildResultCode.Success, _buildRequestCompleted_Entry.Result.OverallResult); 130Assert.Equal(BuildRequestEntryState.Complete, entry.State); 131Assert.Equal(entry, _buildRequestCompleted_Entry); 132Assert.Equal(BuildResultCode.Failure, _buildRequestCompleted_Entry.Result.OverallResult); 160Assert.Equal(_newBuildRequests_Entry, entry); 169Assert.Equal(BuildRequestEntryState.Complete, entry.State); 170Assert.Equal(entry, _buildRequestCompleted_Entry); 171Assert.Equal(BuildResultCode.Success, _buildRequestCompleted_Entry.Result.OverallResult); 199Assert.Equal(_newBuildRequests_Entry, entry); 211Assert.Equal(BuildRequestEntryState.Complete, entry.State); 212Assert.Equal(entry, _buildRequestCompleted_Entry); 213Assert.Equal(BuildResultCode.Failure, _buildRequestCompleted_Entry.Result.OverallResult); 233Assert.Equal(BuildRequestEntryState.Complete, entry.State); 234Assert.Equal(entry, _buildRequestCompleted_Entry); 235Assert.Equal(BuildResultCode.Failure, _buildRequestCompleted_Entry.Result.OverallResult); 236Assert.Equal(typeof(InvalidProjectFileException), _buildRequestCompleted_Entry.Result.Exception.GetType());

BackEnd\ResultsCache_Tests.cs (7)

188Assert.Equal(ResultsCacheResponseType.Satisfied, response.Type); 192Assert.Equal(BuildResultCode.Success, response.Results.OverallResult); 256Assert.Equal(ResultsCacheResponseType.Satisfied, cacheResponseForRequestWithNoBuildDataFlags.Type); 259Assert.Equal(ResultsCacheResponseType.NotSatisfied, cachedResponseForProjectState.Type); 261Assert.Equal(ResultsCacheResponseType.Satisfied, cacheResponseForNoBuildDataFlags2.Type); 332Assert.Equal(ResultsCacheResponseType.Satisfied, cachedResponseWithSubsetFlag1.Type); 337Assert.Equal(ResultsCacheResponseType.Satisfied, cachedResponseWithSubsetFlag2.Type);

BackEnd\Scheduler_Tests.cs (76)

BackEnd\TargetBuilder_Tests.cs (15)

BackEnd\TargetEntry_Tests.cs (65)

BackEnd\TargetResult_Tests.cs (8)

31Assert.Equal(TargetResultCode.Failure, result.ResultCode); 44Assert.Equal(TargetResultCode.Failure, result.ResultCode); 68Assert.Equal(typeof(ArgumentException), result.Exception.GetType()); 69Assert.Equal(TargetResultCode.Failure, result.ResultCode); 82Assert.Equal(TargetResultCode.Failure, result.ResultCode); 103Assert.Equal(result.ResultCode, deserializedResult.ResultCode); 106Assert.Equal(result.OriginalBuildEventContext, deserializedResult.OriginalBuildEventContext); 123Assert.Equal(result.ResultCode, deserializedResult.ResultCode);

BackEnd\TargetUpToDateChecker_Tests.cs (5)

164Assert.Equal(DependencyAnalysisResult.IncrementalBuild, result); // "Should only build partially." 207Assert.Equal(DependencyAnalysisResult.IncrementalBuild, result); // "Should only build partially." 264Assert.Equal(DependencyAnalysisResult.IncrementalBuild, result); // "Should only build partially." 905Assert.Equal(expectedAnyOutOfDate, TargetUpToDateChecker.IsAnyOutOfDate(out detail, Directory.GetCurrentDirectory(), inputs, outputs)); 1047Assert.Equal(expectedOutOfDate,

BackEnd\TaskExecutionHost_Tests.cs (14)

342Assert.Equal(1, ((int[])_parametersSetOnTask["IntArrayParam"])[0]); 343Assert.Equal(0, ((int[])_parametersSetOnTask["IntArrayParam"])[1]); 1315Assert.Equal(0, TaskItemComparer.Instance.Compare(value, new TaskItem(_bucket.Lookup.GetItems("output").First()))); 1326Assert.Equal(values.Length, _bucket.Lookup.GetItems("output").Count); 1341Assert.Equal(values.Length, _bucket.Lookup.GetItems("output").Count); 1344Assert.Equal(0, TaskItemComparer.Instance.Compare(values[i], new TaskItem(_bucket.Lookup.GetItems("output").ElementAt(i)))); 1368Assert.Equal(expectedValue, _parametersSetOnTask[parameterName]); 1382Assert.Equal(BuiltInMetadata.MetadataCount, actualItem.MetadataCount); 1395Assert.Equal(0, TaskItemComparer.Instance.Compare(expectedItem, actualItem)); 1422Assert.Equal(expectedItems.Length, actualItems.Length); 1426Assert.Equal(0, TaskItemComparer.Instance.Compare(expectedItems[i], actualItems[i])); 1440Assert.Equal(expectedItems.Length, actualItems.Length); 1460Assert.Equal(expectedArray.Length, actualArray.Length); 1463Assert.Equal(expectedArray.GetValue(i), actualArray.GetValue(i));

BackEnd\TaskHost_Tests.cs (11)

202Assert.Equal(0, _customLogger.LastError.LineNumber); // "Expected line number to be 0" 214Assert.Equal(0, _customLogger.LastWarning.LineNumber); // "Expected line number to be 0" 219Assert.Equal(1, _customLogger.NumberOfWarning); // "Expected one Warning Event at this point" 220Assert.Equal(1, _customLogger.NumberOfError); // "Expected one Warning Event at this point" 227Assert.Equal(0, _customLogger.LastWarning.LineNumber); // "Expected line number to be 0" 285Assert.Equal(0, _customLogger.LastError.LineNumber); // "Expected line number to be 0" 299Assert.Equal(0, _customLogger.LastWarning.LineNumber); // "Expected line number to be 0" 313Assert.Equal(MessageImportance.High, _customLogger.LastMessage.Importance); // "Expected Message importance to be high" 477Assert.Equal(1, _customLogger.NumberOfWarning); // "Expected there to be only one warning" 497Assert.Equal(1, _customLogger.NumberOfWarning); // "Expected there to be only one warning" 518Assert.Equal(1, _customLogger.NumberOfWarning); // "Expected there to be only one warning"

BackEnd\TaskHostConfiguration_Tests.cs (10)

377Assert.Equal(expectedGlobalProperties, deserializedConfig.GlobalProperties); 473Assert.Equal(config.TaskParameters.Count, deserializedConfig.TaskParameters.Count); 476Assert.Equal(config.GlobalProperties.Count, deserializedConfig.GlobalProperties.Count); 524Assert.Equal(config.TaskParameters.Count, deserializedConfig.TaskParameters.Count); 525Assert.Equal(config.TaskParameters["Text"].WrappedParameter, deserializedConfig.TaskParameters["Text"].WrappedParameter); 526Assert.Equal(config.TaskParameters["BoolValue"].WrappedParameter, deserializedConfig.TaskParameters["BoolValue"].WrappedParameter); 573Assert.Equal(config.TaskParameters.Count, deserializedConfig.TaskParameters.Count); 621Assert.Equal(config.TaskParameters.Count, deserializedConfig.TaskParameters.Count); 776Assert.Equal(metadataFromX.Count, metadataFromY.Count); 786Assert.Equal(metadataFromX[metadataName], metadataFromY[metadataName]);

BackEnd\TaskHostTaskComplete_Tests.cs (11)

BackEnd\TaskRegistry_Tests.cs (30)

113Assert.Equal(1, registeredTaskCount); // "Expected one registered tasks in TaskRegistry.AllTaskDeclarations!" 124Assert.Equal(taskAssemblyLoadInfo, AssemblyLoadInfo.Create(assemblyName, assemblyFile)); // "Task record was not properly registered by TaskRegistry.RegisterTask!" 153Assert.Equal(3, registeredTaskCount); // "Expected three registered tasks in TaskRegistry.AllTaskDeclarations!" 166Assert.Equal(taskAssemblyLoadInfo, AssemblyLoadInfo.Create(assemblyName, assemblyFile == null ? null : Path.GetFullPath(assemblyFile))); // "Task record was not properly registered by TaskRegistry.RegisterTask!" 195Assert.Equal(3, registeredTaskCount); // "Expected three registered tasks in TaskRegistry.AllTaskDeclarations!" 198Assert.Equal(2, registry.TaskRegistrations.Count); // "Expected only two buckets since two of three tasks have the same name!" 207Assert.Equal(singletonAssemblyLoadInfo, AssemblyLoadInfo.Create(assemblyName, assemblyFile)); // "Task record was not properly registered by TaskRegistry.RegisterTask!" 212Assert.Equal(2, duplicateBucket.Count); // "Expected two Records registered under this TaskName!" 260Assert.Equal(3, registeredTaskCount); // "Expected three registered tasks in TaskRegistry.AllTaskDeclarations!" 271Assert.Equal(taskAssemblyLoadInfo, AssemblyLoadInfo.Create(assemblyName, assemblyFile == null ? null : Path.GetFullPath(assemblyFile))); // "Task record was not properly registered by TaskRegistry.RegisterTask!" 299Assert.Equal(2, registry.TaskRegistrations.Count); // "Expected only two buckets since two of three tasks have the same name!" 301Assert.Equal(3, registeredTaskCount); // "Expected three registered tasks in TaskRegistry.TaskRegistrations!" 337Assert.Equal(3, registry.TaskRegistrations.Count); // "Should have three buckets, since two of the tasks are the same." 339Assert.Equal(4, registeredTaskCount); 1128Assert.Equal(3, registeredTaskCount); // "Expected three registered tasks in TaskRegistry.TaskRegistrations!" 1150Assert.Equal(taskAssemblyLoadInfo, AssemblyLoadInfo.Create(expandedAssemblyName, expandedAssemblyFile == null ? null : Path.GetFullPath(expandedAssemblyFile))); // "Task record was not properly registered by TaskRegistry.RegisterTask!" 1184Assert.Equal(2, registeredTaskCount); // "Expected two registered tasks in TaskRegistry.TaskRegistrations!" 1203Assert.Equal(taskAssemblyLoadInfo, AssemblyLoadInfo.Create(expandedAssemblyName, Path.GetFullPath(expandedAssemblyFile))); // "Task record was not properly registered by TaskRegistry.RegisterTask!" 1222Assert.Equal(1, registeredTaskCount); // "Expected three registered tasks in TaskRegistry.TaskRegistrations!" 1275Assert.Equal(1, registeredTaskCount); // "Expected three registered tasks in TaskRegistry.TaskRegistrations!" 1311Assert.Equal(1, registeredTaskCount); // "Expected three registered tasks in TaskRegistry.TaskRegistrations!" 1322Assert.Equal(2, inlineTaskRecord.UsingTaskParameters.Count); 1329Assert.Equal(typeof(System.String), parameterInfo.PropertyType); 1336Assert.Equal(typeof(Int32), parameterInfo.PropertyType); 1684Assert.Equal(1, registeredTaskCount); // "Expected three registered tasks in TaskRegistry.TaskRegistrations!" 1695Assert.Equal(2, inlineTaskRecord.UsingTaskParameters.Count); 1704Assert.Equal(parameterInfo.Output, bool.Parse(expandedOutput)); 1705Assert.Equal(parameterInfo.Required, bool.Parse(expandedRequired)); 1706Assert.Equal( 2032Assert.Equal(shouldBeRetrievedFromCache, retrievedFromCache);

BinaryLogger_Tests.cs (1)

302Assert.Equal(embedFiles1, embedFiles2);

BuildEventArgsSerialization_Tests.cs (5)

47Assert.Equal(BinaryLogRecordKind.ProjectImportArchive, (BinaryLogRecordKind)binaryReader.Read7BitEncodedInt()); 48Assert.Equal(bytes.Length, binaryReader.Read7BitEncodedInt()); 49Assert.Equal(bytes, binaryReader.ReadBytes(bytes.Length)); 1176Assert.Equal(length, memoryStream.Position); 1179Assert.Equal(typeof(T), deserializedArgs.GetType());

Collections\MSBuildNameIgnoreCaseComparer_Tests.cs (6)

Collections\MultiDictionary_Tests.cs (17)

Collections\OMcollections_tests.cs (10)

47Assert.Equal(2, properties.Count); 84Assert.Equal(properties, deserializedProperties); 99Assert.Equal(properties, deserializedProperties); 150Assert.Equal(item1, items["i"].First()); 165Assert.Equal(item1, list[0]); 166Assert.Equal(item2, list[1]); 167Assert.Equal(item3, list[2]); 231Assert.Equal(2, dictionary.Count); 280Assert.Equal(3, convertingCollection.Count); 285Assert.Equal(convertedValues[value.Key], value.Value);

Construction\ElementLocation_Tests.cs (25)

43Assert.Equal(65536, location.Line); 44Assert.Equal(0, location.Column); 56Assert.Equal(0, location.Line); 57Assert.Equal(65536, location.Column); 69Assert.Equal(65536, location.Line); 70Assert.Equal(65537, location.Column); 113Assert.Equal(70012, ex.ColumnNumber); 114Assert.Equal(2, ex.LineNumber); 148Assert.Equal(70002, ex.LineNumber); 149Assert.Equal(2, ex.ColumnNumber); 170Assert.Equal(location.Line, deserializedLocation.Line); 171Assert.Equal(location.Column, deserializedLocation.Column); 188Assert.Equal(location.Line, deserializedLocation.Line); 189Assert.Equal(location.Column, deserializedLocation.Column); 201Assert.Equal(65535, location.Line); 202Assert.Equal(65534, location.Column); 246Assert.Equal(65535, location.Line); 247Assert.Equal(0, location.Column); 259Assert.Equal(0, location.Line); 260Assert.Equal(65535, location.Column); 272Assert.Equal(65535, location.Line); 273Assert.Equal(65534, location.Column); 290Assert.Equal(location.Line, deserializedLocation.Line); 291Assert.Equal(location.Column, deserializedLocation.Column); 426Assert.Equal(readOnly, doc.IsReadOnly);

Construction\ProjectRootElement_Tests.cs (2)

82Assert.Equal(2, children[0].ChildNodes.Count); 114Assert.Equal(2, children[0].ChildNodes.Count);

Construction\SolutionProjectGenerator_Tests.cs (5)

2067Assert.Equal(BuildResultCode.Failure, result.OverallResult); 2155Assert.Equal(BuildResultCode.Failure, result.OverallResult); 2411Assert.Equal(12, instances[0].TargetsCount); 2418Assert.Equal(14, instances[0].TargetsCount); 2776Assert.Equal(count, itemGroup.Count());

CopyOnWriteDictionary_Tests.cs (1)

124Assert.Equal(clone.Count, dictionary.Count);

Definition\ProjectItem_Tests.cs (1)

38Assert.Equal(1 + 15 /* built-in metadata */, item2.MetadataCount);

Definition\Toolset_Tests.cs (3)

120Assert.Equal(t.Properties.Count, t2.Properties.Count); 128Assert.Equal(t.SubToolsets.Count, t2.SubToolsets.Count); 138Assert.Equal(subToolset1.Properties.Count, subToolset2.Properties.Count);

Definition\ToolsetConfigurationReader_Tests.cs (7)

450Assert.Equal(2, msbuildToolsetSection.Toolsets.GetElement("2.0").PropertyElements.Count); 486Assert.Equal(2, msbuildToolsetSection.Toolsets.GetElement("2.0").PropertyElements.Count); 539Assert.Equal(2, msbuildToolsetSection.Toolsets.GetElement("2.0").PropertyElements.Count); 544Assert.Equal(3, msbuildToolsetSection.Toolsets.GetElement(0).AllProjectImportSearchPaths.Count); 547Assert.Equal(2, allPaths.GetElement(0).PropertyElements.Count); 552Assert.Equal(2, allPaths.GetElement(1).PropertyElements.Count); 587Assert.Equal(paths.SearchPaths.Count, expectedPaths.Length);

Definition\ToolsVersion_Tests.cs (4)

204Assert.Equal(1, mockLogger.WarningCount); // "Expected 1 warning logged!" 226Assert.Equal(1, mockLogger.WarningCount); // "Expected a warning for invalid character in toolpath" 278Assert.Equal(sortedTasksExpectedPaths.Count, foundFiles.Length); 284Assert.Equal(sortedOverrideExpectedPaths.Count, foundoverrideFiles.Length);

EscapingInProjects_Tests.cs (2)

882Assert.Equal(3, items.Count()); 914Assert.Equal(4, items.Count());

Evaluation\Evaluator_Tests.cs (22)

726Assert.Equal(2, logger.WarningCount); // "Expected two warnings" 772Assert.Equal(2, logger.WarningCount); // "Expected two warnings" 909Assert.Equal(3, imports.Count); 910Assert.Equal(5, importsIncludingDuplicates.Count); 1914Assert.Equal(allEvaluatedPropertiesWithNoBackingXmlAndNoDuplicates.Count, nonImportedProperties.Count()); 1935Assert.Equal(4, restOfAllEvaluatedProperties.Count()); 1946Assert.Equal(4, restOfAllEvaluatedProperties.Count()); 2006Assert.Equal(6, project.AllEvaluatedItems.Count); 2022Assert.Equal(6, project.AllEvaluatedItems.Count); 2027Assert.Equal(7, project.AllEvaluatedItems.Count); 2078Assert.Equal(allEvaluatedPropertiesWithNoBackingXmlAndNoDuplicates.Count, nonImportedProperties.Count()); 2099Assert.Equal(3, restOfAllEvaluatedProperties.Count()); 2128Assert.Equal(initial, project.AllEvaluatedProperties.Count); 2132Assert.Equal(initial + 1, project.AllEvaluatedProperties.Count); 2161Assert.Equal(4, project.AllEvaluatedItemDefinitionMetadata.Count); 2167Assert.Equal(4, project.AllEvaluatedItemDefinitionMetadata.Count); 2210Assert.Equal(nonImportedProperties.Count(), allProjectPropertiesNoDuplicateNames.Count); 2302Assert.Equal(1, mockLogger.ErrorCount); 2324Assert.Equal(2, instance.DefaultTargets.Count); 2348Assert.Equal(2, instance.InitialTargets.Count); 4527Assert.Equal(4, ex.LineNumber); 4528Assert.Equal(33, ex.ColumnNumber);

Evaluation\Expander_Tests.cs (19)

Evaluation\ExpressionShredder_Tests.cs (21)

Evaluation\ItemEvaluation_Tests.cs (1)

543Assert.Equal(INCLUDE_COUNT, items.Count);

Evaluation\ItemSpec_Tests.cs (1)

70Assert.Equal(1, matches);

Evaluation\ProjectSdkImplicitImport_Tests.cs (5)

117Assert.Equal(expectImportInLogicalProject ? 7 : 6, children.Count); 138Assert.Equal(expectImportInLogicalProject ? 2 : 0, projectRootElement.Imports.Count); 141Assert.Equal(2, project.Imports.Count); 205Assert.Equal(expectImportInLogicalProject ? 6 : 0, projectRootElement.Imports.Count); 208Assert.Equal(sdkNames.Count * 2, project.Imports.Count);

Evaluation\SimpleVersion_Tests.cs (12)

128Assert.Equal(expectedSign, Comparer<SimpleVersion>.Default.Compare(version1, version2)); 129Assert.Equal(expectedSign, Math.Sign(version1.CompareTo(version2))); 198Assert.Equal(expected, version1.Equals(version2)); 199Assert.Equal(expected, version1 == version2); 200Assert.Equal(!expected, version1 != version2); 203Assert.Equal(expected, version1.Equals(version2Object)); 207Assert.Equal(expected, version1Object.GetHashCode() == version2Object.GetHashCode()); 230Assert.Equal(expected, SimpleVersion.Parse(input)); 302Assert.Equal(major, version.Major); 303Assert.Equal(minor, version.Minor); 304Assert.Equal(build, version.Build); 305Assert.Equal(revision, version.Revision);

EvaluationProfiler_Tests.cs (13)

164Assert.Equal(2, profiledElements.Count(location => location.ElementName == "CSFile" & location.EvaluationPass == EvaluationPass.Items)); 166Assert.Equal(2, profiledElements.Count(location => location.ElementName == "CSFile" & location.EvaluationPass == EvaluationPass.LazyItems)); 173Assert.Equal(2, profiledElements.Count(location => location.ElementName == "Message")); 195Assert.Equal(2, profiledElements.Count(location => location.ElementName == "TestGlob" & location.EvaluationPass == EvaluationPass.Items)); 196Assert.Equal(2, profiledElements.Count(location => location.ElementName == "TestGlob" & location.EvaluationPass == EvaluationPass.LazyItems)); 204Assert.Equal(2, totalGlobLocation.NumberOfHits); 231Assert.Equal(itemPass.Id, itemGroup.ParentId); 232Assert.Equal(itemGroup.Id, testItem.ParentId); 237Assert.Equal(lazyItemPass.Id, lazyTestItem.ParentId); 243Assert.Equal(targetPass.Id, target.ParentId); 244Assert.Equal(target.Id, messageTarget.ParentId); 256Assert.Equal(allIds.Count, allUniqueIds.Count); 293Assert.Equal(BuildResultCode.Success, result.OverallResult);

ExpressionTree_Tests.cs (12)

FileLogger_Tests.cs (14)

65Assert.Equal((byte)109, content[0]); // 'm' 151Assert.Equal(fl.Verbosity, verbosityEnumerations[i]); 162Assert.Equal(fl.Verbosity, verbosityEnumerations[i]); 223Assert.Equal((byte)255, content[0]); 224Assert.Equal((byte)254, content[1]); 250Assert.Equal((byte)239, content[0]); 251Assert.Equal((byte)187, content[1]); 252Assert.Equal((byte)191, content[2]); 381Assert.Equal(0, new FileInfo(logFile).Length); 473Assert.Equal(expectedLines.Length, actualLines.Length); 493Assert.Equal(0, string.Compare(fileLogger.InternalFilelogger.Parameters, "ForceNoAlign;ShowEventId;ShowCommandLine;logfile=msbuild0.log;", StringComparison.OrdinalIgnoreCase)); 499Assert.Equal(0, string.Compare(fileLogger.InternalFilelogger.Parameters, "ForceNoAlign;ShowEventId;ShowCommandLine;logfile=" + Path.Combine(Directory.GetCurrentDirectory(), "mylogfile3.log") + ";", StringComparison.OrdinalIgnoreCase)); 505Assert.Equal(0, string.Compare(fileLogger.InternalFilelogger.Parameters, "ForceNoAlign;ShowEventId;ShowCommandLine;logfile=" + Path.Combine(Directory.GetCurrentDirectory(), "mylogfile4.log") + ";", StringComparison.OrdinalIgnoreCase)); 512Assert.Equal(0, string.Compare(fileLogger.InternalFilelogger.Parameters, "ForceNoAlign;ShowEventId;ShowCommandLine;logfile=" + Path.Combine(Directory.GetCurrentDirectory(), "tempura", "mylogfile1.log") + ";", StringComparison.OrdinalIgnoreCase));

FileMatcher_Tests.cs (9)

594Assert.Equal(input.Item3, FileMatcher.IsMatch(input.Item1, input.Item2)); 595Assert.Equal(input.Item3, FileMatcher.IsMatch(input.Item1.ToUpperInvariant(), input.Item2)); 596Assert.Equal(input.Item3, FileMatcher.IsMatch(input.Item1, input.Item2.ToUpperInvariant())); 1291Assert.Equal(new[] { "a.cs", "b.cs", "c.cs" }, files); 1295Assert.Equal(new[] { "b.cs", "c.cs" }, files); 1299Assert.Equal(new[] { "b.cs" }, files); 2426Assert.Equal(1, timesFound); 2445Assert.Equal(0, timesFound); 2450Assert.Equal(0, mockFileSystem.FileHits3); // "At least one file that was marked untouchable was referenced."

FileUtilities_Tests.cs (1)

196Assert.Equal(info.LastWriteTime, new FileInfo(file).LastWriteTime);

Globbing\CompositeGlob_Tests.cs (2)

133Assert.Equal(4, leafGlobs.Length); 170Assert.Equal(2, composite.Globs.Count());

Globbing\MSBuildGlob_Tests.cs (1)

33Assert.Equal(glob.TestOnlyGlobRoot.LastOrDefault(), Path.DirectorySeparatorChar);

HashTableUtility_Tests.cs (4)

43Assert.Equal(0, HashTableUtility.Compare(h1, h2)); 47Assert.Equal(0, HashTableUtility.Compare(h1, h2)); 53Assert.Equal(0, HashTableUtility.Compare(h1, h2)); 67Assert.Equal(0, HashTableUtility.Compare(h1, h2));

Instance\HostServices_Tests.cs (31)

Instance\ProjectPropertyInstance_Internal_Tests.cs (3)

66Assert.Equal(property.IsImmutable, deserializedProperty.IsImmutable); 67Assert.Equal(typeof(ProjectPropertyInstance), property.GetType()); 85Assert.Equal(property.IsImmutable, deserializedProperty.IsImmutable);

Instance\TaskItem_Tests.cs (5)

62Assert.Equal(item.MetadataCount, deserializedItem.MetadataCount); 87Assert.Equal(left, right); 88Assert.Equal(right, left); 102Assert.Equal(left, right); 103Assert.Equal(right, left);

InvalidProjectFileException_Tests.cs (2)

79Assert.Equal(3, e.LineNumber); 80Assert.Equal(38, e.ColumnNumber);

LoggerDescription_Tests.cs (5)

37Assert.Equal(streamWriteEndPosition, streamReadEndPosition); // "Stream end positions should be equal" 39Assert.Equal(description.Verbosity, description2.Verbosity); // "Expected Verbosity to Match" 40Assert.Equal(description.LoggerId, description2.LoggerId); // "Expected Verbosity to Match" 41Assert.Equal(0, string.Compare(description.LoggerSwitchParameters, description2.LoggerSwitchParameters, StringComparison.OrdinalIgnoreCase)); // "Expected LoggerSwitchParameters to Match" 42Assert.Equal(0, string.Compare(description.Name, description2.Name, StringComparison.OrdinalIgnoreCase)); // "Expected Name to Match"

Scanner_Tests.cs (32)

TaskParameter_Tests.cs (50)

TestComparers\ProjectInstanceModelTestComparers.cs (9)

26Assert.Equal(x.TranslateEntireState, y.TranslateEntireState); 30Assert.Equal(((EvaluatorData)x).GlobalPropertiesToTreatAsLocal, ((EvaluatorData)y).GlobalPropertiesToTreatAsLocal); 44Assert.Equal(x.DefaultTargets, y.DefaultTargets); 45Assert.Equal(x.InitialTargets, y.InitialTargets); 48Assert.Equal(x.UsingDifferentToolsVersionFromProjectFile, y.UsingDifferentToolsVersionFromProjectFile); 49Assert.Equal(x.ExplicitToolsVersionSpecified, y.ExplicitToolsVersionSpecified); 56Assert.Equal(x.IsImmutable, y.IsImmutable); 93Assert.Equal(x.ParentProjectSupportsReturnsAttribute, y.ParentProjectSupportsReturnsAttribute); 343Assert.Equal(x.Count, y.Count);

TestComparers\TaskRegistryComparers.cs (5)

23Assert.Equal(x.NextRegistrationOrderId, y.NextRegistrationOrderId); 49Assert.Equal(x.TaskFactoryAssemblyLoadInfo, y.TaskFactoryAssemblyLoadInfo); 78Assert.Equal(x.TaskBodyEvaluated, y.TaskBodyEvaluated); 103Assert.Equal(x.Output, y.Output); 104Assert.Equal(x.Required, y.Required);

Utilities_Tests.cs (1)

91Assert.Equal(

Al_Tests.cs (3)

318Assert.Equal(2, t.LinkResources.Length); // "New value" 465Assert.Equal(2, t.ResponseFiles.Length); // "New value" 490Assert.Equal(2, t.SourceModules.Length); // "New value"

AspNetCompiler_Tests.cs (2)

271Assert.Equal(3, logger.ExternalProjectStartedEvents.Count); 272Assert.Equal(3, logger.ExternalProjectFinishedEvents.Count);

AssemblyDependency\InstalledSDKResolverFixture.cs (4)

48Assert.Equal(0, engine.Errors); 49Assert.Equal(1, engine.Warnings); 94Assert.Equal(0, engine.Errors); 95Assert.Equal(0, engine.Warnings);

AssemblyDependency\Miscellaneous.cs (143)

AssemblyDependency\ResolveAssemblyReferenceTestFixture.cs (1)

3048Assert.Equal(loadModeResolvedFiles.Length, t.ResolvedFiles.Length);

AssemblyDependency\StronglyNamedDependency.cs (2)

73Assert.Equal(0, engine.Errors); 74Assert.Equal(0, engine.Warnings);

AssemblyDependency\StronglyNamedDependencyAppConfig.cs (6)

422Assert.Equal(1, engine.Errors); 464Assert.Equal(1, engine.Errors); 508Assert.Equal(1, engine.Errors); 553Assert.Equal(1, engine.Errors); 600Assert.Equal(0, engine.Errors); 635Assert.Equal(1, engine.Errors);

AssemblyDependency\StronglyNamedDependencyAutoUnify.cs (1)

385Assert.Equal(2, t.ResolvedFiles.Length); // "Expected to find two resolved assemblies"

AssemblyDependency\SuggestedRedirects.cs (15)

66Assert.Equal(3, t.ResolvedDependencyFiles.Length); 73Assert.Equal(1, e.Warnings); // "Should only be one warning for suggested redirects." 108Assert.Equal(1, engine.Warnings); // @"Expected a warning because this is an unresolvable conflict." 111Assert.Equal(1, engine.Warnings); // "Should only be one warning for suggested redirects." 160Assert.Equal(0, engine.Warnings); // "Should be no warning for suggested redirects." 201Assert.Equal(1, e.Warnings); // @"Expected one warning." 210Assert.Equal(3, t.ResolvedFiles.Length); 246Assert.Equal(1, e.Warnings); // @"Expected one warning." 255Assert.Equal(3, t.ResolvedFiles.Length); 335Assert.Equal(1, e.Warnings); 374Assert.Equal(0, e.Warnings); 414Assert.Equal(2, t.ResolvedDependencyFiles.Length); 418Assert.Equal(0, e.Warnings); // "Should only be no warning about suggested redirects." 457Assert.Equal(2, t.ResolvedDependencyFiles.Length); 461Assert.Equal(0, e.Warnings); // "Should only be no warning about suggested redirects."

AssemblyDependency\VerifyIgnoreVersionForFrameworkReference.cs (9)

49Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario." 50Assert.Equal(0, e.Errors); // "No errors expected in this scenario." 72Assert.Equal(1, e.Warnings); // "Expected one warning in this scenario." 102Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario." 103Assert.Equal(0, e.Errors); // "No errors expected in this scenario." 125Assert.Equal(1, e.Warnings); // "Expected one warning in this scenario." 155Assert.Equal(0, e.Warnings); // "No warnings expected in this scenario." 156Assert.Equal(0, e.Errors); // "No errors expected in this scenario." 187Assert.Equal(1, e.Warnings); // "Expected one warning in this scenario."

AssemblyDependency\VerifyTargetFrameworkAttribute.cs (24)

AssemblyDependency\VerifyTargetFrameworkHigherThanRedist.cs (30)

AssemblyDependency\WinMDTests.cs (39)

AssemblyNameEx_Tests.cs (19)

132Assert.Equal(resultBaseline, result); 167Assert.Equal(0, result); 172Assert.Equal(a1.CompareBaseNameTo(a2), result); 183Assert.Equal(-1, result); 187Assert.Equal(a1.Version.CompareTo(a2.Version), result); 195Assert.Equal(resultBaseline, result); 220Assert.Equal(0, String.Compare(AssemblyNameExtension.EscapeDisplayNameCharacters(displayName), @"Hello\,\""Don\'t\"" eat the \\CAT", StringComparison.OrdinalIgnoreCase)); 256Assert.Equal(resultBaseline, result); 297Assert.Equal(resultBaseline, result); 317Assert.Equal(0, result); 631Assert.Equal(0, AssemblyNameComparer.Comparer.Compare(a, b)); 635Assert.Equal(0, AssemblyNameComparer.ComparerConsiderRetargetable.Compare(a, c)); 654Assert.Equal(-1, reverseComparer.Compare(x, y)); 655Assert.Equal(1, reverseComparer.Compare(y, x)); 656Assert.Equal(0, reverseComparer.Compare(x, z)); 657Assert.Equal(0, reverseComparer.Compare(null, null)); 658Assert.Equal(-1, reverseComparer.Compare(x, null)); 659Assert.Equal(1, reverseComparer.Compare(null, y)); 660Assert.Equal(-1, reverseComparer.Compare(a, x));

AssemblyRegistrationCache_Tests.cs (2)

19Assert.Equal(0, arc.Count); 23Assert.Equal(1, arc.Count);

AssignLinkMetadata_Tests.cs (2)

80Assert.Equal(item.MetadataCount + 2, t.OutputItems[0].MetadataCount); 107Assert.Equal(item2.MetadataCount + 2, t.OutputItems[0].MetadataCount);

AssignProjectConfiguration_Tests.cs (6)

51Assert.Equal(expectedResult, result); 312Assert.Equal(2, unresolvedProjects.Count); // "Two unresolved refs expected for case 1" 313Assert.Equal(unresolvedProjects["MCDep1.vcproj"], projectRefs[0]); 314Assert.Equal(unresolvedProjects["MCDep2.vcproj"], projectRefs[1]); 328Assert.Equal(unresolvedProjects["MCDep1.vcproj"], projectRefs[0]); 340Assert.Equal(2, resolvedProjects.Count); // "Two resolved refs expected for case 3"

CodeTaskFactoryEmbeddedFileInBinlogTestHelper.cs (2)

64Assert.Equal(buildShouldSucceed, result); 116Assert.Equal(buildShouldSucceed, result);

ComReferenceWalker_Tests.cs (6)

40Assert.Equal(contains, dependencyExists); 50Assert.Equal(0, walker.GetDependencies().GetLength(0)); 258Assert.Equal(failureException, walker.EncounteredProblems[0]); // "Test failed for failure point " + failurePoint.ToString() 348Assert.Equal(2, analyzedTypes.Count); 358Assert.Equal(4, analyzedTypes.Count); 368Assert.Equal(6, analyzedTypes.Count);

Copy_Tests.cs (33)

515Assert.Equal(0, m.copyCount); 563Assert.Equal(0, m.copyCount); 623Assert.Equal(0, m.copyCount); 676Assert.Equal(0, m.copyCount); 869Assert.Equal(((t.Retries + 1) * 3) - 1, ((MockEngine)t.BuildEngine).Warnings); 874Assert.Equal(2, ((MockEngine)t.BuildEngine).Errors); 1006Assert.Equal(2, t.CopiedFiles.Length); 1244Assert.Equal(1, engine.Errors); 1245Assert.Equal(0, engine.Warnings); 1291Assert.Equal(1, engine.Errors); 1292Assert.Equal(0, engine.Warnings); 1338Assert.Equal(1, engine.Errors); 1339Assert.Equal(0, engine.Warnings); 1389Assert.Equal(2, engine.Errors); // retries failed and the actual failure 1390Assert.Equal(10, engine.Warnings); 1455Assert.Equal(1, engine.Errors); 1456Assert.Equal(0, engine.Warnings); 1511Assert.Equal(1, engine.Errors); 1512Assert.Equal(0, engine.Warnings); 1554Assert.Equal(1, engine.Errors); 1555Assert.Equal(0, engine.Warnings); 1619Assert.Equal(2, t.DestinationFiles.Length); 1818Assert.Equal(2, t.DestinationFiles.Length); 1825Assert.Equal(2, t.CopiedFiles.Length); 2021Assert.Equal(2, filesActuallyCopied.Count); 2022Assert.Equal(4, t.CopiedFiles.Length); 2088Assert.Equal(4, filesActuallyCopied.Count); 2089Assert.Equal(5, t.CopiedFiles.Length); 2094Assert.Equal(3, xaCopies.Count); 2373Assert.Equal(10, t.Retries); 2384Assert.Equal(1000, t.RetryDelayMilliseconds); 2685Assert.Equal(2, t.DestinationFiles.Length); 2686Assert.Equal(2, t.CopiedFiles.Length);

CSharpTokenizer_Tests.cs (1)

425Assert.Equal(expectedLastLineNumber, lastLine);

ErrorWarningMessage_Tests.cs (11)

78Assert.Equal(0, e.Messages); 102Assert.Equal(1, e.Warnings); 125Assert.Equal(1, e.Warnings); 150Assert.Equal(1, e.Warnings); 176Assert.Equal(1, e.Errors); 202Assert.Equal(1, e.Errors); 227Assert.Equal(1, e.Errors); 252Assert.Equal(1, e.Errors); 280Assert.Equal(1, e.Errors); 307Assert.Equal(1, e.Errors); 334Assert.Equal(1, e.Errors);

Exec_Tests.cs (30)

FileStateTests.cs (21)

66Assert.Equal(info.Exists, state.FileExists); 112Assert.Equal(info.LastWriteTime, state.LastWriteTime); 131Assert.Equal(info.LastWriteTimeUtc, state.LastWriteTimeUtcFast); 150Assert.Equal(info.Length, state.Length); 169Assert.Equal(info.IsReadOnly, state.IsReadOnly); 188Assert.Equal(info.Exists, state.FileExists); 240Assert.Equal(info.LastWriteTime, state.LastWriteTime); 247Assert.Equal(time, state.LastWriteTime); 266Assert.Equal(info.LastWriteTimeUtc, state.LastWriteTimeUtcFast); 273Assert.Equal(time.ToUniversalTime(), state.LastWriteTimeUtcFast); 294Assert.Equal(info.Length, state.Length); 297Assert.Equal(info.Length, state.Length); 300Assert.Equal(info.Length, state.Length); 319Assert.Equal(info.IsReadOnly, state.IsReadOnly); 334Assert.Equal(new FileInfo(Path.GetTempPath()).Exists, new FileState(Path.GetTempPath()).FileExists); 341Assert.Equal(new FileInfo(Path.GetTempPath()).IsReadOnly, new FileState(Path.GetTempPath()).IsReadOnly); 347Assert.Equal(new FileInfo(Path.GetTempPath()).LastWriteTime, new FileState(Path.GetTempPath()).LastWriteTime); 353Assert.Equal(new FileInfo(Path.GetTempPath()).LastWriteTimeUtc, new FileState(Path.GetTempPath()).LastWriteTimeUtcFast); 369Assert.Equal(new FileInfo(file).LastWriteTime, new FileState(file).LastWriteTime); 379Assert.Equal(new FileInfo(file).LastWriteTimeUtc, new FileState(file).LastWriteTimeUtcFast); 405Assert.Equal(Directory.Exists(file), new FileState(file).DirectoryExists);

FindInvalidProjectReferences_Tests.cs (1)

57Assert.Equal(2, t.InvalidReferences.Length);

GetInstalledSDKLocations_Tests.cs (7)

206Assert.Equal(1, engine.Errors); 225Assert.Equal(1, engine.Errors); 244Assert.Equal(1, engine.Errors); 262Assert.Equal(1, engine.Warnings); 287Assert.Equal(6, installedSDKs.Length); 334Assert.Equal(6, installedSDKs.Length); 408Assert.Equal(6, installedSDKs.Length);

GetReferencePaths_Tests.cs (6)

35Assert.Equal(ToolLocationHelper.GetPathToReferenceAssemblies(new FrameworkNameVersioning(targetFrameworkMoniker)).Count, returnedPaths.Length); 36Assert.Equal(0, engine.Errors); // "Expected the log to contain no errors" 73Assert.Equal(0, engine.Log.Length); // "Expected the log to contain nothing" 144Assert.Equal(1, engine.Errors); 184Assert.Equal(0, engine.Errors); 326Assert.Equal(0, engine.Log.Length); // "Expected the log to contain nothing"

GetSDKReference_Tests.cs (38)

MakeDir_Tests.cs (2)

94Assert.Equal(2, t.DirectoriesCreated.Length); 102Assert.Equal(3, t.DirectoriesCreated.Length);

MockTypeInfo.cs (1)

421Assert.Equal(-1, index);

MockUnmanagedMemoryHelper.cs (1)

90Assert.Equal(IntPtr.Zero, _mainAllocationHandle);

Move_Tests.cs (2)

461Assert.Equal(2, t.DestinationFiles.Length); 662Assert.Equal(2, t.DestinationFiles.Length);

MSBuild_Tests.cs (13)

217Assert.Equal(0, logger.WarningCount); 218Assert.Equal(1, logger.ErrorCount); 251Assert.Equal(0, logger.WarningCount); 252Assert.Equal(0, logger.ErrorCount); 287Assert.Equal(0, logger.WarningCount); 288Assert.Equal(0, logger.ErrorCount); 335Assert.Equal(0, logger.WarningCount); 336Assert.Equal(1, logger.ErrorCount); 378Assert.Equal(0, logger.WarningCount); 379Assert.Equal(1, logger.ErrorCount); 1350Assert.Equal(5, msbuildTask.TargetOutputs.Length); 1487Assert.Equal(expectedTaskId, actualTaskId); 1523Assert.Equal(expectedTaskId, actualTaskId);

NativeMethodsShared_Tests.cs (4)

59Assert.Equal((uint)Process.GetCurrentProcess().Id, processId); // "Expected the .net processId to match the one from GetCurrentProcessId" 80Assert.Equal(DateTime.MinValue, nonexistentFileTime); 93Assert.Equal(DateTime.MinValue, directoryTime); 107Assert.Equal(DateTime.MinValue, directoryTime);

PropertyParser_Tests.cs (6)

55Assert.Equal(3, propertiesTable.Count); 75Assert.Equal(2, propertiesTable.Count); 94Assert.Equal(2, propertiesTable.Count); 164Assert.Equal(2, propertiesTable.Count); 181Assert.Equal(2, propertiesTable.Count); 198Assert.Equal(2, propertiesTable.Count);

ReadLinesFromFile_Tests.cs (3)

55Assert.Equal(3, r.Lines.Length); 102Assert.Equal(3, r.Lines.Length); 198Assert.Equal(3, r.Lines.Length);

RemoveDuplicates_Tests.cs (3)

70Assert.Equal(3, t.Filtered.Length); 96Assert.Equal(3, t.Filtered.Length); 115Assert.Equal(2, t.Filtered.Length);

ResolveComReference_Tests.cs (12)

44Assert.Equal(ResolveComReference.VerifyReferenceMetadataForNameItem(item, out missingOrInvalidAttribute), valid); 239Assert.Equal(refGuid, refAttr.guid); // "incorrect guid" 240Assert.Equal(11, refAttr.wMajorVerNum); // "incorrect version major" 241Assert.Equal(0, refAttr.wMinorVerNum); // "incorrect version minor" 242Assert.Equal(1033, refAttr.lcid); // "incorrect lcid" 429Assert.Equal(4, rcr.allProjectRefs.Count); // "There should be four references now" 432Assert.Equal(axRefInfo.primaryOfAxImpRef, newTlbInfo); // "axRefInfo should hold back reference to tlbRefInfo" 441Assert.Equal(4, rcr.allProjectRefs.Count); // "There should still be four references" 634Assert.Equal(3, rcr.allProjectRefs.Count); 646Assert.Equal(6, rcr.allProjectRefs.Count); 663Assert.Equal(7, rcr.allProjectRefs.Count); 800Assert.Equal(2, rcr.allProjectRefs.Count); // "Should be two references"

ResolveNonMSBuildProjectOutput_Tests.cs (12)

64Assert.Equal(result, expectedResult); 116Assert.Equal(result, expectedResult); 259Assert.Equal(2, unresolvedOutputs.Count); // "Two unresolved refs expected for case 1" 260Assert.Equal(unresolvedOutputs["MCDep1.vcproj"], projectRefs[0]); 261Assert.Equal(unresolvedOutputs["MCDep2.vcproj"], projectRefs[1]); 275Assert.Equal(unresolvedOutputs["MCDep1.vcproj"], projectRefs[0]); 287Assert.Equal(2, resolvedOutputs.Count); // "Two resolved refs expected for case 3" 330Assert.Equal(unresolvedOutputs["MCDep2.vcproj"], projectRefs[1]); 346Assert.Equal(1, engine.Warnings); 347Assert.Equal(0, engine.Errors); 353Assert.Equal(0, engine.Warnings); 354Assert.Equal(1, engine.Errors);

ResolveSDKReference_Tests.cs (44)

ResourceHandling\GenerateResource_Tests.cs (2)

3649Assert.Equal(resxValue, valuesFromResource[resxDataName]); 3722Assert.Equal(1, ((MockEngine)t.BuildEngine).Errors);

ResourceHandling\GenerateResourceOutOfProc_Tests.cs (3)

472Assert.Equal(time, File.GetLastWriteTime(t2.OutputResources[0].ItemSpec)); 539Assert.Equal(time, File.GetLastWriteTime(t2.OutputResources[0].ItemSpec)); 540Assert.Equal(time2, File.GetLastWriteTime(t2.OutputResources[1].ItemSpec));

ResourceHandling\ResGen_Tests.cs (15)

SdkToolsPathUtility_Tests.cs (7)

52Assert.Equal(0, _mockEngine.Warnings); 56Assert.Equal(1, _mockEngine.Errors); 70Assert.Equal(0, _mockEngine.Warnings); 74Assert.Equal(0, _mockEngine.Errors); 179Assert.Equal(1, _mockEngine.Errors); 191Assert.Equal(1, _mockEngine.Errors); 208Assert.Equal(0, _mockEngine.Errors);

SGen_Tests.cs (2)

122Assert.Equal(1, engine.Errors); 138Assert.Equal(1, engine.Errors);

StreamMappedString_Tests.cs (9)

45Assert.Equal('A', s.GetAt(0)); 58Assert.Equal('A', s.GetAt(0)); 68Assert.Equal('\xd', s.GetAt(1)); 78Assert.Equal('y', s.GetAt(1)); 88Assert.Equal('x', s.GetAt(0)); 98Assert.Equal('\xd', s.GetAt(StreamMappedString.DefaultPageSize)); 163Assert.Equal('\u00C3', s.GetAt(0)); 180Assert.Equal(0, stream.ResetCount); 205Assert.Equal(2, s.PagesAllocated);

TlbImp_Tests.cs (4)

122Assert.Equal(testParameterValue, t.AssemblyVersion); // "New AssemblyNamespace value should be set" 278Assert.Equal(ResolveComReference.TlbImpTransformFlags.None, t.Transform); // "Transform should be TlbImpTransformFlags.None by default" 285Assert.Equal(dispRet, t.Transform); // "New Transform value should be set" 293Assert.Equal(serialize, t.Transform); // "New Transform value should be set"

ToolTaskExtension_Tests.cs (3)

74Assert.Equal(5, t.GetIntParameterWithDefault("Key", 5)); 100Assert.Equal(5, t.GetIntParameterWithDefault("Key", 9)); 121Assert.Equal(expected, actual);

VisualBasicTokenizer_Tests.cs (1)

287Assert.Equal(expectedLastLineNumber, lastLine);

WinMDExp_Tests.cs (1)

142Assert.Equal(expected, actual);

XamlTaskFactory_Tests.cs (17)

XmlPeek_Tests.cs (5)

68Assert.Equal(3, p.Result.Length); // "result Length should be 3" 91Assert.Equal(3, p.Result.Length); // "result Length should be 3" 120Assert.Equal(3, p.Result.Length); // "result Length should be 3" 148Assert.Equal(3, p.Result.Length); // "result Length should be 3" 168Assert.Equal(3, p.Result.Length); // "result Length should be 3"

XslTransformation_Tests.cs (3)

307Assert.Equal(xmlPaths, t.XmlInputPaths); 341Assert.Equal(xslPath, t.XslInputPath); 380Assert.Equal(8, mc.Count); // "The file test doesn't match"

MockLogger.cs (2)

544public void AssertNoErrors() => Assert.Equal(0, ErrorCount); 549public void AssertNoWarnings() => Assert.Equal(0, WarningCount);

ObjectModelHelpers.cs (8)

116Assert.Equal(1, count); 492Assert.Equal(expected.Length, actual.Length); // "Expected array length of <" + expected.Length + "> but was <" + actual.Length + ">."); 497Assert.Equal(expected[i], actual[i]); // "At index " + i + " expected " + expected[i].ToString() + " but was " + actual.ToString()); 1242Assert.Equal(one.Count, two.Count); 1246Assert.Equal(one[i], two[i]); 1255Assert.Equal(one.Count, two.Count); 1276Assert.Equal(x.Count, y.Count); 1904Assert.Equal(ex1.GetType(), ex2.GetType()); // "Both methods threw but the first threw {0} '{1}' and the second threw {2} '{3}'", ex1.GetType(), ex1.Message, ex2.GetType(), ex2.Message);

TestEnvironment.cs (1)

528Assert.Equal(_originalFiles.Length, newFilesCount);

Logger_Tests.cs (2)

42Assert.Equal(0, string.Compare(logger.Parameters, "Parameters", StringComparison.OrdinalIgnoreCase)); 43Assert.Equal(LoggerVerbosity.Diagnostic, logger.Verbosity);

MuxLogger_Tests.cs (1)

279Assert.Equal(1, mockLogger1.ErrorCount);

NativeMethodsShared_Tests.cs (4)

59Assert.Equal((uint)Process.GetCurrentProcess().Id, processId); // "Expected the .net processId to match the one from GetCurrentProcessId" 80Assert.Equal(DateTime.MinValue, nonexistentFileTime); 93Assert.Equal(DateTime.MinValue, directoryTime); 107Assert.Equal(DateTime.MinValue, directoryTime);

MinimalRepoTests.cs (2)

29Assert.Equal(0, exitCode); 41Assert.Equal(0, exitCode);

RepoWithConditionalProjectsToBuildTests.cs (2)

43Assert.Equal(0, exitCode); 53Assert.Equal(expectedPackages, nupkgFiles.Length);

SourceMappingToNugetConfigTest.cs (2)

75Assert.Equal(expectedPackagePatterns, actualPackagePatterns); 82Assert.Equal("clear", firstElement?.Name);

PackageTests.cs (1)

28Assert.Equal(expectedFeatureBand, p.SdkFeatureBand);

SwixComponentTests.cs (1)

192Assert.Equal(2, componentSwr.Split(new[] { "vs.dependency" }, StringSplitOptions.None).Length);

SwixPackageGroupTests.cs (1)

34Assert.Equal(expectedVersion, packageGroup.Version);

TestHelpers\AssertEx.cs (1)

390Assert.Equal(typeof(T), type);

VersionUpdaterTests.cs (1)

40Assert.Equal(expectedParts.Length, actualParts.Length);

OpenApiAddFileTests.cs (2)

34Assert.Equal(1, run); 46Assert.Equal(1, run);

OpenApiAddURLTests.cs (2)

368Assert.Equal(1, appExitCode); 428Assert.Equal(1, run);

OpenApiRefreshTests.cs (1)

94Assert.Equal(firstWriteTime, secondWriteTime);

OpenApiTestBase.cs (1)

112Assert.Equal(0, appExitCode);

RemoteExecutorTests.cs (3)

19Assert.Equal(RemoteExecutor.SuccessExitCode, h.ExitCode); 44Assert.Equal(RemoteExecutor.SuccessExitCode, h.ExitCode); 158Assert.Equal(exitCode, h.ExitCode);

ValidateUsageAgainstBaselineTests.cs (2)

85Assert.Equal( 108Assert.Equal(baseline.IgnorePatterns.Length, data.ActualUsageData.IgnorePatterns.Length);

StringExtensionsTests.cs (7)

16Assert.Equal(expected: 0, actual: replacementCount); 25Assert.Equal(expected: 1, actual: replacementCount); 34Assert.Equal(expected: 1, actual: replacementCount); 43Assert.Equal(expected: 1, actual: replacementCount); 52Assert.Equal(expected: 1, actual: replacementCount); 61Assert.Equal(expected: 2, actual: replacementCount); 70Assert.Equal(expected: 3, actual: replacementCount);

XElementExtensionsTests.cs (1)

76Assert.Equal(expected: transUnitElement.Element(Source), actual: transUnitElement.Element(Target).PreviousNode);

AsyncCollectionAssertsTests.cs (14)

31 Assert.All(items, x => Assert.Equal(1, x)); 39 var ex = Record.Exception(() => Assert.All(items, item => Assert.Equal(1, item))); 83 await Assert.AllAsync(items, async item => { await Task.Yield(); Assert.Equal(1, item); }); 91 var ex = Record.Exception(() => Assert.All(items, x => Assert.Equal(1, x))); 160 item => Assert.Equal(42, item), 161 item => Assert.Equal(2112, item) 172 item => Assert.Equal(42, item), 173 item => Assert.Equal(2113, item) 234 Assert.Equal(42, item); 239 Assert.Equal(2112, item); 254 Assert.Equal(42, item); 259 Assert.Equal(2113, item); 1445 Assert.Equal('H', value); 1540 Assert.Equal('H', value);

CollectionAssertsTests.cs (35)

DictionaryAssertsTests.cs (6)

23 Assert.Equal(42, Assert.Contains("FORTY-two", dictionary)); 24 Assert.Equal(42, Assert.Contains("FORTY-two", new ReadOnlyDictionary<string, int>(dictionary))); 25 Assert.Equal(42, Assert.Contains("FORTY-two", (IDictionary<string, int>)dictionary)); 26 Assert.Equal(42, Assert.Contains("FORTY-two", (IReadOnlyDictionary<string, int>)dictionary)); 28 Assert.Equal(42, Assert.Contains("FORTY-two", dictionary.ToImmutableDictionary(StringComparer.InvariantCultureIgnoreCase))); 29 Assert.Equal(42, Assert.Contains("FORTY-two", (IImmutableDictionary<string, int>)dictionary.ToImmutableDictionary(StringComparer.InvariantCultureIgnoreCase)));

EqualityAssertsTests.cs (139)

EventAssertsTests.cs (28)

NullAssertsTests.cs (1)

23 Assert.Equal(42, result);

Sdk\CollectionTrackerTests.cs (10)

22 Assert.Equal(1, pointerIndent); 34 Assert.Equal(1, pointerIndent); 46 Assert.Equal(4, pointerIndent); 58 Assert.Equal(12, pointerIndent); 70 Assert.Equal(18, pointerIndent); 86 Assert.Equal(1, pointerIndent); 98 Assert.Equal(1, pointerIndent); 110 Assert.Equal(4, pointerIndent); 122 Assert.Equal(12, pointerIndent); 134 Assert.Equal(18, pointerIndent);

ConditionalAttributeTests.cs (1)

80Assert.Equal(3, s_conditionalTheoryCount);

GetCurrentOpenApiReferenceTest.cs (1)

54Assert.Equal(expectedMetadata, orderedMetadata);

GetOpenApiReferenceMetadataTest.cs (15)

MetadataSerializerTest.cs (1)

136Assert.Equal(expectedMetadata, orderedMetadata);

TargetTest.cs (18)

GetDocumentTests.cs (4)

42Assert.Equal(OpenApiSpecVersion.OpenApi3_0, diagnostic.SpecificationVersion); 67Assert.Equal(OpenApiSpecVersion.OpenApi2_0, diagnostic.SpecificationVersion); 93Assert.Equal(OpenApiSpecVersion.OpenApi3_0, diagnostic.SpecificationVersion); 118Assert.Equal(OpenApiSpecVersion.OpenApi3_0, diagnostic.SpecificationVersion);

BufferReleaseTests.cs (6)

55Assert.Equal(1, cacheItem.RefCount); 70Assert.Equal(0, cacheItem.RefCount); 140Assert.Equal(1, cacheItem.RefCount); 157Assert.Equal(1, cacheItem.RefCount); // not decremented because there was no need to add the hook 198Assert.Equal(1, cacheItem.RefCount); 214Assert.Equal(0, cacheItem.RefCount);

DistributedCacheTests.cs (9)

181Assert.Equal(size, expected.Length); 199Assert.Equal(0, writer.CommittedBytes); 241Assert.Equal(size, expected.Length); 259Assert.Equal(0, writer.CommittedBytes); 309Assert.Equal(size, payload.Length); 326Assert.Equal(0, segment.Offset); 328Assert.Equal(size, segment.Count); 329Assert.Equal(size, segment.Array.Length); 336Assert.Equal(size, segment.Count);

RedisTests.cs (1)

95Assert.Equal(1, count);

ServiceConstructionTests.cs (7)

42Assert.Equal(937, options.MaximumKeyLength); 45Assert.Equal(TimeSpan.FromSeconds(120), defaults.Expiration); 46Assert.Equal(HybridCacheEntryFlags.DisableLocalCacheRead, defaults.Flags); 59Assert.Equal(937, options.MaximumKeyLength); 71Assert.Equal(937, options.MaximumKeyLength); 74Assert.Equal(HybridCacheEntryFlags.DisableCompression | HybridCacheEntryFlags.DisableLocalCacheRead, defaults.Flags); 75Assert.Equal(TimeSpan.FromSeconds(120), defaults.LocalCacheExpiration);

StampedeTests.cs (30)

SqlServerCacheServicesExtensionsTest.cs (4)

25Assert.Equal(typeof(IDistributedCache), serviceDescriptor.ServiceType); 26Assert.Equal(typeof(SqlServerCache), serviceDescriptor.ImplementationType); 27Assert.Equal(ServiceLifetime.Singleton, serviceDescriptor.Lifetime); 51Assert.Equal(ServiceLifetime.Scoped, distributedCache.Lifetime);

SqlServerCacheWithDatabaseTest.cs (15)

CacheServiceExtensionsTests.cs (3)

29Assert.Equal(ServiceLifetime.Singleton, distributedCache.Lifetime); 48Assert.Equal(ServiceLifetime.Scoped, distributedCache.Lifetime); 119Assert.Equal(ServiceLifetime.Scoped, distributedCache.Lifetime);

RedisCacheSetAndRemoveTests.cs (5)

39Assert.Equal(value, result); 53Assert.Equal(value, result); 68Assert.Equal(value1, result); 73Assert.Equal(value2, result); 85Assert.Equal(value, result);

TimeExpirationAsyncTests.cs (8)

33Assert.Equal(actualValue, ex.ActualValue); 65Assert.Equal(value, result); 131Assert.Equal(value, result); 193Assert.Equal(value, result); 224Assert.Equal(value, result); 231Assert.Equal(value, result); 252Assert.Equal(value, result); 260Assert.Equal(value, result);

TimeExpirationTests.cs (7)

48Assert.Equal(value, result); 115Assert.Equal(value, result); 178Assert.Equal(value, result); 209Assert.Equal(value, result); 216Assert.Equal(value, result); 237Assert.Equal(value, result); 245Assert.Equal(value, result);

ConfigurationProviderTestBase.cs (5)

139Assert.Equal(new[] { "ArrayValue0", "ArrayValue1", "ArrayValue2" }, options.Section1.Section2.Key3a); 255Assert.Equal(3, sections.Count); 271Assert.Equal(2, sections.Count); 283Assert.Equal(2, sections.Count); 295Assert.Equal(3, sections.Count);

KeyPerFileTests.cs (1)

238Assert.Equal(-2, options.Number);

DefaultHealthCheckServiceTest.cs (27)

DependencyInjection\HealthChecksBuilderTest.cs (9)

DependencyInjection\ServiceCollectionExtensionsTest.cs (15)

29Assert.Equal(ServiceLifetime.Singleton, actual.Lifetime); 30Assert.Equal(typeof(HealthCheckService), actual.ServiceType); 31Assert.Equal(typeof(DefaultHealthCheckService), actual.ImplementationType); 37Assert.Equal(ServiceLifetime.Singleton, actual.Lifetime); 38Assert.Equal(typeof(IHostedService), actual.ServiceType); 39Assert.Equal(typeof(HealthCheckPublisherHostedService), actual.ImplementationType); 59Assert.Equal(ServiceLifetime.Singleton, actual.Lifetime); 60Assert.Equal(typeof(HealthCheckService), actual.ServiceType); 61Assert.Equal(typeof(DefaultHealthCheckService), actual.ImplementationType); 67Assert.Equal(ServiceLifetime.Singleton, actual.Lifetime); 68Assert.Equal(typeof(IHostedService), actual.ServiceType); 69Assert.Equal(typeof(DummyHostedService), actual.ImplementationType); 75Assert.Equal(ServiceLifetime.Singleton, actual.Lifetime); 76Assert.Equal(typeof(IHostedService), actual.ServiceType); 77Assert.Equal(typeof(HealthCheckPublisherHostedService), actual.ImplementationType);

HealthCheckPublisherHostedServiceTest.cs (24)

HealthReportTest.cs (2)

30Assert.Equal(status, result.Status); 44Assert.Equal(TimeSpan.FromMilliseconds(milliseconds), result.TotalDuration);

FeatureCollectionExtensionsTests.cs (1)

24Assert.Equal(retrievedThing, thing);

FeatureCollectionTests.cs (6)

20Assert.Equal(thing2, thing); 31Assert.Equal(interfaces[typeof(IThing)], thing); 41Assert.Equal(interfaces[typeof(IThing)], thing); 74Assert.Equal(value, interfaces.Get<int>()); 94Assert.Equal(value, interfaces.Get<int?>()); 104Assert.Equal(thing, interfaces.Get<Thing>());

EmbeddedFileProviderTests.cs (1)

52Assert.Equal(expectedFileLength, fileInfo.Length);

ManifestEmbeddedFileProviderTests.cs (9)

33Assert.Equal(0, jqueryValidate.Length); 40Assert.Equal(0, jqueryMin.Length); 47Assert.Equal(0, siteCss.Length); 70Assert.Equal(0, jqueryValidate.Length); 77Assert.Equal(0, jqueryMin.Length); 84Assert.Equal(0, siteCss.Length); 169Assert.Equal(0, jqueryValidate.Length); 192Assert.Equal(0, jqueryValidate.Length); 443Assert.Equal(0, jqueryValidate.Length);

DependencyInjection\PollyHttpClientBuilderExtensionsTest.cs (14)

PolicyHttpMessageHandlerTest.cs (5)

52Assert.Equal(2, callCount); 97Assert.Equal(2, callCount); 145Assert.Equal(2, callCount); 197Assert.Equal(2, callCount); 267Assert.Equal(2, callCount);

ResourceManagerStringLocalizerTest.cs (4)

53Assert.Equal(expectedCallCount, resourceAssembly.ManifestResourceStreamCallCount); 88Assert.Equal(expectedCallCount, resourceAssembly1.ManifestResourceStreamCallCount); 89Assert.Equal(expectedCallCount, resourceAssembly2.ManifestResourceStreamCallCount); 209Assert.Equal(expectedTries, resourceAssembly.ManifestResourceStreamCallCount);

DefaultObjectPoolTest.cs (3)

53Assert.Equal(17, list.Capacity); 80Assert.Equal(1, r.ResetCallCount); 85Assert.Equal(2, r.ResetCallCount);

SecretManagerTests.cs (1)

352Assert.Equal(UnixFileMode.UserRead | UnixFileMode.UserWrite, File.GetUnixFileMode(secretManager.SecretsFilePath));

SetCommandTest.cs (2)

41Assert.Equal(3, secretStore.Count); 68Assert.Equal(3, secretStore.Count);

DotNetObjectReferenceTest.cs (3)

26Assert.Equal(objectId, objRef.ObjectId); 27Assert.Equal(1, objRef.ObjectId); 42Assert.Equal(objectId1, objectId2);

Infrastructure\ByteArrayJsonConverterTest.cs (3)

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

Infrastructure\DotNetDispatcherTest.cs (13)

95Assert.Equal(123, result.IntVal); 108Assert.Equal(456, result.IntVal); 137Assert.Equal(756, resultDto1.IntVal); 147Assert.Equal(1299, resultDto2.IntVal); 278Assert.Equal(testDTO.IntVal, result.IntVal); 410Assert.Equal(7, task.Result.IntVal); 422Assert.Equal(new[] { 1, 2, 3 }, task.Result); 455Assert.Equal(1235, resultDto.IntVal); 605Assert.Equal(2000, result.SomeDTO.IntVal); 610Assert.Equal(2468, resultDto2.IntVal); 781Assert.Equal(new object[] { "Hello", 2 }, result); 795Assert.Equal(7, value.IntVal); 811v => Assert.Equal(4, v),

Infrastructure\DotNetObjectReferenceJsonConverterTest.cs (2)

86Assert.Equal(objectId, deserialized.ObjectId); 127Assert.Equal(objectId, deserialized.ObjectId);

Infrastructure\JSStreamReferenceJsonConverterTest.cs (2)

89Assert.Equal(expectedLength, deserialized?.Length); 105Assert.Equal(expectedLength, deserialized?.Length);

JSInProcessRuntimeTest.cs (1)

24Assert.Equal(123, syncResult.IntValue);

JSObjectReferenceTest.cs (2)

22Assert.Equal(1, jsRuntime.BeginInvokeJSInvocationCount); 36Assert.Equal(1, jsRuntime.InvokeJSInvocationCount);

JSRuntimeExtensionsTest.cs (2)

21Assert.Equal(expected, args); 45Assert.Equal(expected, args);

JSRuntimeTest.cs (4)

145Assert.Equal(10, poco.Id); 168Assert.Equal(10, poco.Id); 310Assert.Equal(invocation, error.InvocationInfo); 403Assert.Equal(i, runtime.BeginTransmittingStream(streamRef));

CacheControlHeaderValueTest.cs (15)

36Assert.Equal(timeSpan, cacheControl.MaxAge); 38Assert.Equal(timeSpan, cacheControl.SharedMaxAge); 40Assert.Equal(timeSpan, cacheControl.MaxStaleLimit); 42Assert.Equal(timeSpan, cacheControl.MinFresh); 49Assert.Equal(1, cacheControl.NoCacheHeaders.Count); 50Assert.Equal("PLACEHOLDER", cacheControl.NoCacheHeaders.First()); 56Assert.Equal(1, cacheControl.PrivateHeaders.Count); 57Assert.Equal("PLACEHOLDER", cacheControl.PrivateHeaders.First()); 63Assert.Equal(1, cacheControl.Extensions.Count); 64Assert.Equal(new NameValueHeaderValue("name", "value"), cacheControl.Extensions.First()); 553Assert.Equal(x.GetHashCode(), y.GetHashCode()); 563Assert.Equal(areEqual, x.Equals(y)); 564Assert.Equal(areEqual, y.Equals(x)); 570Assert.Equal(expectedResult, result); 581Assert.Equal(expectedResult, result);

ContentDispositionHeaderValueTest.cs (85)

ContentRangeHeaderValueTest.cs (15)

21Assert.Equal("bytes", range.Unit); 24Assert.Equal(5, range.Length); 42Assert.Equal("bytes", range.Unit); 43Assert.Equal(0, range.From); 44Assert.Equal(1, range.To); 66Assert.Equal("bytes", range.Unit); 67Assert.Equal(0, range.From); 68Assert.Equal(1, range.To); 69Assert.Equal(2, range.Length); 77Assert.Equal("myunit", range.Unit); 114Assert.Equal(range1.GetHashCode(), range4.GetHashCode()); 159Assert.Equal("bytes", result.Unit); 190Assert.Equal("bytes", result.Unit); 210Assert.Equal(expectedResult, result); 216Assert.Equal(expectedResult, result);

CookieHeaderValueTest.cs (15)

DateParserTest.cs (2)

15Assert.Equal(expected, result); 31Assert.Equal(new DateTimeOffset(), result);

EntityTagHeaderValueTest.cs (14)

HeaderUtilitiesTest.cs (14)

MediaTypeHeaderValueComparerTests.cs (1)

68Assert.Equal(expectedSortedValues, actualSorted);

MediaTypeHeaderValueTest.cs (57)

NameValueHeaderValueTest.cs (27)

RangeConditionHeaderValueTest.cs (7)

12Assert.Equal(new EntityTagHeaderValue("\"x\""), rangeCondition.EntityTag); 23Assert.Equal(new EntityTagHeaderValue("\"y\""), rangeCondition.EntityTag); 35Assert.Equal(new DateTimeOffset(2010, 7, 15, 12, 33, 57, TimeSpan.Zero), rangeCondition.LastModified); 62Assert.Equal(rangeCondition1.GetHashCode(), rangeCondition2.GetHashCode()); 65Assert.Equal(rangeCondition3.GetHashCode(), rangeCondition5.GetHashCode()); 158Assert.Equal(expectedResult, result); 164Assert.Equal(expectedResult, result);

RangeHeaderValueTest.cs (5)

19Assert.Equal("myunit", range.Unit); 56Assert.Equal(range1.GetHashCode(), range2.GetHashCode()); 60Assert.Equal(range5.GetHashCode(), range6.GetHashCode()); 155Assert.Equal(expectedResult, result); 166Assert.Equal(expectedResult, result);

RangeItemHeaderValueTest.cs (8)

36Assert.Equal(1, rangeItem.From); 37Assert.Equal(2, rangeItem.To); 66Assert.Equal(rangeItem1.GetHashCode(), rangeItem5.GetHashCode()); 138Assert.Equal(expectedFrom, range.From); 139Assert.Equal(expectedTo, range.To); 148Assert.Equal(expectedRanges.Length, ranges.Length); 152Assert.Equal(expectedRanges[i].Item1, ranges[i].From); 153Assert.Equal(expectedRanges[i].Item2, ranges[i].To);

SetCookieHeaderValueTest.cs (16)

321Assert.Equal("cookie", header.Name); 322Assert.Equal(string.Empty, header.Value); 332Assert.Equal(name, header.Name); 333Assert.Equal(value, header.Value); 340Assert.Equal(string.Empty, cookie.Value); 343Assert.Equal("value1", cookie.Value); 370Assert.Equal(cookie, header); 380Assert.Equal(cookie, header); 404Assert.Equal(cookies, results); 414Assert.Equal(cookies, results); 426Assert.Equal(setCookieHeaderValue1, setCookieHeaderValue2); 435Assert.Equal(cookies, results); 445Assert.Equal(cookies, results); 454Assert.Equal(cookies ?? new List<SetCookieHeaderValue>(), results); 462Assert.Equal(cookies, results); 463Assert.Equal(cookies?.Count > 0, result);

StringWithQualityHeaderValueTest.cs (14)

InsertOrAppendAttributeTests.cs (8)

21Assert.Equal(2, doc.ChildNodes.Count); 24Assert.Equal(2, configurationNode.ChildNodes.Count); 45Assert.Equal(2, doc.ChildNodes.Count); 48Assert.Equal(2, configurationNode.ChildNodes.Count); 69Assert.Equal(2, doc.ChildNodes.Count); 72Assert.Equal(2, configurationNode.ChildNodes.Count); 93Assert.Equal(2, doc.ChildNodes.Count); 96Assert.Equal(2, configurationNode.ChildNodes.Count);

CodeAnalysisExtensionsTest.cs (15)

ActualApiResponseMetadataFactoryTest.cs (12)

34Assert.Equal(412, actual); 48Assert.Equal(302, actual); 101Assert.Equal(401, metadata.Value.StatusCode); 129Assert.Equal(201, metadata.Value.StatusCode); 143Assert.Equal(204, metadata.Value.StatusCode); 157Assert.Equal(302, metadata.Value.StatusCode); 171Assert.Equal(422, metadata.Value.StatusCode); 185Assert.Equal(423, metadata.Value.StatusCode); 214Assert.Equal(400, metadata.Value.StatusCode); 290Assert.Equal(200, metadata.StatusCode); 331Assert.Equal(204, metadata.StatusCode); 358Assert.Equal(200, metadata.StatusCode);

SymbolApiResponseMetadataProviderTest.cs (14)

HelloWorldTest.cs (1)

155Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);

NtlmAuthenticationTest.cs (4)

69Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); 82Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); 92Assert.Equal(HttpStatusCode.OK, response.StatusCode); 97Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);

ResponseCompressionTests.cs (2)

175Assert.Equal(0, response.Content.Headers.ContentEncoding.Count); 207Assert.Equal(1, response.Content.Headers.ContentEncoding.Count);

SocketTransportOptionsTests.cs (1)

80Assert.Equal(fileHandleSocket.LocalEndPoint, listenSocket.LocalEndPoint);

src\Servers\Kestrel\test\BindTests\AddressRegistrationTests.cs (8)

520Assert.Equal(5000, host.GetPort()); 559Assert.Equal(0, LogMessages.Count(log => log.LogLevel == LogLevel.Critical && 594Assert.Equal(0, LogMessages.Count(log => log.LogLevel == LogLevel.Critical && 633Assert.Equal(1, serverAddresses.Count); 678Assert.Equal(1, serverAddresses.Count); 718Assert.Equal(1, serverAddresses.Count); 921Assert.Equal(expected, capturedOptions.OptionsInUse[0].Protocols); 987Assert.Equal(0, LogMessages.Count(log => log.LogLevel == LogLevel.Critical &&

SocketTransportTests.cs (3)

39Assert.Equal(ProtocolType.Tcp, socket.ProtocolType); 41Assert.Equal(ip.Address, context.Connection.RemoteIpAddress); 42Assert.Equal(ip.Port, context.Connection.RemotePort);

src\Servers\Kestrel\shared\test\StreamExtensions.cs (1)

28Assert.Equal(0, await stream.ReadAsync(new byte[1], 0, 1, cancellationToken));

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

155Assert.Equal(data.Length, bytesWritten);

src\Servers\Kestrel\test\FunctionalTests\RequestTests.cs (3)

664Assert.Equal(beforeAbort.Value, afterAbort.Value); 704Assert.Equal(0, result); 912Assert.Equal(2, abortedRequestId);

src\Servers\Kestrel\test\FunctionalTests\ResponseTests.cs (9)

97Assert.Equal(total % 256, bytes[i]); 346Assert.Equal(1, TestSink.Writes.Count(w => w.EventId.Name == "ConnectionStop")); 903Assert.Equal(0, TestSink.Writes.Count(w => w.EventId.Name == "ResponseMinimumDataRateNotSatisfied")); 904Assert.Equal(1, TestSink.Writes.Count(w => w.EventId.Name == "ConnectionStop")); 988Assert.Equal(0, TestSink.Writes.Count(w => w.EventId.Name == "ResponseMinimumDataRateNotSatisfied")); 989Assert.Equal(1, TestSink.Writes.Count(w => w.EventId.Name == "ConnectionStop")); 1063Assert.Equal(0, TestSink.Writes.Count(w => w.EventId.Name == "ResponseMinimumDataRateNotSatisfied")); 1064Assert.Equal(1, TestSink.Writes.Count(w => w.EventId.Name == "ConnectionStop")); 1138Assert.Equal(expectedBytes, totalReceived);

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

116Assert.Equal(data, buffer); 191Assert.Equal(StatusCodes.Status200OK, httpStatus);

WSTrustChannelFactoryTest.cs (1)

21Assert.Equal(typeof(ArgumentNullException), ex.GetType());

WSTrustChannelSecurityTokenProviderTest.cs (1)

73Assert.Equal(2, trustRequest.AdditionalXmlElements.Count);

WSTrustChannelTest.cs (1)

21Assert.Equal(typeof(ArgumentNullException), ex.GetType());

Channels\HttpRequestMessagePropertyTest.cs (2)

43Assert.Equal<bool>(original.SuppressEntityBody, copy.SuppressEntityBody); 44Assert.Equal<int>(original.Headers.Count, copy.Headers.Count);

ServiceModel\BasicHttpBindingTest.cs (45)

ServiceModel\BasicHttpsBindingTest.cs (32)

NetNamedPipeBindingTest.cs (2)

26Assert.Equal(45, result.Length); 32Assert.Equal(61, result.Length);

Channels\TcpConnectionPoolSettingsTest.cs (3)

43Assert.Equal<TimeSpan>(timeSpan, settings.IdleTimeout); 64Assert.Equal<TimeSpan>(timeSpan, settings.LeaseTimeout); 86Assert.Equal<int>(value, settings.MaxOutboundConnectionsPerEndpoint);

ServiceModel\NetTcpBindingTest.cs (10)

21Assert.Equal<EnvelopeVersion>(EnvelopeVersion.Soap12, binding.EnvelopeVersion); 22Assert.Equal<long>(512 * 1024, binding.MaxBufferPoolSize); 23Assert.Equal<long>(65536, binding.MaxBufferSize); 26Assert.Equal<TransferMode>(TransferMode.Buffered, binding.TransferMode); 27Assert.Equal<SecurityMode>(securityMode, binding.Security.Mode); 39Assert.Equal<TransferMode>(mode, binding.TransferMode); 49Assert.Equal<long>(value, binding.MaxBufferPoolSize); 59Assert.Equal<int>(value, binding.MaxBufferSize); 78Assert.Equal<long>(value, binding.MaxReceivedMessageSize); 96Assert.Equal<NetTcpSecurity>(security, binding.Security);

ServiceModel\NetTcpSecurityTest.cs (3)

18Assert.Equal<SecurityMode>(SecurityMode.Transport, security.Mode); 30Assert.Equal<SecurityMode>(mode, security.Mode); 47Assert.Equal<TcpTransportSecurity>(newSecurity, security.Transport);

ServiceModel\TcpTransportSecurityTest.cs (1)

31Assert.Equal<TcpClientCredentialType>(credentialType, transport.ClientCredentialType);

Channels\BinaryMessageEncodingBindingElementTest.cs (10)

20Assert.Equal<CompressionFormat>(CompressionFormat.None, bindingElement.CompressionFormat); 21Assert.Equal<int>(2048, bindingElement.MaxSessionSize); 22Assert.Equal<MessageVersion>(MessageVersion.Default, bindingElement.MessageVersion); 35Assert.Equal(format, bindingElement.CompressionFormat); 49Assert.Equal<int>(value, bindingElement.MaxSessionSize); 67Assert.Equal<MessageVersion>(version, bindingElement.MessageVersion); 90Assert.Equal<int>(value, bindingElement.MaxReadPoolSize); 100Assert.Equal<int>(value, bindingElement.MaxReadPoolSize); 117Assert.Equal<int>(value, bindingElement.MaxWritePoolSize); 127Assert.Equal<int>(value, bindingElement.MaxWritePoolSize);

Channels\MessageTest.cs (7)

20Assert.Equal<EnvelopeVersion>(envelopeVersion, messageVersion.Envelope); 21Assert.Equal<AddressingVersion>(addressingVersion, messageVersion.Addressing); 28Assert.Equal<MessageVersion>(MessageVersion.Soap12WSAddressing10, message.Version); 40Assert.Equal<MessageVersion>(MessageVersion.Soap12WSAddressing10, message.Version); 55Assert.Equal<MessageVersion>(MessageVersion.Soap12WSAddressing10, message.Version); 90Assert.Equal(MessageVersion.Soap12WSAddressing10, message.Version); 100Assert.Equal(MessageVersion.Soap12WSAddressing10, message.Version);

Channels\TextMessageEncodingBindingElementTest.cs (3)

20Assert.Equal<Encoding>(Encoding.UTF8, element.WriteEncoding); 29Assert.Equal<Encoding>(encoding, element.WriteEncoding); 46Assert.Equal<MessageVersion>(messageVersion, element.MessageVersion);

Channels\TransportBindingElementTest.cs (2)

17Assert.Equal(512 * 1024, element.MaxBufferPoolSize); 20Assert.Equal(1024, element.MaxBufferPoolSize);

Channels\UnderstoodHeadersTest.cs (2)

46Assert.Equal(3, numUnderstoodHeaders); 74Assert.Equal(0, numUnderstoodHeaders);

Description\ContractDescriptionTest.cs (10)

Security\securityKeyTest.cs (1)

17Assert.Equal(int.MaxValue, msk.KeySize);

ServiceModel\ChannelFactoryTest.cs (7)

148Assert.Equal(CommunicationState.Created, factory.State); 154Assert.Equal(CommunicationState.Opened, factory.State); 162Assert.Equal(CommunicationState.Closed, factory.State); 170Assert.Equal(CommunicationState.Closed, factory.State); 174Assert.Equal(CommunicationState.Closed, factory.State); 288Assert.Equal(CommunicationState.Closed, factory.State); 317Assert.Equal(CommunicationState.Closed, factory.State);

ServiceModel\ClientBaseTest.cs (15)

23Assert.Equal(CommunicationState.Created, client.State); 25Assert.Equal(CommunicationState.Opened, client.State); 27Assert.Equal(CommunicationState.Closed, client.State); 33Assert.Equal(CacheSetting.Default, MyClientBase.CacheSetting); 52Assert.Equal(CacheSetting.Default, MyClientBase.CacheSetting); 81Assert.Equal(client1.ChannelFactory, client2.ChannelFactory); 85Assert.Equal(client1.ChannelFactory, client3.ChannelFactory); 112Assert.Equal(client1.ChannelFactory, client2.ChannelFactory); 125Assert.Equal(CommunicationState.Closed, existingChannelFactory.State); 184Assert.Equal(CommunicationState.Created, client.State); 186Assert.Equal(CommunicationState.Opened, client.State); 188Assert.Equal(CommunicationState.Closed, client.State); 202Assert.Equal(CommunicationState.Created, client.State); 204Assert.Equal(CommunicationState.Opened, client.State); 206Assert.Equal(CommunicationState.Closed, client.State);

ServiceModel\DuplexClientBaseTest.cs (4)

23Assert.Equal<EndpointAddress>(endpoint, duplexClientBase.Endpoint.Address); 24Assert.Equal<CommunicationState>(CommunicationState.Created, duplexClientBase.State); 37Assert.Equal<CommunicationState>(CommunicationState.Created, duplexClientBase.State); 39Assert.Equal<CommunicationState>(CommunicationState.Closed, duplexClientBase.State);

ServiceModel\FaultExceptionTest.cs (9)

26Assert.Equal(detail, exception.Detail); 27Assert.Equal(reason, exception.Reason); 113Assert.Equal(reason, exception.Reason); 115Assert.Equal(code, exception.Code); 136Assert.Equal(detail, exception.Detail); 162Assert.Equal(detail, exception.Detail); 165Assert.Equal(code, exception.Code); 191Assert.Equal(detail, exception.Detail); 194Assert.Equal(code, exception.Code);

ServiceModel\MessageContractTest.4.4.0.cs (1)

24Assert.Equal(mustUnderstand, attribute.MustUnderstand);

ServiceModel\MessageContractTest.cs (2)

34Assert.Equal(isWrapped, messageCA.IsWrapped); 83Assert.Equal(mustUnderstand, attribute.MustUnderstand);

ServiceModel\UnixDomainSocketBindingTest.cs (10)

22Assert.Equal<EnvelopeVersion>(EnvelopeVersion.Soap12, binding.EnvelopeVersion); 23Assert.Equal<long>(512 * 1024, binding.MaxBufferPoolSize); 24Assert.Equal<long>(65536, binding.MaxBufferSize); 27Assert.Equal<TransferMode>(TransferMode.Buffered, binding.TransferMode); 28Assert.Equal<UnixDomainSocketSecurityMode>(securityMode, binding.Security.Mode); 40Assert.Equal<TransferMode>(mode, binding.TransferMode); 50Assert.Equal<long>(value, binding.MaxBufferPoolSize); 60Assert.Equal<int>(value, binding.MaxBufferSize); 79Assert.Equal<long>(value, binding.MaxReceivedMessageSize); 97Assert.Equal<UnixDomainSocketSecurity>(security, binding.Security);

ServiceModel\UnixDomainSocketSecurityTest.cs (3)

20Assert.Equal<UnixDomainSocketSecurityMode>(mode, security.Mode); 30Assert.Equal<UnixDomainSocketSecurityMode>(mode, security.Mode); 47Assert.Equal<UnixDomainSocketTransportSecurity>(newSecurity, security.Transport);

ServiceModel\UnixDomainSocketTransportSecurityTest.cs (1)

33Assert.Equal<UnixDomainSocketClientCredentialType>(credentialType, transport.ClientCredentialType);

System\Windows\Markup\AcceptedMarkupExtensionExpressionTypeAttributeTests.cs (1)

20Assert.Equal(type, attribute.Type);

System\Windows\Markup\ArrayExtensionTests.cs (8)

28Assert.Equal(type, extension.Type); 56Assert.Equal(expectedType, extension.Type); 59Assert.Equal(elements, extension.Items); 82Assert.Equal(value, Assert.Single(extension.Items)); 93Assert.Equal(text, Assert.Single(extension.Items)); 102Assert.Equal(new object[] { 1, 2 }, extension.ProvideValue(null)); 129Assert.Equal(value, extension.Type); 133Assert.Equal(value, extension.Type);

System\Windows\Markup\ContentWrapperAttributeTests.cs (4)

18Assert.Equal(contentWrapper, attribute.ContentWrapper); 39Assert.Equal(expected, attribute.Equals(other)); 46Assert.Equal(typeof(int).GetHashCode(), attribute.GetHashCode()); 53Assert.Equal(0, attribute.GetHashCode());

System\Windows\Markup\DateTimeValueSerializerTests.cs (2)

25Assert.Equal(expected, serializer.CanConvertToString(value, null)); 77Assert.Equal(expected, serializer.ConvertFromString(value, null));

System\Windows\Markup\MarkupExtensionBracketCharactersAttributeTests.cs (2)

17Assert.Equal(openingBracket, attribute.OpeningBracket); 18Assert.Equal(closingBracket, attribute.ClosingBracket);

System\Windows\Markup\MarkupExtensionReturnTypeAttributeTests.cs (3)

27Assert.Equal(returnType, attribute.ReturnType); 37Assert.Equal(returnType, attribute.ReturnType); 38Assert.Equal(expressionType, attribute.ExpressionType);

System\Windows\Markup\NameReferenceConverterTests.cs (13)

25Assert.Equal(expected, converter.CanConvertFrom(type)); 36Assert.Equal(typeof(IXamlNameResolver), serviceType); 44Assert.Equal("resolve", converter.ConvertFrom(context, null, "name")); 57Assert.Equal(typeof(IXamlNameResolver), serviceType); 65Assert.Equal(fixup, converter.ConvertFrom(context, null, "name")); 83Assert.Equal(typeof(IXamlNameResolver), serviceType); 98Assert.Equal(typeof(IXamlNameResolver), serviceType); 116Assert.Equal(typeof(IXamlNameResolver), serviceType); 137Assert.Equal(expected, converter.CanConvertTo(context, destinationType)); 150Assert.Equal(typeof(IXamlNameProvider), serviceType); 157Assert.Equal(name, converter.ConvertTo(context, null, "value", null)); 175Assert.Equal(typeof(IXamlNameProvider), serviceType); 190Assert.Equal(typeof(IXamlNameProvider), serviceType);

System\Windows\Markup\NameScopePropertyAttributeTests.cs (1)

30Assert.Equal(type, attribute.Type);

System\Windows\Markup\ReferenceTests.cs (2)

43Assert.Equal("resolve", reference.ProvideValue(provider)); 61Assert.Equal(fixup, reference.ProvideValue(provider));

System\Windows\Markup\StaticExtensionTests.cs (8)

47Assert.Equal(expected, extension.ProvideValue(null)); 65Assert.Equal(expected, extension.ProvideValue(provider)); 75Assert.Equal(ConsoleColor.Red, extension.ProvideValue(null)); 89Assert.Equal(ConsoleColor.Red, extension.ProvideValue(provider)); 190Assert.Equal(value, extension.MemberType); 209Assert.Equal(expected, converter.CanConvertTo(type)); 219Assert.Equal(new string[] { "member" }, descriptor.Arguments); 228Assert.Equal(extension.ToString(), converter.ConvertTo(extension, typeof(string)));

System\Windows\Markup\StringValueSerializerTests.cs (2)

31Assert.Equal(value, serializer.ConvertToString(value, null)); 47Assert.Equal(value, serializer.ConvertFromString(value, null));

System\Windows\Markup\TypeExtensionTests.cs (8)

45Assert.Equal(type, extension.Type); 59Assert.Equal(typeof(int), extension.ProvideValue(null)); 77Assert.Equal(typeof(int), extension.ProvideValue(provider)); 78Assert.Equal(typeof(int), extension.Type); 151Assert.Equal(value, extension.Type); 171Assert.Equal(expected, converter.CanConvertTo(type)); 181Assert.Equal(new Type[] { typeof(int) }, descriptor.Arguments); 190Assert.Equal(extension.ToString(), converter.ConvertTo(extension, typeof(string)));

System\Windows\Markup\UsableDuringInitializationAttributeTests.cs (1)

17Assert.Equal(usable, attribute.Usable);

System\Windows\Markup\ValueSerializerTests.cs (3)

179Assert.Equal("1", serializer.ConvertFromString("1", null)); 464Assert.Equal(typeof(string), sourceType); 470Assert.Equal(typeof(string), sourceType);

System\Windows\Markup\XamlDeferLoadAttributeTests.cs (2)

18Assert.Equal(loaderType, attribute.LoaderType); 20Assert.Equal(contentType, attribute.ContentType);

System\Windows\Markup\XamlSetMarkupExtensionEventArgsTests.cs (4)

25Assert.Equal(member, e.Member); 26Assert.Equal(value, e.Value); 27Assert.Equal(value, e.MarkupExtension); 28Assert.Equal(serviceProvider, e.ServiceProvider);

System\Windows\Markup\XamlSetTypeConverterEventArgsTests.cs (5)

27Assert.Equal(member, e.Member); 28Assert.Equal(typeConverter, e.TypeConverter); 29Assert.Equal(value, e.Value); 30Assert.Equal(serviceProvider, e.ServiceProvider); 31Assert.Equal(cultureInfo, e.CultureInfo);

System\Windows\Markup\XamlSetValueEventArgsTests.cs (2)

25Assert.Equal(member, e.Member); 26Assert.Equal(value, e.Value);

BlazorWasmTemplateTest.cs (1)

380Assert.Equal(5, await page.Locator("p+table>tbody>tr").CountAsync());

src\ProjectTemplates\Shared\Project.cs (1)

343Assert.Equal(0, iisSslPort);

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (1)

99Assert.Equal(3, builtPackages.Length);

src\ProjectTemplates\Shared\Project.cs (1)

343Assert.Equal(0, iisSslPort);

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (1)

99Assert.Equal(3, builtPackages.Length);

src\Shared\E2ETesting\WaitAssert.cs (1)

27=> WaitAssertCore(driver, () => Assert.Equal(expected, actual()));

src\ProjectTemplates\Shared\Project.cs (1)

343Assert.Equal(0, iisSslPort);

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (1)

99Assert.Equal(3, builtPackages.Length);

src\Shared\E2ETesting\WaitAssert.cs (1)

27=> WaitAssertCore(driver, () => Assert.Equal(expected, actual()));

src\ProjectTemplates\Shared\Project.cs (1)

343Assert.Equal(0, iisSslPort);

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (1)

99Assert.Equal(3, builtPackages.Length);

src\Shared\E2ETesting\WaitAssert.cs (1)

27=> WaitAssertCore(driver, () => Assert.Equal(expected, actual()));

IdentityUIPackageTest.cs (2)

132Assert.Equal(HttpStatusCode.OK, response.StatusCode); 144Assert.Equal(HttpStatusCode.OK, response.StatusCode);

src\ProjectTemplates\Shared\Project.cs (1)

343Assert.Equal(0, iisSslPort);

src\ProjectTemplates\Shared\TemplatePackageInstaller.cs (1)

99Assert.Equal(3, builtPackages.Length);

src\Shared\E2ETesting\WaitAssert.cs (1)

27=> WaitAssertCore(driver, () => Assert.Equal(expected, actual()));

EqualityAsserts.cs (1)

65 Equal<object>(expected, actual);

MemoryAsserts.cs (1)

236 Equal<object>(expectedMemory.Span.ToArray(), actualMemory.Span.ToArray());

SpanAsserts.cs (1)

233 Equal<object>(expectedSpan.ToArray(), actualSpan.ToArray());