29Assert.Equal(HttpStatusCode.OK, response.StatusCode); 40Assert.Equal(HttpStatusCode.Redirect, response.StatusCode); 41Assert.Equal("http://localhost/account/login?ReturnUrl=%2FHome%2FMyClaims", response.Headers.Location.ToString());

28Assert.Equal(HttpStatusCode.OK, response.StatusCode); 39Assert.Equal(HttpStatusCode.OK, response.StatusCode); 40Assert.Equal("http://localhost/account/login?ReturnUrl=%2FHome%2FMyClaims", response.RequestMessage.RequestUri.ToString()); 60Assert.Equal(HttpStatusCode.OK, response.StatusCode); 66Assert.Equal(HttpStatusCode.OK, response.StatusCode); 67Assert.Contains("Log in</button>", content); 74Assert.Equal(HttpStatusCode.OK, response.StatusCode); 75Assert.Contains("<h2>HttpContext.User.Claims</h2>", content); 76Assert.Contains($"<dd>{userName}</dd>", content); // Ensure user name shows up as a claim 91Assert.Equal(HttpStatusCode.OK, signIn.StatusCode);

27Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); 28Assert.Equal(CustomAuthorizationFailureResponse.Startup.CustomForbiddenMessage, content); 37Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); 38Assert.Equal(CustomAuthorizationFailureResponse.Startup.CustomForbiddenMessage, content);

32Assert.Equal(HttpStatusCode.OK, response.StatusCode); 43Assert.Equal(HttpStatusCode.OK, response.StatusCode); 44Assert.Equal("http://localhost/account/signin?ReturnUrl=%2FHome%2FMinimumAge10", response.RequestMessage.RequestUri.ToString()); 52Assert.Equal(HttpStatusCode.OK, signIn.StatusCode); 58Assert.Equal(HttpStatusCode.OK, response.StatusCode); 59Assert.Contains("Welcome, Dude", content); 60Assert.Contains("Welcome to a page restricted to users 10 or older", content); 68Assert.Equal(HttpStatusCode.OK, signIn.StatusCode); 74Assert.Equal(HttpStatusCode.OK, response.StatusCode); 75Assert.Contains("Access Denied: Dude is not authorized to view this page.", content); 83Assert.Equal(HttpStatusCode.OK, signIn.StatusCode); 89Assert.Equal(HttpStatusCode.OK, response.StatusCode); 90Assert.Contains("Welcome, Dude", content); 91Assert.Contains("Welcome to a page restricted to users 50 or older", content); 99Assert.Equal(HttpStatusCode.OK, signIn.StatusCode); 105Assert.Equal(HttpStatusCode.OK, response.StatusCode); 106Assert.Contains("Access Denied: Dude is not authorized to view this page.", content); 117Assert.Equal(HttpStatusCode.OK, response.StatusCode); 118Assert.Equal("http://localhost/account/signin?ReturnUrl=%2FHome%2FMinimumAge50", response.RequestMessage.RequestUri.ToString());

30Assert.Equal(HttpStatusCode.OK, response.StatusCode); 39Assert.Equal(HttpStatusCode.OK, response.StatusCode); 40Assert.Contains("New1", content); 41Assert.Contains("NewOne", content); 45Assert.Equal(HttpStatusCode.OK, response.StatusCode); 46Assert.Contains("New1", content); 47Assert.Contains("NewOne", content); 48Assert.Contains("New2", content); 49Assert.Contains("NewTwo", content); 53Assert.Equal(HttpStatusCode.OK, response.StatusCode); 54Assert.Contains("New1", content); 55Assert.Contains("NewOne", content); 56Assert.Contains("New2", content); 57Assert.DoesNotContain("NewTwo", content); 58Assert.Contains("UpdateTwo", content); 63Assert.Equal(HttpStatusCode.OK, response.StatusCode); 64Assert.DoesNotContain("New1", content); 65Assert.DoesNotContain("NewOne", content); 66Assert.Contains("New2", content); 67Assert.DoesNotContain("NewTwo", content); 68Assert.Contains("UpdateTwo", content); 72Assert.Equal(HttpStatusCode.OK, response.StatusCode); 73Assert.DoesNotContain("New1", content); 74Assert.DoesNotContain("NewOne", content); 75Assert.DoesNotContain("New2", content); 76Assert.DoesNotContain("NewTwo", content); 77Assert.DoesNotContain("UpdateTwo", content);

21var submitElement = Assert.Single(form.QuerySelectorAll("[type=submit]")); 22var submitButton = Assert.IsAssignableFrom<IHtmlElement>(submitElement); 36var element = Assert.IsAssignableFrom<IHtmlInputElement>(form[kvp.Key]);

29Assert.Equal(HttpStatusCode.OK, response.StatusCode); 40Assert.Equal(HttpStatusCode.Redirect, response.StatusCode); 41Assert.Equal("http://localhost/Account/Login?ReturnUrl=%2FMyClaims", response.Headers.Location.ToString());

30Assert.Equal(HttpStatusCode.OK, response.StatusCode); 41Assert.Equal(HttpStatusCode.OK, response.StatusCode); 52Assert.Equal(HttpStatusCode.OK, response.StatusCode); 53Assert.Equal("http://localhost/account/login?ReturnUrl=%2FHome%2FMyClaims", response.RequestMessage.RequestUri.ToString()); 64Assert.Equal(HttpStatusCode.OK, response.StatusCode); 65Assert.Contains("Scheme: Api", content); // expected scheme 66Assert.Contains("Hao", content); // expected name claim 86Assert.Equal(HttpStatusCode.OK, response.StatusCode); 92Assert.Equal(HttpStatusCode.OK, response.StatusCode); 93Assert.DoesNotContain("Logout", content); 100Assert.Equal(HttpStatusCode.OK, response.StatusCode); 101Assert.Contains("<h2>HttpContext.User.Claims (Scheme: Cookies)</h2>", content); 102Assert.Contains($"<dd>{userName}</dd>", content); // Ensure user name shows up as a claim 117Assert.Equal(HttpStatusCode.OK, signIn.StatusCode);

27Assert.Equal(HttpStatusCode.OK, response.StatusCode); 38Assert.Equal(HttpStatusCode.Redirect, response.StatusCode); 39Assert.Equal("http://localhost/Account/Login?ReturnUrl=%2F" + scenario, response.Headers.Location.ToString());

26var form = Assert.Single(document.QuerySelectorAll("form")); 27return Assert.IsAssignableFrom<IHtmlFormElement>(form); 32var element = Assert.Single(document.QuerySelectorAll(selector)); 33return Assert.IsAssignableFrom<IHtmlAnchorElement>(element); 43Assert.NotEmpty(elements); 50var element = Assert.Single(document.QuerySelectorAll(selector)); 51return Assert.IsAssignableFrom<IHtmlElement>(element); 56var form = Assert.Single(document.QuerySelectorAll(selector)); 57return Assert.IsAssignableFrom<IHtmlFormElement>(form); 63var fragment = Assert.Single(new HtmlParser().ParseFragment(htmlMessage, context: null)); 64return Assert.IsAssignableFrom<IHtmlHtmlElement>(fragment); 69Assert.Equal(HttpStatusCode.Redirect, responseMessage.StatusCode); 75Assert.Equal(HttpStatusCode.OK, response.StatusCode); 76Assert.Equal("text/html", response.Content.Headers.ContentType.MediaType); 80return Assert.IsAssignableFrom<IHtmlDocument>(document); 107=> Assert.Equal(HttpStatusCode.OK, download.StatusCode);

34Assert.NotNull(result); 35Assert.Equal(testString, result);

43Assert.Equal(testString, result); 80Assert.NotNull(result); 81Assert.Equal(testString, result);

43Assert.True(result == testString, String.Format("Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 83Assert.True(result, "Error: expected response from service: 'true' Actual was: 'false'"); 127Assert.True(handlerCalled, "Error: expected client to call intercepting handler"); 128Assert.True(result == testString, String.Format("Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 185Assert.True(result == substituteString, String.Format("Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 223Assert.False(expectHeaderSent, "Expect header should not have been sent. Header value:" + expectHeader); 269Assert.True(userAgentHeaderSent, "User-Agent header should have been sent."); 270Assert.Equal(userAgent, userAgentHeader); 308Assert.Throws<FormatException>(() => 353Assert.Equal(result, decompressionEnabled);

35Assert.NotNull(result); 36Assert.Equal(testString, result);

38Assert.True(String.Equals(testString, result), String.Format("Expected result was {0}. Actual was {1}", testString, result)); 62Assert.Throws<PlatformNotSupportedException>(() => 104Assert.NotNull(result); 105Assert.Equal(testString, result);

39Assert.True(asyncFlowDisabled, "Async flow of Operation Context isn't disabled"); 44Assert.Null(OperationContext.Current); 46Assert.NotNull(OperationContext.Current); 50Assert.NotEqual(currentThreadId, Thread.CurrentThread.ManagedThreadId); 51Assert.NotEqual(currentContext, OperationContext.Current); 52Assert.Throws<InvalidOperationException>(() => scope.Dispose());

34Assert.True(result == testString, String.Format("Error: expected response from service: '{0}' Actual was: '{1}'", testString, result));

43Assert.Equal(testString, result); 160Assert.Equal(1, result1); 161Assert.Equal(2, result2); 163Assert.Equal(3, callCount); 234Assert.Equal(2, httpRequestCount); 241Assert.Equal(4, httpRequestCount); 244await Assert.ThrowsAsync<CommunicationException>(() => resultTask); 245Assert.Equal(CommunicationState.Faulted, ((ICommunicationObject)serviceProxy).State); 330Assert.Equal(1, result1); 331Assert.Equal(2, result2); 332Assert.True(secondRequestBlocked); // Captured before releasing the first request 333Assert.True(secondRequestSent); // Validate that header was seen 385Assert.Equal(1, result1); 386Assert.Equal(1, httpRequestCountAfterInactivity); // Captured before releasing the first request

38Assert.Equal(testString, result); 113Assert.Equal(testString, result); 114Assert.Equal(testString, callbackService.LastReceivedEcho);

43Assert.Equal(testString, result); 160Assert.Equal(1, result1); 161Assert.Equal(2, result2); 163Assert.Equal(3, callCount); 234Assert.Equal(2, httpRequestCount); 241Assert.Equal(4, httpRequestCount); 244await Assert.ThrowsAsync<CommunicationException>(() => resultTask); 245Assert.Equal(CommunicationState.Faulted, ((ICommunicationObject)serviceProxy).State); 330Assert.Equal(1, result1); 331Assert.Equal(2, result2); 332Assert.True(secondRequestBlocked); // Captured before releasing the first request 333Assert.True(secondRequestSent); // Validate that header was seen 385Assert.Equal(1, result1); 386Assert.Equal(1, httpRequestCountAfterInactivity); // Captured before releasing the first request

34Assert.Equal(testString, result); 65Assert.Equal(testString, result); 70Assert.Equal(testString, result); 72Assert.Equal(testString, result); 109Assert.Equal(testString, result);

36Assert.Equal(testString, result); 73Assert.Equal(testString, result);

30Assert.Null(OperationContext.Current); 33Assert.NotNull(OperationContext.Current); 37Assert.NotEqual(currentThreadId, Thread.CurrentThread.ManagedThreadId); 38Assert.Equal(currentContext, OperationContext.Current); 65Assert.Null(OperationContext.Current); 68Assert.NotNull(OperationContext.Current); 72Assert.NotEqual(currentThreadId, Thread.CurrentThread.ManagedThreadId); 73Assert.Equal(firstContext, OperationContext.Current); 76Assert.NotEqual(firstContext, OperationContext.Current); 80Assert.NotEqual(currentThreadId, Thread.CurrentThread.ManagedThreadId); 81Assert.Equal(secondContext, OperationContext.Current); 83Assert.Equal(firstContext, OperationContext.Current); 85Assert.Null(OperationContext.Current); 158Assert.False(asyncFlowDisabled, "DisableAsyncFlow should not be set to true"); 160Assert.NotNull(opContext); 163Assert.NotEqual(currentThreadId, Thread.CurrentThread.ManagedThreadId); 164Assert.Equal(opContext, OperationContext.Current);

49Assert.Equal(testString, result); 88Assert.Equal(testString, result); 135Assert.Equal(testString, result); 168Assert.Equal(testString, result); 201Assert.Throws<EndpointNotFoundException>(() => ((IChannel)serviceProxy).Open());

65Assert.Equal(testString, result); 116Assert.Equal(testString, result); 167Assert.Equal(testString, result);

58Assert.Equal(requestMessage.Headers.MessageId.ToString(), replyMessage.Headers.RelatesTo.ToString()); 64Assert.Equal(expectedResponse, actualResponse); 115Assert.Equal(requestMessage.Headers.MessageId.ToString(), replyMessage.Headers.RelatesTo.ToString()); 121Assert.Equal(expectedResponse, actualResponse); 155Assert.True(imp.MyManualResetEvent.WaitOne(20000)); 156Assert.Equal(1, imp.Counter); 184Assert.True(imp.ManualResetEvent.WaitOne(20000)); 185Assert.Equal(2, imp.Counter);

57Assert.True(String.Equals(expectedMessageID, actualMessageID), String.Format("Expected Message ID was {0}. Actual was {1}", expectedMessageID, actualMessageID)); 63Assert.Equal(expectedResponse, actualResponse); 115Assert.Equal(requestMessage.Headers.MessageId.ToString(), replyMessage.Headers.RelatesTo.ToString()); 121Assert.Equal(expectedResponse, actualResponse);

61Assert.Equal(guid, returnedGuid); 62Assert.Same(syncCtx, callbackSyncContext); 64Assert.True(syncCtxTask.Wait(ScenarioTestHelpers.TestTimeout)); 125Assert.Equal(guid, returnedGuid); 126Assert.Same(syncCtx, callbackSyncContext); 128Assert.True(syncCtxTask.Wait(ScenarioTestHelpers.TestTimeout)); 155Assert.True(success, "Test Scenario: TypedProxy_AsyncBeginEnd_Call_WithSingleThreadedSyncContext timed out"); 164Assert.IsType<TestTypes.SingleThreadSynchronizationContext>(SynchronizationContext.Current); 196Assert.Equal(guid, returnedGuid); 197Assert.Null(callbackSyncContext); 220Assert.True(success, "Test Scenario: TypedProxy_AsyncBeginEnd_Call_WithSingleThreadedSyncContext timed out"); 229Assert.IsType<TestTypes.SingleThreadSynchronizationContext>(SynchronizationContext.Current); 242Assert.Equal(testString, result);

59Assert.Equal(expectedResponse, actualResponse); 109Assert.Equal(action + "Response", replyMessageAction); 114Assert.Equal(expectedResponse, actualResponse); 167Assert.Equal(expectedResponse, actualResponse); 219Assert.Equal(action + "Response", replyMessageAction); 224Assert.Equal(expectedResponse, actualResponse);

56Assert.Equal(expectedResponse, actualResponse);

41Assert.True(String.Equals(echoText, result), 90Assert.True(String.Equals(expected, actual), 94Assert.True(String.Equals(expected, actual), 144Assert.True(String.Equals(expected, actual), 148Assert.True(String.Equals(expected, actual), 195Assert.True(eventsCalled.Count == 0, 199Assert.True(proxyEventsCalled.Count == 0, 245Assert.True(CommunicationState.Closed == client.State, 249Assert.True(CommunicationState.Closed == ((ICommunicationObject)serviceProxy).State, 253Assert.True(CommunicationState.Closed == factory.State,

38Assert.NotNull(property); 39Assert.True(property.SuppressEntityBody == false, "Expected SuppressEntityBody to be 'false'"); 40Assert.Equal("POST", property.Method); 41Assert.Equal("My%20address", property.QueryString); 42Assert.True(property.Headers.Count > 0, "TestHttpRequestMessageProperty.Headers should not have empty headers"); 43Assert.Equal("my value", property.Headers["customer"]); 85Assert.NotNull(property); 86Assert.True(property.SuppressEntityBody == false, "Expected SuppressEntityBody to be 'false'"); 87Assert.Equal("POST", property.Method); 88Assert.Equal("My%20address", property.QueryString); 89Assert.True(property.Headers.Count > 0, "TestHttpRequestMessageProperty.Headers should not have empty headers"); 90Assert.Equal("my value", property.Headers["customer"]); 133Assert.Equal("Hello", result); 134Assert.True(data.BeforeSendRequestCalled, "BeforeSendRequest should have been called"); 135Assert.True(data.Request != null, "Did not call pass Request to BeforeSendRequest"); 136Assert.True(data.Channel != null, "Did not call pass Channel to BeforeSendRequest"); 137Assert.True(data.AfterReceiveReplyCalled, "AfterReceiveReplyCalled should have been called"); 138Assert.True(data.Reply != null, "Did not call pass Reply to AfterReceiveReplyCalled"); 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); 219Assert.True(CommunicationState.Created == client.State, 222Assert.True(CommunicationState.Created == factory.State, 241Assert.True(CommunicationState.Opened == client.State, 244Assert.True(CommunicationState.Opened == factory.State, 247Assert.True(CommunicationState.Opened == ((ICommunicationObject)serviceProxy).State, 256Assert.True(CommunicationState.Closed == client.State, 260Assert.True(CommunicationState.Closed == ((ICommunicationObject)serviceProxy).State, 264Assert.True(CommunicationState.Closed == factory.State, 294Assert.True(CommunicationState.Created == client.State, 297Assert.True(CommunicationState.Created == factory.State, 317Assert.True(CommunicationState.Opened == client.State, 320Assert.True(CommunicationState.Opened == factory.State, 323Assert.True(CommunicationState.Opened == ((ICommunicationObject)serviceProxy).State, 333Assert.True(CommunicationState.Closed == client.State, 337Assert.True(CommunicationState.Closed == ((ICommunicationObject)serviceProxy).State, 341Assert.True(CommunicationState.Closed == factory.State, 373Assert.True(CommunicationState.Created == client.State, 376Assert.True(CommunicationState.Created == factory.State, 396Assert.True(CommunicationState.Opened == client.State, 399Assert.True(CommunicationState.Opened == factory.State, 402Assert.True(CommunicationState.Opened == ((ICommunicationObject)serviceProxy).State, 412Assert.True(CommunicationState.Closed == client.State, 416Assert.True(CommunicationState.Closed == ((ICommunicationObject)serviceProxy).State, 420Assert.True(CommunicationState.Closed == factory.State, 462Assert.True(CommunicationState.Closed == client.State, 466Assert.True(CommunicationState.Closed == ((ICommunicationObject)serviceProxy).State, 470Assert.True(CommunicationState.Closed == factory.State, 513Assert.True(CommunicationState.Closed == client.State, 517Assert.True(CommunicationState.Closed == ((ICommunicationObject)serviceProxy).State, 521Assert.True(CommunicationState.Closed == factory.State, 565Assert.True(String.Equals(expected, actual), 569Assert.True(String.Equals(expected, actual), 619Assert.True(String.Equals(expected, actual), 623Assert.True(String.Equals(expected, actual), 668Assert.True(eventsCalled.Count == 0, 672Assert.True(proxyEventsCalled.Count == 0, 708Assert.Equal("Hello", result); 743Assert.Equal("Hello", result); 790Assert.Equal(customHeaderValue, result); 799Assert.True(string.Empty == outofScopeResult, string.Format("Expect call out of the OperationContextScope does not have the custom header {0}", customHeaderName));

30Assert.True(cookieManager != null, "cookieManager was null."); 31Assert.True(cookieManager.CookieContainer != null, "cookieManager.CookieContainer was null."); 43Assert.True(cookieSentOut == cookieSentBack, 73Assert.True(cookieManager != null, "cookieManager was null."); 74Assert.True(cookieManager.CookieContainer != null, "cookieManager.CookieContainer was null."); 86Assert.True(cookies != null, "cookies was null."); 89Assert.True(cookie != null, "cookie was null."); 94Assert.True(timeReturned != null, "timeReturned != null"); 95Assert.True(timeSetInCookie != null, "timeSetInCookie != null"); 96Assert.True(timeReturned == timeSetInCookie,

38Assert.True(clientCredentials != null, "ClientCredentials should not be null"); 39Assert.True(clientCredentials.ClientCertificate != null, "ClientCredentials.ClientCertificate should not be null"); 40Assert.True(clientCredentials.ServiceCertificate != null, "ClientCredentials.ServiceCertificate should not be null"); 41Assert.True(clientCredentials.HttpDigest != null, "ClientCredentials.HttpDigest should not be null");

33var exception = Assert.Throws<InvalidOperationException>(() => 41Assert.Contains("BasicHttpBinding", exception.Message); 43Assert.Throws<CommunicationObjectFaultedException>(() => 86Assert.True(guid == returnedGuid,

47Assert.True(String.Equals(result1.Result, expectedErrorDescription), String.Format("Expected Error Description: {0}/Actual Error Description: {1}", expectedErrorDescription, result2.Result)); 49Assert.True(returnedErrorCode.Equals(TestTypes.ErrorCode.UserNotAuthenticated), String.Format("Expected Error Code: {0}/nActual Error Code: {1}", TestTypes.ErrorCode.UserNotAuthenticated, returnedErrorCode)); 50Assert.True(result1.HttpStatusCode.Equals(System.Net.HttpStatusCode.Unauthorized), String.Format("Expected HttpStatusCode: {0}/nActual HttpStatusCode: {1}", System.Net.HttpStatusCode.Unauthorized, result2.HttpStatusCode)); 54Assert.True(String.Equals(result2.Result, expectedErrorDescription), String.Format("Expected Error Description: {0}/nActual Error Description: {1}", expectedErrorDescription, result2.Result)); 56Assert.True(returnedErrorCode.Equals(TestTypes.ErrorCode.Ok), String.Format("Expected Error Code: {0}/nActual Error Code: {1}", TestTypes.ErrorCode.Ok, returnedErrorCode)); 57Assert.True(result2.HttpStatusCode.Equals(System.Net.HttpStatusCode.OK), String.Format("Expected HttpStatusCode: {0}/nActual HttpStatusCode: {1}", System.Net.HttpStatusCode.OK, result2.HttpStatusCode)); 96Assert.True(String.Equals(authorizationHeaderValue, accessToken), String.Format("Expected Authorization Header value: {0}/nActual Authorization Header value: {1}", accessToken, authorizationHeaderValue)); 97Assert.True(String.Equals(authTypeHeaderValue, authType.ToString()), String.Format("Expected AuthType Header value: {0}/nActual AuthType Header value: {1}", authType.ToString(), authTypeHeaderValue)); 101Assert.Fail(String.Format("One or both of the expected headers were not found.\nHeader: \"authType\" had value: {0}\nHeader: \"HttpRequestHeader.Authorization\" had value: {1}", authorizationHeaderValue, authTypeHeaderValue));

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); 86Assert.NotEqual(sessionId1, sessionId2); 107Assert.Throws<InvalidOperationException>(() => 131Assert.Throws<InvalidOperationException>(() => 155Assert.Throws<InvalidOperationException>(() => 190Assert.Fail("channel.MethodCTerminating() should throw, but it didn't."); 202Assert.Fail($"channel.MethodCTerminating() threw unexpected exception: {e}"); 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); 441Assert.Throws<CommunicationException>(() => 474Assert.True(e is CommunicationException); 542Assert.Equal(1, result2); 555Assert.True(e is ExpectedException); 558Assert.Equal(cbClosedCalled, s_duplexCallback.ClosedCalled); 559Assert.Equal(cbClosingCalled, s_duplexCallback.ClosingCalled); 560Assert.Equal(cbFaultedCalled, s_duplexCallback.FaultedCalled);

55Assert.Null(response); 76Assert.True(serviceProxy2.GetResult(includeExceptionDetailInFaults));

28ActionNotSupportedException exception = Assert.Throws<ActionNotSupportedException>(() => 49Assert.True(String.Equals(exception.Message, exceptionMsg), String.Format("Expected exception message: {0}\nActual exception message: {1}", exceptionMsg, exception.Message)); 68TimeoutException exception = Assert.Throws<TimeoutException>(() => 96Assert.True((watch.ElapsedMilliseconds >= lowRange && watch.ElapsedMilliseconds <= highRange), 115TimeoutException exception = Assert.Throws<TimeoutException>(() => 143Assert.True((watch.ElapsedMilliseconds >= lowRange && watch.ElapsedMilliseconds <= highRange), 158FaultException<FaultDetail> exception = Assert.Throws<FaultException<FaultDetail>>(() => 179Assert.True(String.Equals(exception.Detail.Message, faultMsg), String.Format("Expected fault message: {0}\nActual fault message: {1}", faultMsg, exception.Detail.Message)); 193FaultException<ExceptionDetail> exception = Assert.Throws<FaultException<ExceptionDetail>>(() => 214Assert.True(String.Equals(exception.Detail.Message, faultMsg), String.Format("Expected fault message: {0}\nActual fault message: {1}", faultMsg, exception.Detail.Message)); 276Assert.Fail("The Opening event timed out waiting for operations to queue, which was not expected for this test."); 354Assert.True((String.Equals("test", results[i])), 363Assert.True(toe == null, String.Format("Task [{0}] should not have failed with TimeoutException", i)); 367Assert.True(nFailures > 0, 379Assert.True(elapsedMs < expectedElapsedMs,

28EndpointNotFoundException exception = Assert.Throws<EndpointNotFoundException>(() => 51Assert.True(exception.Message.Contains(nonExistentHost), string.Format("Expected exception message to contain: '{0}'\nThe exception message was: {1}", nonExistentHost, exception.Message)); 110Assert.True(result == "Success!", string.Format("Test Case failed, expected the returned string to be: {0}, instead it was: {1}", "Success!", result)); 119Assert.Fail(fullExceptionMessage); 130CommunicationException exception = Assert.Throws<CommunicationException>(() => 160EndpointNotFoundException exception = Assert.Throws<EndpointNotFoundException>(() => 184Assert.True(exception.Message.Contains(notFoundUrl), string.Format("Expected exception message to contain: '{0}'\nThe exception message was:{1}", notFoundUrl, exception.Message)); 198ProtocolException exception = Assert.Throws<ProtocolException>(() => 222Assert.True(exception.Message.Contains(protocolExceptionUri), string.Format("Expected exception message to contain: '{0}'\nThe exception was: '{1}'", protocolExceptionUri, exception.Message)); 238FaultException<FaultDetail> exception = Assert.Throws<FaultException<FaultDetail>>(() => 273Assert.True(String.Equals(exceptionCodeName, exception.Code.Name), String.Format("Expected exception code name: {0}\nActual exception code name: {1}", exceptionCodeName, exception.Code.Name)); 274Assert.True(String.Equals(exceptionReason, exception.Reason.GetMatchingTranslation().Text), String.Format("Expected exception reason: {0}\nActual exception reason: {1}", exceptionReason, exception.Reason.GetMatchingTranslation().Text)); 290FaultException<FaultDetail> exception = Assert.Throws<FaultException<FaultDetail>>(() => 326Assert.True(String.Equals(exceptionCodeName, exception.Code.Name), String.Format("Expected exception code name: {0}\nActual exception code name: {1}", exceptionCodeName, exception.Code.Name)); 327Assert.True(String.Equals(exceptionReason, exception.Reason.GetMatchingTranslation().Text), String.Format("Expected exception reason: {0}\nActual exception reason: {1}", exceptionReason, exception.Reason.GetMatchingTranslation().Text)); 354Assert.Fail("Expected: SecurityNegotiationException, Actual: no exception"); 363Assert.Fail(string.Format("Expected type SecurityNegotiationException, Actual: {0}", exceptionType)); 396Assert.Fail("Expected: SecurityNegotiationException, Actual: no exception"); 405Assert.Fail(string.Format("Expected type SecurityNegotiationException, Actual: {0}", exceptionType)); 408Assert.True(exception.Message.Contains(Endpoints.Tcp_RevokedServerCertResource_HostName), 443Assert.Fail("Expected: SecurityNegotiationException, Actual: no exception"); 452Assert.Fail(string.Format("Expected type SecurityNegotiationException, Actual: {0}", exceptionType)); 455Assert.True(exception.Message.Contains(Endpoints.Tcp_RevokedServerCertResource_HostName), 526Assert.Fail("The Opening event timed out waiting for operations to queue, which was not expected for this test."); 604Assert.True((String.Equals("test", results[i])), 613Assert.True(toe == null, String.Format("Task [{0}] should not have failed with TimeoutException", i)); 617Assert.True(nFailures > 0, 621Assert.True(nFailures < operationCount, 631Assert.True(elapsedMs < expectedElapsedMs,

27var exception = Assert.Throws<Exception>(() => 56Assert.Equal(MyCertificateValidator.exceptionMsg, exception.Message);

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

75Assert.True(success, "Test Scenario: TypedProxy_AsyncBeginEnd_Call_WithSingleThreadedSyncContext timed out"); 110Assert.True(success, "Test Scenario: TypedProxy_AsyncTask_Call_WithSingleThreadedSyncContext timed out"); 139Assert.True(String.Equals(result, "Hello"), String.Format("Expected response from Service: {0} Actual was: {1}", "Hello", result)); 163Assert.True(success, "Test Scenario: TypedProxy_Synchronous_Call_WithSingleThreadedSyncContext timed out"); 195Assert.True(startThread == Environment.CurrentManagedThreadId, String.Format("Expected continuation to happen on thread {0} but actually continued on thread {1}", 201Assert.True(success, String.Format("Test didn't complete within the expected time")); 202Assert.True(String.Equals(result, "Hello"), String.Format("Expected response from Service: {0} Actual was: {1}", "Hello", result)); 252Assert.True(String.Equals(replyMessageAction, action + "Response"), 261Assert.True(String.Equals(actualResponse, expectedResponse), 316Assert.True(String.Equals(replyMessageAction, action + "Response"), 325Assert.True(String.Equals(actualResponse, expectedResponse), 381Assert.True(String.Equals(replyMessageAction, action + "Response"), 390Assert.True(String.Equals(actualResponse, expectedResponse), 481Assert.True(success, String.Format("The AsyncCallback was not called. If the AsyncCallback had been called the waitEvent would have been set to 'True', but the value of waitEvent was: {0}", success)); 482Assert.True(String.Equals(result, "Hello"), String.Format("Expected response from Service: {0} Actual was: {1}", "Hello", result)); 517Assert.True(success, String.Format("The IAsyncResult was not called. If the IAsyncResult had been called the AsyncWaitHandle would have been set to 'True', but the value of AsyncWaitHandle was: {0}", success)); 523Assert.True(String.Equals(result, "Hello"), String.Format("Expected response from Service: {0} Actual was: {1}", "Hello", result)); 556Assert.True(String.Equals(result, "Hello"), String.Format("Expected response from Service: {0} Actual was: {1}", "Hello", result));

29Assert.True(success, "Test Scenario: ServiceContract_TypedProxy_NetTcpBinding_AsyncBeginEnd_Call_WithSingleThreadedSyncContext timed out"); 44Assert.True(success, "Test Scenario: ServiceContract_TypedProxy__NetTcpBinding_AsyncTask_Call_WithSingleThreadedSyncContext timed out"); 75Assert.True(guid == returnedGuid, String.Format("The sent GUID does not match the returned GUID. Sent: {0} Received: {1}", guid, returnedGuid));

43Assert.True(response != null, "GetDataUsingDataContract(request) returned null"); 45Assert.True(String.Equals(response.StringValue, expectedStringValue), String.Format("Expected CompositeType.StringValue \"{0}\", actual was \"{1}\"", 47Assert.True(response.BoolValue == request.BoolValue, String.Format("Expected CompositeType.BoolValue \"{0}\", actual was \"{1}\"",

40Assert.True((guid == returnedType.GuidValue), String.Format("The Guid sent was not the same as the Guid returned.\nSent: {0}\nReturned: {1}", guid, returnedType.GuidValue)); 78Assert.True((guid.ToString() == returnedType.StringValue), String.Format("The Guid to string value sent was not the same as what was returned.\nSent: {0}\nReturned: {1}", guid.ToString(), returnedType.StringValue));

40Assert.Single(results); 42Assert.True(manager.GetType() == (typeof(Manager)), string.Format("Expected type: {0}, Actual type: {1}", typeof(Manager), manager.GetType())); 43Assert.True(((Manager)manager).Name == "jone", string.Format("Expected Name: {0}, Actual Name: {1}", "jone", ((Manager)manager).Name)); 44Assert.True(((Manager)manager).Age == "10", string.Format("Expected Age: {0}, Actual Age: {1}", "10", ((Manager)manager).Age)); 45Assert.True(((Manager)manager).OfficeId == 1, string.Format("Expected Id: {0}, Actual Id: {1}", 1, ((Manager)manager).OfficeId));

24FaultException<FaultDetail> exception = Assert.Throws<FaultException<FaultDetail>>(() => 45Assert.True(String.Equals(exception.Detail.Message, faultMsg), String.Format("Expected Fault Message: {0}, actual: {1}", faultMsg, exception.Detail.Message)); 58FaultException<ExceptionDetail> exception = Assert.Throws<FaultException<ExceptionDetail>>(() => 79Assert.True(String.Equals(exception.Detail.Message, faultMsg), String.Format("Expected Fault Message: {0}, actual: {1}", faultMsg, exception.Detail.Message)); 101thrownException = Assert.Throws<FaultException<int>>(() => 107Assert.Equal(expectedFaultCode, thrownException.Detail); 130var exception = Assert.Throws<FaultException<FaultDetail>>(() => 154Assert.Equal(faultMsg, exception.Detail.Message); 167var exception = Assert.Throws<FaultException<FaultDetail2>>(() => 191Assert.Equal(faultMsg, exception.Detail.Message); 204var exception = Assert.Throws<FaultException<FaultDetail>>(() => 228Assert.Equal(faultMsg, exception.Detail.Message); 251Assert.True(input.Length == response.Length, String.Format("Expected {0} response items but actual was {1}", input.Length, response.Length)); 252Assert.True(response[0] != null, "Expected response item to be FaultDetail, but actual was null"); 253Assert.True(response[0].GetType() == typeof(FaultDetail), String.Format("Expected response item to be FaultDetail but actual was {0}", response[0].GetType())); 254Assert.True(response[1] != null, "Expected response item to be KnownTypeA, but actual was null"); 255Assert.True(response[1].GetType() == typeof(KnownTypeA), String.Format("Expected response item to be FaultDetail2 but actual was {0}", response[1].GetType()));

42Assert.True(TestFaultContractInfosBehavior.testFaultWithKnownTypeClientOp != null, "Expected testFaultWithKnownTypeClientOp is NOT null"); 43Assert.True(TestFaultContractInfosBehavior.testFaultWithKnownTypeClientOp.FaultContractInfos.Count == 1, string.Format("expected FaultContractInfos count is 1, actual: {0}", TestFaultContractInfosBehavior.testFaultWithKnownTypeClientOp.FaultContractInfos.Count)); 44Assert.True(TestFaultContractInfosBehavior.testFaultWithKnownTypeClientOp.FaultContractInfos[0].Action == action, string.Format("expected FaultContractInfo Action is {0}, actual: {1}", action, TestFaultContractInfosBehavior.testFaultWithKnownTypeClientOp.FaultContractInfos[0].Action)); 45Assert.True(TestFaultContractInfosBehavior.testFaultWithKnownTypeClientOp.FaultContractInfos[0].Detail == detail, string.Format("expected FaultContractInfo Detail is {0}, actual: {1}", detail.ToString(), TestFaultContractInfosBehavior.testFaultWithKnownTypeClientOp.FaultContractInfos[0].Detail.ToString()));

25Assert.True(reader.LocalName.Equals(wrapperName), 28Assert.True(reader.NamespaceURI.Equals(MessageContractConstants.wrapperNamespace), 43Assert.False(reader.LocalName.Equals(wrapperName), 58Assert.True(reader.LocalName.Equals(wrapperName), 63Assert.True(reader.LocalName.Equals(MessageContractConstants.dateElementName), 70Assert.True(reader.LocalName.Equals(MessageContractConstants.transactionElementName), 77Assert.True(reader.LocalName.Equals(MessageContractConstants.customerElementName), 85Assert.True(reader.IsStartElement() == false && reader.LocalName.Equals(wrapperName), 106Assert.Equal(MessageContractConstants.customerElementValue, reader.Value); 115Assert.True(elementFound, 133Assert.True(header != null, "There's no header in the message."); 134Assert.True(header.MustUnderstand, "Expected MustUnderstand to be true, but it was false."); 151Assert.True(header != null, "There's no header in the message."); 152Assert.False(header.MustUnderstand, "Expected MustUnderstand to be false, but it was true.");

43Assert.True(String.Equals(requestData.accountName, replyData.accountName), 47Assert.True(requestData.amount == replyData.amount, 51Assert.True(String.Equals(requestData.requestSingleValue, replyData.replySingleValue), 71Assert.True(array2 != null, 74Assert.True(array1.Length == array2.Length, 80Assert.True(array1[i] == array2[i], 109Assert.True(response != null, 112Assert.True(String.Equals(testString, response.TestResult),

57Assert.Throws<ProtocolException>(() =>

41Assert.False(replyMessage.IsFault); 42Assert.False(replyMessage.IsEmpty); 43Assert.Equal(MessageState.Created, replyMessage.State); 44Assert.Equal(MessageVersion.Soap11, replyMessage.Version); 50Assert.True(string.Equals(actualResponse, expectedResponse), 93Assert.True(result == expectedResult, string.Format("Error: expected response from service: '{0}' Actual was: '{1}'", expectedResult, result));

49Assert.True(waitEvent.WaitOne(ScenarioTestHelpers.TestTimeout), "AsyncCallback was not called."); 50Assert.True((number == message.Count<char>()), String.Format("The local int variable was not correctly set, expected {0} but got {1}", message.Count<char>(), number)); 96Assert.True(waitEvent.WaitOne(ScenarioTestHelpers.TestTimeout), "AsyncCallback was not called."); 97Assert.True((uniqueType.stringValue == message), 142Assert.True(waitEvent.WaitOne(ScenarioTestHelpers.TestTimeout), "AsyncCallback was not called."); 143Assert.True((number == message.Count<char>()), 190Assert.True(waitEvent.WaitOne(ScenarioTestHelpers.TestTimeout), "AsyncCallback was not called."); 191Assert.True((uniqueType.stringValue == message), 229Assert.True((uniqueType.stringValue == message), 237Assert.True((uniqueType.stringValue == message), 275Assert.True((uniqueType.stringValue == message), 311Assert.True(factory.State == CommunicationState.Opened, 339Assert.True(success, "Test Scenario: BasicHttp_Async_Open_ChannelFactory_WithSingleThreadedSyncContext timed-out."); 365Assert.True(proxyAsCommunicationObject.State == CommunicationState.Opened, 392Assert.True(success, "Test Scenario: BasicHttp_Async_Open_Proxy_WithSingleThreadedSyncContext timed-out."); 420Assert.True(factory.State == CommunicationState.Closed, 443Assert.True(success, "Test Scenario: BasicHttp_Async_Close_ChannelFactory_WithSingleThreadedSyncContext timed-out."); 469Assert.True(proxyAsCommunicationObject.State == CommunicationState.Closed, 493Assert.True(success, "Test Scenario: BasicHttp_Async_Close_Proxy_WithSingleThreadedSyncContext timed-out.");

44Assert.Equal(testString, result); 80Assert.Equal(testString, result); 115Assert.Equal(testString, result); 152Assert.Equal(testString, result); 189Assert.Equal(testString, result); 213Assert.True(success, "Test Scenario: BasicHttp_DefaultSettings_Echo_RoundTrips_String_Streamed_WithSingleThreadedSyncContext timed-out."); 227Assert.True(success, "Test Scenario: BasicHttp_DefaultSettings_Echo_RoundTrips_String_Streamed_Async_WithSingleThreadedSyncContext timed-out."); 276Assert.Throws<TimeoutException>(() => 332Assert.Throws<TimeoutException>(() => 374Assert.Equal(testString, result); 410Assert.Equal(testString, result); 445Assert.Equal(testString, result); 482Assert.Equal(testString, result); 519Assert.Equal(testString, result); 556Assert.Equal(testString, result); 593Assert.Equal(testString, result); 617Assert.True(success, "Test Scenario: NetTcp_NoSecurity_String_Streamed_RoundTrips_WithSingleThreadedSyncContext timed-out."); 631Assert.True(success, "Test Scenario: NetTcp_NoSecurity_Streamed_Async_RoundTrips_String_WithSingleThreadedSyncContext timed-out."); 657Assert.True(string.Equals(result, "Hello " + echoString), String.Format("Expected response from Service: {0} Actual was: {1}", "Hello " + echoString, result)); 702Assert.True(factory.State == CommunicationState.Closed, 733Assert.True(exception1 != null || actualEcho1 != null, "First operation should have thrown Exception or returned an echo"); 734Assert.True(exception2 != null || actualEcho2 != null, "Second operation should have thrown Exception or returned an echo"); 736Assert.True(actualEcho1 == null || String.Equals(expectedEcho1, actualEcho1), 739Assert.True(actualEcho2 == null || String.Equals(expectedEcho2, actualEcho2), 742Assert.True(((ICommunicationObject)serviceProxy1).State == CommunicationState.Closed, 744Assert.True(((ICommunicationObject)serviceProxy2).State == CommunicationState.Closed, 792Assert.True(factory.State == CommunicationState.Closed, 823Assert.True(exception1 != null || actualEcho1 != null, "First operation should have thrown Exception or returned an echo"); 824Assert.True(exception2 != null || actualEcho2!= null, "Second operation should have thrown Exception or returned an echo"); 826Assert.True(actualEcho1 == null || String.Equals(expectedEcho1, actualEcho1), 829Assert.True(actualEcho2 == null || String.Equals(expectedEcho2, actualEcho2), 832Assert.True(((ICommunicationObject)serviceProxy1).State == CommunicationState.Closed, 834Assert.True(((ICommunicationObject)serviceProxy2).State == CommunicationState.Closed, 883Assert.True(factory.State == CommunicationState.Closed, 914Assert.True(exception1 != null || actualEcho1 != null, "First operation should have thrown Exception or returned an echo"); 915Assert.True(exception2 != null || actualEcho2 != null, "Second operation should have thrown Exception or returned an echo"); 917Assert.True(actualEcho1 == null || String.Equals(expectedEcho1, actualEcho1), 920Assert.True(actualEcho2 == null || String.Equals(expectedEcho2, actualEcho2), 923Assert.True(((ICommunicationObject)serviceProxy1).State == CommunicationState.Closed, 925Assert.True(((ICommunicationObject)serviceProxy2).State == CommunicationState.Closed,

117Assert.Equal(expectedId, ((Widget)response[0]).Id); 118Assert.Equal(expectedCatalog, ((Widget)response[0]).Catalog);

26Assert.Equal(message1 + message2, response); 41Assert.NotNull(response); 42Assert.Equal(value.BoolValue, response.BoolValue); 43Assert.Equal(value.StringValue, response.StringValue); 58Assert.Equal("MyNameFoo", response); 75Assert.NotNull(response); 76Assert.Equal(intValue, response.@Return);

26Assert.Equal("message", response); 39Assert.Equal("message", response); 59Assert.Equal(errorMessage, e.Message); 64Assert.True(false); 77Assert.Equal("message", response); 92Assert.True(response != null); 93Assert.Equal("message", response.Result); 110Assert.True(response != null); 111Assert.Equal("message", response.StringValue); 112Assert.True(!input.BoolValue); 136Assert.True(response != null); 137Assert.Equal("123", response.@return); 172Assert.True(response != null); 173Assert.True(response.NonInstantiatedField == null); 174Assert.Equal(complex.Id, response.Id); 206Assert.Equal("message", response);

30Assert.NotNull(response); 31Assert.Equal(input.Message, response.Message); 57Assert.NotNull(response); 58Assert.Equal(input.Message, response.Message); 96Assert.Equal(customHeaderValue.Message, result);

48Assert.Contains("http://schemas.xmlsoap.org/soap/encoding/", str); 90Assert.True(fException.Detail.UsedDataContractSerializer, "The returning Fault Detail should have used the Data Contract Serializer."); 91Assert.True(fException.Detail.UsedXmlSerializer == false, "The returning Fault Detail should NOT have used the Xml Serializer."); 95Assert.Fail($"Test Failed, caught unexpected exception.\nException: {exception.ToString()}\nException Message: {exception.Message}"); 112Assert.True(fException.Detail.UsedDataContractSerializer == false, "The returning Fault Detail should NOT have used the Data Contract Serializer."); 113Assert.True(fException.Detail.UsedXmlSerializer, "The returning Fault Detail should have used the Xml Serializer."); 117Assert.Fail($"Test Failed, caught unexpected exception.\nException: {exception.ToString()}\nException Message: {exception.Message}"); 145Assert.Equal(3, serviceProxy1.Sum2(1, 2)); 149Assert.Fail(ex.Message); 181Assert.Equal(3, serviceProxy1.Sum2(1, 2)); 182Assert.Equal(intParams.P1 + intParams.P2, serviceProxy1.Sum(intParams)); 183Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 184Assert.Equal((float)(floatParams.P1 / floatParams.P2), serviceProxy1.Divide(floatParams)); 185Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 186Assert.Equal(dateTime, serviceProxy1.ReturnInputDateTime(dateTime)); 191Assert.NotNull(outputIntParams); 192Assert.Equal(intParams.P1, outputIntParams.P1); 193Assert.Equal(intParams.P2, outputIntParams.P2); 197Assert.Fail(ex.Message); 229Assert.Equal(3, serviceProxy1.Sum2(1, 2)); 230Assert.Equal(intParams.P1 + intParams.P2, serviceProxy1.Sum(intParams)); 231Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 232Assert.Equal((float)(floatParams.P1 / floatParams.P2), serviceProxy1.Divide(floatParams)); 233Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 234Assert.Equal(dateTime, serviceProxy1.ReturnInputDateTime(dateTime)); 239Assert.NotNull(outputIntParams); 240Assert.Equal(intParams.P1, outputIntParams.P1); 241Assert.Equal(intParams.P2, outputIntParams.P2); 245Assert.Fail(ex.Message); 277Assert.Equal(3, serviceProxy1.Sum2(1, 2)); 278Assert.Equal(intParams.P1 + intParams.P2, serviceProxy1.Sum(intParams)); 279Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 280Assert.Equal((float)(floatParams.P1 / floatParams.P2), serviceProxy1.Divide(floatParams)); 281Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 282Assert.Equal(dateTime, serviceProxy1.ReturnInputDateTime(dateTime)); 287Assert.NotNull(outputIntParams); 288Assert.Equal(intParams.P1, outputIntParams.P1); 289Assert.Equal(intParams.P2, outputIntParams.P2); 293Assert.Fail(ex.Message); 330Assert.Equal(3, serviceProxy1.Sum2(1, 2)); 331Assert.Equal(intParams.P1 + intParams.P2, serviceProxy1.Sum(intParams)); 332Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 333Assert.Equal((float)(floatParams.P1 / floatParams.P2), serviceProxy1.Divide(floatParams)); 334Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 335Assert.Equal(dateTime, serviceProxy1.ReturnInputDateTime(dateTime)); 340Assert.NotNull(outputIntParams); 341Assert.Equal(intParams.P1, outputIntParams.P1); 342Assert.Equal(intParams.P2, outputIntParams.P2); 345Assert.Equal(testStr, serviceProxy2.GetAndRemoveString(guid2)); 349Assert.Fail(ex.Message); 387Assert.Equal(3, serviceProxy1.Sum2(1, 2)); 388Assert.Equal(intParams.P1 + intParams.P2, serviceProxy1.Sum(intParams)); 389Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 390Assert.Equal((float)(floatParams.P1 / floatParams.P2), serviceProxy1.Divide(floatParams)); 391Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 392Assert.Equal(dateTime, serviceProxy1.ReturnInputDateTime(dateTime)); 397Assert.NotNull(outputIntParams); 398Assert.Equal(intParams.P1, outputIntParams.P1); 399Assert.Equal(intParams.P2, outputIntParams.P2); 402Assert.Equal(testStr, serviceProxy2.GetAndRemoveString(guid2)); 406Assert.Fail(ex.Message); 444Assert.Equal(3, serviceProxy1.Sum2(1, 2)); 445Assert.Equal(intParams.P1 + intParams.P2, serviceProxy1.Sum(intParams)); 446Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 447Assert.Equal((float)(floatParams.P1 / floatParams.P2), serviceProxy1.Divide(floatParams)); 448Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 449Assert.Equal(dateTime, serviceProxy1.ReturnInputDateTime(dateTime)); 454Assert.NotNull(outputIntParams); 455Assert.Equal(intParams.P1, outputIntParams.P1); 456Assert.Equal(intParams.P2, outputIntParams.P2); 459Assert.Equal(testStr, serviceProxy2.GetAndRemoveString(guid2)); 463Assert.Fail(ex.Message); 496Assert.Equal(echoText, response.EchoResult); 497Assert.Equal(expectedHeaderText, response.StringHeader.HeaderValue); 501Assert.Fail(ex.Message);

44Assert.Equal("Request Handled", await response.Content.ReadAsStringAsync()); 45Assert.Equal(HttpStatusCode.OK, response.StatusCode); 79var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => 82Assert.Equal("Exception requested from TestMiddleware", ex.Message); 105var ex = await Assert.ThrowsAsync<DbUpdateException>(async () => 108Assert.Equal("SQLite Error 1: 'no such table: Blogs'.", ex.InnerException.Message); 140Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 142Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_NoDbOrMigrationsTitle"), content); 143Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_NoDbOrMigrationsInfo"), content); 144Assert.Contains(typeof(BloggingContext).Name, content); 145Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_AddMigrationCommandPMC").Replace(">", "&gt;"), content); 146Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_ApplyMigrationsCommandPMC").Replace(">", "&gt;"), content); 183Assert.Equal("DbUpdateException", e.GetType().Name); 201Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 204Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_PendingMigrationsTitle"), content); 205Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_PendingMigrationsInfo"), content); 206Assert.Contains(typeof(BloggingContextWithMigrations).Name, content); 207Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_ApplyMigrationsCommandPMC").Replace(">", "&gt;"), content); 208Assert.Contains("<li>111111111111111_MigrationOne</li>", content); 209Assert.Contains("<li>222222222222222_MigrationTwo</li>", content); 211Assert.DoesNotContain(StringsHelpers.GetResourceString("DatabaseErrorPage_AddMigrationCommandPMC").Replace(">", "&gt;"), content); 240Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 243Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_PendingChangesTitle"), content); 244Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_PendingChangesInfo"), content); 245Assert.Contains(typeof(BloggingContextWithPendingModelChanges).Name, content); 246Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_AddMigrationCommandCLI").Replace(">", "&gt;"), content); 247Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_AddMigrationCommandPMC").Replace(">", "&gt;"), content); 248Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_ApplyMigrationsCommandCLI").Replace(">", "&gt;"), content); 249Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_ApplyMigrationsCommandPMC").Replace(">", "&gt;"), content); 285Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 290Assert.Contains("req.open(\"POST\", \"" + JavaScriptEncode(expectedMigrationsEndpoint) + "\", true);", content); 291Assert.Contains("data-assemblyname=\"" + JavaScriptEncode(expectedContextType) + "\"", content); 302Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); 307Assert.Equal("Saved a Blog", content); 363Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 366Assert.Contains("req.open(\"POST\", \"" + JavaScriptEncode(migrationsEndpoint) + "\", true);", content); 403Assert.True( 408Assert.Contains(logProvider.Logger.Messages.ToList(), m => 451Assert.True( 456Assert.Contains(logProvider.Logger.Messages.ToList(), m => 486Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 488Assert.Contains("I wrapped your exception", content); 489Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_NoDbOrMigrationsTitle"), content); 490Assert.Contains(StringsHelpers.GetResourceString("DatabaseErrorPage_NoDbOrMigrationsInfo"), content); 491Assert.Contains(typeof(BloggingContext).Name, content);

42Assert.Equal("Request Handled", await response.Content.ReadAsStringAsync()); 43Assert.Equal(HttpStatusCode.OK, response.StatusCode); 118Assert.False(databaseCreator.Exists()); 128Assert.Equal(HttpStatusCode.NoContent, response.StatusCode); 130Assert.True(databaseCreator.Exists()); 134Assert.Equal(2, appliedMigrations.Count); 135Assert.Equal("111111111111111_MigrationOne", appliedMigrations.ElementAt(0).MigrationId); 136Assert.Equal("222222222222222_MigrationTwo", appliedMigrations.ElementAt(1).MigrationId); 164Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 165Assert.StartsWith(StringsHelpers.GetResourceString("MigrationsEndPointMiddleware_NoContextType"), content); 166Assert.True(content.Length > 512); 196Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 197Assert.StartsWith(StringsHelpers.GetResourceString("FormatMigrationsEndPointMiddleware_ContextNotRegistered", typeName), content); 198Assert.True(content.Length > 512); 225Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 226Assert.StartsWith(StringsHelpers.GetResourceString("FormatMigrationsEndPointMiddleware_ContextNotRegistered", typeof(BloggingContext).AssemblyQualifiedName), content); 227Assert.True(content.Length > 512); 261var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => 264Assert.StartsWith(StringsHelpers.GetResourceString("FormatMigrationsEndPointMiddleware_Exception", typeof(BloggingContextWithSnapshotThatThrows)), ex.Message); 265Assert.Equal("Welcome to the invalid migration!", ex.InnerException.Message);

32Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 33Assert.Contains("In Visual Studio, use the Package Manager Console to scaffold a new migration and apply it to the database:", body);

33Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 34Assert.Contains("Exception: Demonstration exception.", body); 49Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 50Assert.NotNull(body); 51Assert.Equal(500, body.Status); 52Assert.Contains("Demonstration exception", body.Detail); 55Assert.Contains("System.Exception: Demonstration exception.", exceptionNode.GetProperty("details").GetString()); 56Assert.Equal("application/json", exceptionNode.GetProperty("headers").GetProperty("Accept")[0].GetString()); 57Assert.Equal("localhost", exceptionNode.GetProperty("headers").GetProperty("Host")[0].GetString()); 58Assert.Equal("/", exceptionNode.GetProperty("path").GetString()); 59Assert.Equal("Endpoint display name", exceptionNode.GetProperty("endpoint").GetString()); 60Assert.Equal("Value1", exceptionNode.GetProperty("routeValues").GetProperty("routeValue1").GetString()); 61Assert.Equal("Value2", exceptionNode.GetProperty("routeValues").GetProperty("routeValue2").GetString());

29Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 30Assert.Contains("we encountered an un-expected issue with your application.", body);

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

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

34Assert.Equal(HttpStatusCode.OK, response.StatusCode); 35Assert.Contains("Status Code: 417", body); 51Assert.Equal((HttpStatusCode)httpStatusCode, response.StatusCode); 52Assert.DoesNotContain(";", responseBody); 71Assert.Equal((HttpStatusCode)httpStatusCode, response.StatusCode); 72Assert.Contains(";", responseBody); 73Assert.Contains(statusCodeReasonPhrase, responseBody); 89Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 90Assert.NotNull(body); 91Assert.Equal(400, body.Status); 106Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); 107Assert.NotNull(body); 108Assert.Equal(400, body.Status);

26Assert.True(bytes.Length > 1); 27Assert.NotEqual(0xEF, bytes[0]); // No leading UTF-8 BOM 30Assert.Equal(HttpStatusCode.OK, response.StatusCode); 31Assert.Contains("Your ASP.NET Core application has been successfully started", body);

14Assert.True(true);

26Assert.Equal(message1 + message2, response); 41Assert.NotNull(response); 42Assert.Equal(value.BoolValue, response.BoolValue); 43Assert.Equal(value.StringValue, response.StringValue); 58Assert.Equal("MyNameFoo", response); 75Assert.NotNull(response); 76Assert.Equal(intValue, response.@Return);

26Assert.Equal("message", response); 39Assert.Equal("message", response); 59Assert.Equal(errorMessage, e.Message); 64Assert.True(false); 77Assert.Equal("message", response); 92Assert.True(response != null); 93Assert.Equal("message", response.Result); 110Assert.True(response != null); 111Assert.Equal("message", response.StringValue); 112Assert.True(!input.BoolValue); 136Assert.True(response != null); 137Assert.Equal("123", response.@return); 172Assert.True(response != null); 173Assert.True(response.NonInstantiatedField == null); 174Assert.Equal(complex.Id, response.Id); 206Assert.Equal("message", response);

30Assert.NotNull(response); 31Assert.Equal(input.Message, response.Message); 57Assert.NotNull(response); 58Assert.Equal(input.Message, response.Message); 96Assert.Equal(customHeaderValue.Message, result);

48Assert.Contains("http://schemas.xmlsoap.org/soap/encoding/", str); 61Assert.True(method != null, $"No method named {s_serializationModeSetterName}"); 90Assert.True(fException.Detail.UsedDataContractSerializer, "The returning Fault Detail should have used the Data Contract Serializer."); 91Assert.True(fException.Detail.UsedXmlSerializer == false, "The returning Fault Detail should NOT have used the Xml Serializer."); 95Assert.Fail($"Test Failed, caught unexpected exception.\nException: {exception.ToString()}\nException Message: {exception.Message}"); 112Assert.True(fException.Detail.UsedDataContractSerializer == false, "The returning Fault Detail should NOT have used the Data Contract Serializer."); 113Assert.True(fException.Detail.UsedXmlSerializer, "The returning Fault Detail should have used the Xml Serializer."); 117Assert.Fail($"Test Failed, caught unexpected exception.\nException: {exception.ToString()}\nException Message: {exception.Message}"); 145Assert.Equal(3, serviceProxy1.Sum2(1, 2)); 149Assert.Fail(ex.Message); 181Assert.Equal(3, serviceProxy1.Sum2(1, 2)); 182Assert.Equal(intParams.P1 + intParams.P2, serviceProxy1.Sum(intParams)); 183Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 184Assert.Equal((float)(floatParams.P1 / floatParams.P2), serviceProxy1.Divide(floatParams)); 185Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 186Assert.Equal(dateTime, serviceProxy1.ReturnInputDateTime(dateTime)); 191Assert.NotNull(outputIntParams); 192Assert.Equal(intParams.P1, outputIntParams.P1); 193Assert.Equal(intParams.P2, outputIntParams.P2); 197Assert.Fail(ex.Message); 229Assert.Equal(3, serviceProxy1.Sum2(1, 2)); 230Assert.Equal(intParams.P1 + intParams.P2, serviceProxy1.Sum(intParams)); 231Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 232Assert.Equal((float)(floatParams.P1 / floatParams.P2), serviceProxy1.Divide(floatParams)); 233Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 234Assert.Equal(dateTime, serviceProxy1.ReturnInputDateTime(dateTime)); 239Assert.NotNull(outputIntParams); 240Assert.Equal(intParams.P1, outputIntParams.P1); 241Assert.Equal(intParams.P2, outputIntParams.P2); 245Assert.Fail(ex.Message); 277Assert.Equal(3, serviceProxy1.Sum2(1, 2)); 278Assert.Equal(intParams.P1 + intParams.P2, serviceProxy1.Sum(intParams)); 279Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 280Assert.Equal((float)(floatParams.P1 / floatParams.P2), serviceProxy1.Divide(floatParams)); 281Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 282Assert.Equal(dateTime, serviceProxy1.ReturnInputDateTime(dateTime)); 287Assert.NotNull(outputIntParams); 288Assert.Equal(intParams.P1, outputIntParams.P1); 289Assert.Equal(intParams.P2, outputIntParams.P2); 293Assert.Fail(ex.Message); 330Assert.Equal(3, serviceProxy1.Sum2(1, 2)); 331Assert.Equal(intParams.P1 + intParams.P2, serviceProxy1.Sum(intParams)); 332Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 333Assert.Equal((float)(floatParams.P1 / floatParams.P2), serviceProxy1.Divide(floatParams)); 334Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 335Assert.Equal(dateTime, serviceProxy1.ReturnInputDateTime(dateTime)); 340Assert.NotNull(outputIntParams); 341Assert.Equal(intParams.P1, outputIntParams.P1); 342Assert.Equal(intParams.P2, outputIntParams.P2); 345Assert.Equal(testStr, serviceProxy2.GetAndRemoveString(guid2)); 349Assert.Fail(ex.Message); 387Assert.Equal(3, serviceProxy1.Sum2(1, 2)); 388Assert.Equal(intParams.P1 + intParams.P2, serviceProxy1.Sum(intParams)); 389Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 390Assert.Equal((float)(floatParams.P1 / floatParams.P2), serviceProxy1.Divide(floatParams)); 391Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 392Assert.Equal(dateTime, serviceProxy1.ReturnInputDateTime(dateTime)); 397Assert.NotNull(outputIntParams); 398Assert.Equal(intParams.P1, outputIntParams.P1); 399Assert.Equal(intParams.P2, outputIntParams.P2); 402Assert.Equal(testStr, serviceProxy2.GetAndRemoveString(guid2)); 406Assert.Fail(ex.Message); 444Assert.Equal(3, serviceProxy1.Sum2(1, 2)); 445Assert.Equal(intParams.P1 + intParams.P2, serviceProxy1.Sum(intParams)); 446Assert.Equal(string.Format("{0}{1}", intParams.P1, intParams.P2), serviceProxy1.Concatenate(intParams)); 447Assert.Equal((float)(floatParams.P1 / floatParams.P2), serviceProxy1.Divide(floatParams)); 448Assert.Equal((new byte[] { byteParams.P1, byteParams.P2 }), serviceProxy1.CreateSet(byteParams)); 449Assert.Equal(dateTime, serviceProxy1.ReturnInputDateTime(dateTime)); 454Assert.NotNull(outputIntParams); 455Assert.Equal(intParams.P1, outputIntParams.P1); 456Assert.Equal(intParams.P2, outputIntParams.P2); 459Assert.Equal(testStr, serviceProxy2.GetAndRemoveString(guid2)); 463Assert.Fail(ex.Message); 496Assert.Equal(echoText, response.EchoResult); 497Assert.Equal(expectedHeaderText, response.StringHeader.HeaderValue); 501Assert.Fail(ex.Message);

22Assert.False(File.Exists(outputFile)); 28Assert.True(File.Exists(outputFile));

42Assert.True(Directory.Exists(this_TestGroupOutputDir), $"{nameof(this_TestGroupOutputDir)} is not initialized!"); 43Assert.True(Directory.Exists(this_TestGroupBaselinesDir), $"{nameof(this_TestGroupBaselinesDir)} is not initialized!"); 48Assert.False(string.IsNullOrWhiteSpace(this_TestCaseName), $"{nameof(this_TestCaseName)} not initialized!"); 49Assert.False(options == null, $"{nameof(options)} not initialized!"); 179Assert.True(File.Exists(wsdlFile), $"{wsdlFile} not initialized!"); 234Assert.True(result.ExitCode == 0, result.OutputText); 237Assert.True(File.Exists(binProjPath), $"{nameof(binProjPath)} not initialized!"); 238Assert.True(File.Exists(libProjPath), $"{nameof(libProjPath)} not initialized!"); 245Assert.True(ret.ExitCode == 0, ret.OutputText); 368Assert.True(File.Exists(srcParamsFilePath), $"{nameof(srcParamsFilePath)} not initialized!");

15Assert.True(dir.Exists, "Can't copy nonexistant directory.");

18Assert.False(string.IsNullOrWhiteSpace(this_TestCaseName), $"{nameof(this_TestCaseName)} not initialized!"); 19Assert.False(options == null, $"{nameof(options)} not initialized!"); 159Assert.True(ret.ExitCode == 0, ret.OutputText);

43Assert.NotNull(build); 44Assert.NotEmpty(build.Dependencies); 45Assert.Contains(build.Dependencies, x => x.Name == "xunit" && x.Version == "2.4.1"); 63Assert.NotNull(build); 64Assert.NotEmpty(build.Dependencies); 65Assert.Contains(build.Dependencies, x => x.Name == "xunit" && x.Version == "2.4.1"); 82Assert.NotNull(build); 83Assert.NotEmpty(build.Dependencies); 84Assert.Contains(build.Dependencies, x => x.Name == "xunit" && x.Version == "2.4.1"); 102Assert.NotNull(build); 103Assert.NotEmpty(build.Dependencies); 104Assert.Contains(build.Dependencies, x => x.Name == "xunit" && x.Version == "2.4.1");

54Assert.NotNull(project); 68Assert.True(success, $"Could not add tool package dependency: dotnet-svcutil-lib.{svcutilPkgVersion}"); 73Assert.True(ret.ExitCode == 0, $"Project package restore failed:{Environment.NewLine}{ret.OutputText}{logger}"); 78Assert.True(ret.ExitCode == 0, $"Project build failed:{Environment.NewLine}{ret.OutputText}{logger}"); 86Assert.False(string.IsNullOrEmpty(options), $"{nameof(options)} not initialized!"); 87Assert.True(File.Exists(project?.FullPath), $"{nameof(project)} is not initialized!"); 173Assert.False(string.IsNullOrEmpty(srcParamsFile), $"{nameof(srcParamsFile)} not initialized!"); 174Assert.False(string.IsNullOrEmpty(referenceFolderName), $"{nameof(referenceFolderName)} not initialized!"); 175Assert.True(File.Exists(project?.FullPath), $"{nameof(project)} is not initialized!");

155Assert.True(Directory.Exists(g_RepositoryRoot), $"{nameof(g_RepositoryRoot)} is not initialized!"); 156Assert.True(Directory.Exists(g_TestCasesDir), $"{nameof(g_TestCasesDir)} is not initialized!"); 157Assert.True(Directory.Exists(g_TestResultsDir), $"{nameof(g_TestResultsDir)} is not initialized!"); 158Assert.True(Directory.Exists(g_TestBootstrapDir), $"{nameof(g_TestBootstrapDir)} is not initialized!"); 159Assert.True(Directory.Exists(g_TestOutputDir), $"{nameof(g_TestOutputDir)} is not initialized!"); 160Assert.True(Directory.Exists(g_BaselinesDir), $"{nameof(g_BaselinesDir)} is not initialized!"); 167Assert.True(File.Exists(g_StarterProject.FullPath), $"{nameof(g_StarterProject)} is not initialized!"); 169Assert.False(string.IsNullOrEmpty(g_SvcutilNugetFeed), $"{nameof(g_SvcutilNugetFeed)} is not initialized!"); 170Assert.False(string.IsNullOrEmpty(g_SvcutilPkgVersion), $"{nameof(g_SvcutilPkgVersion)} is not initialized!"); 184Assert.True(Directory.GetFiles(pkgPath, "dotnet-svcutil-lib.*.nupkg").Any(), $"dotnet-svcutil-lib*.nupkg not found under {pkgPath}!"); 186Assert.True(ret.ExitCode == 0, "Could not install the global tool." + Environment.NewLine + ret.OutputText); 240Assert.False(string.IsNullOrWhiteSpace(testCaseName), $"{nameof(testCaseName)} is not initialized!"); 277Assert.True(Directory.Exists(this_TestCaseOutputDir), $"{nameof(this_TestGroupOutputDir)} is not initialized!"); 278Assert.True(Directory.Exists(this_TestCaseBaselinesDir), $"{nameof(this_TestCaseBaselinesDir)} is not initialized!"); 279Assert.True(this_TestCaseBootstrapDir != null, $"{nameof(this_TestCaseBootstrapDir)} is not initialized!"); 280Assert.True(this_TestCaseLogger != null, $"{nameof(this_TestGroupOutputDir)} is not initialized!"); 281Assert.True(this_FixupUtil != null, $"{nameof(this_FixupUtil)} is not initialized!"); 337Assert.True(isTestSucess, $"{Environment.NewLine}Test failed:{Environment.NewLine}{outputText}{g_GeneralErrMsg}"); 343Assert.True(validationSuccess, $"{Environment.NewLine}Test failed validation!{failureMessage}{g_GeneralErrMsg}"); 540Assert.True(Directory.Exists(vstestDir), $"{nameof(vstestDir)} is not initialized!"); 551Assert.True(nugetFiles.Length <= 1, "There should be one and only one nuget package for testing."); 565Assert.NotNull(nugetFile); 590Assert.True(rootSolutionFolder != null && File.Exists(rootSolutionFolder), $"Unable to find dotnet-svcutil.sln file, current dir: {parentDir}");

19Assert.False(string.IsNullOrWhiteSpace(this_TestCaseName), $"{nameof(this_TestCaseName)} not initialized!"); 20Assert.False(options == null, $"{nameof(options)} not initialized!"); 274Assert.False(cmdOptions.Errors.Count() == 0 ^ expectSuccess, cmderrors); 275Assert.True(ValidateOutputs(options, out var failureMessage), failureMessage); 312Assert.True(ValidateOutputs(options, out var failureMessage), failureMessage); 339Assert.True(ValidateJson(options, jsonFileSrcPath, out errorMessage), errorMessage);

40Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 79Assert.True(compositeObject.Equals(result), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", compositeObject, result));

40Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result));

31Assert.Throws<ProtocolException>(() => { serviceProxy.ReturnContentType(testContentType); });

39Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 75Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result));

39Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 75Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 111Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 147Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 183Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result));

46Assert.Equal(result, testString); 114Assert.True(streamLength == ms.Length, 120Assert.True(requestBytes.SequenceEqual(returnedByteArraySegment.Array), "Returned bytes are different than sent bytes");

76Assert.True(clientReceiver.ReceiveStreamInvoked.WaitOne(ScenarioTestHelpers.TestTimeout), 88Assert.True(clientReceiver.ReceiveStreamCompleted.WaitOne(ScenarioTestHelpers.TestTimeout), 94Assert.True(clientReceiver.LogReceived.WaitOne(ScenarioTestHelpers.TestTimeout), 98Assert.True(clientReceiver.ServerLog.Count > 0, 151Assert.True(clientReceiver.ReceiveDataInvoked.WaitOne(ScenarioTestHelpers.TestTimeout), 156Assert.True(clientReceiver.ReceiveDataCompleted.WaitOne(ScenarioTestHelpers.TestTimeout), 162Assert.True(clientReceiver.LogReceived.WaitOne(ScenarioTestHelpers.TestTimeout), 166Assert.True(clientReceiver.ServerLog.Count > 0, 219Assert.True(clientReceiver.ReceiveDataInvoked.WaitOne(ScenarioTestHelpers.TestTimeout), 224Assert.True(clientReceiver.ReceiveDataCompleted.WaitOne(ScenarioTestHelpers.TestTimeout), 230Assert.True(clientReceiver.LogReceived.WaitOne(ScenarioTestHelpers.TestTimeout), 234Assert.True(clientReceiver.ServerLog.Count > 0, 308Assert.True(clientReceiver.ReceiveStreamInvoked.WaitOne(ScenarioTestHelpers.TestTimeout), 320Assert.True(clientReceiver.ReceiveStreamCompleted.WaitOne(ScenarioTestHelpers.TestTimeout), 326Assert.True(clientReceiver.LogReceived.WaitOne(ScenarioTestHelpers.TestTimeout), 330Assert.True(clientReceiver.ServerLog.Count > 0, 386Assert.True(clientReceiver.ReceiveDataInvoked.WaitOne(ScenarioTestHelpers.TestTimeout), 391Assert.True(clientReceiver.ReceiveDataCompleted.WaitOne(ScenarioTestHelpers.TestTimeout), 397Assert.True(clientReceiver.LogReceived.WaitOne(ScenarioTestHelpers.TestTimeout), 401Assert.True(clientReceiver.ServerLog.Count > 0, 467Assert.True(!ScenarioTestHelpers.IsLocalHost() || !serverLogItem.Contains(ScenarioTestHelpers.RemoteEndpointMessagePropertyFailure), serverLogItem); 521Assert.True(!ScenarioTestHelpers.IsLocalHost() || !serverLogItem.Contains(ScenarioTestHelpers.RemoteEndpointMessagePropertyFailure), serverLogItem); 575Assert.True(!ScenarioTestHelpers.IsLocalHost() || !serverLogItem.Contains(ScenarioTestHelpers.RemoteEndpointMessagePropertyFailure), serverLogItem); 630Assert.True(!ScenarioTestHelpers.IsLocalHost() || !serverLogItem.Contains(ScenarioTestHelpers.RemoteEndpointMessagePropertyFailure), serverLogItem); 687Assert.True(!ScenarioTestHelpers.IsLocalHost() || !serverLogItem.Contains(ScenarioTestHelpers.RemoteEndpointMessagePropertyFailure), serverLogItem); 728Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); 768Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); 811Assert.True(guid == returnedGuid, 851Assert.True(responseFromService, String.Format("Response from the service was not expected. Expected: 'True' but got {0}", responseFromService));

112Assert.Equal(expected, Encoding.ASCII.GetString((await ReceiveChunk()).Span)); 120Assert.Equal(expected, Encoding.ASCII.GetString(actual.Span)); 169Assert.True(task.Wait(4000), "timeout"); 177Assert.True(count == 1); 187Assert.StartsWith(prefix, actualLine); 202Assert.Contains(s, headers);

52Assert.Equal(HttpVersion.Version20, response.Version); 53Assert.Empty(response.TrailingHeaders); 63Assert.Equal(HttpVersion.Version20, response.Version); 64Assert.Empty(response.TrailingHeaders); 74Assert.Equal(HttpVersion.Version20, response.Version); 75Assert.NotEmpty(response.TrailingHeaders); 76Assert.Equal("TrailerValue", response.TrailingHeaders.GetValues("TrailerName").Single()); 86Assert.Equal(HttpVersion.Version20, response.Version); 87Assert.Equal("Hello World", await response.Content.ReadAsStringAsync()); 88Assert.NotEmpty(response.TrailingHeaders); 89Assert.Equal("Trailer Value", response.TrailingHeaders.GetValues("TrailerName").Single()); 101Assert.Equal(HttpVersion.Version20, response.Version); 102Assert.Equal(body, await response.Content.ReadAsStringAsync()); 103Assert.NotEmpty(response.TrailingHeaders); 104Assert.Equal("Trailer Value", response.TrailingHeaders.GetValues("TrailerName").Single()); 116Assert.Equal(HttpVersion.Version20, response.Version); 118Assert.True(response.Content.Headers.TryGetValues(HeaderNames.ContentLength, out var contentLength), HeaderNames.ContentLength); 119Assert.Equal((2 * body.Length).ToString(CultureInfo.InvariantCulture), contentLength.First()); 120Assert.Equal(body + body, await response.Content.ReadAsStringAsync()); 121Assert.NotEmpty(response.TrailingHeaders); 122Assert.Equal("Trailer Value", response.TrailingHeaders.GetValues("TrailerName").Single()); 134Assert.Equal(HttpVersion.Version20, response.Version); 136Assert.True(response.Content.Headers.TryGetValues(HeaderNames.ContentLength, out var contentLength), HeaderNames.ContentLength); 137Assert.Equal(body.Length.ToString(CultureInfo.InvariantCulture), contentLength.First()); 138Assert.Equal("TrailerName", response.Headers.Trailer.Single()); 139Assert.Equal(body, await response.Content.ReadAsStringAsync()); 140Assert.NotEmpty(response.TrailingHeaders); 141Assert.Equal("Trailer Value", response.TrailingHeaders.GetValues("TrailerName").Single()); 151Assert.Equal(HttpVersion.Version20, response.Version); 152Assert.NotEmpty(response.TrailingHeaders); 154Assert.Equal(new[] { "TrailerValue0", "TrailerValue1" }, response.TrailingHeaders.GetValues("TrailerName")); 165Assert.Equal(HttpVersion.Version20, response.Version); 166Assert.NotEmpty(response.TrailingHeaders); 167Assert.Equal("TrailerValue", response.TrailingHeaders.GetValues("TrailerName").Single()); 170Assert.True(response2.IsSuccessStatusCode); 181Assert.Equal(HttpVersion.Version20, response.Version); 182Assert.Equal("Hello World", await response.Content.ReadAsStringAsync()); 183Assert.NotEmpty(response.TrailingHeaders); 184Assert.Equal("Trailer Value", response.TrailingHeaders.GetValues("TrailerName").Single()); 187Assert.True(response2.IsSuccessStatusCode); 206Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 238Assert.True(response.IsSuccessStatusCode); 265Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection)); 266Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 299Assert.True(response.IsSuccessStatusCode); 323Assert.True(response.IsSuccessStatusCode); 327Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 354Assert.True(headerOrResetFrame.Type == Http2FrameType.HEADERS || headerOrResetFrame.Type == Http2FrameType.RST_STREAM); 440Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 470Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]);

53Assert.Equal(HttpVersion.Version30, response.Version); 54Assert.Equal("HTTP/3", await response.Content.ReadAsStringAsync()); 72Assert.Equal("HTTP/1.1", await response1.Content.ReadAsStringAsync()); 73Assert.Equal(altsvc, response1.Headers.GetValues(HeaderNames.AltSvc).SingleOrDefault()); 77Assert.Equal(HttpVersion.Version30, response3.Version); 78Assert.Equal("HTTP/3", await response3.Content.ReadAsStringAsync()); 94Assert.Equal(altsvc, response2.Headers.GetValues(HeaderNames.AltSvc).SingleOrDefault()); 95Assert.Equal("HTTP/2", await response2.Content.ReadAsStringAsync()); 99Assert.Equal("HTTP/3", response3); 112Assert.Equal("HTTP/3", result); 113Assert.Equal("value", response.TrailingHeaders.GetValues("custom").SingleOrDefault()); 123var ex = await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(address)); 124var qex = Assert.IsType<QuicException>(ex.InnerException); 125Assert.Equal(QuicError.StreamAborted, qex.QuicError); 126Assert.Equal(0x010b, qex.ApplicationErrorCode.Value); 139var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsStringAsync()); 140var qex = Assert.IsType<QuicException>(ex.InnerException?.InnerException?.InnerException); 141Assert.Equal(QuicError.StreamAborted, qex.QuicError); 142Assert.Equal(0x010c, qex.ApplicationErrorCode.Value); // H3_REQUEST_CANCELLED 156var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsStringAsync()); 157var qex = Assert.IsType<QuicException>(ex.InnerException?.InnerException?.InnerException); 158Assert.Equal(QuicError.StreamAborted, qex.QuicError); 159Assert.Equal(0x0102, qex.ApplicationErrorCode.Value); // H3_INTERNAL_ERROR 170var ex = await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(address)); 171var qex = Assert.IsType<QuicException>(ex.InnerException); 172Assert.Equal(QuicError.StreamAborted, qex.QuicError); 173Assert.Equal(0x010c, qex.ApplicationErrorCode.Value); // H3_REQUEST_CANCELLED

66Assert.Equal(port, new Uri(responseText).Port); 82Assert.InRange(new Uri(responseText).Port, _minPort, _maxPort); 97Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode); 128Assert.False(true); 146Assert.False(true);

70Assert.StartsWith("Windows", responseText); 71Assert.Contains(username, responseText); 76Assert.Equal("Windows", responseText);

143Assert.Equal(messages, await response.Content.ReadAsStringAsync()); 144Assert.True(response.Content.Headers.TryGetValues("Content-Type", out var contentTypes)); 145Assert.Single(contentTypes, "text/event-stream"); 148Assert.Contains("gzip", response.Content.GetType().FullName, StringComparison.OrdinalIgnoreCase);

139Assert.Contains(expectedEvent, frebEvent);

54Assert.Equal(_helloWorldResponse, responseText); 78Assert.Equal(_helloWorldResponse, responseText); 100Assert.False(response.IsSuccessStatusCode); 102Assert.Contains("500.0", responseString); 124Assert.Equal(_helloWorldResponse, responseText); 149Assert.Equal(_helloWorldResponse, responseText); 170Assert.Equal(_helloWorldResponse, responseText); 186Assert.Equal(_helloWorldResponse, responseText); 201Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 230Assert.Contains(TestSink.Writes, context => context.Message.Contains(version + @"\aspnetcorev2_outofprocess.dll"));

83Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 120Assert.Equal("411", decodedHeaders[InternalHeaderNames.Status]); 168Assert.Equal(Http2FrameType.WINDOW_UPDATE, windowUpdate.Type); 173Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 177Assert.Equal(Http2FrameType.DATA, dataFrame.Type); 178Assert.Equal(1, dataFrame.StreamId); 183Assert.False(dataFrame.DataEndStream); 185Assert.Equal(Http2FrameType.DATA, dataFrame.Type); 186Assert.Equal(1, dataFrame.StreamId); 189Assert.Equal(11, dataFrame.PayloadLength); 190Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 237Assert.Equal(Http2FrameType.WINDOW_UPDATE, windowUpdate.Type); 242Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 246Assert.Equal(Http2FrameType.DATA, dataFrame.Type); 247Assert.Equal(1, dataFrame.StreamId); 252Assert.False(dataFrame.DataEndStream); 254Assert.Equal(Http2FrameType.DATA, dataFrame.Type); 255Assert.Equal(1, dataFrame.StreamId); 258Assert.Equal(11, dataFrame.PayloadLength); 259Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 287Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 291Assert.Equal(Http2FrameType.DATA, dataFrame.Type); 292Assert.Equal(1, dataFrame.StreamId); 297Assert.False(dataFrame.DataEndStream); 299Assert.Equal(Http2FrameType.DATA, dataFrame.Type); 300Assert.Equal(1, dataFrame.StreamId); 303Assert.Equal(11, dataFrame.PayloadLength); 304Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 323Assert.Equal(HttpVersion.Version11, response.Version); 324Assert.Empty(response.TrailingHeaders); 343Assert.Equal("500", decodedHeaders[InternalHeaderNames.Status]); 363Assert.Equal("Hello World", response); 377Assert.Equal("Hello World", response);

97Assert.Equal($"Enabled;{cert.GetCertHashString()}", responseText); 101Assert.Equal("Disabled", responseText);

20Assert.True(deploymentResult.HostProcess.HasExited); 39Assert.True(deploymentResult.HostProcess.HasExited); 52Assert.True(0 == entries.Count, $"Some entries were not matched by any regex {FormatEntries(entries)}"); 72Assert.True(matchedEntries.Length > 0, $"No entries matched by '{regexString}'"); 73Assert.True(allowMultiple || matchedEntries.Length < 2, $"Multiple entries matched by '{regexString}': {FormatEntries(matchedEntries)}");

33Assert.Equal("Hello World", responseText); 160Assert.True(hostProcess.WaitForExit(timeout ?? (int)TimeoutExtensions.DefaultTimeoutValue.TotalMilliseconds)); 164Assert.Equal(0, hostProcess.ExitCode); 188Assert.NotNull(appPool);

54Assert.Equal(expectedResponse, await response.Content.ReadAsStringAsync()); 70Assert.Equal("Hello World", responseText);

37Assert.Equal(HttpStatusCode.OK, response.StatusCode); 41Assert.True(timings.Length > (int)HttpSysRequestTimingType.Http3HeaderDecodeEnd); 46Assert.True(headerStart > 0); 47Assert.True(headerEnd > 0); 48Assert.True(headerEnd > headerStart);

45Assert.Equal(HttpStatusCode.RequestEntityTooLarge, result.StatusCode); 68Assert.True(result.StatusCode == HttpStatusCode.NotFound || result.StatusCode == HttpStatusCode.RequestEntityTooLarge); 89Assert.Equal(HttpStatusCode.OK, result.StatusCode); 110Assert.Equal(HttpStatusCode.OK, result.StatusCode); 129Assert.True(requestLine.Contains("404") || requestLine.Contains("413")); 155Assert.Equal(HttpStatusCode.OK, result.StatusCode); 161Assert.Single(TestSink.Writes, w => w.Message.Contains("Increasing the MaxRequestBodySize conflicts with the max value for IIS limit maxAllowedContentLength." +

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

78Assert.Contains("TEST MESSAGE", contents); 79Assert.DoesNotContain("\r\n\r\n", contents); 80Assert.Contains("\r\n", contents); 174Assert.Contains("Switching debug log files to", logContents); 213Assert.False(response.IsSuccessStatusCode); 218Assert.Contains("彡⾔", contents); 235Assert.Single(Directory.GetFiles(LogFolderPath), Helpers.GetExpectedLogName(deploymentResult, LogFolderPath)); 302Assert.Contains(TestSink.Writes, context => context.Message.Contains(firstWriteString)); 322Assert.True(processIdMatch.Success, $"'{processIdPattern}' did not match '{aspnetcorev2Log}'"); 347Assert.Contains("[aspnetcorev2.dll]", logContents); 348Assert.True(logContents.Contains("[aspnetcorev2_inprocess.dll]") || logContents.Contains("[aspnetcorev2_outofprocess.dll]")); 349Assert.Contains("Description: IIS ASP.NET Core Module V2. Commit:", logContents); 350Assert.Contains("Description: IIS ASP.NET Core Module V2 Request Handler. Commit:", logContents); 357Assert.True(prefixMatch.Success, $"'{prefixPattern}' did not match '{log}'"); 362Assert.Equal(processId, prefixProcessId); 366Assert.True(DateTime.UtcNow > time); 368Assert.True(DateTime.UtcNow.AddHours(-2) < time);

46Assert.Equal(HttpStatusCode.RequestEntityTooLarge, result.StatusCode); 69Assert.True(result.StatusCode == HttpStatusCode.NotFound || result.StatusCode == HttpStatusCode.RequestEntityTooLarge); 90Assert.Equal(HttpStatusCode.OK, result.StatusCode); 111Assert.Equal(HttpStatusCode.OK, result.StatusCode); 130Assert.True(requestLine.Contains("404") || requestLine.Contains("413")); 156Assert.Equal(HttpStatusCode.OK, result.StatusCode); 162Assert.Single(TestSink.Writes, w => w.Message.Contains("Increasing the MaxRequestBodySize conflicts with the max value for IIS limit maxAllowedContentLength." +

49Assert.NotEqual(id2, id1); 61Assert.Equal(200, (int)result1.StatusCode); 62Assert.Equal(500, (int)result2.StatusCode); 67Assert.Contains("500.35", await result2.Content.ReadAsStringAsync()); 88Assert.Equal(200, (int)result1.StatusCode); 89Assert.Equal(500, (int)result2.StatusCode); 94Assert.Contains("500.34", await result2.Content.ReadAsStringAsync());

51Assert.Equal(200, status); 52Assert.Equal($"PathBase: {expectedPathBase}; Path: {expectedPath}", body); 81Assert.Equal(200, status); 82Assert.Equal($"PathBase: {expectedPathBase}; Path: {expectedPath}", body);

60Assert.Equal(200, response.Status); 62Assert.Equal("/ !\"#$%&'()*,-.%2F0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~", response.Body); 71Assert.Equal(200, response.Status); 72Assert.Equal("//a/b//c", response.Body); 82Assert.Equal(200, response.Status); 83Assert.Equal(expectedPath, response.Body); 93Assert.Equal(200, response.Status); 94Assert.Equal(expectedPath, response.Body); 108Assert.True(string.Equals(400, response.Status), i.ToString("X2", CultureInfo.InvariantCulture) + ";" + response); 119Assert.True(string.Equals(400, response.Status), i.ToString("X2", CultureInfo.InvariantCulture) + ";" + response); 132Assert.Equal("gzip", response.Content.Headers.ContentEncoding.Single()); 133Assert.Equal( 150Assert.Equal("gzip", response.Content.Headers.ContentEncoding.Single()); 151Assert.Equal( 168Assert.Equal(expected: 110000, actual: responseText.Length); 180Assert.Equal(body, responseText); 191Assert.Equal(body, responseText); 202Assert.Equal(requestBody.Length * 2, responseText.Length); 213Assert.Equal(body, response.Headers.GetValues("BodyAsString").Single()); 214Assert.Equal(body, responseText); 375Assert.Equal(10, (await _fixture.Client.GetByteArrayAsync($"/UnflushedResponsePipe")).Length); 382Assert.Equal(20, (await _fixture.Client.GetByteArrayAsync($"/FlushedPipeAndThenUnflushedPipe")).Length); 389Assert.Equal("SlowOnCompleted", await _fixture.Client.GetStringAsync($"/OnCompletedHttpContext")); 390Assert.Equal("", await _fixture.Client.GetStringAsync($"/OnCompletedHttpContext_Completed")); 400Assert.True(response.IsSuccessStatusCode); 403Assert.True(response2.IsSuccessStatusCode); 410Assert.Equal("SERVER_PORT: " + port, await _fixture.Client.GetStringAsync("/ServerVariable?q=SERVER_PORT")); 411Assert.Equal("QUERY_STRING: q=QUERY_STRING", await _fixture.Client.GetStringAsync("/ServerVariable?q=QUERY_STRING")); 417Assert.Equal("THIS_VAR_IS_UNDEFINED: (null)", await _fixture.Client.GetStringAsync("/ServerVariable?q=THIS_VAR_IS_UNDEFINED")); 423Assert.Equal("ROUNDTRIP: 1", await _fixture.Client.GetStringAsync("/ServerVariable?v=1&q=ROUNDTRIP")); 429Assert.DoesNotContain(@"\\?\", await _fixture.Client.GetStringAsync("/BasePath")); 438Assert.StartsWith("Response Begin", text); 439Assert.EndsWith("Response End", text); 447Assert.Equal("Success", result); 454Assert.Equal("Hello World", await result.Content.ReadAsStringAsync()); 466Assert.Equal("Success", result); 475Assert.Equal("Success", result); 484Assert.Equal("Success", await result.Content.ReadAsStringAsync()); 496Assert.Equal("Success", result); 503Assert.Equal("Success", result); 510Assert.Equal("Success", await result.Content.ReadAsStringAsync()); 518Assert.Equal(HttpStatusCode.OK, response.StatusCode); 519Assert.False(response.Headers.TryGetValues("EmptyHeader", out var headerValues)); 527Assert.Equal(HttpStatusCode.OK, response.StatusCode); 528Assert.Equal("Request Complete", responseText); 530Assert.True(response.Headers.TryGetValues("UnknownHeader", out var headerValues)); 531Assert.Equal("test123=foo", headerValues.First()); 533Assert.True(response.Content.Headers.TryGetValues(Net.Http.Headers.HeaderNames.ContentType, out headerValues)); 534Assert.Equal("text/plain", headerValues.First()); 536Assert.True(response.Headers.TryGetValues("MultiHeader", out headerValues)); 537Assert.Equal(2, headerValues.Count()); 538Assert.Equal("1", headerValues.First()); 539Assert.Equal("2", headerValues.Last()); 546Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 547Assert.Equal("Internal Server Error", response.ReasonPhrase); 569Assert.Equal((HttpStatusCode)code, response.StatusCode); 570Assert.Equal(expectedReason, response.ReasonPhrase); 573Assert.Equal(body ?? string.Empty, await response.Content.ReadAsStringAsync()); 584Assert.Equal((HttpStatusCode)code, response.StatusCode); 585Assert.DoesNotContain(response.Headers, h => h.Key.Equals("transfer-encoding", StringComparison.InvariantCultureIgnoreCase)); 592Assert.Equal("MyServer/7.8", response.Headers.Server.Single().Product.ToString()); 600Assert.Equal($"Started_{path}Threw_Finished", await _fixture.Client.GetStringAsync("/ResponseInvalidOrdering/" + path)); 607Assert.Equal(_fixture.DeploymentResult.ContentRoot, await _fixture.Client.GetStringAsync("/ContentRootPath")); 608Assert.Equal(_fixture.DeploymentResult.ContentRoot + "\\wwwroot", await _fixture.Client.GetStringAsync("/WebRootPath")); 609Assert.Equal(_fixture.DeploymentResult.ContentRoot, await _fixture.DeploymentResult.HttpClient.GetStringAsync("/CurrentDirectory")); 610Assert.Equal(_fixture.DeploymentResult.ContentRoot + "\\", await _fixture.Client.GetStringAsync("/BaseDirectory")); 611Assert.Equal(_fixture.DeploymentResult.ContentRoot + "\\", await _fixture.Client.GetStringAsync("/ASPNETCORE_IIS_PHYSICAL_PATH")); 633Assert.Equal(expected, await _fixture.Client.GetStringAsync($"/{endpoint}")); 643Assert.Equal(new string('a', query), await _fixture.Client.GetStringAsync($"/LargeResponseBody?length={query}")); 649Assert.Equal(200000000, (await _fixture.Client.GetStringAsync($"/LargeResponseFile")).Length); 658Assert.Equal("Success", await _fixture.Client.GetStringAsync(path + "/path" + "?query")); 666Assert.Equal(_fixture.Client.BaseAddress.ToString(), await _fixture.Client.GetStringAsync("/ServerAddresses")); 693Assert.Equal("Hello World", responseText); 806Assert.False(bytes0.IsEmpty);

58Assert.StartsWith("Windows:", responseText); 59Assert.Contains(Environment.UserName, responseText);

68Assert.True(result.HostProcess.HasExited); 73Assert.Empty(matchedEntries);

46Assert.False(response.IsSuccessStatusCode); 70Assert.False(response.IsSuccessStatusCode); 80Assert.Contains(@"Framework: 'Microsoft.NETCore.App', version '2.9.9' (x64)", contents); 81Assert.Contains(missingFrameworkString, contents); 100Assert.False(response.IsSuccessStatusCode); 107Assert.Contains("Invoked hostfxr", contents); 127Assert.False(response.IsSuccessStatusCode); 153Assert.False(response.IsSuccessStatusCode); 161Assert.Contains("Invoked hostfxr", contents);

20Assert.True(deploymentResult.HostProcess.HasExited); 39Assert.True(deploymentResult.HostProcess.HasExited); 52Assert.True(0 == entries.Count, $"Some entries were not matched by any regex {FormatEntries(entries)}"); 72Assert.True(matchedEntries.Length > 0, $"No entries matched by '{regexString}'"); 73Assert.True(allowMultiple || matchedEntries.Length < 2, $"Multiple entries matched by '{regexString}': {FormatEntries(matchedEntries)}");

33Assert.Equal("Hello World", responseText); 160Assert.True(hostProcess.WaitForExit(timeout ?? (int)TimeoutExtensions.DefaultTimeoutValue.TotalMilliseconds)); 164Assert.Equal(0, hostProcess.ExitCode); 188Assert.NotNull(appPool);

54Assert.Equal(expectedResponse, await response.Content.ReadAsStringAsync()); 70Assert.Equal("Hello World", responseText);

48Assert.Equal("Hello World", await deploymentResult.HttpClient.GetStringAsync("/HelloWorld")); 145Assert.Equal(500, (int)result.StatusCode); 146Assert.Contains("500.0", await result.Content.ReadAsStringAsync()); 164Assert.Equal(502, (int)result.StatusCode); 165Assert.Contains("502.5", await result.Content.ReadAsStringAsync()); 182Assert.Equal(500, (int)result.StatusCode); 183Assert.Contains("500.30", await result.Content.ReadAsStringAsync()); 278Assert.Equal(HttpStatusCode.OK, result.StatusCode); 290Assert.Equal(HttpStatusCode.OK, res.StatusCode); 315Assert.Equal(HttpStatusCode.OK, result.StatusCode); 327Assert.Equal(HttpStatusCode.OK, res.StatusCode); 420Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode); 577Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode); 616Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode); 624Assert.Contains("0x80072efe", await response.Content.ReadAsStringAsync()); 643Assert.True(false, "Should not reach here");

70Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 77Assert.Contains("500.0", await response.Content.ReadAsStringAsync()); 81Assert.Contains("500.0", await response.Content.ReadAsStringAsync()); 123Assert.Equal(1, TestSink.Writes.Count(w => w.Message.Contains("Invoking where.exe to find dotnet.exe"))); 155Assert.Equal(1, TestSink.Writes.Count(w => w.Message.Contains($"Found dotnet.exe in InstallLocation at '{installDir}\\dotnet.exe'"))); 179Assert.False(response.IsSuccessStatusCode); 214Assert.True(File.Exists(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.exe"))); 215Assert.False(File.Exists(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"))); 216Assert.Contains("InProcessWebSite.exe", Helpers.ReadAllTextFromFile(Path.Combine(deploymentResult.ContentRoot, "web.config"), Logger)); 229Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 247Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 264Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 429Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 431Assert.Contains("500.31", responseContent); 432Assert.Contains("Framework: 'Microsoft.NETCore.App', version '2.9.9'", responseContent); 480Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 492Assert.Contains("500.37", responseContent); 513Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 524Assert.Contains("500.37", responseContent); 539Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 560Assert.Equal(HttpStatusCode.InternalServerError, result.StatusCode); 604Assert.Equal(expectedArguments, await result.HttpClient.GetStringAsync("/CommandLineArgs")); 675Assert.Equal(expectedArguments, await result.HttpClient.GetStringAsync("/CommandLineArgs")); 713Assert.Equal(deploymentResult.ContentRoot, await deploymentResult.HttpClient.GetStringAsync("/ContentRootPath")); 714Assert.Equal(deploymentResult.ContentRoot + "\\wwwroot", await deploymentResult.HttpClient.GetStringAsync("/WebRootPath")); 715Assert.Equal(Path.GetDirectoryName(deploymentResult.HostProcess.MainModule.FileName), await deploymentResult.HttpClient.GetStringAsync("/CurrentDirectory")); 716Assert.Equal(deploymentResult.ContentRoot + "\\", await deploymentResult.HttpClient.GetStringAsync("/BaseDirectory")); 717Assert.Equal(deploymentResult.ContentRoot + "\\", await deploymentResult.HttpClient.GetStringAsync("/ASPNETCORE_IIS_PHYSICAL_PATH")); 738Assert.True(suspendedWaitHandle.WaitOne(TimeoutExtensions.DefaultTimeoutValue)); 748Assert.False(request.IsCompleted); 773Assert.False(result.IsSuccessStatusCode); 776Assert.Contains("InvalidOperationException", content); 777Assert.Contains("TestSite.Program.Main", content); 797Assert.False(result.IsSuccessStatusCode); 800Assert.Contains("InvalidOperationException", content); 801Assert.Contains("TestSite.Program.Main", content); 820Assert.False(result.IsSuccessStatusCode); 823Assert.Contains("InvalidOperationException", content); 824Assert.Contains("TestSite.Program.Main", content); 825Assert.Contains("From Configure", content); 845Assert.False(result.IsSuccessStatusCode); 848Assert.DoesNotContain("InvalidOperationException", content); 867Assert.False(result.IsSuccessStatusCode); 870Assert.DoesNotContain("InvalidOperationException", content); 889Assert.Equal("True", content); 907Assert.Equal("True", content); 919Assert.True(result.IsSuccessStatusCode); 931Assert.True(result.IsSuccessStatusCode); 975Assert.True(response.IsSuccessStatusCode); 982Assert.Contains(TestSink.Writes, context => context.Message.Contains("An unhandled exception was thrown by the application.")); 1006Assert.Contains(TestSink.Writes, context => context.Message.Contains(expectedLogString)); 1031Assert.Contains(expectedLogString, contents); 1048Assert.Contains(TestSink.Writes, context => context.Message.Contains("Is Console redirection: True")); 1060Assert.False(response.IsSuccessStatusCode); 1061Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1064Assert.Contains("500.30", responseText); 1074Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1079Assert.Contains("500.0", responseString); 1093Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode); 1098Assert.Contains("HTTP Error 502.5 - ANCM Out-Of-Process Startup Failure", responseString); 1116Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1121Assert.Contains("500.0", responseString); 1139Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1144Assert.Contains("500.30", responseString); 1163Assert.Equal( 1182Assert.Equal( 1199Assert.DoesNotContain("shouldberemoved", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_IIS_HTTPAUTH")); 1217Assert.Equal("Production", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_ENVIRONMENT")); 1236Assert.Equal("Asm1", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_HOSTINGSTARTUPASSEMBLIES")); 1240Assert.Equal("Asm1;Microsoft.AspNetCore.Server.IISIntegration", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_HOSTINGSTARTUPASSEMBLIES")); 1259Assert.Equal("Asm2", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_HOSTINGSTARTUPASSEMBLIES")); 1277Assert.Equal("World;Hello", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=OtherVariable")); 1294Assert.Equal(environment, await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_ENVIRONMENT")); 1319Assert.Equal(deploymentParameters.ApplicationBaseUriHint + appName, await client.GetStringAsync($"/{appName}/ServerAddresses")); 1343Assert.Equal("123", await client.GetStringAsync("/ANCM_HTTPS_PORT")); 1344Assert.Equal("NOVALUE", await client.GetStringAsync("/HTTPS_PORT")); 1384Assert.Equal(307, (int)response.StatusCode); 1389Assert.Equal(200, (int)response.StatusCode); 1420Assert.Equal("NOVALUE", await client.GetStringAsync("/ANCM_HTTPS_PORT")); 1436Assert.Equal(true, response.Headers.ConnectionClose); 1481Assert.EndsWith("</html>\r\n", responseString); 1487Assert.Contains("<a href=\"http://example\"> <cite> http://example </cite></a> and ", await response.Content.ReadAsStringAsync()); 1506Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1518Assert.True(matchedEntries.Length > 0); 1581Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1582Assert.Contains(error, await response.Content.ReadAsStringAsync()); 1596Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1600Assert.Contains(error, responseText);

29Assert.True(response.IsSuccessStatusCode); 38Assert.Equal("12.2.18316.0", handle.FileVersionInfo.FileVersion);

20Assert.True(deploymentResult.HostProcess.HasExited); 39Assert.True(deploymentResult.HostProcess.HasExited); 52Assert.True(0 == entries.Count, $"Some entries were not matched by any regex {FormatEntries(entries)}"); 72Assert.True(matchedEntries.Length > 0, $"No entries matched by '{regexString}'"); 73Assert.True(allowMultiple || matchedEntries.Length < 2, $"Multiple entries matched by '{regexString}': {FormatEntries(matchedEntries)}");

33Assert.Equal("Hello World", responseText); 160Assert.True(hostProcess.WaitForExit(timeout ?? (int)TimeoutExtensions.DefaultTimeoutValue.TotalMilliseconds)); 164Assert.Equal(0, hostProcess.ExitCode); 188Assert.NotNull(appPool);

54Assert.Equal(expectedResponse, await response.Content.ReadAsStringAsync()); 70Assert.Equal("Hello World", responseText);

48Assert.Equal("Hello World", await deploymentResult.HttpClient.GetStringAsync("/HelloWorld")); 145Assert.Equal(500, (int)result.StatusCode); 146Assert.Contains("500.0", await result.Content.ReadAsStringAsync()); 164Assert.Equal(502, (int)result.StatusCode); 165Assert.Contains("502.5", await result.Content.ReadAsStringAsync()); 182Assert.Equal(500, (int)result.StatusCode); 183Assert.Contains("500.30", await result.Content.ReadAsStringAsync()); 278Assert.Equal(HttpStatusCode.OK, result.StatusCode); 290Assert.Equal(HttpStatusCode.OK, res.StatusCode); 315Assert.Equal(HttpStatusCode.OK, result.StatusCode); 327Assert.Equal(HttpStatusCode.OK, res.StatusCode); 420Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode); 577Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode); 616Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode); 624Assert.Contains("0x80072efe", await response.Content.ReadAsStringAsync()); 643Assert.True(false, "Should not reach here");

70Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 77Assert.Contains("500.0", await response.Content.ReadAsStringAsync()); 81Assert.Contains("500.0", await response.Content.ReadAsStringAsync()); 123Assert.Equal(1, TestSink.Writes.Count(w => w.Message.Contains("Invoking where.exe to find dotnet.exe"))); 155Assert.Equal(1, TestSink.Writes.Count(w => w.Message.Contains($"Found dotnet.exe in InstallLocation at '{installDir}\\dotnet.exe'"))); 179Assert.False(response.IsSuccessStatusCode); 214Assert.True(File.Exists(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.exe"))); 215Assert.False(File.Exists(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"))); 216Assert.Contains("InProcessWebSite.exe", Helpers.ReadAllTextFromFile(Path.Combine(deploymentResult.ContentRoot, "web.config"), Logger)); 229Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 247Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 264Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 429Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 431Assert.Contains("500.31", responseContent); 432Assert.Contains("Framework: 'Microsoft.NETCore.App', version '2.9.9'", responseContent); 480Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 492Assert.Contains("500.37", responseContent); 513Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 524Assert.Contains("500.37", responseContent); 539Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 560Assert.Equal(HttpStatusCode.InternalServerError, result.StatusCode); 604Assert.Equal(expectedArguments, await result.HttpClient.GetStringAsync("/CommandLineArgs")); 675Assert.Equal(expectedArguments, await result.HttpClient.GetStringAsync("/CommandLineArgs")); 713Assert.Equal(deploymentResult.ContentRoot, await deploymentResult.HttpClient.GetStringAsync("/ContentRootPath")); 714Assert.Equal(deploymentResult.ContentRoot + "\\wwwroot", await deploymentResult.HttpClient.GetStringAsync("/WebRootPath")); 715Assert.Equal(Path.GetDirectoryName(deploymentResult.HostProcess.MainModule.FileName), await deploymentResult.HttpClient.GetStringAsync("/CurrentDirectory")); 716Assert.Equal(deploymentResult.ContentRoot + "\\", await deploymentResult.HttpClient.GetStringAsync("/BaseDirectory")); 717Assert.Equal(deploymentResult.ContentRoot + "\\", await deploymentResult.HttpClient.GetStringAsync("/ASPNETCORE_IIS_PHYSICAL_PATH")); 738Assert.True(suspendedWaitHandle.WaitOne(TimeoutExtensions.DefaultTimeoutValue)); 748Assert.False(request.IsCompleted); 773Assert.False(result.IsSuccessStatusCode); 776Assert.Contains("InvalidOperationException", content); 777Assert.Contains("TestSite.Program.Main", content); 797Assert.False(result.IsSuccessStatusCode); 800Assert.Contains("InvalidOperationException", content); 801Assert.Contains("TestSite.Program.Main", content); 820Assert.False(result.IsSuccessStatusCode); 823Assert.Contains("InvalidOperationException", content); 824Assert.Contains("TestSite.Program.Main", content); 825Assert.Contains("From Configure", content); 845Assert.False(result.IsSuccessStatusCode); 848Assert.DoesNotContain("InvalidOperationException", content); 867Assert.False(result.IsSuccessStatusCode); 870Assert.DoesNotContain("InvalidOperationException", content); 889Assert.Equal("True", content); 907Assert.Equal("True", content); 919Assert.True(result.IsSuccessStatusCode); 931Assert.True(result.IsSuccessStatusCode); 975Assert.True(response.IsSuccessStatusCode); 982Assert.Contains(TestSink.Writes, context => context.Message.Contains("An unhandled exception was thrown by the application.")); 1006Assert.Contains(TestSink.Writes, context => context.Message.Contains(expectedLogString)); 1031Assert.Contains(expectedLogString, contents); 1048Assert.Contains(TestSink.Writes, context => context.Message.Contains("Is Console redirection: True")); 1060Assert.False(response.IsSuccessStatusCode); 1061Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1064Assert.Contains("500.30", responseText); 1074Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1079Assert.Contains("500.0", responseString); 1093Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode); 1098Assert.Contains("HTTP Error 502.5 - ANCM Out-Of-Process Startup Failure", responseString); 1116Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1121Assert.Contains("500.0", responseString); 1139Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1144Assert.Contains("500.30", responseString); 1163Assert.Equal( 1182Assert.Equal( 1199Assert.DoesNotContain("shouldberemoved", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_IIS_HTTPAUTH")); 1217Assert.Equal("Production", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_ENVIRONMENT")); 1236Assert.Equal("Asm1", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_HOSTINGSTARTUPASSEMBLIES")); 1240Assert.Equal("Asm1;Microsoft.AspNetCore.Server.IISIntegration", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_HOSTINGSTARTUPASSEMBLIES")); 1259Assert.Equal("Asm2", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_HOSTINGSTARTUPASSEMBLIES")); 1277Assert.Equal("World;Hello", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=OtherVariable")); 1294Assert.Equal(environment, await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_ENVIRONMENT")); 1319Assert.Equal(deploymentParameters.ApplicationBaseUriHint + appName, await client.GetStringAsync($"/{appName}/ServerAddresses")); 1343Assert.Equal("123", await client.GetStringAsync("/ANCM_HTTPS_PORT")); 1344Assert.Equal("NOVALUE", await client.GetStringAsync("/HTTPS_PORT")); 1384Assert.Equal(307, (int)response.StatusCode); 1389Assert.Equal(200, (int)response.StatusCode); 1420Assert.Equal("NOVALUE", await client.GetStringAsync("/ANCM_HTTPS_PORT")); 1436Assert.Equal(true, response.Headers.ConnectionClose); 1481Assert.EndsWith("</html>\r\n", responseString); 1487Assert.Contains("<a href=\"http://example\"> <cite> http://example </cite></a> and ", await response.Content.ReadAsStringAsync()); 1506Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1518Assert.True(matchedEntries.Length > 0); 1581Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1582Assert.Contains(error, await response.Content.ReadAsStringAsync()); 1596Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1600Assert.Contains(error, responseText);

31Assert.Equal("12.2.19169.6", handle.FileVersionInfo.FileVersion);

20Assert.True(deploymentResult.HostProcess.HasExited); 39Assert.True(deploymentResult.HostProcess.HasExited); 52Assert.True(0 == entries.Count, $"Some entries were not matched by any regex {FormatEntries(entries)}"); 72Assert.True(matchedEntries.Length > 0, $"No entries matched by '{regexString}'"); 73Assert.True(allowMultiple || matchedEntries.Length < 2, $"Multiple entries matched by '{regexString}': {FormatEntries(matchedEntries)}");

33Assert.Equal("Hello World", responseText); 160Assert.True(hostProcess.WaitForExit(timeout ?? (int)TimeoutExtensions.DefaultTimeoutValue.TotalMilliseconds)); 164Assert.Equal(0, hostProcess.ExitCode); 188Assert.NotNull(appPool);

54Assert.Equal(expectedResponse, await response.Content.ReadAsStringAsync()); 70Assert.Equal("Hello World", responseText);

48Assert.Equal("Hello World", await deploymentResult.HttpClient.GetStringAsync("/HelloWorld")); 145Assert.Equal(500, (int)result.StatusCode); 146Assert.Contains("500.0", await result.Content.ReadAsStringAsync()); 164Assert.Equal(502, (int)result.StatusCode); 165Assert.Contains("502.5", await result.Content.ReadAsStringAsync()); 182Assert.Equal(500, (int)result.StatusCode); 183Assert.Contains("500.30", await result.Content.ReadAsStringAsync()); 278Assert.Equal(HttpStatusCode.OK, result.StatusCode); 290Assert.Equal(HttpStatusCode.OK, res.StatusCode); 315Assert.Equal(HttpStatusCode.OK, result.StatusCode); 327Assert.Equal(HttpStatusCode.OK, res.StatusCode); 420Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode); 577Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode); 616Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode); 621Assert.Contains("0x80072f78", await response.Content.ReadAsStringAsync()); 643Assert.True(false, "Should not reach here");

70Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 77Assert.Contains("500.0", await response.Content.ReadAsStringAsync()); 81Assert.Contains("500.0", await response.Content.ReadAsStringAsync()); 123Assert.Equal(1, TestSink.Writes.Count(w => w.Message.Contains("Invoking where.exe to find dotnet.exe"))); 155Assert.Equal(1, TestSink.Writes.Count(w => w.Message.Contains($"Found dotnet.exe in InstallLocation at '{installDir}\\dotnet.exe'"))); 179Assert.False(response.IsSuccessStatusCode); 214Assert.True(File.Exists(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.exe"))); 215Assert.False(File.Exists(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"))); 216Assert.Contains("InProcessWebSite.exe", Helpers.ReadAllTextFromFile(Path.Combine(deploymentResult.ContentRoot, "web.config"), Logger)); 229Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 247Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 264Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 429Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 431Assert.Contains("500.31", responseContent); 432Assert.Contains("Framework: 'Microsoft.NETCore.App', version '2.9.9'", responseContent); 480Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 492Assert.Contains("500.37", responseContent); 513Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 524Assert.Contains("500.37", responseContent); 539Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 560Assert.Equal(HttpStatusCode.InternalServerError, result.StatusCode); 604Assert.Equal(expectedArguments, await result.HttpClient.GetStringAsync("/CommandLineArgs")); 675Assert.Equal(expectedArguments, await result.HttpClient.GetStringAsync("/CommandLineArgs")); 713Assert.Equal(deploymentResult.ContentRoot, await deploymentResult.HttpClient.GetStringAsync("/ContentRootPath")); 714Assert.Equal(deploymentResult.ContentRoot + "\\wwwroot", await deploymentResult.HttpClient.GetStringAsync("/WebRootPath")); 715Assert.Equal(Path.GetDirectoryName(deploymentResult.HostProcess.MainModule.FileName), await deploymentResult.HttpClient.GetStringAsync("/CurrentDirectory")); 716Assert.Equal(deploymentResult.ContentRoot + "\\", await deploymentResult.HttpClient.GetStringAsync("/BaseDirectory")); 717Assert.Equal(deploymentResult.ContentRoot + "\\", await deploymentResult.HttpClient.GetStringAsync("/ASPNETCORE_IIS_PHYSICAL_PATH")); 738Assert.True(suspendedWaitHandle.WaitOne(TimeoutExtensions.DefaultTimeoutValue)); 748Assert.False(request.IsCompleted); 773Assert.False(result.IsSuccessStatusCode); 776Assert.Contains("InvalidOperationException", content); 777Assert.Contains("TestSite.Program.Main", content); 797Assert.False(result.IsSuccessStatusCode); 800Assert.Contains("InvalidOperationException", content); 801Assert.Contains("TestSite.Program.Main", content); 820Assert.False(result.IsSuccessStatusCode); 823Assert.Contains("InvalidOperationException", content); 824Assert.Contains("TestSite.Program.Main", content); 825Assert.Contains("From Configure", content); 845Assert.False(result.IsSuccessStatusCode); 848Assert.DoesNotContain("InvalidOperationException", content); 867Assert.False(result.IsSuccessStatusCode); 870Assert.DoesNotContain("InvalidOperationException", content); 889Assert.Equal("True", content); 907Assert.Equal("True", content); 919Assert.True(result.IsSuccessStatusCode); 931Assert.True(result.IsSuccessStatusCode); 975Assert.True(response.IsSuccessStatusCode); 982Assert.Contains(TestSink.Writes, context => context.Message.Contains("An unhandled exception was thrown by the application.")); 1006Assert.Contains(TestSink.Writes, context => context.Message.Contains(expectedLogString)); 1031Assert.Contains(expectedLogString, contents); 1048Assert.Contains(TestSink.Writes, context => context.Message.Contains("Is Console redirection: True")); 1060Assert.False(response.IsSuccessStatusCode); 1061Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1064Assert.Contains("500.30", responseText); 1074Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1079Assert.Contains("500.0", responseString); 1093Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode); 1098Assert.Contains("HTTP Error 502.5 - ANCM Out-Of-Process Startup Failure", responseString); 1116Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1121Assert.Contains("500.0", responseString); 1139Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1144Assert.Contains("500.30", responseString); 1163Assert.Equal( 1182Assert.Equal( 1199Assert.DoesNotContain("shouldberemoved", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_IIS_HTTPAUTH")); 1217Assert.Equal("Production", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_ENVIRONMENT")); 1236Assert.Equal("Asm1", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_HOSTINGSTARTUPASSEMBLIES")); 1240Assert.Equal("Asm1;Microsoft.AspNetCore.Server.IISIntegration", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_HOSTINGSTARTUPASSEMBLIES")); 1259Assert.Equal("Asm2", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_HOSTINGSTARTUPASSEMBLIES")); 1277Assert.Equal("World;Hello", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=OtherVariable")); 1294Assert.Equal(environment, await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_ENVIRONMENT")); 1319Assert.Equal(deploymentParameters.ApplicationBaseUriHint + appName, await client.GetStringAsync($"/{appName}/ServerAddresses")); 1343Assert.Equal("123", await client.GetStringAsync("/ANCM_HTTPS_PORT")); 1344Assert.Equal("NOVALUE", await client.GetStringAsync("/HTTPS_PORT")); 1384Assert.Equal(307, (int)response.StatusCode); 1389Assert.Equal(200, (int)response.StatusCode); 1420Assert.Equal("NOVALUE", await client.GetStringAsync("/ANCM_HTTPS_PORT")); 1436Assert.Equal(true, response.Headers.ConnectionClose); 1481Assert.EndsWith("</html>\r\n", responseString); 1487Assert.Contains("<a href=\"http://example\"> <cite> http://example </cite></a> and ", await response.Content.ReadAsStringAsync()); 1506Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1518Assert.True(matchedEntries.Length > 0); 1581Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1582Assert.Contains(error, await response.Content.ReadAsStringAsync()); 1596Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1600Assert.Contains(error, responseText);

28Assert.True(response.IsSuccessStatusCode); 54Assert.True(response.IsSuccessStatusCode); 88Assert.True(response.IsSuccessStatusCode); 119Assert.True(response.IsSuccessStatusCode); 138Assert.True(response.IsSuccessStatusCode); 155Assert.True(response.IsSuccessStatusCode); 169Assert.True(response.IsSuccessStatusCode); 184Assert.True(response.IsSuccessStatusCode); 195Assert.True(response.IsSuccessStatusCode); 211Assert.True(response.IsSuccessStatusCode); 220Assert.False(Directory.Exists(Path.Combine(directory.DirectoryPath, "0")), "Expected 0 shadow copy directory to be skipped"); 225Assert.True(response.ReasonPhrase == "Application Shutting Down" || response.ReasonPhrase == "Server has been shutdown"); 231Assert.True(Directory.Exists(Path.Combine(directory.DirectoryPath, "2")), "Expected 2 shadow copy directory"); 234Assert.True(response.IsSuccessStatusCode); 252Assert.True(response.IsSuccessStatusCode); 261Assert.False(Directory.Exists(Path.Combine(directory.DirectoryPath, "0")), "Expected 0 shadow copy directory to be skipped"); 266Assert.True(response.ReasonPhrase == "Application Shutting Down" || response.ReasonPhrase == "Server has been shutdown"); 272Assert.True(Directory.Exists(Path.Combine(directory.DirectoryPath, "11")), "Expected 11 shadow copy directory"); 275Assert.True(response.IsSuccessStatusCode); 278Assert.False(Directory.Exists(Path.Combine(directory.DirectoryPath, "1")), "Expected 1 shadow copy directory to be deleted"); 279Assert.False(Directory.Exists(Path.Combine(directory.DirectoryPath, "3")), "Expected 3 shadow copy directory to be deleted"); 294Assert.True(response.IsSuccessStatusCode); 304Assert.True(Directory.Exists(Path.Combine(deploymentResult.ContentRoot, "ShadowCopy"))); 306Assert.False(Directory.Exists(Path.Combine(deploymentResult.ContentRoot, "ShadowCopy", "0", "ShadowCopy"))); 309Assert.True(response.IsSuccessStatusCode); 324Assert.True(response.IsSuccessStatusCode); 334Assert.True(Directory.Exists(Path.Combine(deploymentResult.ContentRoot, "ShadowCopy"))); 336Assert.False(Directory.Exists(Path.Combine(deploymentResult.ContentRoot, "ShadowCopy", "0", "ShadowCopy"))); 339Assert.True(response.IsSuccessStatusCode);

20Assert.True(deploymentResult.HostProcess.HasExited); 39Assert.True(deploymentResult.HostProcess.HasExited); 52Assert.True(0 == entries.Count, $"Some entries were not matched by any regex {FormatEntries(entries)}"); 72Assert.True(matchedEntries.Length > 0, $"No entries matched by '{regexString}'"); 73Assert.True(allowMultiple || matchedEntries.Length < 2, $"Multiple entries matched by '{regexString}': {FormatEntries(matchedEntries)}");

33Assert.Equal("Hello World", responseText); 160Assert.True(hostProcess.WaitForExit(timeout ?? (int)TimeoutExtensions.DefaultTimeoutValue.TotalMilliseconds)); 164Assert.Equal(0, hostProcess.ExitCode); 188Assert.NotNull(appPool);

54Assert.Equal(expectedResponse, await response.Content.ReadAsStringAsync()); 70Assert.Equal("Hello World", responseText);

95Assert.IsType<OperationCanceledException>(exception); 134Assert.IsType<ConnectionResetException>(exception); 135Assert.Equal("The client has disconnected", exception.Message); 177Assert.IsType<OperationCanceledException>(exception); 218Assert.IsType<OperationCanceledException>(exception); 275Assert.IsType<ConnectionResetException>(exception); 276Assert.Equal("The client has disconnected", exception.Message); 294Assert.True(!task.IsCompleted); 347Assert.Single(TestSink.Writes, w => w.EventId.Name == "ConnectionDisconnect");

30Assert.NotNull(connectionId);

26Assert.False(bodyControl.AllowSynchronousIO); 52Assert.IsType<InvalidOperationException>(readException); 53Assert.IsType<InvalidOperationException>(writeException);

57Assert.Equal(CoreStrings.BadRequest_RequestBodyTooLarge, exception.Message); 75Assert.Equal(maxRequestSize, feature.MaxRequestBodySize); 100Assert.Equal(CoreStrings.BadRequest_RequestBodyTooLarge, exception.Message); 111Assert.Equal(0, feature.MaxRequestBodySize); 138Assert.Equal(0, feature.MaxRequestBodySize); 246Assert.Equal(1, await ctx.Request.Body.ReadAsync(buffer, 0, 1)); 249Assert.True(feature.IsReadOnly); 251invalidOpEx = Assert.Throws<InvalidOperationException>(() => 309Assert.NotNull(exception); 310Assert.Equal(CoreStrings.BadRequest_RequestBodyTooLarge, exception.Message); 324requestRejectedEx1 = await Assert.ThrowsAnyAsync<BadHttpRequestException>( 326requestRejectedEx2 = await Assert.ThrowsAnyAsync<BadHttpRequestException>( 344Assert.NotNull(requestRejectedEx1); 345Assert.NotNull(requestRejectedEx2); 346Assert.Equal(CoreStrings.BadRequest_RequestBodyTooLarge, requestRejectedEx1.Message); 347Assert.Equal(CoreStrings.BadRequest_RequestBodyTooLarge, requestRejectedEx2.Message); 357var appErrorLog = Assert.Single(TestSink.Writes, w => w.LoggerName == "Microsoft.AspNetCore.Server.IIS.Core.IISHttpServer" && w.LogLevel > LogLevel.Debug); 358var badRequestLog = Assert.Single(TestSink.Writes, w => w.LoggerName == "Microsoft.AspNetCore.Server.IIS.Core.IISHttpServer" && w.EventId == new EventId(4, "ConnectionBadRequest")); 360Assert.Equal(new EventId(2, "ApplicationError"), appErrorLog.EventId); 361Assert.Equal(LogLevel.Error, appErrorLog.LogLevel); 362Assert.Same(thrownError, appErrorLog.Exception); 363Assert.Same(thrownError, badRequestLog.Exception);

93Assert.IsType<ConnectionAbortedException>(exception); 122Assert.Null(exception); 144Assert.True(tokenAborted); 157Assert.True(token.WaitHandle.WaitOne(10000)); 158Assert.True(ctx.RequestAborted.WaitHandle.WaitOne(10000)); 159Assert.Equal(token, originalRegistration.Token);

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

31Assert.Equal(helloWorld, await result.Content.ReadAsStringAsync()); 32Assert.Equal(expectedPath, path);

30Assert.NotNull(tlsHandshakeFeature); 33Assert.True(protocol > SslProtocols.None, "Protocol: " + protocol); 34Assert.True(Enum.IsDefined(typeof(SslProtocols), protocol), "Defined: " + protocol); // Mapping is required, make sure it's current 37Assert.True(cipherAlgorithm > CipherAlgorithmType.Null, "Cipher: " + cipherAlgorithm); 40Assert.True(cipherStrength > 0, "CipherStrength: " + cipherStrength); 43Assert.True(hashAlgorithm >= HashAlgorithmType.None, "HashAlgorithm: " + hashAlgorithm); 46Assert.True(hashStrength >= 0, "HashStrength: " + hashStrength); // May be 0 for some algorithms 49Assert.True(keyExchangeAlgorithm >= ExchangeAlgorithmType.None, "KeyExchangeAlgorithm: " + keyExchangeAlgorithm); 52Assert.True(keyExchangeStrength >= 0, "KeyExchangeStrength: " + keyExchangeStrength); 57Assert.Equal("localhost", hostName); 74Assert.Null(tlsHandshakeFeature);

58Assert.Contains(TestSink.Writes, context => context.Message.Contains("Drained all requests, notifying managed.")); 64Assert.True(false);

34Assert.Equal(HttpStatusCode.OK, response.StatusCode); 35Assert.Equal("Anonymous?True", responseText); 39Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); 40Assert.Contains("NTLM", response.Headers.WwwAuthenticate.ToString()); 41Assert.Contains("Negotiate", response.Headers.WwwAuthenticate.ToString()); 45Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); 46Assert.Contains("NTLM", response.Headers.WwwAuthenticate.ToString()); 48Assert.Contains("Negotiate", response.Headers.WwwAuthenticate.ToString()); 52Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); 59Assert.Equal(HttpStatusCode.OK, response.StatusCode); 60Assert.Equal("Anonymous?True", responseText); 64Assert.Equal(HttpStatusCode.OK, response.StatusCode); 65Assert.NotEmpty(responseText);

57Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode); 87Assert.True(result.HostProcess.ExitCode == 0); 99Assert.True(result.HostProcess.ExitCode == 1);

161Assert.Equal(expectedMessage, Encoding.ASCII.GetString(received));

55Assert.Equal(HttpStatusCode.OK, response.StatusCode); 57Assert.Equal("Hello World", responseText);

48Assert.Equal(HttpStatusCode.OK, response.StatusCode); 49Assert.Equal("Hello World", responseText); 54Assert.Equal(HttpStatusCode.OK, response.StatusCode); 55Assert.Equal("Anonymous?True", responseText); 58Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); 59Assert.Contains("NTLM", response.Headers.WwwAuthenticate.ToString()); 60Assert.Contains("Negotiate", response.Headers.WwwAuthenticate.ToString()); 63Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); 64Assert.Contains("NTLM", response.Headers.WwwAuthenticate.ToString()); 66Assert.Contains("Negotiate", response.Headers.WwwAuthenticate.ToString()); 69Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode); 76Assert.Equal(HttpStatusCode.OK, response.StatusCode); 77Assert.Equal("Anonymous?True", responseText); 81Assert.Equal(HttpStatusCode.OK, response.StatusCode); 82Assert.Equal("Windows", responseText);

66Assert.Equal(port, new Uri(responseText).Port); 82Assert.InRange(new Uri(responseText).Port, _minPort, _maxPort); 97Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode); 128Assert.False(true); 146Assert.False(true);

70Assert.StartsWith("Windows", responseText); 71Assert.Contains(username, responseText); 76Assert.Equal("Windows", responseText);

143Assert.Equal(messages, await response.Content.ReadAsStringAsync()); 144Assert.True(response.Content.Headers.TryGetValues("Content-Type", out var contentTypes)); 145Assert.Single(contentTypes, "text/event-stream"); 148Assert.Contains("gzip", response.Content.GetType().FullName, StringComparison.OrdinalIgnoreCase);

139Assert.Contains(expectedEvent, frebEvent);

54Assert.Equal(_helloWorldResponse, responseText); 78Assert.Equal(_helloWorldResponse, responseText); 100Assert.False(response.IsSuccessStatusCode); 102Assert.Contains("500.0", responseString); 124Assert.Equal(_helloWorldResponse, responseText); 149Assert.Equal(_helloWorldResponse, responseText); 170Assert.Equal(_helloWorldResponse, responseText); 186Assert.Equal(_helloWorldResponse, responseText); 201Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 230Assert.Contains(TestSink.Writes, context => context.Message.Contains(version + @"\aspnetcorev2_outofprocess.dll"));

83Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 120Assert.Equal("411", decodedHeaders[InternalHeaderNames.Status]); 168Assert.Equal(Http2FrameType.WINDOW_UPDATE, windowUpdate.Type); 173Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 177Assert.Equal(Http2FrameType.DATA, dataFrame.Type); 178Assert.Equal(1, dataFrame.StreamId); 183Assert.False(dataFrame.DataEndStream); 185Assert.Equal(Http2FrameType.DATA, dataFrame.Type); 186Assert.Equal(1, dataFrame.StreamId); 189Assert.Equal(11, dataFrame.PayloadLength); 190Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 237Assert.Equal(Http2FrameType.WINDOW_UPDATE, windowUpdate.Type); 242Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 246Assert.Equal(Http2FrameType.DATA, dataFrame.Type); 247Assert.Equal(1, dataFrame.StreamId); 252Assert.False(dataFrame.DataEndStream); 254Assert.Equal(Http2FrameType.DATA, dataFrame.Type); 255Assert.Equal(1, dataFrame.StreamId); 258Assert.Equal(11, dataFrame.PayloadLength); 259Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 287Assert.Equal("200", decodedHeaders[InternalHeaderNames.Status]); 291Assert.Equal(Http2FrameType.DATA, dataFrame.Type); 292Assert.Equal(1, dataFrame.StreamId); 297Assert.False(dataFrame.DataEndStream); 299Assert.Equal(Http2FrameType.DATA, dataFrame.Type); 300Assert.Equal(1, dataFrame.StreamId); 303Assert.Equal(11, dataFrame.PayloadLength); 304Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 323Assert.Equal(HttpVersion.Version11, response.Version); 324Assert.Empty(response.TrailingHeaders); 343Assert.Equal("500", decodedHeaders[InternalHeaderNames.Status]); 363Assert.Equal("Hello World", response); 377Assert.Equal("Hello World", response);

97Assert.Equal($"Enabled;{cert.GetCertHashString()}", responseText); 101Assert.Equal("Disabled", responseText);

20Assert.True(deploymentResult.HostProcess.HasExited); 39Assert.True(deploymentResult.HostProcess.HasExited); 52Assert.True(0 == entries.Count, $"Some entries were not matched by any regex {FormatEntries(entries)}"); 72Assert.True(matchedEntries.Length > 0, $"No entries matched by '{regexString}'"); 73Assert.True(allowMultiple || matchedEntries.Length < 2, $"Multiple entries matched by '{regexString}': {FormatEntries(matchedEntries)}");

33Assert.Equal("Hello World", responseText); 160Assert.True(hostProcess.WaitForExit(timeout ?? (int)TimeoutExtensions.DefaultTimeoutValue.TotalMilliseconds)); 164Assert.Equal(0, hostProcess.ExitCode); 188Assert.NotNull(appPool);

54Assert.Equal(expectedResponse, await response.Content.ReadAsStringAsync()); 70Assert.Equal("Hello World", responseText);

37Assert.Equal(HttpStatusCode.OK, response.StatusCode); 41Assert.True(timings.Length > (int)HttpSysRequestTimingType.Http3HeaderDecodeEnd); 46Assert.True(headerStart > 0); 47Assert.True(headerEnd > 0); 48Assert.True(headerEnd > headerStart);

45Assert.Equal(HttpStatusCode.RequestEntityTooLarge, result.StatusCode); 68Assert.True(result.StatusCode == HttpStatusCode.NotFound || result.StatusCode == HttpStatusCode.RequestEntityTooLarge); 89Assert.Equal(HttpStatusCode.OK, result.StatusCode); 110Assert.Equal(HttpStatusCode.OK, result.StatusCode); 129Assert.True(requestLine.Contains("404") || requestLine.Contains("413")); 155Assert.Equal(HttpStatusCode.OK, result.StatusCode); 161Assert.Single(TestSink.Writes, w => w.Message.Contains("Increasing the MaxRequestBodySize conflicts with the max value for IIS limit maxAllowedContentLength." +

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

78Assert.Contains("TEST MESSAGE", contents); 79Assert.DoesNotContain("\r\n\r\n", contents); 80Assert.Contains("\r\n", contents); 174Assert.Contains("Switching debug log files to", logContents); 213Assert.False(response.IsSuccessStatusCode); 218Assert.Contains("彡⾔", contents); 235Assert.Single(Directory.GetFiles(LogFolderPath), Helpers.GetExpectedLogName(deploymentResult, LogFolderPath)); 302Assert.Contains(TestSink.Writes, context => context.Message.Contains(firstWriteString)); 322Assert.True(processIdMatch.Success, $"'{processIdPattern}' did not match '{aspnetcorev2Log}'"); 347Assert.Contains("[aspnetcorev2.dll]", logContents); 348Assert.True(logContents.Contains("[aspnetcorev2_inprocess.dll]") || logContents.Contains("[aspnetcorev2_outofprocess.dll]")); 349Assert.Contains("Description: IIS ASP.NET Core Module V2. Commit:", logContents); 350Assert.Contains("Description: IIS ASP.NET Core Module V2 Request Handler. Commit:", logContents); 357Assert.True(prefixMatch.Success, $"'{prefixPattern}' did not match '{log}'"); 362Assert.Equal(processId, prefixProcessId); 366Assert.True(DateTime.UtcNow > time); 368Assert.True(DateTime.UtcNow.AddHours(-2) < time);

46Assert.Equal(HttpStatusCode.RequestEntityTooLarge, result.StatusCode); 69Assert.True(result.StatusCode == HttpStatusCode.NotFound || result.StatusCode == HttpStatusCode.RequestEntityTooLarge); 90Assert.Equal(HttpStatusCode.OK, result.StatusCode); 111Assert.Equal(HttpStatusCode.OK, result.StatusCode); 130Assert.True(requestLine.Contains("404") || requestLine.Contains("413")); 156Assert.Equal(HttpStatusCode.OK, result.StatusCode); 162Assert.Single(TestSink.Writes, w => w.Message.Contains("Increasing the MaxRequestBodySize conflicts with the max value for IIS limit maxAllowedContentLength." +

49Assert.NotEqual(id2, id1); 61Assert.Equal(200, (int)result1.StatusCode); 62Assert.Equal(500, (int)result2.StatusCode); 67Assert.Contains("500.35", await result2.Content.ReadAsStringAsync()); 88Assert.Equal(200, (int)result1.StatusCode); 89Assert.Equal(500, (int)result2.StatusCode); 94Assert.Contains("500.34", await result2.Content.ReadAsStringAsync());

51Assert.Equal(200, status); 52Assert.Equal($"PathBase: {expectedPathBase}; Path: {expectedPath}", body); 81Assert.Equal(200, status); 82Assert.Equal($"PathBase: {expectedPathBase}; Path: {expectedPath}", body);

60Assert.Equal(200, response.Status); 62Assert.Equal("/ !\"#$%&'()*,-.%2F0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~", response.Body); 71Assert.Equal(200, response.Status); 72Assert.Equal("//a/b//c", response.Body); 82Assert.Equal(200, response.Status); 83Assert.Equal(expectedPath, response.Body); 93Assert.Equal(200, response.Status); 94Assert.Equal(expectedPath, response.Body); 108Assert.True(string.Equals(400, response.Status), i.ToString("X2", CultureInfo.InvariantCulture) + ";" + response); 119Assert.True(string.Equals(400, response.Status), i.ToString("X2", CultureInfo.InvariantCulture) + ";" + response); 132Assert.Equal("gzip", response.Content.Headers.ContentEncoding.Single()); 133Assert.Equal( 150Assert.Equal("gzip", response.Content.Headers.ContentEncoding.Single()); 151Assert.Equal( 168Assert.Equal(expected: 110000, actual: responseText.Length); 180Assert.Equal(body, responseText); 191Assert.Equal(body, responseText); 202Assert.Equal(requestBody.Length * 2, responseText.Length); 213Assert.Equal(body, response.Headers.GetValues("BodyAsString").Single()); 214Assert.Equal(body, responseText); 375Assert.Equal(10, (await _fixture.Client.GetByteArrayAsync($"/UnflushedResponsePipe")).Length); 382Assert.Equal(20, (await _fixture.Client.GetByteArrayAsync($"/FlushedPipeAndThenUnflushedPipe")).Length); 389Assert.Equal("SlowOnCompleted", await _fixture.Client.GetStringAsync($"/OnCompletedHttpContext")); 390Assert.Equal("", await _fixture.Client.GetStringAsync($"/OnCompletedHttpContext_Completed")); 400Assert.True(response.IsSuccessStatusCode); 403Assert.True(response2.IsSuccessStatusCode); 410Assert.Equal("SERVER_PORT: " + port, await _fixture.Client.GetStringAsync("/ServerVariable?q=SERVER_PORT")); 411Assert.Equal("QUERY_STRING: q=QUERY_STRING", await _fixture.Client.GetStringAsync("/ServerVariable?q=QUERY_STRING")); 417Assert.Equal("THIS_VAR_IS_UNDEFINED: (null)", await _fixture.Client.GetStringAsync("/ServerVariable?q=THIS_VAR_IS_UNDEFINED")); 423Assert.Equal("ROUNDTRIP: 1", await _fixture.Client.GetStringAsync("/ServerVariable?v=1&q=ROUNDTRIP")); 429Assert.DoesNotContain(@"\\?\", await _fixture.Client.GetStringAsync("/BasePath")); 438Assert.StartsWith("Response Begin", text); 439Assert.EndsWith("Response End", text); 447Assert.Equal("Success", result); 454Assert.Equal("Hello World", await result.Content.ReadAsStringAsync()); 466Assert.Equal("Success", result); 475Assert.Equal("Success", result); 484Assert.Equal("Success", await result.Content.ReadAsStringAsync()); 496Assert.Equal("Success", result); 503Assert.Equal("Success", result); 510Assert.Equal("Success", await result.Content.ReadAsStringAsync()); 518Assert.Equal(HttpStatusCode.OK, response.StatusCode); 519Assert.False(response.Headers.TryGetValues("EmptyHeader", out var headerValues)); 527Assert.Equal(HttpStatusCode.OK, response.StatusCode); 528Assert.Equal("Request Complete", responseText); 530Assert.True(response.Headers.TryGetValues("UnknownHeader", out var headerValues)); 531Assert.Equal("test123=foo", headerValues.First()); 533Assert.True(response.Content.Headers.TryGetValues(Net.Http.Headers.HeaderNames.ContentType, out headerValues)); 534Assert.Equal("text/plain", headerValues.First()); 536Assert.True(response.Headers.TryGetValues("MultiHeader", out headerValues)); 537Assert.Equal(2, headerValues.Count()); 538Assert.Equal("1", headerValues.First()); 539Assert.Equal("2", headerValues.Last()); 546Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 547Assert.Equal("Internal Server Error", response.ReasonPhrase); 569Assert.Equal((HttpStatusCode)code, response.StatusCode); 570Assert.Equal(expectedReason, response.ReasonPhrase); 573Assert.Equal(body ?? string.Empty, await response.Content.ReadAsStringAsync()); 584Assert.Equal((HttpStatusCode)code, response.StatusCode); 585Assert.DoesNotContain(response.Headers, h => h.Key.Equals("transfer-encoding", StringComparison.InvariantCultureIgnoreCase)); 592Assert.Equal("MyServer/7.8", response.Headers.Server.Single().Product.ToString()); 600Assert.Equal($"Started_{path}Threw_Finished", await _fixture.Client.GetStringAsync("/ResponseInvalidOrdering/" + path)); 607Assert.Equal(_fixture.DeploymentResult.ContentRoot, await _fixture.Client.GetStringAsync("/ContentRootPath")); 608Assert.Equal(_fixture.DeploymentResult.ContentRoot + "\\wwwroot", await _fixture.Client.GetStringAsync("/WebRootPath")); 609Assert.Equal(_fixture.DeploymentResult.ContentRoot, await _fixture.DeploymentResult.HttpClient.GetStringAsync("/CurrentDirectory")); 610Assert.Equal(_fixture.DeploymentResult.ContentRoot + "\\", await _fixture.Client.GetStringAsync("/BaseDirectory")); 611Assert.Equal(_fixture.DeploymentResult.ContentRoot + "\\", await _fixture.Client.GetStringAsync("/ASPNETCORE_IIS_PHYSICAL_PATH")); 633Assert.Equal(expected, await _fixture.Client.GetStringAsync($"/{endpoint}")); 643Assert.Equal(new string('a', query), await _fixture.Client.GetStringAsync($"/LargeResponseBody?length={query}")); 649Assert.Equal(200000000, (await _fixture.Client.GetStringAsync($"/LargeResponseFile")).Length); 658Assert.Equal("Success", await _fixture.Client.GetStringAsync(path + "/path" + "?query")); 666Assert.Equal(_fixture.Client.BaseAddress.ToString(), await _fixture.Client.GetStringAsync("/ServerAddresses")); 693Assert.Equal("Hello World", responseText); 806Assert.False(bytes0.IsEmpty);

58Assert.StartsWith("Windows:", responseText); 59Assert.Contains(Environment.UserName, responseText);

48Assert.Equal("Hello World", await deploymentResult.HttpClient.GetStringAsync("/HelloWorld")); 145Assert.Equal(500, (int)result.StatusCode); 146Assert.Contains("500.0", await result.Content.ReadAsStringAsync()); 164Assert.Equal(502, (int)result.StatusCode); 165Assert.Contains("502.5", await result.Content.ReadAsStringAsync()); 182Assert.Equal(500, (int)result.StatusCode); 183Assert.Contains("500.30", await result.Content.ReadAsStringAsync()); 278Assert.Equal(HttpStatusCode.OK, result.StatusCode); 290Assert.Equal(HttpStatusCode.OK, res.StatusCode); 315Assert.Equal(HttpStatusCode.OK, result.StatusCode); 327Assert.Equal(HttpStatusCode.OK, res.StatusCode); 420Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode); 577Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode); 616Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode); 624Assert.Contains("0x80072efe", await response.Content.ReadAsStringAsync()); 643Assert.True(false, "Should not reach here");

70Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 77Assert.Contains("500.0", await response.Content.ReadAsStringAsync()); 81Assert.Contains("500.0", await response.Content.ReadAsStringAsync()); 123Assert.Equal(1, TestSink.Writes.Count(w => w.Message.Contains("Invoking where.exe to find dotnet.exe"))); 155Assert.Equal(1, TestSink.Writes.Count(w => w.Message.Contains($"Found dotnet.exe in InstallLocation at '{installDir}\\dotnet.exe'"))); 179Assert.False(response.IsSuccessStatusCode); 214Assert.True(File.Exists(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.exe"))); 215Assert.False(File.Exists(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"))); 216Assert.Contains("InProcessWebSite.exe", Helpers.ReadAllTextFromFile(Path.Combine(deploymentResult.ContentRoot, "web.config"), Logger)); 229Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 247Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 264Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 429Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 431Assert.Contains("500.31", responseContent); 432Assert.Contains("Framework: 'Microsoft.NETCore.App', version '2.9.9'", responseContent); 480Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 492Assert.Contains("500.37", responseContent); 513Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 524Assert.Contains("500.37", responseContent); 539Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 560Assert.Equal(HttpStatusCode.InternalServerError, result.StatusCode); 604Assert.Equal(expectedArguments, await result.HttpClient.GetStringAsync("/CommandLineArgs")); 675Assert.Equal(expectedArguments, await result.HttpClient.GetStringAsync("/CommandLineArgs")); 713Assert.Equal(deploymentResult.ContentRoot, await deploymentResult.HttpClient.GetStringAsync("/ContentRootPath")); 714Assert.Equal(deploymentResult.ContentRoot + "\\wwwroot", await deploymentResult.HttpClient.GetStringAsync("/WebRootPath")); 715Assert.Equal(Path.GetDirectoryName(deploymentResult.HostProcess.MainModule.FileName), await deploymentResult.HttpClient.GetStringAsync("/CurrentDirectory")); 716Assert.Equal(deploymentResult.ContentRoot + "\\", await deploymentResult.HttpClient.GetStringAsync("/BaseDirectory")); 717Assert.Equal(deploymentResult.ContentRoot + "\\", await deploymentResult.HttpClient.GetStringAsync("/ASPNETCORE_IIS_PHYSICAL_PATH")); 738Assert.True(suspendedWaitHandle.WaitOne(TimeoutExtensions.DefaultTimeoutValue)); 748Assert.False(request.IsCompleted); 773Assert.False(result.IsSuccessStatusCode); 776Assert.Contains("InvalidOperationException", content); 777Assert.Contains("TestSite.Program.Main", content); 797Assert.False(result.IsSuccessStatusCode); 800Assert.Contains("InvalidOperationException", content); 801Assert.Contains("TestSite.Program.Main", content); 820Assert.False(result.IsSuccessStatusCode); 823Assert.Contains("InvalidOperationException", content); 824Assert.Contains("TestSite.Program.Main", content); 825Assert.Contains("From Configure", content); 845Assert.False(result.IsSuccessStatusCode); 848Assert.DoesNotContain("InvalidOperationException", content); 867Assert.False(result.IsSuccessStatusCode); 870Assert.DoesNotContain("InvalidOperationException", content); 889Assert.Equal("True", content); 907Assert.Equal("True", content); 919Assert.True(result.IsSuccessStatusCode); 931Assert.True(result.IsSuccessStatusCode); 975Assert.True(response.IsSuccessStatusCode); 982Assert.Contains(TestSink.Writes, context => context.Message.Contains("An unhandled exception was thrown by the application.")); 1006Assert.Contains(TestSink.Writes, context => context.Message.Contains(expectedLogString)); 1031Assert.Contains(expectedLogString, contents); 1048Assert.Contains(TestSink.Writes, context => context.Message.Contains("Is Console redirection: True")); 1060Assert.False(response.IsSuccessStatusCode); 1061Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1064Assert.Contains("500.30", responseText); 1074Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1079Assert.Contains("500.0", responseString); 1093Assert.Equal(HttpStatusCode.BadGateway, response.StatusCode); 1098Assert.Contains("HTTP Error 502.5 - ANCM Out-Of-Process Startup Failure", responseString); 1116Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1121Assert.Contains("500.0", responseString); 1139Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1144Assert.Contains("500.30", responseString); 1163Assert.Equal( 1182Assert.Equal( 1199Assert.DoesNotContain("shouldberemoved", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_IIS_HTTPAUTH")); 1217Assert.Equal("Production", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_ENVIRONMENT")); 1236Assert.Equal("Asm1", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_HOSTINGSTARTUPASSEMBLIES")); 1240Assert.Equal("Asm1;Microsoft.AspNetCore.Server.IISIntegration", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_HOSTINGSTARTUPASSEMBLIES")); 1259Assert.Equal("Asm2", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_HOSTINGSTARTUPASSEMBLIES")); 1277Assert.Equal("World;Hello", await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=OtherVariable")); 1294Assert.Equal(environment, await GetStringAsync(deploymentParameters, "/GetEnvironmentVariable?name=ASPNETCORE_ENVIRONMENT")); 1319Assert.Equal(deploymentParameters.ApplicationBaseUriHint + appName, await client.GetStringAsync($"/{appName}/ServerAddresses")); 1343Assert.Equal("123", await client.GetStringAsync("/ANCM_HTTPS_PORT")); 1344Assert.Equal("NOVALUE", await client.GetStringAsync("/HTTPS_PORT")); 1384Assert.Equal(307, (int)response.StatusCode); 1389Assert.Equal(200, (int)response.StatusCode); 1420Assert.Equal("NOVALUE", await client.GetStringAsync("/ANCM_HTTPS_PORT")); 1436Assert.Equal(true, response.Headers.ConnectionClose); 1481Assert.EndsWith("</html>\r\n", responseString); 1487Assert.Contains("<a href=\"http://example\"> <cite> http://example </cite></a> and ", await response.Content.ReadAsStringAsync()); 1506Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1518Assert.True(matchedEntries.Length > 0); 1581Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1582Assert.Contains(error, await response.Content.ReadAsStringAsync()); 1596Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); 1600Assert.Contains(error, responseText);

76Assert.Equal(expected, responseText);

16Assert.True(FrameworkHelper.Current != FrameworkID.None, 25Assert.True(OSHelper.Current != OSID.None, 40Assert.True(formatted.Contains("NetCore") && formatted.Contains("NetNative"), 51Assert.True(formatted.Contains("Windows_7") && formatted.Contains("Ubuntu"), 66Assert.Fail(string.Format("Detected the current Runtime Identifier as: '{0}'\n" +

167Assert.Equal("www.foo.com:80", receivedHost); 206Assert.All(TestSink.Writes.Where(w => w.LoggerName != "Microsoft.Hosting.Lifetime"), w => Assert.InRange(w.LogLevel, LogLevel.Trace, LogLevel.Debug)); 207Assert.Contains(TestSink.Writes, w => w.EventId.Id == 17); 237Assert.Equal(Http1Connection.Http2GoAwayHttp11RequiredBytes.ToArray(), data); 238Assert.Empty(await client.Stream.ReadUntilEndAsync().DefaultTimeout()); 315Assert.NotNull(loggedException); 316Assert.Equal(expectedExceptionMessage, loggedException.Message); 319Assert.True(badRequestEventListener.EventFired); 320Assert.Equal("Microsoft.AspNetCore.Server.Kestrel.BadRequest", eventProviderName); 321Assert.Contains(expectedExceptionMessage, exceptionString); 387Assert.Null(loggedException); 389Assert.False(badRequestEventListener.EventFired); 451Assert.Null(loggedException); 453Assert.False(badRequestEventListener.EventFired); 504Assert.Null(loggedException); 506Assert.False(badRequestEventListener.EventFired);

22Assert.Empty(cert.Extensions.OfType<X509EnhancedKeyUsageExtension>()); 24Assert.True(CertificateLoader.IsCertificateAllowedForServerAuth(cert)); 35Assert.NotEmpty(cert.Extensions); 36var eku = Assert.Single(cert.Extensions.OfType<X509EnhancedKeyUsageExtension>()); 37Assert.NotEmpty(eku.EnhancedKeyUsages); 39Assert.True(CertificateLoader.IsCertificateAllowedForServerAuth(cert)); 50Assert.NotEmpty(cert.Extensions); 51var eku = Assert.Single(cert.Extensions.OfType<X509EnhancedKeyUsageExtension>()); 52Assert.NotEmpty(eku.EnhancedKeyUsages); 54Assert.False(CertificateLoader.IsCertificateAllowedForServerAuth(cert)); 65Assert.Equal(hasSan, CertificateLoader.DoesCertificateHaveASubjectAlternativeName(cert));

28Assert.True(request.CanHaveBody()); 45Assert.True(request.CanHaveBody()); 64Assert.True(request.CanHaveBody()); 181Assert.True(request.CanHaveBody()); 183Assert.Equal("POST", request.Method); 237Assert.True(request.CanHaveBody()); 244Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 245Assert.False(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); // Not yet 246Assert.Throws<InvalidOperationException>(() => request.GetTrailer("X-Trailer-Header")); // Not yet 251Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 252Assert.False(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); // Not yet 253Assert.Throws<InvalidOperationException>(() => request.GetTrailer("X-Trailer-Header")); // Not yet 254Assert.Equal("X-Trailer-Header", request.GetDeclaredTrailers().ToString()); 259Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 260Assert.False(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); 261Assert.Throws<InvalidOperationException>(() => request.GetTrailer("X-Trailer-Header")); 269Assert.False(request.Headers.ContainsKey("X-Trailer-Header")); 274Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 275Assert.True(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); 276Assert.Equal(string.Empty, request.GetDeclaredTrailers().ToString()); 277Assert.Equal(string.Empty, request.GetTrailer("X-Trailer-Header").ToString()); 282Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 283Assert.True(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); 284Assert.Equal("X-Trailer-Header", request.GetDeclaredTrailers().ToString()); 285Assert.Equal(new string('a', requestsReceived), request.GetTrailer("X-Trailer-Header").ToString()); 290Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 291Assert.True(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); 292Assert.Equal(string.Empty, request.GetDeclaredTrailers().ToString()); 293Assert.Equal(string.Empty, request.GetTrailer("X-Trailer-Header").ToString()); 365Assert.True(request.CanHaveBody()); 370Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 371Assert.False(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); // Not yet 372Assert.Throws<InvalidOperationException>(() => request.GetTrailer("X-Trailer-Header")); // Not yet 377Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 378Assert.False(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); // Not yet 379Assert.Throws<InvalidOperationException>(() => request.GetTrailer("X-Trailer-Header")); // Not yet 380Assert.Equal("X-Trailer-Header", request.GetDeclaredTrailers().ToString()); 385Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 386Assert.False(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); 387Assert.Throws<InvalidOperationException>(() => request.GetTrailer("X-Trailer-Header")); 400Assert.False(request.Headers.ContainsKey("X-Trailer-Header")); 405Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 406Assert.True(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); 407Assert.Equal(string.Empty, request.GetDeclaredTrailers().ToString()); 408Assert.Equal(string.Empty, request.GetTrailer("X-Trailer-Header").ToString()); 413Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 414Assert.True(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); 415Assert.Equal("X-Trailer-Header", request.GetDeclaredTrailers().ToString()); 416Assert.Equal(new string('a', requestsReceived), request.GetTrailer("X-Trailer-Header").ToString()); 421Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 422Assert.True(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); 423Assert.Equal(string.Empty, request.GetDeclaredTrailers().ToString()); 424Assert.Equal(string.Empty, request.GetTrailer("X-Trailer-Header").ToString()); 595Assert.True(string.IsNullOrEmpty(request.Headers["X-Trailer-Header"])); 599Assert.Equal(new string('a', requestsReceived), request.GetTrailer("X-Trailer-Header").ToString()); 668Assert.True(request.CanHaveBody()); 712Assert.True(request.CanHaveBody()); 898Assert.Equal(RequestRejectionReason.UnexpectedEndOfRequestContent, badReqEx.Reason); 914Assert.Equal("POST", request.Method); 923Assert.True((await requestTask).IsCanceled); 970Assert.Equal("POST", request.Method); 977await Assert.ThrowsAsync<InvalidOperationException>(async () => await request.BodyReader.ReadAsync()); 1070Assert.All(TestSink.Writes, w => Assert.InRange(w.LogLevel, LogLevel.Trace, LogLevel.Information)); 1083Assert.Equal("POST", request.Method);

203Assert.True(length <= memory.Length); 1006Assert.Equal(4005, memory.Length); 1009Assert.Equal(4005, memory.Length); 1042Assert.Equal(4096, memory.Length); 1045Assert.True(memory.Length >= 1000000);

46Assert.True(await lockedTcs.Task.DefaultTimeout()); 145Assert.Collection(rejectedConnections.GetMeasurementSnapshot(), actions); 152static void AssertCounter(CollectedMeasurement<long> measurement) => Assert.Equal(1, measurement.Value); 205Assert.Equal(count, opened); 206Assert.Equal(count, closed);

63Assert.Equal(sendString.Length, middleware.BytesRead); 255Assert.Contains(LogMessages, m => m.Message.Contains("Unhandled exception while processing " + connectionId + "."));

75Assert.NotNull(connectionId); 76Assert.Equal(2, requestsReceived); 83Assert.Equal("ConnectionStart", connectionStart.EventName); 84Assert.Equal(1, connectionStart.EventId); 85Assert.All(new[] { "connectionId", "remoteEndPoint", "localEndPoint" }, p => Assert.Contains(p, connectionStart.PayloadNames)); 86Assert.Equal($"127.0.0.1:{port}", GetProperty(connectionStart, "localEndPoint")); 87Assert.Same(KestrelEventSource.Log, connectionStart.EventSource); 88Assert.NotEqual(Guid.Empty, connectionStart.ActivityId); 91Assert.Equal("RequestStart", firstRequestStart.EventName); 92Assert.Equal(3, firstRequestStart.EventId); 93Assert.All(new[] { "connectionId", "requestId" }, p => Assert.Contains(p, firstRequestStart.PayloadNames)); 94Assert.Equal(requestIds[0], GetProperty(firstRequestStart, "requestId")); 95Assert.Same(KestrelEventSource.Log, firstRequestStart.EventSource); 96Assert.NotEqual(Guid.Empty, firstRequestStart.ActivityId); 97Assert.Equal(connectionStart.ActivityId, firstRequestStart.RelatedActivityId); 100Assert.Equal("RequestStop", firstRequestStop.EventName); 101Assert.Equal(4, firstRequestStop.EventId); 102Assert.All(new[] { "connectionId", "requestId" }, p => Assert.Contains(p, firstRequestStop.PayloadNames)); 103Assert.Same(KestrelEventSource.Log, firstRequestStop.EventSource); 104Assert.Equal(requestIds[0], GetProperty(firstRequestStop, "requestId")); 105Assert.Equal(firstRequestStart.ActivityId, firstRequestStop.ActivityId); 106Assert.Equal(Guid.Empty, firstRequestStop.RelatedActivityId); 109Assert.Equal("RequestStart", secondRequestStart.EventName); 110Assert.Equal(3, secondRequestStart.EventId); 111Assert.All(new[] { "connectionId", "requestId" }, p => Assert.Contains(p, secondRequestStart.PayloadNames)); 112Assert.Equal(requestIds[1], GetProperty(secondRequestStart, "requestId")); 113Assert.Same(KestrelEventSource.Log, secondRequestStart.EventSource); 114Assert.NotEqual(Guid.Empty, secondRequestStart.ActivityId); 115Assert.Equal(connectionStart.ActivityId, secondRequestStart.RelatedActivityId); 118Assert.Equal("RequestStop", secondRequestStop.EventName); 119Assert.Equal(4, secondRequestStop.EventId); 120Assert.All(new[] { "connectionId", "requestId" }, p => Assert.Contains(p, secondRequestStop.PayloadNames)); 121Assert.Same(KestrelEventSource.Log, secondRequestStop.EventSource); 122Assert.Equal(requestIds[1], GetProperty(secondRequestStop, "requestId")); 123Assert.Equal(secondRequestStart.ActivityId, secondRequestStop.ActivityId); 124Assert.Equal(Guid.Empty, secondRequestStop.RelatedActivityId); 127Assert.Equal("ConnectionStop", connectionStop.EventName); 128Assert.Equal(2, connectionStop.EventId); 129Assert.All(new[] { "connectionId" }, p => Assert.Contains(p, connectionStop.PayloadNames)); 130Assert.Same(KestrelEventSource.Log, connectionStop.EventSource); 131Assert.Equal(connectionStart.ActivityId, connectionStop.ActivityId); 132Assert.Equal(Guid.Empty, connectionStop.RelatedActivityId); 134Assert.Equal(eventIndex, events.Count); 200Assert.NotNull(connectionId); 201Assert.Equal(2, requestsReceived); 208Assert.Equal("ConnectionStart", connectionStart.EventName); 209Assert.Equal(1, connectionStart.EventId); 210Assert.All(new[] { "connectionId", "remoteEndPoint", "localEndPoint" }, p => Assert.Contains(p, connectionStart.PayloadNames)); 211Assert.Same(KestrelEventSource.Log, connectionStart.EventSource); 212Assert.Equal($"127.0.0.1:{port}", GetProperty(connectionStart, "localEndPoint")); 213Assert.NotEqual(Guid.Empty, connectionStart.ActivityId); 216Assert.Equal("TlsHandshakeStart", tlsHandshakeStart.EventName); 217Assert.Equal(8, tlsHandshakeStart.EventId); 218Assert.All(new[] { "connectionId", "sslProtocols" }, p => Assert.Contains(p, tlsHandshakeStart.PayloadNames)); 219Assert.Same(KestrelEventSource.Log, tlsHandshakeStart.EventSource); 220Assert.NotEqual(Guid.Empty, tlsHandshakeStart.ActivityId); 221Assert.Equal(connectionStart.ActivityId, tlsHandshakeStart.RelatedActivityId); 224Assert.Equal("TlsHandshakeStop", tlsHandshakeStop.EventName); 225Assert.Equal(9, tlsHandshakeStop.EventId); 226Assert.All(new[] { "connectionId", "sslProtocols", "applicationProtocol", "hostName" }, p => Assert.Contains(p, tlsHandshakeStop.PayloadNames)); 227Assert.Equal("h2", GetProperty(tlsHandshakeStop, "applicationProtocol")); 228Assert.Same(KestrelEventSource.Log, tlsHandshakeStop.EventSource); 229Assert.Equal(tlsHandshakeStart.ActivityId, tlsHandshakeStop.ActivityId); 230Assert.Equal(Guid.Empty, tlsHandshakeStop.RelatedActivityId); 235Assert.Equal("RequestStart", requestStart.EventName); 236Assert.Equal(3, requestStart.EventId); 237Assert.All(new[] { "connectionId", "requestId" }, p => Assert.Contains(p, requestStart.PayloadNames)); 238Assert.Equal(requestIds[i], GetProperty(requestStart, "requestId")); 239Assert.Same(KestrelEventSource.Log, requestStart.EventSource); 240Assert.NotEqual(Guid.Empty, requestStart.ActivityId); 241Assert.Equal(connectionStart.ActivityId, requestStart.RelatedActivityId); 244Assert.Equal("RequestStop", requestStop.EventName); 245Assert.Equal(4, requestStop.EventId); 246Assert.All(new[] { "connectionId", "requestId" }, p => Assert.Contains(p, requestStop.PayloadNames)); 247Assert.Same(KestrelEventSource.Log, requestStop.EventSource); 248Assert.Equal(requestIds[i], GetProperty(requestStop, "requestId")); 249Assert.Equal(requestStart.ActivityId, requestStop.ActivityId); 250Assert.Equal(Guid.Empty, requestStop.RelatedActivityId); 254Assert.Equal("ConnectionStop", connectionStop.EventName); 255Assert.Equal(2, connectionStop.EventId); 256Assert.All(new[] { "connectionId" }, p => Assert.Contains(p, connectionStop.PayloadNames)); 257Assert.Same(KestrelEventSource.Log, connectionStop.EventSource); 258Assert.Equal(connectionStart.ActivityId, connectionStop.ActivityId); 259Assert.Equal(Guid.Empty, connectionStop.RelatedActivityId); 261Assert.Equal(eventIndex, events.Count); 302await Assert.ThrowsAnyAsync<Exception>(() => sslStream.AuthenticateAsClientAsync(clientAuthOptions, handshakeCts.Token)); 305Assert.NotNull(connectionId); 312Assert.Equal("ConnectionStart", connectionStart.EventName); 313Assert.Equal(1, connectionStart.EventId); 314Assert.All(new[] { "connectionId", "remoteEndPoint", "localEndPoint" }, p => Assert.Contains(p, connectionStart.PayloadNames)); 315Assert.Equal($"127.0.0.1:{port}", GetProperty(connectionStart, "localEndPoint")); 316Assert.Same(KestrelEventSource.Log, connectionStart.EventSource); 317Assert.NotEqual(Guid.Empty, connectionStart.ActivityId); 320Assert.Equal("TlsHandshakeStart", tlsHandshakeStart.EventName); 321Assert.Equal(8, tlsHandshakeStart.EventId); 322Assert.All(new[] { "connectionId", "sslProtocols" }, p => Assert.Contains(p, tlsHandshakeStart.PayloadNames)); 323Assert.Same(KestrelEventSource.Log, tlsHandshakeStart.EventSource); 324Assert.NotEqual(Guid.Empty, tlsHandshakeStart.ActivityId); 325Assert.Equal(connectionStart.ActivityId, tlsHandshakeStart.RelatedActivityId); 328Assert.Equal("TlsHandshakeFailed", tlsHandshakeFailed.EventName); 329Assert.Equal(10, tlsHandshakeFailed.EventId); 330Assert.All(new[] { "connectionId" }, p => Assert.Contains(p, tlsHandshakeFailed.PayloadNames)); 331Assert.Same(KestrelEventSource.Log, tlsHandshakeFailed.EventSource); 332Assert.Equal(tlsHandshakeStart.ActivityId, tlsHandshakeFailed.ActivityId); 333Assert.Equal(Guid.Empty, tlsHandshakeFailed.RelatedActivityId); 336Assert.Equal("TlsHandshakeStop", tlsHandshakeStop.EventName); 337Assert.Equal(9, tlsHandshakeStop.EventId); 338Assert.All(new[] { "connectionId", "sslProtocols", "applicationProtocol", "hostName" }, p => Assert.Contains(p, tlsHandshakeStop.PayloadNames)); 339Assert.Same(KestrelEventSource.Log, tlsHandshakeStop.EventSource); 340Assert.Equal(tlsHandshakeStart.ActivityId, tlsHandshakeStop.ActivityId); 341Assert.Equal(Guid.Empty, tlsHandshakeStop.RelatedActivityId); 344Assert.Equal("ConnectionStop", connectionStop.EventName); 345Assert.Equal(2, connectionStop.EventId); 346Assert.All(new[] { "connectionId" }, p => Assert.Contains(p, connectionStop.PayloadNames)); 347Assert.Same(KestrelEventSource.Log, connectionStop.EventSource); 348Assert.Equal(connectionStart.ActivityId, connectionStop.ActivityId); 349Assert.Equal(Guid.Empty, connectionStop.RelatedActivityId); 351Assert.Equal(eventIndex, events.Count); 386Assert.NotNull(connectionId); 393Assert.Equal("ConnectionStart", connectionStart.EventName); 394Assert.Equal(1, connectionStart.EventId); 395Assert.All(new[] { "connectionId", "remoteEndPoint", "localEndPoint" }, p => Assert.Contains(p, connectionStart.PayloadNames)); 396Assert.Equal($"127.0.0.1:{port}", GetProperty(connectionStart, "localEndPoint")); 397Assert.Same(KestrelEventSource.Log, connectionStart.EventSource); 398Assert.NotEqual(Guid.Empty, connectionStart.ActivityId); 401Assert.Equal("ConnectionRejected", connectionRejected.EventName); 402Assert.Equal(5, connectionRejected.EventId); 403Assert.All(new[] { "connectionId" }, p => Assert.Contains(p, connectionRejected.PayloadNames)); 404Assert.Same(KestrelEventSource.Log, connectionRejected.EventSource); 405Assert.Equal(connectionStart.ActivityId, connectionRejected.ActivityId); 406Assert.Equal(Guid.Empty, connectionRejected.RelatedActivityId); 409Assert.Equal("ConnectionStop", connectionStop.EventName); 410Assert.Equal(2, connectionStop.EventId); 411Assert.All(new[] { "connectionId" }, p => Assert.Contains(p, connectionStop.PayloadNames)); 412Assert.Same(KestrelEventSource.Log, connectionStop.EventSource); 413Assert.Equal(connectionStart.ActivityId, connectionStop.ActivityId); 414Assert.Equal(Guid.Empty, connectionStop.RelatedActivityId); 416Assert.Equal(eventIndex, events.Count);

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")); 191Assert.Equal(1, _connection.StreamPool.Count); 204Assert.Same(contentType1, contentType2); 205Assert.Same(authority1, authority2); 206Assert.Same(path1, path2); 247Assert.Equal(1, _connection.StreamPool.Count); 248Assert.True(_connection.StreamPool.TryPeek(out var stream1)); 265Assert.Equal(1, _connection.StreamPool.Count); 266Assert.True(_connection.StreamPool.TryPeek(out var stream2)); 272Assert.Equal("application/json", contentTypeValue1); 273Assert.Equal(StringValues.Empty, contentTypeValue2); 353Assert.Single(_decodedHeaders); 354Assert.Equal("true", _decodedHeaders["trailer-1"]); 365Assert.Equal(1, _connection.StreamPool.Count); 381Assert.Single(_decodedHeaders); 382Assert.Equal("true", _decodedHeaders[$"trailer-{i + 1}"]); 388Assert.NotNull(trailersFirst); 389Assert.NotNull(trailersLast); 390Assert.NotSame(trailersFirst, trailersLast); 407Assert.Equal(0, _connection.StreamPool.Count); 418Assert.Equal(1, _connection.StreamPool.Count); 434Assert.Equal(0, _connection.StreamPool.Count); 473Assert.Equal(2, _connection.StreamPool.Count); 497Assert.Equal(0, _connection.StreamPool.Count); 512Assert.Equal(1, _connection.StreamPool.Count); 513Assert.True(_connection.StreamPool.TryPeek(out var pooledStream)); 514Assert.Equal(stream, pooledStream); 517Assert.Null(persistedState); 529Assert.Equal(0, _connection.StreamPool.Count); 537Assert.Equal(1, _connection.StreamPool.Count); 538Assert.True(_connection.StreamPool.TryPeek(out pooledStream)); 539Assert.Equal(stream, pooledStream); 542Assert.Equal(1, (int)persistedState); 579Assert.True(output._disposed); 582Assert.Equal(0, _connection.StreamPool.Count); 614Assert.Equal(0, _connection.StreamPool.Count); 643Assert.Equal(0, _connection.StreamPool.Count); 656Assert.Equal(0, _connection.StreamPool.Count); 669Assert.Equal(1, _connection.StreamPool.Count); 676Assert.Equal(1, _connection.StreamPool.Count); 681Assert.Equal(0, _connection.StreamPool.Count); 684Assert.True(((Http2OutputProducer)pooledStream.Output)._disposed); 761Assert.True(_helloWorldBytes.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray())); 788Assert.True(_maxData.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray())); 884Assert.True(_maxData.AsSpan().SequenceEqual(frame.PayloadSequence.ToArray())); 887Assert.Equal(updateSize, streamWindowUpdateFrame1.WindowUpdateSizeIncrement); 889Assert.Equal(updateSize, connectionWindowUpdateFrame1.WindowUpdateSizeIncrement); 951Assert.True(_helloWorldBytes.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray())); 1014Assert.True(_helloBytes.AsSpan().SequenceEqual(stream1DataFrame1.PayloadSequence.ToArray())); 1015Assert.True(_worldBytes.AsSpan().SequenceEqual(stream1DataFrame2.PayloadSequence.ToArray())); 1016Assert.True(_helloBytes.AsSpan().SequenceEqual(stream3DataFrame1.PayloadSequence.ToArray())); 1017Assert.True(_worldBytes.AsSpan().SequenceEqual(stream3DataFrame2.PayloadSequence.ToArray())); 1128Assert.True(_maxData.AsSpan().SequenceEqual(frame.PayloadSequence.ToArray())); 1131Assert.Equal(updateSize, streamWindowUpdateFrame.WindowUpdateSizeIncrement); 1133Assert.Equal(updateSize, connectionWindowUpdateFrame.WindowUpdateSizeIncrement); 1231Assert.True(_helloWorldBytes.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray())); 1270Assert.Equal(Http2FrameType.DATA, frame.Type); 1271Assert.True(dataSent >= frame.PayloadLength); 1272Assert.Equal(Http2DataFrameFlags.NONE, frame.DataFlags); 1273Assert.Equal(1, frame.StreamId); 1300Assert.True(_maxData.AsSpan().SequenceEqual(dataFrame3.PayloadSequence.ToArray())); 1303Assert.Equal(updateSize, connectionWindowUpdateFrame.WindowUpdateSizeIncrement); 1327Assert.Contains(LogMessages, m => m.Message.Contains("the application completed without reading the entire request body.")); 1341Assert.Equal(updateSize, connectionWindowUpdateFrame.WindowUpdateSizeIncrement); 1372Assert.Equal(readResult.Buffer.Length, _maxData.Length * 5); 1433Assert.True(_maxData.AsSpan().SequenceEqual(frame.PayloadSequence.ToArray())); 1437Assert.Equal(updateSize, streamWindowUpdateFrame1.WindowUpdateSizeIncrement); 1439Assert.Equal(updateSize, connectionWindowUpdateFrame.WindowUpdateSizeIncrement); 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); 2171Assert.False(_receivedHeaders.ContainsKey(header.Key)); 2172Assert.True(_receivedTrailers.ContainsKey(header.Key)); 2173Assert.Equal(header.Value, _receivedTrailers[header.Key]); 2191Assert.Equal(new byte[] { 0x08, 0x03, (byte)'1', (byte)'0', (byte)'0' }, frame.PayloadSequence.ToArray()); 2279Assert.True(integerDecoder.BeginTryDecode((byte)(headerFrame.Payload.Span[0] & ~DynamicTableSizeUpdateMask), prefixLength: 5, out var result)); 2282Assert.Equal(0, result); 2319Assert.Equal("200", handler.Headers[":status"]); 2320Assert.Equal("SetCookie!", handler.Headers[HeaderNames.SetCookie]); 2321Assert.Equal("ContentDisposition!", handler.Headers[HeaderNames.ContentDisposition]); 2322Assert.Equal("0", handler.Headers[HeaderNames.ContentLength]); 2336Assert.Equal("200", handler.Headers[":status"]); 2337Assert.Equal("SetCookie!", handler.Headers[HeaderNames.SetCookie]); 2338Assert.Equal("ContentDisposition!", handler.Headers[HeaderNames.ContentDisposition]); 2339Assert.Equal("0", handler.Headers[HeaderNames.ContentLength]); 2941Assert.Equal("a=0; b=1; c=2", _receivedHeaders[HeaderNames.Cookie]); 3095Assert.False(writeTasks[1].IsCompleted); 3127Assert.False(writeTasks[3].IsCompleted); 3135Assert.Contains(1, _abortedStreamIds); 3136Assert.Contains(3, _abortedStreamIds); 3195Assert.True(_helloWorldBytes.AsSpan(0, initialWindowSize).SequenceEqual(dataFrame.PayloadSequence.ToArray())); 3196Assert.False(writeTasks[streamId].IsCompleted); 3205Assert.False(writeTasks[3].IsCompleted); 3206Assert.False(writeTasks[5].IsCompleted); 3210Assert.False(writeTasks[5].IsCompleted); 3218Assert.Contains(1, _abortedStreamIds); 3219Assert.Contains(3, _abortedStreamIds); 3220Assert.Contains(5, _abortedStreamIds); 3252Assert.Contains(1, _abortedStreamIds); 3254Assert.Equal(updateSize, connectionWindowUpdateFrame.WindowUpdateSizeIncrement); 3445Assert.Equal(4, settings.Count); 3448Assert.Equal(Http2SettingsParameter.SETTINGS_MAX_CONCURRENT_STREAMS, setting.Parameter); 3449Assert.Equal(100u, setting.Value); 3452Assert.Equal(Http2SettingsParameter.SETTINGS_INITIAL_WINDOW_SIZE, setting.Parameter); 3453Assert.Equal(768 * 1024u, setting.Value); 3456Assert.Equal(Http2SettingsParameter.SETTINGS_MAX_HEADER_LIST_SIZE, setting.Parameter); 3457Assert.Equal(32 * 1024u, setting.Value); 3460Assert.Equal(Http2SettingsParameter.SETTINGS_ENABLE_CONNECT_PROTOCOL, setting.Parameter); 3461Assert.Equal(1u, setting.Value); 3468Assert.Equal(1024 * 1024 - (int)Http2PeerSettings.DefaultInitialWindowSize, update.WindowUpdateSizeIncrement); 3500Assert.Equal(5, settings.Count); 3503Assert.Equal(Http2SettingsParameter.SETTINGS_HEADER_TABLE_SIZE, setting.Parameter); 3504Assert.Equal(0u, setting.Value); 3507Assert.Equal(Http2SettingsParameter.SETTINGS_MAX_CONCURRENT_STREAMS, setting.Parameter); 3508Assert.Equal(1u, setting.Value); 3511Assert.Equal(Http2SettingsParameter.SETTINGS_INITIAL_WINDOW_SIZE, setting.Parameter); 3512Assert.Equal(1024 * 1024 * 10u, setting.Value); 3515Assert.Equal(Http2SettingsParameter.SETTINGS_MAX_HEADER_LIST_SIZE, setting.Parameter); 3516Assert.Equal(4 * 1024u, setting.Value); 3519Assert.Equal(Http2SettingsParameter.SETTINGS_ENABLE_CONNECT_PROTOCOL, setting.Parameter); 3520Assert.Equal(1u, setting.Value); 3527Assert.Equal(1024 * 1024u - Http2PeerSettings.DefaultInitialWindowSize, (uint)update.WindowUpdateSizeIncrement); 3792Assert.Equal(0x88, headerFrame.Payload.Span[0]); 3825Assert.False(integerDecoder.BeginTryDecode((byte)(headerFrame.Payload.Span[0] & ~DynamicTableSizeUpdateMask), prefixLength: 5, out _)); 3826Assert.False(integerDecoder.TryDecode(headerFrame.Payload.Span[1], out _)); 3827Assert.False(integerDecoder.TryDecode(headerFrame.Payload.Span[2], out _)); 3828Assert.True(integerDecoder.TryDecode(headerFrame.Payload.Span[3], out var result)); 3830Assert.Equal(40000, result); 3935Assert.False(lifetime.ConnectionClosedRequested.IsCancellationRequested); 3939Assert.True(lifetime.ConnectionClosedRequested.IsCancellationRequested); 4062Assert.False(writeTasks[1].IsCompleted); 4086Assert.Contains(1, _abortedStreamIds); 4087Assert.Contains(3, _abortedStreamIds); 4088Assert.Contains(5, _abortedStreamIds); 4147Assert.True(_helloWorldBytes.AsSpan(0, initialWindowSize).SequenceEqual(dataFrame.PayloadSequence.ToArray())); 4148Assert.False(writeTasks[streamId].IsCompleted); 4163Assert.Contains(1, _abortedStreamIds); 4164Assert.Contains(3, _abortedStreamIds); 4165Assert.Contains(5, _abortedStreamIds); 4354Assert.False(lastWriteTask.IsCompleted); 4451Assert.True(_helloWorldBytes.AsSpan(0, initialWindowSize).SequenceEqual(dataFrame1.PayloadSequence.ToArray())); 4452Assert.True(_helloWorldBytes.AsSpan(initialWindowSize, initialWindowSize).SequenceEqual(dataFrame2.PayloadSequence.ToArray())); 4506Assert.True(_helloWorldBytes.AsSpan(0, 6).SequenceEqual(dataFrame1.PayloadSequence.ToArray())); 4507Assert.True(_helloWorldBytes.AsSpan(6, 3).SequenceEqual(dataFrame2.PayloadSequence.ToArray())); 4508Assert.True(_helloWorldBytes.AsSpan(9, 3).SequenceEqual(dataFrame3.PayloadSequence.ToArray())); 4575Assert.False(_receivedHeaders.ContainsKey("trailer-1")); 4576Assert.False(_receivedHeaders.ContainsKey("trailer-2")); 4577Assert.True(_receivedTrailers.ContainsKey("trailer-1")); 4578Assert.True(_receivedTrailers.ContainsKey("trailer-2")); 4579Assert.Equal("1", _receivedTrailers["trailer-1"]); 4580Assert.Equal("2", _receivedTrailers["trailer-2"]); 4639Assert.True(await SendHeadersAsync(1, Http2HeadersFrameFlags.END_STREAM, headers)); 4699Assert.Equal(11, _decodedHeaders.Count); 4700Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4701Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4702Assert.Equal("0", _decodedHeaders["content-length"]); 4703Assert.Equal(_4kHeaderValue, _decodedHeaders["a"]); 4704Assert.Equal(_4kHeaderValue, _decodedHeaders["b"]); 4705Assert.Equal(_4kHeaderValue, _decodedHeaders["c"]); 4706Assert.Equal(_4kHeaderValue, _decodedHeaders["d"]); 4707Assert.Equal(_4kHeaderValue, _decodedHeaders["e"]); 4708Assert.Equal(_4kHeaderValue, _decodedHeaders["f"]); 4709Assert.Equal(_4kHeaderValue, _decodedHeaders["g"]); 4710Assert.Equal(_4kHeaderValue, _decodedHeaders["h"]); 4765Assert.Contains(1, _abortedStreamIds); 4766Assert.Contains(3, _abortedStreamIds); 4767Assert.Contains(5, _abortedStreamIds); 4780Assert.Single(LogMessages, m => m.Exception is ConnectionResetException); 4791Assert.DoesNotContain(LogMessages, m => m.Exception is ConnectionResetException); 4803Assert.True(result.IsCompleted); 4804Assert.True(result.Buffer.IsEmpty); 4861Assert.False(result.IsCompleted); 4871Assert.True(result.IsCompleted); 4968Assert.True(result.IsCompleted); 4969Assert.True(result.Buffer.IsEmpty); 4982Assert.All(LogMessages, w => Assert.InRange(w.LogLevel, LogLevel.Trace, LogLevel.Debug)); 4986Assert.Equal("Connection id \"TestConnectionId\" request processing ended abnormally.", logMessage.Message); 4987Assert.Same(ioException, logMessage.Exception); 5002Assert.Equal(LogLevel.Warning, logMessage.LogLevel); 5003Assert.Equal(CoreStrings.RequestProcessingEndError, logMessage.Message); 5004Assert.Same(exception, logMessage.Exception); 5033Assert.Contains(LogMessages, m => m.Message.Contains("the application completed without reading the entire request body.")); 5323Assert.True(result.IsCompleted); 5339Assert.Equal(streamPayload, streamResponse); 5490Assert.NotNull(Http2Connection.InvalidHttp1xErrorResponseBytes); 5491Assert.Equal(Http2Connection.InvalidHttp1xErrorResponseBytes, data);

74Assert.Equal("hello, world", await responseMessage.Content.ReadAsStringAsync()); 76Assert.NotNull(connectionIdFromFeature); 77Assert.NotNull(mockScopeLoggerProvider.ConnectionLogScope); 78Assert.Equal(connectionIdFromFeature, mockScopeLoggerProvider.ConnectionLogScope[0].Value);

18Assert.Null(_connection._keepAlive); 47Assert.Equal(KeepAliveState.PingSent, _connection._keepAlive._state); 195Assert.Equal(KeepAliveState.Timeout, _connection._keepAlive._state); 214Assert.Equal(KeepAliveState.PingSent, _connection._keepAlive._state); 221Assert.Equal(KeepAliveState.None, _connection._keepAlive._state);

108Assert.Equal(4, _decodedHeaders.Count); 109Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 110Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 111Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 112Assert.Equal(method, _decodedHeaders["Method"]); 127Assert.Equal(4, _decodedHeaders.Count); 128Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 129Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 130Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 131Assert.Equal(method, _decodedHeaders["Method"]); 158Assert.Equal(3, _decodedHeaders.Count); 159Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 160Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 161Assert.Equal("HEAD", _decodedHeaders["Method"]); 183Assert.True(HttpMethods.Equals(method, context.Request.Method)); 184Assert.True(context.Request.CanHaveBody()); 185Assert.Equal(11, context.Request.ContentLength); 186Assert.False(context.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 210Assert.Equal(2, _decodedHeaders.Count); 211Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 212Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 213Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 234Assert.True(HttpMethods.Equals(method, context.Request.Method)); 235Assert.True(context.Request.CanHaveBody()); 236Assert.Null(context.Request.ContentLength); 237Assert.False(context.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 261Assert.Equal(2, _decodedHeaders.Count); 262Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 263Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 264Assert.Equal("Hello World", Encoding.UTF8.GetString(dataFrame.Payload.Span)); 285Assert.Equal(3, _decodedHeaders.Count); 286Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 287Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 288Assert.Equal("CONNECT", _decodedHeaders["Method"]); 314Assert.Equal(5, _decodedHeaders.Count); 315Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 316Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 317Assert.Equal("", _decodedHeaders["path"]); 318Assert.Equal("*", _decodedHeaders["rawtarget"]); 319Assert.Equal("0", _decodedHeaders["content-length"]); 345Assert.Equal(5, _decodedHeaders.Count); 346Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 347Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 348Assert.Equal("/", _decodedHeaders["path"]); 349Assert.Equal("/", _decodedHeaders["rawtarget"]); 350Assert.Equal("0", _decodedHeaders["content-length"]); 382Assert.Equal(6, _decodedHeaders.Count); 383Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 384Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 385Assert.Equal("/a/path", _decodedHeaders["path"]); 386Assert.Equal("?a&que%35ry", _decodedHeaders["query"]); 387Assert.Equal("/a/path?a&que%35ry", _decodedHeaders["rawtarget"]); 388Assert.Equal("0", _decodedHeaders["content-length"]); 404Assert.Equal(expected, context.Request.Path.Value); 405Assert.Equal(input, context.Features.Get<IHttpRequestFeature>().RawTarget); 427Assert.Equal(3, _decodedHeaders.Count); 428Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 429Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 430Assert.Equal("0", _decodedHeaders["content-length"]); 477Assert.Equal(scheme, context.Request.Scheme); 478Assert.False(context.Request.Headers.ContainsKey(InternalHeaderNames.Scheme)); 499Assert.Equal(3, _decodedHeaders.Count); 500Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 501Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 502Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 550Assert.Equal(3, _decodedHeaders.Count); 551Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 552Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 553Assert.Equal("0", _decodedHeaders["content-length"]); 579Assert.Equal(3, _decodedHeaders.Count); 580Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 581Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 582Assert.Equal("0", _decodedHeaders["content-length"]); 608Assert.Equal(4, _decodedHeaders.Count); 609Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 610Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 611Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 612Assert.Equal("abc", _decodedHeaders[HeaderNames.Host]); 639Assert.Equal(4, _decodedHeaders.Count); 640Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 641Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 642Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 643Assert.Equal("abc", _decodedHeaders[HeaderNames.Host]); 670Assert.Equal(4, _decodedHeaders.Count); 671Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 672Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 673Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 674Assert.Equal("def", _decodedHeaders[HeaderNames.Host]); 701Assert.Equal(4, _decodedHeaders.Count); 702Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 703Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 704Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 705Assert.Equal("def", _decodedHeaders[HeaderNames.Host]); 823Assert.Equal(3, _decodedHeaders.Count); 824Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 825Assert.Equal("431", _decodedHeaders[InternalHeaderNames.Status]); 826Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 857Assert.Equal(3, _decodedHeaders.Count); 858Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 859Assert.Equal("431", _decodedHeaders[InternalHeaderNames.Status]); 860Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 877Assert.Equal(12, read); 879Assert.Equal(0, read); 894Assert.Equal(3, _decodedHeaders.Count); 895Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 896Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 897Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 907Assert.Equal(12, read); 909Assert.Equal(0, read); 935Assert.Equal(3, _decodedHeaders.Count); 936Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 937Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 938Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 961Assert.Equal(12, total); 978Assert.Equal(3, _decodedHeaders.Count); 979Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 980Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 981Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 1003Assert.Equal(12, readResult.Buffer.Length); 1021Assert.Equal(3, _decodedHeaders.Count); 1022Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1023Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1024Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 1041Assert.Equal(1, readResult.Buffer.Length); 1056Assert.Equal(11, total); 1074Assert.Equal(3, _decodedHeaders.Count); 1075Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1076Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1077Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 1106Assert.False(requestDelegateCalled); 1146thrownEx = await Assert.ThrowsAsync<IOException>(async () => 1162Assert.NotNull(thrownEx); 1163Assert.Equal(expectedError.Message, thrownEx.Message); 1164Assert.IsType<Http2StreamErrorException>(thrownEx.InnerException); 1181thrownEx = await Assert.ThrowsAsync<IOException>(async () => 1197Assert.NotNull(thrownEx); 1198Assert.Equal(expectedError.Message, thrownEx.Message); 1199Assert.IsType<Http2StreamErrorException>(thrownEx.InnerException); 1216thrownEx = await Assert.ThrowsAsync<IOException>(async () => 1233Assert.NotNull(thrownEx); 1234Assert.Equal(expectedError.Message, thrownEx.Message); 1235Assert.IsType<Http2StreamErrorException>(thrownEx.InnerException); 1252thrownEx = await Assert.ThrowsAsync<IOException>(async () => 1269Assert.NotNull(thrownEx); 1270Assert.Equal(expectedError.Message, thrownEx.Message); 1271Assert.IsType<Http2StreamErrorException>(thrownEx.InnerException); 1286Assert.Equal(12, readResult.Buffer.Length); 1290Assert.True(readResult.IsCompleted); 1316Assert.Equal(3, _decodedHeaders.Count); 1317Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1318Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1319Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 1348Assert.Contains(LogMessages, m => m.Exception?.Message.Contains("Response Content-Length mismatch: too many bytes written (12 of 11).") ?? false); 1354Assert.Equal(3, _decodedHeaders.Count); 1355Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1356Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1357Assert.Equal("11", _decodedHeaders[HeaderNames.ContentLength]); 1393Assert.Equal(3, _decodedHeaders.Count); 1394Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1395Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1396Assert.Equal("11", _decodedHeaders[HeaderNames.ContentLength]); 1421Assert.Contains(LogMessages, m => m.Exception?.Message.Contains(CoreStrings.FormatTooFewBytesWritten(0, 11)) ?? false); 1427Assert.Equal(3, _decodedHeaders.Count); 1428Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1429Assert.Equal("500", _decodedHeaders[InternalHeaderNames.Status]); 1430Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 1462Assert.Equal(2, _decodedHeaders.Count); 1463Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1464Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1497Assert.Equal(3, _decodedHeaders.Count); 1498Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1499Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1500Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 1517ex = Assert.Throws<InvalidOperationException>(() => context.Response.OnStarting(_ => Task.CompletedTask, null)); 1533Assert.NotNull(ex); 1537Assert.Equal(2, _decodedHeaders.Count); 1538Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1539Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1554Assert.True(context.Response.HasStarted); 1572Assert.Equal(2, _decodedHeaders.Count); 1573Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1574Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1620Assert.Equal(2, _decodedHeaders.Count); 1621Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1622Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1624Assert.True(_helloWorldBytes.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray())); 1660Assert.Equal(2, _decodedHeaders.Count); 1661Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1662Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1696Assert.Equal(3, _decodedHeaders.Count); 1697Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1698Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1699Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 1738Assert.Equal(2, _decodedHeaders.Count); 1739Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1740Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1742Assert.True(_helloWorldBytes.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray())); 1774Assert.Equal(3, _decodedHeaders.Count); 1775Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1776Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1777Assert.Equal("11", _decodedHeaders[HeaderNames.ContentLength]); 1808Assert.Equal(2, _decodedHeaders.Count); 1809Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1810Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1845Assert.Equal(3, _decodedHeaders.Count); 1846Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1847Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1848Assert.Equal("11", _decodedHeaders[HeaderNames.ContentLength]); 1866Assert.Equal(12, read); 1868Assert.Equal(0, read); 1883Assert.Equal(3, _decodedHeaders.Count); 1884Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1885Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1886Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 1906exception = await Assert.ThrowsAsync<BadHttpRequestException>(async () => 1924Assert.Contains(LogMessages, m => m.Message.Contains("the application completed without reading the entire request body.")); 1930Assert.Equal(3, _decodedHeaders.Count); 1931Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1932Assert.Equal("413", _decodedHeaders[InternalHeaderNames.Status]); 1933Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 1935Assert.NotNull(exception); 1952Assert.Equal(12, read); 1954Assert.Equal(0, read); 1969Assert.Equal(3, _decodedHeaders.Count); 1970Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 1971Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 1972Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 1991exception = await Assert.ThrowsAsync<BadHttpRequestException>(async () => 2011Assert.Contains(LogMessages, m => m.Message.Contains("the application completed without reading the entire request body.")); 2017Assert.Equal(3, _decodedHeaders.Count); 2018Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 2019Assert.Equal("413", _decodedHeaders[InternalHeaderNames.Status]); 2020Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 2022Assert.NotNull(exception); 2049Assert.False(context.Features.Get<IHttpMaxRequestBodySizeFeature>().IsReadOnly); 2052exception = await Assert.ThrowsAsync<BadHttpRequestException>(async () => 2058Assert.True(context.Features.Get<IHttpMaxRequestBodySizeFeature>().IsReadOnly); 2074Assert.Contains(LogMessages, m => m.Message.Contains("the application completed without reading the entire request body.")); 2080Assert.Equal(3, _decodedHeaders.Count); 2081Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 2082Assert.Equal("413", _decodedHeaders[InternalHeaderNames.Status]); 2083Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 2085Assert.NotNull(exception); 2109Assert.False(context.Features.Get<IHttpMaxRequestBodySizeFeature>().IsReadOnly); 2113Assert.Equal(12, read); 2114Assert.True(context.Features.Get<IHttpMaxRequestBodySizeFeature>().IsReadOnly); 2116Assert.Equal(0, read); 2131Assert.Equal(3, _decodedHeaders.Count); 2132Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 2133Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 2134Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 2142Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("Custom你好Name", "Custom Value")); 2143Assert.Throws<InvalidOperationException>(() => context.Response.ContentType = "Custom 你好 Type"); 2144Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom 你好 Value")); 2145Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom \r Value")); 2170Assert.Equal(2, _decodedHeaders.Count); 2171Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 2172Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 2183Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("Custom你好Name", "Custom Value")); 2184Assert.Throws<InvalidOperationException>(() => context.Response.Headers.Append("CustomName", "Custom \r Value")); 2211Assert.Equal(4, _decodedHeaders.Count); 2212Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 2213Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 2214Assert.Equal("Custom 你好 Type", _decodedHeaders[HeaderNames.ContentType]); 2215Assert.Equal("Custom 你好 Value", _decodedHeaders["CustomName"]); 2261Assert.Equal(3, _decodedHeaders.Count); 2262Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 2263Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 2264Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 2270Assert.Single(_decodedHeaders); 2271Assert.Equal("Custom Value", _decodedHeaders["CustomName"]); 2294Assert.Equal(3, _decodedHeaders.Count); 2295Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 2296Assert.Equal("500", _decodedHeaders[InternalHeaderNames.Status]); 2297Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 2305Assert.True(context.Response.SupportsTrailers(), "SupportsTrailers"); 2308Assert.False(trailers.IsReadOnly); 2341Assert.Single(_decodedHeaders); 2342Assert.Equal("Custom Value", _decodedHeaders["CustomName"]); 2348Assert.Single(_decodedHeaders); 2349Assert.Equal("Custom Value", _decodedHeaders["CustomName"]); 2382Assert.Equal(2, _decodedHeaders.Count); 2383Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 2384Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 2390Assert.Single(_decodedHeaders); 2391Assert.Equal("Custom Value", _decodedHeaders["CustomName"]); 2437Assert.Equal(2, _decodedHeaders.Count); 2438Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 2439Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 2445Assert.Equal(5, _decodedHeaders.Count); 2446Assert.Equal(largeHeader, _decodedHeaders["CustomName0"]); 2447Assert.Equal(largeHeader, _decodedHeaders["CustomName1"]); 2448Assert.Equal(largeHeader, _decodedHeaders["CustomName2"]); 2449Assert.Equal(largeHeader, _decodedHeaders["CustomName3"]); 2450Assert.Equal(largeHeader, _decodedHeaders["CustomName4"]); 2456Assert.Single(_decodedHeaders); 2457Assert.Equal(largeHeader, _decodedHeaders["CustomName5"]); 2466Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("Custom你好Name", "Custom Value")); 2467Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("CustomName", "Custom 你好 Value")); 2468Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("CustomName", "Custom \r Value")); 2470Assert.Throws<InvalidOperationException>(() => context.Features.Get<IHttpResponseTrailersFeature>().Trailers.ETag = "Custom 你好 Tag"); 2471Assert.Throws<InvalidOperationException>(() => context.Features.Get<IHttpResponseTrailersFeature>().Trailers.Accept = "Custom 你好 Tag"); 2495Assert.Equal(2, _decodedHeaders.Count); 2496Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 2497Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 2509Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("Custom你好Name", "Custom Value")); 2510Assert.Throws<InvalidOperationException>(() => context.Response.AppendTrailer("CustomName", "Custom \r Value")); 2538Assert.Equal(2, _decodedHeaders.Count); 2539Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 2540Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 2546Assert.Equal(3, _decodedHeaders.Count); 2547Assert.Equal("Custom 你好 Value", _decodedHeaders["CustomName"]); 2548Assert.Equal("Custom 你好 Tag", _decodedHeaders[HeaderNames.ETag]); 2549Assert.Equal("Custom 你好 Accept", _decodedHeaders[HeaderNames.Accept]); 2579Assert.Equal(2, _decodedHeaders.Count); 2580Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 2581Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 2624Assert.Single(_decodedHeaders); 2625Assert.Equal(trailerValue, _decodedHeaders["too_long"]); 2669Assert.Equal("a-value", _decodedHeaders["a-key"]); 2670Assert.Equal("b-value", _decodedHeaders["b-key"]); 2674Assert.Empty(_decodedHeaders); 2677Assert.Equal(trailerValue, _decodedHeaders["too_long"]); 2708Assert.Equal("a-value", _decodedHeaders["a-key"]); 2709Assert.Equal("b-value", _decodedHeaders["b-key"]); 2713Assert.Empty(_decodedHeaders); 2716Assert.Equal(trailerValue, _decodedHeaders["too_long"]); 2750Assert.Empty(_decodedHeaders); 2758Assert.Equal(trailerValue, _decodedHeaders["too_long"]); 2767Assert.Empty(_decodedHeaders); 2775Assert.Equal(trailerValue, _decodedHeaders["too_long2"]); 2811Assert.Single(_decodedHeaders); 2812Assert.Equal(shortValue, _decodedHeaders["short"]); 2821Assert.Empty(_decodedHeaders); 2829Assert.Equal(trailerValue, _decodedHeaders["long"]); 2830Assert.Equal(shortValue, _decodedHeaders["short2"]); 2856Assert.Equal(2, _decodedHeaders.Count); 2857Assert.Equal("200", _decodedHeaders[":status"]); 2858Assert.Equal("Sat, 01 Jan 2000 00:00:00 GMT", _decodedHeaders["date"]); 2867Assert.Empty(_decodedHeaders); 2875Assert.Single(_decodedHeaders); 2876Assert.Equal(value, _decodedHeaders["too_long_header"]); 2892Assert.Empty(_decodedHeaders); 2900Assert.Single(_decodedHeaders); 2901Assert.Equal(value, _decodedHeaders["too_long_trailer"]); 2914Assert.Equal(2, _decodedHeaders.Count); 2915Assert.Equal("200", _decodedHeaders[":status"]); 2916Assert.Equal("Sat, 01 Jan 2000 00:00:00 GMT", _decodedHeaders["date"]); 2925Assert.Empty(_decodedHeaders); 2933Assert.Single(_decodedHeaders); 2934Assert.Equal(value, _decodedHeaders["too_long_header"]); 2950Assert.Empty(_decodedHeaders); 2958Assert.Single(_decodedHeaders); 2959Assert.Equal(value, _decodedHeaders["too_long_trailer"]); 3008Assert.False(dataTask.IsCompletedSuccessfully); 3023Assert.Equal(2, _decodedHeaders.Count); 3024Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 3025Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 3030Assert.Single(_decodedHeaders); 3031Assert.Equal("Custom Value", _decodedHeaders["CustomName"]); 3075Assert.Equal(2, _decodedHeaders.Count); 3076Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 3077Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 3082Assert.Single(_decodedHeaders); 3083Assert.Equal("Custom Value", _decodedHeaders["CustomName"]); 3107Assert.Contains(LogMessages, m => (m.Exception?.Message.Contains("App Faulted") ?? false) && m.LogLevel == LogLevel.Error); 3113Assert.Equal(3, _decodedHeaders.Count); 3114Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 3115Assert.Equal("500", _decodedHeaders[InternalHeaderNames.Status]); 3116Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 3151Assert.Equal(2, _decodedHeaders.Count); 3152Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 3153Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 3164Assert.Contains(1, _abortedStreamIds); 3197Assert.Contains(1, _abortedStreamIds); 3232Assert.Contains(1, _abortedStreamIds); 3274Assert.Contains(1, _abortedStreamIds); 3318Assert.Contains(1, _abortedStreamIds); 3358Assert.Contains(1, _abortedStreamIds); 3410Assert.Contains(1, _abortedStreamIds); 3425var thrownExTask = Assert.ThrowsAnyAsync<OperationCanceledException>(() => context.Request.Body.ReadAsync(buffer, 0, buffer.Length)); 3427Assert.True(thrownExTask.IsCompleted); 3437Assert.NotNull(thrownEx); 3438Assert.IsType<ConnectionAbortedException>(thrownEx); 3439Assert.Equal(CoreStrings.ConnectionAbortedByApplication, thrownEx.Message); 3450var thrownExTask = Assert.ThrowsAnyAsync<OperationCanceledException>(() => context.Request.Body.ReadAsync(buffer, 0, buffer.Length)); 3452Assert.False(thrownExTask.IsCompleted); 3464Assert.NotNull(thrownEx); 3465Assert.IsType<TaskCanceledException>(thrownEx); 3466Assert.Equal("The request was aborted", thrownEx.Message); 3467Assert.IsType<ConnectionAbortedException>(thrownEx.InnerException); 3468Assert.Equal(CoreStrings.ConnectionAbortedByApplication, thrownEx.InnerException.Message); 3553Assert.Equal((int)Http2PeerSettings.DefaultMaxFrameSize, _decodedHeaders[HeaderNames.ETag].Length); 3590Assert.Equal((int)Http2PeerSettings.DefaultMaxFrameSize, _decodedHeaders[HeaderNames.ETag].Length); 3591Assert.Equal(30, _decodedHeaders[HeaderNames.TE].Length); 3639Assert.Equal((int)Http2PeerSettings.DefaultMaxFrameSize, _decodedHeaders[HeaderNames.ETag].Length); 3640Assert.Equal((int)Http2PeerSettings.DefaultMaxFrameSize, _decodedHeaders[HeaderNames.TE].Length); 3702Assert.Equal((int)Http2PeerSettings.DefaultMaxFrameSize - 20, _decodedHeaders[HeaderNames.ETag].Length); 3740Assert.Equal(headerValue, _decodedHeaders[longHeaderName]); 3791await Assert.ThrowsAsync<OperationCanceledException>(() => context.Response.WriteAsync("hello,", new CancellationToken(true))); 3792Assert.False(context.Response.HasStarted); 3806Assert.Equal(3, _decodedHeaders.Count); 3807Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 3808Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 3809Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 3828await Assert.ThrowsAsync<OperationCanceledException>(() => writeTask); 3855Assert.Equal(2, _decodedHeaders.Count); 3856Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 3857Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 3899Assert.Equal(2, _decodedHeaders.Count); 3900Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 3901Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 3903Assert.True(_helloWorldBytes.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray())); 3945Assert.Equal(2, _decodedHeaders.Count); 3946Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 3947Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 3949Assert.True(_helloWorldBytes.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray())); 3966Assert.Equal(4096, memory.Length); 3998Assert.Equal(2, _decodedHeaders.Count); 3999Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4000Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4001Assert.Equal(Encoding.ASCII.GetBytes(new string('a', 4102)), dataFrame.PayloadSequence.ToArray()); 4051Assert.Equal(2, _decodedHeaders.Count); 4052Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4053Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4054Assert.Equal(Encoding.ASCII.GetBytes(new string('a', 4102)), dataFrame.PayloadSequence.ToArray()); 4097Assert.Equal(2, _decodedHeaders.Count); 4098Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4099Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4100Assert.True(_helloWorldBytes.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray())); 4147Assert.Equal(2, _decodedHeaders.Count); 4148Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4149Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4150Assert.True(_helloWorldBytes.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray())); 4192Assert.Equal(2, _decodedHeaders.Count); 4193Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4194Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4195Assert.True(_helloWorldBytes.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray())); 4214Assert.Equal(4096, memory.Length); 4217Assert.Equal(4096, memory.Length); 4235Assert.Equal(2, _decodedHeaders.Count); 4236Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4237Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4254Assert.Equal(4096, memory.Length); 4257Assert.Equal(4096, memory.Length); 4273Assert.Equal(3, _decodedHeaders.Count); 4274Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4275Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4276Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 4296Assert.True(result.IsCompleted); 4329Assert.True(cancelledResult.IsCanceled); 4333Assert.False(goodResult.IsCanceled); 4416Assert.Equal(2, _decodedHeaders.Count); 4417Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4418Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4466Assert.Equal(3, _decodedHeaders.Count); 4467Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4468Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4469Assert.Equal("12", _decodedHeaders[HeaderNames.ContentLength]); 4512Assert.Equal(3, _decodedHeaders.Count); 4513Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4514Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4515Assert.Equal("12", _decodedHeaders[HeaderNames.ContentLength]); 4552Assert.Equal(3, _decodedHeaders.Count); 4553Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4554Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4555Assert.Equal("12", _decodedHeaders[HeaderNames.ContentLength]); 4616Assert.Equal(3, _decodedHeaders.Count); 4617Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4618Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4619Assert.Equal("54", _decodedHeaders[HeaderNames.ContentLength]); 4648Assert.Equal(3, _decodedHeaders.Count); 4649Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4650Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4666writeEx = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.WriteAsync("")); 4681Assert.Equal(3, _decodedHeaders.Count); 4682Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4683Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4684Assert.NotNull(writeEx); 4714Assert.Equal(3, _decodedHeaders.Count); 4715Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4716Assert.Equal("500", _decodedHeaders[InternalHeaderNames.Status]); 4718Assert.Contains(TestSink.Writes, w => w.EventId.Id == 13 && w.LogLevel == LogLevel.Error 4741Assert.True(startingTcs.Task.IsCompletedSuccessfully); // OnStarting got called. 4742Assert.True(context.Response.Headers.IsReadOnly); 4743Assert.True(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 4769Assert.Equal(3, _decodedHeaders.Count); 4770Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4771Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4772Assert.Equal("0", _decodedHeaders["content-length"]); 4797Assert.True(startingTcs.Task.IsCompletedSuccessfully); // OnStarting got called. 4798Assert.True(context.Response.Headers.IsReadOnly); 4799Assert.True(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 4829Assert.Equal(3, _decodedHeaders.Count); 4830Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4831Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4832Assert.Equal("0", _decodedHeaders["content-length"]); 4838Assert.Single(_decodedHeaders); 4839Assert.Equal("Custom Value", _decodedHeaders["CustomName"]); 4862var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.CompleteAsync().DefaultTimeout()); 4863Assert.Equal(CoreStrings.FormatTooFewBytesWritten(0, 25), ex.Message); 4865Assert.True(startingTcs.Task.IsCompletedSuccessfully); 4866Assert.False(context.Response.Headers.IsReadOnly); 4867Assert.False(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 4890Assert.Equal(3, _decodedHeaders.Count); 4891Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4892Assert.Equal("500", _decodedHeaders[InternalHeaderNames.Status]); 4893Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 4915Assert.True(startingTcs.Task.IsCompletedSuccessfully); // OnStarting got called. 4916Assert.True(context.Response.Headers.IsReadOnly); 4921Assert.True(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 4955Assert.Equal(2, _decodedHeaders.Count); 4956Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 4957Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 4959Assert.Equal("Hello World", Encoding.UTF8.GetString(bodyFrame.Payload.Span)); 4981Assert.True(startingTcs.Task.IsCompletedSuccessfully); // OnStarting got called. 4982Assert.True(context.Response.Headers.IsReadOnly); 4983Assert.True(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 4985var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.WriteAsync("2 Hello World").DefaultTimeout()); 4986Assert.Equal("Writing is not allowed after writer was completed.", ex.Message); 5012Assert.Equal(3, _decodedHeaders.Count); 5013Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 5014Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 5015Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 5037Assert.True(startingTcs.Task.IsCompletedSuccessfully); // OnStarting got called. 5038Assert.True(context.Response.Headers.IsReadOnly); 5042Assert.True(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 5044var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.WriteAsync("2 Hello World").DefaultTimeout()); 5045Assert.Equal("Writing is not allowed after writer was completed.", ex.Message); 5079Assert.Equal(2, _decodedHeaders.Count); 5080Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 5081Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 5083Assert.Equal("Hello World", Encoding.UTF8.GetString(bodyFrame.Payload.Span)); 5110Assert.True(false); 5124Assert.Equal(3, _decodedHeaders.Count); 5125Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 5126Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 5127Assert.Equal("0", _decodedHeaders[HeaderNames.ContentLength]); 5154Assert.False(startingTcs.Task.IsCompletedSuccessfully); // OnStarting did not get called. 5155Assert.False(context.Response.Headers.IsReadOnly); 5160Assert.True(startingTcs.Task.IsCompletedSuccessfully); // OnStarting got called. 5161Assert.True(context.Response.Headers.IsReadOnly); 5163Assert.True(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 5197Assert.Equal(2, _decodedHeaders.Count); 5198Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 5199Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 5201Assert.Equal("Hello World", Encoding.UTF8.GetString(bodyFrame.Payload.Span)); 5207Assert.Single(_decodedHeaders); 5208Assert.Equal("Custom Value", _decodedHeaders["CustomName"]); 5230Assert.True(startingTcs.Task.IsCompletedSuccessfully); // OnStarting got called. 5231Assert.True(context.Response.Headers.IsReadOnly); 5237Assert.True(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 5271Assert.Equal(2, _decodedHeaders.Count); 5272Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 5273Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 5275Assert.Equal("Hello World", Encoding.UTF8.GetString(bodyFrame.Payload.Span)); 5281Assert.Single(_decodedHeaders); 5282Assert.Equal("Custom Value", _decodedHeaders["CustomName"]); 5305Assert.True(startingTcs.Task.IsCompletedSuccessfully); // OnStarting got called. 5306Assert.True(context.Response.Headers.IsReadOnly); 5310var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.CompleteAsync().DefaultTimeout()); 5311Assert.Equal(CoreStrings.FormatTooFewBytesWritten(11, 25), ex.Message); 5313Assert.False(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 5347Assert.Equal(3, _decodedHeaders.Count); 5348Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 5349Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 5350Assert.Equal("25", _decodedHeaders[HeaderNames.ContentLength]); 5352Assert.Equal("Hello World", Encoding.UTF8.GetString(bodyFrame.Payload.Span)); 5376Assert.True(startingTcs.Task.IsCompletedSuccessfully); // OnStarting got called. 5377Assert.True(context.Response.Headers.IsReadOnly); 5381var ex = Assert.Throws<InvalidOperationException>(() => context.Response.BodyWriter.Complete()); 5382Assert.Equal(CoreStrings.FormatTooFewBytesWritten(11, 25), ex.Message); 5384Assert.False(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 5418Assert.Equal(3, _decodedHeaders.Count); 5419Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 5420Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 5421Assert.Equal("25", _decodedHeaders[HeaderNames.ContentLength]); 5423Assert.Equal("Hello World", Encoding.UTF8.GetString(bodyFrame.Payload.Span)); 5445Assert.True(startingTcs.Task.IsCompletedSuccessfully); // OnStarting got called. 5446Assert.True(context.Response.Headers.IsReadOnly); 5452Assert.True(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 5455Assert.False(context.RequestAborted.CanBeCanceled); 5492Assert.Equal(2, _decodedHeaders.Count); 5493Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 5494Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 5496Assert.Equal("Hello World", Encoding.UTF8.GetString(bodyFrame.Payload.Span)); 5502Assert.Single(_decodedHeaders); 5503Assert.Equal("Custom Value", _decodedHeaders["CustomName"]); 5527Assert.True(startingTcs.Task.IsCompletedSuccessfully); // OnStarting got called. 5528Assert.True(context.Response.Headers.IsReadOnly); 5534Assert.True(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 5537Assert.False(context.RequestAborted.CanBeCanceled); 5540await Assert.ThrowsAsync<TaskCanceledException>(async () => await requestBodyTask); 5541await Assert.ThrowsAsync<ConnectionAbortedException>(async () => await context.Request.BodyReader.ReadAsync()); 5576Assert.Equal(2, _decodedHeaders.Count); 5577Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 5578Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 5580Assert.Equal("Hello World", Encoding.UTF8.GetString(bodyFrame.Payload.Span)); 5586Assert.Single(_decodedHeaders); 5587Assert.Equal("Custom Value", _decodedHeaders["CustomName"]); 5609Assert.True(startingTcs.Task.IsCompletedSuccessfully); // OnStarting got called. 5610Assert.True(context.Response.Headers.IsReadOnly); 5616Assert.True(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 5619Assert.False(context.RequestAborted.CanBeCanceled); 5621Assert.NotNull(resetFeature); 5658Assert.Equal(2, _decodedHeaders.Count); 5659Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 5660Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 5662Assert.Equal("Hello World", Encoding.UTF8.GetString(bodyFrame.Payload.Span)); 5668Assert.Single(_decodedHeaders); 5669Assert.Equal("Custom Value", _decodedHeaders["CustomName"]); 5693Assert.True(startingTcs.Task.IsCompletedSuccessfully); // OnStarting got called. 5694Assert.True(context.Response.Headers.IsReadOnly); 5700Assert.True(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 5703Assert.False(context.RequestAborted.CanBeCanceled); 5705Assert.NotNull(resetFeature); 5708await Assert.ThrowsAsync<TaskCanceledException>(async () => await requestBodyTask); 5709await Assert.ThrowsAsync<ConnectionAbortedException>(async () => await context.Request.BodyReader.ReadAsync()); 5745Assert.Equal(2, _decodedHeaders.Count); 5746Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 5747Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 5749Assert.Equal("Hello World", Encoding.UTF8.GetString(bodyFrame.Payload.Span)); 5755Assert.Single(_decodedHeaders); 5756Assert.Equal("Custom Value", _decodedHeaders["CustomName"]); 5777Assert.Equal("£", context.Request.Headers["X-Test"]); 5792Assert.Equal(3, _decodedHeaders.Count); 5793Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 5794Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 5795Assert.Equal("0", _decodedHeaders["content-length"]); 5821Assert.Equal("£", context.Request.Headers["X-Test"]); 5865Assert.Equal(2, _decodedHeaders.Count); 5866Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 5867Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]); 5869Assert.True(_helloWorldBytes.AsSpan().SequenceEqual(dataFrame1.PayloadSequence.ToArray())); 5871Assert.Contains(LogMessages, m => m.Message.Equals("One or more of the following response headers have been removed because they are invalid for HTTP/2 and HTTP/3 responses: 'Connection', 'Transfer-Encoding', 'Keep-Alive', 'Upgrade' and 'Proxy-Connection'.")); 5895Assert.True(memory.Length >= sizeHint); 5917Assert.Equal(2, _decodedHeaders.Count); 5918Assert.Contains("date", _decodedHeaders.Keys, StringComparer.OrdinalIgnoreCase); 5919Assert.Equal("200", _decodedHeaders[InternalHeaderNames.Status]);