248await Assert.ThrowsAsync<CommunicationException>(() => resultTask);

248await Assert.ThrowsAsync<CommunicationException>(() => resultTask);

80var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => 106var ex = await Assert.ThrowsAsync<DbUpdateException>(async () =>

261var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () =>

123var ex = await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(address)); 139var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsStringAsync()); 156var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsStringAsync()); 170var ex = await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(address));

982await Assert.ThrowsAsync<InvalidOperationException>(async () => await request.BodyReader.ReadAsync());

1148thrownEx = await Assert.ThrowsAsync<IOException>(async () => 1183thrownEx = await Assert.ThrowsAsync<IOException>(async () => 1218thrownEx = await Assert.ThrowsAsync<IOException>(async () => 1254thrownEx = await Assert.ThrowsAsync<IOException>(async () => 1908exception = await Assert.ThrowsAsync<BadHttpRequestException>(async () => 1993exception = await Assert.ThrowsAsync<BadHttpRequestException>(async () => 2054exception = await Assert.ThrowsAsync<BadHttpRequestException>(async () => 3796await Assert.ThrowsAsync<OperationCanceledException>(() => context.Response.WriteAsync("hello,", new CancellationToken(true))); 3833await Assert.ThrowsAsync<OperationCanceledException>(() => writeTask); 4671writeEx = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.WriteAsync("")); 4867var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.CompleteAsync().DefaultTimeout()); 4990var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.WriteAsync("2 Hello World").DefaultTimeout()); 5049var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.WriteAsync("2 Hello World").DefaultTimeout()); 5315var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.CompleteAsync().DefaultTimeout()); 5554await Assert.ThrowsAsync<TaskCanceledException>(async () => await requestBodyTask); 5555await Assert.ThrowsAsync<ConnectionAbortedException>(async () => await context.Request.BodyReader.ReadAsync()); 5732await Assert.ThrowsAsync<TaskCanceledException>(async () => await requestBodyTask); 5733await Assert.ThrowsAsync<ConnectionAbortedException>(async () => await context.Request.BodyReader.ReadAsync());

456var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.Body.WriteAsync(new byte[1] { 0x00 }).AsTask()); 458ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.BodyWriter.WriteAsync(new byte[1] { 0x00 }).AsTask()); 465ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.Body.WriteAsync(new byte[1] { 0x00 }).AsTask()); 467ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.BodyWriter.WriteAsync(new byte[1] { 0x00 }).AsTask());

1244var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.CompleteAsync().DefaultTimeout()); 1347var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.WriteAsync("2 Hello World").DefaultTimeout()); 1399var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.WriteAsync("2 Hello World").DefaultTimeout()); 1606var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.CompleteAsync().DefaultTimeout()); 1789await Assert.ThrowsAsync<TaskCanceledException>(async () => await requestBodyTask); 1790await Assert.ThrowsAsync<ConnectionAbortedException>(async () => await context.Request.BodyReader.ReadAsync()); 1918await Assert.ThrowsAsync<TaskCanceledException>(async () => await requestBodyTask); 1919await Assert.ThrowsAsync<ConnectionAbortedException>(async () => await context.Request.BodyReader.ReadAsync()); 2080var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => readTrailersTcs.Task).DefaultTimeout(); 2559exception = await Assert.ThrowsAsync<BadHttpRequestException>(async () => 2631exception = await Assert.ThrowsAsync<BadHttpRequestException>(async () => 2684exception = await Assert.ThrowsAsync<BadHttpRequestException>(async () =>

428await Assert.ThrowsAsync<IOException>(() => 490await Assert.ThrowsAsync<IOException>(() => 642await Assert.ThrowsAsync<PlatformNotSupportedException>(() => context.Connection.GetClientCertificateAsync()); 902var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Connection.GetClientCertificateAsync()); 1086var ioe = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Connection.GetClientCertificateAsync());

560var ex = await Assert.ThrowsAsync<IOException>(async () =>

900await Assert.ThrowsAsync<HttpRequestException>(() => httpClient.SendAsync(httpRequestMessage));

36requestRejectedEx = await Assert.ThrowsAsync<BadHttpRequestException>( 76BadHttpRequestException requestRejectedEx = await Assert.ThrowsAsync<BadHttpRequestException>(async () => 123BadHttpRequestException requestRejectedEx = await Assert.ThrowsAsync<BadHttpRequestException>(async () => 179requestRejectedEx = await Assert.ThrowsAsync<BadHttpRequestException>( 377requestRejectedEx1 = await Assert.ThrowsAsync<BadHttpRequestException>( 379requestRejectedEx2 = await Assert.ThrowsAsync<BadHttpRequestException>( 425requestRejectedEx = await Assert.ThrowsAsync<BadHttpRequestException>(async () => 534requestRejectedEx = await Assert.ThrowsAsync<BadHttpRequestException>(async () => 590requestRejectedEx1 = await Assert.ThrowsAsync<BadHttpRequestException>( 592requestRejectedEx2 = await Assert.ThrowsAsync<BadHttpRequestException>(

1965await Assert.ThrowsAsync<InvalidOperationException>(async () => await request.BodyReader.ReadAsync());

206await Assert.ThrowsAsync<OperationCanceledException>(() => appTcs.Task).DefaultTimeout(); 485readException = await Assert.ThrowsAsync<BadHttpRequestException>( 703var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => responseWriteTcs.Task).DefaultTimeout(); 781var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => responseWriteTcs.Task).DefaultTimeout(); 819var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => responseWriteTcs.Task).DefaultTimeout(); 861var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => responseWriteTcs.Task).DefaultTimeout(); 2681var writeException = await Assert.ThrowsAsync<ObjectDisposedException>(async () => await response.BodyWriter.FlushAsync()); 4034writeEx = await Assert.ThrowsAsync<InvalidOperationException>(() => httpContext.Response.WriteAsync("test"));

31var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.Body.WriteAsync(new byte[1], 0, 1)); 34await Assert.ThrowsAsync<InvalidOperationException>(() => context.Response.BodyWriter.WriteAsync(new byte[1]).AsTask()); 154var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await upgradeTcs.Task.DefaultTimeout()); 296var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await upgradeTcs.Task).DefaultTimeout(); 347var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await upgradeTcs.Task.TimeoutAfter(TimeSpan.FromSeconds(60)));

101var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => upgradeFeature.UpgradeAsync());

522var serverEx = await Assert.ThrowsAsync<IOException>(() => serverReadTask).DefaultTimeout(); 572var ex = await Assert.ThrowsAsync<HttpRequestException>(() => sendTask).DefaultTimeout(); 588var serverEx = await Assert.ThrowsAsync<ConnectionAbortedException>(() => serverReadTask).DefaultTimeout(); 628var ex = await Assert.ThrowsAsync<HttpRequestException>(async () => 1047var serverEx = await Assert.ThrowsAsync<IOException>(() => serverReadTask).DefaultTimeout(); 1902await Assert.ThrowsAsync<HttpRequestException>(() => responseTask).DefaultTimeout();

281var exception = await Assert.ThrowsAsync<NotSupportedException>(() =>

599var exception = await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(url)).DefaultTimeout(); 628var exception = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsStringAsync()).DefaultTimeout(); 741var responseEx = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsStringAsync().DefaultTimeout()); 743await Assert.ThrowsAsync<HttpProtocolException>(() => streamingContent.SendAsync("Hello World").DefaultTimeout()); 800var responseEx = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsStringAsync().DefaultTimeout()); 802await Assert.ThrowsAsync<HttpProtocolException>(() => streamingContent.SendAsync("Hello World").DefaultTimeout()); 825var ex = await Assert.ThrowsAsync<IOException>(() => readTask).DefaultTimeout(); 872var ex = await Assert.ThrowsAsync<IOException>(() => readTask).DefaultTimeout(); 936await Assert.ThrowsAsync<TaskCanceledException>(() => requestTask).DefaultTimeout(); 1370var ex = await Assert.ThrowsAsync<HttpRequestException>(() => client.SendAsync(request).DefaultTimeout()); 1401var ex = await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(url)).DefaultTimeout();

37var exception = await Assert.ThrowsAsync<InvalidOperationException>( 58var exception = await Assert.ThrowsAsync<InvalidOperationException>( 794var exception = await Assert.ThrowsAsync<AntiforgeryValidationException>( 858var exception = await Assert.ThrowsAsync<AntiforgeryValidationException>( 882var exception = await Assert.ThrowsAsync<AntiforgeryValidationException>( 908var exception = await Assert.ThrowsAsync<AntiforgeryValidationException>( 934var exception = await Assert.ThrowsAsync<AntiforgeryValidationException>(

313var ex = await Assert.ThrowsAsync<AntiforgeryValidationException>(() => tokenStore.GetRequestTokensAsync(httpContext.Object)); 338var ex = await Assert.ThrowsAsync<AntiforgeryValidationException>(() => tokenStore.GetRequestTokensAsync(httpContext.Object));

23var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.AuthenticateAsync("missing")); 62var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.ChallengeAsync("missing")); 77var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.ForbidAsync("missing")); 91var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync("signin", new ClaimsPrincipal(), null)); 124var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync("base", new ClaimsPrincipal(new ClaimsIdentity("whatever")), null)); 128ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync("signout", new ClaimsPrincipal(new ClaimsIdentity("whatever")), null)); 147var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignOutAsync("base")); 168var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignOutAsync()); 170ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync(new ClaimsPrincipal(new ClaimsIdentity("whatever")))); 225var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync(new ClaimsPrincipal(new ClaimsIdentity("whatever"))));

88var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => 136var ex = await Assert.ThrowsAsync<Exception>(() =>

36var ex = await Assert.ThrowsAsync<NotSupportedException>(() => SendAsync(server, "/Anonymous1", connection: null)); 101var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => SendAsync(server, "/404", testConnection)); 111var ex = await Assert.ThrowsAsync<TrueException>(() => SendAsync(server, "/404", new TestConnection(), "Negotiate ClientNtlmBlob2")); 329var ex = await Assert.ThrowsAsync<Exception>(() => SendAsync(server, "/404", testConnection, "Negotiate OtherError")); 478return Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync(new ClaimsPrincipal())); 483return Assert.ThrowsAsync<InvalidOperationException>(() => context.SignOutAsync());

28var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await CreateHostAsync(supportsAuth: true, isEnabled: false));

114var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => authenticationService.AuthenticateAsync(httpContext, scheme: "custom")); 166var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => authenticationService.ChallengeAsync(httpContext, scheme: "custom", properties: null)); 217var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => authenticationService.ForbidAsync(httpContext, scheme: "custom", properties: null)); 268var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => authenticationService.SignInAsync(httpContext, scheme: "custom", new ClaimsPrincipal(), properties: null)); 319var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => authenticationService.SignOutAsync(httpContext, scheme: "custom", properties: null));

313await Assert.ThrowsAsync<InvalidOperationException>(async () => await SendAsync(server, "http://example.com/testpath")); 326await Assert.ThrowsAsync<InvalidOperationException>(async () => await SendAsync(server, "http://example.com/testpath")); 1284await Assert.ThrowsAsync<InvalidOperationException>(() => context.ChallengeAsync(CookieAuthenticationDefaults.AuthenticationScheme));

63await Assert.ThrowsAsync<InvalidOperationException>(() => server.SendAsync("http://example.com/auth/One")); 80await Assert.ThrowsAsync<InvalidOperationException>(() => server.SendAsync("http://example.com/auth/Two")); 87await Assert.ThrowsAsync<InvalidOperationException>(() => server.SendAsync("http://example.com/auth/Two")); 88await Assert.ThrowsAsync<InvalidOperationException>(() => server.SendAsync("http://example.com/auth/One"));

1213await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync("Google", new ClaimsPrincipal())); 1217await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignOutAsync("Google")); 1221await Assert.ThrowsAsync<InvalidOperationException>(() => context.ForbidAsync("Google"));

613var exception = await Assert.ThrowsAsync<Exception>(delegate 685var exception = await Assert.ThrowsAsync<Exception>(delegate 757var exception = await Assert.ThrowsAsync<Exception>(delegate 1221await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync(JwtBearerDefaults.AuthenticationScheme, new ClaimsPrincipal())); 1225await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignOutAsync(JwtBearerDefaults.AuthenticationScheme));

575var exception = await Assert.ThrowsAsync<Exception>(delegate 641var exception = await Assert.ThrowsAsync<Exception>(delegate 707var exception = await Assert.ThrowsAsync<Exception>(delegate 1289await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync(JwtBearerDefaults.AuthenticationScheme, new ClaimsPrincipal())); 1293await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignOutAsync(JwtBearerDefaults.AuthenticationScheme));

405await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync("Microsoft", new ClaimsPrincipal())); 409await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignOutAsync("Microsoft")); 413await Assert.ThrowsAsync<InvalidOperationException>(() => context.ForbidAsync("Microsoft"));

473var exception = await Assert.ThrowsAsync<AuthenticationFailureException>( 514var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(

470var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => server.SendAsync(ChallengeEndpoint)); 756var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => server.SendAsync(ChallengeEndpoint)); 779var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => server.SendAsync(ChallengeEndpoint)); 964await Assert.ThrowsAsync<InvalidOperationException>(() => server.SendAsync(ChallengeEndpoint));

68await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync(new ClaimsPrincipal())); 97await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync(new ClaimsPrincipal())); 301await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync(new ClaimsPrincipal())); 356await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync(new ClaimsPrincipal())); 416await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync(new ClaimsPrincipal())); 576var exception = await Assert.ThrowsAsync<T>(() => BuildTestServer(options).SendAsync(@"https://example.com"));

67var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(delegate 136var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(delegate 245var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(delegate 351var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(delegate 459var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(delegate 569var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(delegate 693var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(delegate

67var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(delegate 136var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(delegate 245var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(delegate 351var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(delegate 459var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(delegate 569var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(delegate 693var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(delegate

304var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => server.SendAsync(DefaultHost + TestServerBuilder.Signout));

69var error = await Assert.ThrowsAsync<InvalidOperationException>(() => server.SendAsync("https://example.com/challenge")); 82var error = await Assert.ThrowsAsync<InvalidOperationException>(() => server.SendAsync("https://example.com/challenge")); 97var error = await Assert.ThrowsAsync<InvalidOperationException>(() => server.SendAsync("https://example.com/challenge"));

67await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignOutAsync()); 77await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync(new ClaimsPrincipal())); 367await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignOutAsync()); 377await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync(new ClaimsPrincipal())); 436await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignOutAsync()); 446await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync(new ClaimsPrincipal())); 510await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignOutAsync()); 520await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync(new ClaimsPrincipal()));

302var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => 332await Assert.ThrowsAsync<HttpRequestException>(async () => 556await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignInAsync("Twitter", new ClaimsPrincipal())); 560await Assert.ThrowsAsync<InvalidOperationException>(() => context.SignOutAsync("Twitter")); 564await Assert.ThrowsAsync<InvalidOperationException>(() => context.ForbidAsync("Twitter"));

72var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => httpClient.GetAsync("/")); 153var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(() => httpClient.PostAsync(httpClient.BaseAddress + "signin-wsfed", form));

63var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => httpClient.GetAsync("/")); 144var exception = await Assert.ThrowsAsync<AuthenticationFailureException>(() => httpClient.PostAsync(httpClient.BaseAddress + "signin-wsfed", form));

75await Assert.ThrowsAsync<InvalidOperationException>(() => authorizationService.AuthorizeAsync(user, "UnknownPolicy")); 157var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => authorizationService.AuthorizeAsync(user, resource: null, new TestRequirement()));

30await Assert.ThrowsAsync<InvalidOperationException>(() => AuthorizationPolicy.CombineAsync(provider, new AuthorizeAttribute[] { 340var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => authorizationService.AuthorizeAsync(new ClaimsPrincipal(), "whatever", "BogusPolicy"));

793var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await renderer.PrerenderComponentAsync( 813var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await renderer.PrerenderComponentAsync( 833var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await renderer.PrerenderComponentAsync( 872var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await renderer.PrerenderComponentAsync( 946var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => 989var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => renderer.DispatchSubmitEventAsync("default", out isBadRequest)); 1515await Assert.ThrowsAsync<InvalidOperationException>(async () => await renderer.PrerenderPersistedStateAsync(httpContext));

251var ex = await Assert.ThrowsAsync<InvalidOperationException>(

114var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await remoteJSDataStream.CopyToAsync(mem).DefaultTimeout()); 128var ex = await Assert.ThrowsAsync<EndOfStreamException>(async () => await RemoteJSDataStream.ReceiveData(jsRuntime, streamId, chunkId: 0, chunk, error: null).DefaultTimeout()); 133ex = await Assert.ThrowsAsync<EndOfStreamException>(async () => await remoteJSDataStream.CopyToAsync(mem).DefaultTimeout()); 147var ex = await Assert.ThrowsAsync<EndOfStreamException>(async () => await RemoteJSDataStream.ReceiveData(jsRuntime, streamId, chunkId: 0, chunk, error: null).DefaultTimeout()); 152ex = await Assert.ThrowsAsync<EndOfStreamException>(async () => await remoteJSDataStream.CopyToAsync(mem).DefaultTimeout()); 167var ex = await Assert.ThrowsAsync<EndOfStreamException>(async () => await RemoteJSDataStream.ReceiveData(jsRuntime, streamId, chunkId: 0, chunk, error: null).DefaultTimeout()); 172ex = await Assert.ThrowsAsync<EndOfStreamException>(async () => await remoteJSDataStream.CopyToAsync(mem).DefaultTimeout()); 191var ex = await Assert.ThrowsAsync<EndOfStreamException>(async () => await RemoteJSDataStream.ReceiveData(jsRuntime, streamId, chunkId: 7, chunk, error: null).DefaultTimeout()); 196ex = await Assert.ThrowsAsync<EndOfStreamException>(async () => await remoteJSDataStream.CopyToAsync(mem).DefaultTimeout()); 232var ex = await Assert.ThrowsAsync<TimeoutException>(async () => await remoteJSDataStream.CopyToAsync(mem).DefaultTimeout()); 281var ex = await Assert.ThrowsAsync<TimeoutException>(async () => await remoteJSDataStream.CopyToAsync(mem).DefaultTimeout());

423var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => renderer.OnRenderCompletedAsync(4, null)); 447var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => AddWebRootComponentAsync(renderer, MaxInteractiveServerRootComponentCount)); 463var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => AddWebRootComponentAsync(renderer, 0)); 476var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => 514var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => 534var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () =>

14await Assert.ThrowsAsync<InvalidOperationException>(() =>

177var ex = await Assert.ThrowsAsync<JsonException>( 193var ex = await Assert.ThrowsAsync<CryptographicException>( 213var ex = await Assert.ThrowsAsync<CryptographicException>( 230var ex = await Assert.ThrowsAsync<CryptographicException>(

412var actual = await Assert.ThrowsAsync<TimeZoneNotFoundException>(() => renderer.RenderRootComponentAsync(componentId)); 428var actual = await Assert.ThrowsAsync<TimeZoneNotFoundException>(() => renderer.RenderRootComponentAsync(componentId)); 444var actual = await Assert.ThrowsAsync<TimeZoneNotFoundException>(() => renderer.RenderRootComponentAsync(componentId)); 460var actual = await Assert.ThrowsAsync<TimeZoneNotFoundException>(() => renderer.RenderRootComponentAsync(componentId));

56await Assert.ThrowsAsync<InvalidTimeZoneException>(() =>

160await Assert.ThrowsAsync<ArgumentException>(() => 268await Assert.ThrowsAsync<ArgumentException>(() =>

787var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => navigationManager.RunNotifyLocationChangingAsync($"{baseUri}/subdir1", null, false)); 809var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => navigationManager.RunNotifyLocationChangingAsync($"{baseUri}/subdir1", null, false));

78await Assert.ThrowsAsync<InvalidOperationException>(() => persistenceManager.RestoreStateAsync(store)); 105await Assert.ThrowsAsync<InvalidOperationException>(() => persistenceManager.PersistStateAsync(store, renderer));

342await Assert.ThrowsAsync<TimeoutException>(() => renderTask1.WaitAsync(TimeSpan.FromMilliseconds(250))); 1565await Assert.ThrowsAsync<InvalidTimeZoneException>(() => task); 1597await Assert.ThrowsAsync<InvalidTimeZoneException>(() => task); 1633await Assert.ThrowsAsync<InvalidTimeZoneException>(() => task); 1903await Assert.ThrowsAsync<InvalidTimeZoneException>(() => task); 1940await Assert.ThrowsAsync<InvalidTimeZoneException>(() => task); 1981await Assert.ThrowsAsync<InvalidTimeZoneException>(() => task); 1991await Assert.ThrowsAsync<ArgumentException>(() => 2701await Assert.ThrowsAsync<ArgumentException>(() => 2742await Assert.ThrowsAsync<ArgumentException>(() => 2793await Assert.ThrowsAsync<ArgumentException>(() => 2828await Assert.ThrowsAsync<ArgumentException>(() => 3534var ex = await Assert.ThrowsAsync<ArgumentException>(() => 4537var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => renderer.RenderRootComponentAsync(rootComponentId));

474await Assert.ThrowsAsync<InvalidTimeZoneException>(async () => await task); 562await Assert.ThrowsAsync<InvalidTimeZoneException>(async () => await task); 656await Assert.ThrowsAsync<InvalidTimeZoneException>(async () => await task); 744await Assert.ThrowsAsync<InvalidTimeZoneException>(async () => await task);

42var ex = await Assert.ThrowsAsync<InvalidOperationException>( 56var ex = await Assert.ThrowsAsync<InvalidOperationException>(

33var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => InputRenderer.RenderAndGetComponent(rootComponent));

23var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => RenderAndGetTestInputComponentAsync(rootComponent));

29var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => resultTask); 894var ex = await Assert.ThrowsAsync<InvalidTimeZoneException>(async () => 916var ex = await Assert.ThrowsAsync<InvalidTimeZoneException>(() => 962var ex = await Assert.ThrowsAsync<InvalidTimeZoneException>(() =>

30var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await testRenderer.RenderRootComponentAsync(componentId)); 49var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await testRenderer.RenderRootComponentAsync(componentId)); 68var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await testRenderer.RenderRootComponentAsync(componentId)); 98var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await testRenderer.RenderRootComponentAsync(componentId));

50var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => host.RunAsyncCore(cts.Token));

72var ex = await Assert.ThrowsAsync<EndOfStreamException>(async () => await pullFromJSDataStream.CopyToAsync(mem).DefaultTimeout()); 86var ex = await Assert.ThrowsAsync<EndOfStreamException>(async () => await pullFromJSDataStream.CopyToAsync(mem).DefaultTimeout()); 100var ex = await Assert.ThrowsAsync<EndOfStreamException>(async () => await pullFromJSDataStream.CopyToAsync(mem).DefaultTimeout());

108var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await webViewManager.AddRootComponentAsync(typeof(MyComponent), arbitraryComponentSelector, ParameterView.Empty));

119await Assert.ThrowsAsync<DivideByZeroException>(() => middleware.Invoke(new DefaultHttpContext())).DefaultTimeout(); 164await Assert.ThrowsAsync<DivideByZeroException>(() => middleware.Invoke(context)).DefaultTimeout();

655var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => client.GetAsync(requestPath)); 693var ex = await Assert.ThrowsAsync<HttpRequestException>(() => client.PutAsync("/error?body=true", content)); 727var ex = await Assert.ThrowsAsync<HttpRequestException>(() => client.PutAsync("/error?body=true", content));

367await Assert.ThrowsAsync<InvalidOperationException>(() => middleware.Invoke(httpContext)); 543await Assert.ThrowsAsync<InvalidOperationException>(() => middleware.Invoke(httpContext));

1161await Assert.ThrowsAsync<HttpRequestException>(async () => await server.CreateClient().GetAsync("/path"));

90var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => client.GetAsync("http://localhost/")); 164var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => host.StartAsync());

34await Assert.ThrowsAsync<InvalidOperationException>(() => host.GetTestServer().SendAsync(_ => { }));

1297var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => 1354var startEx = await Assert.ThrowsAsync<InvalidOperationException>(() => host.StartAsync()); 1379var startEx = await Assert.ThrowsAsync<InvalidOperationException>(() => host.StartAsync());

27var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => CreateBuilder().Build().StartAsync()); 471await Assert.ThrowsAsync<InvalidOperationException>(() => host.StartAsync()); 691await Assert.ThrowsAsync<InvalidOperationException>(() => host.StartAsync());

29await Assert.ThrowsAsync<TaskCanceledException>( 43await Assert.ThrowsAsync<TaskCanceledException>(

191await Assert.ThrowsAsync<NotImplementedException>(() => app.Invoke(context));

57throw await Assert.ThrowsAsync<Exception>(() => next()); 61throw await Assert.ThrowsAsync<Exception>(() => next(context)); 73var ex = await Assert.ThrowsAsync<Exception>(() => builder.Build().Invoke(context));

126var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => app(new DefaultHttpContext())); 140var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => app(new DefaultHttpContext())); 165var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => app(new DefaultHttpContext())); 227var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => 244var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () =>

134var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await connection.Transport.Input.ReadAsync()); 137exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await connection.Application.Input.ReadAsync()); 325var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await firstTask.DefaultTimeout()); 328exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await secondTask.DefaultTimeout()); 352await Assert.ThrowsAsync<TaskCanceledException>(async () => await firstTask.DefaultTimeout()); 353await Assert.ThrowsAsync<TaskCanceledException>(async () => await secondTask.DefaultTimeout());

42var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await context.Request.ReadFromJsonAsync<int>()); 57var ex = await Assert.ThrowsAsync<JsonException>(async () => await context.Request.ReadFromJsonAsync<int>()); 150await Assert.ThrowsAsync<TaskCanceledException>(async () => await readTask); 161var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await context.Request.ReadFromJsonAsync<object>()); 205var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await context.Request.ReadFromJsonAsync(typeof(object)));

138await Assert.ThrowsAsync<TaskCanceledException>(async () => await writeTask); 207await Assert.ThrowsAsync<ArgumentNullException>(async () => await context.Response.WriteAsJsonAsync(value: null, type: null!)); 219await Assert.ThrowsAsync<ArgumentNullException>(async () => await HttpResponseJsonExtensions.WriteAsJsonAsync(response: null!, value: null, typeof(int?)));

75await Assert.ThrowsAsync<InvalidOperationException>(async () => await service.WriteAsync(new() { HttpContext = context })); 91await Assert.ThrowsAsync<InvalidOperationException>(async () => await service.WriteAsync(new() { HttpContext = context }));

761var badHttpRequestException = await Assert.ThrowsAsync<BadHttpRequestException>(() => requestDelegate(httpContext)); 1162var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => requestDelegateResult.RequestDelegate(httpContext)); 1758await Assert.ThrowsAsync<InvalidOperationException>(() => requestDelegate(httpContext));

58var exception = await Assert.ThrowsAsync<BadHttpRequestException>(async () => await requestDelegate(httpContext)); 105var exception = await Assert.ThrowsAsync<BadHttpRequestException>(async () => await requestDelegate(httpContext)); 153var exception = await Assert.ThrowsAsync<BadHttpRequestException>(async () => await requestDelegate(httpContext)); 171var anotherException = await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () => await requestDelegate(httpContext)); 280var exception = await Assert.ThrowsAsync<BadHttpRequestException>(async () => await requestDelegate(httpContext));

46var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => endpoint.RequestDelegate(httpContext)); 458var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await endpoint.RequestDelegate(httpContext)); 475_ = await Assert.ThrowsAsync<NullReferenceException>(async () => await endpoint.RequestDelegate(httpContext));

103var ex = await Assert.ThrowsAsync<BadHttpRequestException>(() => endpoint.RequestDelegate(httpContext)); 132var ex = await Assert.ThrowsAsync<BadHttpRequestException>(() => endpoint.RequestDelegate(httpContext)); 197var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => endpoint.RequestDelegate(httpContext));

283await Assert.ThrowsAsync<InvalidOperationException>(() => endpoint.RequestDelegate(httpContext)); 314await Assert.ThrowsAsync<InvalidOperationException>(() => endpoints[0].RequestDelegate(httpContext));

335var ex = await Assert.ThrowsAsync<BadHttpRequestException>(() => request); 1004var badHttpRequestException = await Assert.ThrowsAsync<BadHttpRequestException>(() => endpoint.RequestDelegate(httpContext));

202var ex = await Assert.ThrowsAsync<BadHttpRequestException>(() => endpoint.RequestDelegate(httpContext));

127var exception = await Assert.ThrowsAsync<InvalidOperationException>( 225var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await endpoint.RequestDelegate(httpContext));

152var badHttpRequestException = await Assert.ThrowsAsync<BadHttpRequestException>(() => endpoint.RequestDelegate(httpContext)); 191var badHttpRequestException = await Assert.ThrowsAsync<BadHttpRequestException>(() => endpoint.RequestDelegate(httpContext)); 269var badHttpRequestException = await Assert.ThrowsAsync<BadHttpRequestException>(() => endpoint.RequestDelegate(httpContext)); 348var badHttpRequestException = await Assert.ThrowsAsync<BadHttpRequestException>(() => endpoint.RequestDelegate(httpContext)); 392var ex = await Assert.ThrowsAsync<BadHttpRequestException>(() => request); 441var ex = await Assert.ThrowsAsync<BadHttpRequestException>(() => request); 563var badHttpRequestException = await Assert.ThrowsAsync<BadHttpRequestException>(() => endpoint.RequestDelegate(httpContext)); 642var badHttpRequestException = await Assert.ThrowsAsync<BadHttpRequestException>(() => endpoint.RequestDelegate(httpContext));

283await Assert.ThrowsAsync<NotImplementedException>(async () => await endpoint.RequestDelegate(httpContext));

15return Assert.ThrowsAsync<FileNotFoundException>(() => response.SendFileAsync("foo")); 69await Assert.ThrowsAsync<OperationCanceledException>(

92var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => result.ExecuteAsync(httpContext)); 113var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => result.ExecuteAsync(httpContext));

75await Assert.ThrowsAsync<ArgumentNullException>(async () => 94await Assert.ThrowsAsync<InvalidOperationException>(async () => 290await Assert.ThrowsAsync<ArgumentNullException>(async () => 309await Assert.ThrowsAsync<InvalidOperationException>(async () => 574await Assert.ThrowsAsync<ArgumentNullException>(async () => 593await Assert.ThrowsAsync<InvalidOperationException>(async () => 935await Assert.ThrowsAsync<ArgumentNullException>(async () => 954await Assert.ThrowsAsync<InvalidOperationException>(async () => 1381await Assert.ThrowsAsync<ArgumentNullException>(async () => 1400await Assert.ThrowsAsync<InvalidOperationException>(async () =>

243await Assert.ThrowsAsync<TaskCanceledException>(() => executeTask);

383var ex = await Assert.ThrowsAsync<NotSupportedException>( 405await Assert.ThrowsAsync<DirectoryNotFoundException>( 418await Assert.ThrowsAsync<FileNotFoundException>(

478var ex = await Assert.ThrowsAsync<FileNotFoundException>(() => ExecuteAsync(httpContext, path, "text/plain"));

69var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => app.Invoke(httpContext));

41var exception = await Assert.ThrowsAsync<InvalidDataException>(() => context.Request.ReadFormAsync()); 468var exception = await Assert.ThrowsAsync<InvalidDataException>(() => context.Request.ReadFormAsync()); 492var exception = await Assert.ThrowsAsync<InvalidDataException>(() => context.Request.ReadFormAsync()); 516var exception = await Assert.ThrowsAsync<InvalidDataException>(() => context.Request.ReadFormAsync()); 540var exception = await Assert.ThrowsAsync<InvalidDataException>(() => context.Request.ReadFormAsync()); 608var exception = await Assert.ThrowsAsync<InvalidDataException>(() => context.Request.ReadFormAsync());

56await Assert.ThrowsAsync<NotSupportedException>(() => stream.WriteAsync(new byte[1], 0, 1));

183await Assert.ThrowsAsync<InvalidOperationException>(() => middleware.Invoke(context)); 248await Assert.ThrowsAsync<OperationCanceledException>(() => middleware.Invoke(context));

898await Assert.ThrowsAsync<IOException>(() => middleware.Invoke(httpContext)); 923await Assert.ThrowsAsync<IOException>(() => middleware.Invoke(httpContext)); 1588await Assert.ThrowsAsync<IOException>(() => middleware.Invoke(httpContext));

312var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => client.SendAsync(request));

318await Assert.ThrowsAsync<InvalidOperationException>(async () => await manager.GetSecurityStampAsync(user));

79await Assert.ThrowsAsync<InvalidOperationException>(async () => await manager.FindByEmailAsync("dupe@dupe.com"));

68await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.AddClaimsAsync(null, null)); 69await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.AddLoginAsync(null, null)); 70await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.AddToRoleAsync(null, null)); 71await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.GetClaimsAsync(null)); 72await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.GetLoginsAsync(null)); 73await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.GetRolesAsync(null)); 74await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.IsInRoleAsync(null, null)); 75await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.RemoveClaimsAsync(null, null)); 76await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.RemoveLoginAsync(null, null, null)); 77await Assert.ThrowsAsync<ObjectDisposedException>( 79await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.RemoveClaimsAsync(null, null)); 80await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.ReplaceClaimAsync(null, null, null)); 81await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.FindByLoginAsync(null, null)); 82await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.FindByIdAsync(null)); 83await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.FindByNameAsync(null)); 84await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.CreateAsync(null)); 85await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.UpdateAsync(null)); 86await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.DeleteAsync(null)); 87await Assert.ThrowsAsync<ObjectDisposedException>( 89await Assert.ThrowsAsync<ObjectDisposedException>(async () => await store.GetEmailConfirmedAsync(null)); 90await Assert.ThrowsAsync<ObjectDisposedException>( 92await Assert.ThrowsAsync<ObjectDisposedException>( 197await Assert.ThrowsAsync<InvalidOperationException>(async () => await manager.FindByEmailAsync("dupe@dupe.com")); 207await Assert.ThrowsAsync<InvalidOperationException>(

235await Assert.ThrowsAsync<InvalidOperationException>(()

1689var ex = await Assert.ThrowsAsync<NotSupportedException>( 1692ex = await Assert.ThrowsAsync<NotSupportedException>( 1695ex = await Assert.ThrowsAsync<NotSupportedException>( 1698ex = await Assert.ThrowsAsync<NotSupportedException>(

138await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.FindByIdAsync(null)); 139await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.FindByNameAsync(null)); 140await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.RoleExistsAsync(null)); 141await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.CreateAsync(null)); 142await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.UpdateAsync(null)); 143await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.DeleteAsync(null));

65var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => SecurityStampValidator.ValidatePrincipalAsync(context));

744await Assert.ThrowsAsync<InvalidOperationException>(() => helper.SignInAsync(user, isPersistent: false)); 1045await Assert.ThrowsAsync<InvalidOperationException>(() => helper.ForgetTwoFactorClientAsync()); 1144await Assert.ThrowsAsync<InvalidOperationException>(() => helper.SignOutAsync());

685var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => manager.CreateAsync(user)); 712var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => manager.UpdateAsync(user)); 894await Assert.ThrowsAsync<NotSupportedException>(() => manager.FindByEmailAsync(null)); 895await Assert.ThrowsAsync<NotSupportedException>(() => manager.SetEmailAsync(null, null)); 896await Assert.ThrowsAsync<NotSupportedException>(() => manager.GetEmailAsync(null)); 897await Assert.ThrowsAsync<NotSupportedException>(() => manager.IsEmailConfirmedAsync(null)); 898await Assert.ThrowsAsync<NotSupportedException>(() => manager.ConfirmEmailAsync(null, null)); 921await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.SetPhoneNumberAsync(null, null)); 922await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.ChangePhoneNumberAsync(null, null, null)); 923await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.GetPhoneNumberAsync(null)); 947await Assert.ThrowsAsync<NotSupportedException>( 949await Assert.ThrowsAsync<NotSupportedException>( 976await Assert.ThrowsAsync<NotSupportedException>(() => manager.CreateAsync(null, null)); 977await Assert.ThrowsAsync<NotSupportedException>(() => manager.ChangePasswordAsync(null, null, null)); 978await Assert.ThrowsAsync<NotSupportedException>(() => manager.AddPasswordAsync(null, null)); 979await Assert.ThrowsAsync<NotSupportedException>(() => manager.RemovePasswordAsync(null)); 980await Assert.ThrowsAsync<NotSupportedException>(() => manager.CheckPasswordAsync(null, null)); 981await Assert.ThrowsAsync<NotSupportedException>(() => manager.HasPasswordAsync(null)); 1022await Assert.ThrowsAsync<NotSupportedException>(() => manager.UpdateSecurityStampAsync(null)); 1023await Assert.ThrowsAsync<NotSupportedException>(() => manager.GetSecurityStampAsync(null)); 1024await Assert.ThrowsAsync<NotSupportedException>( 1026await Assert.ThrowsAsync<NotSupportedException>( 1051await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.AddLoginAsync(null, null)); 1052await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.RemoveLoginAsync(null, null, null)); 1053await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.GetLoginsAsync(null)); 1054await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.FindByLoginAsync(null, null)); 1077await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.AddClaimAsync(null, null)); 1078await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.ReplaceClaimAsync(null, null, null)); 1079await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.RemoveClaimAsync(null, null)); 1080await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.GetClaimsAsync(null)); 1132await Assert.ThrowsAsync<NotImplementedException>(() => manager.GenerateUserTokenAsync(new PocoUser(), "A", "purpose")); 1229await Assert.ThrowsAsync<NotImplementedException>(() => manager.GenerateUserTokenAsync(new PocoUser(), TokenOptions.DefaultProvider, "purpose")); 1237await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.GetTwoFactorEnabledAsync(null)); 1239Assert.ThrowsAsync<NotSupportedException>(async () => await manager.SetTwoFactorEnabledAsync(null, true)); 1247await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.GetLockoutEnabledAsync(null)); 1248await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.SetLockoutEnabledAsync(null, true)); 1249await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.AccessFailedAsync(null)); 1250await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.IsLockedOutAsync(null)); 1251await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.ResetAccessFailedCountAsync(null)); 1252await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.GetAccessFailedCountAsync(null)); 1260await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.AddToRoleAsync(null, "bogus")); 1261await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.AddToRolesAsync(null, null)); 1262await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.GetRolesAsync(null)); 1263await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.RemoveFromRoleAsync(null, "bogus")); 1264await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.RemoveFromRolesAsync(null, null)); 1265await Assert.ThrowsAsync<NotSupportedException>(async () => await manager.IsInRoleAsync(null, "bogus")); 1301var error = await Assert.ThrowsAsync<TException>(code); 1494await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.AddClaimAsync(null, null)); 1495await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.AddClaimsAsync(null, null)); 1496await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.AddLoginAsync(null, null)); 1497await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.AddPasswordAsync(null, null)); 1498await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.AddToRoleAsync(null, null)); 1499await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.AddToRolesAsync(null, null)); 1500await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.ChangePasswordAsync(null, null, null)); 1501await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.GetClaimsAsync(null)); 1502await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.GetLoginsAsync(null)); 1503await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.GetRolesAsync(null)); 1504await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.IsInRoleAsync(null, null)); 1505await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.RemoveClaimAsync(null, null)); 1506await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.RemoveClaimsAsync(null, null)); 1507await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.RemoveLoginAsync(null, null, null)); 1508await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.RemovePasswordAsync(null)); 1509await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.RemoveFromRoleAsync(null, null)); 1510await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.RemoveFromRolesAsync(null, null)); 1511await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.FindByLoginAsync(null, null)); 1512await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.FindByIdAsync(null)); 1513await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.FindByNameAsync(null)); 1514await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.CreateAsync(null)); 1515await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.CreateAsync(null, null)); 1516await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.UpdateAsync(null)); 1517await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.DeleteAsync(null)); 1518await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.ReplaceClaimAsync(null, null, null)); 1519await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.UpdateSecurityStampAsync(null)); 1520await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.GetSecurityStampAsync(null)); 1521await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.GeneratePasswordResetTokenAsync(null)); 1522await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.ResetPasswordAsync(null, null, null)); 1523await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.GenerateEmailConfirmationTokenAsync(null)); 1524await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.IsEmailConfirmedAsync(null)); 1525await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.ConfirmEmailAsync(null, null)); 1526await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.SetPasskeyAsync(null, null)); 1527await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.GetPasskeysAsync(null)); 1528await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.GetPasskeyAsync(null, null)); 1529await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.FindByPasskeyIdAsync(null)); 1530await Assert.ThrowsAsync<ObjectDisposedException>(() => manager.RemovePasskeyAsync(null, null));

56var ex = await Assert.ThrowsAsync<TException>(testCode).ConfigureAwait(false); 120var ex = await Assert.ThrowsAsync<TException>(testCode).ConfigureAwait(false);

17await Assert.ThrowsAsync<TimeoutException>(async () => await Task.Delay(30000, cts.Token).TimeoutAfter(TimeSpan.FromMilliseconds(50))); 37await Assert.ThrowsAsync<TimeoutException>(async () => await Task.Delay(30000, cts.Token).DefaultTimeout(TimeSpan.FromMilliseconds(50))); 45await Assert.ThrowsAsync<TimeoutException>(async () => await Task.Delay(30000, cts.Token).DefaultTimeout(50)); 53await Assert.ThrowsAsync<TimeoutException>(async () => await Task.Delay(30000, cts.Token).DefaultTimeout(50)); 72var exception = await Assert.ThrowsAsync<TimeoutException>(() => ExpectedTimeout().TimeoutAfter(TimeSpan.FromMilliseconds(30000))); 85var exception = await Assert.ThrowsAsync<TimeoutException>(() => ExpectedTimeout().TimeoutAfter(TimeSpan.FromMilliseconds(30000)));

63var ex = await Assert.ThrowsAsync<InvalidOperationException>( 79var ex = await Assert.ThrowsAsync<InvalidOperationException>(

130await Assert.ThrowsAsync<InvalidOperationException>(() => result.ExecuteResultAsync(actionContext));

100var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => pipeline(httpContext)); 214var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => pipeline(httpContext)); 282var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => pipeline(httpContext));

158var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await invoker.InvokeAsync()); 207var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await invoker.InvokeAsync());

83await Assert.ThrowsAsync<TimeZoneNotFoundException>(() => formatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.GetEncoding("utf-16")));

434var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => Execute(actionMethodExecutor, filterContext, withFilter).AsTask());

183var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => reader(enumerable, default)); 199await Assert.ThrowsAsync<TimeZoneNotFoundException>(() => reader(enumerable, default));

922await Assert.ThrowsAsync<NotImplementedException>( 945await Assert.ThrowsAsync<NotImplementedException>( 969var ex = await Assert.ThrowsAsync<ArgumentException>( 1018await Assert.ThrowsAsync<NotImplementedException>( 1346await Assert.ThrowsAsync<InvalidCastException>( 1539var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => invoker.InvokeAsync());

303var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => executor.ExecuteAsync(context, result)); 438await Assert.ThrowsAsync<OperationCanceledException>(() => executor.ExecuteAsync(context, result));

318var exception = await Assert.ThrowsAsync<InvalidOperationException>( 350var exception = await Assert.ThrowsAsync<InvalidOperationException>(

33await Assert.ThrowsAsync<TimeZoneNotFoundException>(() => executor.ExecuteAsync(context, result));

99var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => result.ExecuteResultAsync(actionContext)); 121var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => result.ExecuteResultAsync(actionContext));

458var exception = await Assert.ThrowsAsync<IOException>(() => binder.BindModelAsync(bindingContext)); 526var exception = await Assert.ThrowsAsync<IOException>(

1017var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await binder.BindModelAsync(bindingContext));

70var ex = await Assert.ThrowsAsync<ValueProviderException>(() => factory.CreateValueProviderAsync(valueProviderContext)); 84var ex = await Assert.ThrowsAsync<ValueProviderException>(() => factory.CreateValueProviderAsync(valueProviderContext)); 98var ex = await Assert.ThrowsAsync<TimeZoneNotFoundException>(() => factory.CreateValueProviderAsync(valueProviderContext));

58var ex = await Assert.ThrowsAsync<ValueProviderException>(() => factory.CreateValueProviderAsync(valueProviderContext)); 72var ex = await Assert.ThrowsAsync<ValueProviderException>(() => factory.CreateValueProviderAsync(valueProviderContext)); 86var ex = await Assert.ThrowsAsync<TimeZoneNotFoundException>(() => factory.CreateValueProviderAsync(valueProviderContext));

143var ex = await Assert.ThrowsAsync<ValueProviderException>(() => factory.CreateValueProviderAsync(valueProviderContext)); 157var ex = await Assert.ThrowsAsync<ValueProviderException>(() => factory.CreateValueProviderAsync(valueProviderContext)); 171var ex = await Assert.ThrowsAsync<TimeZoneNotFoundException>(() => factory.CreateValueProviderAsync(valueProviderContext));

43var ex = await Assert.ThrowsAsync<RouteCreationException>(() => route.RouteAsync(routeContext)); 67var ex = await Assert.ThrowsAsync<RouteCreationException>(async () => 101var ex = await Assert.ThrowsAsync<RouteCreationException>(async () => 139var ex = await Assert.ThrowsAsync<RouteCreationException>(async () =>

233await Assert.ThrowsAsync<InvalidOperationException>(() => policy.ApplyAsync(httpContext, candidates));

383var ex = await Assert.ThrowsAsync<NotSupportedException>( 405await Assert.ThrowsAsync<DirectoryNotFoundException>( 418await Assert.ThrowsAsync<FileNotFoundException>(

478var ex = await Assert.ThrowsAsync<FileNotFoundException>(() => ExecuteAsync(httpContext, path, "text/plain"));

724var thrown = await Assert.ThrowsAsync<InvalidCastException>(invoker.InvokeAsync); 1438var exception = await Assert.ThrowsAsync<DataMisalignedException>(invoker.InvokeAsync); 1474var exception = await Assert.ThrowsAsync<DataMisalignedException>(invoker.InvokeAsync); 1510var exception = await Assert.ThrowsAsync<DataMisalignedException>(invoker.InvokeAsync); 1693var exception = await Assert.ThrowsAsync<InvalidOperationException>(invoker.InvokeAsync);

229await Assert.ThrowsAsync<XmlException>(() => formatter.ReadAsync(context)); 357await Assert.ThrowsAsync<XmlException>(() => formatter.ReadAsync(context)); 426await Assert.ThrowsAsync<InputFormatterException>(async () => await formatter.ReadAsync(context)); 442await Assert.ThrowsAsync<InputFormatterException>(async () => await formatter.ReadAsync(context)); 615await Assert.ThrowsAsync<InputFormatterException>(async () => await formatter.ReadAsync(context)); 674await Assert.ThrowsAsync<InputFormatterException>(async () => await formatter.ReadAsync(context));

473await Assert.ThrowsAsync<SerializationException>(async () => await formatter.WriteAsync(outputFormatterContext)); 490await Assert.ThrowsAsync<SerializationException>(async () => await formatter.WriteAsync(outputFormatterContext));

182await Assert.ThrowsAsync<XmlException>(() => formatter.ReadAsync(context)); 226await Assert.ThrowsAsync<XmlException>(() => formatter.ReadAsync(context)); 438await Assert.ThrowsAsync<InputFormatterException>(() => formatter.ReadAsync(context)); 459await Assert.ThrowsAsync<InputFormatterException>(() => formatter.ReadAsync(context));

134var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.SendAsync(request));

163var ex = await Assert.ThrowsAsync<InvalidOperationException>(

78var exception = await Assert.ThrowsAsync<HttpRequestException>(async () => await Client.GetAsync("http://localhost/Home/MyHtml"));

404var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => parameterBinder.BindModelAsync(parameter, testContext)); 471var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => parameterBinder.BindModelAsync(parameter, testContext)); 495var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => parameterBinder.BindModelAsync(parameter, testContext)); 518var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => parameterBinder.BindModelAsync(parameter, testContext)); 557var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => parameterBinder.BindModelAsync(parameter, testContext)); 590var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => parameterBinder.BindModelAsync(parameter, testContext));

399var exception = await Assert.ThrowsAsync<InvalidOperationException>(

996var exception = await Assert.ThrowsAsync<InvalidOperationException>( 1082var exception = await Assert.ThrowsAsync<InvalidOperationException>( 1120var exception = await Assert.ThrowsAsync<InvalidOperationException>(

3324var exception = await Assert.ThrowsAsync<InvalidOperationException>( 3394var exception = await Assert.ThrowsAsync<InvalidOperationException>( 3428var exception = await Assert.ThrowsAsync<InvalidOperationException>(

3559var exception = await Assert.ThrowsAsync<InvalidOperationException>( 3645var exception = await Assert.ThrowsAsync<InvalidOperationException>( 3697var exception = await Assert.ThrowsAsync<InvalidOperationException>(

1225var exception = await Assert.ThrowsAsync<InvalidOperationException>(

179var exception = await Assert.ThrowsAsync<InvalidOperationException>(

1159var ex = await Assert.ThrowsAsync<NotSupportedException>(() => TryUpdateModelAsync(model, string.Empty, testContext));

2326var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => 2365var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => 2406var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>

503await Assert.ThrowsAsync<OperationCanceledException>(() => formatter.WriteResponseBodyAsync(outputFormatterContext, Encoding.GetEncoding("utf-8")));

183var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => reader(enumerable, default)); 199await Assert.ThrowsAsync<TimeZoneNotFoundException>(() => reader(enumerable, default));

303var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => executor.ExecuteAsync(context, result)); 438await Assert.ThrowsAsync<OperationCanceledException>(() => executor.ExecuteAsync(context, result));

702var actual = await Assert.ThrowsAsync<InvalidTimeZoneException>( 709actual = await Assert.ThrowsAsync<InvalidTimeZoneException>(

130var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => page.ExecuteAsync()); 183var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => page.ExecuteAsync()); 262var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => page.ExecuteAsync()); 410var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => page.ExecuteAsync()); 470var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => page.ExecuteAsync()); 578var ex = await Assert.ThrowsAsync<InvalidOperationException>(page.ExecuteAsync); 602var ex = await Assert.ThrowsAsync<InvalidOperationException>(page.ExecuteAsync); 626var ex = await Assert.ThrowsAsync<InvalidOperationException>(page.ExecuteAsync); 645var ex = await Assert.ThrowsAsync<InvalidOperationException>(page.ExecuteAsync); 896var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => page.ExecuteAsync());

549var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); 592var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); 637var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); 746var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); 945var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); 1014var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); 1049var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); 1232var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); 1286var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); 1500var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); 1547var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext));

294await Assert.ThrowsAsync<InvalidOperationException>(() => policy.ApplyAsync(httpContext, candidates));

524var ex = await Assert.ThrowsAsync<InvalidOperationException>( 564var ex = await Assert.ThrowsAsync<InvalidOperationException>( 602var ex = await Assert.ThrowsAsync<InvalidOperationException>( 640var ex = await Assert.ThrowsAsync<InvalidOperationException>(

678await Assert.ThrowsAsync<Exception>(() => cacheTagHelper1.ProcessAsync(tagHelperContext1, tagHelperOutput1)); 751await Assert.ThrowsAsync<Exception>(() => cacheTagHelper.ProcessAsync(tagHelperContext1, tagHelperOutput1)); 763await Assert.ThrowsAsync<Exception>(() => cacheTagHelper.ProcessAsync(tagHelperContext2, tagHelperOutput2)); 878await Assert.ThrowsAsync<DivideByZeroException>(() => task1); 879await Assert.ThrowsAsync<DivideByZeroException>(() => task2);

57var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => tagHelper.ProcessAsync(context, output));

690await Assert.ThrowsAsync<Exception>(() => cacheTagHelper1.ProcessAsync(tagHelperContext1, tagHelperOutput1));

547var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => tagHelper.ProcessAsync(context, output)); 587var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => tagHelper.ProcessAsync(context, output)); 625var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => tagHelper.ProcessAsync(context, output)); 663var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => tagHelper.ProcessAsync(context, output)); 701var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => tagHelper.ProcessAsync(context, output));

1044var ex = await Assert.ThrowsAsync<InvalidOperationException>( 1080var ex = await Assert.ThrowsAsync<InvalidOperationException>( 1114var ex = await Assert.ThrowsAsync<InvalidOperationException>( 1148var ex = await Assert.ThrowsAsync<InvalidOperationException>(

600var exception = await Assert.ThrowsAsync<InvalidOperationException>( 743var exception = await Assert.ThrowsAsync<InvalidOperationException>(

235await Assert.ThrowsAsync<InvalidOperationException>(() => tagHelper.ProcessAsync(context, output));

54var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => viewResult.ExecuteResultAsync(actionContext)); 92var ex = await Assert.ThrowsAsync<InvalidOperationException>( 130var ex = await Assert.ThrowsAsync<InvalidOperationException>( 170var ex = await Assert.ThrowsAsync<InvalidOperationException>(

420var exception = await Assert.ThrowsAsync<InvalidOperationException>( 449var exception = await Assert.ThrowsAsync<InvalidOperationException>( 480var exception = await Assert.ThrowsAsync<InvalidOperationException>( 509var exception = await Assert.ThrowsAsync<InvalidOperationException>( 538var exception = await Assert.ThrowsAsync<InvalidOperationException>( 569var exception = await Assert.ThrowsAsync<InvalidOperationException>(

63var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => viewResult.ExecuteResultAsync(actionContext)); 114var exception = await Assert.ThrowsAsync<InvalidOperationException>( 137var exception = await Assert.ThrowsAsync<InvalidOperationException>( 162var exception = await Assert.ThrowsAsync<InvalidOperationException>(

413var ex = await Assert.ThrowsAsync<InvalidOperationException>( 442var ex = await Assert.ThrowsAsync<InvalidOperationException>(

105var exception = await Assert.ThrowsAsync<NotImplementedException>(async () => await viewExecutor.ExecuteAsync(

64var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => viewResult.ExecuteResultAsync(actionContext)); 102var ex = await Assert.ThrowsAsync<InvalidOperationException>( 142var ex = await Assert.ThrowsAsync<InvalidOperationException>( 182var ex = await Assert.ThrowsAsync<InvalidOperationException>(

297await Assert.ThrowsAsync<OperationCanceledException>(async () =>

271await Assert.ThrowsAsync<TaskCanceledException>(async () =>

423var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => VerifyOpenApiDocument(builder, _ => { }));

602await Assert.ThrowsAsync<TaskCanceledException>(async () =>

887await Assert.ThrowsAsync<TaskCanceledException>(async () =>

245await Assert.ThrowsAsync<ArgumentException>(async () => await store.SetAsync(key, value, new string[] { tag }, TimeSpan.FromMinutes(1), default));

961await Assert.ThrowsAsync<SomeException>(

178await Assert.ThrowsAsync<InvalidOperationException>(() => middleware.Invoke(context)).DefaultTimeout();

32await Assert.ThrowsAsync<Exception>(async () => await executionContext.SetOutputContentAsync()); 55await Assert.ThrowsAsync<Exception>(

123await Assert.ThrowsAsync<InvalidDataException>(async () => await InvokeMiddleware(compressedBytes, new[] { contentEncoding }));

579var ex = await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => server.CreateClient().GetAsync("article/23?p1=123&p2=abc"));

152var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => server.CreateRequest("/").SendAsync("GET")); 213var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => server.CreateRequest("/").SendAsync("GET")); 244var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => server.CreateRequest("/").SendAsync("GET")); 343var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => server.CreateRequest("/").SendAsync("GET"));

208var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.SendAsync(request)); 428var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.SendAsync(request)); 487var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await client.SendAsync(request));

826var ex = await Assert.ThrowsAsync<BadHttpRequestException>(() => endpoint.RequestDelegate!(httpContext));

118var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => middleware.Invoke(httpContext)); 147var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => middleware.Invoke(httpContext)); 244var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => middleware.Invoke(httpContext)); 342var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => middleware.Invoke(httpContext));

152await Assert.ThrowsAsync<InvalidTimeZoneException>(async () => await middleware.Invoke(httpContext)); 153await Assert.ThrowsAsync<InvalidTimeZoneException>(async () => await middleware.Invoke(httpContext)); 225await Assert.ThrowsAsync<InvalidOperationException>(() => middleware.Invoke(httpContext));

161var ex = await Assert.ThrowsAsync<AmbiguousMatchException>(() => selector.SelectAsync(httpContext, candidateSet));

1842await Assert.ThrowsAsync<Exception>(() => route.RouteAsync(context));

859await Assert.ThrowsAsync<IOException>(() => readTask); 907await Assert.ThrowsAsync<IOException>(() => readTask); 957await Assert.ThrowsAsync<IOException>(() => readTask);

176var ex = await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(address)); 209var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsStringAsync()); 235var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsStringAsync()); 256var ex = await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(address));

135await Assert.ThrowsAsync<IOException>(async () => await readTask); 139await Assert.ThrowsAsync<HttpRequestException>(async () => await responseTask); 160await Assert.ThrowsAsync<IOException>(async () => await readTask); 164await Assert.ThrowsAsync<HttpRequestException>(async () => await responseTask); 185var assertTask = Assert.ThrowsAsync<IOException>(async () => await context.Request.Body.ReadAsync(input, 0, input.Length, context.DisconnectToken));

161await Assert.ThrowsAsync<HttpRequestException>(() => responseTask); 181await Assert.ThrowsAsync<HttpRequestException>(() => responseTask); 204await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.LoadIntoBufferAsync()); 226await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.LoadIntoBufferAsync()); 251await Assert.ThrowsAsync<IOException>(async () => 287await Assert.ThrowsAsync<IOException>(async () => 297await Assert.ThrowsAsync<ObjectDisposedException>(() => context.Response.Body.WriteAsync(Utilities.WriteBuffer, 0, Utilities.WriteBuffer.Length)); 385await Assert.ThrowsAsync<IOException>(async () => 424await Assert.ThrowsAsync<IOException>(async () =>

272var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await SendOpaqueRequestAsync(method, address, extraHeader)); 354var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => upgrade.Task); 358ex = await Assert.ThrowsAsync<InvalidOperationException>(() => ParseResponseAsync(stream));

266var ex = await Assert.ThrowsAsync<BadHttpRequestException>(() => httpContext.Request.Body.ReadAsync(input, 0, input.Length)); 269ex = await Assert.ThrowsAsync<BadHttpRequestException>(() => httpContext.Request.Body.ReadAsync(input, 0, input.Length)); 347var ex = await Assert.ThrowsAsync<BadHttpRequestException>(() => httpContext.Request.Body.ReadAsync(input, 0, input.Length));

243await Assert.ThrowsAsync<HttpRequestException>(() => SendRequestAsync(address)); 257await Assert.ThrowsAsync<HttpRequestException>(async () => await SendRequestAsync(address)); 270await Assert.ThrowsAsync<InvalidOperationException>(() => 275await Assert.ThrowsAsync<HttpRequestException>(() => SendRequestAsync(address));

165await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => 184await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => 391await Assert.ThrowsAsync<HttpRequestException>(() => SendRequestAsync(address)); 419await Assert.ThrowsAsync<HttpRequestException>(() => SendRequestAsync(address)); 446await Assert.ThrowsAsync<HttpRequestException>(() => SendRequestAsync(address)); 473await Assert.ThrowsAsync<HttpRequestException>(() => SendRequestAsync(address)); 497await Assert.ThrowsAsync<IOException>(async () => 506await Assert.ThrowsAsync<ObjectDisposedException>(() => 595await Assert.ThrowsAsync<IOException>(async () =>

182await Assert.ThrowsAsync<HttpRequestException>(async () => await responseTask); 204await Assert.ThrowsAsync<HttpRequestException>(async () => await responseTask); 216var ex = await Assert.ThrowsAsync<HttpRequestException>(async () => await requestTask); 221ex = await Assert.ThrowsAsync<HttpRequestException>(async () => await requestTask); 235var ex = await Assert.ThrowsAsync<HttpRequestException>(async () => await requestTask); 240ex = await Assert.ThrowsAsync<HttpRequestException>(async () => await requestTask);

192await Assert.ThrowsAsync<IOException>(() => 267await Assert.ThrowsAsync<OperationCanceledException>(() =>

29await Assert.ThrowsAsync<Exception>(() => request.ReadAsync(new byte[1], 0, 1))); 31await Assert.ThrowsAsync<Exception>(async () => await requestPipe.ReadAsync())); 44var writeEx = await Assert.ThrowsAsync<InvalidOperationException>(() => response.WriteAsync(new byte[1], 0, 1)); 48await Assert.ThrowsAsync<Exception>(() => request.ReadAsync(new byte[1], 0, 1))); 51await Assert.ThrowsAsync<Exception>(() => upgrade.ReadAsync(new byte[1], 0, 1))); 54await Assert.ThrowsAsync<Exception>(async () => await requestPipe.ReadAsync())); 70var writeEx = await Assert.ThrowsAsync<InvalidOperationException>(() => response.WriteAsync(new byte[1], 0, 1)); 74await Assert.ThrowsAsync<Exception>(() => request.ReadAsync(new byte[1], 0, 1))); 77await Assert.ThrowsAsync<Exception>(() => upgrade.ReadAsync(new byte[1], 0, 1))); 79await Assert.ThrowsAsync<Exception>(async () => await requestPipe.ReadAsync())); 120await Assert.ThrowsAsync<ObjectDisposedException>(async () => await requestPipe.ReadAsync()); 137await Assert.ThrowsAsync<ObjectDisposedException>(async () => await responsePipe.WriteAsync(new Memory<byte>())); 138await Assert.ThrowsAsync<ObjectDisposedException>(async () => await responsePipe.FlushAsync());

198var aggregateException = await Assert.ThrowsAsync<AggregateException>(async () => await memoryPool.WhenAllBlocksReturnedAsync(TimeSpan.FromSeconds(5)));

591await Assert.ThrowsAsync<InvalidOperationException>(() => _http1Connection.WriteAsync(new ArraySegment<byte>(new byte[1]))); 602await Assert.ThrowsAsync<InvalidOperationException>(() => _http1Connection.WriteAsync(new ArraySegment<byte>(new byte[1]), default(CancellationToken))); 638await Assert.ThrowsAsync<InvalidOperationException>(() => _http1Connection.FlushAsync()); 652await Assert.ThrowsAsync<InvalidOperationException>(() => _http1Connection.FlushAsync());

21await Assert.ThrowsAsync<ObjectDisposedException>(async () => { await pipeReader.ReadAsync(); }); 30await Assert.ThrowsAsync<TaskCanceledException>(() => pipeReader.ReadAsync().AsTask()); 41var exception = await Assert.ThrowsAsync<Exception>(() => pipeReader.ReadAsync().AsTask());

86await Assert.ThrowsAsync<NotSupportedException>(() => stream.WriteAsync(new byte[1], 0, 1)); 138await Assert.ThrowsAsync<TaskCanceledException>(() => stream.ReadAsync(new byte[1], 0, 1)); 150var exception = await Assert.ThrowsAsync<Exception>(() => stream.ReadAsync(new byte[1], 0, 1)); 163await Assert.ThrowsAsync<ObjectDisposedException>(async () => { await stream.ReadAsync(new byte[1], 0, 1); }); 173await Assert.ThrowsAsync<TaskCanceledException>(() => stream.CopyToAsync(Mock.Of<Stream>())); 184var exception = await Assert.ThrowsAsync<Exception>(() => stream.CopyToAsync(Mock.Of<Stream>())); 196await Assert.ThrowsAsync<ObjectDisposedException>(async () => { await stream.CopyToAsync(Mock.Of<Stream>()); }); 205await Assert.ThrowsAsync<ArgumentNullException>(async () => { await stream.CopyToAsync(null); }); 215await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () => { await stream.CopyToAsync(Mock.Of<Stream>(), 0); });

57await Assert.ThrowsAsync<NotSupportedException>(() => stream.ReadAsync(new byte[1], 0, 1)); 103var ex = await Assert.ThrowsAsync<ObjectDisposedException>(async () => { await stream.WriteAsync(new byte[1], 0, 1); });

351var exception = await Assert.ThrowsAsync<InvalidOperationException>( 392var exception = await Assert.ThrowsAsync<InvalidOperationException>( 648Assert.Same(unbindException, await Assert.ThrowsAsync<InvalidOperationException>(() => stopTask1.TimeoutAfter(timeout))); 649Assert.Same(unbindException, await Assert.ThrowsAsync<InvalidOperationException>(() => stopTask2.TimeoutAfter(timeout))); 650Assert.Same(unbindException, await Assert.ThrowsAsync<InvalidOperationException>(() => stopTask3.TimeoutAfter(timeout)));

125await Assert.ThrowsAsync<InvalidOperationException>(async () => await reader.ReadAsync()); 228await Assert.ThrowsAsync<BadHttpRequestException>(() => task); 256await Assert.ThrowsAsync<BadHttpRequestException>(() => task); 297await Assert.ThrowsAsync<BadHttpRequestException>(() => task); 378var ex = await Assert.ThrowsAsync<IOException>(async () => 401var ex = await Assert.ThrowsAsync<BadHttpRequestException>(async () => 747var exception = await Assert.ThrowsAsync<BadHttpRequestException>(async () => await body.ReadAsync()); 811var exception = await Assert.ThrowsAsync<BadHttpRequestException>(() => stream.CopyToAsync(ms)); 1223var ex2 = await Assert.ThrowsAsync<BadHttpRequestException>(() => reader.ReadAsync().AsTask()); 1224var ex3 = await Assert.ThrowsAsync<BadHttpRequestException>(() => reader.ReadAsync().AsTask()); 1256var ex2 = await Assert.ThrowsAsync<BadHttpRequestException>(() => reader.ReadAsync().AsTask()); 1257var ex3 = await Assert.ThrowsAsync<BadHttpRequestException>(() => reader.ReadAsync().AsTask()); 1283var ex2 = await Assert.ThrowsAsync<BadHttpRequestException>(() => reader.ReadAsync().AsTask()); 1284var ex3 = await Assert.ThrowsAsync<BadHttpRequestException>(() => reader.ReadAsync().AsTask());

23Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, (await Assert.ThrowsAsync<InvalidOperationException>(() => stream.WriteAsync(new byte[1], 0, 1))).Message); 25Assert.Equal(CoreStrings.ResponseStreamWasUpgraded, (await Assert.ThrowsAsync<InvalidOperationException>(() => stream.FlushAsync())).Message);

138var ex = await Assert.ThrowsAsync<ConnectionResetException>(() => acceptStreamTask.AsTask()).DefaultTimeout(); 301var ex = await Assert.ThrowsAsync<ConnectionResetException>(() => acceptTask).DefaultTimeout(); 426var ex = await Assert.ThrowsAsync<ConnectionResetException>(() => serverStream.Transport.Input.ReadAsync().AsTask()).DefaultTimeout(); 475var serverEx = await Assert.ThrowsAsync<ConnectionResetException>(() => serverStream.Transport.Input.ReadAsync().AsTask()).DefaultTimeout(); 487var clientEx = await Assert.ThrowsAsync<QuicException>(() => clientStream.ReadAsync(buffer).AsTask()).DefaultTimeout();

86var ex = await Assert.ThrowsAsync<AuthenticationException>(async () => 184await Assert.ThrowsAsync<AuthenticationException>(() => QuicConnection.ConnectAsync(options).AsTask()); 257var ex = await Assert.ThrowsAsync<AuthenticationException>(() => QuicConnection.ConnectAsync(options).AsTask()).DefaultTimeout(); 280await Assert.ThrowsAsync<AddressInUseException>(() => QuicTestHelpers.CreateConnectionListenerFactory(LoggerFactory, port: port)); 295await Assert.ThrowsAsync<AddressInUseException>(() => QuicTestHelpers.CreateConnectionListenerFactory(LoggerFactory, port: port)); 404await Assert.ThrowsAsync<AuthenticationException>(() => clientConnectionTask.AsTask()).DefaultTimeout();

276var ex = await Assert.ThrowsAsync<ConnectionResetException>(() => serverStream.Transport.Input.ReadAsync().AsTask()).DefaultTimeout(); 354var ex = await Assert.ThrowsAsync<ConnectionResetException>(() => serverStream.Transport.Input.ReadAsync().AsTask()).DefaultTimeout(); 467var ex = await Assert.ThrowsAsync<QuicException>(() => clientStream.ReadAsync(new byte[1024]).AsTask()).DefaultTimeout(); 522var clientEx = await Assert.ThrowsAsync<QuicException>(() => clientStream.WriteAsync(data).AsTask()).DefaultTimeout(); 527var serverEx = await Assert.ThrowsAsync<ConnectionAbortedException>(() => serverReadTask).DefaultTimeout();

32var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => quicTransportFactory.BindAsync(new IPEndPoint(0, 0), features: null, cancellationToken: CancellationToken.None).AsTask()).DefaultTimeout(); 49var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => quicTransportFactory.BindAsync(new IPEndPoint(0, 0), features: features, cancellationToken: CancellationToken.None).AsTask()).DefaultTimeout();

409var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => host.StartAsync()).DefaultTimeout();

704await Assert.ThrowsAsync<InvalidOperationException>(() => context.Session.LoadAsync()); 756await Assert.ThrowsAsync<OperationCanceledException>(() => context.Session.LoadAsync()); 804await Assert.ThrowsAsync<OperationCanceledException>(() => context.Session.LoadAsync(token)); 985await Assert.ThrowsAsync<OperationCanceledException>(() => context.Session.CommitAsync(token));

122await Assert.ThrowsAsync<NotImplementedException>( 139await Assert.ThrowsAsync<NotImplementedException>( 372var exception = await Assert.ThrowsAsync<AggregateException>(async () => await resultTask); 405var exception = await Assert.ThrowsAsync<AggregateException>(async () => await resultTask);

575var ex = Assert.ThrowsAsync<OperationCanceledException>(async () => 615await Assert.ThrowsAsync<TaskCanceledException>(async () => 657var ex = await Assert.ThrowsAsync<HubException>(async () => 894var ex = await Assert.ThrowsAsync<OperationCanceledException>(async () => 941await Assert.ThrowsAsync<TaskCanceledException>(async () => 991await Assert.ThrowsAsync<TaskCanceledException>(() => channel.Completion); 1054var ex = await Assert.ThrowsAsync<HubException>(() => channel.ReadAndCollectAllAsync().DefaultTimeout()); 1081var ex = await Assert.ThrowsAsync<HubException>(() => connection.InvokeAsync("!@#$%")).DefaultTimeout(); 1108var ex = await Assert.ThrowsAsync<HubException>(() => connection.InvokeAsync("!@#$%", 10, "test")).DefaultTimeout(); 1135var ex = await Assert.ThrowsAsync<HubException>(() => connection.InvokeAsync("Echo", "p1", 42)).DefaultTimeout(); 1162var ex = await Assert.ThrowsAsync<HubException>(() => connection.InvokeAsync("Echo", new[] { 42 })).DefaultTimeout(); 1190var ex = await Assert.ThrowsAsync<HubException>(() => channel.ReadAndCollectAllAsync().DefaultTimeout()); 1218var ex = await Assert.ThrowsAsync<HubException>(() => channel.ReadAndCollectAllAsync().DefaultTimeout()); 1246var ex = await Assert.ThrowsAsync<HubException>(() => channel.ReadAndCollectAllAsync().DefaultTimeout()); 1273var ex = await Assert.ThrowsAsync<HubException>(() => channel.ReadAndCollectAllAsync()).DefaultTimeout(); 1300var ex = await Assert.ThrowsAsync<HubException>(() => connection.InvokeAsync("Stream", 3)).DefaultTimeout(); 1327var ex = await Assert.ThrowsAsync<HubException>(() => channel.ReadAndCollectAllAsync()).DefaultTimeout(); 1375var hubException = await Assert.ThrowsAsync<HubException>(() => result).DefaultTimeout(); 1429var hubException = await Assert.ThrowsAsync<HubException>(() => result).DefaultTimeout(); 1463var hubException = await Assert.ThrowsAsync<HubException>(() => connection.InvokeAsync<int>("StreamEcho", new List<string> { "1", "2" }).DefaultTimeout()); 1896var ex = await Assert.ThrowsAsync<AggregateException>(() => hubConnection.StartAsync().DefaultTimeout());

408await Assert.ThrowsAsync<TaskCanceledException>(async () => 505var ex = await Assert.ThrowsAsync<HubException>(async () =>

53var ex = await Assert.ThrowsAsync<NotSupportedException>(async () => await factory.ConnectAsync(new IPEndPoint(IPAddress.Loopback, 0))); 72var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () => await factory.ConnectAsync(new UriEndPoint(url2)));

69await Assert.ThrowsAsync<ObjectDisposedException>( 157var ex = await Assert.ThrowsAsync<AggregateException>(() => connection.StartAsync()).DefaultTimeout(); 317await Assert.ThrowsAsync<HttpRequestException>(async () => await connection.Transport.Input.ReadAsync()); 346await Assert.ThrowsAsync<AggregateException>( 422await Assert.ThrowsAsync<TaskCanceledException>(() => startTask).DefaultTimeout(); 447var ex = await Assert.ThrowsAsync<AggregateException>(async () => await connection.StartAsync(cts.Token)).DefaultTimeout(); 473await Assert.ThrowsAsync<TaskCanceledException>(async () => await connection.StartAsync(new CancellationToken(canceled: true))).DefaultTimeout(); 504var ex = await Assert.ThrowsAsync<AggregateException>(async () => await connection.StartAsync()).DefaultTimeout(); 530var ex = await Assert.ThrowsAsync<AggregateException>(async () => await connection.StartAsync(cts.Token).DefaultTimeout()); 538await Assert.ThrowsAsync<ObjectDisposedException>(() => connection.StartAsync());

326var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => connection.StartAsync().DefaultTimeout()); 599var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => connection.StartAsync().DefaultTimeout()); 615var exception = await Assert.ThrowsAsync<TException>(

261var exception = await Assert.ThrowsAsync<InvalidOperationException>( 277var exception = await Assert.ThrowsAsync<ObjectDisposedException>( 338await Assert.ThrowsAsync<HttpRequestException>(async () => await connection.StartAsync().DefaultTimeout()); 447await Assert.ThrowsAsync<HttpRequestException>(async () => await connection.Transport.Input.ReadAllAsync()); 551await Assert.ThrowsAsync<HttpRequestException>(async () => await connection.Transport.Input.ReadAllAsync());

73await Assert.ThrowsAsync<InvalidOperationException>(() => secondStart).DefaultTimeout(); 199var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => method(connection)).DefaultTimeout(); 377var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => connection.SendAsync("Foo")).DefaultTimeout(); 412var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => connection.SendAsync("Foo")).DefaultTimeout(); 450var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => connection.SendAsync("Foo")).DefaultTimeout(); 480var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => targetTask).DefaultTimeout(); 543await Assert.ThrowsAsync<TaskCanceledException>(() => hubConnection.StartAsync(new CancellationToken(canceled: true))).DefaultTimeout();

40await Assert.ThrowsAsync<InvalidOperationException>(async () => await hubConnection.InvokeAsync<int>("test").DefaultTimeout()); 55await Assert.ThrowsAsync<InvalidOperationException>(async () => await hubConnection.SendAsync("test").DefaultTimeout()); 137await Assert.ThrowsAsync<TaskCanceledException>(async () => await invokeTask); 161var actualException = await Assert.ThrowsAsync<InvalidOperationException>(async () => await invokeTask); 178await Assert.ThrowsAsync<TaskCanceledException>(async () => await invokeTask); 191await Assert.ThrowsAsync<TaskCanceledException>(() => 210await Assert.ThrowsAsync<TaskCanceledException>(() => 237await Assert.ThrowsAsync<OperationCanceledException>(() => sendTask.DefaultTimeout()); 252await Assert.ThrowsAsync<TaskCanceledException>(() => 272await Assert.ThrowsAsync<TaskCanceledException>(() => result.GetAsyncEnumerator().MoveNextAsync().DefaultTimeout()); 341await Assert.ThrowsAsync<TaskCanceledException>(async () => await e.MoveNextAsync()).DefaultTimeout(); 421var exception = await Assert.ThrowsAsync<TimeoutException>(() => invokeTask); 629await Assert.ThrowsAsync<TaskCanceledException>(() => invokeTask).DefaultTimeout(); 743await Assert.ThrowsAsync<TaskCanceledException>(() => tcs.Task.DefaultTimeout()); 786await Assert.ThrowsAsync<InvalidOperationException>(() => connection.StartAsync().DefaultTimeout());

83var ex = await Assert.ThrowsAsync<InvalidDataException>(() => startTask).DefaultTimeout(); 306var ex = await Assert.ThrowsAsync<HubException>(() => invokeTask).DefaultTimeout(); 329var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => channel.ReadAndCollectAllAsync()).DefaultTimeout(); 352var ex = await Assert.ThrowsAsync<HubException>(async () => await channel.ReadAndCollectAllAsync()).DefaultTimeout(); 375var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => invokeTask).DefaultTimeout(); 488var ex = Assert.ThrowsAsync<TimeoutException>(async () => await handlerTask.DefaultTimeout(2000)); 522var ex = Assert.ThrowsAsync<TimeoutException>(async () => await handlerTask.DefaultTimeout(2000));

719Assert.Same(firstException, await Assert.ThrowsAsync<Exception>(() => startTask).DefaultTimeout());

171var exception = await Assert.ThrowsAsync<HttpRequestException>(() => longPollingTransport.StartAsync(TestUri, TransferFormat.Binary)); 207await Assert.ThrowsAsync<HttpRequestException>(async () => 309var exception = await Assert.ThrowsAsync<HttpRequestException>(async () => await longPollingTransport.Input.ReadAllAsync().DefaultTimeout()); 626var exception = await Assert.ThrowsAsync<ArgumentException>(() =>

214var exception = await Assert.ThrowsAsync<HttpRequestException>(() => sseTransport.Input.ReadAllAsync().DefaultTimeout()); 374var ex = await Assert.ThrowsAsync<ArgumentException>(() => sseTransport.StartAsync(new Uri("http://fakeuri.org"), TransferFormat.Binary).DefaultTimeout()); 400var exception = await Assert.ThrowsAsync<ArgumentException>(() =>

223var ex = await Assert.ThrowsAsync<HubException>(() => resultTask).DefaultTimeout(); 251var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => 280await Assert.ThrowsAsync<IOException>(() => manager1.InvokeConnectionAsync<int>("none", "Result", new object[] { "test" }, cancellationToken: default)).DefaultTimeout(); 337var ex = await Assert.ThrowsAsync<IOException>(() => invoke1).DefaultTimeout(); 362await Assert.ThrowsAsync<HubException>(() => invoke1).DefaultTimeout();

524var ex = await Assert.ThrowsAsync<HubException>(() => resultTask).DefaultTimeout(); 547await Assert.ThrowsAsync<IOException>(() => manager1.InvokeConnectionAsync<int>("none", "Result", new object[] { "test" }, cancellationToken: default)).DefaultTimeout(); 575var ex = await Assert.ThrowsAsync<HubException>(() => invoke1).DefaultTimeout(); 626var ex = await Assert.ThrowsAsync<IOException>(() => manager1.InvokeConnectionAsync<int>("1234", "Result", new object[] { "test" }, cancellationToken: default)).DefaultTimeout(); 656var ex = await Assert.ThrowsAsync<HubException>(() => resultTask).DefaultTimeout();

116var ex = await Assert.ThrowsAsync<ApplicationException>(() => manager.OnConnectedAsync(connection)).DefaultTimeout();

216var ex = await Assert.ThrowsAsync<NotImplementedException>(async () => await proxy.InvokeAsync<int>("method", cancellationToken: default)).DefaultTimeout();

240var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => connection.StartAsync().DefaultTimeout()); 389var exception = await Assert.ThrowsAsync<HttpRequestException>(() => connection.StartAsync().DefaultTimeout()); 420await Assert.ThrowsAsync<WebSocketException>(() => connection.StartAsync().DefaultTimeout());

122var ex = await Assert.ThrowsAsync<IOException>(() => connectionHandlerTask).DefaultTimeout(); 384var ex = await Assert.ThrowsAsync<HubException>(() => resultTask).DefaultTimeout(); 429var ex = await Assert.ThrowsAsync<HubException>(() => resultTask).DefaultTimeout();

709await Assert.ThrowsAsync<InvalidOperationException>( 784var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await connectionHandlerTask); 2499await Assert.ThrowsAsync<InvalidOperationException>(async () => await await client.ConnectAsync(connectionHandler, expectedHandshakeResponseMessage: false)).DefaultTimeout(); 2523await Assert.ThrowsAsync<InvalidOperationException>(async () => await await client.ConnectAsync(connectionHandler, expectedHandshakeResponseMessage: false)).DefaultTimeout(); 3609var ex = await Assert.ThrowsAsync<TimeoutException>(async () => 4585var exception = await Assert.ThrowsAsync<OperationCanceledException>(() => task).DefaultTimeout();

238var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => typedProxy.GetValue(102, objArg, "test")).DefaultTimeout();

148var e = await Assert.ThrowsAsync<InvalidOperationException>(() => InProcessTestServer<Startup<ChannelValueTypeMethodHub>>.StartServer(NullLoggerFactory.Instance)); 154var e = await Assert.ThrowsAsync<InvalidOperationException>(() => InProcessTestServer<Startup<EnumerableValueTypeMethodHub>>.StartServer(NullLoggerFactory.Instance));

219var exception = await Assert.ThrowsAsync<ArgumentException>(() =>

458await Assert.ThrowsAsync<OperationCanceledException>(() => readTask.DefaultTimeout()); 481await Assert.ThrowsAsync<OperationCanceledException>(() => readTask.DefaultTimeout()); 504await Assert.ThrowsAsync<ObjectDisposedException>(() => responseTask); 516return Assert.ThrowsAsync<InvalidOperationException>(() => httpClient.GetAsync("https://example.com/", 536var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsStringAsync()); 552return Assert.ThrowsAsync<InvalidOperationException>(() => httpClient.GetAsync("https://example.com/", 568return Assert.ThrowsAsync<InvalidOperationException>(() => httpClient.GetAsync("https://example.com/", 593return Assert.ThrowsAsync<InvalidOperationException>(() => httpClient.GetAsync("https://example.com/",

212await Assert.ThrowsAsync<OperationCanceledException>(() => readTask.DefaultTimeout()); 236await Assert.ThrowsAsync<OperationCanceledException>(() => contextTask.DefaultTimeout()); 262await Assert.ThrowsAsync<OperationCanceledException>(() => readTask.DefaultTimeout()); 277return Assert.ThrowsAsync<InvalidOperationException>(() => server.SendAsync(c => { })); 343var ex = await Assert.ThrowsAsync<OperationCanceledException>(() => server.SendAsync(c => { }));

28var ex = await Assert.ThrowsAsync<OperationCanceledException>(() => client.GetAsync("/", HttpCompletionOption.ResponseHeadersRead)); 44var ex = await Assert.ThrowsAsync<OperationCanceledException>(() => client.GetAsync("/", HttpCompletionOption.ResponseHeadersRead)); 66var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsByteArrayAsync()); 89var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsByteArrayAsync());

61var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => client.GetAsync("/")); 97var requestException = await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync("/"));

81var rex = await Assert.ThrowsAsync<HttpResetTestException>(() => client.GetAsync("/")); 100var rex = await Assert.ThrowsAsync<HttpResetTestException>(() => client.GetAsync("/", HttpCompletionOption.ResponseHeadersRead)); 125var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsByteArrayAsync()); 151var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsByteArrayAsync());

256var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => client.SendAsync(message, CancellationToken.None)); 441var ex = await Assert.ThrowsAsync<IOException>(async () => 776await Assert.ThrowsAsync<IOException>(async () => await clientSocket.ReceiveAsync(new System.ArraySegment<byte>(buffer), CancellationToken.None)); 1031await Assert.ThrowsAsync<NotSupportedException>(() => upgradeFeature.UpgradeAsync());

675await Assert.ThrowsAsync<ObjectDisposedException>(() => server.CreateClient().GetAsync("/")); 693await Assert.ThrowsAsync<TaskCanceledException>(async () => { string result = await server.CreateClient().GetStringAsync("/path"); }); 765await Assert.ThrowsAsync<Exception>(() => server.CreateClient().GetAsync("/path"));

105await Assert.ThrowsAsync<NotSupportedException>(() => upgradeFeature.UpgradeAsync());

355await Assert.ThrowsAsync<InvalidOperationException>(() => app.RunAsync("http://localhost:5001")); 366await Assert.ThrowsAsync<InvalidOperationException>(() => app.RunAsync("http://localhost:5001")); 2058var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => client.GetAsync("/")); 2089var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => client.GetAsync("/"));

362var exception = await Assert.ThrowsAsync<IOException>(() => stream.ReadAsync(bytes, 0, bytes.Length)); 394var exception = await Assert.ThrowsAsync<IOException>(() => stream.ReadAsync(bytes, 0, bytes.Length));

299var exception = await Assert.ThrowsAsync<IOException>(() => bufferingStream.WriteAsync(input, 0, input.Length)); 314var exception = await Assert.ThrowsAsync<IOException>(() => bufferingStream.WriteAsync(input, 0, input.Length));

82var exception = await Assert.ThrowsAsync<InvalidDataException>( 108var exception = await Assert.ThrowsAsync<InvalidDataException>( 123var exception = await Assert.ThrowsAsync<InvalidDataException>( 151var exception = await Assert.ThrowsAsync<InvalidDataException>( 179var exception = await Assert.ThrowsAsync<InvalidDataException>( 199var readTask = Assert.ThrowsAsync<InvalidDataException>(

83var exception = await Assert.ThrowsAsync<InvalidDataException>( 95var exception = await Assert.ThrowsAsync<InvalidDataException>( 122var exception = await Assert.ThrowsAsync<InvalidDataException>( 149var exception = await Assert.ThrowsAsync<InvalidDataException>(

394await Assert.ThrowsAsync<ObjectDisposedException>(() => action(httpRequestStreamReader));

192await Assert.ThrowsAsync<IOException>(() => writer.FlushAsync()); 388await Assert.ThrowsAsync<TaskCanceledException>(async () => await writer.WriteAsync(memory, cancellationToken)); 446await Assert.ThrowsAsync<TaskCanceledException>(async () => await writer.WriteLineAsync(memory, cancellationToken)); 782await Assert.ThrowsAsync<ObjectDisposedException>(() =>

132var exception = await Assert.ThrowsAsync<InvalidDataException>(() => reader.ReadNextSectionAsync()); 145var exception = await Assert.ThrowsAsync<InvalidDataException>(() => reader.ReadNextSectionAsync()); 160var exception = await Assert.ThrowsAsync<InvalidDataException>(() => reader.ReadNextSectionAsync()); 378await Assert.ThrowsAsync<IOException>(async () =>

4259await Assert.ThrowsAsync<Xunit.Sdk.TrueException>(() => VerifyItemExistsAsync(code, "XAttribute"));

878await Assert.ThrowsAsync<OperationCanceledException>(() => compilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(tree, analyzer.CancellationToken));

283await Assert.ThrowsAsync<TaskCanceledException>(

2116await Assert.ThrowsAsync<OperationCanceledException>(() =>

1116=> Assert.ThrowsAsync<AggregateException>(async () =>

1227=> Assert.ThrowsAsync<AggregateException>(async () =>

1809await Assert.ThrowsAsync<ArgumentException>(async () =>

4902await Assert.ThrowsAsync<ObjectDisposedException>(async () => await debuggingSession.EmitSolutionUpdateAsync(solution, runningProjects: ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty, s_noActiveSpans, CancellationToken.None));

446var firstDocumentResult2 = Assert.ThrowsAsync<StreamJsonRpc.RemoteInvocationException>(async () => await testLspServer.ExecuteRequestAsync<LSP.CodeLens, LSP.CodeLens>(LSP.Methods.CodeLensResolveName, firstCodeLens, CancellationToken.None));

114=> Assert.ThrowsAsync<InvalidOperationException>(async () => await CreateTestLspServerAsync("", mutatingLspWorkspace, 123await Assert.ThrowsAsync<StreamJsonRpc.RemoteInvocationException>(async () => await server.ExecuteRequestAsync<TestRequestTypeThree, string>(TestNonMutatingDocumentHandler.MethodName, request, CancellationToken.None));

117var ex = await Assert.ThrowsAsync<RemoteInvocationException>(async () => await server.ExecuteRequestAsync<DidOpenTextDocumentParams, object>(Methods.TextDocumentDidOpenName, didOpenParams, CancellationToken.None));

120await Assert.ThrowsAsync<StreamJsonRpc.RemoteInvocationException>(() => waitables[0]); 175await Assert.ThrowsAsync<StreamJsonRpc.RemoteInvocationException>(() => waitables[0]);

170await Assert.ThrowsAsync<TaskCanceledException>(() => task); 182await Assert.ThrowsAsync<TaskCanceledException>(() => task);

207var exception = await Assert.ThrowsAsync<InvalidOperationException>(testCode);

199var exception = await Assert.ThrowsAsync<RemoteInvocationException>(() => rpcPair.Client.InvokeAsync(targetObject: 0, nameof(ObjectWithThrowingMethod.ThrowException), [], CancellationToken.None));

863var e = await Assert.ThrowsAsync<InvalidOperationException>(async delegate 878var e = await Assert.ThrowsAsync<InvalidOperationException>(async delegate 935await Assert.ThrowsAsync<FileNotFoundException>(() => workspace.OpenSolutionAsync(solutionFilePath)); 1071await Assert.ThrowsAsync<FileNotFoundException>(() => workspace.OpenSolutionAsync(solutionFilePath)); 1129var e = await Assert.ThrowsAsync<InvalidOperationException>(async () => 1151var e = await Assert.ThrowsAsync<InvalidOperationException>(async () => 1190var e = await Assert.ThrowsAsync<InvalidOperationException>(() => workspace.OpenProjectAsync(projectName)); 1213await Assert.ThrowsAsync<FileNotFoundException>(async () => 1273await Assert.ThrowsAsync<FileNotFoundException>(async () => 1307await Assert.ThrowsAsync<InvalidOperationException>(async () => 2614await Assert.ThrowsAsync<FileNotFoundException>(async () => 2628await Assert.ThrowsAsync<FileNotFoundException>(async () => 3277var exception = await Assert.ThrowsAsync<Exception>(() => workspace.OpenSolutionAsync(solutionFilePath));

110await Assert.ThrowsAsync<NotImplementedException>(() => loader.LoadTextAndVersionAsync(new LoadTextOptions(SourceHashAlgorithms.Default), CancellationToken.None)); 111await Assert.ThrowsAsync<NotImplementedException>(() => loader.LoadTextAndVersionAsync(workspace: null, documentId: null, CancellationToken.None));

295? await Assert.ThrowsAsync<ArgumentException>(async () => await lazy.GetValueAsync(CancellationToken.None))

58await Assert.ThrowsAsync<TaskCanceledException>(async () => await whenAll); 172var exception = await Assert.ThrowsAsync<TaskCanceledException>(async () => await task); 229var exception = await Assert.ThrowsAsync<TaskCanceledException>(async () => await task); 289var exception = await Assert.ThrowsAsync<TaskCanceledException>(async () => await task); 356var exception = await Assert.ThrowsAsync<TaskCanceledException>(async () => await task); 431var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => task.AsTask()); 514var exception = await Assert.ThrowsAsync<TaskCanceledException>(() => task.AsTask()); 554var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => task.AsTask());

56await Assert.ThrowsAsync<NotImplementedException>(() => requestExecutionQueue.ExecuteAsync(JToken.FromObject(new MockRequest(1)), ThrowingHandler.Name, lspServices, CancellationToken.None));

691 await Assert.ThrowsAsync<ArgumentNullException>("testCode", () => Assert.ThrowsAsync<ArgumentException>(default(Func<Task>)!)); 699 var ex = await Record.ExceptionAsync(() => Assert.ThrowsAsync<ArgumentException>(testCode)); 715 await Assert.ThrowsAsync<ArgumentException>(testCode); 724 var ex = await Record.ExceptionAsync(() => Assert.ThrowsAsync<ArgumentException>(testCode)); 742 var ex = await Record.ExceptionAsync(() => Assert.ThrowsAsync<ArgumentException>(testCode));

29var ex1 = await Assert.ThrowsAsync<ArgumentNullException>(() => SpeechToTextClientExtensions.GetTextAsync(client!, content)); 34var ex2 = await Assert.ThrowsAsync<ArgumentNullException>(() => SpeechToTextClientExtensions.GetTextAsync(testClient, nullContent!)); 43var ex1 = await Assert.ThrowsAsync<ArgumentNullException>(() => SpeechToTextClientExtensions.GetStreamingTextAsync(client!, content).GetAsyncEnumerator().MoveNextAsync().AsTask()); 48var ex2 = await Assert.ThrowsAsync<ArgumentNullException>(() => SpeechToTextClientExtensions.GetStreamingTextAsync(testClient, nullContent!).GetAsyncEnumerator().MoveNextAsync().AsTask());

42await Assert.ThrowsAsync<InvalidOperationException>(() => chatClient.GetResponseAsync("hello")); 43await Assert.ThrowsAsync<InvalidOperationException>(() => chatClient.GetStreamingResponseAsync("hello").GetAsyncEnumerator().MoveNextAsync().AsTask()); 45await Assert.ThrowsAsync<InvalidOperationException>(() => chatClient.GetResponseAsync("hello", new ChatOptions { ModelId = null })); 46await Assert.ThrowsAsync<InvalidOperationException>(() => chatClient.GetStreamingResponseAsync("hello", new ChatOptions { ModelId = null }).GetAsyncEnumerator().MoveNextAsync().AsTask());

99ex = await Assert.ThrowsAsync<InvalidOperationException>(() => chatClient.GetResponseAsync("Hello, world!")); 102ex = await Assert.ThrowsAsync<InvalidOperationException>(() => chatClient.GetStreamingResponseAsync("Hello, world!").ToChatResponseAsync());

29ex = await Assert.ThrowsAsync<InvalidOperationException>(() => generator.GenerateAsync(["Hello, world!"]));

111await Assert.ThrowsAsync<TaskCanceledException>(() 125await Assert.ThrowsAsync<TaskCanceledException>(()

185var ex1 = await Assert.ThrowsAsync<InvalidTimeZoneException>(() => outer.GetResponseAsync([input])); 190var ex2 = await Assert.ThrowsAsync<InvalidTimeZoneException>(() => outer.GetResponseAsync([input])); 228await Assert.ThrowsAsync<TaskCanceledException>(() => result1); 496var ex1 = await Assert.ThrowsAsync<InvalidTimeZoneException>(() => ToListAsync(result1)); 502var ex2 = await Assert.ThrowsAsync<InvalidTimeZoneException>(() => ToListAsync(result2)); 537await Assert.ThrowsAsync<TaskCanceledException>(() => result1Assertion);

380var ex = await Assert.ThrowsAsync<AggregateException>(() => 386ex = await Assert.ThrowsAsync<AggregateException>(() => 396var ex = await Assert.ThrowsAsync<InvalidTimeZoneException>(() => 400ex = await Assert.ThrowsAsync<InvalidTimeZoneException>(() => 438var ex = await Assert.ThrowsAsync<InvalidTimeZoneException>(() => 442ex = await Assert.ThrowsAsync<InvalidTimeZoneException>(() =>

190var ex1 = await Assert.ThrowsAsync<InvalidTimeZoneException>(() => outer.GenerateAsync("abc")); 195var ex2 = await Assert.ThrowsAsync<InvalidTimeZoneException>(() => outer.GenerateAsync("abc"));

74Exception e = await Assert.ThrowsAsync<ArgumentException>(() => f.InvokeAsync().AsTask()); 200await Assert.ThrowsAsync<NotImplementedException>(() => func.InvokeAsync().AsTask()); 426await Assert.ThrowsAsync<InvalidOperationException>(async () => await func.InvokeAsync()); 437await Assert.ThrowsAsync<TargetException>(async () => await func.InvokeAsync()); 606Exception e = await Assert.ThrowsAsync<ArgumentException>(() => f.InvokeAsync(new() { ["myInteger"] = 1 }).AsTask()); 609e = await Assert.ThrowsAsync<ArgumentException>(() => f.InvokeAsync(new()

176await Assert.ThrowsAsync<KnownFailureException>(async () => await cache.GetOrCreateAsync("key", func)); 242await Assert.ThrowsAsync<KnownFailureException>(async () => await cache.GetOrCreateAsync("key", func));

81var exception = await Assert.ThrowsAsync<InvalidOperationException>(() =>

22var ex = await Assert.ThrowsAsync<ArgumentOutOfRangeException>(test);

270await Assert.ThrowsAsync<TaskCanceledException>(async () => await task);

792await Assert.ThrowsAsync<TaskCanceledException>(() => Task.Delay(TimeSpan.FromSeconds(10), cancellationToken));

245await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () => await collector.WaitForMeasurementsAsync(-1)); 246await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () => await collector.WaitForMeasurementsAsync(0)); 309await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () => await collector.WaitForMeasurementsAsync(-1)); 310await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () => await collector.WaitForMeasurementsAsync(0)); 366await Assert.ThrowsAsync<ObjectDisposedException>(async () => await collector.WaitForMeasurementsAsync(1)); 367await Assert.ThrowsAsync<ObjectDisposedException>(async () => await collector.WaitForMeasurementsAsync(1, TimeSpan.FromSeconds(1)));

75await Assert.ThrowsAsync<ArgumentNullException>(act); 110var actualException = await Assert.ThrowsAsync<HttpRequestException>(act); 437await Assert.ThrowsAsync<TaskCanceledException>(act); 554await Assert.ThrowsAsync<InvalidOperationException>(act); 820await Assert.ThrowsAsync<TaskCanceledException>(act);

108await Assert.ThrowsAsync<OverflowException>(() => client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/throw"))); 146await Assert.ThrowsAsync<OverflowException>(() => client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/throw"))); 231await Assert.ThrowsAsync<OverflowException>(() => client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/throw")));

214var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => 342var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => 368var exception = await Assert.ThrowsAsync<OperationCanceledException>(async () =>

151var exception = await Assert.ThrowsAsync<InvalidOperationException>( 173var exception = await Assert.ThrowsAsync<HttpRequestException>(

159await Assert.ThrowsAsync<InvalidOperationException>(() => InvokeHandler(invoker, request, asynchronous));

324await Assert.ThrowsAsync<TaskCanceledException>(async () => await delay); 351await Assert.ThrowsAsync<TaskCanceledException>(() => timeProvider.Delay(TimeSpan.FromTicks(1), cts.Token)); 362await Assert.ThrowsAsync<TimeoutException>(() => source.Task.WaitAsync(TimeSpan.FromTicks(-1), timeProvider, CancellationToken.None)); 366await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => source.Task.WaitAsync(TimeSpan.FromMilliseconds(-2), timeProvider, CancellationToken.None)); 437await Assert.ThrowsAsync<TaskCanceledException>(() => t);

81var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () => await endpoint.RequestDelegate(httpContext));

371var exception = await Assert.ThrowsAsync<InvalidOperationException>(

594await Assert.ThrowsAsync<OperationCanceledException>(async () =>

553await Assert.ThrowsAsync<OperationCanceledException>(async () =>

297var ex = await Assert.ThrowsAsync<JSException>(async () => await task); 313var ex = await Assert.ThrowsAsync<JSException>(async () => await task);

51await Assert.ThrowsAsync<ObjectDisposedException>(async () => await jsObject.InvokeAsync<object>("test", "arg1", "arg2")); 52await Assert.ThrowsAsync<ObjectDisposedException>(async () => await jsObject.InvokeAsync<object>("test", CancellationToken.None, "arg1", "arg2"));

50await Assert.ThrowsAsync<TaskCanceledException>(async () => await task); 82await Assert.ThrowsAsync<TaskCanceledException>(async () => await task); 99await Assert.ThrowsAsync<TaskCanceledException>(async () => await task); 231var jsException = await Assert.ThrowsAsync<JSException>(async () => await task); 421var exception = await Assert.ThrowsAsync<NotSupportedException>(async () => await runtime.ReadJSDataAsStreamAsync(dataReference, 10, CancellationToken.None));

111await Assert.ThrowsAsync<InvalidProjectDataException>(() => CSharpHelpers.CreateCSharpCPSProjectAsync(environment, "Test2", binOutputPath: "")); 112await Assert.ThrowsAsync<InvalidProjectDataException>(() => CSharpHelpers.CreateCSharpCPSProjectAsync(environment, "Test3", binOutputPath: "Test.dll"));

21await Assert.ThrowsAsync<NotImplementedException>(async () => await socketTransportFactory.BindAsync(new UriEndPoint(new Uri("http://127.0.0.1:5554"))));

984await Assert.ThrowsAsync<TaskCanceledException>(async () => await readTcs.Task);

45await Assert.ThrowsAsync<InvalidOperationException>(() => _host.GetNextClientConnectionAsync()); 66await Assert.ThrowsAsync<TaskCanceledException>(async () => await task);

291 var ex = await ThrowsAsync<T>(testCode);